semanticseg

Семантическая сегментация изображений с помощью глубокого обучения

Описание

пример

C = semanticseg(I,network) возвращает семантическую сегментацию входного изображения с помощью глубокого обучения.

[C,score,allScores] = semanticseg(I,network) также возвращает классификационные оценки для каждой категориальной метки в C. Функция возвращает оценки в массиве, который соответствует каждому пикселю или вокселю во входном изображении.

[___] = semanticseg(I,network,roi) возвращает семантическую сегментацию для прямоугольной подобласти входного изображения.

pxds = semanticseg(ds,network) возвращает семантическую сегментацию для набора изображений в ds, объект datastore.

Функция поддерживает параллельные вычисления с помощью нескольких рабочих MATLAB®. Можно включить параллельные вычисления с помощью диалогового окна Настроек Computer Vision Toolbox.

[___] = semanticseg(___,Name,Value) возвращает семантическую сегментацию с дополнительными опциями, заданными одним или несколькими аргументами пары "имя-значение".

Примеры

свернуть все

Наложите результаты сегментации на изображении и отобразите результаты.

Загрузите предварительно обученную сеть.

data = load('triangleSegmentationNetwork');
net = data.net
net = 
  SeriesNetwork with properties:

         Layers: [10x1 nnet.cnn.layer.Layer]
     InputNames: {'imageinput'}
    OutputNames: {'classoutput'}

Перечислите слоя сети.

net.Layers
ans = 
  10x1 Layer array with layers:

     1   'imageinput'        Image Input                  32x32x1 images with 'zerocenter' normalization
     2   'conv_1'            Convolution                  64 3x3x1 convolutions with stride [1  1] and padding [1  1  1  1]
     3   'relu_1'            ReLU                         ReLU
     4   'maxpool'           Max Pooling                  2x2 max pooling with stride [2  2] and padding [0  0  0  0]
     5   'conv_2'            Convolution                  64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]
     6   'relu_2'            ReLU                         ReLU
     7   'transposed-conv'   Transposed Convolution       64 4x4x64 transposed convolutions with stride [2  2] and cropping [1  1  1  1]
     8   'conv_3'            Convolution                  2 1x1x64 convolutions with stride [1  1] and padding [0  0  0  0]
     9   'softmax'           Softmax                      softmax
    10   'classoutput'       Pixel Classification Layer   Class weighted cross-entropy loss with classes 'triangle' and 'background'

Считывание и отображение тестового изображения.

I = imread('triangleTest.jpg');
figure
imshow(I)

Figure contains an axes. The axes contains an object of type image.

Выполните семантическую сегментацию изображений.

[C,scores] = semanticseg(I,net,'MiniBatchSize',32);

Наложите результаты сегментации на изображении и отобразите результаты.

B = labeloverlay(I, C);
figure
imshow(B)

Figure contains an axes. The axes contains an object of type image.

Отобразите классификационные оценки.

figure
imagesc(scores)
axis square
colorbar

Figure contains an axes. The axes contains an object of type image.

Создайте бинарную маску только с треугольниками.

BW = C == 'triangle';
figure
imshow(BW)

Figure contains an axes. The axes contains an object of type image.

Запустите семантическую сегментацию на наборе тестов изображений и сравните результаты с достоверными данными.

Загрузите предварительно обученную сеть.

data = load('triangleSegmentationNetwork');
net = data.net;

Загрузка тестовых изображений с помощью imageDatastore.

dataDir = fullfile(toolboxdir('vision'),'visiondata','triangleImages');
testImageDir = fullfile(dataDir,'testImages');
imds = imageDatastore(testImageDir)
imds = 
  ImageDatastore with properties:

                       Files: {
                              ' .../toolbox/vision/visiondata/triangleImages/testImages/image_001.jpg';
                              ' .../toolbox/vision/visiondata/triangleImages/testImages/image_002.jpg';
                              ' .../toolbox/vision/visiondata/triangleImages/testImages/image_003.jpg'
                               ... and 97 more
                              }
                     Folders: {
                              ' .../build/matlab/toolbox/vision/visiondata/triangleImages/testImages'
                              }
    AlternateFileSystemRoots: {}
                    ReadSize: 1
                      Labels: {}
      SupportedOutputFormats: ["png"    "jpg"    "jpeg"    "tif"    "tiff"]
         DefaultOutputFormat: "png"
                     ReadFcn: @readDatastoreImage

Загрузите тестовые метки основной истины.

testLabelDir = fullfile(dataDir,'testLabels');
classNames = ["triangle" "background"];
pixelLabelID = [255 0];
pxdsTruth = pixelLabelDatastore(testLabelDir,classNames,pixelLabelID);

Запустите семантическую сегментацию на всех тестовых изображениях с пакетным размером 4. Можно увеличить пакетный размер, чтобы увеличить пропускную способность на основе системных ресурсов памяти.

pxdsResults = semanticseg(imds,net,'MiniBatchSize',4,'WriteLocation',tempdir);
Running semantic segmentation network
-------------------------------------
* Processed 100 images.

Сравните результаты с основной истиной.

metrics = evaluateSemanticSegmentation(pxdsResults,pxdsTruth)
Evaluating semantic segmentation results
----------------------------------------
* Selected metrics: global accuracy, class accuracy, IoU, weighted IoU, BF score.
* Processed 100 images.
* Finalizing... Done.
* Data set metrics:

    GlobalAccuracy    MeanAccuracy    MeanIoU    WeightedIoU    MeanBFScore
    ______________    ____________    _______    ___________    ___________

       0.90624          0.95085       0.61588      0.87529        0.40652  
metrics = 
  semanticSegmentationMetrics with properties:

              ConfusionMatrix: [2x2 table]
    NormalizedConfusionMatrix: [2x2 table]
               DataSetMetrics: [1x5 table]
                 ClassMetrics: [2x3 table]
                 ImageMetrics: [100x5 table]

В этом примере показано, как задать и создать пользовательский слой классификации пикселей, который использует потерю Tversky.

Этот слой может использоваться, чтобы обучить сети семантической сегментации. Чтобы узнать больше о создании пользовательских слоев глубокого обучения, смотрите, Задают Пользовательские Слои Глубокого обучения (Deep Learning Toolbox).

Потеря Tversky

Потеря Tversky основана на индексе Tversky для измерения перекрытия между двумя сегментированными изображениями [1]. Индекс Tversky TIc между одним изображением Y и соответствующая основная истина T дают

TIc=m=1MYcmTcmm=1MYcmTcm+αm=1MYcmTcm+βm=1MYcmTcm

  • c соответствует классу и cсоответствует тому, чтобы не быть в классе c.

  • M число элементов по первым двум измерениям Y.

  • α и β взвешивают факторы, которые управляют вкладом, который ложные положительные стороны и ложные отрицательные стороны для каждого класса делают к потере.

Потеря Lпо количеству классов C дают

L=c=1C1-TIc

Шаблон слоя классификации

Скопируйте шаблон слоя классификации в новый файл в MATLAB®. Этот шаблон обрисовывает в общих чертах структуру слоя классификации и включает функции, которые задают поведение слоя. Остальная часть примера показывает, как завершить tverskyPixelClassificationLayer.

classdef tverskyPixelClassificationLayer < nnet.layer.ClassificationLayer

   properties
      % Optional properties
   end

   methods

        function loss = forwardLoss(layer, Y, T)
            % Layer forward loss function goes here
        end
        
    end
end

Объявите свойства слоя

По умолчанию пользовательские выходные слои имеют следующие свойства:

  • Name – Имя слоя в виде вектора символов или строкового скаляра. Чтобы включать этот слой в график слоев, необходимо задать непустое уникальное имя слоя. Если вы обучаете серийную сеть с этим слоем и Name установлен в '', затем программное обеспечение автоматически присваивает имя в учебное время.

  • Description – Однострочное описание слоя в виде вектора символов или строкового скаляра. Это описание появляется, когда слой отображен в Layer массив. Если вы не задаете описание слоя, то программное обеспечение отображает имя класса слоя.

  • Type – Тип слоя в виде вектора символов или строкового скаляра. Значение Type появляется, когда слой отображен в Layer массив. Если вы не задаете тип слоя, то программное обеспечение отображает 'Classification layer' или 'Regression layer'.

Пользовательские слои классификации также имеют следующее свойство:

  • Classes – Классы выходного слоя в виде категориального вектора, массива строк, массива ячеек из символьных векторов или 'auto'. Если Classes 'auto', затем программное обеспечение автоматически устанавливает классы в учебное время. Если вы задаете массив строк или массив ячеек из символьных векторов str, затем программное обеспечение устанавливает классы выходного слоя к categorical(str,str). Значением по умолчанию является 'auto'.

Если слой не имеет никаких других свойств, то можно не использовать properties раздел.

Потеря Tversky требует, чтобы маленькое постоянное значение предотвратило деление на нуль. Задайте свойство, Epsilon, содержать это значение. Также требуется два переменных свойства Alpha и Beta то управление взвешивание ложных положительных сторон и ложных отрицательных сторон, соответственно.

classdef tverskyPixelClassificationLayer < nnet.layer.ClassificationLayer

    properties(Constant)
       % Small constant to prevent division by zero. 
       Epsilon = 1e-8;
    end

    properties
       % Default weighting coefficients for false positives and false negatives 
       Alpha = 0.5;
       Beta = 0.5;  
    end

    ...
end

Создайте функцию конструктора

Создайте функцию, которая создает слой и инициализирует свойства слоя. Задайте любые переменные, требуемые создать слой как входные параметры к функции конструктора.

Задайте дополнительное имя входного параметра, чтобы присвоить Name свойство при создании.

function layer = tverskyPixelClassificationLayer(name, alpha, beta)
    % layer =  tverskyPixelClassificationLayer(name) creates a Tversky
    % pixel classification layer with the specified name.
           
    % Set layer name          
    layer.Name = name;

    % Set layer properties
    layer.Alpha = alpha;
    layer.Beta = beta;

    % Set layer description
    layer.Description = 'Tversky loss';
end

Создайте прямую функцию потерь

Создайте функцию с именем forwardLoss это возвращает взвешенную потерю перекрестной энтропии между предсказаниями, сделанными сетью и учебными целями. Синтаксис для forwardLoss loss = forwardLoss(layer,Y,T), где Y выход предыдущего слоя и T представляет учебные цели.

Для проблем семантической сегментации, размерностей T совпадайте с размерностью Y, где Y 4-D массив размера H- W- K- N, где K количество классов и N мини-пакетный размер.

Размер Y зависит от выхода предыдущего слоя. Гарантировать тот Y одного размера с T, необходимо включать слой, который выводит правильный размер перед выходным слоем. Например, чтобы гарантировать тот Y 4-D массив музыки предсказания к K классы, можно включать полносвязный слой размера K или сверточный слой с K фильтры сопровождаются softmax слоем перед выходным слоем.

function loss = forwardLoss(layer, Y, T)
    % loss = forwardLoss(layer, Y, T) returns the Tversky loss between
    % the predictions Y and the training targets T.

    Pcnot = 1-Y;
    Gcnot = 1-T;
    TP = sum(sum(Y.*T,1),2);
    FP = sum(sum(Y.*Gcnot,1),2);
    FN = sum(sum(Pcnot.*T,1),2);

    numer = TP + layer.Epsilon;
    denom = TP + layer.Alpha*FP + layer.Beta*FN + layer.Epsilon;
    
    % Compute Tversky index
    lossTIc = 1 - numer./denom;
    lossTI = sum(lossTIc,3);
    
    % Return average Tversky index loss
    N = size(Y,4);
    loss = sum(lossTI)/N;

end

Обратная функция потерь

Как forwardLoss функционируйте полностью поддерживает автоматическое дифференцирование, нет никакой потребности создать функцию за обратную потерю.

Для списка функций, которые поддерживают автоматическое дифференцирование, см. Список Функций с Поддержкой dlarray (Deep Learning Toolbox).

Завершенный слой

Завершенный слой обеспечивается в tverskyPixelClassificationLayer.m.

classdef tverskyPixelClassificationLayer < nnet.layer.ClassificationLayer
    % This layer implements the Tversky loss function for training
    % semantic segmentation networks.
    
    % References
    % Salehi, Seyed Sadegh Mohseni, Deniz Erdogmus, and Ali Gholipour.
    % "Tversky loss function for image segmentation using 3D fully
    % convolutional deep networks." International Workshop on Machine
    % Learning in Medical Imaging. Springer, Cham, 2017.
    % ----------
    
    
    properties(Constant)
        % Small constant to prevent division by zero.
        Epsilon = 1e-8;
    end
    
    properties
        % Default weighting coefficients for False Positives and False
        % Negatives
        Alpha = 0.5;
        Beta = 0.5;
    end

    
    methods
        
        function layer = tverskyPixelClassificationLayer(name, alpha, beta)
            % layer =  tverskyPixelClassificationLayer(name, alpha, beta) creates a Tversky
            % pixel classification layer with the specified name and properties alpha and beta.
            
            % Set layer name.          
            layer.Name = name;
            
            layer.Alpha = alpha;
            layer.Beta = beta;
            
            % Set layer description.
            layer.Description = 'Tversky loss';
        end
        
        
        function loss = forwardLoss(layer, Y, T)
            % loss = forwardLoss(layer, Y, T) returns the Tversky loss between
            % the predictions Y and the training targets T.   

            Pcnot = 1-Y;
            Gcnot = 1-T;
            TP = sum(sum(Y.*T,1),2);
            FP = sum(sum(Y.*Gcnot,1),2);
            FN = sum(sum(Pcnot.*T,1),2); 
            
            numer = TP + layer.Epsilon;
            denom = TP + layer.Alpha*FP + layer.Beta*FN + layer.Epsilon;
            
            % Compute tversky index
            lossTIc = 1 - numer./denom;
            lossTI = sum(lossTIc,3);
            
            % Return average tversky index loss.
            N = size(Y,4);
            loss = sum(lossTI)/N;
            
        end     
    end
end

Совместимость с GPU

Функции MATLAB используются в forwardLoss в tverskyPixelClassificationLayer вся поддержка gpuArray входные параметры, таким образом, слоем является совместимый графический процессор.

Проверяйте Выходную валидность слоя

Создайте экземпляр слоя.

layer = tverskyPixelClassificationLayer('tversky',0.7,0.3);

Проверяйте валидность слоя при помощи checkLayer (Deep Learning Toolbox). Задайте допустимый входной размер, чтобы быть размером одного наблюдения за типичным входом к слою. Слой ожидает H- W- K- N входные параметры массивов, где K количество классов и N количество наблюдений в мини-пакете.

numClasses = 2;
validInputSize = [4 4 numClasses];
checkLayer(layer,validInputSize, 'ObservationDimension',4)
Skipping GPU tests. No compatible GPU device found.
 
Skipping code generation compatibility tests. To check validity of the layer for code generation, specify the 'CheckCodegenCompatibility' and 'ObservationDimension' options.
 
Running nnet.checklayer.TestOutputLayerWithoutBackward
........
Done nnet.checklayer.TestOutputLayerWithoutBackward
__________

Test Summary:
	 8 Passed, 0 Failed, 0 Incomplete, 2 Skipped.
	 Time elapsed: 1.083 seconds.

В сводке тестов указывается количество пройденных, неудачных, неполных и пропущенных тестов.

Используйте пользовательский слой в сети Семантической Сегментации

Создайте сеть семантической сегментации, которая использует tverskyPixelClassificationLayer.

layers = [
    imageInputLayer([32 32 1])
    convolution2dLayer(3,64,'Padding',1)
    batchNormalizationLayer
    reluLayer
    maxPooling2dLayer(2,'Stride',2)
    convolution2dLayer(3,64,'Padding',1)
    reluLayer
    transposedConv2dLayer(4,64,'Stride',2,'Cropping',1)
    convolution2dLayer(1,2)
    softmaxLayer
    tverskyPixelClassificationLayer('tversky',0.3,0.7)]
layers = 
  11x1 Layer array with layers:

     1   ''          Image Input              32x32x1 images with 'zerocenter' normalization
     2   ''          Convolution              64 3x3 convolutions with stride [1  1] and padding [1  1  1  1]
     3   ''          Batch Normalization      Batch normalization
     4   ''          ReLU                     ReLU
     5   ''          Max Pooling              2x2 max pooling with stride [2  2] and padding [0  0  0  0]
     6   ''          Convolution              64 3x3 convolutions with stride [1  1] and padding [1  1  1  1]
     7   ''          ReLU                     ReLU
     8   ''          Transposed Convolution   64 4x4 transposed convolutions with stride [2  2] and cropping [1  1  1  1]
     9   ''          Convolution              2 1x1 convolutions with stride [1  1] and padding [0  0  0  0]
    10   ''          Softmax                  softmax
    11   'tversky'   Classification Output    Tversky loss

Загрузите обучающие данные для семантической сегментации с помощью imageDatastore и pixelLabelDatastore.

dataSetDir = fullfile(toolboxdir('vision'),'visiondata','triangleImages');
imageDir = fullfile(dataSetDir,'trainingImages');
labelDir = fullfile(dataSetDir,'trainingLabels');

imds = imageDatastore(imageDir);

classNames = ["triangle" "background"];
labelIDs = [255 0];
pxds = pixelLabelDatastore(labelDir, classNames, labelIDs);

Сопоставьте изображение и данные о пиксельных метках при помощи pixelLabelImageDatastore.

ds = pixelLabelImageDatastore(imds,pxds);

Установите опции обучения и обучите сеть.

options = trainingOptions('adam', ...
    'InitialLearnRate',1e-3, ...
    'MaxEpochs',100, ...
    'LearnRateDropFactor',5e-1, ...
    'LearnRateDropPeriod',20, ...
    'LearnRateSchedule','piecewise', ...
    'MiniBatchSize',50);

net = trainNetwork(ds,layers,options);
Training on single CPU.
Initializing input data normalization.
|========================================================================================|
|  Epoch  |  Iteration  |  Time Elapsed  |  Mini-batch  |  Mini-batch  |  Base Learning  |
|         |             |   (hh:mm:ss)   |   Accuracy   |     Loss     |      Rate       |
|========================================================================================|
|       1 |           1 |       00:00:00 |       50.32% |       1.2933 |          0.0010 |
|      13 |          50 |       00:00:08 |       98.83% |       0.0988 |          0.0010 |
|      25 |         100 |       00:00:15 |       99.33% |       0.0547 |          0.0005 |
|      38 |         150 |       00:00:21 |       99.37% |       0.0473 |          0.0005 |
|      50 |         200 |       00:00:28 |       99.48% |       0.0400 |          0.0003 |
|      63 |         250 |       00:00:36 |       99.48% |       0.0383 |          0.0001 |
|      75 |         300 |       00:00:43 |       99.54% |       0.0348 |          0.0001 |
|      88 |         350 |       00:00:50 |       99.51% |       0.0353 |      6.2500e-05 |
|     100 |         400 |       00:00:57 |       99.56% |       0.0331 |      6.2500e-05 |
|========================================================================================|

Оцените обученную сеть, сегментировав тестовое изображение и отобразив результат сегментации.

I = imread('triangleTest.jpg');
[C,scores] = semanticseg(I,net);

B = labeloverlay(I,C);
montage({I,B})

Figure contains an axes. The axes contains an object of type image.

Ссылки

[1] Salehi, Сейед Сэдег Мохсени, Дениз Эрдогмус и Али Голипур. "Функция потерь Tversky для сегментации изображений с помощью 3D полностью сверточных глубоких сетей". Международный семинар на Машинном обучении в Медицинской Обработке изображений. Спрингер, Хан, 2017.

Обучите сеть семантической сегментации с помощью расширенных сверток.

Семантическая сеть сегментации классифицирует каждый пиксель в изображении, получая к изображение, которое сегментировано по классам. Приложения для семантической сегментации включают сегментацию дорог для автономного управления автомобилем и сегментацию раковой клетки для медицинского диагностирования. Чтобы узнать больше, смотрите Начало работы с Семантической Сегментацией Используя Глубокое обучение.

Сети семантической сегментации как DeepLab [1] делают широкое применение расширенных сверток (также известный atrous свертки), потому что они могут увеличить восприимчивое поле слоя (область входа, который слои видят), не увеличивая число параметров или расчетов.

Загрузите обучающие данные

Пример использует простой набор данных 32 32 треугольных изображений в целях рисунка. Набор данных включает сопроводительные пиксельные достоверные данные метки. Загрузите обучающие данные с помощью imageDatastore и pixelLabelDatastore.

dataFolder = fullfile(toolboxdir('vision'),'visiondata','triangleImages');
imageFolderTrain = fullfile(dataFolder,'trainingImages');
labelFolderTrain = fullfile(dataFolder,'trainingLabels');

Создайте imageDatastore для изображений.

imdsTrain = imageDatastore(imageFolderTrain);

Создайте pixelLabelDatastore для пиксельных меток основной истины.

classNames = ["triangle" "background"];
labels = [255 0];
pxdsTrain = pixelLabelDatastore(labelFolderTrain,classNames,labels)
pxdsTrain = 
  PixelLabelDatastore with properties:

                       Files: {200x1 cell}
                  ClassNames: {2x1 cell}
                    ReadSize: 1
                     ReadFcn: @readDatastoreImage
    AlternateFileSystemRoots: {}

Создайте сеть Семантической Сегментации

Этот пример использует простую сеть семантической сегментации на основе расширенных сверток.

Создайте источник данных для обучающих данных и получите количество пикселей для каждой метки.

pximdsTrain = pixelLabelImageDatastore(imdsTrain,pxdsTrain);
tbl = countEachLabel(pxdsTrain)
tbl=2×3 table
         Name         PixelCount    ImagePixelCount
    ______________    __________    _______________

    {'triangle'  }         10326       2.048e+05   
    {'background'}    1.9447e+05       2.048e+05   

Большинство меток пикселей предназначены для фона. Этот классовый дисбаланс смещает процесс обучения в пользу доминирующего класса. Чтобы исправить это, используйте взвешивание классов для балансировки классов. Для вычисления весов классов можно использовать несколько методов. Одним из распространенных методов является обратное взвешивание частот, где веса классов являются обратными частотам классов. Этот метод увеличивает вес, придаваемый недостаточно представленным классам. Вычислите веса классов, используя обратное частотное взвешивание.

numberPixels = sum(tbl.PixelCount);
frequency = tbl.PixelCount / numberPixels;
classWeights = 1 ./ frequency;

Создайте сеть для классификации пикселей при помощи входного слоя изображений с входным размером, соответствующим размеру входных изображений. Затем задайте три блока свертки, нормализации партии. и слоев ReLU. Для каждого сверточного слоя задайте 32 3х3 фильтра с увеличивающимися коэффициентами расширения и заполните входные параметры, таким образом, они одного размера с выходными параметрами путем установки 'Padding' опция к 'same'. Чтобы классифицировать пиксели, включайте сверточный слой с K свертки 1 на 1, где K является количеством классов, сопровождаемых softmax слоем и pixelClassificationLayer с обратными весами класса.

inputSize = [32 32 1];
filterSize = 3;
numFilters = 32;
numClasses = numel(classNames);

layers = [
    imageInputLayer(inputSize)
    
    convolution2dLayer(filterSize,numFilters,'DilationFactor',1,'Padding','same')
    batchNormalizationLayer
    reluLayer
    
    convolution2dLayer(filterSize,numFilters,'DilationFactor',2,'Padding','same')
    batchNormalizationLayer
    reluLayer
    
    convolution2dLayer(filterSize,numFilters,'DilationFactor',4,'Padding','same')
    batchNormalizationLayer
    reluLayer
    
    convolution2dLayer(1,numClasses)
    softmaxLayer
    pixelClassificationLayer('Classes',classNames,'ClassWeights',classWeights)];

Обучение сети

Задайте опции обучения.

options = trainingOptions('sgdm', ...
    'MaxEpochs', 100, ...
    'MiniBatchSize', 64, ... 
    'InitialLearnRate', 1e-3);

Обучите сеть с помощью trainNetwork.

net = trainNetwork(pximdsTrain,layers,options);
Training on single CPU.
Initializing input data normalization.
|========================================================================================|
|  Epoch  |  Iteration  |  Time Elapsed  |  Mini-batch  |  Mini-batch  |  Base Learning  |
|         |             |   (hh:mm:ss)   |   Accuracy   |     Loss     |      Rate       |
|========================================================================================|
|       1 |           1 |       00:00:00 |       91.62% |       1.6825 |          0.0010 |
|      17 |          50 |       00:00:08 |       88.56% |       0.2393 |          0.0010 |
|      34 |         100 |       00:00:15 |       92.08% |       0.1672 |          0.0010 |
|      50 |         150 |       00:00:23 |       93.17% |       0.1472 |          0.0010 |
|      67 |         200 |       00:00:31 |       94.15% |       0.1313 |          0.0010 |
|      84 |         250 |       00:00:38 |       94.47% |       0.1167 |          0.0010 |
|     100 |         300 |       00:00:46 |       95.04% |       0.1100 |          0.0010 |
|========================================================================================|

Тестирование сети

Загрузите тестовые данные. Создайте imageDatastore для изображений. Создайте pixelLabelDatastore для пиксельных меток основной истины.

imageFolderTest = fullfile(dataFolder,'testImages');
imdsTest = imageDatastore(imageFolderTest);
labelFolderTest = fullfile(dataFolder,'testLabels');
pxdsTest = pixelLabelDatastore(labelFolderTest,classNames,labels);

Сделайте предсказания с помощью тестовых данных, и обучил сеть.

pxdsPred = semanticseg(imdsTest,net,'MiniBatchSize',32,'WriteLocation',tempdir);
Running semantic segmentation network
-------------------------------------
* Processed 100 images.

Оцените точность предсказания с помощью evaluateSemanticSegmentation.

metrics = evaluateSemanticSegmentation(pxdsPred,pxdsTest);
Evaluating semantic segmentation results
----------------------------------------
* Selected metrics: global accuracy, class accuracy, IoU, weighted IoU, BF score.
* Processed 100 images.
* Finalizing... Done.
* Data set metrics:

    GlobalAccuracy    MeanAccuracy    MeanIoU    WeightedIoU    MeanBFScore
    ______________    ____________    _______    ___________    ___________

       0.95237          0.97352       0.72081      0.92889        0.46416  

Для получения дополнительной информации об оценке сетей семантической сегментации смотрите evaluateSemanticSegmentation.

Сегмент новое изображение

Считывание и отображение тестового изображения triangleTest.jpg.

imgTest = imread('triangleTest.jpg');
figure
imshow(imgTest)

Figure contains an axes. The axes contains an object of type image.

Сегментируйте тестовое изображение с помощью semanticseg и отобразите результаты с помощью labeloverlay.

C = semanticseg(imgTest,net);
B = labeloverlay(imgTest,C);
figure
imshow(B)

Figure contains an axes. The axes contains an object of type image.

Входные параметры

свернуть все

Введите изображение в виде одного из следующих.

Тип изображенияФормат данных
Одно 2D полутоновое изображение2D матрица размера H-by-W
Одно 2D цветное изображение или 2D многоспектральное изображениеТрехмерный массив размера H-by-W-by-C. Количество цветовых каналов C 3 для цветных изображений.
Серия P 2D изображенияМассив 4-D размера H-by-W-by-C-by-P. Количество цветовых каналов C 1 для полутоновых изображений и 3 для цветных изображений.
Одно 3-D полутоновое изображение с глубиной DТрехмерный массив размера H-by-W-by-D
Одно 3-D цветное изображение или 3-D многоспектральное изображениеМассив 4-D размера H-by-W-by-D-by-C. Количество цветовых каналов C 3 для цветных изображений.
Серия P 3-D изображенияМассив 5-D размера H-by-W-by-D-by-C-by-P

Входное изображение может также быть a gpuArray (Parallel Computing Toolbox), содержащий один из предыдущих типов изображения (требует Parallel Computing Toolbox™).

Типы данных: uint8 | uint16 | int16 | double | single | logical

Сеть в виде SeriesNetwork (Deep Learning Toolbox), DAGNetwork (Deep Learning Toolbox) или dlnetwork Объект (Deep Learning Toolbox).

Необходимая область в виде одного из следующих.

Тип изображенияФормат ROI
2D изображениеВектор с 4 элементами из формы [x, y, width, height]
3-D изображениеВектор с 6 элементами из формы [x, y, z, width, height, depth]

Вектор задает прямоугольную или кубовидную необходимую область, полностью содержавшуюся во входном изображении. Пиксели изображения вне необходимой области присвоены <undefined> категориальная метка. Если входное изображение состоит из серии изображений, то semanticseg применяет тот же roi ко всем изображениям в ряду.

Набор изображений в виде datastore. read функция datastore должна возвратить числовой массив, массив ячеек или таблицу. Для массивов ячеек или таблиц с несколькими столбцами, функциональные процессы только первый столбец.

Для получения дополнительной информации смотрите Хранилища данных для Глубокого обучения (Deep Learning Toolbox).

Аргументы в виде пар имя-значение

Задайте дополнительные разделенные запятой пары Name,Value аргументы. Name имя аргумента и Value соответствующее значение. Name должен появиться в кавычках. Вы можете задать несколько аргументов в виде пар имен и значений в любом порядке, например: Name1, Value1, ..., NameN, ValueN.

Пример: 'ExecutionEnvironment', 'gpu'

Возвращенный тип сегментации в виде 'categorical''double', или 'uint8'. Когда вы задаете 'double' или 'uint8', функция возвращает результаты сегментации как массив метки, содержащий метку IDs. Идентификаторы являются целочисленными значениями, которые соответствуют именам классов, заданным в слое классификации, используемом во входной сети.

Вы не можете использовать OutputType свойство с ImageDatastore объектный вход.

Группа изображений в виде целого числа. Изображения сгруппированы и обработаны вместе как пакет. Пакеты используются для обработки большого количества изображений, и они повышают вычислительную эффективность. Увеличение 'MiniBatchSize'повышения стоимости КПД, но это также поднимает больше памяти.

Аппаратный ресурс для обработки изображений с сетью в виде 'auto', 'gpu', или 'cpu'.

Среда выполненияОписание
'auto'Используйте графический процессор при наличии. В противном случае используйте центральный процессор. Использование графического процессора требует Parallel Computing Toolbox, и CUDA® включил NVIDIA® графический процессор. Для получения информации о поддерживаемом вычислите возможности, смотрите Поддержку графического процессора Релизом (Parallel Computing Toolbox).
'gpu'Используйте графический процессор. Если подходящий графический процессор не доступен, функция возвращает сообщение об ошибке.
'cpu'Используйте центральный процессор.

Оптимизация эффективности в виде 'auto'MEX, или 'none'.

УскорениеОписание
'auto'Автоматически примените много оптимизации, подходящей для входной сети и аппаратного ресурса.
'mex'Скомпилируйте и выполните MEX-функцию. Эта опция доступна при использовании графического процессора только. Необходимо было также установить компилятор C/C++. Для инструкций по настройке смотрите Setup MEX (GPU Coder).
'none'Отключите все ускорение.

Опцией по умолчанию является 'auto'. Если вы используете 'auto' опция, затем MATLAB никогда не генерирует MEX-функцию.

Используя 'Acceleration' опции 'auto' и 'mex' может предложить выигрыши в производительности, но за счет увеличенного начального времени выполнения. Последующие вызовы совместимыми параметрами быстрее. Используйте оптимизацию эффективности, когда вы запланируете вызвать функцию многократно с помощью новых входных данных.

'mex' опция генерирует и выполняет MEX-функцию на основе сети и параметров, используемых в вызове функции. У вас может быть несколько MEX-функций, сопоставленных с одной сетью одновременно. Очищение сетевой переменной также очищает любые MEX-функции, сопоставленные с той сетью.

'mex' опция только доступна, когда вы используете графический процессор. Используя графический процессор требует Parallel Computing Toolbox, и CUDA включил NVIDIA графический процессор. Для получения информации о поддерживаемом вычислите возможности, смотрите Поддержку графического процессора Релизом (Parallel Computing Toolbox). Если Parallel Computing Toolbox или подходящий графический процессор не доступны, то функция возвращает ошибку.

'mex' ускорение не поддерживает сети, заданные как dlnetwork Объект (Deep Learning Toolbox).

'mex' ускорение не поддерживает все слои. Для списка поддерживаемых слоев смотрите Поддерживаемые Слои (GPU Coder).

Классы, в которые пиксели или воксели классифицируются в виде 'auto', массив ячеек из символьных векторов, вектор строки или категориальный вектор. Если значением является категориальный векторный Y, то элементы вектора отсортированы и упорядочены согласно categories(Y).

Если сетью является dlnetwork Объект (Deep Learning Toolbox), затем количество классов задано 'Classes'должен совпадать с количеством каналов в выходе сетевых предсказаний. По умолчанию, когда 'Classes'имеет значение 'auto', классы пронумерованы от 1 до C, где C является количеством каналов в выходном слое сети.

Если сетью является SeriesNetwork (Deep Learning Toolbox) или DAGNetwork Объект (Deep Learning Toolbox), затем количество классов задано 'Classes'должен совпадать с количеством классов в классификации выходной слой. По умолчанию, когда 'Classes'имеет значение 'auto', классы автоматически установлены с помощью классификации выходной слой.

Местоположение папки в виде pwd (ваша текущая рабочая папка), строковый скаляр или вектор символов. Заданная папка должна существовать и иметь полномочия записи.

Это свойство применяется только при использовании ImageDatastore объектный вход.

Префикс применился к именам выходного файла в виде строкового скаляра или вектора символов. Файлы изображений называют можно следующим образом:

  • prefixN.png, где N соответствует индексу входного файла изображения, imds.FilesN.

Это свойство применяется только при использовании ImageDatastore объектный вход.

Отобразите информацию о прогрессе в виде 'true' или 'false'.

Это свойство применяется только при использовании ImageDatastore объектный вход.

Выходные аргументы

свернуть все

Категориальные метки, возвращенные как категориальный массив. Категориальный массив связывает метку с каждым пикселем или вокселем во входном изображении. Изображения, возвращенные readalldatastore) имейте взаимно-однозначное соответствие с категориальными матрицами, возвращенными readall(pixelLabelDatastore). Элементы массива метки соответствуют пикселю или элементам вокселя входного изображения. Если вы выбираете ROI, то метки ограничиваются областью в ROI. Пиксели изображения и воксели вне необходимой области присвоены <undefined> категориальная метка.

Тип изображенияКатегориальный формат этикетки
Одно 2D изображение2D матрица размера H-by-W. Элемент C(i, j), категориальная метка, присвоенная пикселю I(i, j).
Серия P 2D изображенияТрехмерный массив размера H-by-W-by-P. Элемент C(i, j, p), категориальная метка, присвоенная пикселю I(i, j, p).
Одно 3-D изображениеТрехмерный массив размера H-by-W-by-D. Элемент C(i, j, k), категориальная метка, присвоенная вокселю I(i, j, k).
Серия P 3-D изображенияМассив 4-D размера H-by-W-by-D-by-P. Элемент C(i, j, k, p), категориальная метка, присвоенная вокселю I(i, j, k, p).

Оценки достоверности для каждой категориальной метки в C, возвращенный как массив значений между 0 и 1. Баллы представляют доверие к предсказанным меткам C. Более высокие значения баллов указывают на более высокое доверие к предсказанной метке.

Тип изображенияВыиграйте формат
Одно 2D изображение2D матрица размера H-by-W. Элемент score(i, j), классификационная оценка пикселя I(i, j).
Серия P 2D изображенияТрехмерный массив размера H-by-W-by-P. Элемент score(i, j, p), классификационная оценка пикселя I(i, j, p).
Одно 3-D изображениеТрехмерный массив размера H-by-W-by-D. Элемент score(i, j, k), классификационная оценка вокселя I(i, j, k).
Серия P 3-D изображенияМассив 4-D размера H-by-W-by-D-by-P. Элемент score(i, j, k, p), классификационная оценка вокселя I(i, j, k, p).

Оценки для всех категорий меток, которые может классифицировать входная сеть, возвратились как числовой массив. Формат массива описан в следующей таблице. L представляет общее количество категорий меток.

Тип изображенияВесь формат баллов
Одно 2D изображениеТрехмерный массив размера H-by-W-by-L. Элемент allScores(i, j, q), счет q th метка на уровне пикселя I(i, j).
Серия P 2D изображенияМассив 4-D размера H-by-W-by-L-by-P. Элемент allScores(i, j, q, p), счет q th метка на уровне пикселя I(i, j, p).
Одно 3-D изображениеМассив 4-D размера H-by-W-by-D-by-L. Элемент allScores(i, j, k, q), счет q th метка в вокселе I(i, j, k).
Серия P 3-D изображенияМассив 5-D размера H-by-W-by-D-by-L-by-P. Элемент allScores(i, j, k, q, p), счет q th метка в вокселе I(i, j, k, p).

Результаты семантической сегментации, возвращенные как a pixelLabelDatastore объект. Объект содержит результаты семантической сегментации для всех изображений, содержавшихся в ds входной объект. Результат для каждого изображения сохранен как отдельный uint8 пометьте матрицы изображений PNG. Можно использовать read(pxds) возвратить категориальные метки, присвоенные изображениям в ds.

Изображения в выходе readallds ) имейте взаимно-однозначное соответствие с категориальными матрицами в выходе readall(pxds).

Расширенные возможности

Введенный в R2017b
Для просмотра документации необходимо авторизоваться на сайте