Тверской проигрыш

Потеря Тверского основана на индексе Тверского для измерения перекрытия между двумя сегментированными изображениями [1]. Индекс TIc Тверского ${\mathrm{}}_{\mathit{}}$между одним изображением $\mathit{Y}$ и соответствующей истинностью $\mathit{T\; основания}$задается

Потеря $\mathit{L}$над числом классов $\mathit{C}$ задается

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

Скопируйте шаблон классификационного слоя в новый файл в 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

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

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

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

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

Для Тверского проигрыша требуется малое постоянное значение, чтобы предотвратить деление на ноль. Укажите свойство, 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.

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

Завершенный слой представлен в 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

Совместимость графического процессора

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

Проверка достоверности выходного уровня

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

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

Проверьте действительность слоя с помощью checkLayer. Укажите допустимый размер ввода, который должен быть размером одного наблюдения за типовым вводом в слой. Слой ожидает 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})

Ссылки

[1] Салехи, Сейед Садег Мохсени, Дениз Эрдогм и Али Голипур. «Функция потерь Тверского для сегментации изображения с использованием 3D полностью сверточных глубоких сетей». Международный семинар по машинному обучению медицинской визуализации. Спрингер, Чам, 2017.