このページの内容は最新ではありません。最新版の英語を参照するには、ここをクリックします。

semanticseg

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

構文

C = semanticseg(I,network)

[C,score,allScores] = semanticseg(I,network)

[___] = semanticseg(I,network,roi)

pxds = semanticseg(ds,network)

[___] = semanticseg(___,Name=Value)

説明

C = semanticseg(I,network) は、深層学習を使用した入力イメージのセマンティック セグメンテーションを返します。

[C,score,allScores] = semanticseg(I,network) は、C 内の各カテゴリカル ラベルの分類スコアも返します。関数は、入力イメージの各ピクセルまたはボクセルに対応する配列でスコアを返します。

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

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

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

[___] = semanticseg(___,Name=Value) は、前の構文にある引数の任意の組み合わせに加えて、名前と値の引数を 1 つ以上使用してオプションを指定します。たとえば、ExecutionEnvironment = "gpu" は、イメージを処理するためのハードウェア リソースを gpu に設定します。

例

セマンティック イメージ セグメンテーション

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

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

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'            2-D Convolution              64 3x3x1 convolutions with stride [1  1] and padding [1  1  1  1]
     3   'relu_1'            ReLU                         ReLU
     4   'maxpool'           2-D Max Pooling              2x2 max pooling with stride [2  2] and padding [0  0  0  0]
     5   'conv_2'            2-D Convolution              64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]
     6   'relu_2'            ReLU                         ReLU
     7   'transposed-conv'   2-D Transposed Convolution   64 4x4x64 transposed convolutions with stride [2  2] and cropping [1  1  1  1]
     8   'conv_3'            2-D 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,'MiniBatchSize',32);

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

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
                              }
                     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 損失を使用するカスタム ピクセル分類層の定義

この例では、Tversky 損失を使用するカスタム ピクセル分類層を定義および作成する方法を説明します。

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

Tversky 損失

Tversky 損失は、セグメント化された 2 つのイメージの間のオーバーラップを測定する Tversky 指数に基づきます [1]。1 つのイメージ $\mathit{Y}$ と対応するグラウンド トゥルース $\mathit{T}$ の間の Tversky 指数 ${\mathrm{TI}}_{\mathit{c}}$ は、次のようになります。

${\mathrm{TI}}_{\mathit{c}}=\frac{{\sum }_{\mathit{m}=1}^{\mathit{M}}{\mathit{Y}}_{\mathrm{cm}}{\mathit{T}}_{\mathrm{cm}}}{{\sum }_{\mathit{m}=1}^{\mathit{M}}{\mathit{Y}}_{\mathrm{cm}}{\mathit{T}}_{\mathrm{cm}}+\alpha {\sum }_{\mathit{m}=1}^{\mathit{M}}{\mathit{Y}}_{\mathrm{cm}}{\mathit{T}}_{\bar{\mathrm{c}}\mathit{m}}+\beta {\sum }_{\mathit{m}=1}^{\mathit{M}}{\mathit{Y}}_{\bar{\mathrm{c}}\mathit{m}}{\mathit{T}}_{\mathrm{cm}}}$

• $\mathit{c}$ はクラスに対応し、$\bar{\mathit{c}}$ はクラス $\mathit{c}$ 以外に対応します。

• $\mathit{M}$ は、$\mathit{Y}$ の最初の 2 つの次元に沿った要素の数です。

• $\alpha$ と $\beta$ は、各クラス偽陽性と偽陰性の損失に対する寄与を制御する重み係数です。

クラス数 $\mathit{C}$ に対する損失 $\mathit{L}$ は、次のようになります。

$$\mathit{L}=\sum _{\mathit{c}=1}^{\mathit{C}}1-{\mathrm{TI}}_{\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

層のプロパティの宣言

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

• 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 セクションを省略できます。

Tversky 損失には、ゼロ除算を防止するために小さい定数値が必要です。プロパティ Epsilon を指定して、この値を保持します。2 つの可変プロパティ 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 プロパティを割り当てるオプションの入力引数 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 は、H x W x K x N の 4 次元配列です。K はクラスの数、N はミニバッチ サイズです。

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

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 互換性

tverskyPixelClassificationLayer の forwardLoss で使用する MATLAB 関数はすべて、gpuArray 入力をサポートしているため、層は GPU 互換です。

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

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

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

checkLayer (Deep Learning Toolbox) を使用して、層の有効性をチェックします。層への典型的な入力における 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.
 
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.8244 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)];

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

データストア combine を使用してイメージとピクセル ラベル データを関連付けます。

ds = combine(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:02 |       50.32% |       1.2933 |          0.0010 |
|      13 |          50 |       00:00:28 |       98.83% |       0.0990 |          0.0010 |
|      25 |         100 |       00:00:50 |       99.32% |       0.0550 |          0.0005 |
|      38 |         150 |       00:01:11 |       99.38% |       0.0461 |          0.0005 |
|      50 |         200 |       00:01:33 |       99.48% |       0.0397 |          0.0003 |
|      63 |         250 |       00:01:54 |       99.47% |       0.0380 |          0.0001 |
|      75 |         300 |       00:02:14 |       99.54% |       0.0344 |          0.0001 |
|      88 |         350 |       00:02:35 |       99.51% |       0.0352 |      6.2500e-05 |
|     100 |         400 |       00:02:53 |       99.56% |       0.0330 |      6.2500e-05 |
|========================================================================================|
Training finished: Max epochs completed.

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

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

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

参考文献

[1] 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.

膨張畳み込みを使用したセマンティック セグメンテーション

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

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

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

学習データの読み込み

例では、説明のために 32 x 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: {}

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

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

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

ds = combine(imdsTrain,pxdsTrain);
tbl = countEachLabel(pxdsTrain)

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(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:01 |       91.62% |       1.6825 |          0.0010 |
|      17 |          50 |       00:00:16 |       88.56% |       0.2393 |          0.0010 |
|      34 |         100 |       00:00:30 |       92.08% |       0.1672 |          0.0010 |
|      50 |         150 |       00:00:42 |       93.17% |       0.1472 |          0.0010 |
|      67 |         200 |       00:00:54 |       94.15% |       0.1313 |          0.0010 |
|      84 |         250 |       00:01:13 |       94.47% |       0.1167 |          0.0010 |
|     100 |         300 |       00:01:32 |       95.04% |       0.1100 |          0.0010 |
|========================================================================================|
Training finished: Max epochs completed.

ネットワークのテスト

テスト データを読み込みます。イメージの 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)

入力引数

I — 入力イメージ

数値配列

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

イメージ タイプ	データ形式
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) にすることができます (Parallel Computing Toolbox™ が必要)。

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

network — ネットワーク

SeriesNetwork オブジェクト | DAGNetwork オブジェクト | dlnetwork オブジェクト | taylorPrunableNetwork オブジェクト

ネットワーク。SeriesNetwork (Deep Learning Toolbox) オブジェクト、DAGNetwork (Deep Learning Toolbox) オブジェクト、dlnetwork (Deep Learning Toolbox) オブジェクト、または taylorPrunableNetwork (Deep Learning Toolbox) オブジェクトとして指定します。

roi — 関心領域

4 要素の数値ベクトル | 6 要素ベクトル

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

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

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

ds — イメージ コレクション

データストア オブジェクト

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

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

名前と値の引数

オプションの引数のペアを Name1=Value1,...,NameN=ValueN として指定します。ここで、Name は引数名で、Value は対応する値です。名前と値の引数は他の引数の後に指定しなければなりませんが、ペアの順序は重要ではありません。

例: ExecutionEnvironment="gpu" は、イメージを処理するためのハードウェア リソースを "gpu" に設定します。

R2021a より前では、コンマを使用して名前と値をそれぞれ区切り、Name を引用符で囲みます。

OutputType — 返されるセグメンテーションのタイプ

"categorical" (既定値) | "double" | "uint8"

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

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

MiniBatchSize — イメージのグループ

128 (既定値) | 整数

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

ExecutionEnvironment — ハードウェア リソース

"auto" (既定値) | "gpu" | "cpu"

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

ExecutionEnvironment	説明
"auto"	利用可能な場合、GPU を使用します。そうでない場合、CPU を使用します。GPU を使用すには、Parallel Computing Toolbox および CUDA® 対応 NVIDIA® GPU が必要です。サポートされる Compute Capability の詳細については、GPU 計算の要件 (Parallel Computing Toolbox)を参照してください。
"gpu"	GPU を使用します。適切な GPU が利用できない場合、関数はエラー メッセージを返します。
"cpu"	CPU を使用します。

Acceleration — パフォーマンスの最適化

"auto" (既定値) | "mex" | "none"

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

Acceleration	説明
"auto"	入力ネットワークとハードウェア リソースに適した最適化の回数を自動的に適用します。
"mex"	MEX 関数をコンパイルして実行します。このオプションは GPU の使用時にのみ利用できます。また、C/C++ コンパイラがインストールされていなければなりません。設定手順については、MEX の設定 (GPU Coder)を参照してください。
"none"	すべての高速化を無効にします。

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

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

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

"mex" オプションは、GPU の使用時にのみ利用できます。GPU を使用するには、Parallel Computing Toolbox および CUDA 対応 NVIDIA GPU が必要です。サポートされる Compute Capability の詳細については、GPU 計算の要件 (Parallel Computing Toolbox)を参照してください。Parallel Computing Toolbox または適切な GPU が利用できない場合、関数はエラーを返します。

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

Classes — ピクセルまたはボクセルが分類されるクラス

"auto" (既定値) | 文字ベクトルの cell 配列 | string ベクトル | categorical ベクトル

ピクセルまたはボクセルが分類されるクラス。"auto"、文字ベクトルの cell 配列、string ベクトル、または categorical ベクトルとして指定します。値が categorical ベクトル Y の場合、ベクトルの要素は categories(Y) に従って並べ替えられ、順序付けられます。

ネットワークが dlnetwork (Deep Learning Toolbox) オブジェクトの場合、'Classes' で指定するクラスの数が、ネットワーク予測の出力チャネル数と一致しなければなりません。既定では、'Classes' の値が "auto" の場合、クラスには 1 から C までの番号が付けられます。ここで、C はネットワークの出力層のチャネル数です。

ネットワークが SeriesNetwork (Deep Learning Toolbox) または DAGNetwork (Deep Learning Toolbox) オブジェクトの場合、名前と値の引数 Classes で指定するクラスの数が、分類出力レイヤーのクラス数と一致しなければなりません。既定では、Classes の値が "auto" の場合、クラスは分類出力層を使用して自動的に設定されます。

WriteLocation — フォルダーの場所

pwd (現在の作業フォルダー) (既定値) | string スカラー | 文字ベクトル

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

このプロパティは、イメージを処理できるデータストアを使用している場合にのみ適用されます。

NamePrefix — 出力ファイル名に適用する接頭辞

"pixelLabel" (既定値) | string スカラー | 文字ベクトル

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

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

このプロパティは、イメージを処理できるデータストアを使用している場合にのみ適用されます。

OutputFolderName — 出力フォルダー名

"semanticsegOutput" (既定値) | string スカラー | 文字ベクトル

セグメンテーション結果の出力フォルダー名。string スカラーまたは文字ベクトルとして指定します。このフォルダーは、名前と値の引数 WriteLocation の値で指定された場所にあります。

出力フォルダーが既に存在する場合、関数は名前の末尾に string "_1" を追加した新しいフォルダーを作成します。OutputFoldername を "" に設定すると、WriteLocation で指定されたフォルダーにすべての結果を書き込みます。

NameSuffix — 出力イメージ ファイル名に追加する接尾辞

string スカラー | 文字ベクトル

出力イメージ ファイル名に追加する接尾辞。string スカラーまたは文字ベクトルとして指定します。関数は、指定された接尾辞を次のように出力ファイル名に追加します。

• <prefix>_<N><suffix>.png。N は入力イメージ ファイルのインデックス imds.Files(N) に対応します。

接尾辞を指定しない場合、関数は入力ファイル名を出力ファイルの接尾辞として使用します。関数は、データストアのオブジェクト関数 read の info 出力から入力ファイル名を抽出します。データストアがファイル名を提供しない場合、関数は接尾辞を追加しません。

Verbose — 進行状況の表示

false または 0 (既定値) | true または 1

進行状況の表示。logical の 0 (false) または 1 (true) として指定します。進行状況を表示するには、Verbose を true に指定します。このプロパティは、イメージを処理できるデータストアを使用している場合にのみ適用されます。

UseParallel — 並列計算の実行

"false" (既定値) | true

並列計算の実行。"true" または "false" として指定します。

並列実行するには、'UseParallel' を true に設定するか、Computer Vision Toolbox™ の基本設定を使用して既定でこれを有効にします。

詳細については、Parallel Computing Toolbox のサポートを参照してください。

出力引数

C — カテゴリカル ラベル

categorical 配列

カテゴリカル ラベル。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) に割り当てられたカテゴリカル ラベルです。

score — 信頼度スコア

数値配列

C 内の各カテゴリカル ラベルの信頼度スコア。0 ～ 1 の値の配列として返されます。このスコアは、予測されるラベル 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) の分類スコアです。

allScores — すべてのラベル カテゴリのスコア

数値配列

入力ネットワークが分類できるすべてのラベル カテゴリのスコア。数値配列として返されます。次の表で配列の形式について説明します。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 番目のラベルのスコアです。

pxds — セマンティック セグメンテーションの結果

PixelLabelDatastore オブジェクト

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

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

拡張機能

自動並列サポート

Parallel Computing Toolbox™ を使用して自動的に並列計算を実行することで、コードを高速化します。

並列実行するには、'UseParallel' を true に設定するか、Computer Vision Toolbox の基本設定を使用して既定でこれを有効にします。

詳細については、Parallel Computing Toolbox のサポートを参照してください。

バージョン履歴

R2017b で導入

R2023a: 出力ファイルの場所

関数 semanticseg は、出力ファイルを、名前と値の引数 WriteLocation と OutputFolderName で指定されたフォルダー (<WriteLocation>/<OutputFolderName>) に書き込むようになりました。R2023a より前では、関数は WriteLocation で指定された場所に出力ファイルを直接書き込みました。以前のリリースと同じ結果を得るには、名前と値の引数 OutputFolderName を "" に設定します。

参考

関数

• trainNetwork (Deep Learning Toolbox) | labeloverlay | evaluateSemanticSegmentation

アプリ

• イメージ ラベラー | ビデオ ラベラー

オブジェクト

• ImageDatastore | pixelLabelDatastore | dlnetwork (Deep Learning Toolbox)

トピック

• 深層学習を使用したセマンティック セグメンテーション入門
• MATLAB による深層学習 (Deep Learning Toolbox)
• 深層学習用のデータストア (Deep Learning Toolbox)

外部の Web サイト

• セマンティック セグメンテーションとは