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

semanticseg

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

構文

C = semanticseg(I,network)
[C,score,allScores] = semanticseg(I,network)
[___] = semanticseg(I,network,roi)
pxds = semanticseg(imds,network)
[___] = semanticseg(___,Name,Value)

説明

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

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

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

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

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

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

すべて折りたたむ

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

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

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

    Layers: [10x1 nnet.cnn.layer.Layer]

ネットワーク層をリストします。

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 output cropping [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,'WriteLocation',tempdir);
Running semantic segmentation network
-------------------------------------
* Processing 100 images.
* Progress: 100.00%

結果をグラウンド トゥルースと比較します。

metrics = evaluateSemanticSegmentation(pxdsResults,pxdsTruth)
Evaluating semantic segmentation results
---------------------------------------[==================================================] 100%
Elapsed time: 00:00:01
Estimated time remaining: 00:00:00
* 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 類似度係数に基づきます。イメージ と対応するグラウンド トゥルース の間の一般化 Dice 損失 [1,2] は、次により与えられます。

ここで、 はクラスの数、 の最初の 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' の場合、学習時にクラスが自動的に設定されます。文字ベクトル str の string 配列または cell 配列を指定すると、出力層のクラスが 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)
Skipping GPU tests. No compatible GPU device found.
 
Running nnet.checklayer.OutputLayerTestCase
.......... ...
Done nnet.checklayer.OutputLayerTestCase
__________

Test Summary:
	 13 Passed, 0 Failed, 0 Incomplete, 4 Skipped.
	 Time elapsed: 1.1004 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 CPU.
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:01:40 |       89.67% |       0.6384 |          0.0100 |
|     100 |         100 |       00:03:13 |       94.35% |       0.5024 |          0.0010 |
|========================================================================================|

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

I = imread('triangleTest.jpg');

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

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

参照

  1. Crum, William R., Oscar Camara, and Derek LG Hill. "Generalized overlap measures for evaluation and validation in medical image analysis." IEEE transactions on medical imaging 25.11 (2006): 1451-1461.

  2. Sudre, Carole H., et al. "Generalised Dice overlap as a deep learning loss function for highly unbalanced segmentations." Deep Learning in Medical Image Analysis and Multimodal Learning for Clinical Decision Support. Springer, Cham, 2017. 240-248.

この例では、膨張畳み込みを使用してセマンティック セグメンテーション ネットワークの学習を行う方法を説明します。

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

膨張畳み込み (Atrous 畳み込みとも呼ばれる) は、パラメーターの数や計算量を増やさずに、層の受容野 (層で確認できる入力の領域) を増やすことができるため、セマンティック セグメンテーション タスクに非常に適しています。

学習データの読み込み

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

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

イメージのイメージ データストアを作成します。

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)];

ネットワークの学習

学習オプションを指定します。SGDM ソルバーを使用して、100 エポック、ミニバッチ サイズ 64、学習率 0.001 の学習を行います。

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 |
|========================================================================================|

ネットワークのテスト

テスト データを読み込みます。イメージのイメージ データストアを作成します。グラウンド トゥルース ピクセル ラベル用の 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)

入力引数

すべて折りたたむ

入力イメージ。次のいずれかに指定します。配列の最初の 3 つの次元はイメージの高さ (M)、幅 (N)、およびチャネル (K) のインデックスを表します。一連の P 個のイメージの場合、4 番目の次元は個々のイメージのインデックスを表します。

イメージ タイプデータ形式
グレースケール イメージM 行 N 列の行列
カラー イメージM x N x 3 の配列
マルチスペクトル イメージM x N x K の配列
一連のグレースケール イメージM x N x 1 x P の配列
一連のカラー イメージM x N x 3 x P の配列
一連のマルチスペクトル イメージM x N x K x P の配列
イメージの gpuArray前述のイメージ タイプのいずれかを含む gpuArray (Parallel Computing Toolbox™ が必要)

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

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

関心領域。[x,y,width,height] 形式の 4 要素ベクトルとして指定します。このベクトルは、入力イメージに完全に含まれる四角形の関心領域を定義します。関心領域外部のイメージ ピクセルは、<undefined> カテゴリカル ラベルが割り当てられます。4 次元入力イメージを使用する場合、関数は同じ roi をすべてのイメージに適用します。

イメージの集合。ImageDatastore オブジェクトとして指定します。関数は、ラベルを入力イメージの各ピクセルに関連付ける categorical 配列としてセマンティック セグメンテーションを返します。

名前と値のペアの引数

オプションの引数 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 を使用します。

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

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

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

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

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

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

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

出力引数

すべて折りたたむ

カテゴリカル ラベル。2 次元 categorical 配列として返されます。ラベル配列の要素は、入力イメージのピクセル要素に対応します。ROI を選択した場合、ラベルは ROI 内の領域に制限されます。関心領域外部のイメージ ピクセルは、<undefined> カテゴリカル ラベルが割り当てられます。

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

C の各カテゴリカル ラベルの分類スコア。categorical 配列として返されます。このスコアは、予測されるラベル C の信頼度を表します。ピクセル (i,j) の分類スコアは score(i,j) に関連しています。

入力ネットワークが分類できるすべてのラベル カテゴリのスコア。4 次元配列として返されます。最初の 3 つの次元は、C の高さ、幅、およびカテゴリの数を表します。4 番目の次元は個々のイメージのインデックスを表します。

拡張機能

R2017b で導入