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 に設定します。

例

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

テスト イメージのセマンティック セグメンテーションを実行し、結果を表示します。

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

load("triangleSegmentationNetwork")

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

net.Layers

ans = 
  9x1 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

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

I = imread("triangleTest.jpg");
imshow(I)

ネットワークに学習させた 2 つのクラスを定義し、セマンティック イメージ セグメンテーションを実行します。

classNames = ["triangle" "background"];
[C,scores] = semanticseg(I,net,Classes=classNames,MiniBatchSize=32);

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

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

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

imagesc(scores)
axis square
colorbar

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

BW = C=="triangle";
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,Classes=classNames, ...
    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.99074          0.99183       0.91118      0.98299        0.80563  

metrics = 
  semanticSegmentationMetrics with properties:

              ConfusionMatrix: [2x2 table]
    NormalizedConfusionMatrix: [2x2 table]
               DataSetMetrics: [1x5 table]
                 ClassMetrics: [2x3 table]
                 ImageMetrics: [100x5 table]

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

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

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

Deeplab v3+ [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: {200×1 cell}
                  ClassNames: {2×1 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 = dlarray(1 ./ frequency,"C");

入力サイズが入力イメージのサイズに対応するイメージ入力層を使用して、ピクセル分類用ネットワークを作成します。次に、畳み込み層、バッチ正規化層、および ReLU 層の 3 つのブロックを指定します。各畳み込み層で、膨張係数を増加させながら 3 行 3 列のフィルターを 32 個指定します。また、名前と値の引数 Padding を "same" として設定して、出力と同じサイズになるように入力をパディングします。ピクセルを分類するには K 個の 1 行 1 列の畳み込みを使用する畳み込み層を含め (K はクラスの数)、その後にソフトマックス層を含めます。ピクセルの分類は、組み込みトレーナー trainnet 内で、カスタム モデル損失を使用して行われます。

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

モデル損失関数

セマンティック セグメンテーション ネットワークには、さまざまな損失関数を使用して学習させることができます。組み込みトレーナーtrainnet (Deep Learning Toolbox)は、カスタム損失関数だけでなく、"crossentropy" や "mse" などのいくつかの標準損失関数もサポートしています。カスタム損失関数では、ネットワークの予測を実際のグラウンド トゥルースまたはターゲット値と比較することにより、学習データの各バッチの損失を手動で計算します。カスタム損失関数は、関数構文 loss = f(Y1,...,Yn,T1,...,Tm) をもつ関数ハンドルを使用します。ここで、Y1,...,Yn は、n 個のネットワーク予測に対応する dlarray オブジェクトであり、T1,...,Tm は、m 個のターゲットに対応する dlarray オブジェクトです。

この例では、データに見られるクラスの不均衡を考慮する 2 つの異なる損失関数のいずれかを選択できます。その損失関数は次のとおりです。

1. 関数crossentropy (Deep Learning Toolbox)を使用する加重クロスエントロピー損失。加重クロスエントロピー損失では、学習中にそのクラスの誤差をスケーリングすることにより、少数しか存在しないクラスにも比重を置きます。

2. Tversky 損失 [2] を計算するカスタム損失関数 tverskyLoss。Tversky 損失は、クラスの不均衡に特化した損失です。

Tversky 損失は、セグメント化された 2 つのイメージの間のオーバーラップを測定する Tversky 指数に基づいています。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}}$$

学習の際に使用する損失関数を選択します。

lossFunction = "tverskyLoss"

lossFunction = 
"tverskyLoss"

if strcmp(lossFunction,"tverskyLoss")
    % Declare Tversky loss weighting coefficients for false positives and
    % false negatives. These coefficients are set and passed to the
    % training loss function using trainnet.
    alpha = 0.7;
    beta = 0.3;
    lossFcn = @(Y,T) tverskyLoss(Y,T,alpha,beta);
else
    % Use weighted cross-entropy loss during training.
    lossFcn = @(Y,T) crossentropy(Y,T,classWeights,NormalizationFactor="all-elements");
end

ネットワークの学習

学習オプションを指定します。

options = trainingOptions("sgdm",...
    MaxEpochs=100,...
    MiniBatchSize= 64,... 
    InitialLearnRate=1e-2,...
    Verbose=false);

trainnet (Deep Learning Toolbox)を使用してネットワークに学習させます。損失を損失関数 lossFcn として指定します。

net = trainnet(ds,layers,lossFcn,options);

ネットワークのテスト

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

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

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

pxdsPred = semanticseg(imdsTest,net,...
    Classes=classNames,...
    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.99674          0.98562       0.96447      0.99362        0.92831  

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

テスト イメージ triangleTest.jpg を読み取り、semanticseg を使用してテスト イメージをセグメント化します。labeloverlay を使用して結果を表示します。

imgTest = imread("triangleTest.jpg");
[C,scores] = semanticseg(imgTest,net,classes=classNames);

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

サポート関数

function loss = tverskyLoss(Y,T,alpha,beta)
    % loss = tverskyLoss(Y,T,alpha,beta) 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); 
    
    epsilon = 1e-8;
    numer = TP + epsilon;
    denom = TP + alpha*FP + beta*FN + 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

参考文献

[1] Chen, Liang-Chieh et al. "Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation." ECCV (2018).

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

入力引数

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 — ネットワーク

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

ネットワーク。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 で導入

R2024a: DAGNetwork オブジェクトおよび SeriesNetwork オブジェクトは非推奨

R2024a 以降、DAGNetwork (Deep Learning Toolbox) オブジェクトおよび SeriesNetwork (Deep Learning Toolbox) オブジェクトは非推奨となりました。代わりに、セマンティック セグメンテーション ネットワークを dlnetwork (Deep Learning Toolbox) オブジェクトとして指定します。

DAGNetwork オブジェクトおよび SeriesNetwork オブジェクトのサポートを削除する予定はありません。ただし、dlnetwork オブジェクトには次の利点があります。

• dlnetwork オブジェクトは、関数 trainnet (Deep Learning Toolbox) を使用して簡単に学習させたり、外部のプラットフォームからインポートしたりできる、さまざまなネットワーク アーキテクチャをサポートしています。

• dlnetwork オブジェクトの方が柔軟です。このオブジェクトは、Deep Learning Toolbox™ の現在の機能や今後導入される機能をより幅広くサポートします。

• dlnetwork オブジェクトは、ネットワークの構築、予測、組み込み学習、圧縮、およびカスタム学習ループをサポートする統合されたデータ型を提供します。

• dlnetwork を使用した学習と予測は、通常、DAGNetwork と SeriesNetwork を使用した学習と予測よりも高速です。

R2023a: 出力ファイルの場所

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

参考

アプリ

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

関数

• trainnet (Deep Learning Toolbox) | labeloverlay | evaluateSemanticSegmentation

オブジェクト

• ImageDatastore | pixelLabelDatastore | dlnetwork (Deep Learning Toolbox)

トピック

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

外部の Web サイト

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