最新のリリースでは、このページがまだ翻訳されていません。 このページの最新版は英語でご覧になれます。

semanticseg

深層学習を使用したセマンティック イメージ セグメンテーション

説明

C = semanticseg(I,network) は、深層学習を使用した入力イメージのセマンティック セグメンテーションを返します。入力 networkSeriesNetwork または DAGNetwork オブジェクトでなければなりません。

[C,score,allScores] = semanticseg(I,network) は、C で各カテゴリカル ラベルの分類スコアと共に入力イメージのセマンティック セグメンテーションを返します。関数は、入力イメージの各ピクセルまたはボクセルに対応する配列でスコアを返します。allScores は、入力ネットワークが分類できるすべてのラベル カテゴリのスコアを含みます。

[___] = semanticseg(I,network,roi) は、入力イメージの四角形の部分領域のセマンティック セグメンテーションを返します。

pxds = semanticseg(ds,network) は、ds に含まれるイメージの集合であるデータストア オブジェクト ds のセマンティック セグメンテーションを返します。

この関数は、複数の MATLAB® ワーカーを使用する並列計算をサポートします。Computer Vision Toolbox の設定ダイアログを使用して並列計算を有効にできます。

[___] = semanticseg(___,Name,Value) は、1 つ以上の名前と値のペアの引数で指定された追加オプションを使用してセマンティック セグメンテーションを返します。

すべて折りたたむ

セグメンテーション結果をイメージに重ね合わせ、結果を表示します。

事前学習済みのネットワークを読み込みます。

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)

セマンティック イメージ セグメンテーションを実行します。

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

セグメンテーション結果をイメージに重ね合わせ、結果を表示します。

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

分類スコアを表示します。

figure
imagesc(scores)
axis square
colorbar

三角形のみを使用するバイナリ マスクを作成します。

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

イメージのテスト セットに対してセマンティック セグメンテーションを実行し、結果をグラウンド トゥルース データと比較します。

事前学習済みのネットワークを読み込みます。

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
                              }
    AlternateFileSystemRoots: {}
                    ReadSize: 1
                      Labels: {}
                     ReadFcn: @readDatastoreImage

グラウンド トゥルース テスト ラベルを読み込みます。

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

すべてのテスト イメージに対してセマンティック セグメンテーションを実行します。

pxdsResults = semanticseg(imds,net,'MiniBatchSize',32,'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]

Dice 損失を使用するカスタム ピクセル分類層を定義して作成します。

この層を使用して、セマンティック セグメンテーション ネットワークに学習させることができます。カスタム深層学習層の作成の詳細については、カスタム深層学習層の定義 (Deep Learning Toolbox)を参照してください。

Dice 損失

Dice 損失は、セグメント化された 2 つのイメージの間のオーバーラップを測定する Sørensen-Dice 類似度係数に基づきます。1 つのイメージ Y と対応するグラウンド トゥルース T の間の一般化 Dice 損失 [1,2] L は、次により与えられます。

L=1-2k=1Kwkm=1MYkmTkmk=1Kwkm=1MYkm2+Tkm2

ここで、K はクラスの数、MY の最初の 2 つの次元に沿った要素の数、wk は損失に対する各クラスの寄与を制御するクラス固有の重み係数です。wk は一般的に予想される領域の面積の逆です。

wk=1(m=1MTkm)2

この重み付けは、Dice スコアに対する大きな領域の影響を無効にするのに役立ち、ネットワークがより小さい領域をセグメント化する方法を学習するのを容易にします。

分類層テンプレート

分類層のテンプレートを MATLAB® の新しいファイルにコピーします。このテンプレートは、分類層の構造の概要を示しており、層の動作を定義する関数が含まれます。この例の残りの部分では、dicePixelClassificationLayer を完成する方法を示します。

classdef dicePixelClassificationLayer < nnet.layer.ClassificationLayer

   properties
      % Optional properties
   end

   methods

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

層のプロパティの宣言

既定では、カスタム出力層には次のプロパティがあります。

  • Name — 層の名前。文字ベクトルまたは string スカラーとして指定します。層グラフにこの層を含めるには、空ではない一意の層の名前を指定しなければなりません。この層が含まれる系列ネットワークに学習させて Name'' に設定すると、学習時に層に名前が自動的に割り当てられます。

  • Description — 層についての 1 行の説明。文字ベクトルまたは string スカラーとして指定します。この説明は、層が Layer 配列に表示されるときに表示されます。層の説明を指定しない場合、層のクラス名が表示されます。

  • Type — 層のタイプ。文字ベクトルまたは string スカラーとして指定します。Type の値は、層が Layer 配列に表示されるときに表示されます。層のタイプを指定しない場合、'Classification layer' または 'Regression layer' が表示されます。

カスタム分類層には次のプロパティもあります。

  • Classes — 出力層のクラス。categorical ベクトル、string 配列、文字ベクトルの cell 配列、または 'auto' として指定します。Classes'auto' の場合、学習時にクラスが自動的に設定されます。string 配列または文字ベクトルの cell 配列 str を指定すると、出力層のクラスが categorical(str,str) に設定されます。既定値は 'auto' です。

層にその他のプロパティがない場合は、properties セクションを省略できます。

Dice 損失には、ゼロ除算を防止するために小さい定数値が必要です。プロパティ Epsilon を指定して、この値を保持します。

classdef dicePixelClassificationLayer < nnet.layer.ClassificationLayer

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

    end

    ...
end

コンストラクター関数の作成

層を構築する関数を作成し、層のプロパティを初期化します。層を作成するために必要な変数をコンストラクター関数への入力として指定します。

作成時に Name プロパティを割り当てるオプションの入力引数 name を指定します。

        function layer = dicePixelClassificationLayer(name)
            % layer =  dicePixelClassificationLayer(name) creates a Dice
            % pixel classification layer with the specified name.
            
            % Set layer name.          
            layer.Name = name;
            
            % Set layer description.
            layer.Description = 'Dice loss';
        end

順方向損失関数の作成

ネットワークで行った予測と学習ターゲットの間の重み付き交差エントロピー損失を返す、forwardLoss という名前の関数を作成します。forwardLoss の構文は loss = forwardLoss(layer, Y, T) です。ここで、Y は前の層の出力であり、T は学習ターゲットを表します。

セマンティック セグメンテーションの問題の場合、T の次元は Y の次元と一致する必要があります。Y は、H x W x K x N の 4 次元配列です。K はクラスの数、N はミニバッチ サイズです。

Y のサイズは前の層の出力によって異なります。YT と同じサイズになるように、正しいサイズを出力する層を出力層の前に含めなければなりません。たとえば、Y を必ず K 個のクラスの予測スコアを持つ 4 次元配列にするために、サイズが K の全結合層か K 個のフィルターを持つ畳み込み層を含め、その後にソフトマックス層、出力層の順に配置することができます。

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

            % Weights by inverse of region size.
            W = 1 ./ sum(sum(T,1),2).^2;
            
            intersection = sum(sum(Y.*T,1),2);
            union = sum(sum(Y.^2 + T.^2, 1),2);          
            
            numer = 2*sum(W.*intersection,3) + layer.Epsilon;
            denom = sum(W.*union,3) + layer.Epsilon;
            
            % Compute Dice score.
            dice = numer./denom;
            
            % Return average Dice loss.
            N = size(Y,4);
            loss = sum((1-dice))/N;
            
        end

逆方向損失関数の作成

予測 Y についての Dice 損失の微分を返す、逆方向損失関数を作成します。backwardLoss の構文は loss = backwardLoss(layer, Y, T) です。ここで、Y は前の層の出力であり、T は学習ターゲットを表します。

YT の次元は forwardLoss の入力と同じです。

        function dLdY = backwardLoss(layer, Y, T)
            % dLdY = backwardLoss(layer, Y, T) returns the derivatives of
            % the Dice loss with respect to the predictions Y.
            
            % Weights by inverse of region size.
            W = 1 ./ sum(sum(T,1),2).^2;
            
            intersection = sum(sum(Y.*T,1),2);
            union = sum(sum(Y.^2 + T.^2, 1),2);
     
            numer = 2*sum(W.*intersection,3) + layer.Epsilon;
            denom = sum(W.*union,3) + layer.Epsilon;
            
            N = size(Y,4);
      
            dLdY = (2*W.*Y.*numer./denom.^2 - 2*W.*T./denom)./N;
        end

完成した層

完成した層は、dicePixelClassificationLayer.m で提供されています。

classdef dicePixelClassificationLayer < nnet.layer.ClassificationLayer
    % This layer implements the generalized Dice loss function for training
    % semantic segmentation networks.
    
    properties(Constant)
        % Small constant to prevent division by zero. 
        Epsilon = 1e-8;
    end
    
    methods
        
        function layer = dicePixelClassificationLayer(name)
            % layer =  dicePixelClassificationLayer(name) creates a Dice
            % pixel classification layer with the specified name.
            
            % Set layer name.          
            layer.Name = name;
            
            % Set layer description.
            layer.Description = 'Dice loss';
        end
        
        
        function loss = forwardLoss(layer, Y, T)
            % loss = forwardLoss(layer, Y, T) returns the Dice loss between
            % the predictions Y and the training targets T.   

            % Weights by inverse of region size.
            W = 1 ./ sum(sum(T,1),2).^2;
            
            intersection = sum(sum(Y.*T,1),2);
            union = sum(sum(Y.^2 + T.^2, 1),2);          
            
            numer = 2*sum(W.*intersection,3) + layer.Epsilon;
            denom = sum(W.*union,3) + layer.Epsilon;
            
            % Compute Dice score.
            dice = numer./denom;
            
            % Return average Dice loss.
            N = size(Y,4);
            loss = sum((1-dice))/N;
            
        end
        
        function dLdY = backwardLoss(layer, Y, T)
            % dLdY = backwardLoss(layer, Y, T) returns the derivatives of
            % the Dice loss with respect to the predictions Y.
            
            % Weights by inverse of region size.
            W = 1 ./ sum(sum(T,1),2).^2;
            
            intersection = sum(sum(Y.*T,1),2);
            union = sum(sum(Y.^2 + T.^2, 1),2);
     
            numer = 2*sum(W.*intersection,3) + layer.Epsilon;
            denom = sum(W.*union,3) + layer.Epsilon;
            
            N = size(Y,4);
      
            dLdY = (2*W.*Y.*numer./denom.^2 - 2*W.*T./denom)./N;
        end
    end
end

GPU 互換性

GPU 互換性のために、層関数は gpuArray 型の入力をサポートし、この型の出力を返さなければなりません。層で使用される他の関数も同じ動作をしなければなりません。

dicePixelClassificationLayerforwardLoss および backwardLoss で使用する MATLAB 関数はすべて、gpuArray 入力をサポートしているため、層は GPU 互換です。

出力層の有効性のチェック

層のインスタンスを作成します。

layer = dicePixelClassificationLayer('dice');

checkLayer を使用してこの層の層の有効性をチェックします。層への典型的な入力における 1 つの観測値のサイズになるように有効な入力サイズを指定します。層には H x W x K x N の配列を入力する必要があります。K はクラスの数、N はミニバッチ内の観測値の数です。

numClasses = 2;
validInputSize = [4 4 numClasses];
checkLayer(layer,validInputSize, 'ObservationDimension',4)
Running nnet.checklayer.OutputLayerTestCase
.......... .......
Done nnet.checklayer.OutputLayerTestCase
__________

Test Summary:
	 17 Passed, 0 Failed, 0 Incomplete, 0 Skipped.
	 Time elapsed: 1.6227 seconds.

テストの概要では、パスしたテスト、失敗したテスト、不完全なテスト、およびスキップされたテストの数が報告されます。

セマンティック セグメンテーション ネットワークでのカスタム層の使用

dicePixelClassificationLayer を使用するセマンティック セグメンテーション ネットワークを作成します。

layers = [
    imageInputLayer([32 32 1])
    convolution2dLayer(3,64,'Padding',1)
    reluLayer
    maxPooling2dLayer(2,'Stride',2)
    convolution2dLayer(3,64,'Padding',1)
    reluLayer
    transposedConv2dLayer(4,64,'Stride',2,'Cropping',1)
    convolution2dLayer(1,2)
    softmaxLayer
    dicePixelClassificationLayer('dice')]
layers = 
  10x1 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   ''       ReLU                     ReLU
     4   ''       Max Pooling              2x2 max pooling with stride [2  2] and padding [0  0  0  0]
     5   ''       Convolution              64 3x3 convolutions with stride [1  1] and padding [1  1  1  1]
     6   ''       ReLU                     ReLU
     7   ''       Transposed Convolution   64 4x4 transposed convolutions with stride [2  2] and output cropping [1  1]
     8   ''       Convolution              2 1x1 convolutions with stride [1  1] and padding [0  0  0  0]
     9   ''       Softmax                  softmax
    10   'dice'   Classification Output    Dice loss

imageDatastorepixelLabelDatastore を使用してセマンティック セグメンテーション用の学習データを読み込みます。

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('sgdm', ...
    'InitialLearnRate',1e-2, ...
    'MaxEpochs',100, ...
    'LearnRateDropFactor',1e-1, ...
    'LearnRateDropPeriod',50, ...
    'LearnRateSchedule','piecewise', ...
    'MiniBatchSize',128);

net = trainNetwork(ds,layers,options);
Training on single GPU.
Initializing image normalization.
|========================================================================================|
|  Epoch  |  Iteration  |  Time Elapsed  |  Mini-batch  |  Mini-batch  |  Base Learning  |
|         |             |   (hh:mm:ss)   |   Accuracy   |     Loss     |      Rate       |
|========================================================================================|
|       1 |           1 |       00:00:03 |       27.89% |       0.8346 |          0.0100 |
|      50 |          50 |       00:00:34 |       89.67% |       0.6384 |          0.0100 |
|     100 |         100 |       00:01:09 |       94.35% |       0.5024 |          0.0010 |
|========================================================================================|

テスト イメージをセグメント化し、セグメンテーション結果を表示して、学習済みネットワークを評価します。

I = imread('triangleTest.jpg');

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

B = labeloverlay(I,C);
figure
imshow(imtile({I,B}))

膨張畳み込みを使用してセマンティック セグメンテーション ネットワークに学習させます。

セマンティック セグメンテーション ネットワークはイメージ内のすべてのピクセルを分類して、クラスごとにセグメント化されたイメージを作成します。セマンティック セグメンテーションの応用例としては、自動運転のための道路セグメンテーションや医療診断のための癌細胞セグメンテーションなどがあります。詳細は、深層学習を使用したセマンティック セグメンテーション入門を参照してください。

DeepLab [1] などのセマンティック セグメンテーション ネットワークでは、膨張畳み込み (Atrous 畳み込みとも呼ばれる) が広範に使用されます。これはパラメーターの数や計算量を増やさずに、層の受容野 (層で確認できる入力の領域) を増やすことができるからです。

学習データの読み込み

例では、説明のために 32 x 32 の三角形のイメージを含む単純なデータセットを使用します。データセットには、付随するピクセル ラベル グラウンド トゥルース データが含まれます。imageDatastorepixelLabelDatastore を使用して学習データを読み込みます。

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: {200×1 cell}
                  ClassNames: {2×1 cell}
                    ReadSize: 1
                     ReadFcn: @readDatastoreImage
    AlternateFileSystemRoots: {}

セマンティック セグメンテーション ネットワークの作成

この例では、膨張畳み込みに基づく単純なセマンティック セグメンテーション ネットワークを使用します。

学習データのデータ ソースを作成して、各ラベルのピクセル数を取得します。

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

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

ピクセル ラベルの大部分は背景用です。このクラスの不均衡によって、上位クラスを優先して学習プロセスにバイアスがかけられます。これを修正するには、クラスの重み付けを使用してクラスのバランスを調整します。クラスの重みの計算にはいくつかの方法を使用できます。一般的な方法の 1 つは、クラスの重みがクラスの頻度の逆となる逆頻度重み付けです。この方法では、過少に表現されたクラスに与えられる重みが増えます。逆頻度重み付けを使用してクラスの重みを計算します。

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

入力サイズが入力イメージのサイズに対応するイメージ入力層を使用して、ピクセル分類用ネットワークを作成します。次に、畳み込み層、バッチ正規化層、および ReLU 層の 3 つのブロックを指定します。各畳み込み層で、膨張係数を増加させながら 3 行 3 列のフィルターを 32 個指定します。また、'Padding' オプションを 'same' に設定して、出力と同じサイズになるように入力をパディングします。ピクセルを分類するには K と 1 行 1 列の畳み込みを使用する畳み込み層を含め (K はクラスの数)、その後にソフトマックス層と逆のクラスの重みを持つ 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 GPU.
Initializing image normalization.
|========================================================================================|
|  Epoch  |  Iteration  |  Time Elapsed  |  Mini-batch  |  Mini-batch  |  Base Learning  |
|         |             |   (hh:mm:ss)   |   Accuracy   |     Loss     |      Rate       |
|========================================================================================|
|       1 |           1 |       00:00:00 |       67.54% |       0.7098 |          0.0010 |
|      17 |          50 |       00:00:03 |       84.60% |       0.3851 |          0.0010 |
|      34 |         100 |       00:00:06 |       89.85% |       0.2536 |          0.0010 |
|      50 |         150 |       00:00:09 |       93.39% |       0.1959 |          0.0010 |
|      67 |         200 |       00:00:11 |       95.89% |       0.1559 |          0.0010 |
|      84 |         250 |       00:00:14 |       97.29% |       0.1188 |          0.0010 |
|     100 |         300 |       00:00:18 |       98.28% |       0.0970 |          0.0010 |
|========================================================================================|

ネットワークのテスト

テスト データを読み込みます。イメージの imageDatastore を作成します。グラウンド トゥルース ピクセル ラベル用の pixelLabelDatastore を作成します。

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

テスト データと学習済みネットワークを使用して、予測を実行します。

pxdsPred = semanticseg(imdsTest,net,'WriteLocation',tempdir);
Running semantic segmentation network
-------------------------------------
* Processing 100 images.
* Progress: 100.00%

evaluateSemanticSegmentation を使用して予測精度を評価します。

metrics = evaluateSemanticSegmentation(pxdsPred,pxdsTest);
Evaluating semantic segmentation results
----------------------------------------
* Selected metrics: global accuracy, class accuracy, IoU, weighted IoU, BF score.
* Processing 100 images...
[==================================================] 100%
Elapsed time: 00:00:00
Estimated time remaining: 00:00:00
* Finalizing... Done.
* Data set metrics:

    GlobalAccuracy    MeanAccuracy    MeanIoU    WeightedIoU    MeanBFScore
    ______________    ____________    _______    ___________    ___________

       0.98334          0.99107       0.85869      0.97109        0.68197  

セマンティック セグメンテーション ネットワークの評価の詳細については、evaluateSemanticSegmentationを参照してください。

新しいイメージのセグメンテーション

テスト イメージ triangleTest.jpg を読み取って表示します。

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

semanticseg を使用してテスト イメージをセグメント化し、labeloverlay を使用して結果を表示します。

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

入力引数

すべて折りたたむ

入力イメージ。次のいずれかに指定します。

イメージ タイプデータ形式
1 つの 2 次元グレースケール イメージH 行 W 列の 2 次元行列
1 つの 2 次元カラー イメージまたは 2 次元マルチスペクトル イメージH x W x C の 3 次元配列。カラー イメージの場合、カラー チャネル数 C は 3 です。
一連の P 2 次元イメージH x W x C x P の 4 次元配列。カラー チャネル数 C は、グレースケール イメージの場合は 1 になり、カラー イメージの場合は 3 になります。
深さ D の 1 つの 3 次元グレースケール イメージH x W x D の 3 次元配列
1 つの 3 次元カラー イメージまたは 3 次元マルチスペクトル イメージH x W x D x C の 4 次元配列。カラー イメージの場合、カラー チャネル数 C は 3 です。
一連の P 3 次元イメージH x W x D x C x P の 5 次元配列

入力イメージは、前述のイメージ タイプのいずれかを含む gpuArray にすることができます (Parallel Computing Toolbox™ が必要)。

データ型: uint8 | uint16 | int16 | double | single | logical

ネットワーク。SeriesNetwork または DAGNetwork オブジェクトとして指定します。

関心領域。次のいずれかに指定します。

イメージ タイプROI の形式
2 次元イメージ[x,y,width,height] 形式の 4 要素ベクトル
3 次元イメージ[x,y,z,width,height,depth] 形式の 6 要素ベクトル

このベクトルは、入力イメージに完全に含まれる四角形または直方体の関心領域を定義します。関心領域外部のイメージ ピクセルは、<undefined> カテゴリカル ラベルが割り当てられます。入力イメージが一連のイメージで構成される場合、semanticseg は同じ roi を一連のすべてのイメージに適用します。

イメージの集合。データストア オブジェクトとして指定します。データストアの関数 read は数値配列、cell 配列または table を返さなければなりません。複数の列を持つ cell 配列または table の場合、関数は最初の列のみを処理します。

詳細については、深層学習用のデータストア (Deep Learning Toolbox)を参照してください。

名前と値のペアの引数

オプションの Name,Value 引数のコンマ区切りペアを指定します。Name は引数名で、Value は対応する値です。Name は引用符で囲まなければなりません。Name1,Value1,...,NameN,ValueN のように、複数の名前と値のペアの引数を、任意の順番で指定できます。

例: 'ExecutionEnvironment','gpu'

返されるセグメンテーションのタイプ。'categorical''double' または 'uint8' として指定します。'double' または 'uint8' を指定した場合、関数はセグメンテーションの結果をラベル ID を含むラベル配列として返します。ID は、入力ネットワークで使用される分類層で定義されたクラス名に対応する整数値です。

OutputType プロパティを ImageDatastore オブジェクト入力と一緒に使用することはできません。

イメージのグループ。整数で指定します。イメージは、バッチとしてグループ化され、まとめて処理されます。バッチは大規模なイメージの集合の処理に使用され、計算効率を向上させます。'MiniBatchSize' の値を大きくすると効率は向上しますが、メモリ消費量も増加します。

ネットワークでイメージを処理するためのハードウェア リソース。'auto''gpu' または 'cpu' として指定します。

ExecutionEnvironment説明
'auto'利用可能な場合、GPU を使用します。そうでない場合、CPU を使用します。GPU を使用する場合、Parallel Computing Toolbox および Compute Capability 3.0 以上の CUDA® 対応 NVIDIA® GPU が必要です。
'gpu'GPU を使用します。適切な GPU が利用できない場合、関数はエラー メッセージを返します。
'cpu'CPU を使用します。

パフォーマンスの最適化。'auto''mex' または 'none' として指定します。

高速化説明
'auto'入力ネットワークとハードウェア リソースに適した最適化の回数を自動的に適用します。
'mex'MEX 関数をコンパイルして実行します。このオプションは GPU の使用時にのみ利用できます。GPU を使用するには、Parallel Computing Toolbox および Compute Capability 3.0 以上の CUDA 対応 NVIDIA GPU が必要です。Parallel Computing Toolbox または適切な GPU が利用できない場合、関数はエラーを返します。
'none'すべての高速化を無効にします。

既定のオプションは 'auto' です。'auto' オプションを使用する場合、MATLAB は MEX 関数を生成しません。

'Acceleration' オプション 'auto' および 'mex' を使用すると、パフォーマンス上のメリットが得られますが、初期実行時間が長くなります。互換性のあるパラメーターを使用した後続の呼び出しは、より高速になります。新しい入力データを使用して関数を複数回呼び出す場合は、パフォーマンスの最適化を使用してください。

'mex' オプションは、関数の呼び出しに使用されたネットワークとパラメーターに基づいて MEX 関数を生成し、実行します。複数の MEX 関数を一度に 1 つのネットワークに関連付けることができます。ネットワークの変数をクリアすると、そのネットワークに関連付けられている MEX 関数もクリアされます。

'mex' オプションは、GPU の使用時にのみ利用できます。また、C/C++ コンパイラがインストールされていなければなりません。設定手順については、MEX の設定 (GPU Coder)を参照してください。

'mex' による高速化ではサポートされていない層があります。サポートされている層の一覧については、サポートされている層 (GPU Coder)を参照してください。

フォルダーの場所。pwd (現在の作業フォルダー)、string スカラー、または文字ベクトルを指定します。指定されたフォルダーが存在している必要があります。また、そのフォルダーへの書き込み権限が必要です。

このプロパティは、ImageDatastore オブジェクト入力を使用する場合にのみ適用されます。

出力ファイル名に適用する接頭辞。string スカラーまたは文字ベクトルとして指定します。イメージ ファイルは次のように命名されます。

  • prefix_N.pngN は入力イメージ ファイルのインデックス imds.Files(N) に対応します。

このプロパティは、ImageDatastore オブジェクト入力を使用する場合にのみ適用されます。

進行状況の表示。'true' または 'false' を指定します。

このプロパティは、ImageDatastore オブジェクト入力を使用する場合にのみ適用されます。

出力引数

すべて折りたたむ

カテゴリカル ラベル。categorical 配列として返されます。categorical 配列は、ラベルを入力イメージの各ピクセルまたはボクセルに関連付けます。readall(datastore) によって返されるイメージは、readall(pixelLabelDatastore) によって返される categorical 行列と 1 対 1 で対応しています。ラベル配列の要素は、入力イメージのピクセルまたはボクセル要素に対応します。ROI を選択すると、ラベルは ROI 内の領域に制限されます。関心領域外部のイメージ ピクセルおよびボクセルは、<undefined> カテゴリカル ラベルが割り当てられます。

イメージ タイプカテゴリカル ラベルの形式
1 つの 2 次元イメージH 行 W 列の 2 次元行列。要素 C(i,j) は、ピクセル I(i,j) に割り当てられたカテゴリカル ラベルです。
一連の P 2 次元イメージH x W x P の 3 次元配列。要素 C(i,j,p) は、ピクセル I(i,j,p) に割り当てられたカテゴリカル ラベルです。
1 つの 3 次元イメージH x W x D の 3 次元配列。要素 C(i,j,k) は、ボクセル I(i,j,k) に割り当てられたカテゴリカル ラベルです。
一連の P 3 次元イメージH x W x D x P の 4 次元配列。要素 C(i,j,k,p) は、ボクセル I(i,j,k,p) に割り当てられたカテゴリカル ラベルです。

C 内の各カテゴリカル ラベルの信頼度スコア。01 の値の配列として返されます。このスコアは、予測されるラベル C の信頼度を表します。スコア値が大きいほど、予測ラベルの信頼度が高いことを示します。

イメージ タイプスコアの形式
1 つの 2 次元イメージH 行 W 列の 2 次元行列。要素 score(i,j) は、ピクセル I(i,j) の分類スコアです。
一連の P 2 次元イメージH x W x P の 3 次元配列。要素 score(i,j,p) は、ピクセル I(i,j,p) の分類スコアです。
1 つの 3 次元イメージH x W x D の 3 次元配列。要素 score(i,j,k) はボクセル I(i,j,k) の分類スコアです。
一連の P 3 次元イメージH x W x D x P の 4 次元配列。要素 score(i,j,k,p) は、ボクセル I(i,j,k,p) の分類スコアです。

入力ネットワークが分類できるすべてのラベル カテゴリのスコア。数値配列として返されます。次の表で配列の形式について説明します。L はラベル カテゴリの総数を表します。

イメージ タイプ全スコアの形式
1 つの 2 次元イメージH x W x L の 3 次元配列。要素 allScores(i,j,q) は、ピクセル I(i,j) における q 番目のラベルのスコアです。
一連の P 2 次元イメージH x W x L x P の 4 次元配列。要素 allScores(i,j,q,p) は、ピクセル I(i,j,p) における q 番目のラベルのスコアです。
1 つの 3 次元イメージH x W x D x L の 4 次元配列。要素 allScores(i,j,k,q) は、ボクセル I(i,j,k) における q 番目のラベルのスコアです。
一連の P 3 次元イメージH x W x D x L x P の 5 次元配列。要素 allScores(i,j,k,q,p) は、ボクセル I(i,j,k,p) における q 番目のラベルのスコアです。

セマンティック セグメンテーションの結果。pixelLabelDatastore オブジェクトとして返されます。このオブジェクトには、ds 入力オブジェクトに含まれるすべてのイメージのセマンティック セグメンテーションの結果が含まれます。各イメージの結果は、PNG イメージの個別の uint8 ラベル行列として保存されます。read(pxds) を使用して、ds 内のイメージに割り当てられたカテゴリカル ラベルを返すことができます。

readall(ds) の出力内のイメージは、readall(pxds) の出力内の categorical 行列と 1 対 1 で対応しています。

拡張機能

R2017b で導入