チュートリアル: ML.NET で ONNX を使用してオブジェクトを検出する

ML.NET で事前トレーニング済みの ONNX モデルを使用して、画像内のオブジェクトを検出する方法について説明します。

物体検出モデルをゼロからトレーニングするには、何百万ものパラメーター、大量のラベル付けされたトレーニング データ、膨大な量のコンピューティング リソース (数百 GPU 時間) を設定する必要があります。 事前トレーニング済みモデルを使用すると、トレーニング プロセスをショートカットできます。

このチュートリアルでは、以下の内容を学習します。

[前提条件]

• Visual Studio 2022 以降。
• Microsoft.ML の NuGet パッケージ
• Microsoft.ML.ImageAnalytics NuGet パッケージ
• Microsoft.ML.OnnxTransformer NuGet パッケージ
• Tiny YOLOv2 事前トレーニング済みモデル
• Netron (省略可能)

ONNX オブジェクト検出サンプルの概要

このサンプルでは、事前トレーニング済みのディープ ラーニング ONNX モデルを使用して、イメージ内のオブジェクトを検出する .NET Core コンソール アプリケーションを作成します。 このサンプルのコードは、GitHub の dotnet/machinelearning-samples リポジトリ にあります。

物体検出とは

物体検出は、コンピューター ビジョンの問題です。 物体検出は画像分類と密接に関連していますが、より詳細なスケールで画像分類を実行します。 オブジェクト 検出では、 画像内のエンティティを見つけて分類します。 物体検出モデルは、一般的にディープ ラーニングとニューラル ネットワークを使用してトレーニングされます。 詳細については、 ディープ ラーニングと機械学習 を参照してください。

画像に異なる種類の複数のオブジェクトが含まれている場合は、オブジェクト検出を使用します。

オブジェクト検出のユース ケースには、次のようなものがあります。

• 自動運転車
• ロボティックス
• 顔検出
• 職場の安全
• オブジェクトのカウント
• アクティビティの認識

ディープ ラーニング モデルを選択する

ディープ ラーニングは機械学習のサブセットです。 ディープ ラーニング モデルをトレーニングするには、大量のデータが必要です。 データ内のパターンは、一連のレイヤーによって表されます。 データ内のリレーションシップは、重みを含むレイヤー間の接続としてエンコードされます。 重みが大きいほど、リレーションシップは強くなります。 総称して、この一連の層と接続は人工ニューラル ネットワークと呼ばれます。 ネットワーク内の層が多いほど"深い"ため、ディープ ニューラル ネットワークになります。

ニューラル ネットワークにはさまざまな種類があり、最も一般的なものは多層パーセプトロン (MLP)、畳み込みニューラル ネットワーク (CNN)、およびリカレント ニューラル ネットワーク (RNN) です。 最も基本的な MLP は、一連の入力を出力のセットにマップします。 このニューラル ネットワークは、データに空間または時間のコンポーネントがない場合に適しています。 CNN では、畳み込みレイヤーを使用して、データに含まれる空間情報を処理します。 CNN の適切なユース ケースは、画像の領域に特徴の存在を検出する画像処理です (画像の中央に鼻があるかなど)。 最後に、RNN を使用すると、状態またはメモリの永続化を入力として使用できます。 RNN は、イベントの順番とコンテキストが重要な時系列分析に使用されます。

モデルを理解する

物体検出は画像処理タスクです。 そのため、この問題を解決するためにトレーニングされたほとんどのディープ ラーニング モデルは CNN です。 このチュートリアルで使用されるモデルは Tiny YOLOv2 モデルです。このモデルは、ホワイト ペーパーで説明されている YOLOv2 モデルのよりコンパクトなバージョンです。 Redmon と Farhadi による"YOLO9000: Better, Faster, Stronger" です。 Tiny YOLOv2 は、Pascal VOC データセットでトレーニングされ、20 個の異なるクラスのオブジェクトを予測できる 15 個のレイヤーで構成されています。 Tiny YOLOv2 は元の YOLOv2 モデルの凝縮バージョンであるため、速度と精度の間でトレードオフが行われます。 モデルを構成するさまざまなレイヤーは、Netron などのツールを使用して視覚化できます。 モデルを検査すると、ニューラル ネットワークを構成するすべてのレイヤー間の接続のマッピングが生成されます。各レイヤーには、各レイヤーの名前と、それぞれの入力/出力のディメンションが含まれます。 モデルの入力と出力を記述するために使用されるデータ構造はテンソルと呼ばれます。 テンソルは、N 次元にデータを格納するコンテナーと考えることができます。 Tiny YOLOv2 の場合、入力レイヤーの名前は image され、 3 x 416 x 416次元のテンソルが必要です。 出力レイヤーの名前が grid され、ディメンション 125 x 13 x 13の出力テンソルが生成されます。

YOLO モデルは画像 3(RGB) x 416px x 416pxを受け取ります。 モデルはこの入力を受け取り、異なるレイヤーを通過して出力を生成します。 出力により、入力イメージが 13 x 13 グリッドに分割され、グリッド内の各セルが 125 値で構成されます。

ONNX モデルとは

Open Neural Network Exchange (ONNX) は、AI モデルのオープン ソース形式です。 ONNX では、フレームワーク間の相互運用性がサポートされています。 つまり、PyTorch などの多くの一般的な機械学習フレームワークの 1 つでモデルをトレーニングし、それを ONNX 形式に変換し、ML.NET のような別のフレームワークで ONNX モデルを使用できます。 詳細については、 ONNX の Web サイトを参照してください。

事前トレーニング済みの Tiny YOLOv2 モデルは、ONNX 形式で格納されます。これは、レイヤーのシリアル化された表現と、それらのレイヤーの学習されたパターンです。 ML.NET では、 ImageAnalytics パッケージと OnnxTransformer NuGet パッケージとの相互運用性が ONNX と実現されます。 ImageAnalytics パッケージには、画像を取得し、予測パイプラインまたはトレーニング パイプラインへの入力として使用できる数値にエンコードする一連の変換が含まれています。 OnnxTransformer パッケージでは、ONNX ランタイムを利用して ONNX モデルを読み込み、それを使用して提供された入力に基づいて予測を行います。

.NET コンソール プロジェクトを設定する

ONNX とは何か、Tiny YOLOv2 のしくみを一般的に理解したら、アプリケーションをビルドします。

コンソール アプリケーションの作成

1. "ObjectDetection" という名前の C# コンソール アプリケーション を作成します。 [ 次へ ] ボタンをクリックします。

2. 使用するフレームワークとして .NET 8 を選択します。 [作成] ボタンをクリックします。

3. Microsoft.ML NuGet パッケージをインストールします。

   注

   このサンプルでは、特に明記されていない限り、記載されている最新の安定バージョンの NuGet パッケージを使用します。

   • ソリューション エクスプローラーで、プロジェクトを右クリックし、[ NuGet パッケージの管理] を選択します。
   • パッケージ ソースとして [nuget.org] を選択し、[参照] タブを選択し、 Microsoft.ML を検索します。
   • [インストール] ボタンを選択します。
   • [変更のプレビュー] ダイアログで [OK] ボタンを選択し、表示されているパッケージのライセンス条項に同意する場合は、[ライセンスの同意] ダイアログで [同意する] ボタンを選択します。
   • Microsoft.Windows.Compatibility、Microsoft.ML.ImageAnalytics、Microsoft.ML.OnnxTransformer、Microsoft.ML.OnnxRuntime について、これらの手順を繰り返します。

データと事前トレーニング済みモデルを準備する

1. プロジェクト資産ディレクトリの zip ファイルをダウンロードし、解凍します。

2. assets ディレクトリを ObjectDetection プロジェクト ディレクトリにコピーします。 このディレクトリとそのサブディレクトリには、このチュートリアルに必要なイメージ ファイル (次の手順でダウンロードして追加する Tiny YOLOv2 モデルを除く) が含まれています。

3. ONNX Model Zoo から Tiny YOLOv2 モデルをダウンロードします。

4. model.onnx ファイルを ObjectDetection プロジェクトassets\Modelディレクトリにコピーし、名前を TinyYolo2_model.onnx に変更します。 このディレクトリには、このチュートリアルに必要なモデルが含まれています。

5. ソリューション エクスプローラーで、資産ディレクトリとサブディレクトリ内の各ファイルを右クリックし、[ プロパティ] を選択します。 [ 詳細設定] で、[ 出力ディレクトリにコピー ] の値を [新しい場合はコピー] に変更します。

クラスの作成とパスの定義

Program.cs ファイルを開き、次の追加のusing ディレクティブをファイルの先頭に追加します。

using System.Drawing;
using System.Drawing.Drawing2D;
using ObjectDetection.YoloParser;
using ObjectDetection.DataStructures;
using ObjectDetection;
using Microsoft.ML;

次に、さまざまな資産のパスを定義します。

1. まず、GetAbsolutePath下部に メソッドを作成します。

   string GetAbsolutePath(string relativePath)
   {
       FileInfo _dataRoot = new FileInfo(typeof(Program).Assembly.Location);
       string assemblyFolderPath = _dataRoot.Directory.FullName;
   
       string fullPath = Path.Combine(assemblyFolderPath, relativePath);
   
       return fullPath;
   }
   

2. 次に、 using ディレクティブの下に、資産の場所を格納するフィールドを作成します。

   var assetsRelativePath = @"../../../assets";
   string assetsPath = GetAbsolutePath(assetsRelativePath);
   var modelFilePath = Path.Combine(assetsPath, "Model", "TinyYolo2_model.onnx");
   var imagesFolder = Path.Combine(assetsPath, "images");
   var outputFolder = Path.Combine(assetsPath, "images", "output");
   

入力データと予測クラスを格納する新しいディレクトリをプロジェクトに追加します。

ソリューション エクスプローラーで、プロジェクトを右クリックし、[追加>新しいフォルダー] を選択します。 ソリューション エクスプローラーに新しいフォルダーが表示されたら、"DataStructures" という名前を付けます。

新しく作成した DataStructures ディレクトリに入力データ クラスを作成します。

1. ソリューション エクスプローラーでDataStructures ディレクトリを右クリックし、>を選択します。

2. [ 新しい項目の追加 ] ダイアログ ボックスで、[ クラス ] を選択し、[ 名前 ] フィールドを ImageNetData.csに変更します。 その後、 [追加] を選択します。

   ImageNetData.cs ファイルがコード エディターで開きます。 次の using ディレクティブを ImageNetData.csの先頭に追加します。

   using System.Collections.Generic;
   using System.IO;
   using System.Linq;
   using Microsoft.ML.Data;
   

   既存のクラス定義を削除し、 ImageNetData クラスの次のコードを ImageNetData.cs ファイルに追加します。

   public class ImageNetData
   {
       [LoadColumn(0)]
       public string ImagePath;
   
       [LoadColumn(1)]
       public string Label;
   
       public static IEnumerable<ImageNetData> ReadFromFile(string imageFolder)
       {
           return Directory
               .GetFiles(imageFolder)
               .Where(filePath => Path.GetExtension(filePath) != ".md")
               .Select(filePath => new ImageNetData { ImagePath = filePath, Label = Path.GetFileName(filePath) });
       }
   }
   

   ImageNetData は入力イメージ データ クラスであり、次の String フィールドがあります。

   • ImagePath には、イメージが格納されるパスが含まれています。
   • Label には、ファイルの名前が含まれています。

   さらに、ImageNetDataには、指定されたReadFromFile パスに格納されている複数のイメージ ファイルを読み込み、imageFolder オブジェクトのコレクションとして返すメソッド ImageNetDataが含まれています。

DataStructures ディレクトリに予測クラスを作成します。

1. ソリューション エクスプローラーでDataStructures ディレクトリを右クリックし、>を選択します。

2. [ 新しい項目の追加 ] ダイアログ ボックスで、[ クラス ] を選択し、[ 名前 ] フィールドを ImageNetPrediction.csに変更します。 その後、 [追加] を選択します。

   ImageNetPrediction.cs ファイルがコード エディターで開きます。 次の using ディレクティブを ImageNetPrediction.csの先頭に追加します。

   using Microsoft.ML.Data;
   

   既存のクラス定義を削除し、 ImageNetPrediction クラスの次のコードを ImageNetPrediction.cs ファイルに追加します。

   public class ImageNetPrediction
   {
       [ColumnName("grid")]
       public float[] PredictedLabels;
   }
   

   ImageNetPrediction は予測データ クラスであり、次の float[] フィールドがあります。

   • PredictedLabels には、画像で検出された各境界ボックスの寸法、オブジェクト性スコア、およびクラス確率が含まれます。

変数の初期化

MLContext クラスは、すべての ML.NET 操作の開始点であり、mlContextを初期化すると、モデル作成ワークフロー オブジェクト間で共有できる新しい ML.NET 環境が作成されます。 概念的には、Entity Framework の DBContext に似ています。

mlContext フィールドの下に次の行を追加して、MLContextの新しいインスタンスでoutputFolder変数を初期化します。

MLContext mlContext = new MLContext();

モデル出力を後処理するためのパーサーを作成する

モデルは、画像を 13 x 13 グリッドにセグメント化し、各グリッド セルが 32px x 32px。 各グリッド セルには、最大5つのオブジェクト境界ボックスが含まれています。 境界ボックスには 25 個の要素が包含されています。

• x 関連付けられているグリッド セルを基準とした境界ボックスの中心の x 位置。
• y 関連付けられているグリッド セルを基準とした境界ボックスの中心の y 位置。
• w 境界ボックスの幅。
• h 境界ボックスの高さ。
• o オブジェクトが境界ボックス内に存在する信頼度値 (オブジェクトネス スコアとも呼ばれます)。
• p1-p20 モデルによって予測される 20 個の各クラスのクラス確率。

合計で、5 つの境界ボックスをそれぞれ記述する 25 個の要素が、各グリッド セルに含まれる 125 個の要素を構成します。

事前トレーニング済みの ONNX モデルによって生成される出力は、次元が21125テンソルの要素を表す、長さ125 x 13 x 13の float 配列です。 モデルによって生成された予測をテンソルに変換するには、いくつかの後処理作業が必要です。 これを行うには、出力の解析に役立つクラスのセットを作成します。

新しいディレクトリをプロジェクトに追加して、パーサー クラスのセットを整理します。

1. ソリューション エクスプローラーで、プロジェクトを右クリックし、[追加>新しいフォルダー] を選択します。 ソリューション エクスプローラーに新しいフォルダーが表示されたら、"YoloParser" という名前を付けます。

境界ボックスと寸法を作成する

モデルによって出力されるデータには、画像内のオブジェクトの境界ボックスの座標と寸法が含まれています。 ディメンションの基本クラスを作成します。

1. ソリューション エクスプローラーでYoloParser ディレクトリを右クリックし、>を選択します。

2. [ 新しい項目の追加 ] ダイアログ ボックスで、[ クラス ] を選択し、[ 名前 ] フィールドを DimensionsBase.csに変更します。 その後、 [追加] を選択します。

   DimensionsBase.cs ファイルがコード エディターで開きます。 すべての using ディレクティブと既存のクラス定義を削除します。

   DimensionsBase クラスの次のコードをDimensionsBase.cs ファイルに追加します。

   public class DimensionsBase
   {
       public float X { get; set; }
       public float Y { get; set; }
       public float Height { get; set; }
       public float Width { get; set; }
   }
   

   DimensionsBase には、次の float プロパティがあります。

   • X には、x 軸に沿ったオブジェクトの位置が含まれます。
   • Y には、y 軸に沿ったオブジェクトの位置が含まれます。
   • Height には、オブジェクトの高さが含まれています。
   • Width には、オブジェクトの幅が含まれています。

次に、境界ボックスのクラスを作成します。

1. ソリューション エクスプローラーでYoloParser ディレクトリを右クリックし、>を選択します。

2. [ 新しい項目の追加 ] ダイアログ ボックスで、[ クラス ] を選択し、[ 名前 ] フィールドを YoloBoundingBox.csに変更します。 その後、 [追加] を選択します。

   YoloBoundingBox.cs ファイルがコード エディターで開きます。 次の using ディレクティブを YoloBoundingBox.csの先頭に追加します。

   using System.Drawing;
   

   既存のクラス定義のすぐ上に、BoundingBoxDimensions クラスから継承する DimensionsBase という名前の新しいクラス定義を追加して、それぞれの境界ボックスの次元を格納します。

   public class BoundingBoxDimensions : DimensionsBase { }
   

   既存の YoloBoundingBox クラス定義を削除し、 YoloBoundingBox クラスの次のコードを YoloBoundingBox.cs ファイルに追加します。

   public class YoloBoundingBox
   {
       public BoundingBoxDimensions Dimensions { get; set; }
   
       public string Label { get; set; }
   
       public float Confidence { get; set; }
   
       public RectangleF Rect
       {
           get { return new RectangleF(Dimensions.X, Dimensions.Y, Dimensions.Width, Dimensions.Height); }
       }
   
       public Color BoxColor { get; set; }
   }
   

   YoloBoundingBox には、次のプロパティがあります。

   • Dimensions には境界ボックスの寸法が含まれています。
   • Label には、境界ボックス内で検出されたオブジェクトのクラスが含まれています。
   • Confidence には、クラスの信頼度が含まれています。
   • Rect には、境界ボックスの寸法の四角形表現が含まれます。
   • BoxColor には、イメージに描画するために使用されるそれぞれのクラスに関連付けられている色が含まれています。

パーサーを作成する

ディメンションと境界ボックスのクラスが作成されたので、パーサーを作成します。

1. ソリューション エクスプローラーでYoloParser ディレクトリを右クリックし、>を選択します。

2. [ 新しい項目の追加 ] ダイアログ ボックスで、[ クラス ] を選択し、[ 名前 ] フィールドを YoloOutputParser.csに変更します。 その後、 [追加] を選択します。

   YoloOutputParser.cs ファイルがコード エディターで開きます。 YoloOutputParser.csの先頭に次のusing ディレクティブを追加します。

   using System;
   using System.Collections.Generic;
   using System.Drawing;
   using System.Linq;
   

   既存の YoloOutputParser クラス定義内に、画像内の各セルの寸法を含む入れ子になったクラスを追加します。 CellDimensions クラス定義の先頭にあるDimensionsBase クラスから継承するYoloOutputParser クラスの次のコードを追加します。

   class CellDimensions : DimensionsBase { }
   

3. YoloOutputParserクラス定義内に、次の定数とフィールドを追加します。

   public const int ROW_COUNT = 13;
   public const int COL_COUNT = 13;
   public const int CHANNEL_COUNT = 125;
   public const int BOXES_PER_CELL = 5;
   public const int BOX_INFO_FEATURE_COUNT = 5;
   public const int CLASS_COUNT = 20;
   public const float CELL_WIDTH = 32;
   public const float CELL_HEIGHT = 32;
   
   private int channelStride = ROW_COUNT * COL_COUNT;
   

   • ROW_COUNT は、画像が分割されているグリッド内の行数です。
   • COL_COUNT は、画像が分割されているグリッド内の列の数です。
   • CHANNEL_COUNT は、グリッドの 1 つのセルに含まれる値の合計数です。
   • BOXES_PER_CELL は、セル内の境界ボックスの数です。
   • BOX_INFO_FEATURE_COUNT は、ボックス内に含まれる特徴の数 (x、y、高さ、幅、信頼度) です。
   • CLASS_COUNT は、各境界ボックスに含まれるクラス予測の数です。
   • CELL_WIDTH は、イメージ グリッド内の 1 つのセルの幅です。
   • CELL_HEIGHT は、イメージ グリッド内の 1 つのセルの高さです。
   • channelStride は、グリッド内の現在のセルの開始位置です。

   モデルは、スコアリングとも呼ばれる予測を行うと、 416px x 416px 入力画像を 13 x 13のサイズのセルのグリッドに分割します。 各セルには、 32px x 32pxが含まれています。 各セル内には、それぞれ 5 つの特徴 (x、y、幅、高さ、信頼度) を含む 5 つの境界ボックスがあります。 さらに、各境界ボックスには各クラスの確率が含まれます。この場合は 20 です。 したがって、各セルには 125 個の情報 (5 つの特徴 + 20 個のクラス確率) が含まれています。

5 つの境界ボックスすべてに対して、 channelStride の下にアンカーの一覧を作成します。

private float[] anchors = new float[]
{
    1.08F, 1.19F, 3.42F, 4.41F, 6.63F, 11.38F, 9.42F, 5.11F, 16.62F, 10.52F
};

アンカーは、境界ボックスの定義済みの高さと幅の比率です。 モデルによって検出されるほとんどのオブジェクトまたはクラスの比率は似ています。 これは、境界ボックスを作成する場合に重要です。 境界ボックスを予測する代わりに、定義済みのディメンションからのオフセットが計算されるため、境界ボックスを予測するために必要な計算が減ります。 通常、これらのアンカー比率は、使用されるデータセットに基づいて計算されます。 この場合、データセットが既知であり、値が事前計算されているため、アンカーをハードコーディングできます。

次に、モデルが予測するラベルまたはクラスを定義します。 このモデルでは、20 個のクラスが予測されます。これは、元の YOLOv2 モデルによって予測されたクラスの合計数のサブセットです。

anchorsの下にラベルの一覧を追加します。

private string[] labels = new string[]
{
    "aeroplane", "bicycle", "bird", "boat", "bottle",
    "bus", "car", "cat", "chair", "cow",
    "diningtable", "dog", "horse", "motorbike", "person",
    "pottedplant", "sheep", "sofa", "train", "tvmonitor"
};

各クラスに関連付けられている色があります。 labelsの下にクラスの色を割り当てます。

private static Color[] classColors = new Color[]
{
    Color.Khaki,
    Color.Fuchsia,
    Color.Silver,
    Color.RoyalBlue,
    Color.Green,
    Color.DarkOrange,
    Color.Purple,
    Color.Gold,
    Color.Red,
    Color.Aquamarine,
    Color.Lime,
    Color.AliceBlue,
    Color.Sienna,
    Color.Orchid,
    Color.Tan,
    Color.LightPink,
    Color.Yellow,
    Color.HotPink,
    Color.OliveDrab,
    Color.SandyBrown,
    Color.DarkTurquoise
};

ヘルパー関数を作成する

後処理フェーズには一連の手順が含まれます。 そのためには、いくつかのヘルパー メソッドを使用できます。

パーサーで使用されるヘルパー メソッドは次のとおりです。

• Sigmoid は、0 ~ 1 の数値を出力するシグモイド関数を適用します。
• Softmax は、入力ベクトルを確率分布に正規化します。
• GetOffset は、1 次元モデル出力の要素を、 125 x 13 x 13 テンソル内の対応する位置にマップします。
• ExtractBoundingBoxes では、モデル出力から GetOffset メソッドを使用して境界ボックスディメンションを抽出します。
• GetConfidence は、モデルがオブジェクトを検出し、 Sigmoid 関数を使用してそれをパーセンテージに変換する方法を示す信頼度値を抽出します。
• MapBoundingBoxToCell は境界ボックスの寸法を使用し、画像内のそれぞれのセルにマップします。
• ExtractClasses は、 GetOffset メソッドを使用してモデル出力から境界ボックスのクラス予測を抽出し、 Softmax メソッドを使用して確率分布に変換します。
• GetTopResult は、最も高い確率で予測されたクラスの一覧からクラスを選択します。
• IntersectionOverUnion は、確率が低い境界ボックスを重ねてフィルター処理します。

classColorsの一覧の下に、すべてのヘルパー メソッドのコードを追加します。

private float Sigmoid(float value)
{
    var k = (float)Math.Exp(value);
    return k / (1.0f + k);
}

private float[] Softmax(float[] values)
{
    var maxVal = values.Max();
    var exp = values.Select(v => Math.Exp(v - maxVal));
    var sumExp = exp.Sum();

    return exp.Select(v => (float)(v / sumExp)).ToArray();
}

private int GetOffset(int x, int y, int channel)
{
    // YOLO outputs a tensor that has a shape of 125x13x13, which 
    // WinML flattens into a 1D array.  To access a specific channel 
    // for a given (x,y) cell position, we need to calculate an offset
    // into the array
    return (channel * this.channelStride) + (y * COL_COUNT) + x;
}

private BoundingBoxDimensions ExtractBoundingBoxDimensions(float[] modelOutput, int x, int y, int channel)
{
    return new BoundingBoxDimensions
    {
        X = modelOutput[GetOffset(x, y, channel)],
        Y = modelOutput[GetOffset(x, y, channel + 1)],
        Width = modelOutput[GetOffset(x, y, channel + 2)],
        Height = modelOutput[GetOffset(x, y, channel + 3)]
    };
}

private float GetConfidence(float[] modelOutput, int x, int y, int channel)
{
    return Sigmoid(modelOutput[GetOffset(x, y, channel + 4)]);
}

private CellDimensions MapBoundingBoxToCell(int x, int y, int box, BoundingBoxDimensions boxDimensions)
{
    return new CellDimensions
    {
        X = ((float)x + Sigmoid(boxDimensions.X)) * CELL_WIDTH,
        Y = ((float)y + Sigmoid(boxDimensions.Y)) * CELL_HEIGHT,
        Width = (float)Math.Exp(boxDimensions.Width) * CELL_WIDTH * anchors[box * 2],
        Height = (float)Math.Exp(boxDimensions.Height) * CELL_HEIGHT * anchors[box * 2 + 1],
    };
}

public float[] ExtractClasses(float[] modelOutput, int x, int y, int channel)
{
    float[] predictedClasses = new float[CLASS_COUNT];
    int predictedClassOffset = channel + BOX_INFO_FEATURE_COUNT;
    for (int predictedClass = 0; predictedClass < CLASS_COUNT; predictedClass++)
    {
        predictedClasses[predictedClass] = modelOutput[GetOffset(x, y, predictedClass + predictedClassOffset)];
    }
    return Softmax(predictedClasses);
}

private ValueTuple<int, float> GetTopResult(float[] predictedClasses)
{
    return predictedClasses
        .Select((predictedClass, index) => (Index: index, Value: predictedClass))
        .OrderByDescending(result => result.Value)
        .First();
}

private float IntersectionOverUnion(RectangleF boundingBoxA, RectangleF boundingBoxB)
{
    var areaA = boundingBoxA.Width * boundingBoxA.Height;

    if (areaA <= 0)
        return 0;

    var areaB = boundingBoxB.Width * boundingBoxB.Height;

    if (areaB <= 0)
        return 0;

    var minX = Math.Max(boundingBoxA.Left, boundingBoxB.Left);
    var minY = Math.Max(boundingBoxA.Top, boundingBoxB.Top);
    var maxX = Math.Min(boundingBoxA.Right, boundingBoxB.Right);
    var maxY = Math.Min(boundingBoxA.Bottom, boundingBoxB.Bottom);

    var intersectionArea = Math.Max(maxY - minY, 0) * Math.Max(maxX - minX, 0);

    return intersectionArea / (areaA + areaB - intersectionArea);
}

すべてのヘルパー メソッドを定義したら、それらを使用してモデルの出力を処理します。

IntersectionOverUnion メソッドの下に、モデルによって生成された出力を処理するParseOutputs メソッドを作成します。

public IList<YoloBoundingBox> ParseOutputs(float[] yoloModelOutputs, float threshold = .3F)
{

}

境界ボックスを格納し、 ParseOutputs メソッド内に変数を定義するリストを作成します。

var boxes = new List<YoloBoundingBox>();

各画像は、 13 x 13 セルのグリッドに分割されます。 各セルには、5 つの境界ボックスが含まれています。 boxes変数の下に、各セルのすべてのボックスを処理するコードを追加します。

for (int row = 0; row < ROW_COUNT; row++)
{
    for (int column = 0; column < COL_COUNT; column++)
    {
        for (int box = 0; box < BOXES_PER_CELL; box++)
        {

        }
    }
}

最も内側のループ内で、1 次元モデル出力内の現在のボックスの開始位置を計算します。

var channel = (box * (CLASS_COUNT + BOX_INFO_FEATURE_COUNT));

その真下で、 ExtractBoundingBoxDimensions メソッドを使用して、現在の境界ボックスの寸法を取得します。

BoundingBoxDimensions boundingBoxDimensions = ExtractBoundingBoxDimensions(yoloModelOutputs, row, column, channel);

次に、 GetConfidence メソッドを使用して、現在の境界ボックスの信頼度を取得します。

float confidence = GetConfidence(yoloModelOutputs, row, column, channel);

その後、 MapBoundingBoxToCell メソッドを使用して、現在の境界ボックスを処理中の現在のセルにマップします。

CellDimensions mappedBoundingBox = MapBoundingBoxToCell(row, column, box, boundingBoxDimensions);

それ以上の処理を行う前に、信頼度の値が指定されたしきい値を超えているかどうかを確認します。 そうでない場合は、次のバウンディングボックスを処理します。

if (confidence < threshold)
    continue;

それ以外の場合は、出力の処理を続行します。 次の手順では、 ExtractClasses メソッドを使用して、現在の境界ボックスの予測クラスの確率分布を取得します。

float[] predictedClasses = ExtractClasses(yoloModelOutputs, row, column, channel);

次に、 GetTopResult メソッドを使用して、現在のボックスの確率が最も高いクラスの値とインデックスを取得し、そのスコアを計算します。

var (topResultIndex, topResultScore) = GetTopResult(predictedClasses);
var topScore = topResultScore * confidence;

topScoreを使用して、指定したしきい値を超える境界ボックスのみを保持し直します。

if (topScore < threshold)
    continue;

最後に、現在の境界ボックスがしきい値を超えた場合は、新しい BoundingBox オブジェクトを作成し、 boxes リストに追加します。

boxes.Add(new YoloBoundingBox()
{
    Dimensions = new BoundingBoxDimensions
    {
        X = (mappedBoundingBox.X - mappedBoundingBox.Width / 2),
        Y = (mappedBoundingBox.Y - mappedBoundingBox.Height / 2),
        Width = mappedBoundingBox.Width,
        Height = mappedBoundingBox.Height,
    },
    Confidence = topScore,
    Label = labels[topResultIndex],
    BoxColor = classColors[topResultIndex]
});

画像内のすべてのセルが処理されたら、 boxes リストを返します。 次の return ステートメントを、 ParseOutputs メソッドの最も外側の for ループの下に追加します。

return boxes;

重なり合うボックスをフィルター処理する

信頼性の高い境界ボックスがすべてモデル出力から抽出されたので、重なっている画像を削除するには、追加のフィルター処理を行う必要があります。 FilterBoundingBoxes メソッドの下に ParseOutputs というメソッドを追加します。

public IList<YoloBoundingBox> FilterBoundingBoxes(IList<YoloBoundingBox> boxes, int limit, float threshold)
{

}

FilterBoundingBoxesメソッド内では、まず、検出されたボックスのサイズと等しい配列を作成し、すべてのスロットをアクティブまたは処理の準備ができているものとしてマークします。

var activeCount = boxes.Count;
var isActiveBoxes = new bool[boxes.Count];

for (int i = 0; i < isActiveBoxes.Length; i++)
    isActiveBoxes[i] = true;

次に、境界ボックスを含むリストを信頼度に基づいて降順に並べ替えます。

var sortedBoxes = boxes.Select((b, i) => new { Box = b, Index = i })
                    .OrderByDescending(b => b.Box.Confidence)
                    .ToList();

その後、フィルター処理された結果を保持するリストを作成します。

var results = new List<YoloBoundingBox>();

各境界ボックスを反復処理して、各境界ボックスの処理を開始します。

for (int i = 0; i < boxes.Count; i++)
{

}

この for ループ内で、現在のバウンディングボックスを処理できるかどうかを確認します。

if (isActiveBoxes[i])
{

}

その場合は、境界ボックスを結果の一覧に追加します。 結果が抽出するボックスの指定された制限を超えた場合は、ループから抜け出します。 if ステートメント内に次のコードを追加します。

var boxA = sortedBoxes[i].Box;
results.Add(boxA);

if (results.Count >= limit)
    break;

それ以外の場合は、隣接する境界ボックスを見てください。 ボックス制限チェックの下に次のコードを追加します。

for (var j = i + 1; j < boxes.Count; j++)
{

}

1 つ目のボックスと同様に、隣接するボックスがアクティブであるか、処理する準備ができている場合は、 IntersectionOverUnion メソッドを使用して、最初のボックスと 2 番目のボックスが指定されたしきい値を超えているかどうかを確認します。 最も内側の for ループに次のコードを追加します。

if (isActiveBoxes[j])
{
    var boxB = sortedBoxes[j].Box;

    if (IntersectionOverUnion(boxA.Rect, boxB.Rect) > threshold)
    {
        isActiveBoxes[j] = false;
        activeCount--;

        if (activeCount <= 0)
            break;
    }
}

隣接する境界ボックスをチェックする最も内側の for ループの外側で、処理する境界ボックスが残っているかどうかを確認します。 そうでない場合は、外側の for ループから抜け出します。

if (activeCount <= 0)
    break;

最後に、 FilterBoundingBoxes メソッドの最初の for ループの外側で、結果を返します。

return results;

すごい！ 次に、このコードをスコアリング用のモデルと共に使用します。

スコアリングにモデルを使用する

後処理と同様に、スコア付け手順にはいくつかの手順があります。 これを支援するには、スコア付けロジックを含むクラスをプロジェクトに追加します。

1. ソリューション エクスプローラーでプロジェクトを右クリックし、[追加]、[>を選択します。

2. [ 新しい項目の追加 ] ダイアログ ボックスで、[ クラス ] を選択し、[ 名前 ] フィールドを OnnxModelScorer.csに変更します。 その後、 [追加] を選択します。

   OnnxModelScorer.cs ファイルがコード エディターで開きます。 次の using ディレクティブを OnnxModelScorer.csの先頭に追加します。

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using Microsoft.ML;
   using Microsoft.ML.Data;
   using ObjectDetection.DataStructures;
   using ObjectDetection.YoloParser;
   

   OnnxModelScorer クラス定義内に、次の変数を追加します。

   private readonly string imagesFolder;
   private readonly string modelLocation;
   private readonly MLContext mlContext;
   
   private IList<YoloBoundingBox> _boundingBoxes = new List<YoloBoundingBox>();
   

   その直下に、前に定義した変数を初期化する OnnxModelScorer クラスのコンストラクターを作成します。

   public OnnxModelScorer(string imagesFolder, string modelLocation, MLContext mlContext)
   {
       this.imagesFolder = imagesFolder;
       this.modelLocation = modelLocation;
       this.mlContext = mlContext;
   }
   

   コンストラクターを作成したら、イメージとモデルの設定に関連する変数を含む構造体をいくつか定義します。 モデルの入力として期待される高さと幅を格納するために、 ImageNetSettings という構造体を作成します。

   public struct ImageNetSettings
   {
       public const int imageHeight = 416;
       public const int imageWidth = 416;
   }
   

   その後、モデルの入力レイヤーと出力レイヤーの名前を含む TinyYoloModelSettings という別の構造体を作成します。 モデルの入力レイヤーと出力レイヤーの名前を視覚化するには、 Netron などのツールを使用できます。

   public struct TinyYoloModelSettings
   {
       // for checking Tiny yolo2 Model input and  output  parameter names,
       //you can use tools like Netron, 
       // which is installed by Visual Studio AI Tools
   
       // input tensor name
       public const string ModelInput = "image";
   
       // output tensor name
       public const string ModelOutput = "grid";
   }
   

   次に、スコアリングに使用するメソッドの最初のセットを作成します。 LoadModel クラス内にOnnxModelScorer メソッドを作成します。

   private ITransformer LoadModel(string modelLocation)
   {
   
   }
   

   LoadModel メソッド内に、ログ記録用の次のコードを追加します。

   Console.WriteLine("Read model");
   Console.WriteLine($"Model location: {modelLocation}");
   Console.WriteLine($"Default parameters: image size=({ImageNetSettings.imageWidth},{ImageNetSettings.imageHeight})");
   

   ML.NET パイプラインは、 Fit メソッドが呼び出されたときに操作するデータ スキーマを認識する必要があります。 この場合、トレーニングと同様のプロセスが使用されます。 ただし、実際のトレーニングは行われませんので、空の IDataViewを使用してもかまいません。 空のリストからパイプラインの新しい IDataView を作成します。

   var data = mlContext.Data.LoadFromEnumerable(new List<ImageNetData>());
   

   その下で、パイプラインを定義します。 パイプラインは 4 つの変換で構成されます。

   • LoadImages は、イメージをビットマップとして読み込みます。
   • ResizeImages は、指定されたサイズ (この場合は 416 x 416) にイメージを再スケーリングします。
   • ExtractPixels は、イメージのピクセル表現をビットマップから数値ベクターに変更します。
   • ApplyOnnxModel は ONNX モデルを読み込み、それを使用して提供されたデータにスコアを付けます。

   Important

   信頼できるソースからのモデルのみを適用します。 信頼されていないソースからモデルを適用することは、セキュリティ 上のリスクです。

   LoadModel変数の下の data メソッドでパイプラインを定義します。

   var pipeline = mlContext.Transforms.LoadImages(outputColumnName: "image", imageFolder: "", inputColumnName: nameof(ImageNetData.ImagePath))
                   .Append(mlContext.Transforms.ResizeImages(outputColumnName: "image", imageWidth: ImageNetSettings.imageWidth, imageHeight: ImageNetSettings.imageHeight, inputColumnName: "image"))
                   .Append(mlContext.Transforms.ExtractPixels(outputColumnName: "image"))
                   .Append(mlContext.Transforms.ApplyOnnxModel(modelFile: modelLocation, outputColumnNames: new[] { TinyYoloModelSettings.ModelOutput }, inputColumnNames: new[] { TinyYoloModelSettings.ModelInput }));
   

   次に、スコアリングのためにモデルをインスタンス化します。 パイプラインで Fit メソッドを呼び出し、さらに処理するためにそれを返します。

   var model = pipeline.Fit(data);
   
   return model;
   

モデルが読み込まれたら、それを使用して予測を行うことができます。 そのプロセスを容易にするために、PredictDataUsingModel メソッドの下に LoadModel というメソッドを作成します。

private IEnumerable<float[]> PredictDataUsingModel(IDataView testData, ITransformer model)
{

}

PredictDataUsingModel内に、ログ記録用の次のコードを追加します。

Console.WriteLine($"Images location: {imagesFolder}");
Console.WriteLine("");
Console.WriteLine("=====Identify the objects in the images=====");
Console.WriteLine("");

次に、 Transform メソッドを使用してデータをスコア付けします。

IDataView scoredData = model.Transform(testData);

予測される確率を抽出し、追加処理のために返します。

IEnumerable<float[]> probabilities = scoredData.GetColumn<float[]>(TinyYoloModelSettings.ModelOutput);

return probabilities;

両方の手順が設定されたので、それらを 1 つのメソッドに結合します。 PredictDataUsingModel メソッドの下に、Scoreという名前の新しいメソッドを追加します。

public IEnumerable<float[]> Score(IDataView data)
{
    var model = LoadModel(modelLocation);

    return PredictDataUsingModel(data, model);
}

もうすぐです！ 今こそ、すべてを活用するときです。

オブジェクトを検出する

すべてのセットアップが完了したら、いくつかのオブジェクトを検出します。

モデル出力のスコア付けと解析

mlContext変数の作成の下に、try-catch ステートメントを追加します。

try
{

}
catch (Exception ex)
{
    Console.WriteLine(ex.ToString());
}

try ブロック内で、オブジェクト検出ロジックの実装を開始します。 まず、データを IDataViewに読み込みます。

IEnumerable<ImageNetData> images = ImageNetData.ReadFromFile(imagesFolder);
IDataView imageDataView = mlContext.Data.LoadFromEnumerable(images);

次に、 OnnxModelScorer のインスタンスを作成し、それを使用して読み込まれたデータのスコア付けを行います。

// Create instance of model scorer
var modelScorer = new OnnxModelScorer(imagesFolder, modelFilePath, mlContext);

// Use model to score data
IEnumerable<float[]> probabilities = modelScorer.Score(imageDataView);

次に、後処理の手順を実行します。 YoloOutputParserのインスタンスを作成し、それを使用してモデルの出力を処理します。

YoloOutputParser parser = new YoloOutputParser();

var boundingBoxes =
    probabilities
    .Select(probability => parser.ParseOutputs(probability))
    .Select(boxes => parser.FilterBoundingBoxes(boxes, 5, .5F));

モデルの出力が処理されたら、画像に境界ボックスを描画します。

予測の視覚化

モデルが画像にスコアを付け、出力が処理されたら、境界ボックスを画像に描画する必要があります。 これを行うには、Program.cs内の DrawBoundingBox メソッドの下に GetAbsolutePath というメソッドを追加します。

void DrawBoundingBox(string inputImageLocation, string outputImageLocation, string imageName, IList<YoloBoundingBox> filteredBoundingBoxes)
{

}

まず、イメージを読み込み、 DrawBoundingBox メソッドで高さと幅の寸法を取得します。

Image image = Image.FromFile(Path.Combine(inputImageLocation, imageName));

var originalImageHeight = image.Height;
var originalImageWidth = image.Width;

次に、for-each ループを作成して、モデルによって検出された各境界ボックスを反復処理します。

foreach (var box in filteredBoundingBoxes)
{

}

for-eachループ内で、バウンディングボックスの寸法を取得します。

var x = (uint)Math.Max(box.Dimensions.X, 0);
var y = (uint)Math.Max(box.Dimensions.Y, 0);
var width = (uint)Math.Min(originalImageWidth - x, box.Dimensions.Width);
var height = (uint)Math.Min(originalImageHeight - y, box.Dimensions.Height);

境界ボックスの寸法は 416 x 416のモデル入力に対応するため、境界ボックスの寸法をイメージの実際のサイズに合わせてスケーリングします。

x = (uint)originalImageWidth * x / OnnxModelScorer.ImageNetSettings.imageWidth;
y = (uint)originalImageHeight * y / OnnxModelScorer.ImageNetSettings.imageHeight;
width = (uint)originalImageWidth * width / OnnxModelScorer.ImageNetSettings.imageWidth;
height = (uint)originalImageHeight * height / OnnxModelScorer.ImageNetSettings.imageHeight;

次に、各境界ボックスの上に表示されるテキストのテンプレートを定義します。 テキストには、それぞれの境界ボックス内のオブジェクトのクラスと信頼度が含まれます。

string text = $"{box.Label} ({(box.Confidence * 100).ToString("0")}%)";

イメージに描画するには、 Graphics オブジェクトに変換します。

using (Graphics thumbnailGraphic = Graphics.FromImage(image))
{

}

using コード ブロック内で、グラフィックのGraphics オブジェクト設定を調整します。

thumbnailGraphic.CompositingQuality = CompositingQuality.HighQuality;
thumbnailGraphic.SmoothingMode = SmoothingMode.HighQuality;
thumbnailGraphic.InterpolationMode = InterpolationMode.HighQualityBicubic;

その下に、テキストと境界ボックスのフォントと色のオプションを設定します。

// Define Text Options
Font drawFont = new Font("Arial", 12, FontStyle.Bold);
SizeF size = thumbnailGraphic.MeasureString(text, drawFont);
SolidBrush fontBrush = new SolidBrush(Color.Black);
Point atPoint = new Point((int)x, (int)y - (int)size.Height - 1);

// Define BoundingBox options
Pen pen = new Pen(box.BoxColor, 3.2f);
SolidBrush colorBrush = new SolidBrush(box.BoxColor);

FillRectangle メソッドを使用して、境界ボックスの上に四角形を作成して塗りつぶします。 これにより、テキストのコントラストが向上し、読みやすさが向上します。

thumbnailGraphic.FillRectangle(colorBrush, (int)x, (int)(y - size.Height - 1), (int)size.Width, (int)size.Height);

次に、 DrawString メソッドと DrawRectangle メソッドを使用して、画像にテキストと境界ボックスを描画します。

thumbnailGraphic.DrawString(text, drawFont, fontBrush, atPoint);

// Draw bounding box on image
thumbnailGraphic.DrawRectangle(pen, x, y, width, height);

for-each ループの外部で、 outputFolderにイメージを保存するコードを追加します。

if (!Directory.Exists(outputImageLocation))
{
    Directory.CreateDirectory(outputImageLocation);
}

image.Save(Path.Combine(outputImageLocation, imageName));

アプリケーションが実行時に予想どおりに予測を行っているという追加のフィードバックを得るために、検出されたオブジェクトをコンソールに出力するために、Program.cs ファイルの LogDetectedObjects メソッドの下に DrawBoundingBox というメソッドを追加します。

void LogDetectedObjects(string imageName, IList<YoloBoundingBox> boundingBoxes)
{
    Console.WriteLine($".....The objects in the image {imageName} are detected as below....");

    foreach (var box in boundingBoxes)
    {
        Console.WriteLine($"{box.Label} and its Confidence score: {box.Confidence}");
    }

    Console.WriteLine("");
}

予測から視覚的なフィードバックを作成するヘルパー メソッドが用意されたので、スコア付けされた各画像を反復処理する for ループを追加します。

for (var i = 0; i < images.Count(); i++)
{

}

for ループ内で、イメージ ファイルの名前と、それに関連付けられている境界ボックスを取得します。

string imageFileName = images.ElementAt(i).Label;
IList<YoloBoundingBox> detectedObjects = boundingBoxes.ElementAt(i);

その下で、 DrawBoundingBox メソッドを使用して、画像に境界ボックスを描画します。

DrawBoundingBox(imagesFolder, outputFolder, imageFileName, detectedObjects);

最後に、 LogDetectedObjects メソッドを使用して、予測をコンソールに出力します。

LogDetectedObjects(imageFileName, detectedObjects);

try-catch ステートメントの後に、プロセスの実行が完了したことを示すロジックを追加します。

Console.WriteLine("========= End of Process..Hit any Key ========");

それです！

結果

前の手順に従った後、コンソール アプリを実行します (Ctrl + F5 キー)。 結果は次の出力のようになります。 警告が表示されたり、メッセージが処理されたりすることがありますが、わかりやすくするために、これらのメッセージは次の結果から削除されています。

=====Identify the objects in the images=====

.....The objects in the image image1.jpg are detected as below....
car and its Confidence score: 0.9697262
car and its Confidence score: 0.6674225
person and its Confidence score: 0.5226039
car and its Confidence score: 0.5224892
car and its Confidence score: 0.4675332

.....The objects in the image image2.jpg are detected as below....
cat and its Confidence score: 0.6461141
cat and its Confidence score: 0.6400049

.....The objects in the image image3.jpg are detected as below....
chair and its Confidence score: 0.840578
chair and its Confidence score: 0.796363
diningtable and its Confidence score: 0.6056048
diningtable and its Confidence score: 0.3737402

.....The objects in the image image4.jpg are detected as below....
dog and its Confidence score: 0.7608147
person and its Confidence score: 0.6321323
dog and its Confidence score: 0.5967442
person and its Confidence score: 0.5730394
person and its Confidence score: 0.5551759

========= End of Process..Hit any Key ========

境界ボックスがある画像を表示するには、 assets/images/output/ ディレクトリに移動します。 処理された画像の 1 つのサンプルを次に示します。

おめでとうございます! これで、事前トレーニング済みの ONNX モデルを ML.NET で再利用することで、物体検出用の機械学習モデルを正常に構築できました。

このチュートリアルのソース コードは 、dotnet/machinelearning-samples リポジトリにあります。

このチュートリアルでは、次の方法を学習しました。

拡張オブジェクト検出サンプルを調べるには、Machine Learning サンプルの GitHub リポジトリを参照してください。