Tutorial: Kategorisieren von Supportproblemen unter Verwendung von Multiklassenklassifizierung mit ML.NET

In diesem Beispieltutorial wird veranschaulicht, wie Sie ML.NET zum Erstellen eines Klassifizierers für GitHub-Issues über eine .NET Core-Konsolenanwendung mithilfe von C# in Visual Studio verwenden können, um ein Modell zu trainieren, dass die Bereichsbezeichnung für ein GitHub-Issue klassifiziert und vorhersagt.

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

• Vorbereiten Ihrer Daten
• Transformieren der Daten
• Trainieren des Modells
• Evaluieren des Modells
• Vorhersagen treffen mit dem trainierten Modell
• Bereitstellen eines geladenen Modells und Vorhersagen mit diesem treffen

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

Voraussetzungen

• Visual Studio 2022 mit installierter Workload „.NET-Desktopentwicklung“.
• Die durch Tabstopp getrennte Datei mit GitHub-Issues (issues_train.tsv).
• Die durch Tabstopp getrennte Testdatei für GitHub-Issues (issues_test.tsv).

Erstellen einer Konsolenanwendung

Erstellen eines Projekts

1. Erstellen Sie eine C#- -Konsolenanwendung mit dem Namen „GitHubIssueClassification“. Wählen Sie Weiter aus.

2. Wählen Sie .NET 7 als zu verwendendes Framework aus. Klicken Sie auf Erstellen.

3. Erstellen Sie ein Verzeichnis mit dem Namen Data in Ihrem Projekt, um die Datasetdateien zu speichern:

   Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie Hinzufügen>Neuer Ordner aus. Geben Sie „Data“ ein, und drücken Sie die Eingabetaste.

4. Erstellen Sie ein Verzeichnis mit dem Namen Models in Ihrem Projekt, um Ihr Modell zu speichern:

   Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie Hinzufügen>Neuer Ordner aus. Geben Sie „Models“ ein, und drücken Sie die Eingabetaste.

5. 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 als Paketquelle „nuget.org“ aus. Klicken Sie dann auf die Registerkarte „Durchsuchen“ aus, suchen Sie nach Microsoft.ML, und klicken Sie anschließend auf Installieren. Wählen Sie die Schaltfläche OK im Dialogfeld Vorschau der Änderungen und dann die Schaltfläche Ich stimme zu im Dialogfeld Zustimmung zur Lizenz aus, wenn Sie den Lizenzbedingungen für die aufgelisteten Pakete zustimmen.

Vorbereiten Ihrer Daten

1. Laden Sie die Datasets issues_train.tsv und issues_test.tsv herunter, und speichern Sie sie im zuvor erstellten Ordner Daten. Das erste Dataset trainiert das Machine Learning-Modell, und das zweite kann verwendet werden, um zu evaluieren, wie genau das Modell ist.

2. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die *.tsv-Dateien, 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 GitHubIssueClassification;

Erstellen Sie drei globale Felder, die die Pfade zu den zuletzt heruntergeladenen Dateien sowie globale Variablen für MLContext, DataView und PredictionEngine enthalten:

• _trainDataPath enthält den Pfad zu dem Dataset, das zum Trainieren des Modells verwendet wird.
• _testDataPath enthält den Pfad zu dem Dataset, das zum Evaluieren des Modells verwendet wird.
• _modelPath enthält den Pfad zu dem Speicherort, in dem das trainierte Modell gespeichert ist.
• _mlContext ist die MLContext-Klasse, die den Verarbeitungskontext enthält.
• _trainingDataView ist die zum Verarbeiten des Trainingsdatasets verwendete IDataView-Schnittstelle.
• _predEngine ist die für einzelne Vorhersagen verwendete PredictionEngine<TSrc,TDst>-Klasse.

Fügen Sie den folgenden Code der Zeile direkt unter den using-Anweisungen hinzu, um diese Pfade und die anderen Variablen anzugeben:

string _appPath = Path.GetDirectoryName(Environment.GetCommandLineArgs()[0]) ?? ".";
string _trainDataPath = Path.Combine(_appPath, "..", "..", "..", "Data", "issues_train.tsv");
string _testDataPath = Path.Combine(_appPath, "..", "..", "..", "Data", "issues_test.tsv");
string _modelPath = Path.Combine(_appPath, "..", "..", "..", "Models", "model.zip");

MLContext _mlContext;
PredictionEngine<GitHubIssue, IssuePrediction> _predEngine;
ITransformer _trainedModel;
IDataView _trainingDataView;

Erstellen Sie einige Klassen für Ihre Eingabedaten und Vorhersagen. Fügen Sie dem Projekt eine neue Klasse hinzu:

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie dann Hinzufügen>Neues Element aus.

2. Wählen Sie im Dialogfeld Neues Element hinzufügen die Option Klasse aus, und ändern Sie das Feld Name in GitHubIssueData.cs. Wählen Sie dann die Schaltfläche Hinzufügen aus.

   Die Datei GitHubIssueData.cs wird im Code-Editor geöffnet. Fügen Sie am Anfang der Datei GitHubIssueData.cs die folgende using-Anweisung hinzu:

using Microsoft.ML.Data;

Entfernen Sie die vorhandene Klassendefinition, und fügen Sie der Datei GitHubIssueData.cs den folgenden Code mit den beiden Klassen GitHubIssue und IssuePrediction hinzu:

public class GitHubIssue
{
    [LoadColumn(0)]
    public string? ID { get; set; }
    [LoadColumn(1)]
    public string? Area { get; set; }
    [LoadColumn(2)]
    public required string Title { get; set; }
    [LoadColumn(3)]
    public required string Description { get; set; }
}

public class IssuePrediction
{
    [ColumnName("PredictedLabel")]
    public string? Area;
}

label ist die Spalte, die vorhergesagt werden soll. Die identifizierten Features sind die Eingaben, die Sie für das Modell zum Vorhersagen der Bezeichnung bereitstellen.

Verwenden Sie das LoadColumnAttribute, um die Indizes der Quellspalten im Dataset festzulegen.

GitHubIssue ist die Klasse des Eingabedatasets mit den folgenden String-Feldern:

• Die erste Spalte: ID (ID des GitHub-Issues)
• Die zweite Spalte: Area (Vorhersage für das Training)
• Die dritte Spalte Title (Titel des GitHub-Issues) ist das erste feature zur Vorhersage von Area
• Die vierte Spalte Description ist das zweite feature für die Vorhersage von Area

Die IssuePrediction-Klasse wird für die Vorhersage verwendet, nachdem das Modell trainiert wurde. Sie verfügt über ein einzelnes string- (Area) und ein PredictedLabelColumnName-Attribut. Das PredictedLabel wird während der Vorhersage und Evaluierung verwendet. Für die Evaluierung werden eine Eingabe mit Trainingsdaten, die vorhergesagten Werte und das Modell verwendet.

Alle ML.NET-Operationen beginnen in der MLContext-Klasse. Beim Initialisieren von mlContext wird eine neue ML.NET-Umgebung erstellt, die für alle Objekte des Workflows für die Modellerstellung gemeinsam genutzt werden kann. Die Klasse ähnelt dem Konzept von DBContext in Entity Framework.

Initialisieren der Variablen

Initialisieren Sie die globale Variable _mlContext mit einer neuen Instanz von MLContext mit einem zufälligen Ausgangswert (seed: 0), um in mehreren Trainings wiederholbare/deterministische Ergebnisse zu erhalten. Ersetzen Sie die Zeile Console.WriteLine("Hello World!") durch folgenden Code:

_mlContext = new MLContext(seed: 0);

Laden der Daten

ML.NET verwendet das IDataView-Interface als flexible, effiziente Möglichkeit, Tabellendaten in Zahlen- oder Textform zu beschreiben. Mit IDataView können entweder Textdateien geladen werden, oder es kann ein Echtzeitladevorgang durchgeführt werden (z.B. SQL-Datenbank- oder Protokolldateien).

Fügen Sie nach der Initialisierung von mlContext den folgenden Code hinzu, um die globale Variable _trainingDataView zur Verwendung für die Pipeline zu initialisieren und zu laden:

_trainingDataView = _mlContext.Data.LoadFromTextFile<GitHubIssue>(_trainDataPath,hasHeader: true);

Die LoadFromTextFile()-Methode definiert das Datenschema und liest die Datei ein. Diese Methode akzeptiert Datenpfadvariablen und gibt ein IDataView-Objekt zurück.

Fügen Sie Folgendes nach dem Aufruf der LoadFromTextFile()-Methode hinzu:

var pipeline = ProcessData();

Die ProcessData-Methode führt die folgenden Aufgaben aus:

• Extrahieren und Transformieren der Daten.
• Zurückgeben der Verarbeitungspipeline

Erstellen Sie mithilfe des folgenden Codes unten in der Datei Program.cs eine ProcessData-Methode:

IEstimator<ITransformer> ProcessData()
{

}

Extrahieren von Features und Transformieren der Daten

Da Sie die GitHub-Bereichsbezeichnung für ein GitHubIssue vorhersagen möchten, verwenden Sie die MapValueToKey()-Methode, um die Area-Spalte in eine Label-Spalte eines numerischen Typs zu transformieren (ein Format, das von Klassifizierungsalgorithmen akzeptiert wird), und fügen Sie sie als neue Datasetspalte hinzu:

var pipeline = _mlContext.Transforms.Conversion.MapValueToKey(inputColumnName: "Area", outputColumnName: "Label")

Rufen Sie als Nächstes mlContext.Transforms.Text.FeaturizeText auf, wodurch die Textspalten (Title und Description) jeweils in einen numerischen Vektor namens TitleFeaturized und DescriptionFeaturized transformiert werden. Fügen Sie an die Pipeline die Featurebereitstellung für beide Spalten mit dem folgenden Code an:

.Append(_mlContext.Transforms.Text.FeaturizeText(inputColumnName: "Title", outputColumnName: "TitleFeaturized"))
.Append(_mlContext.Transforms.Text.FeaturizeText(inputColumnName: "Description", outputColumnName: "DescriptionFeaturized"))

Im letzten Schritt der Vorbereitung der Daten werden alle Feature-Spalten mithilfe der Concatenate()-Methode in die Spalte Features kombiniert. Standardmäßig verarbeitet ein Lernalgorithmus nur Merkmale aus der Spalte Features. Fügen Sie an die Pipeline diese Transformation mit dem folgenden Code an:

.Append(_mlContext.Transforms.Concatenate("Features", "TitleFeaturized", "DescriptionFeaturized"))

Fügen Sie anschließend wie im folgenden Code veranschaulicht eine AppendCacheCheckpoint-Methode zum Zwischenspeichern von DataView an. Dadurch erhalten Sie beim mehrmaligen Durchlaufen der Daten mit dem Cache möglicherweise eine bessere Leistung:

.AppendCacheCheckpoint(_mlContext);

Warnung

Verwenden Sie AppendCacheCheckpoint für kleine/mittlere Datasets, um die Zeit für das Training zu reduzieren. Verwenden Sie dies NICHT bei der Verarbeitung sehr großer Datasets (entfernen Sie .AppendCacheCheckpoint()).

Geben Sie die Pipeline am Ende der ProcessData-Methode zurück.

return pipeline;

In diesem Schritt wird die Vorverarbeitung/Featurebereitstellung behandelt. Die Verwendung zusätzlicher in ML.NET verfügbarer Komponenten kann bessere Ergebnisse mit dem Modell ermöglichen.

Erstellen und Trainieren des Modells

Fügen Sie den folgenden Aufruf der BuildAndTrainModel-Methode als nächste Codezeile nach dem Aufruf der ProcessData()-Methode hinzu:

var trainingPipeline = BuildAndTrainModel(_trainingDataView, pipeline);

Die BuildAndTrainModel-Methode führt die folgenden Aufgaben aus:

• Erstellen der Algorithmusklasse für das Training
• Trainieren des Modells.
• Vorhersagen des Bereichs basierend auf den Trainingsdaten
• Zurückgeben des Modells.

Erstellen Sie die BuildAndTrainModel-Methode mit dem folgenden Code direkt nach der Deklaration der ProcessData()-Methode:

IEstimator<ITransformer> BuildAndTrainModel(IDataView trainingDataView, IEstimator<ITransformer> pipeline)
{

}

Informationen zur Klassifizierungsaufgabe

Die Klassifizierung ist eine Machine Learning-Aufgabe, die Daten zum Bestimmen von Kategorie, Typ oder Klasse eines Elements oder einer Datenzeile verwendet, und ist oft eine der folgenden Typen:

• Binär: entweder A oder B.
• Multiklasse: mehrere Kategorien, die mit einem einzelnen Modell vorhergesagt werden können.

Verwenden Sie für diese Art von Problemen einen Lernalgorithmus für die Klassifizierung, da es wahrscheinlicher ist, dass Ihre Vorhersage einer Problemkategorie einer von vielen Kategorien (Multiklasse) als einer von zwei (Binär) entspricht.

Fügen Sie den unten aufgeführten Code als erste Codezeilen in BuildAndTrainModel() ein, um den Machine Learning-Algorithmus festzulegen und ihn an die Datentransformationsdefinitionen anzufügen:

var trainingPipeline = pipeline.Append(_mlContext.MulticlassClassification.Trainers.SdcaMaximumEntropy("Label", "Features"))
        .Append(_mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabel"));

Der SdcaMaximumEntropy Algorithmus für die Multiklassenklassifizierung. Dieser wird an die pipeline angefügt und akzeptiert die mit Features ausgestatteten Title- und Description-Parameter (Features) sowie die Label-Eingabeparameter, um aus den historischen Daten zu lernen.

Trainieren des Modells

Fügen Sie den unten aufgeführten Code als nächste Codezeilen in die BuildAndTrainModel()-Methode ein, um das Modell an die splitTrainSet-Daten anzupassen und das trainierte Modell zurückzugeben:

_trainedModel = trainingPipeline.Fit(trainingDataView);

Mit der Fit()-Methode wird Ihr Modell trainiert, indem das Dataset transformiert und das Training angewendet wird.

Die PredictionEngine ist eine Hilfs-API, mit der Sie eine einzelne Instanz der Daten übergeben und dafür dann eine Vorhersage treffen können. Fügen Sie das als nächste Zeile in der BuildAndTrainModel()-Methode hinzu:

_predEngine = _mlContext.Model.CreatePredictionEngine<GitHubIssue, IssuePrediction>(_trainedModel);

Vorhersagen treffen mit dem trainierten Modell

Fügen Sie ein GitHub-Issue hinzu, um die Vorhersage des trainierten Modells in der Predict-Methode zu testen, indem Sie eine GitHubIssue-Instanz erstellen:

GitHubIssue issue = new GitHubIssue() {
    Title = "WebSockets communication is slow in my machine",
    Description = "The WebSockets communication used under the covers by SignalR looks like is going slow in my development machine.."
};

Die Predict()-Funktion trifft eine Vorhersage für eine einzelne Datenzeile:

var prediction = _predEngine.Predict(issue);

Verwenden des Modells: Vorhersageergebnisse

Zeigen Sie GitHubIssue und die entsprechende Vorhersage der Area-Bezeichnung an, um die Ergebnisse freizugeben und entsprechenden Aktionen auszuführen. Erstellen Sie mit dem folgenden Console.WriteLine()-Code eine Anzeige für die Ergebnisse:

Console.WriteLine($"=============== Single Prediction just-trained-model - Result: {prediction.Area} ===============");

Zurückgeben des für die Evaluierung trainierten Modells

Geben Sie das Modell am Ende der BuildAndTrainModel-Methode zurück.

return trainingPipeline;

Evaluieren des Modells

Da Sie nun das Modell erstellt und trainiert haben, müssen Sie es zur Qualitätssicherung und Validierung mit einem anderen Dataset evaluieren. In der Evaluate-Methode wird das in BuildAndTrainModel erstellte Modell zur Evaluierung übergeben. Erstellen Sie die Evaluate-Methode direkt nach BuildAndTrainModel wie im folgenden Code:

void Evaluate(DataViewSchema trainingDataViewSchema)
{

}

Die Evaluate-Methode führt die folgenden Aufgaben aus:

• Laden des Testdatasets.
• Erstellen des Multiklassenauswerters
• Evaluieren des Modells und Erstellen von Metriken.
• Anzeigen der Metriken.

Fügen Sie der neuen Methode mit dem folgenden Code einen Aufruf direkt unter der BuildAndTrainModel-Methode hinzu:

Evaluate(_trainingDataView.Schema);

Wie zuvor beim Trainingsdataset laden Sie das Testdataset, indem Sie den folgenden Code zur Evaluate-Methode hinzufügen:

var testDataView = _mlContext.Data.LoadFromTextFile<GitHubIssue>(_testDataPath,hasHeader: true);

Die Evaluate()-Methode berechnet die Qualitätsmetriken für das Modell mit dem angegebenen Dataset. Das zurückgegebene MulticlassClassificationMetrics-Objekt enthält alle von Auswertern der Multiklassenklassifizierung berechneten Metriken. Um diese Metriken zum Ermitteln der Modellqualität anzuzeigen, müssen Sie sie zunächst abrufen. Beachten Sie die Verwendung der Transform()-Methode der globalen Machine Learning-Variable _trainedModel (ein Transformator), um die Features einzugeben und die Vorhersagen zurückzugeben. Fügen Sie der Evaluate-Methode folgenden Code als nächste Zeile hinzu:

var testMetrics = _mlContext.MulticlassClassification.Evaluate(_trainedModel.Transform(testDataView));

Für die Multiklassenklassifizierung werden die folgenden Metriken ausgewertet:

• Mikrogenauigkeit: Jedes Beispiel/Klasse-Paar trägt zu gleichen Teilen zur Genauigkeitsmetrik bei. Die Mikrogenauigkeit sollte so nahe wie möglich bei 1 liegen.

• Makrogenauigkeit: Jede Klasse trägt zu gleichen Teilen zur Genauigkeitsmetrik bei. Minderheitsklassen werden gleich wie größere Klassen gewichtet. Die Makrogenauigkeit sollte so nahe wie möglich bei 1 liegen.

• Protokollverlust: Siehe Protokollverlust. Der Protokollverlust sollte so nahe wie möglich bei 0 liegen.

• Verringerung des Protokollverlusts: Dieser liegt zwischen -inf und 1.00, wobei „1.00“ perfekte Vorhersagen und „0“ durchschnittliche Vorhersagen bedeutet. Die Verringerung des Protokollverlusts sollte so nahe wie möglich bei 0 liegen.

Anzeigen der Metriken zur Modellvalidierung

Verwenden Sie den folgenden Code, um die Metriken anzuzeigen, die Ergebnisse freizugeben und dann mit ihnen zu arbeiten:

Console.WriteLine($"*************************************************************************************************************");
Console.WriteLine($"*       Metrics for Multi-class Classification model - Test Data     ");
Console.WriteLine($"*------------------------------------------------------------------------------------------------------------");
Console.WriteLine($"*       MicroAccuracy:    {testMetrics.MicroAccuracy:0.###}");
Console.WriteLine($"*       MacroAccuracy:    {testMetrics.MacroAccuracy:0.###}");
Console.WriteLine($"*       LogLoss:          {testMetrics.LogLoss:#.###}");
Console.WriteLine($"*       LogLossReduction: {testMetrics.LogLossReduction:#.###}");
Console.WriteLine($"*************************************************************************************************************");

Speichern des Modells in einer Datei

Wenn Sie mit Ihrem Modell zufrieden sind, speichern Sie es in einer Datei, um Vorhersagen zu einem späteren Zeitpunkt oder in einer anderen Anwendung zu treffen. Fügen Sie der Evaluate -Methode folgenden Code hinzu.

SaveModelAsFile(_mlContext, trainingDataViewSchema, _trainedModel);

Erstellen Sie die SaveModelAsFile-Methode unter der Evaluate-Methode.

void SaveModelAsFile(MLContext mlContext,DataViewSchema trainingDataViewSchema, ITransformer model)
{

}

Fügen Sie der SaveModelAsFile-Methode den folgenden Code hinzu. Dieser Code verwendet die Save-Methode, um das trainierte Modell zu serialisieren und als ZIP-Datei zu speichern.

mlContext.Model.Save(model, trainingDataViewSchema, _modelPath);

Bereitstellen eines Modells und Treffen von Vorhersagen

Fügen Sie der neuen Methode mit dem folgenden Code einen Aufruf direkt unter der Evaluate-Methode hinzu:

PredictIssue();

Erstellen Sie die PredictIssue-Methode unmittelbar nach der Evaluate-Methode (und direkt vor der SaveModelAsFile-Methode) mithilfe des folgenden Codes:

void PredictIssue()
{

}

Die PredictIssue-Methode führt die folgenden Aufgaben aus:

• Laden des gespeicherte Modells
• Erstellen eines einzelnen Issues aus Testdaten
• Vorhersagen des Bereichs basierend auf Testdaten
• Kombinieren von Testdaten und Vorhersagen für die Berichterstattung.
• Anzeigen der vorhergesagten Ergebnisse.

Laden Sie das gespeicherte Modell in Ihre Anwendung, indem Sie der PredictIssue-Methode den folgenden Code hinzufügen:

ITransformer loadedModel = _mlContext.Model.Load(_modelPath, out var modelInputSchema);

Fügen Sie ein GitHub-Issue hinzu, um die Vorhersage des trainierten Modells in der Predict-Methode zu testen, indem Sie eine GitHubIssue-Instanz erstellen:

GitHubIssue singleIssue = new GitHubIssue() { Title = "Entity Framework crashes", Description = "When connecting to the database, EF is crashing" };

Erstellen Sie wie zuvor eine PredictionEngine-Instanz mit dem folgenden Code:

_predEngine = _mlContext.Model.CreatePredictionEngine<GitHubIssue, IssuePrediction>(loadedModel);

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.

Verwenden Sie die PredictionEngine, um die GitHub-Bereichsbezeichnung vorherzusagen, indem Sie den folgenden Code zur PredictIssue-Methode für die Vorhersage hinzufügen:

var prediction = _predEngine.Predict(singleIssue);

Verwenden des geladenen Modells für Vorhersagen

Zeigen Sie Area an, um das Issue zu kategorisieren und eine entsprechende Aktion auszuführen. Erstellen Sie mit dem folgenden Console.WriteLine()-Code eine Anzeige für die Ergebnisse:

Console.WriteLine($"=============== Single Prediction - Result: {prediction.Area} ===============");

Ergebnisse

Die Ergebnisse sollten den unten dargestellten ähneln. Während der Pipelineverarbeitung werden Meldungen angezeigt. Sie können Warnungen oder Verarbeitungsmeldungen sehen. Diese Nachrichten wurden der Übersichtlichkeit halber aus den folgenden Ergebnissen entfernt.

=============== Single Prediction just-trained-model - Result: area-System.Net ===============
*************************************************************************************************************
*       Metrics for Multi-class Classification model - Test Data
*------------------------------------------------------------------------------------------------------------
*       MicroAccuracy:    0.738
*       MacroAccuracy:    0.668
*       LogLoss:          .919
*       LogLossReduction: .643
*************************************************************************************************************
=============== Single Prediction - Result: area-System.Data ===============

Herzlichen Glückwunsch! Sie haben jetzt erfolgreich ein Machine Learning-Modell zur Klassifizierung und Vorhersage der Bereichsbezeichnung für ein GitHub-Issue erstellt. Sie finden den Quellcode für dieses Tutorial im Repository dotnet/samples.

Nächste Schritte

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

• Vorbereiten Ihrer Daten
• Transformieren der Daten
• Trainieren des Modells
• Evaluieren des Modells
• Vorhersagen treffen mit dem trainierten Modell
• Bereitstellen eines geladenen Modells und Vorhersagen mit diesem treffen

Wechseln Sie zum nächsten Tutorial, um mehr zu erfahren.

Vorhersage des Taxifahrtpreises