Lernprogramm: Analysieren der Stimmung von Websitekommentaren mit binärer Klassifizierung in ML.NET

In diesem Lernprogramm erfahren Sie, wie Sie eine .NET-Konsolenanwendung erstellen, die die Stimmung von Websitekommentaren klassifiziert und die entsprechende Aktion ausführt. Der Klassifizierer für binäre Stimmungen verwendet C# in Visual Studio 2022.

In diesem Tutorial erfahren Sie, wie:

• Erstellen einer Konsolenanwendung
• Vorbereiten von Daten
• Laden der Daten
• Erstellen und Trainieren des Modells
• Auswerten des Modells
• Verwenden des Modells zum Erstellen einer Vorhersage
• Die Ergebnisse anzeigen

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

Voraussetzungen

• Visual Studio 2022 oder höher.

• Dataset "UCI Sentiment Labeled Sentences" (ZIP-Datei)

Erstellen einer Konsolenanwendung

1. Erstellen Sie eine C# -Konsolenanwendung namens "SentimentAnalysis". 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. Erstellen Sie ein Verzeichnis mit dem Namen "Daten " in Ihrem Projekt, um Ihre Datasetdateien zu speichern.

4. 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, und wählen Sie dann die Registerkarte " Durchsuchen " aus. Suchen Sie nach Microsoft.ML, wählen Sie das gewünschte Paket und dann "Installieren" aus. Fahren Sie mit der Installation fort, indem Sie den Lizenzbedingungen für das von Ihnen ausgewählte Paket zustimmen.

Bereiten Sie die Daten vor.

Hinweis

Die Datensätze für dieses Lernprogramm stammen aus der Veröffentlichung „From Group to Individual Labels using Deep Features“ von Kotzias et al. KDD 2015 und gehostet im UCI Machine Learning Repository - Dua, D. und Karra Taniskidou, E. (2017). UCI Machine Learning Repository [http://archive.ics.uci.edu/ml]. Irvine, C. A.: University of California, School of Information and Computer Science.

1. Laden Sie die ZIP-Datei "UCI Sentiment Labeled Sentences" herunter, und entzippen Sie die ZIP-Datei.

2. Kopieren Sie die yelp_labelled.txt Datei in das von Ihnen erstellte Datenverzeichnis .

3. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die yelp_labelled.txt Datei, 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;
   using SentimentAnalysis;
   using static Microsoft.ML.DataOperationsCatalog;
   

2. Fügen Sie der Zeile direkt unterhalb der using Direktiven den folgenden Code hinzu, um ein Feld zu erstellen, das den zuletzt heruntergeladenen Datasetdateipfad enthält:

   string _dataPath = Path.Combine(Environment.CurrentDirectory, "Data", "yelp_labelled.txt");
   

3. Erstellen Sie als Nächstes Klassen für Ihre Eingabedaten und -vorhersagen. Fügen Sie Ihrem Projekt eine neue Klasse hinzu:

   • Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie dann "> hinzufügen" aus.

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

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

   using Microsoft.ML.Data;
   

5. Entfernen Sie die vorhandene Klassendefinition und fügen Sie den folgenden Code hinzu, welcher die zwei Klassen SentimentData und SentimentPrediction enthält, in die Datei SentimentData.cs hinzu:

   public class SentimentData
   {
       [LoadColumn(0)]
       public string? SentimentText;
   
       [LoadColumn(1), ColumnName("Label")]
       public bool Sentiment;
   }
   
   public class SentimentPrediction : SentimentData
   {
   
       [ColumnName("PredictedLabel")]
       public bool Prediction { get; set; }
   
       public float Probability { get; set; }
   
       public float Score { get; set; }
   }
   

Wie die Daten vorbereitet wurden

Die Eingabe-Datasetklasse SentimentDatahat einen string Wert für Benutzerkommentare (SentimentText) und einen bool (Sentiment) Wert von 1 (positiv) oder 0 (negativ) für die Stimmung. Beide Felder verfügen über "LoadColumn "-Attribute, die die Datendateireihenfolge jedes Felds beschreiben. Darüber hinaus verfügt die Sentiment Eigenschaft über ein ColumnName-Attribut , um sie als Label Feld festzulegen. Die folgende Beispieldatei verfügt nicht über eine Kopfzeile und sieht wie folgt aus:

SentimentText	Stimmung (Bezeichnung)
Waitress war ein wenig langsam im Dienst.	0
Die Kruste ist nicht gut.	0
Beeindruckend... Liebte diesen Ort.	1
Service war sehr prompt.	1

SentimentPrediction ist die Vorhersageklasse, die nach der Modellschulung verwendet wird. Es erbt von SentimentData, damit die Eingabe SentimentText zusammen mit der Ausgabevorhersage angezeigt werden kann. Der Prediction boolesche Wert ist der Wert, der vom Modell vorhergesagt wird, wenn es mit neuen Eingaben SentimentTextbereitgestellt wird.

Die Ausgabeklasse SentimentPrediction enthält zwei weitere Eigenschaften, die vom Modell berechnet werden: Score - die vom Modell berechnete Rohbewertung und Probability - die Bewertung, die auf die Wahrscheinlichkeit des Texts mit positiven Stimmungen kalibriert wurde.

In diesem Lernprogramm ist die wichtigste Eigenschaft Prediction.

Laden der Daten

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.

Die MLContext-Klasse ist ein Ausgangspunkt für alle ML.NET Vorgänge. 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 dem DBContext Entity Framework.

Sie bereiten die App vor und laden dann Daten:

1. Ersetzen Sie die Console.WriteLine("Hello World!") Zeile durch den folgenden Code, um die mlContext-Variable zu deklarieren und zu initialisieren:

   MLContext mlContext = new MLContext();
   

2. Fügen Sie Folgendes als nächste Codezeile hinzu:

   TrainTestData splitDataView = LoadData(mlContext);
   

3. Erstellen Sie unten in der LoadData() Datei eine Program.cs Methode mit dem folgenden Code:

   TrainTestData LoadData(MLContext mlContext)
   {
   
   }
   

   Die LoadData() Methode führt die folgenden Aufgaben aus:

   • Lädt die Daten.
   • Teilt das geladene Dataset in Train- und Test-Datasets auf.
   • Gibt die aufgeteilten Trainings- und Testdatensätze zurück.

4. Fügen Sie den folgenden Code als erste Zeile der LoadData() Methode hinzu:

   IDataView dataView = mlContext.Data.LoadFromTextFile<SentimentData>(_dataPath, hasHeader: false);
   

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

Teilen des Datensatzes für Modellschulung und -tests

Beim Vorbereiten eines Modells verwenden Sie einen Teil des Datasets, um es und einen Teil des Datasets zu trainieren, um die Genauigkeit des Modells zu testen.

1. Um die geladenen Daten in die erforderlichen Datasets aufzuteilen, fügen Sie den folgenden Code als nächste Zeile in der LoadData() Methode hinzu:

   TrainTestData splitDataView = mlContext.Data.TrainTestSplit(dataView, testFraction: 0.2);
   

   Der vorherige Code verwendet die TrainTestSplit()- Methode, um das geladene Dataset in Train- und Test-Datasets aufzuteilen und in der DataOperationsCatalog.TrainTestData Klasse zurückzugeben. Geben Sie den Prozentsatz der Testsatzdaten mit dem testFractionParameter an. Der Standardwert ist 10%, in diesem Fall verwenden Sie 20%, um weitere Daten auszuwerten.

2. Gibt das splitDataView Ende der LoadData() Methode zurück:

   return splitDataView;
   

Erstellen und Trainieren des Modells

1. Fügen Sie den folgenden Aufruf der BuildAndTrainModelMethode unterhalb des Aufrufs der LoadData Methode hinzu:

   ITransformer model = BuildAndTrainModel(mlContext, splitDataView.TrainSet);
   

   Die BuildAndTrainModel() Methode führt die folgenden Aufgaben aus:

   • Extrahiert und transformiert die Daten.
   • Trainiert das Modell.
   • Prognostiziert die Stimmung basierend auf Testdaten.
   • Gibt das Modell zurück.

2. Erstellen Sie die BuildAndTrainModel() Methode unter der LoadData() Methode mit dem folgenden Code:

   ITransformer BuildAndTrainModel(MLContext mlContext, IDataView splitTrainSet)
   {
   
   }
   

Extrahieren und Transformieren der Daten

1. Rufen Sie FeaturizeText als nächste Codezeile auf:

   var estimator = mlContext.Transforms.Text.FeaturizeText(outputColumnName: "Features", inputColumnName: nameof(SentimentData.SentimentText))
   

   Die FeaturizeText() Methode im vorherigen Code konvertiert die Textspalte (SentimentText) in eine numerische Schlüsseltypspalte Features , die vom Machine Learning-Algorithmus verwendet wird, und fügt sie als neue Datasetspalte hinzu:

   SentimentText	Gefühl	Features
   Waitress war ein wenig langsam im Dienst.	0	[0.76, 0.65, 0.44, …]
   Die Kruste ist nicht gut.	0	[0.98, 0.43, 0.54, …]
   Beeindruckend... Liebte diesen Ort.	1	[0.35, 0.73, 0.46, …]
   Service war sehr prompt.	1	[0.39, 0, 0.75, …]

Hinzufügen eines Lernalgorithmus

Diese App verwendet einen Klassifizierungsalgorithmus, der Elemente oder Datenzeilen kategorisiert. Die App kategorisiert Websitekommentare entweder positiv oder negativ, verwenden Sie daher die Binäre Klassifizierungsaufgabe.

Fügen Sie die Aufgabe des maschinellen Lernens zu den Definitionen der Datentransformation hinzu, indem Sie Folgendes als nächste Zeile in BuildAndTrainModel() hinzufügen:

.Append(mlContext.BinaryClassification.Trainers.SdcaLogisticRegression(labelColumnName: "Label", featureColumnName: "Features"));

Der SdcaLogisticRegressionBinaryTrainer ist Ihr Klassifizierungstrainingsalgorithmus. Dies wird an die featurisierte estimator und akzeptiert die SentimentText (Features) und 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:

Console.WriteLine("=============== Create and Train the Model ===============");
var model = estimator.Fit(splitTrainSet);
Console.WriteLine("=============== End of training ===============");
Console.WriteLine();

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

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

Gibt das Modell am Ende der BuildAndTrainModel() Methode zurück:

return model;

Auswerten des Modells

Nachdem Ihr Modell trainiert wurde, verwenden Sie Ihre Testdaten, um die Leistung des Modells zu überprüfen.

1. Erstellen Sie die Evaluate() Methode direkt hinter BuildAndTrainModel()dem folgenden Code:

   void Evaluate(MLContext mlContext, ITransformer model, IDataView splitTestSet)
   {
   
   }
   

   Die Evaluate() Methode führt die folgenden Aufgaben aus:

   • Lädt das Test-Dataset.
   • Erstellt den BinaryClassification-Evaluator.
   • Wertet das Modell aus und erstellt Metriken.
   • Zeigt die Metriken an.

2. Fügen Sie unterhalb des BuildAndTrainModel-Methodenaufrufs einen Aufruf der neuen Methode mithilfe des folgenden Codes hinzu.

   Evaluate(mlContext, model, splitDataView.TestSet);
   

3. Transformieren Sie die splitTestSet Daten, indem Sie den folgenden Code hinzufügen zu Evaluate():

   Console.WriteLine("=============== Evaluating Model accuracy with Test data===============");
   IDataView predictions = model.Transform(splitTestSet);
   

   Der vorherige Code verwendet die Transform()- Methode, um Vorhersagen für mehrere bereitgestellte Eingabezeilen eines Test-Datasets zu erstellen.

4. Bewerten Sie das Modell, indem Sie Folgendes als nächste Codezeile in der Evaluate() Methode hinzufügen:

   CalibratedBinaryClassificationMetrics metrics = mlContext.BinaryClassification.Evaluate(predictions, "Label");
   

Nachdem Sie den Vorhersagesatz (predictions) festgelegt haben, bewertet die Evaluate() -Methode das Modell, das die vorhergesagten Werte mit dem tatsächlichen Labels Im Testdatensatz vergleicht und ein KalibrierBinaryClassificationMetrics-Objekt zurückgibt, wie das Modell ausgeführt wird.

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

Verwenden Sie den folgenden Code, um die Metriken anzuzeigen:

Console.WriteLine();
Console.WriteLine("Model quality metrics evaluation");
Console.WriteLine("--------------------------------");
Console.WriteLine($"Accuracy: {metrics.Accuracy:P2}");
Console.WriteLine($"Auc: {metrics.AreaUnderRocCurve:P2}");
Console.WriteLine($"F1Score: {metrics.F1Score:P2}");
Console.WriteLine("=============== End of model evaluation ===============");

• Die Accuracy Metrik ruft die Genauigkeit eines Modells ab, bei dem es sich um den Anteil der richtigen Vorhersagen im Testsatz handelt.

• Die AreaUnderRocCurve Metrik gibt an, wie sicher das Modell die positiven und negativen Klassen korrekt klassifizieren kann. Sie möchten, dass dies AreaUnderRocCurve so nah wie möglich ist.

• Die F1Score Metrik ruft die F1-Bewertung des Modells ab, bei der es sich um ein Maß für das Gleichgewicht zwischen Genauigkeit und Rückruf handelt. Sie möchten, dass dies F1Score so nah wie möglich ist.

Vorhersagen des Testdatenergebnisses

1. Erstellen Sie die UseModelWithSingleItem() Methode direkt nach der Evaluate() Methode mithilfe des folgenden Codes:

   void UseModelWithSingleItem(MLContext mlContext, ITransformer model)
   {
   
   }
   

   Die UseModelWithSingleItem() Methode führt die folgenden Aufgaben aus:

   • Erstellt einen einzelnen Kommentar von Testdaten.
   • Prognostiziert die Stimmung basierend auf Testdaten.
   • Kombiniert Testdaten und Vorhersagen für die Berichterstellung.
   • Zeigt die vorhergesagten Ergebnisse an.

2. Fügen Sie direkt unter dem Evaluate()-Methodenaufruf einen Aufruf der neuen Methode mithilfe des folgenden Codes hinzu:

   UseModelWithSingleItem(mlContext, model);
   

3. Fügen Sie den folgenden Code hinzu, der als erste Zeile in der UseModelWithSingleItem() Methode erstellt werden soll:

   PredictionEngine<SentimentData, SentimentPrediction> predictionFunction = mlContext.Model.CreatePredictionEngine<SentimentData, SentimentPrediction>(model);
   

   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. Fügen Sie einen Kommentar hinzu, um die Vorhersage des trainierten Modells in der UseModelWithSingleItem() Methode zu testen, indem Sie eine Instanz von SentimentData erstellen.

   SentimentData sampleStatement = new SentimentData
   {
       SentimentText = "This was a very bad steak"
   };
   

5. Übergeben Sie die Testkommentardaten an die PredictionEngine, indem Sie die folgenden Zeilen als nächsten Code in der Methode UseModelWithSingleItem() hinzufügen.

   var resultPrediction = predictionFunction.Predict(sampleStatement);
   

   Die Funktion "Vorhersagen()" macht eine Vorhersage für eine einzelne Datenzeile.

6. Anzeigen SentimentText und entsprechende Stimmungsvorhersage mithilfe des folgenden Codes:

   Console.WriteLine();
   Console.WriteLine("=============== Prediction Test of model with a single sample and test dataset ===============");
   
   Console.WriteLine();
   Console.WriteLine($"Sentiment: {resultPrediction.SentimentText} | Prediction: {(Convert.ToBoolean(resultPrediction.Prediction) ? "Positive" : "Negative")} | Probability: {resultPrediction.Probability} ");
   
   Console.WriteLine("=============== End of Predictions ===============");
   Console.WriteLine();
   

Verwenden des Modells für die Vorhersage

Bereitstellen und Vorhersagen von Batchelementen

1. Erstellen Sie die UseModelWithBatchItems() Methode direkt nach der UseModelWithSingleItem() Methode mithilfe des folgenden Codes:

   void UseModelWithBatchItems(MLContext mlContext, ITransformer model)
   {
   
   }
   

   Die UseModelWithBatchItems() Methode führt die folgenden Aufgaben aus:

   • Erstellt Batchtestdaten.
   • Prognostiziert die Stimmung basierend auf Testdaten.
   • Kombiniert Testdaten und Vorhersagen für die Berichterstellung.
   • Zeigt die vorhergesagten Ergebnisse an.

2. Fügen Sie direkt unter dem UseModelWithSingleItem()-Methodenaufruf einen Aufruf der neuen Methode mithilfe des folgenden Codes hinzu:

   UseModelWithBatchItems(mlContext, model);
   

3. Fügen Sie einige Kommentare hinzu, um die Vorhersagen des trainierten Modells in der UseModelWithBatchItems() Methode zu testen:

   IEnumerable<SentimentData> sentiments = new[]
   {
       new SentimentData
       {
           SentimentText = "This was a horrible meal"
       },
       new SentimentData
       {
           SentimentText = "I love this spaghetti."
       }
   };
   

Kommentarstimmung vorhersagen

Verwenden Sie das Modell, um die Kommentardatenstimmung mithilfe der Transform()- Methode vorherzusagen:

IDataView batchComments = mlContext.Data.LoadFromEnumerable(sentiments);

IDataView predictions = model.Transform(batchComments);

// Use model to predict whether comment data is Positive (1) or Negative (0).
IEnumerable<SentimentPrediction> predictedResults = mlContext.Data.CreateEnumerable<SentimentPrediction>(predictions, reuseRowObject: false);

Kombinieren und Anzeigen der Vorhersagen

Erstellen Sie einen Header für die Vorhersagen mithilfe des folgenden Codes:

Console.WriteLine();

Console.WriteLine("=============== Prediction Test of loaded model with multiple samples ===============");

Da SentimentPrediction geerbt wird, SentimentDatawird die Transform() Methode mit den vorhergesagten Feldern aufgefüllt SentimentText . Während der ML.NET-Prozess läuft, fügt jede Komponente Spalten hinzu, was die Anzeige der Ergebnisse erleichtert.

foreach (SentimentPrediction prediction  in predictedResults)
{
    Console.WriteLine($"Sentiment: {prediction.SentimentText} | Prediction: {(Convert.ToBoolean(prediction.Prediction) ? "Positive" : "Negative")} | Probability: {prediction.Probability} ");
}
Console.WriteLine("=============== End of predictions ===============");

Ergebnisse

Ihre Ergebnisse sollten dem Folgenden ähnlich sein. Während der Verarbeitung werden Nachrichten angezeigt. Möglicherweise werden Warnmeldungen oder Verarbeitungsnachrichten angezeigt. Diese wurden aus den folgenden Ergebnissen aus Gründen der Klarheit entfernt.

Model quality metrics evaluation
--------------------------------
Accuracy: 83.96%
Auc: 90.51%
F1Score: 84.04%

=============== End of model evaluation ===============

=============== Prediction Test of model with a single sample and test dataset ===============

Sentiment: This was a very bad steak | Prediction: Negative | Probability: 0.1027377
=============== End of Predictions ===============

=============== Prediction Test of loaded model with a multiple samples ===============

Sentiment: This was a horrible meal | Prediction: Negative | Probability: 0.1369192
Sentiment: I love this spaghetti. | Prediction: Positive | Probability: 0.9960636
=============== End of predictions ===============

=============== End of process ===============
Press any key to continue . . .

Glückwunsch! Sie haben nun erfolgreich ein Machine Learning-Modell für die Klassifizierung und Vorhersage von Nachrichtenstimmungen erstellt.

Das Erstellen erfolgreicher Modelle ist ein iterativer Prozess. Dieses Modell hat anfänglich eine niedrigere Qualität, da das Lernprogramm kleine Datasets verwendet, um schnelle Modellschulungen bereitzustellen. Wenn Sie mit der Modellqualität nicht zufrieden sind, können Sie versuchen, sie zu verbessern, indem Sie größere Schulungsdatensätze bereitstellen oder verschiedene Schulungsalgorithmen mit unterschiedlichen Hyperparametern für jeden Algorithmus auswählen.

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

Nächste Schritte

In diesem Tutorial haben Sie Folgendes gelernt:

• Erstellen einer Konsolenanwendung
• Vorbereiten von Daten
• Laden der Daten
• Erstellen und Trainieren des Modells
• Auswerten des Modells
• Verwenden des Modells zum Erstellen einer Vorhersage
• Die Ergebnisse anzeigen

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

Problemklassifizierung