Teilen über

Lernprogramm: Trainieren eines ML.NET Klassifizierungsmodells zum Kategorisieren von Bildern

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, Bilder in tausend Kategorien zu klassifizieren. Da das TensorFlow-Modell weiß, wie Muster in Bildern erkannt werden, kann das ML.NET-Modell einen Teil davon in seiner Pipeline verwenden, um Rohbilder in Features oder Eingaben zu konvertieren, um ein Klassifizierungsmodell zu trainieren.

In diesem Tutorial erfahren Sie, wie:

  • Verstehen des Problems
  • Integrieren Sie das vortrainierte TensorFlow-Modell in die ML.NET-Pipeline.
  • Trainieren und Bewerten des ML.NET Modells
  • Klassifizieren eines Testbilds

Den Quellcode für dieses Lernprogramm finden Sie im Repository dotnet/samples . Standardmäßig zielt die .NET-Projektkonfiguration für dieses Lernprogramm auf .NET Core 2.2 ab.

Voraussetzungen

Wählen Sie die richtige Machine Learning-Aufgabe aus.

das Deep Learning

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

Deep Learning-Modelle werden mit großen Gruppen bezeichneter Daten und neuronaler Netzwerke trainiert, die mehrere Lernebenen enthalten. Deep Learning:

  • Erfüllt bei einigen Aufgaben wie Computer Vision besser.
  • Erfordert große Mengen an Schulungsdaten.

Die Bildklassifizierung ist eine bestimmte Klassifizierungsaufgabe, mit der wir Bilder automatisch in Kategorien klassifizieren können, z. B.:

  • Erkennen eines menschlichen Gesichts in einem Bild oder nicht.
  • Erkennen von Katzen und Hunden.

Oder wie in den folgenden Bildern, bestimmen Sie, ob ein Bild ein Lebensmittel, ein Toy oder ein Gerät ist:

Pizzabild Teddybärbild Toaster-Bild

Hinweis

Die vorangehenden Bilder gehören zu Wikimedia Commons und werden wie folgt zugeschrieben:

Das Training eines Bildklassifizierungsmodells erfordert das Festlegen von Millionen von Parametern, eine große Menge an bezeichneten Schulungsdaten und eine große Menge an Rechenressourcen (Hunderte von GPU-Stunden). Obwohl es nicht so effektiv ist, wie ein benutzerdefiniertes Modell von Grund auf neu zu trainieren, können Sie mit einem vortrainierten Modell diesen Prozess abkürzen, indem Sie mit Tausenden von Bildern anstelle von Millionen von beschrifteten Bildern arbeiten und ein angepasstes Modell relativ schnell erstellen (innerhalb einer Stunde auf einem Computer ohne GPU). In diesem Lernprogramm wird dieser Prozess noch weiter skaliert, wobei nur ein Dutzend Schulungsbilder verwendet werden.

Inception model wird darauf trainiert, Bilder in tausend Kategorien zu klassifizieren, aber für dieses Lernprogramm müssen Sie Bilder nur in einem kleineren Kategoriesatz klassifizieren. Sie können die Inception modelMöglichkeit verwenden, Bilder in den neuen eingeschränkten Kategorien Ihres benutzerdefinierten Bildklassifizierers zu erkennen und zu klassifizieren.

  • Essen
  • Spielzeug
  • Gerät

In diesem Lernprogramm wird das Deep Learning-Modell TensorFlow Inception verwendet, ein beliebtes Bilderkennungsmodell, das auf dem ImageNet Dataset trainiert wurde. Das TensorFlow-Modell klassifiziert ganze Bilder in tausend Klassen, z. B. "Umbrella", "Jersey" und "Dishwasher".

Da die Inception model bereits auf Tausenden von verschiedenen Bildern vortrainiert wurde, enthält sie intern die für die Bildidentifizierung erforderlichen Bildfunktionen . Wir können diese internen Bildfunktionen im Modell nutzen, um ein neues Modell mit weit weniger Klassen zu trainieren.

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

TensorFlow Transform ML.NET Architekturdiagramm

Mehrklassenklassifizierung

Nachdem Sie das TensorFlow-Inception-Modell zum Extrahieren von Features verwendet haben, die als Eingabe für einen klassischen Machine Learning-Algorithmus geeignet sind, fügen Sie einen ML.NET Klassifizierer mit mehreren Klassen hinzu.

Der in diesem Fall verwendete spezifische Trainer ist der multinomiale Regressionsalgorithmus.

Der von diesem Trainer implementierte Algorithmus erzielt gute Ergebnisse bei Problemen mit einer großen Anzahl von Merkmalen, wie es bei einem Deep-Learning-Modell, das auf Bilddaten arbeitet, der Fall ist.

Weitere Informationen finden Sie unter Deep Learning im Vergleich zum maschinellen Lernen.

Daten

Es gibt zwei Datenquellen: die .tsv Datei und die Bilddateien. Die tags.tsv Datei enthält zwei Spalten: die erste ist definiert als ImagePath und die zweite ist das Label entsprechende 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 Schulungs- und Testbilder befinden sich in den Ressourcenordnern, die Sie in einer ZIP-Datei herunterladen. Diese Bilder gehören zu Wikimedia Commons.

Wikimedia Commons, das kostenlose Medien-Repository. Abgerufen am 10:48, 17. Oktober 2018 von: https://commons.wikimedia.org/wiki/Pizzahttps://commons.wikimedia.org/wiki/Toasterhttps://commons.wikimedia.org/wiki/Teddy_bear

Konfiguration

Erstellen eines Projekts

  1. Erstellen Sie eine C# -Konsolenanwendung namens "TransferLearningTF". Klicken Sie auf die Schaltfläche Weiter .

  2. Wählen Sie .NET 8 als zu verwendende Framework aus. Klicken Sie auf die Schaltfläche " Erstellen ".

  3. Installieren Sie das Microsoft.ML NuGet-Paket:

    Hinweis

    In diesem Beispiel wird die neueste stabile Version der erwähnten NuGet-Pakete verwendet, sofern nichts anderes angegeben ist.

    • Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt, und wählen Sie "NuGet-Pakete verwalten" aus.
    • Wählen Sie "nuget.org" als Paketquelle aus, wählen Sie die Registerkarte "Durchsuchen" aus, suchen Sie nach Microsoft.ML.
    • Wählen Sie die Schaltfläche Installieren aus.
    • Wählen Sie im Dialogfeld "Vorschauänderungen" die Schaltfläche "OK" aus.
    • Wählen Sie im Dialogfeld "Lizenzakzeptanz" die Schaltfläche "Ich stimme zu", wenn Sie den Lizenzbedingungen für die aufgeführten Pakete zustimmen.
    • Wiederholen Sie diese Schritte für Microsoft.ML.ImageAnalytics, SciSharp.TensorFlow.Redist und Microsoft.ML.TensorFlow.

Ressourcen herunterladen

  1. Laden Sie die ZIP-Datei des Projektressourcenverzeichnisses herunter, und entpacken Sie sie.

  2. Kopieren Sie das assets Verzeichnis in Ihr TransferLearningTF-Projektverzeichnis . Dieses Verzeichnis und seine Unterverzeichnisse enthalten die Für dieses Lernprogramm erforderlichen Daten und Supportdateien (mit Ausnahme des Inception-Modells, das Sie im nächsten Schritt herunterladen und hinzufügen werden).

  3. Laden Sie das Inception-Modell herunter, und entpacken Sie es.

  4. Kopieren Sie den Inhalt des inception5h Verzeichnisses, das gerade in Ihr TransferLearningTF Projektverzeichnis assets/inception entzippt wurde. Dieses Verzeichnis enthält das Modell und zusätzliche Supportdateien, die für dieses Lernprogramm erforderlich sind, wie in der folgenden Abbildung dargestellt:

    Inhalt des Inception-Verzeichnisses

  5. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die dateien im Objektverzeichnis und unterverzeichnisse, und wählen Sie "Eigenschaften" aus. Ändern Sie unter Erweitert den Wert von In Ausgabeordner kopieren in Kopieren, wenn neuer.

Erstellen von Klassen und Definieren von Pfaden

  1. Fügen Sie oben in der using die folgenden zusätzlichen Direktiven hinzu:

    using Microsoft.ML;
using Microsoft.ML.Data;

  2. Fügen Sie der Zeile direkt unter den using Direktiven den folgenden Code hinzu, um die Objektpfade 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");

  3. Erstellen Sie Klassen für Ihre Eingabedaten und Vorhersagen.

    public class ImageData
{
    [LoadColumn(0)]
    public string? ImagePath;

    [LoadColumn(1)]
    public string? Label;
}

    ImageData ist die Eingabebilddatenklasse und weist die folgenden String Felder auf:

    • ImagePath enthält den Namen der Bilddatei.
    • Label enthält einen Wert für die Bildbeschriftung.

  4. Hinzufügen einer neuen Klasse zu Ihrem Projekt für ImagePrediction:

    public class ImagePrediction : ImageData
{
    public float[]? Score;

    public string? PredictedLabelValue;
}

    ImagePrediction ist die Bildvorhersageklasse und weist die folgenden Felder auf:

    • Score enthält den Konfidenzprozentsatz für eine bestimmte Bildklassifizierung.
    • PredictedLabelValue enthält einen Wert für die vorhergesagte Bildklassifizierungsbezeichnung.

    ImagePrediction ist die Klasse, die für die Vorhersage verwendet wird, nachdem das Modell trainiert wurde. Er weist einen string (ImagePath) für den Bildpfad auf. Das Label Modell wird verwendet, um das Modell wiederzuverwenden und zu trainieren. Die PredictedLabelValue Wird während der Vorhersage und Auswertung verwendet. Zur Auswertung werden eine Eingabe mit Schulungsdaten, die vorhergesagten Werte und das Modell verwendet.

Initialisieren der Variablen

  1. Initialisieren Sie die mlContext Variable mit einer neuen Instanz von MLContext. Ersetzen Sie die Console.WriteLine("Hello World!") Zeile durch den folgenden Code:

    MLContext mlContext = new MLContext();

    Die MLContext Klasse ist ein Ausgangspunkt für alle ML.NET-Vorgänge und die Initialisierung mlContext erstellt eine neue ML.NET Umgebung, die für die Modellerstellungsworkflowobjekte freigegeben werden kann. Es ist konzeptionell ähnlich wie DBContext im Entity Framework.

Erstellen einer Struktur für Inception-Modellparameter

  1. Das Inception-Modell verfügt über mehrere Parameter, die Sie übergeben müssen. Erstellen Sie eine Struktur, um die Parameterwerte mit freundlichen Namen zu verknüpfen, indem Sie den folgenden Code direkt nach der Initialisierung der mlContext-Variablen verwenden:

    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 Anzeigehilfsmethode

Da Sie die Bilddaten und die zugehörigen Vorhersagen mehrmals anzeigen, erstellen Sie eine Anzeigehilfsmethode zum Behandeln der Anzeige der Bild- und Vorhersageergebnisse.

  1. Erstellen Sie die DisplayResults() Methode direkt nach der InceptionSettings Struktur mithilfe des folgenden Codes:

    void DisplayResults(IEnumerable<ImagePrediction> imagePredictionData)
{

}

  2. Füllen Sie den Textkörper der DisplayResults Methode aus:

    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 Erstellen einer Vorhersage

  1. Erstellen Sie die ClassifySingleImage() Methode direkt vor der DisplayResults() Methode mit dem folgenden Code:

    void ClassifySingleImage(MLContext mlContext, ITransformer model)
{

}

  2. Erstellen Sie ein ImageData Objekt, das den vollqualifizierten Pfad- und Bilddateinamen für die einzelne ImagePathDatei enthält. Fügen Sie den folgenden Code als nächste Zeilen in der ClassifySingleImage() Methode hinzu:

    var imageData = new ImageData()
{
    ImagePath = _predictSingleImage
};

  3. Erstellen 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);

    Verwenden Sie die Predict() -Methode, um die Vorhersage abzurufen. Die PredictionEngine ist eine Komfort-API, mit der Sie eine Vorhersage für eine einzelne Instanz von Daten durchführen können. PredictionEngine ist nicht threadsicher. Es ist akzeptabel, in Singlethread- oder Prototypumgebungen zu verwenden. Um die Leistung und Threadsicherheit in Produktionsumgebungen zu verbessern, verwenden Sie den PredictionEnginePool Dienst, der eine ObjectPool Von PredictionEngine Objekten für die gesamte Anwendung erstellt. In diesem Handbuch erfahren Sie, wie Sie in einer ASP.NET Core Web-API verwendenPredictionEnginePool.

    Hinweis

    PredictionEnginePool Die Diensterweiterung befindet sich derzeit in der Vorschau.

  4. Zeigt 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 Schätzungen. Während des Pipelinebaus erfolgt keine Ausführung. Die Schätzobjekte werden erstellt, aber nicht ausgeführt.

  1. Hinzufügen einer Methode zum Generieren des Modells

    Diese Methode ist das Herzstück des Lernprogramms. Es erstellt eine Pipeline für das Modell und trainiert die Pipeline zur Herstellung des ML.NET Modells. Außerdem wird das Modell anhand einiger zuvor nicht angezeigter Testdaten ausgewertet.

    Erstellen Sie die GenerateModel() Methode direkt nach der InceptionSettings Struktur und direkt vor der DisplayResults() Methode, indem Sie den folgenden Code verwenden:

    ITransformer GenerateModel(MLContext mlContext)
{

}

  2. Fügen Sie die Estimatoren hinzu, um die Bilddaten zu laden, die Größe anzupassen und die Pixel daraus zu extrahieren.

    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 das TensorFlow-Modell erwartet. In diesem Fall werden die Bilder in den Arbeitsspeicher geladen, auf eine einheitliche Größe gebracht und die Pixel in einen numerischen Vektor umgewandelt.

  3. Fügen Sie den Estimator hinzu, um das TensorFlow-Modell zu laden, und bewerten Sie es.

    .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 von Pixelwerten über das TensorFlow-Modellnetzwerk. Das Anwenden von Eingaben auf ein Deep Learning-Modell und das Generieren einer Ausgabe mithilfe des Modells wird als Bewertung bezeichnet. Wenn Sie das Modell vollständig verwenden, macht die Bewertung eine Ableitung oder Vorhersage.

    In diesem Fall verwenden Sie das gesamte TensorFlow-Modell mit Ausnahme der letzten Ebene, d. h. die Ebene, die die Ableitung macht. Die Ausgabe der vorletzten Ebene wird beschriftet softmax_2_preactivation. Die Ausgabe dieser Ebene ist effektiv ein Vektor von Features, die die ursprünglichen Eingabebilder charakterisieren.

    Dieser vom TensorFlow-Modell generierte Featurevektor wird als Eingabe für einen ML.NET Schulungsalgorithmus verwendet.

  4. Fügen Sie den Schätzer hinzu, um die String-Labels in den Schulungsdaten in ganzzahlige Schlüsselwerte zuzuordnen.

    .Append(mlContext.Transforms.Conversion.MapValueToKey(outputColumnName: "LabelKey", inputColumnName: "Label"))

    Der ML.NET Trainer, der als Nächstes angefügt wird, erfordert, dass die Beschriftungen im key-Format vorliegen und nicht als beliebige Zeichenfolgen. Ein Schlüssel ist eine Zahl, die eindeutig einem Stringwert zugeordnet ist.

  5. Fügen Sie den ML.NET Schulungsalgorithmus hinzu:

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

  6. Fügen Sie den Schätzwert hinzu, um den vorhergesagten Schlüsselwert wieder einer Zeichenfolge zuzuordnen:

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

Trainieren des Modells

  1. Laden Sie die Schulungsdaten mithilfe des "LoadFromTextFile"-Wrappers. Fügen Sie den folgenden Code als nächste Zeile in der GenerateModel() Methode hinzu:

    IDataView trainingData = mlContext.Data.LoadFromTextFile<ImageData>(path:  _trainTagsTsv, hasHeader: false);

    Daten in ML.NET werden als IDataView-Schnittstelle dargestellt. IDataView ist eine flexible, effiziente Möglichkeit, tabellarische Daten (numerisch und Text) zu beschreiben. Daten können aus einer Textdatei oder in Echtzeit (z. B. SQL-Datenbank- oder Protokolldateien) in ein IDataView Objekt geladen werden.

  2. Trainieren Sie das Modell mit den oben geladenen Daten:

    ITransformer model = pipeline.Fit(trainingData);

    Die Fit() Methode trainiert Ihr Modell, indem das Schulungsdatenset auf die Pipeline angewendet wird.

Bewerten Sie die Genauigkeit des Modells

  1. 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, mit denen Sie das Modell auswerten können. Wie die Schulungsdaten müssen diese in ein IDataViewModell geladen werden, damit sie vom Modell transformiert werden können.

  2. 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 den Vorhersagesatz festgelegt haben, gibt die Evaluate()- Methode Folgendes an:

    • Bewertet das Modell (vergleicht die vorhergesagten Werte mit dem Test-Dataset labels).
    • Gibt die Modellleistungsmetriken zurück.

  3. Anzeigen der Modellgenauigkeitsmetriken

    Verwenden Sie den folgenden Code, um die Metriken anzuzeigen, die Ergebnisse zu teilen und dann darauf zu reagieren:

    Console.WriteLine($"LogLoss is: {metrics.LogLoss}");
Console.WriteLine($"PerClassLogLoss is: {String.Join(" , ", metrics.PerClassLogLoss.Select(c => c.ToString()))}");

    Die folgenden Metriken werden für die Bildklassifizierung ausgewertet:

    • Log-loss - siehe Protokollverlust. Sie möchten, dass der Protokollverlust so nah wie möglich null ist.
    • Per class Log-loss. Sie möchten pro Klassenprotokollverlust so nah wie möglich null sein.

  4. Fügen Sie den folgenden Code hinzu, um das trainierte Modell als nächste Zeile zurückzugeben:

    return model;

Ausführen der Anwendung

  1. Fügen Sie den Aufruf GenerateModel nach der Erstellung der MLContext Klasse hinzu:

    ITransformer model = GenerateModel(mlContext);

  2. Fügen Sie den Aufruf der ClassifySingleImage() Methode nach dem Aufruf der GenerateModel() Methode hinzu:

    ClassifySingleImage(mlContext, model);

  3. Führen Sie Die Konsolen-App (STRG + F5) aus. Ihre Ergebnisse sollten mit der folgenden Ausgabe vergleichbar sein. (Möglicherweise werden Warnungen oder die Verarbeitung von Nachrichten angezeigt, aber diese Nachrichten wurden aus den folgenden Ergebnissen aus Gründen der Übersichtlichkeit 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

Glückwunsch! Sie haben nun erfolgreich ein Klassifizierungsmodell in ML.NET erstellt, um Bilder mithilfe eines vortrainierten TensorFlows für die Bildverarbeitung zu kategorisieren.

Den Quellcode für dieses Lernprogramm finden Sie im Repository dotnet/samples .

In diesem Tutorial haben Sie Folgendes gelernt:

  • Verstehen des Problems
  • Integrieren Sie das vortrainierte TensorFlow-Modell in die ML.NET-Pipeline.
  • Trainieren und Bewerten des ML.NET Modells
  • Klassifizieren eines Testbilds

Sehen Sie sich das GitHub-Repository für Machine Learning-Beispiele an, um ein erweitertes Beispiel für die Bildklassifizierung zu erkunden.

dotnet/machinelearning-samples GitHub Repository

  • Last updated on