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

この例では次を使用します。

この例では、セマンティックセグメンテーションネットワークを使用してイメージをセグメント化する方法を説明します。

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

この例では、まず、事前学習済みの Deeplab v3+ [1] ネットワークを使用してイメージをセグメント化する方法を説明します。これは、畳み込みニューラルネットワーク (CNN) の一種で、セマンティックイメージセグメンテーション用に設計されています。他のタイプのセマンティックセグメンテーションネットワークには、完全畳み込みネットワーク (FCN)、SegNet、U-Net などがあります。または、データセットをダウンロードし、転移学習を使用して Deeplab v3 ネットワークに学習させることもできます。ここで示す学習手順は、他のタイプのセマンティックセグメンテーションネットワークにも適用することができます。

この例では、学習手順を説明するため、University of Cambridge の CamVid データセット [2] を使用します。このデータセットは、運転中に得られた路上レベルでのビューが含まれるイメージコレクションです。データセットは、車、歩行者、道路を含む 32 個のセマンティッククラスについてピクセルレベルのラベルを提供します。

この例を実行するには、CUDA 対応 NVIDIA™ GPU の使用が強く推奨されます。GPU を使用するには Parallel Computing Toolbox™ が必要です。サポートされる Compute Capability の詳細については、GPU 計算の要件 (Parallel Computing Toolbox)を参照してください。

事前学習済みのセマンティックセグメンテーションネットワークのダウンロード

CamVid データセットで学習させた事前学習済みのバージョンの DeepLab v3+ をダウンロードします。

pretrainedURL = 'https://ssd.mathworks.com/supportfiles/vision/data/deeplabv3plusResnet18CamVid.zip';
pretrainedFolder = fullfile(tempdir,'pretrainedNetwork');
pretrainedNetworkZip = fullfile(pretrainedFolder,'deeplabv3plusResnet18CamVid.zip'); 
if ~exist(pretrainedNetworkZip,'file')
    mkdir(pretrainedFolder);
    disp('Downloading pretrained network (58 MB)...');
    websave(pretrainedNetworkZip,pretrainedURL);
end
unzip(pretrainedNetworkZip, pretrainedFolder)

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

pretrainedNetwork = fullfile(pretrainedFolder,'deeplabv3plusResnet18CamVid.mat');  
data = load(pretrainedNetwork);
net = data.net;

分類用にこのネットワークに学習させたクラスをリストします。

classes = string(net.Layers(end).Classes)

classes = 11×1 string
    "Sky"
    "Building"
    "Pole"
    "Road"
    "Pavement"
    "Tree"
    "SignSymbol"
    "Fence"
    "Car"
    "Pedestrian"
    "Bicyclist"

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

分類用にこのネットワークに学習させたクラスを含むイメージを読み取ります。

I = imread('highway.png');

イメージのサイズをネットワークの入力サイズに変更します。

inputSize = net.Layers(1).InputSize;
I = imresize(I,inputSize(1:2));

関数 semanticseg と事前学習済みのネットワークを使用して、セマンティックセグメンテーションを実行します。

C = semanticseg(I,net);

labeloverlay を使用して、セグメント化の結果をイメージに重ね合わせます。オーバーレイのカラーマップを、CamVid データセット [2] で定義されたカラーマップの値に設定します。

cmap = camvidColorMap;
B = labeloverlay(I,C,'Colormap',cmap,'Transparency',0.4);
figure
imshow(B)
pixelLabelColorbar(cmap, classes);

このネットワークは、市街地の走行イメージで事前学習されていますが、ハイウェイの走行シーンでも妥当な結果を生成します。セグメント化の結果を改善するには、ハイウェイの走行シーンを含む追加のイメージでネットワークに再学習させる必要があります。この例の残りの部分では、転移学習を使用してセマンティックセグメンテーションネットワークの学習を行う方法を説明します。

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

この例では、事前学習済みの ResNet-18 ネットワークから、重みが初期化された Deeplab v3+ ネットワークに学習させます。ResNet-18 は、処理するリソースが限られている用途に非常に適した効率的なネットワークです。用途の要件によって、MobileNet v2 や ResNet-50 など、その他の事前学習済みのネットワークも使用できます。詳細については、事前学習済みの深層ニューラルネットワークを参照してください。

事前学習済みの Resnet-18 を入手するには、resnet18をインストールします。インストールが完了したら、次のコードを実行して正しくインストールされていることを確認します。

resnet18();

CamVid データセットのダウンロード

次の URL から CamVid データセットをダウンロードします。

imageURL = 'http://web4.cs.ucl.ac.uk/staff/g.brostow/MotionSegRecData/files/701_StillsRaw_full.zip';
labelURL = 'http://web4.cs.ucl.ac.uk/staff/g.brostow/MotionSegRecData/data/LabeledApproved_full.zip';
 
outputFolder = fullfile(tempdir,'CamVid'); 
labelsZip = fullfile(outputFolder,'labels.zip');
imagesZip = fullfile(outputFolder,'images.zip');

if ~exist(labelsZip, 'file') || ~exist(imagesZip,'file')   
    mkdir(outputFolder)
       
    disp('Downloading 16 MB CamVid dataset labels...'); 
    websave(labelsZip, labelURL);
    unzip(labelsZip, fullfile(outputFolder,'labels'));
    
    disp('Downloading 557 MB CamVid dataset images...');  
    websave(imagesZip, imageURL);       
    unzip(imagesZip, fullfile(outputFolder,'images'));    
end

メモ: データのダウンロードにかかる時間はインターネット接続の速度によって異なります。上記で使用したコマンドは、ダウンロードが完了するまで MATLAB をブロックします。別の方法として、Web ブラウザーを使用して、データセットをローカルディスクにまずダウンロードしておくことができます。Web からダウンロードしたファイルを使用するには、上記の変数 outputFolder の値を、ダウンロードしたファイルの場所に変更します。

CamVid イメージの読み込み

imageDatastore を使用して CamVid イメージを読み込みます。imageDatastore は、ディスク上の大規模なイメージコレクションを効率的に読み込むことができます。

imgDir = fullfile(outputFolder,'images','701_StillsRaw_full');
imds = imageDatastore(imgDir);

イメージのうちの 1 つを表示します。

I = readimage(imds,559);
I = histeq(I);
imshow(I)

CamVid のピクセルラベル付きイメージの読み込み

pixelLabelDatastore (Computer Vision Toolbox) を使用して、CamVid のピクセルラベルイメージデータを読み込みます。pixelLabelDatastore は、ピクセルラベルデータとラベル ID をクラス名のマッピングにカプセル化します。

学習を容易にするために、CamVid の元の 32 個のクラスを 11 個のクラスにグループ化します。

classes = [
    "Sky"
    "Building"
    "Pole"
    "Road"
    "Pavement"
    "Tree"
    "SignSymbol"
    "Fence"
    "Car"
    "Pedestrian"
    "Bicyclist"
    ];

32 個のクラスを 11 個に減らすには、元のデータセットの複数のクラスをグループとしてまとめます。たとえば、"Car"、"SUVPickupTruck"、"Truck_Bus"、"Train"、および "OtherMoving" を組み合わせたものを "Car" とします。この例の最後にリストされているサポート関数 camvidPixelLabelIDs を使用することで、グループ化されたラベル ID が返されます。

labelIDs = camvidPixelLabelIDs();

クラスとラベル ID を使用して pixelLabelDatastore. を作成します。

labelDir = fullfile(outputFolder,'labels');
pxds = pixelLabelDatastore(labelDir,classes,labelIDs);

イメージの上に重ね合わせることで、ピクセルラベル付きイメージのうちの 1 つを読み取って表示します。

C = readimage(pxds,559);
cmap = camvidColorMap;
B = labeloverlay(I,C,'ColorMap',cmap);
imshow(B)
pixelLabelColorbar(cmap,classes);

色の重ね合わせが存在しない領域にはピクセルラベルはなく、学習中は使用されません。

データセット統計の解析

CamVid データセット内のクラスラベルの分布を表示するには、countEachLabel (Computer Vision Toolbox) を使用します。この関数は、クラスラベル別にピクセルの数をカウントします。

tbl = countEachLabel(pxds)

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

    {'Sky'       }    7.6801e+07      4.8315e+08   
    {'Building'  }    1.1737e+08      4.8315e+08   
    {'Pole'      }    4.7987e+06      4.8315e+08   
    {'Road'      }    1.4054e+08      4.8453e+08   
    {'Pavement'  }    3.3614e+07      4.7209e+08   
    {'Tree'      }    5.4259e+07       4.479e+08   
    {'SignSymbol'}    5.2242e+06      4.6863e+08   
    {'Fence'     }    6.9211e+06       2.516e+08   
    {'Car'       }    2.4437e+07      4.8315e+08   
    {'Pedestrian'}    3.4029e+06      4.4444e+08   
    {'Bicyclist' }    2.5912e+06      2.6196e+08

ピクセル数をクラス別に可視化します。

frequency = tbl.PixelCount/sum(tbl.PixelCount);

bar(1:numel(classes),frequency)
xticks(1:numel(classes)) 
xticklabels(tbl.Name)
xtickangle(45)
ylabel('Frequency')

観測値の数がすべてのクラスで等しいことが理想的です。しかし、CamVid 内のクラスは不均衡です。これは、路上シーンの自動車データセットに共通する問題です。こうしたシーンには、歩行者や自転車運転者のピクセルよりも多くの空、建物、および道路のピクセルが含まれます。これは、空、建物、および道路がイメージ内でより広い領域を占めているためです。学習では上位クラスを優先してバイアスがかけられるため、正しく処理されていない場合は、こうした不均衡が学習プロセスに悪影響を及ぼす可能性があります。この例の後半では、クラスの重み付けを使用してこの問題に対処します。

CamVid データセット内のイメージのサイズは 720 × 960 です。イメージサイズは、12 GB のメモリ搭載の NVIDIA™ Titan X での学習時に、イメージの十分な大きさのバッチがメモリに収まるように選択されます。GPU に十分なメモリがない場合には、イメージをより小さいサイズに変更するか、学習バッチのサイズを小さくする必要があります。

学習セット、検証セット、およびテストセットの準備

Deeplab v3+ の学習には、データセットのイメージの 60% が使用されます。残りのイメージは均等に 20% ずつに分割され、検証とテストにそれぞれ 20% が使用されます。次のコードでは、イメージとピクセルラベルデータを学習セット、検証セット、およびテストセットに無作為に分割します。

[imdsTrain, imdsVal, imdsTest, pxdsTrain, pxdsVal, pxdsTest] = partitionCamVidData(imds,pxds);

60 対 20 対 20 に分割すると、学習イメージ、検証イメージ、およびテストイメージの数が次のようになります。

numTrainingImages = numel(imdsTrain.Files)

numTrainingImages = 421

numValImages = numel(imdsVal.Files)

numValImages = 140

numTestingImages = numel(imdsTest.Files)

numTestingImages = 140

ネットワークの作成

関数 deeplabv3plusLayers を使用して、ResNet-18 に基づいて DeepLab v3+ ネットワークを作成します。用途に最適なネットワークを選択することは、経験的解析が必要であり、別のレベルのハイパーパラメーター調整です。たとえば、ResNet-50 や MobileNet v2 などの異なる基本ネットワークで試すか、または SegNet、完全畳み込みネットワーク (FCN)、U-Net などの他のセマンティックセグメンテーションネットワークアーキテクチャを試すことができます。

% Specify the network image size. This is typically the same as the traing image sizes.
imageSize = [720 960 3];

% Specify the number of classes.
numClasses = numel(classes);

% Create DeepLab v3+.
lgraph = deeplabv3plusLayers(imageSize, numClasses, "resnet18");

クラスの重み付けを使用したクラスのバランス調整

前に示したように、CamVid 内のクラスはバランスがとれていません。学習を改善するために、クラスの重み付けを使用してクラスのバランスを調整することができます。前に countEachLabel (Computer Vision Toolbox) を使用して計算したピクセルラベルのカウントを使用して、中央頻度クラスの重みを計算します。

imageFreq = tbl.PixelCount ./ tbl.ImagePixelCount;
classWeights = median(imageFreq) ./ imageFreq

classWeights = 11×1

    0.3182
    0.2082
    5.0924
    0.1744
    0.7103
    0.4175
    4.5371
    1.8386
    1.0000
    6.6059
      ⋮

pixelClassificationLayer (Computer Vision Toolbox) を使用してクラスの重みを指定します。

pxLayer = pixelClassificationLayer('Name','labels','Classes',tbl.Name,'ClassWeights',classWeights);
lgraph = replaceLayer(lgraph,"classification",pxLayer);

学習オプションの選択

学習に使用される最適化アルゴリズムはモーメンタム項付き確率的勾配降下法 (SGDM) です。trainingOptions を使用して、SGDM に使用されるハイパーパラメーターを指定します。

% Define validation data.
dsVal = combine(imdsVal,pxdsVal);

% Define training options. 
options = trainingOptions('sgdm', ...
    'LearnRateSchedule','piecewise',...
    'LearnRateDropPeriod',10,...
    'LearnRateDropFactor',0.3,...
    'Momentum',0.9, ...
    'InitialLearnRate',1e-3, ...
    'L2Regularization',0.005, ...
    'ValidationData',dsVal,...
    'MaxEpochs',30, ...  
    'MiniBatchSize',8, ...
    'Shuffle','every-epoch', ...
    'CheckpointPath', tempdir, ...
    'VerboseFrequency',2,...
    'Plots','training-progress',...
    'ValidationPatience', 4);

学習率には区分的なスケジュールが使用されます。学習率は 10 エポックごとに 0.3 ずつ減少します。これにより、ネットワークはより高い初期学習率で高速に学習することができる一方で、学習率が低下すると、局所的最適値に近い解を求めることができます。

'ValidationData' パラメーターを設定することによって、すべてのエポックで検証データに対してネットワークのテストが行われます。'ValidationPatience' は 4 に設定されており、検証精度が収束すると学習が早期に停止します。これにより、学習データセットに対するネットワークの過適合を防ぎます。

ミニバッチのサイズ 8 を使用して、学習中のメモリ使用量を削減します。この値は、システムに搭載されている GPU メモリの量に応じて増減させることができます。

また、'CheckpointPath' は一時的な場所に設定されています。この名前と値のペアを設定すると、各学習エポックの終わりにネットワークチェックポイントを保存できます。システム障害や停電で学習が中断された場合に、保存したチェックポイントから学習を再開できます。'CheckpointPath' で指定された場所に、ネットワークチェックポイントを保存するのに十分なスペースがあることを確認します。たとえば、100 個の Deeplab v3+ チェックポイントを保存する場合、各チェックポイントが 61 MB であるため、約 6 GB のディスク領域が必要です。

データ拡張

データ拡張は、学習中に元のデータをランダムに変換してネットワークの精度を高めるために使用されます。データ拡張を使用すると、ラベル付き学習サンプルの数を増やさずに、学習データをさらに多様化させることができます。イメージとピクセルラベルデータの両方に同じランダム変換を適用するには、データストアに combine と transform を使用します。まず、imdsTrain と pxdsTrain を統合します。

dsTrain = combine(imdsTrain, pxdsTrain);

次に、データストアに transform を使用して、サポート関数 augmentImageAndLabel で定義されている目的のデータ拡張を適用します。ここでは、データ拡張に対して +/- 10 ピクセルのランダムな左/右反射とランダムな X/Y 平行移動が使用されます。

xTrans = [-10 10];
yTrans = [-10 10];
dsTrain = transform(dsTrain, @(data)augmentImageAndLabel(data,xTrans,yTrans));

データ拡張は、テストデータと検証データには適用されないことに注意してください。理想的には、テストデータと検証データは元のデータを代表するもので、バイアスのない評価を行うために変更なしで使用されなければなりません。

学習の開始

doTraining フラグが true の場合、trainNetwork を使用して学習を開始します。そうでない場合は、事前学習済みのネットワークを読み込みます。

メモ: この学習は、12 GB の GPU メモリ搭載の NVIDIA™ Titan X で検証済みです。GPU のメモリがこれより少ない場合、学習時にメモリ不足が発生する可能性があります。これが発生する場合は、trainingOptions の 'MiniBatchSize' を 1 に設定するか、ネットワーク入力を減らして学習データのサイズを変更してみてください。このネットワークに学習させるには、約 70 分かかります。GPU ハードウェアによっては、さらに時間がかかる場合があります。

doTraining = false;
if doTraining    
    [net, info] = trainNetwork(dsTrain,lgraph,options);
end

1 つのイメージを使用したネットワークテスト

迅速な正常性チェックとして、1 つのテストイメージ上で学習済みのネットワークを実行します。

I = readimage(imdsTest,35);
C = semanticseg(I, net);

結果を表示します。

B = labeloverlay(I,C,'Colormap',cmap,'Transparency',0.4);
imshow(B)
pixelLabelColorbar(cmap, classes);

C での結果と、pxdsTest に格納されている予想されるグラウンドトゥルースを比較します。緑とマゼンタの領域は、セグメンテーション結果が予想されるグラウンドトゥルースと異なる領域を強調表示しています。

expectedResult = readimage(pxdsTest,35);
actual = uint8(C);
expected = uint8(expectedResult);
imshowpair(actual, expected)

視覚的には、道路、空、建物などのクラスのセマンティックセグメンテーションの結果は適切にオーバーラップしてます。しかし、歩行者や車のような小さいオブジェクトはそれほど正確ではありません。クラスごとのオーバーラップ量は、ジャカードインデックスとしても知られている Intersection over Union (IoU) メトリクスを使用して測定できます。関数jaccard (Image Processing Toolbox)を使用して IoU を測定します。

iou = jaccard(C,expectedResult);
table(classes,iou)

ans=11×2 table
      classes         iou  
    ____________    _______

    "Sky"           0.93418
    "Building"      0.86604
    "Pole"          0.37524
    "Road"          0.94517
    "Pavement"      0.85422
    "Tree"          0.91563
    "SignSymbol"    0.62075
    "Fence"         0.81075
    "Car"           0.71446
    "Pedestrian"    0.37249
    "Bicyclist"     0.69775

IoU メトリクスでは視覚的な結果を確認できます。道路、空、建物クラスの IoU スコアは高く、一方で歩行者や自動車などのクラスのスコアは低くなります。その他の一般的なセグメンテーションメトリクスには、dice (Image Processing Toolbox) や bfscore (Image Processing Toolbox) の輪郭マッチングスコアなどがあります。

学習済みネットワークの評価

複数のテストイメージの精度を測定するには、テストセット全体に対して semanticseg (Computer Vision Toolbox) を実行します。ミニバッチのサイズ 4 を使用して、イメージのセグメント化中のメモリ使用量を削減します。この値は、システムに搭載されている GPU メモリの量に応じて増減させることができます。

pxdsResults = semanticseg(imdsTest,net, ...
    'MiniBatchSize',4, ...
    'WriteLocation',tempdir, ...
    'Verbose',false);

semanticseg はテストセットに対する結果を pixelLabelDatastore オブジェクトとして返します。imdsTest 内の各テストイメージの実際のピクセルラベルデータは、'WriteLocation' パラメーターで指定された場所にあるディスクに書き込まれます。evaluateSemanticSegmentation (Computer Vision Toolbox) を使用して、テストセット結果のセマンティックセグメンテーションメトリクスを測定します。

metrics = evaluateSemanticSegmentation(pxdsResults,pxdsTest,'Verbose',false);

evaluateSemanticSegmentation は、データセット全体、個々のクラス、各テストイメージに関するさまざまなメトリクスを返します。データセットレベルのメトリクスを確認するには、metrics.DataSetMetrics を検査します。

metrics.DataSetMetrics

ans=1×5 table
    GlobalAccuracy    MeanAccuracy    MeanIoU    WeightedIoU    MeanBFScore
    ______________    ____________    _______    ___________    ___________

       0.89244           0.8657       0.66347      0.82837        0.69324

データセットメトリクスは、ネットワークパフォーマンスに関する大まかな概要を示します。各クラスがパフォーマンス全体に与える影響を確認するには、metrics.ClassMetrics を使用してクラスごとのメトリクスを検査します。

metrics.ClassMetrics

ans=11×3 table
                  Accuracy      IoU      MeanBFScore
                  ________    _______    ___________

    Sky           0.94272     0.90979      0.90853  
    Building      0.81488     0.79161      0.63963  
    Pole          0.75997     0.24632      0.58505  
    Road          0.93955     0.92638      0.80615  
    Pavement      0.90048     0.73874      0.74538  
    Tree          0.88173      0.7746      0.72892  
    SignSymbol    0.76491     0.42338      0.53707  
    Fence         0.83661     0.57442       0.5567  
    Car           0.92588     0.79441      0.74331  
    Pedestrian    0.86718     0.47077      0.64356  
    Bicyclist     0.88881      0.6478      0.59473

データセット全体のパフォーマンスは非常に高いですが、クラスメトリクスは、Pedestrian、Bicyclist、Car といった少数しか存在しないクラスは Road、Sky、Building などのクラスと同じようにうまくセグメント化されていないことを示しています。少数しか存在しないクラスのサンプルが多く含まれているデータが追加されることで、結果が改善する可能性があります。

サポート関数

function labelIDs = camvidPixelLabelIDs()
% Return the label IDs corresponding to each class.
%
% The CamVid dataset has 32 classes. Group them into 11 classes following
% the original SegNet training methodology [1].
%
% The 11 classes are:
%   "Sky" "Building", "Pole", "Road", "Pavement", "Tree", "SignSymbol",
%   "Fence", "Car", "Pedestrian",  and "Bicyclist".
%
% CamVid pixel label IDs are provided as RGB color values. Group them into
% 11 classes and return them as a cell array of M-by-3 matrices. The
% original CamVid class names are listed alongside each RGB value. Note
% that the Other/Void class are excluded below.
labelIDs = { ...
    
    % "Sky"
    [
    128 128 128; ... % "Sky"
    ]
    
    % "Building" 
    [
    000 128 064; ... % "Bridge"
    128 000 000; ... % "Building"
    064 192 000; ... % "Wall"
    064 000 064; ... % "Tunnel"
    192 000 128; ... % "Archway"
    ]
    
    % "Pole"
    [
    192 192 128; ... % "Column_Pole"
    000 000 064; ... % "TrafficCone"
    ]
    
    % Road
    [
    128 064 128; ... % "Road"
    128 000 192; ... % "LaneMkgsDriv"
    192 000 064; ... % "LaneMkgsNonDriv"
    ]
    
    % "Pavement"
    [
    000 000 192; ... % "Sidewalk" 
    064 192 128; ... % "ParkingBlock"
    128 128 192; ... % "RoadShoulder"
    ]
        
    % "Tree"
    [
    128 128 000; ... % "Tree"
    192 192 000; ... % "VegetationMisc"
    ]
    
    % "SignSymbol"
    [
    192 128 128; ... % "SignSymbol"
    128 128 064; ... % "Misc_Text"
    000 064 064; ... % "TrafficLight"
    ]
    
    % "Fence"
    [
    064 064 128; ... % "Fence"
    ]
    
    % "Car"
    [
    064 000 128; ... % "Car"
    064 128 192; ... % "SUVPickupTruck"
    192 128 192; ... % "Truck_Bus"
    192 064 128; ... % "Train"
    128 064 064; ... % "OtherMoving"
    ]
    
    % "Pedestrian"
    [
    064 064 000; ... % "Pedestrian"
    192 128 064; ... % "Child"
    064 000 192; ... % "CartLuggagePram"
    064 128 064; ... % "Animal"
    ]
    
    % "Bicyclist"
    [
    000 128 192; ... % "Bicyclist"
    192 000 192; ... % "MotorcycleScooter"
    ]
    
    };
end

function pixelLabelColorbar(cmap, classNames)
% Add a colorbar to the current axis. The colorbar is formatted
% to display the class names with the color.

colormap(gca,cmap)

% Add colorbar to current figure.
c = colorbar('peer', gca);

% Use class names for tick marks.
c.TickLabels = classNames;
numClasses = size(cmap,1);

% Center tick labels.
c.Ticks = 1/(numClasses*2):1/numClasses:1;

% Remove tick mark.
c.TickLength = 0;
end

function cmap = camvidColorMap()
% Define the colormap used by CamVid dataset.

cmap = [
    128 128 128   % Sky
    128 0 0       % Building
    192 192 192   % Pole
    128 64 128    % Road
    60 40 222     % Pavement
    128 128 0     % Tree
    192 128 128   % SignSymbol
    64 64 128     % Fence
    64 0 128      % Car
    64 64 0       % Pedestrian
    0 128 192     % Bicyclist
    ];

% Normalize between [0 1].
cmap = cmap ./ 255;
end

function [imdsTrain, imdsVal, imdsTest, pxdsTrain, pxdsVal, pxdsTest] = partitionCamVidData(imds,pxds)
% Partition CamVid data by randomly selecting 60% of the data for training. The
% rest is used for testing.
    
% Set initial random state for example reproducibility.
rng(0); 
numFiles = numel(imds.Files);
shuffledIndices = randperm(numFiles);

% Use 60% of the images for training.
numTrain = round(0.60 * numFiles);
trainingIdx = shuffledIndices(1:numTrain);

% Use 20% of the images for validation
numVal = round(0.20 * numFiles);
valIdx = shuffledIndices(numTrain+1:numTrain+numVal);

% Use the rest for testing.
testIdx = shuffledIndices(numTrain+numVal+1:end);

% Create image datastores for training and test.
trainingImages = imds.Files(trainingIdx);
valImages = imds.Files(valIdx);
testImages = imds.Files(testIdx);

imdsTrain = imageDatastore(trainingImages);
imdsVal = imageDatastore(valImages);
imdsTest = imageDatastore(testImages);

% Extract class and label IDs info.
classes = pxds.ClassNames;
labelIDs = camvidPixelLabelIDs();

% Create pixel label datastores for training and test.
trainingLabels = pxds.Files(trainingIdx);
valLabels = pxds.Files(valIdx);
testLabels = pxds.Files(testIdx);

pxdsTrain = pixelLabelDatastore(trainingLabels, classes, labelIDs);
pxdsVal = pixelLabelDatastore(valLabels, classes, labelIDs);
pxdsTest = pixelLabelDatastore(testLabels, classes, labelIDs);
end

function data = augmentImageAndLabel(data, xTrans, yTrans)
% Augment images and pixel label images using random reflection and
% translation.

for i = 1:size(data,1)
    
    tform = randomAffine2d(...
        'XReflection',true,...
        'XTranslation', xTrans, ...
        'YTranslation', yTrans);
    
    % Center the view at the center of image in the output space while
    % allowing translation to move the output image out of view.
    rout = affineOutputView(size(data{i,1}), tform, 'BoundsStyle', 'centerOutput');
    
    % Warp the image and pixel labels using the same transform.
    data{i,1} = imwarp(data{i,1}, tform, 'OutputView', rout);
    data{i,2} = imwarp(data{i,2}, tform, 'OutputView', rout);
    
end
end

参考文献

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

[2] Brostow, G. J., J. Fauqueur, and R. Cipolla. "Semantic object classes in video: A high-definition ground truth database." Pattern Recognition Letters. Vol. 30, Issue 2, 2009, pp 88-97.

参考

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

事前学習済みのセマンティック セグメンテーション ネットワークのダウンロード

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

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