Lernprogramm: Kategorisieren von Supportproblemen mithilfe der Mehrklassenklassifizierung mit ML.NET

In diesem Beispiellernprogramm wird die Verwendung von ML.NET zum Erstellen eines GitHub-Problemklassifizierers veranschaulicht, um ein Modell zu trainieren, das die Bereichsbezeichnung für ein GitHub-Problem über eine .NET-Konsolenanwendung mit C# in Visual Studio klassifiziert und vorhersagt.

In diesem Tutorial erfahren Sie, wie:

• Bereiten Sie die Daten vor.
• Transformieren der Daten
• Trainieren des Modells
• Auswerten des Modells
• Vorhersagen mit dem trainierten Modell
• Bereitstellen und Vorhersagen mit einem geladenen Modell

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

Voraussetzungen

• Visual Studio 2022 oder höher mit installierter Workload ".NET Desktop Development".
• Die tabgetrennte GitHub-Issues-Schulungsdatei (issues_train.tsv).
• Die GitHub Issues Testdatei im TSV-Format (issues_test.tsv).

Erstellen einer Konsolenanwendung

Erstellen eines Projekts

1. Erstellen Sie eine C# -Konsolenanwendung namens "GitHubIssueClassification". Wählen Sie Weiteraus.

2. Wählen Sie .NET 7 als zu verwendende Framework aus. Wählen Sie "Erstellen" aus.

3. Erstellen Sie ein Verzeichnis mit dem Namen "Daten " in Ihrem Projekt, um Ihre Datasetdateien zu speichern:

   Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt, und wählen Sie"Neuen Ordner>" aus. Geben Sie "Daten" ein, und drücken Sie die EINGABETASTE.

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

   Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt, und wählen Sie"Neuen Ordner>" aus. Geben Sie "Modelle" ein, und drücken Sie die EINGABETASTE.

5. 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 , und wählen Sie "Installieren" aus. Wählen Sie im Dialogfeld "Vorschauänderungen" die Schaltfläche "OK" und dann im Dialogfeld "Lizenzakzeptanz" die Schaltfläche "Ich stimme zu", wenn Sie den Lizenzbedingungen für die aufgeführten Pakete zustimmen.

Bereiten Sie die Daten vor.

1. Laden Sie die issues_train.tsv und die issues_test.tsv-Datensätze herunter, und speichern Sie sie im zuvor erstellten Datenordner . Das erste Dataset trainiert das Machine Learning-Modell und das zweite kann verwendet werden, um zu bewerten, wie genau Ihr Modell ist.

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

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

using Microsoft.ML;
using GitHubIssueClassification;

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

• _trainDataPath hat den Pfad zum Dataset, der zum Trainieren des Modells verwendet wird.
• _testDataPath hat den Pfad zum Dataset, der zum Auswerten des Modells verwendet wird.
• _modelPath hat den Pfad, in dem das trainierte Modell gespeichert wird.
• _mlContext stellt den MLContext Verarbeitungskontext bereit.
• _trainingDataView IDataView wird verwendet, um das Schulungsdatenset zu verarbeiten.
• _predEngine PredictionEngine<TSrc,TDst> wird für einzelne Vorhersagen verwendet.

Fügen Sie der Zeile direkt unterhalb der using Direktiven den folgenden Code 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 Ihrem 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" aus.

2. Wählen Sie im Dialogfeld " Neues Element hinzufügen " " Klasse " aus, und ändern Sie das Feld "Name " in GitHubIssueData.cs. Klicken Sie anschließend auf Hinzufügen.

   Die GitHubIssueData.cs Datei wird im Code-Editor geöffnet. Fügen Sie oben using die folgende Direktive hinzu:

   using Microsoft.ML.Data;
   

3. Entfernen Sie die vorhandene Klassendefinition, und fügen Sie der datei GitHubIssueData.cs den folgenden Code hinzu. Dieser Code verfügt über zwei Klassen GitHubIssue und IssuePrediction.

   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;
   }
   

   Dies label ist die Spalte, die Sie vorhersagen möchten. Die identifizierten Features Eingaben sind die Eingaben, die Sie dem Modell geben, um die Bezeichnung vorherzusagen.

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

   GitHubIssue ist die Eingabe-Datasetklasse und weist die folgenden String Felder auf:

   • Die erste Spalte ID (GitHub-Problem-ID).
   • Die zweite Spalte Area (die Vorhersage für Schulungen).
   • Die dritte Spalte Title (GitHub-Problemtitel) ist der erste feature , der für die Vorhersage des AreaProblems verwendet wird.
   • Die vierte Spalte ist die zweiteDescription, feature die für die Vorhersage der Area.

   IssuePrediction ist die Klasse, die für die Vorhersage verwendet wird, nachdem das Modell trainiert wurde. Es verfügt über ein einzelnes string (Area) und ein PredictedLabelColumnName Attribut. Die PredictedLabel Wird während der Vorhersage und Auswertung verwendet. Zur Auswertung werden eine Eingabe mit Schulungsdaten, die vorhergesagten Werte und das Modell verwendet.

   Alle ML.NET Vorgänge beginnen in der MLContext-Klasse . Beim Initialisieren mlContext wird eine neue ML.NET Umgebung erstellt, die für die Workflowobjekte der Modellerstellung freigegeben werden kann. Es ist konzeptionell ähnlich zu DBContext in Entity Framework.

Initialisieren der Variablen

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

_mlContext = new MLContext(seed: 0);

Laden der Daten

ML.NET verwendet die IDataView-Schnittstelle als flexible, effiziente Methode zum Beschreiben numerischer oder Text tabellarischer Daten. IDataView kann textdateien oder in Echtzeit laden (z. B. SQL-Datenbank oder Protokolldateien).

Um die _trainingDataView globale Variable zu initialisieren und zu laden, um sie für die Pipeline zu verwenden, fügen Sie nach der mlContext Initialisierung den folgenden Code hinzu:

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

Das LoadFromTextFile() -Element definiert das Datenschema und liest es in der Datei. Es nimmt die Datenpfadvariablen auf und gibt einen IDataView zurück.

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

var pipeline = ProcessData();

Die ProcessData Methode führt die folgenden Aufgaben aus:

• Extrahiert und transformiert die Daten.
• Gibt die Verarbeitungspipeline zurück.

Erstellen Sie die ProcessData Methode am ende der Program.cs Datei mit dem folgenden Code:

IEstimator<ITransformer> ProcessData()
{

}

Extrahieren von Features und Transformieren der Daten

Wenn Sie das Area GitHub-Label für ein GitHubIssue vorhersagen möchten, verwenden Sie die Methode MapValueToKey(), um die Area-Spalte in eine numerische Schlüsselformats-Spalte Label zu transformieren (ein Format, das von Klassifizierungsalgorithmen akzeptiert wird), und fügen Sie sie als neue Spalte im Datensatz hinzu.

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

Rufen Sie als Nächstes mlContext.Transforms.Text.FeaturizeText auf, um die Textspalten (Title und Description) in einen numerischen Vektor für jede aufgerufene Instanz von TitleFeaturized und DescriptionFeaturized zu transformieren. Fügen Sie die Featurisierung für beide Spalten mit dem folgenden Code an die Pipeline an:

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

Der letzte Schritt in der Datenvorbereitung kombiniert alle Featurespalten in der Spalte "Features " mithilfe der Concatenate()- Methode. Standardmäßig verarbeitet ein Lernalgorithmus nur Features aus der Spalte "Features ". Fügen Sie diese Transformation mit dem folgenden Code an die Pipeline an:

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

Fügen Sie als Nächstes ein AppendCacheCheckpoint hinzu, um die DataView zu zwischenspeichern, damit möglicherweise eine bessere Leistung erzielt wird, wenn Sie mehrmals über die Daten iterieren, wie im folgenden Code:

.AppendCacheCheckpoint(_mlContext);

Warnung

Verwenden Sie AppendCacheCheckpoint für kleine/mittlere Datasets, um die Schulungszeit zu verringern. Verwenden Sie sie NICHT (entfernen Sie es. AppendCacheCheckpoint()) beim Behandeln sehr großer Datasets.

Gibt die Pipeline am Ende der ProcessData Methode zurück.

return pipeline;

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

Erstellen und Trainieren des Modells

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

var trainingPipeline = BuildAndTrainModel(_trainingDataView, pipeline);

Die BuildAndTrainModel Methode führt die folgenden Aufgaben aus:

• Erstellt die Klasse des Schulungsalgorithmus.
• Trainiert das Modell.
• Prognostiziert den Bereich basierend auf Schulungsdaten.
• Gibt das Modell zurück.

Erstellen Sie die BuildAndTrainModel Methode direkt nach der Deklaration der ProcessData() Methode mithilfe des folgenden Codes:

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

}

Informationen zur Klassifizierungsaufgabe

Klassifizierung ist eine Machine Learning-Aufgabe, die Daten verwendet, um die Kategorie, den Typ oder die Klasse eines Elements oder einer Zeile mit Daten zu bestimmen und ist häufig einer der folgenden Typen:

• Binär: entweder A oder B.
• Mehrere Klassen: mehrere Kategorien, die mithilfe eines einzelnen Modells vorhergesagt werden können.

Verwenden Sie für diese Art von Problem einen Algorithmus für die Mehrklassenklassifizierung, da ihre Problemkategorievorhersage eine von mehreren Kategorien (Multiklassen) und nicht nur zwei (binär) sein kann.

Fügen Sie den Machine-Learning-Algorithmus zu den Datentransformationsdefinitionen hinzu, indem Sie Folgendes als erste Codezeile in BuildAndTrainModel() hinzufügen:

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

Die SdcaMaximumEntropy ist Ihr Klassenklassifizierungstrainingsalgorithmus. Dies wird an die pipeline angehängt und akzeptiert die featurisierten Title und Description (Features) sowie die Label Eingabeparameter, um aus den historischen Daten zu lernen.

Trainieren des Modells

Passen Sie das Modell an die splitTrainSet Daten an, und geben Sie das trainierte Modell zurück, indem Sie Folgendes als nächste Codezeile in der BuildAndTrainModel() Methode hinzufügen:

_trainedModel = trainingPipeline.Fit(trainingDataView);

Die Fit()Methode trainiert Ihr Modell, indem das Dataset transformiert und die Schulung angewendet wird.

Die PredictionEngine ist eine Benutzerfreundlichkeits-API, mit der Sie eine Vorhersage für eine einzelne Dateninstanz ausführen können. Fügen Sie dies als nächste Zeile in der BuildAndTrainModel() Methode hinzu:

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

Vorhersagen 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 Instanz von GitHubIssue 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.."
};

Verwenden Sie die Funktion "Vorhersagen() ", um eine Vorhersage für eine einzelne Datenzeile zu erstellen:

var prediction = _predEngine.Predict(issue);

Verwenden des Modells: Vorhersageergebnisse

Anzeigen von GitHubIssue und entsprechenden Area Labelvorhersagen, um die Ergebnisse zu teilen und entsprechend darauf zu reagieren. Erstellen Sie eine Anzeige für die Ergebnisse mithilfe des folgenden Console.WriteLine() Codes:

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

Zurückgeben des modells, das für die Auswertung verwendet werden soll

Gibt das Modell am Ende der BuildAndTrainModel Methode zurück.

return trainingPipeline;

Auswerten des Modells

Nachdem Sie das Modell erstellt und trainiert haben, müssen Sie es mit einem anderen Dataset zur Qualitätssicherung und Validierung auswerten. In der Evaluate Methode wird das erstellte BuildAndTrainModel Modell übergeben, um ausgewertet zu werden. Erstellen Sie die Evaluate Methode direkt hinter BuildAndTrainModeldem folgenden Code:

void Evaluate(DataViewSchema trainingDataViewSchema)
{

}

Die Evaluate Methode führt die folgenden Aufgaben aus:

• Lädt das Test-Dataset.
• Erstellt den Evaluator für mehrere Klassen.
• Wertet das Modell aus und erstellt Metriken.
• Zeigt die Metriken an.

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

Evaluate(_trainingDataView.Schema);

Laden Sie wie zuvor beim Trainingsdatensatz das Testdatenset, indem Sie der Methode Evaluate den folgenden Code hinzufügen:

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

Die Evaluate()- Methode berechnet die Qualitätsmetriken für das Modell mithilfe des angegebenen Datasets. Es gibt ein MulticlassClassificationMetrics Objekt zurück, das die Gesamtmetriken enthält, die von Klassenklassifizierungs-Evaluatoren berechnet werden. Um die Metriken anzuzeigen, um die Qualität des Modells zu ermitteln, müssen Sie sie zuerst abrufen. Beachten Sie die Verwendung der Transform()- Methode der globalen Variablen für maschinelles Lernen _trainedModel (ein ITransformer), um die Features einzugeben und Vorhersagen zurückzugeben. Fügen Sie der Evaluate Methode den folgenden Code als nächste Zeile hinzu:

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

Die folgenden Metriken werden für die Klassifizierung mit mehreren Klassen ausgewertet:

• Mikrogenauigkeit – Jedes Stichprobenklassenpaar trägt gleichermaßen zur Genauigkeitsmetrik bei. Sie möchten, dass die Mikro-Genauigkeit so nah wie möglich an eins liegt.
• Makrogenauigkeit – Jede Klasse trägt gleichermaßen zur Genauigkeitsmetrik bei. Minderheitenklassen werden gleich gewichten wie die größeren Klassen. Sie möchten, dass die Makrogenauigkeit so nah wie möglich ist.
• Protokollverlust – siehe Protokollverlust. Sie möchten, dass der Protokollverlust so nah wie möglich null ist.
• Reduzierung von Protokollverlusten - Reicht von [-inf, 1,00], wobei 1,00 perfekte Vorhersagen ist und 0 bedeutet Mittelvorhersagen. Sie möchten, dass die Reduzierung von Protokollverlusten so nah wie möglich ist.

Anzeigen der Metriken für die Modellüberprüfung

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

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

Nachdem 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 erstellen. Fügen Sie der Evaluate -Methode den folgenden Code hinzu.

SaveModelAsFile(_mlContext, trainingDataViewSchema, _trainedModel);

Erstellen Sie die SaveModelAsFile Methode unter Ihrer 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 zum Serialisieren und Speichern des trainierten Modells als ZIP-Datei.

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

Bereitstellen und Vorhersagen mit einem Modell

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

PredictIssue();

Erstellen Sie die Methode direkt nach der PredictIssueEvaluate Methode (und direkt vor der SaveModelAsFile Methode) mithilfe des folgenden Codes:

void PredictIssue()
{

}

Die PredictIssue Methode führt die folgenden Aufgaben aus:

• Lädt das gespeicherte Modell.
• Erstellt ein einzelnes Problem mit Testdaten.
• Prognostiziert den Bereich basierend auf Testdaten.
• Kombiniert Testdaten und Vorhersagen für die Berichterstellung.
• Zeigt die vorhergesagten Ergebnisse an.

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 Instanz von GitHubIssue 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 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.

Verwenden Sie PredictionEngine, um das Label "Area GitHub" 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 die Vorhersage

Anzeigen Area , um das Problem zu kategorisieren und entsprechend zu bearbeiten. Erstellen Sie eine Anzeige für die Ergebnisse mithilfe des folgenden Console.WriteLine() Codes:

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

Ergebnisse

Ihre Ergebnisse sollten dem Folgenden ähnlich sein. Während der Pipelineprozesse werden Meldungen angezeigt. Möglicherweise sehen Sie Warnungen oder Verarbeitungsmeldungen. Diese Nachrichten wurden aus den folgenden Ergebnissen aus Gründen der Übersichtlichkeit 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 ===============

Glückwunsch! Sie haben nun erfolgreich ein Machine Learning-Modell für die Klassifizierung und Vorhersage einer Bereichsbezeichnung für ein GitHub-Problem erstellt. Den Quellcode für dieses Lernprogramm finden Sie im Repository dotnet/samples .

Nächste Schritte

In diesem Tutorial haben Sie Folgendes gelernt:

• Bereiten Sie die Daten vor.
• Transformieren der Daten
• Trainieren des Modells
• Auswerten des Modells
• Vorhersagen mit dem trainierten Modell
• Bereitstellen und Vorhersagen mit einem geladenen Modell

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

Taxi-Tarifvorhersage