Tutorial: Kategorisieren von Supportproblemen unter Verwendung von Multiklassenklassifizierung mit ML.NETTutorial: Categorize support issues using multiclass classification with 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.This sample tutorial illustrates using ML.NET to create a GitHub issue classifier to train a model that classifies and predicts the Area label for a GitHub issue via a .NET Core console application using C# in Visual Studio.

In diesem Tutorial lernen Sie, wie die folgenden Aufgaben ausgeführt werden:In this tutorial, you learn how to:

  • Vorbereiten Ihrer DatenPrepare your data
  • Transformieren der DatenTransform the data
  • Trainieren des ModellsTrain the model
  • Evaluieren des ModellsEvaluate the model
  • Vorhersagen treffen mit dem trainierten ModellPredict with the trained model
  • Bereitstellen eines geladenen Modells und Vorhersagen mit diesem treffenDeploy and Predict with a loaded model

Sie finden den Quellcode für dieses Tutorial im Repository dotnet/samples.You can find the source code for this tutorial at the dotnet/samples repository.

Erforderliche KomponentenPrerequisites

Erstellen einer KonsolenanwendungCreate a console application

Erstellen eines ProjektsCreate a project

  1. Öffnen Sie Visual Studio 2017.Open Visual Studio 2017. Wählen Sie Datei > Neu > Projekt aus der Menüleiste aus.Select File > New > Project from the menu bar. Wählen Sie im Dialogfeld Neues Projekt den Knoten Visual C# und anschließend den Knoten .NET Core aus.In the New Project dialog, select the Visual C# node followed by the .NET Core node. Klicken Sie dann auf die Projektvorlage Konsolen-App (.NET Core) .Then select the Console App (.NET Core) project template. Geben Sie „GitHubIssueClassification“ im Textfeld Name ein, und wählen Sie die Schaltfläche OK aus.In the Name text box, type "GitHubIssueClassification" and then select the OK button.

  2. Erstellen Sie ein Verzeichnis mit dem Namen Data in Ihrem Projekt, um die Datasetdateien zu speichern:Create a directory named Data in your project to save your data set files:

    Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie Hinzufügen > Neuer Ordner aus.In Solution Explorer, right-click on your project and select Add > New Folder. Geben Sie „Data“ ein, und drücken Sie die EINGABETASTE.Type "Data" and hit Enter.

  3. Erstellen Sie ein Verzeichnis mit dem Namen Models in Ihrem Projekt, um Ihr Modell zu speichern:Create a directory named Models in your project to save your model:

    Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie Hinzufügen > Neuer Ordner aus.In Solution Explorer, right-click on your project and select Add > New Folder. Geben Sie „Models“ ein, und drücken Sie die EINGABETASTE.Type "Models" and hit Enter.

  4. Installieren des Microsoft.ML NuGet-Pakets:Install the Microsoft.ML NuGet Package:

    Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie NuGet-Pakete verwalten aus.In Solution Explorer, right-click on your project and select Manage NuGet Packages. 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.Choose "nuget.org" as the Package source, select the Browse tab, search for Microsoft.ML and select the Install button. 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.Select the OK button on the Preview Changes dialog and then select the I Accept button on the License Acceptance dialog if you agree with the license terms for the packages listed.

Vorbereiten Ihrer DatenPrepare your data

  1. Laden Sie die Datasets issues_train.tsv und issues_test.tsv herunter, und speichern Sie sie im zuvor erstellten Ordner Daten.Download the issues_train.tsv and the issues_test.tsv data sets and save them to the Data folder previously created. Das erste Dataset trainiert das Machine Learning-Modell, und das zweite kann verwendet werden, um zu evaluieren, wie genau das Modell ist.The first dataset trains the machine learning model and the second can be used to evaluate how accurate your model is.

  2. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die *.tsv-Dateien, und wählen Sie Eigenschaften aus.In Solution Explorer, right-click each of the *.tsv files and select Properties. Ändern Sie unter Erweitert den Wert von In Ausgabeverzeichnis kopieren in Kopieren, wenn neuer.Under Advanced, change the value of Copy to Output Directory to Copy if newer.

Erstellen von Klassen und Definieren von PfadenCreate classes and define paths

Fügen Sie am Anfang der Datei Program.cs folgende zusätzliche using-Anweisungen hinzu:Add the following additional using statements to the top of the Program.cs file:

using System;
using System.IO;
using System.Linq;
using Microsoft.ML;

Erstellen Sie drei globale Felder, die die Pfade zu den zuletzt heruntergeladenen Dateien sowie globale Variablen für MLContext, DataView und PredictionEngine enthalten:Create three global fields to hold the paths to the recently downloaded files, and global variables for the MLContext,DataView, and PredictionEngine:

  • _trainDataPath enthält den Pfad zu dem Dataset, das zum Trainieren des Modells verwendet wird._trainDataPath has the path to the dataset used to train the model.
  • _testDataPath enthält den Pfad zu dem Dataset, das zum Evaluieren des Modells verwendet wird._testDataPath has the path to the dataset used to evaluate the model.
  • _modelPath enthält den Pfad zu dem Speicherort, in dem das trainierte Modell gespeichert ist._modelPath has the path where the trained model is saved.
  • _mlContext ist die MLContext-Klasse, die den Verarbeitungskontext enthält._mlContext is the MLContext that provides processing context.
  • _trainingDataView ist die zum Verarbeiten des Trainingsdatasets verwendete IDataView-Schnittstelle._trainingDataView is the IDataView used to process the training dataset.
  • _predEngine ist die für einzelne Vorhersagen verwendete PredictionEngine<TSrc,TDst>-Klasse._predEngine is the PredictionEngine<TSrc,TDst> used for single predictions.

Fügen Sie den folgenden Code der Zeile direkt über der Main-Methode hinzu, um diese Pfade und die anderen Variablen anzugeben:Add the following code to the line right above the Main method to specify those paths and the other variables:

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

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

Erstellen Sie einige Klassen für Ihre Eingabedaten und Vorhersagen.Create some classes for your input data and predictions. Fügen Sie dem Projekt eine neue Klasse hinzu:Add a new class to your project:

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie dann Hinzufügen > Neues Element aus.In Solution Explorer, right-click the project, and then select Add > New Item.

  2. Wählen Sie im Dialogfeld Neues Element hinzufügen die Option Klasse aus, und ändern Sie das Feld Name in GitHubIssueData.cs.In the Add New Item dialog box, select Class and change the Name field to GitHubIssueData.cs. Wählen Sie dann die Schaltfläche Hinzufügen aus.Then, select the Add button.

    Die Datei GitHubIssueData.cs wird im Code-Editor geöffnet.The GitHubIssueData.cs file opens in the code editor. Fügen Sie am Anfang der Datei GitHubIssueData.cs die folgende using-Anweisung hinzu:Add the following using statement to the top of GitHubIssueData.cs:

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:Remove the existing class definition and add the following code, which has two classes GitHubIssue and IssuePrediction, to the GitHubIssueData.cs file:

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

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

label ist die Spalte, die vorhergesagt werden soll.The label is the column you want to predict. Die identifizierten Features sind die Eingaben, die Sie für das Modell zum Vorhersagen der Bezeichnung bereitstellen.The identified Features are the inputs you give the model to predict the Label.

Verwenden Sie das LoadColumnAttribute, um die Indizes der Quellspalten im Dataset festzulegen.Use the LoadColumnAttribute to specify the indices of the source columns in the data set.

GitHubIssue ist die Klasse des Eingabedatasets mit den folgenden String-Feldern:GitHubIssue is the input dataset class and has the following String fields:

  • Die erste Spalte: ID (ID des GitHub-Issues)the first column ID (GitHub Issue ID)
  • Die zweite Spalte: Area (Vorhersage für das Training)the second column Area (the prediction for training)
  • Die dritte Spalte Title (Titel des GitHub-Issues) ist das erste feature zur Vorhersage von Areathe third column Title (GitHub issue title) is the first feature used for predicting the Area
  • Die vierte Spalte Description ist das zweite feature für die Vorhersage von Areathe fourth column Description is the second feature used for predicting the Area

Die IssuePrediction-Klasse wird für die Vorhersage verwendet, nachdem das Modell trainiert wurde.IssuePrediction is the class used for prediction after the model has been trained. Sie verfügt über ein einzelnes string- (Area) und ein PredictedLabel ColumnName-Attribut.It has a single string (Area) and a PredictedLabel ColumnName attribute. Das PredictedLabel wird während der Vorhersage und Evaluierung verwendet.The PredictedLabel is used during prediction and evaluation. Für die Evaluierung werden eine Eingabe mit Trainingsdaten, die vorhergesagten Werte und das Modell verwendet.For evaluation, an input with training data, the predicted values, and the model are used.

Alle ML.NET-Operationen beginnen in der MLContext-Klasse.All ML.NET operations start in the MLContext class. 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.Initializing mlContext creates a new ML.NET environment that can be shared across the model creation workflow objects. Die Klasse ähnelt dem Konzept von DBContext in Entity Framework.It's similar, conceptually, to DBContext in Entity Framework.

Initialisieren von Variablen in MainInitialize variables in Main

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.Initialize the _mlContext global variable with a new instance of MLContext with a random seed (seed: 0) for repeatable/deterministic results across multiple trainings. Ersetzen Sie die Zeile Console.WriteLine("Hello World!") mit dem folgenden Code in der Main-Methode:Replace the Console.WriteLine("Hello World!") line with the following code in the Main method:

_mlContext = new MLContext(seed: 0);

Laden der DatenLoad the data

Für ML.NET wird die IDataView-Klasse als flexible, effiziente Möglichkeit zum Beschreiben von Tabellendaten in Zahlen- oder Textform verwendet.ML.NET uses the IDataView class as a flexible, efficient way of describing numeric or text tabular data. Mit IDataView können entweder Textdateien geladen werden, oder es kann ein Echtzeitladevorgang durchgeführt werden (z.B. SQL-Datenbank- oder Protokolldateien).IDataView can load either text files or in real time (for example, SQL database or log files).

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:To initialize and load the _trainingDataView global variable in order to use it for the pipeline, add the following code after the mlContext initialization:

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

Die LoadFromTextFile()-Methode definiert das Datenschema und liest die Datei ein.The LoadFromTextFile() defines the data schema and reads in the file. Diese Methode akzeptiert Datenpfadvariablen und gibt ein IDataView-Objekt zurück.It takes in the data path variables and returns an IDataView.

Fügen Sie den folgenden Text als nächste Codezeile in die Main-Methode ein:Add the following as the next line of code in the Main method:

var pipeline = ProcessData();

Die ProcessData-Methode führt die folgenden Aufgaben aus:The ProcessData method executes the following tasks:

  • Extrahieren und Transformieren der Daten.Extracts and transforms the data.
  • Zurückgeben der VerarbeitungspipelineReturns the processing pipeline.

Erstellen Sie die ProcessData-Methode mit dem folgenden Code direkt nach der Main-Methode:Create the ProcessData method, just after the Main method, using the following code:

public static IEstimator<ITransformer> ProcessData()
{

}

Extrahieren von Features und Transformieren der DatenExtract Features and transform the data

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:As you want to predict the Area GitHub label for a GitHubIssue, use the MapValueToKey() method to transform the Area column into a numeric key type Label column (a format accepted by classification algorithms) and add it as a new dataset column:

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.Next, call mlContext.Transforms.Text.FeaturizeText which transforms the text (Title and Description) columns into a numeric vector for each called TitleFeaturized and DescriptionFeaturized. Fügen Sie an die Pipeline die Featurebereitstellung für beide Spalten mit dem folgenden Code an:Append the featurization for both columns to the pipeline with the following code:

.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.The last step in data preparation combines all of the feature columns into the Features column using the Concatenate() method. Standardmäßig verarbeitet ein Lernalgorithmus nur Merkmale aus der Spalte Features.By default, a learning algorithm processes only features from the Features column. Fügen Sie an die Pipeline diese Transformation mit dem folgenden Code an:Append this transformation to the pipeline with the following code:

.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:Next, append a AppendCacheCheckpoint to cache the DataView so when you iterate over the data multiple times using the cache might get better performance, as with the following code:

.AppendCacheCheckpoint(_mlContext);

Warnung

Verwenden Sie AppendCacheCheckpoint für kleine/mittlere Datasets, um die Zeit für das Training zu reduzieren.Use AppendCacheCheckpoint for small/medium datasets to lower training time. Verwenden Sie dies NICHT bei der Verarbeitung sehr großer Datasets (entfernen Sie .AppendCacheCheckpoint()).Do NOT use it (remove .AppendCacheCheckpoint()) when handling very large datasets.

Geben Sie die Pipeline am Ende der ProcessData-Methode zurück.Return the pipeline at the end of the ProcessData method.

return pipeline;

In diesem Schritt wird die Vorverarbeitung/Featurebereitstellung behandelt.This step handles preprocessing/featurization. Die Verwendung zusätzlicher in ML.NET verfügbarer Komponenten kann bessere Ergebnisse mit dem Modell ermöglichen.Using additional components available in ML.NET can enable better results with your model.

Erstellen und Trainieren des ModellsBuild and train the model

Fügen Sie der BuildAndTrainModel-Methode den folgenden Aufruf als nächste Codezeile der Main-Methode hinzu:Add the following call to the BuildAndTrainModelmethod as the next line of code in the Main method:

var trainingPipeline = BuildAndTrainModel(_trainingDataView, pipeline);

Die BuildAndTrainModel-Methode führt die folgenden Aufgaben aus:The BuildAndTrainModel method executes the following tasks:

  • Erstellen der Algorithmusklasse für das TrainingCreates the training algorithm class.
  • Trainieren des Modells.Trains the model.
  • Vorhersagen des Bereichs basierend auf den TrainingsdatenPredicts area based on training data.
  • Zurückgeben des Modells.Returns the model.

Erstellen Sie die BuildAndTrainModel-Methode mit dem folgenden Code direkt nach der Main-Methode:Create the BuildAndTrainModel method, just after the Main method, using the following code:

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

}

Informationen zur KlassifizierungsaufgabeAbout the classification task

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:Classification is a machine learning task that uses data to determine the category, type, or class of an item or row of data and is frequently one of the following types:

  • Binär: entweder A oder B.Binary: either A or B.
  • Multiklasse: mehrere Kategorien, die mit einem einzelnen Modell vorhergesagt werden können.Multiclass: multiple categories that can be predicted by using a single model.

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.For this type of problem, use a Multiclass classification learning algorithm, since your issue category prediction can be one of multiple categories (multiclass) rather than just two (binary).

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:Append the machine learning algorithm to the data transformation definitions by adding the following as the first line of code in BuildAndTrainModel():

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

Der SdcaMaximumEntropy Algorithmus für die Multiklassenklassifizierung.The SdcaMaximumEntropy is your multiclass classification training algorithm. 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.This is appended to the pipeline and accepts the featurized Title and Description (Features) and the Label input parameters to learn from the historic data.

Trainieren des ModellsTrain the model

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:Fit the model to the splitTrainSet data and return the trained model by adding the following as the next line of code in the BuildAndTrainModel() method:

_trainedModel = trainingPipeline.Fit(trainingDataView);

Mit der Fit()-Methode wird Ihr Modell trainiert, indem das Dataset transformiert und das Training angewendet wird.The Fit()method trains your model by transforming the dataset and applying the training.

Die PredictionEngine ist eine Hilfs-API, mit der Sie eine einzelne Instanz der Daten übergeben und dafür dann eine Vorhersage treffen können.The PredictionEngine is a convenience API, which allows you to pass in and then perform a prediction on a single instance of data. Fügen Sie das als nächste Zeile in der BuildAndTrainModel()-Methode hinzu:Add this as the next line in the BuildAndTrainModel() method:

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

Vorhersagen treffen mit dem trainierten ModellPredict with the trained model

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:Add a GitHub issue to test the trained model's prediction in the Predict method by creating an instance of GitHubIssue:

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:Use the Predict() function makes a prediction on a single row of data:

var prediction = _predEngine.Predict(issue);

Verwenden des Modells: VorhersageergebnisseUsing the model: prediction results

Zeigen Sie GitHubIssue und die entsprechende Vorhersage der Area-Bezeichnung an, um die Ergebnisse freizugeben und entsprechenden Aktionen auszuführen.Display GitHubIssue and corresponding Area label prediction in order to share the results and act on them accordingly. Erstellen Sie mit dem folgenden Console.WriteLine()-Code eine Anzeige für die Ergebnisse:Create a display for the results using the following Console.WriteLine() code:

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

Zurückgeben des für die Evaluierung trainierten ModellsReturn the model trained to use for evaluation

Geben Sie das Modell am Ende der BuildAndTrainModel-Methode zurück.Return the model at the end of the BuildAndTrainModel method.

return trainingPipeline;

Evaluieren des ModellsEvaluate the model

Da Sie nun das Modell erstellt und trainiert haben, müssen Sie es zur Qualitätssicherung und Validierung mit einem anderen Dataset evaluieren.Now that you've created and trained the model, you need to evaluate it with a different dataset for quality assurance and validation. In der Evaluate-Methode wird das in BuildAndTrainModel erstellte Modell zur Evaluierung übergeben.In the Evaluate method, the model created in BuildAndTrainModel is passed in to be evaluated. Erstellen Sie die Evaluate-Methode direkt nach BuildAndTrainModel wie im folgenden Code:Create the Evaluate method, just after BuildAndTrainModel, as in the following code:

public static void Evaluate(DataViewSchema trainingDataViewSchema)
{

}

Die Evaluate-Methode führt die folgenden Aufgaben aus:The Evaluate method executes the following tasks:

  • Laden des Testdatasets.Loads the test dataset.
  • Erstellen des MultiklassenauswertersCreates the multiclass evaluator.
  • Evaluieren des Modells und Erstellen von Metriken.Evaluates the model and create metrics.
  • Anzeigen der Metriken.Displays the metrics.

Fügen Sie einen Aufruf der neuen Methode aus der Main-Methode mit dem folgenden Code direkt unter dem BuildAndTrainModel-Methodenaufruf hinzu:Add a call to the new method from the Main method, right under the BuildAndTrainModel method call, using the following code:

Evaluate(_trainingDataView.Schema);

Wie zuvor beim Trainingsdataset laden Sie das Testdataset, indem Sie den folgenden Code zur Evaluate-Methode hinzufügen:As you did previously with the training dataset, load the test dataset by adding the following code to the Evaluate method:

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

Die Evaluate()-Methode berechnet die Qualitätsmetriken für das Modell mit dem angegebenen Dataset.The Evaluate() method computes the quality metrics for the model using the specified dataset. Das zurückgegebene MulticlassClassificationMetrics-Objekt enthält alle von Auswertern der Multiklassenklassifizierung berechneten Metriken.It returns a MulticlassClassificationMetrics object that contains the overall metrics computed by multiclass classification evaluators. Um diese Metriken zum Ermitteln der Modellqualität anzuzeigen, müssen Sie sie zunächst abrufen.To display the metrics to determine the quality of the model, you need to get them first. Beachten Sie die Verwendung der Transform()-Methode der globalen Machine Learning-Variable _trainedModel (ein Transformator), um die Features einzugeben und die Vorhersagen zurückzugeben.Notice the use of the Transform() method of the machine learning _trainedModel global variable (an ITransformer) to input the features and return predictions. Fügen Sie der Evaluate-Methode folgenden Code als nächste Zeile hinzu:Add the following code to the Evaluate method as the next line:

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

Für die Multiklassenklassifizierung werden die folgenden Metriken ausgewertet:The following metrics are evaluated for multiclass classification:

  • Mikrogenauigkeit: Jedes Beispiel/Klasse-Paar trägt zu gleichen Teilen zur Genauigkeitsmetrik bei.Micro Accuracy - Every sample-class pair contributes equally to the accuracy metric. Die Mikrogenauigkeit sollte so nahe wie möglich bei 1 liegen.You want Micro Accuracy to be as close to one as possible.

  • Makrogenauigkeit: Jede Klasse trägt zu gleichen Teilen zur Genauigkeitsmetrik bei.Macro Accuracy - Every class contributes equally to the accuracy metric. Minderheitsklassen werden gleich wie größere Klassen gewichtet.Minority classes are given equal weight as the larger classes. Die Makrogenauigkeit sollte so nahe wie möglich bei 1 liegen.You want Macro Accuracy to be as close to one as possible.

  • Protokollverlust: Siehe Protokollverlust.Log-loss - see Log Loss. Der Protokollverlust sollte so nahe wie möglich bei 0 liegen.You want Log-loss to be as close to zero as possible.

  • Verringerung des Protokollverlusts: Dieser liegt zwischen -inf und 1.00, wobei „1.00“ perfekte Vorhersagen und „0“ durchschnittliche Vorhersagen bedeutet.Log-loss reduction - Ranges from [-inf, 1.00], where 1.00 is perfect predictions and 0 indicates mean predictions. Die Verringerung des Protokollverlusts sollte so nahe wie möglich bei 0 liegen.You want Log-loss reduction to be as close to one as possible.

Anzeigen der Metriken zur ModellvalidierungDisplaying the metrics for model validation

Verwenden Sie den folgenden Code, um die Metriken anzuzeigen, die Ergebnisse freizugeben und dann mit ihnen zu arbeiten:Use the following code to display the metrics, share the results, and then act on them:

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 DateiSave the model to a file

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.Once satisfied with your model, save it to a file to make predictions at a later time or in another application. Fügen Sie der Evaluate -Methode folgenden Code hinzu.Add the following code to the Evaluate method.

SaveModelAsFile(_mlContext, trainingDataViewSchema, _trainedModel);

Erstellen Sie die SaveModelAsFile-Methode unter der Evaluate-Methode.Create the SaveModelAsFile method below your Evaluate method.

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

}

Fügen Sie der SaveModelAsFile-Methode den folgenden Code hinzu.Add the following code to your SaveModelAsFile method. Dieser Code verwendet die Save-Methode, um das trainierte Modell zu serialisieren und als ZIP-Datei zu speichern.This code uses the Save method to serialize and store the trained model as a zip file.

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

Bereitstellen eines Modells und Treffen von VorhersagenDeploy and Predict with a model

Fügen Sie einen Aufruf der neuen Methode aus der Main-Methode mit dem folgenden Code direkt unter dem Evaluate-Methodenaufruf hinzu:Add a call to the new method from the Main method, right under the Evaluate method call, using the following code:

PredictIssue();

Erstellen Sie die PredictIssue-Methode unmittelbar nach der Evaluate-Methode (und direkt vor der SaveModelAsFile-Methode) mithilfe des folgenden Codes:Create the PredictIssue method, just after the Evaluate method (and just before the SaveModelAsFile method), using the following code:

private static void PredictIssue()
{

}

Die PredictIssue-Methode führt die folgenden Aufgaben aus:The PredictIssue method executes the following tasks:

  • Laden des gespeicherte ModellsLoads the saved model
  • Erstellen eines einzelnen Issues aus TestdatenCreates a single issue of test data.
  • Vorhersagen des Bereichs basierend auf TestdatenPredicts Area based on test data.
  • Kombinieren von Testdaten und Vorhersagen für die Berichterstattung.Combines test data and predictions for reporting.
  • Anzeigen der vorhergesagten Ergebnisse.Displays the predicted results.

Laden Sie das gespeicherte Modell in Ihre Anwendung, indem Sie der PredictIssue-Methode den folgenden Code hinzufügen:Load the saved model into your application by adding the following code to the PredictIssue method:

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:Add a GitHub issue to test the trained model's prediction in the Predict method by creating an instance of GitHubIssue:

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:As you did previously, create a PredictionEngine instance with the following 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.The PredictionEngine is a convenience API, which allows you to perform a prediction on a single instance of data. PredictionEngine ist nicht threadsicher.PredictionEngine is not thread-safe. Die Verwendung in Singlethread-oder Prototypumgebungen ist zulässig.It's acceptable to use in single-threaded or prototype environments. 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.For improved performance and thread safety in production environments, use the PredictionEnginePool service, which creates an ObjectPool of PredictionEngine objects for use throughout your application. Informationen zur Verwendung von PredictionEnginePool in einer ASP.NET Core-Web-API finden Sie in dieser Anleitung.See this guide on how to use PredictionEnginePool in an ASP.NET Core Web API

Hinweis

Die PredictionEnginePool-Diensterweiterung ist derzeit als Vorschauversion verfügbar.PredictionEnginePool service extension is currently in preview.

Verwenden Sie die PredictionEngine, um die GitHub-Bereichsbezeichnung vorherzusagen, indem Sie den folgenden Code zur PredictIssue-Methode für die Vorhersage hinzufügen:Use the PredictionEngine to predict the Area GitHub label by adding the following code to the PredictIssue method for the prediction:

var prediction = _predEngine.Predict(singleIssue);

Verwenden des geladenen Modells für VorhersagenUsing the loaded model for prediction

Zeigen Sie Area an, um das Issue zu kategorisieren und eine entsprechende Aktion auszuführen.Display Area in order to categorize the issue and act on it accordingly. Erstellen Sie mit dem folgenden Console.WriteLine()-Code eine Anzeige für die Ergebnisse:Create a display for the results using the following Console.WriteLine() code:

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

ErgebnisseResults

Die Ergebnisse sollten den unten dargestellten ähneln.Your results should be similar to the following. Während der Pipelineverarbeitung werden Meldungen angezeigt.As the pipeline processes, it displays messages. Sie können Warnungen oder Verarbeitungsmeldungen sehen.You may see warnings, or processing messages. Diese Nachrichten wurden der Übersichtlichkeit halber aus den folgenden Ergebnissen entfernt.These messages have been removed from the following results for clarity.

=============== 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!Congratulations! Sie haben jetzt erfolgreich ein Machine Learning-Modell zur Klassifizierung und Vorhersage der Bereichsbezeichnung für ein GitHub-Issue erstellt.You've now successfully built a machine learning model for classifying and predicting an Area label for a GitHub issue. Sie finden den Quellcode für dieses Tutorial im Repository dotnet/samples.You can find the source code for this tutorial at the dotnet/samples repository.

Nächste SchritteNext steps

In diesem Tutorial haben Sie gelernt, wie die folgenden Aufgaben ausgeführt werden:In this tutorial, you learned how to:

  • Vorbereiten Ihrer DatenPrepare your data
  • Transformieren der DatenTransform the data
  • Trainieren des ModellsTrain the model
  • Evaluieren des ModellsEvaluate the model
  • Vorhersagen treffen mit dem trainierten ModellPredict with the trained model
  • Bereitstellen eines geladenen Modells und Vorhersagen mit diesem treffenDeploy and Predict with a loaded model

Wechseln Sie zum nächsten Tutorial, um mehr zu erfahren.Advance to the next tutorial to learn more