Улучшение результатов

Сети не удалось сегментировать треугольники и классифицировать каждый пиксель как «фон». Обучение, по-видимому, проходит хорошо с точностью обучения более 90%. Однако сеть научилась только классифицировать фоновый класс. Чтобы понять, почему это произошло, можно подсчитать появление каждой пиксельной метки в наборе данных.

tbl = countEachLabel(pxds)

tbl=2×3 table
         Name         PixelCount    ImagePixelCount
    ______________    __________    _______________

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

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

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

classWeights = 2×1

   19.8334
    1.0531

Веса классов могут быть указаны с помощью pixelClassificationLayer. Обновление последнего слоя для использования pixelClassificationLayer с весами обратного класса.

layers(end) = pixelClassificationLayer('Classes',tbl.Name,'ClassWeights',classWeights);

Снова тренировать сеть.

net = trainNetwork(trainingData,layers,opts);

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 |       72.27% |       5.4135 |          0.0010 |
|      17 |          50 |       00:00:11 |       94.84% |       0.1188 |          0.0010 |
|      34 |         100 |       00:00:23 |       96.52% |       0.0871 |          0.0010 |
|      50 |         150 |       00:00:35 |       97.29% |       0.0599 |          0.0010 |
|      67 |         200 |       00:00:47 |       97.46% |       0.0628 |          0.0010 |
|      84 |         250 |       00:00:59 |       97.64% |       0.0586 |          0.0010 |
|     100 |         300 |       00:01:10 |       97.99% |       0.0451 |          0.0010 |
|========================================================================================|

Попробуйте снова сегментировать тестовый образ.

C = semanticseg(testImage,net);
B = labeloverlay(testImage,C);
imshow(B)

Использование взвешивания класса для балансировки классов привело к лучшему результату сегментации. Дополнительные шаги по улучшению результатов включают увеличение числа периодов, используемых для обучения, добавление дополнительных данных обучения или изменение сети.

Загрузка данных обучения

В примере для иллюстрации используется простой набор данных из изображений треугольника 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)

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

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