Tutorial: Trainieren eines ML.NET-Klassifizierungsmodells zum Kategorisieren von Bildern

Artikel
06/05/2023

In diesem Artikel erfahren Sie, wie Sie ein Klassifizierungsmodell trainieren, um Bilder mithilfe eines vortrainierten TensorFlow-Modells für die Bildverarbeitung zu kategorisieren.

Das TensorFlow-Modell wurde trainiert, um Bilder in tausend Kategorien zu klassifizieren. Da das TensorFlow-Modell Muster in Bildern erkennen kann, kann das ML.NET-Modell diese Fähigkeit teilweise in der dazugehörigen Pipeline nutzen, um Rohbilder in Merkmale oder Eingaben zu konvertieren, mit denen ein Klassifizierungsmodell trainiert werden kann.

In diesem Tutorial lernen Sie, wie die folgenden Aufgaben ausgeführt werden:

Das Problem verstehen
Integrieren des vortrainierten TensorFlow-Modells in die ML.NET-Pipeline
Trainieren und Auswerten des ML.NET-Modells
Klassifizieren eines Testbilds

Sie finden den Quellcode für dieses Tutorial im Repository dotnet/samples. Standardmäßig ist die .NET-Projektkonfiguration für dieses Tutorial auf .NET Core 2.2 festgelegt.

Voraussetzungen

Auswählen der richtigen Machine Learning-Aufgabe

Deep Learning

Deep Learning ist eine Teilmenge von Machine Learning, die Bereiche wie maschinelles Sehen und Spracherkennung revolutioniert.

Deep Learning-Modelle werden mithilfe großer Mengen bezeichneter Daten und neuronaler Netze trainiert, die mehrere Lernebenen enthalten. Deep Learning:

Bietet bei einigen Aufgaben eine bessere Leistung, z. B. beim maschinellen Sehen
Erfordert große Mengen an Trainingsdaten.

Die Bildklassifizierung ist eine spezifische Klassifizierungsaufgabe, mit der automatisch Bilder in verschiedene Kategorien klassifiziert werden können:

Erkennen, ob ein Bild ein menschliches Gesicht enthält oder nicht.
Unterscheiden zwischen Katzen und Hunden.

Es lässt sich auch wie in den folgenden Bildern bestimmen, ob ein Bild ein Lebensmittel, ein Spielzeug oder ein Gerät zeigt:

Pizzabild Teddybärbild Toasterbild

Hinweis

Die vorherigen Abbildungen stammen aus Wikimedia-Commons und unterliegen folgendem Urheberrecht:

„220px-Pepperoni_pizza.jpg“ Public Domainhttps://commons.wikimedia.org/w/index.php?curid=79505,
„119px-Nalle_-_a_small_brown_teddy_bear.jpg“ von Jonik – selbst fotografiert, CC-BY-SA-2.0, https://commons.wikimedia.org/w/index.php?curid=48166.
„193px-Broodrooster.jpg“ von M.Minderhoud – eigenes Werk, CC-BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=27403

Wenn ein Modell für die Bildklassifizierung von Grund auf trainiert werden soll, müssen Millionen von Parametern festgelegt werden, und zahlreiche bezeichnete Trainingsdaten und eine große Menge an Computeressourcen (Hunderte von GPU-Stunden) werden benötigt. Wenn ein bereits trainiertes Modell verwendet wird, ist dieses zwar nicht so effektiv wie ein vollständig neu trainiertes benutzerdefiniertes Modell, doch damit können Sie diesen Prozess durch die Arbeit mit Tausenden von Bildern im Vergleich zur Arbeit mit Millionen bezeichneter Bilder abkürzen und relativ schnell ein benutzerdefiniertes Modell erstellen (innerhalb einer Stunde auf einem Computer ohne eine GPU). In diesem Tutorial wird dieser Prozess noch weiter herunterskaliert, indem nur ein Dutzend Trainingsbilder verwendet werden.

Das Inception model ist darauf trainiert, Bilder in tausend Kategorien zu klassifizieren, jedoch müssen Sie für dieses Tutorial Bilder in eine kleinere Kategoriegruppe und nur in diese Kategorien klassifizieren. Sie können die Fähigkeit des Inception model zum Erkennen und Klassifizieren von Bildern für die neuen begrenzten Kategorien Ihrer benutzerdefinierten Bildklassifizierung nutzen.

Lebensmittel
Spielzeug
Gerät

Dieses Tutorial verwendet das Deep-Learning-Modell Inception von TensorFlow, ein beliebtes Bilderkennungsmodell, das mit dem Dataset ImageNet trainiert wurde. Das TensorFlow-Modell klassifiziert ganze Bilder in tausend Klassen wie „Regenschirm“, „Trikot“ und „Geschirrspüler“.

Da Inception model bereits anhand von Tausenden anderer Bilder vortrainiert wurde, enthält es intern die zur Bildidentifizierung erforderlichen Bildmerkmale. Wir können diese internen Bildmerkmale im Modell verwenden, um ein neues Modell mit weitaus weniger Klassen zu trainieren.

Wie im folgenden Diagramm dargestellt, fügen Sie einen Verweis auf die ML.NET-NuGet-Pakete in Ihrer .NET Core- oder .NET Framework-Anwendung hinzu. Im Hintergrund beinhaltet und verweist ML.NET auf die native TensorFlow-Bibliothek, mit der Sie Code schreiben können, der eine vorhandene trainierte TensorFlow-Modelldatei lädt.

TensorFlow-Transformation – ML.NET Arch-Diagramm

Multiklassenklassifizierung

Nachdem wir das TensorFlow-Inception-Modell verwendet haben, um Merkmale zu extrahieren, die als Eingabe für einen klassischen Machine Learning-Algorithmus geeignet sind, fügen wir einen ML.NET-Multiklassenklassifizierer hinzu.

Der in diesem Fall verwendete Trainingsmechanismus ist der multinomiale logistische Regressionsalgorithmus.

Der von diesem Trainingsmechanismus implementierte Algorithmus eignet sich gut für Probleme mit einer Vielzahl von Merkmalen, was bei einem Deep Learning-Modell der Fall ist, das mit Bilddaten arbeitet.

Weitere Informationen finden Sie unter Deep Learning im Vergleich zu maschinellem Lernen.

Daten

Es gibt zwei Datenquellen: die .tsv-Datei und die Bilddateien. Die tags.tsv-Datei enthält zwei Spalten: die erste ist als ImagePath definiert und die zweite das Label für das Bild. Die folgende Beispieldatei verfügt nicht über eine Kopfzeile und sieht wie folgt aus:

broccoli.jpg	food
pizza.jpg	food
pizza2.jpg	food
teddy2.jpg	toy
teddy3.jpg	toy
teddy4.jpg	toy
toaster.jpg	appliance
toaster2.png	appliance

Die Trainings- und Testbilder befinden sich in dem Assetsordner, den Sie in einer ZIP-Datei herunterladen. Diese Bilder gehören zu Wikimedia Commons.

Wikimedia-Commons, das Repository für kostenlose Medien. Abgerufen am 17. Oktober 2018 um 10:48 Uhr aus: https://commons.wikimedia.org/wiki/Pizza https://commons.wikimedia.org/wiki/Toaster https://commons.wikimedia.org/wiki/Teddy_bear

Setup

Erstellen eines Projekts

Erstellen Sie eine C#-Konsolenanwendung mit dem Namen „TransferLearningTF“. Klicken Sie auf die Schaltfläche Weiter.
Wählen Sie .NET 6 als zu verwendendes Framework aus. Klicken Sie auf die Schaltfläche Erstellen .
Installieren des Microsoft.ML NuGet-Pakets:

Hinweis

In diesem Beispiel wird, sofern nicht anders angegeben, die neueste stabile Version der genannten NuGet-Pakete verwendet.
- Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie NuGet-Pakete verwalten aus.
- Wählen Sie „nuget.org“ als Paketquelle aus, wählen Sie die Registerkarte „Durchsuchen“ aus, und suchen Sie nach Microsoft.ML.
- Wählen Sie die Schaltfläche Installieren aus.
- Klicken Sie im Dialogfeld Vorschau der Änderungen auf die Schaltfläche OK.
- Wählen Sie die Schaltfläche Ich stimme zu im Dialogfeld Zustimmung zur Lizenz, wenn Sie mit den Lizenzbedingungen für die aufgeführten Pakete einverstanden sind.
- Wiederholen Sie diese Schritte für Microsoft.ML.ImageAnalytics, SciSharp.TensorFlow.Redist und Microsoft.ML.TensorFlow.

Herunterladen von Ressourcen

Laden Sie die ZIP-Datei des Projektassetverzeichnisses herunter, und entzippen Sie sie.
Kopieren Sie das assets-Verzeichnis in Ihr TransferLearningTF-Projektverzeichnis. Dieses Verzeichnis und seine Unterverzeichnisse enthalten die für dieses Tutorial erforderlichen Daten und Unterstützungsdateien (mit Ausnahme des Inception-Modells, das Sie im nächsten Schritt herunterladen und hinzufügen).
Laden Sie das Inception-Modell herunter, und entzippen Sie es.
Kopieren Sie den Inhalt des gerade entzippten inception5h-Verzeichnisses in Ihr TransferLearningTF-Projektverzeichnis assets/inception. Dieses Verzeichnis enthält das Modell und die zusätzlich für dieses Tutorial erforderlichen Unterstützungsdateien wie in der folgenden Abbildung gezeigt:
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf alle Dateien im Assetverzeichnis und den Unterverzeichnissen, und wählen Sie Eigenschaften aus. Ändern Sie unter Erweitert den Wert von In Ausgabeverzeichnis kopieren in Kopieren, wenn neuer.

Erstellen von Klassen und Definieren von Pfaden

Fügen Sie am Anfang der Datei Program.cs folgende zusätzliche using-Anweisungen hinzu:
```
using Microsoft.ML;
using Microsoft.ML.Data;
```

Fügen Sie der Zeile direkt unter den using-Anweisungen den folgenden Code hinzu, um die Ressourcenpfade anzugeben:

string _assetsPath = Path.Combine(Environment.CurrentDirectory, "assets");
string _imagesFolder = Path.Combine(_assetsPath, "images");
string _trainTagsTsv = Path.Combine(_imagesFolder, "tags.tsv");
string _testTagsTsv = Path.Combine(_imagesFolder, "test-tags.tsv");
string _predictSingleImage = Path.Combine(_imagesFolder, "toaster3.jpg");
string _inceptionTensorFlowModel = Path.Combine(_assetsPath, "inception", "tensorflow_inception_graph.pb");

Erstellen Sie anschließend Klassen für Ihre Eingabedaten und Vorhersagen.
```
public class ImageData
{
    [LoadColumn(0)]
    public string? ImagePath;

    [LoadColumn(1)]
    public string? Label;
}
```
ImageData ist die Eingabebilddaten-Klasse mit den folgenden String-Feldern:
- ImagePath enthält den Bilddateinamen.
- Label enthält einen Wert für die Bildbezeichnung.
Fügen Sie dem Projekt eine neue Klasse für ImagePrediction hinzu:
```
public class ImagePrediction : ImageData
{
    public float[]? Score;

    public string? PredictedLabelValue;
}
```
ImagePrediction ist die Bildvorhersageklasse und hat die folgenden Felder:
- Score enthält den Zuverlässigkeitsprozentsatz für eine bestimmte Bildklassifizierung.
- PredictedLabelValue enthält einen Wert für die vorhergesagte Bildklassifizierungsbezeichnung.
Die ImagePrediction-Klasse wird für die Vorhersage verwendet, nachdem das Modell trainiert wurde. Sie besitzt einen string (ImagePath) für den Bildpfad. Mit Label wird das Modell wiederverwendet und trainiert. Das PredictedLabelValue wird während der Vorhersage und Evaluierung verwendet. Für die Evaluierung werden eine Eingabe mit Trainingsdaten, die vorhergesagten Werte und das Modell verwendet.

Initialisieren der Variablen

Initialisieren Sie die mlContext-Variable mit einer neuen Instanz von MLContext. Ersetzen Sie die Zeile Console.WriteLine("Hello World!") durch folgenden Code:
```
MLContext mlContext = new MLContext();
```
Die MLContext-Klasse ist der Startpunkt für alle ML.NET-Vorgänge. Durch das Initialisieren von mlContext wird eine neue ML.NET-Umgebung erstellt, die für mehrere Objekte des Modellerstellungsworkflows verwendet werden kann. Die Klasse ähnelt dem Konzept von DBContext in Entity Framework.

Erstellen einer Struktur für Inception-Modellparameter

Das Inception-Modell verfügt über mehrere Parameter, die Sie übergeben müssen. Erstellen Sie direkt nach der Initialisierung der Variablen mlContext eine Struktur, um die Parameterwerte mit folgendem Code Anzeigenamen zuzuordnen:
```
struct InceptionSettings
{
    public const int ImageHeight = 224;
    public const int ImageWidth = 224;
    public const float Mean = 117;
    public const float Scale = 1;
    public const bool ChannelsLast = true;
}
```

Erstellen einer Anzeigehilfsprogramm-Methode

Da Sie die Bilddaten und die zugehörigen Vorhersagen mehr als einmal anzeigen werden, erstellen Sie eine Anzeigehilfsmethode, um die Anzeige der Bild- und Vorhersageergebnisse zu verarbeiten.

Erstellen Sie die DisplayResults()-Methode mit dem folgenden Code direkt nach der InceptionSettings-Struktur:
```
void DisplayResults(IEnumerable<ImagePrediction> imagePredictionData)
{

}
```

Geben Sie den Text der DisplayResults-Methode ein:

foreach (ImagePrediction prediction in imagePredictionData)
{
    Console.WriteLine($"Image: {Path.GetFileName(prediction.ImagePath)} predicted as: {prediction.PredictedLabelValue} with score: {prediction.Score?.Max()} ");
}

Erstellen einer Methode zum Treffen einer Vorhersage

Erstellen Sie die ClassifySingleImage()-Methode mit dem folgenden Code direkt vor der DisplayResults()-Methode:
```
void ClassifySingleImage(MLContext mlContext, ITransformer model)
{

}
```
Erstellen Sie ein ImageData-Objekt, das den vollqualifizierten Pfad und Bilddateinamen für den einzelnen ImagePath enthält. Fügen Sie der ClassifySingleImage()-Methode folgenden Code als nächste Zeilen hinzu:
```
var imageData = new ImageData()
{
    ImagePath = _predictSingleImage
};
```
Treffen Sie eine einzelne Vorhersage, indem Sie den folgenden Code als nächste Zeile in der ClassifySingleImage-Methode hinzufügen:
```
// Make prediction function (input = ImageData, output = ImagePrediction)
var predictor = mlContext.Model.CreatePredictionEngine<ImageData, ImagePrediction>(model);
var prediction = predictor.Predict(imageData);
```
Um die Vorhersage zu erhalten, verwenden Sie die Predict()-Methode. Die PredictionEngine ist eine Hilfs-API, mit der Sie eine Vorhersage für eine einzelne Instanz der Daten treffen können. PredictionEngine ist nicht threadsicher. Die Verwendung in Singlethread-oder Prototypumgebungen ist zulässig. Zur Verbesserung der Leistung und Threadsicherheit in Produktionsumgebungen verwenden Sie den PredictionEnginePool-Dienst, der einen ObjectPool aus PredictionEngine-Objekten für die Verwendung in Ihrer gesamten Anwendung erstellt. Informationen zur Verwendung von PredictionEnginePool in einer ASP.NET Core-Web-API finden Sie in dieser Anleitung.

Hinweis

Die PredictionEnginePool-Diensterweiterung ist derzeit als Vorschauversion verfügbar.

Zeigen Sie das Vorhersageergebnis als nächste Codezeile in der ClassifySingleImage()-Methode an:

Console.WriteLine($"Image: {Path.GetFileName(imageData.ImagePath)} predicted as: {prediction.PredictedLabelValue} with score: {prediction.Score?.Max()} ");

Erstellen der ML.NET-Modellpipeline

Eine ML.NET-Modellpipeline ist eine Kette von Kalkulatoren. Während der Pipelineerstellung erfolgt keine Ausführung. Die Kalkulatorobjekte werden erstellt, aber nicht ausgeführt.

Hinzufügen einer Methode zum Generieren des Modells

Diese Methode ist das Herzstück des Tutorials. Sie erstellt eine Pipeline für das Modell und trainiert die Pipeline, um das ML.NET-Modell zu generieren. Außerdem wertet sie das Modell anhand einiger zuvor unbekannter Testdaten aus.

Erstellen Sie die GenerateModel()-Methode mithilfe des folgenden Codes unmittelbar nach der InceptionSettings-Struktur und direkt vor der DisplayResults()-Methode:
```
ITransformer GenerateModel(MLContext mlContext)
{

}
```

Fügen Sie die Schätzer zum Laden, Ändern der Größe und Extrahieren der Pixel aus den Bilddaten hinzu:

IEstimator<ITransformer> pipeline = mlContext.Transforms.LoadImages(outputColumnName: "input", imageFolder: _imagesFolder, inputColumnName: nameof(ImageData.ImagePath))
                // The image transforms transform the images into the model's expected format.
                .Append(mlContext.Transforms.ResizeImages(outputColumnName: "input", imageWidth: InceptionSettings.ImageWidth, imageHeight: InceptionSettings.ImageHeight, inputColumnName: "input"))
                .Append(mlContext.Transforms.ExtractPixels(outputColumnName: "input", interleavePixelColors: InceptionSettings.ChannelsLast, offsetImage: InceptionSettings.Mean))

Die Bilddaten müssen in das Format verarbeitet werden, das vom TensorFlow-Modell erwartet wird. In diesem Fall werden die Bilder in den Arbeitsspeicher geladen, die Größe in eine konsistente Größe geändert, und die Pixel werden in einen numerischen Vektor extrahiert.

Fügen Sie den Kalkulator zum Laden des TensorFlow-Modells hinzu, und versehen Sie es mit einem Score:
```
.Append(mlContext.Model.LoadTensorFlowModel(_inceptionTensorFlowModel).
    ScoreTensorFlowModel(outputColumnNames: new[] { "softmax2_pre_activation" }, inputColumnNames: new[] { "input" }, addBatchDimensionInput: true))
```
Diese Phase in der Pipeline lädt das TensorFlow-Modell in den Arbeitsspeicher und verarbeitet dann den Vektor der Pixelwerte über das TensorFlow-Modellnetzwerk. Das Anwenden von Eingaben auf ein Deep Learning-Modell und das Generieren einer Ausgabe mithilfe des Modells wird als Scoring bezeichnet. Wenn Sie das Modell in seiner Gesamtheit verwenden, führt das Scoring zu einem Rückschluss oder einer Vorhersage.

In diesem Fall verwenden Sie das gesamte TensorFlow-Modell mit Ausnahme der letzten Schicht, bei der es sich um die Schicht handelt, die den Rückschluss ausführt. Die Ausgabe der vorletzten Schicht wird als softmax_2_preactivation bezeichnet. Die Ausgabe dieser Schicht ist praktisch ein Vektor von Merkmalen, die die ursprünglichen Eingabebilder charakterisieren.

Dieser vom TensorFlow-Modell generierte Merkmalsvektor wird als Eingabe in einen ML.NET-Trainingsalgorithmus verwendet.
Fügen Sie den Kalkulator hinzu, um die Zeichenfolgenbezeichnungen in den Trainingsdaten ganzzahligen Schlüsselwerten zuzuordnen:
```
.Append(mlContext.Transforms.Conversion.MapValueToKey(outputColumnName: "LabelKey", inputColumnName: "Label"))
```
Der ML.NET-Trainingsmechanismus, der als nächstes angefügt wird, erfordert, dass seine Bezeichnungen im key-Format und nicht in beliebigen Zeichenfolgen vorliegen. Ein Schlüssel ist eine Zahl, die eine 1:1-Zuordnung zu einem Zeichenfolgenwert aufweist.

Fügen Sie den ML.NET-Trainingsalgorithmus hinzu:

.Append(mlContext.MulticlassClassification.Trainers.LbfgsMaximumEntropy(labelColumnName: "LabelKey", featureColumnName: "softmax2_pre_activation"))

Fügen Sie den Kalkulator hinzu, um den vorhergesagten Schlüsselwert erneut einer Zeichenfolge zuzuordnen:

.Append(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabelValue", "PredictedLabel"))
.AppendCacheCheckpoint(mlContext);

Trainieren des Modells

Laden Sie die Trainingsdaten mithilfe des LoadFromTextFile-Wrappers. Fügen Sie der GenerateModel()-Methode folgenden Code als nächste Zeile hinzu:
```
IDataView trainingData = mlContext.Data.LoadFromTextFile<ImageData>(path:  _trainTagsTsv, hasHeader: false);
```
Daten im ML.NET werden angezeigt als ein IDataView interface. Mit IDataView können Tabellendaten (Zahlen und Text) flexibel und effizient beschrieben werden. Daten können aus einer Textdatei oder in Echtzeit (z. B. aus einer SQL-Datenbank oder aus Protokolldateien) in ein IDataView-Objekt geladen werden.
Trainieren Sie das Modell mit den zuvor geladenen Daten:
```
ITransformer model = pipeline.Fit(trainingData);
```
Die Fit()-Methode trainiert Ihr Modell, indem das Trainingsdataset auf die Pipeline angewendet wird.

Auswerten der Genauigkeit des Modells

Laden und transformieren Sie die Testdaten, indem Sie der nächsten Zeile der GenerateModel-Methode den folgenden Code hinzufügen:

IDataView testData = mlContext.Data.LoadFromTextFile<ImageData>(path: _testTagsTsv, hasHeader: false);
IDataView predictions = model.Transform(testData);

// Create an IEnumerable for the predictions for displaying results
IEnumerable<ImagePrediction> imagePredictionData = mlContext.Data.CreateEnumerable<ImagePrediction>(predictions, true);
DisplayResults(imagePredictionData);

Es gibt einige Beispielbilder, die Sie zum Auswerten des Modells verwenden können. Wie die Trainingsdaten müssen diese in eine IDataView geladen werden, damit Sie vom Modell transformiert werden können.

Fügen Sie der GenerateModel()-Methode den folgenden Code hinzu, um das Modell auszuwerten:
```
MulticlassClassificationMetrics metrics =
    mlContext.MulticlassClassification.Evaluate(predictions,
        labelColumnName: "LabelKey",
        predictedLabelColumnName: "PredictedLabel");
```
Nachdem Sie die Vorhersage festgelegt haben, führt die Evaluate()-Methode Folgendes aus:
- Bewerten des Modells (Vergleichen der vorhergesagten Werte mit dem Testdataset labels).
- Rückgabe der Modellleistungsmetriken.
Anzeigen der Modellgenauigkeitsmetriken

Verwenden Sie den folgenden Code, um die Metriken anzuzeigen, die Ergebnisse freizugeben und dann mit ihnen zu arbeiten:
```
Console.WriteLine($"LogLoss is: {metrics.LogLoss}");
Console.WriteLine($"PerClassLogLoss is: {String.Join(" , ", metrics.PerClassLogLoss.Select(c => c.ToString()))}");
```
Für die Bildklassifizierung werden die folgenden Metriken ausgewertet:
- Log-loss – siehe Protokollverlust. Der Protokollverlust sollte so nahe wie möglich bei 0 liegen.
- Per class Log-loss. Der Protokollverlust pro Klasse sollte so nahe wie möglich bei 0 liegen.
Fügen Sie den folgenden Code hinzu, um das trainierte Modell als nächste Zeile zurückzugeben:
```
return model;
```

Führen Sie die Anwendung aus!

Fügen Sie den Aufruf von GenerateModel nach der Erstellung der MLContext-Klasse hinzu:
```
ITransformer model = GenerateModel(mlContext);
```
Fügen Sie den Aufruf der ClassifySingleImage()-Methode nach dem Aufruf der GenerateModel()-Methode hinzu:
```
ClassifySingleImage(mlContext, model);
```

Führen Sie die Konsolen-App aus (STRG + F5). Ihre Ergebnisse sollten der folgenden Ausgabe ähneln. (Möglicherweise werden Warnungen oder Verarbeitungsnachrichten angezeigt. Diese wurden jedoch aus Gründen der Übersichtlichkeit aus den folgenden Ergebnissen entfernt.)

=============== Training classification model ===============
Image: broccoli2.jpg predicted as: food with score: 0.8955513
Image: pizza3.jpg predicted as: food with score: 0.9667718
Image: teddy6.jpg predicted as: toy with score: 0.9797683
=============== Classification metrics ===============
LogLoss is: 0.0653774699265059
PerClassLogLoss is: 0.110315812569315 , 0.0204391272836966 , 0
=============== Making single image classification ===============
Image: toaster3.jpg predicted as: appliance with score: 0.9646884

Herzlichen Glückwunsch! Sie haben nun erfolgreich ein Klassifizierungsmodell in ML.NET erstellt, mit dem Sie Bilder mithilfe eines vortrainierten TensorFlow-Modells für die Bildverarbeitung kategorisieren können.

Sie finden den Quellcode für dieses Tutorial im Repository dotnet/samples.

In diesem Tutorial haben Sie gelernt, wie die folgenden Aufgaben ausgeführt werden:

Das Problem verstehen
Integrieren des vortrainierten TensorFlow-Modells in die ML.NET-Pipeline
Trainieren und Auswerten des ML.NET-Modells
Klassifizieren eines Testbilds

Sehen Sie sich im GitHub-Repository für Machine Learning-Beispiele nach einem Beispiel für erweiterte Bildklassifizierung um, damit Sie es untersuchen können.

dotnet/machinelearning-samples-GitHub-Repository