Lernprogramm: Analysieren der Stimmung von Filmrezensionen mithilfe eines vortrainierten TensorFlow-Modells in ML.NET

In diesem Lernprogramm erfahren Sie, wie Sie ein vortrainiertes TensorFlow-Modell verwenden, um die Stimmung in Websitekommentaren zu klassifizieren. Der Klassifizierer für binäre Stimmungen ist eine C#-Konsolenanwendung, die mit Visual Studio entwickelt wurde.

Das in diesem Lernprogramm verwendete TensorFlow-Modell wurde mithilfe von Filmrezensionen aus der IMDB-Datenbank trainiert. Nachdem Sie die Entwicklung der Anwendung abgeschlossen haben, können Sie einen Filmkritiktext bereitstellen, und die Anwendung teilt Ihnen mit, ob die Rezension ein positives oder negatives Sentiment besitzt.

In diesem Tutorial erfahren Sie, wie:

• Laden eines vortrainierten TensorFlow-Modells
• Transformieren von Websitekommentartext in Features, die für das Modell geeignet sind
• Verwenden des Modells zum Erstellen einer Vorhersage

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

Voraussetzungen

• Visual Studio 2022 oder höher mit installierter .NET Desktop Development-Workload .

Konfiguration

Erstellen der Anwendung

1. Erstellen Sie eine C# -Konsolenanwendung namens "TextClassificationTF". 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. Wiederholen Sie diese Schritte für Microsoft.ML.TensorFlow, Microsoft.ML.SampleUtils und SciSharp.TensorFlow.Redist.

Hinzufügen des TensorFlow-Modells zum Projekt

Hinweis

Das Modell für dieses Lernprogramm stammt aus dem GitHub-Repository dotnet/machinelearning-testdata . Das Modell ist im TensorFlow SavedModel-Format.

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

   Die ZIP-Datei enthält:

   • saved_model.pb: das TensorFlow-Modell selbst. Das Modell nimmt ein ganzzahliges Array mit fester Länge (Größe 600) aus Merkmalen an, die den Text in einem IMDB-Bewertungstext darstellen, und gibt zwei Wahrscheinlichkeiten aus, die zusammen 1 ergeben: die Wahrscheinlichkeit, dass die Eingabebewertung eine positive Stimmung hat, und die Wahrscheinlichkeit, dass die Eingabebewertung eine negative Stimmung hat.
   • imdb_word_index.csv: eine Zuordnung von einzelnen Wörtern zu einem ganzzahligen Wert. Die Zuordnung wird verwendet, um die Eingabefeatures für das TensorFlow-Modell zu generieren.

2. Kopieren Sie den Inhalt des innersten sentiment_model Verzeichnisses in Ihr TextClassificationTF-Projektverzeichnissentiment_model. Dieses Verzeichnis enthält das Modell und zusätzliche Supportdateien, die für dieses Lernprogramm erforderlich sind, wie in der folgenden Abbildung dargestellt:

   

3. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die einzelnen Dateien im sentiment_model Verzeichnis und Unterverzeichnis, und wählen Sie "Eigenschaften" aus. Ändern Sie unter Erweitert den Wert von In Ausgabeverzeichnis kopieren in Wenn neuer, kopieren.

Hinzufügen von using Direktiven und globalen Variablen

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

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

2. Erstellen Sie eine globale Variable direkt nach den using Direktiven, um den gespeicherten Modelldateipfad zu speichern.

   string _modelPath = Path.Combine(Environment.CurrentDirectory, "sentiment_model");
   

   • _modelPath ist der Dateipfad des trainierten Modells.

Modellieren der Daten

Filmrezensionen sind Freiformtext. Ihre Anwendung konvertiert den Text in das vom Modell erwartete Eingabeformat in einer Reihe von einzelnen Stufen.

Der erste besteht darin, den Text in separate Wörter aufzuteilen und die bereitgestellte Zuordnungsdatei zu verwenden, um jedes Wort einer ganzzahligen Codierung zuzuordnen. Das Ergebnis dieser Transformation ist ein Integer-Array mit variabler Länge, die der Anzahl der Wörter im Satz entspricht.

Eigentum	Wert	Typ
ReviewText	Dieser Film ist wirklich gut	Schnur
VariableLengthFeatures	14,22,9,66,78,...	int[]

Das Feature-Array mit variabler Länge wird dann auf eine feste Länge von 600 angepasst. Dies ist die Länge, die das TensorFlow-Modell erwartet.

Eigentum	Wert	Typ
ReviewText	Dieser Film ist wirklich gut	Schnur
VariableLengthFeatures	14,22,9,66,78,...	int[]
Features	14,22,9,66,78,...	int[600]

1. Erstellen Sie eine Klasse für Ihre Eingabedaten unten in der datei Program.cs :

   /// <summary>
   /// Class to hold original sentiment data.
   /// </summary>
   public class MovieReview
   {
       public string? ReviewText { get; set; }
   }
   

   Die Eingabedatenklasse , MovieReviewhat eine string für Benutzerkommentare (ReviewText).

2. Erstellen Sie nach der MovieReview Klasse eine Klasse für die Features mit variabler Länge:

   /// <summary>
   /// Class to hold the variable length feature vector. Used to define the
   /// column names used as input to the custom mapping action.
   /// </summary>
   public class VariableLength
   {
       /// <summary>
       /// This is a variable length vector designated by VectorType attribute.
       /// Variable length vectors are produced by applying operations such as 'TokenizeWords' on strings
       /// resulting in vectors of tokens of variable lengths.
       /// </summary>
       [VectorType]
       public int[]? VariableLengthFeatures { get; set; }
   }
   

   Die VariableLengthFeatures Eigenschaft verfügt über ein VectorType-Attribut , um es als Vektor zu kennzeichnen. Alle Vektorelemente müssen denselben Typ aufweisen. Bei Datensätzen mit einer großen Anzahl von Spalten reduziert das Laden mehrerer Spalten als einzelner Vektor die Anzahl der Datendurchläufe, wenn Sie Datentransformationen anwenden.

   Diese Klasse wird in der ResizeFeatures Aktion verwendet. Die Namen der Eigenschaften (in diesem Fall nur eine) werden verwendet, um anzugeben, welche Spalten in der DataView als Eingabe für die benutzerdefinierte Zuordnungsaktion verwendet werden können.

3. Erstellen Sie nach der VariableLength Klasse eine Klasse für die Features mit fester Länge:

   /// <summary>
   /// Class to hold the fixed length feature vector. Used to define the
   /// column names used as output from the custom mapping action,
   /// </summary>
   public class FixedLength
   {
       /// <summary>
       /// This is a fixed length vector designated by VectorType attribute.
       /// </summary>
       [VectorType(Config.FeatureLength)]
       public int[]? Features { get; set; }
   }
   

   Diese Klasse wird in der ResizeFeatures Aktion verwendet. Die Namen ihrer Eigenschaften (in diesem Fall nur eine) werden verwendet, um anzugeben, welche Spalten in der DataView als Ausgabe der benutzerdefinierten Zuordnungsaktion verwendet werden können.

   Beachten Sie, dass der Name der Eigenschaft Features durch das TensorFlow-Modell bestimmt wird. Sie können diesen Eigenschaftennamen nicht ändern.

4. Erstellen Sie eine Klasse für die Vorhersage nach der FixedLength Klasse:

   /// <summary>
   /// Class to contain the output values from the transformation.
   /// </summary>
   public class MovieReviewSentimentPrediction
   {
       [VectorType(2)]
       public float[]? Prediction { get; set; }
   }
   

   MovieReviewSentimentPrediction ist die Vorhersageklasse, die nach der Modellschulung verwendet wird. MovieReviewSentimentPrediction hat ein einzelnes float Array (Prediction) und ein VectorType Attribut.

5. Erstellen Sie eine weitere Klasse zum Speichern von Konfigurationswerten, z. B. die Länge des Featurevektors:

   static class Config
   {
       public const int FeatureLength = 600;
   }
   

Erstellen des MLContext-, Nachschlagewörterbuchs und der Aktion zum Ändern der Größe von Features

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 wie DBContext im Entity Framework.

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. Erstellen Sie ein Wörterbuch zum Codieren von Wörtern als ganze Zahlen, indem Sie die LoadFromTextFile Methode zum Laden von Zuordnungsdaten aus einer Datei verwenden, wie in der folgenden Tabelle dargestellt:

   Wort	Index
   Kinder	362
   wollen	181
   falsch	355
   Effekte	302
   Gefühl	547

   Fügen Sie den folgenden Code hinzu, um damit die Lookup-Tabelle zu erstellen.

   var lookupMap = mlContext.Data.LoadFromTextFile(Path.Combine(_modelPath, "imdb_word_index.csv"),
       columns: new[]
           {
               new TextLoader.Column("Words", DataKind.String, 0),
               new TextLoader.Column("Ids", DataKind.Int32, 1),
           },
       separatorChar: ','
       );
   

3. Fügen Sie ein Action hinzu, um das Ganzzahl-Array variabler Länge in ein Ganzzahl-Array fester Größe umzuwandeln, mit den folgenden Codezeilen:

   Action<VariableLength, FixedLength> ResizeFeaturesAction = (s, f) =>
   {
       var features = s.VariableLengthFeatures;
       Array.Resize(ref features, Config.FeatureLength);
       f.Features = features;
   };
   

Laden des vortrainierten TensorFlow-Modells

1. Fügen Sie Code zum Laden des TensorFlow-Modells hinzu:

   TensorFlowModel tensorFlowModel = mlContext.Model.LoadTensorFlowModel(_modelPath);
   

   Nachdem das Modell geladen wurde, können Sie das Eingabe- und Ausgabeschema extrahieren. Die Schemas werden nur für Interesse und Lernen angezeigt. Sie benötigen diesen Code nicht, damit die endgültige Anwendung funktioniert:

   DataViewSchema schema = tensorFlowModel.GetModelSchema();
   Console.WriteLine(" =============== TensorFlow Model Schema =============== ");
   var featuresType = (VectorDataViewType)schema["Features"].Type;
   Console.WriteLine($"Name: Features, Type: {featuresType.ItemType.RawType}, Size: ({featuresType.Dimensions[0]})");
   var predictionType = (VectorDataViewType)schema["Prediction/Softmax"].Type;
   Console.WriteLine($"Name: Prediction/Softmax, Type: {predictionType.ItemType.RawType}, Size: ({predictionType.Dimensions[0]})");
   
   

   Das Eingabeschema ist das Array mit ganzzahligen codierten Wörtern mit fester Länge. Das Ausgabeschema ist ein Float-Array mit Wahrscheinlichkeiten, die angeben, ob die Stimmung einer Bewertung negativ oder positiv ist. Diese Werte summieren sich auf 1, da die Wahrscheinlichkeit, positiv zu sein, die Ergänzung der Wahrscheinlichkeit ist, dass die Stimmung negativ ist.

Erstellen der ML.NET Pipeline

1. Erstellen Sie die Pipeline, und teilen Sie den Eingabetext mithilfe der TokenizeIntoWords-Transformation in Wörter auf, um den Text als nächste Codezeile in Wörter aufzuteilen:

   IEstimator<ITransformer> pipeline =
       // Split the text into individual words
       mlContext.Transforms.Text.TokenizeIntoWords("TokenizedWords", "ReviewText")
   

   Die TokenizeIntoWords-Transformation verwendet Leerzeichen, um den Text/die Zeichenfolge in Wörter zu analysieren. Sie erstellt eine neue Spalte und teilt jede Eingabezeichenfolge auf einen Vektor von Teilzeichenfolgen basierend auf dem benutzerdefinierten Trennzeichen auf.

2. Ordnen Sie die Wörter mithilfe der oben definierten Lookup-Tabelle der ganzzahligen Codierung zu.

   // Map each word to an integer value. The array of integer makes up the input features.
   .Append(mlContext.Transforms.Conversion.MapValue("VariableLengthFeatures", lookupMap,
       lookupMap.Schema["Words"], lookupMap.Schema["Ids"], "TokenizedWords"))
   

3. Passen Sie die Ganzzahlcodierungen mit variabler Länge an die feste Länge an, die für das Modell erforderlich ist.

   // Resize variable length vector to fixed length vector.
   .Append(mlContext.Transforms.CustomMapping(ResizeFeaturesAction, "Resize"))
   

4. Klassifizieren Sie die Eingabe mit dem geladenen TensorFlow-Modell:

   // Passes the data to TensorFlow for scoring
   .Append(tensorFlowModel.ScoreTensorFlowModel("Prediction/Softmax", "Features"))
   

   Die TensorFlow-Modellausgabe wird als Prediction/Softmax bezeichnet. Beachten Sie, dass der Name Prediction/Softmax durch das TensorFlow-Modell bestimmt wird. Sie können diesen Namen nicht ändern.

5. Erstellen Sie eine neue Spalte für die Ausgabevorhersage:

   // Retrieves the 'Prediction' from TensorFlow and copies to a column
   .Append(mlContext.Transforms.CopyColumns("Prediction", "Prediction/Softmax"));
   

   Sie müssen die Spalte Prediction/Softmax in eine mit einem Namen kopieren, der als Eigenschaft in einer C#-Klasse verwendet werden kann: Prediction. Das / Zeichen ist in einem C#-Eigenschaftsnamen nicht zulässig.

Erstellen des ML.NET Modells aus der Pipeline

1. Fügen Sie den Code hinzu, um das Modell aus der Pipeline zu erstellen:

   // Create an executable model from the estimator pipeline
   IDataView dataView = mlContext.Data.LoadFromEnumerable(new List<MovieReview>());
   ITransformer model = pipeline.Fit(dataView);
   

   Ein ML.NET Modell wird aus der Kette der Schätzer in der Pipeline erstellt, indem die Fit Methode aufgerufen wird. In diesem Fall passen Sie keine Daten an, um das Modell zu erstellen, da das TensorFlow-Modell bereits trainiert wurde. Sie geben ein leeres Datenansichtsobjekt an, um die Anforderungen der Fit Methode zu erfüllen.

Verwenden des Modells zum Erstellen einer Vorhersage

1. Fügen Sie die Methode oberhalb der PredictSentimentMovieReview Klasse hinzu:

   void PredictSentiment(MLContext mlContext, ITransformer model)
   {
   
   }
   

2. Fügen Sie den folgenden Code hinzu, um die PredictionEngine erste Zeile in der PredictSentiment() Methode zu erstellen:

   var engine = mlContext.Model.CreatePredictionEngine<MovieReview, MovieReviewSentimentPrediction>(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.

3. Fügen Sie einen Kommentar hinzu, um die Vorhersage des trainierten Modells in der Predict() Methode zu testen, indem Sie eine Instanz von MovieReview erstellen.

   var review = new MovieReview()
   {
       ReviewText = "this film is really good"
   };
   

4. Übergeben Sie die Testkommentardaten an die Prediction Engine, indem Sie die folgenden Codezeilen in der PredictSentiment()-Methode hinzufügen:

   var sentimentPrediction = engine.Predict(review);
   

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

   Eigentum	Wert	Typ
   Prediction	[0.5459937, 0.454006255]	float[]

6. Zeigen Sie die Stimmungsvorhersage mit dem folgenden Code an:

   Console.WriteLine($"Number of classes: {sentimentPrediction.Prediction?.Length}");
   Console.WriteLine($"Is sentiment/review positive? {(sentimentPrediction.Prediction?[1] > 0.5 ? "Yes." : "No.")}");
   

7. Fügen Sie nach dem Aufrufen der Methode Fit() einen Aufruf zu PredictSentiment hinzu:

   PredictSentiment(mlContext, model);
   

Ergebnisse

Erstellen Sie Ihre Anwendung, und führen Sie sie aus.

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

Number of classes: 2
Is sentiment/review positive ? Yes

Glückwunsch! Sie haben nun erfolgreich ein Machine Learning-Modell für die Klassifizierung und Vorhersage von Nachrichtenstimmungen erstellt, indem Sie ein vortrainiertes Modell in ML.NET wiederverwenden TensorFlow .

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

In diesem Tutorial haben Sie Folgendes gelernt:

• Laden eines vortrainierten TensorFlow-Modells
• Transformieren von Websitekommentartext in Features, die für das Modell geeignet sind
• Verwenden des Modells zum Erstellen einer Vorhersage