Tutoriel : Analyser les sentiments des critiques de films à l’aide d’un modèle TensorFlow préentraîné dans ML.NET

Ce tutoriel vous montre comment utiliser un modèle TensorFlow préentraîné pour classifier les sentiments dans les commentaires du site web. Le classifieur de sentiment binaire est une application console C# développée à l’aide de Visual Studio.

Le modèle TensorFlow utilisé dans ce tutoriel a été formé à l’aide de critiques vidéo de la base de données IMDB. Une fois que vous avez terminé de développer l'application, vous serez en mesure de fournir un texte de critique de film et l'application vous indiquera si la critique a un sentiment positif ou négatif.

Dans ce tutoriel, vous allez apprendre à :

• Charger un modèle TensorFlow préentraîné
• Transformer le texte du commentaire du site web en fonctionnalités adaptées au modèle
• Utiliser le modèle pour effectuer une prédiction

Vous trouverez le code source de ce didacticiel dans le référentiel dotnet/samples .

Prerequisites

• Visual Studio 2022 ou version ultérieure avec la charge de travail développement .NET Desktop installée.

Configuration

Créer l’application

1. Créez une application console C# appelée « TextClassificationTF ». Cliquez sur le bouton Suivant .

2. Choisissez .NET 8 comme framework à utiliser. Cliquez sur le bouton Créer.

3. Créez un répertoire nommé Data dans votre projet pour enregistrer vos fichiers de jeu de données.

4. Installez le package NuGet Microsoft.ML :

   Note

   Cet exemple utilise la dernière version stable des packages NuGet mentionnés, sauf indication contraire.

   Dans l’Explorateur de solutions, cliquez avec le bouton droit sur votre projet, puis sélectionnez Gérer les packages NuGet. Choisissez « nuget.org » comme source du package, puis sélectionnez l’onglet Parcourir . Recherchez Microsoft.ML, sélectionnez le package souhaité, puis sélectionnez Installer. Poursuivez l’installation en acceptant les termes du contrat de licence pour le package que vous choisissez. Répétez ces étapes pour Microsoft.ML.TensorFlow, Microsoft.ML.SampleUtils et SciSharp.TensorFlow.Redist.

Ajouter le modèle TensorFlow au projet

Note

Le modèle de ce didacticiel provient du dépôt GitHub dotnet/machinelearning-testdata . Le modèle est au format TensorFlow SavedModel.

1. Téléchargez le fichier zip sentiment_model et décompressez-le.

   Le fichier zip contient :

   • saved_model.pb: modèle TensorFlow lui-même. Le modèle prend un tableau entier de longueur fixe (taille 600) de caractéristiques représentant le texte dans une chaîne de révision IMDB et génère deux probabilités qui se résument à 1 : la probabilité que la révision d’entrée ait un sentiment positif et la probabilité que la révision d’entrée ait un sentiment négatif.
   • imdb_word_index.csv: mappage de mots individuels à une valeur entière. Le mappage est utilisé pour générer les fonctionnalités d’entrée du modèle TensorFlow.

2. Copiez le contenu du répertoire le plus sentiment_model interne dans votre répertoire de projet sentiment_model. Ce répertoire contient le modèle et les fichiers de support supplémentaires nécessaires pour ce didacticiel, comme illustré dans l’image suivante :

   

3. Dans l’Explorateur de solutions, cliquez avec le sentiment_model bouton droit sur chacun des fichiers du répertoire et du sous-répertoire, puis sélectionnez Propriétés. Sous Avancé, modifiez la valeur de Copie dans le répertoire de sortie pour copier si elle est plus récente.

Ajouter des using directives et des variables globales

1. Ajoutez les directives supplémentaires using suivantes en haut du fichier Program.cs :

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

2. Créez une variable globale juste après les using directives pour contenir le chemin d’accès au fichier de modèle enregistré.

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

   • _modelPath est le chemin d’accès au fichier du modèle entraîné.

Modéliser les données

Les critiques de films sont du texte de forme libre. Votre application convertit le texte dans le format d’entrée attendu par le modèle en plusieurs étapes discrètes.

La première consiste à fractionner le texte en mots distincts et à utiliser le fichier de mappage fourni pour mapper chaque mot sur un encodage entier. Le résultat de cette transformation est un tableau entier de longueur variable avec une longueur correspondant au nombre de mots dans la phrase.

Propriété	Valeur	Type
ReviewText	ce film est vraiment bon	ficelle
VariableLengthFeatures	14,22,9,66,78,...	int[]

Le tableau de caractéristiques de longueur variable est ensuite redimensionné sur une longueur fixe de 600. Il s’agit de la longueur attendue par le modèle TensorFlow.

Propriété	Valeur	Type
ReviewText	ce film est vraiment bon	ficelle
VariableLengthFeatures	14,22,9,66,78,...	int[]
Fonctionnalités	14,22,9,66,78,...	int[600]

1. Créez une classe pour vos données d’entrée en bas du fichier Program.cs :

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

   La classe de données d’entrée, MovieReviewa un string pour les commentaires utilisateur (ReviewText).

2. Créez une classe pour les fonctionnalités de longueur variable après la MovieReview classe :

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

   La VariableLengthFeatures propriété a un attribut VectorType pour le désigner comme vecteur. Tous les éléments vectoriels doivent être du même type. Dans les jeux de données avec un grand nombre de colonnes, le chargement de plusieurs colonnes en tant que vecteur unique réduit le nombre de passes de données lorsque vous appliquez des transformations de données.

   Cette classe est utilisée dans l’action ResizeFeatures . Les noms de ses propriétés (dans ce cas, une seule) sont utilisés pour indiquer les colonnes du DataView qui peuvent être utilisées comme entrée de l’action de mappage personnalisée.

3. Créez une classe pour les fonctionnalités de longueur fixe, après la VariableLength classe :

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

   Cette classe est utilisée dans l’action ResizeFeatures . Les noms de ses propriétés (dans ce cas, une seule) sont utilisés pour indiquer les colonnes dans DataView qui peuvent être utilisées comme sortie de l’action de mappage personnalisée.

   Notez que le nom de la propriété Features est déterminé par le modèle TensorFlow. Vous ne pouvez pas modifier ce nom de propriété.

4. Créez une classe pour la prédiction après la FixedLength classe :

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

   MovieReviewSentimentPrediction est la classe de prédiction utilisée après l’entraînement du modèle. MovieReviewSentimentPrediction a un seul float tableau (Prediction) et un VectorType attribut.

5. Créez une autre classe pour contenir des valeurs de configuration, telles que la longueur du vecteur de fonctionnalité :

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

Créer le MLContext, le dictionnaire de correspondance et l’action pour redimensionner les caractéristiques.

La classe MLContext est un point de départ pour toutes les opérations ML.NET. L’initialisation mlContext crée un environnement ML.NET qui peut être partagé entre les objets de flux de travail de création de modèle. Il est similaire, conceptuellement, à DBContext entity Framework.

1. Remplacez la Console.WriteLine("Hello World!") ligne par le code suivant pour déclarer et initialiser la variable mlContext :

   MLContext mlContext = new MLContext();
   

2. Créez un dictionnaire pour encoder des mots en tant qu’entiers à l’aide de la LoadFromTextFile méthode pour charger des données de mappage à partir d’un fichier, comme indiqué dans le tableau suivant :

   Mot	Index
   enfants	362
   vouloir	181
   erreur	355
   Effets	302
   sentiment	547

   Ajoutez le code ci-dessous pour créer la carte de recherche :

   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. Ajoutez un Action pour redimensionner le tableau entier de mots de longueur variable à un tableau entier de taille fixe, avec les lignes de code suivantes :

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

Charger le modèle TensorFlow préentraîné

1. Ajoutez du code pour charger le modèle TensorFlow :

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

   Une fois le modèle chargé, vous pouvez extraire son schéma d’entrée et de sortie. Les schémas sont affichés uniquement pour l’intérêt et l’apprentissage. Vous n’avez pas besoin de ce code pour que l’application finale fonctionne :

   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]})");
   
   

   Le schéma d’entrée est le tableau de longueur fixe de mots encodés entiers. Le schéma de sortie est un tableau flottant de probabilités indiquant si le sentiment d’une révision est négatif ou positif. Ces valeurs correspondent à 1, car la probabilité d’être positif est le complément de la probabilité du sentiment négatif.

Créer le pipeline ML.NET

1. Créez le pipeline et fractionnez le texte d’entrée en mots à l’aide de tokenizeIntoWords transform pour diviser le texte en mots comme ligne de code suivante :

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

   La transformation TokenizeIntoWords utilise des espaces pour analyser le texte/la chaîne en mots. Il crée une colonne et fractionne chaque chaîne d’entrée en vecteur de sous-chaînes en fonction du séparateur défini par l’utilisateur.

2. Mappez les mots à leur encodage entier à l’aide de la table de recherche que vous avez déclarée ci-dessus :

   // 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. Redimensionnez les encodages entiers de longueur variable sur la longueur fixe requise par le modèle :

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

4. Classifiez l’entrée avec le modèle TensorFlow chargé :

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

   La sortie du modèle TensorFlow est appelée Prediction/Softmax. Notez que le nom Prediction/Softmax est déterminé par le modèle TensorFlow. Vous ne pouvez pas modifier ce nom.

5. Créez une colonne pour la prédiction de sortie :

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

   Vous devez copier la Prediction/Softmax colonne en une avec un nom qui peut être utilisé comme propriété dans une classe C# : Prediction. Le / caractère n’est pas autorisé dans un nom de propriété C#.

Créer le modèle ML.NET à partir du pipeline

1. Ajoutez le code pour créer le modèle à partir du pipeline :

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

   Un modèle ML.NET est créé à partir de la chaîne d’estimateurs dans le pipeline en appelant la Fit méthode. Dans ce cas, vous n’ajustez aucune donnée pour créer le modèle, car le modèle TensorFlow a déjà été formé. Vous fournissez un objet de vue de données vide pour répondre aux exigences de la Fit méthode.

Utiliser le modèle pour effectuer une prédiction

1. Ajoutez la PredictSentiment méthode au-dessus de la MovieReview classe :

   void PredictSentiment(MLContext mlContext, ITransformer model)
   {
   
   }
   

2. Ajoutez le code suivant pour créer la PredictionEngine première ligne de la PredictSentiment() méthode :

   var engine = mlContext.Model.CreatePredictionEngine<MovieReview, MovieReviewSentimentPrediction>(model);
   

   PredictionEngine est une API pratique, qui vous permet d’effectuer une prédiction sur une seule instance de données. PredictionEngine n’est pas thread-safe. Il est acceptable d’utiliser dans des environnements monothreads ou prototypes. Pour améliorer les performances et la sécurité des threads dans les environnements de production, utilisez le PredictionEnginePool service, qui crée un ObjectPool objet PredictionEngine à utiliser dans votre application. Consultez ce guide sur l’utilisation PredictionEnginePool dans une API web ASP.NET Core.

   Note

   PredictionEnginePool l’extension de service est actuellement en préversion.

3. Ajoutez un commentaire pour tester la prédiction du modèle entraîné dans la Predict() méthode en créant une instance de MovieReview:

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

4. Transmettez les données de commentaire de test à celles-ci Prediction Engine en ajoutant les lignes de code suivantes dans la PredictSentiment() méthode :

   var sentimentPrediction = engine.Predict(review);
   

5. La fonction Predict() effectue une prédiction sur une seule ligne de données :

   Propriété	Valeur	Type
   Prediction	[0.5459937, 0.454006255]	float[]

6. Affichez la prédiction des sentiments à l’aide du code suivant :

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

7. Ajoutez un appel après l’appel de PredictSentiment la Fit() méthode :

   PredictSentiment(mlContext, model);
   

Results

Créez et exécutez votre application.

Vos résultats doivent être similaires à ce qui suit. Pendant le traitement, les messages sont affichés. Vous pouvez voir des avertissements ou traiter des messages. Ces messages ont été supprimés des résultats suivants pour plus de clarté.

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

Félicitations! Vous avez maintenant créé un modèle Machine Learning pour classifier et prédire les sentiments de messages en réutilisant un modèle préentraîné TensorFlow dans ML.NET.

Vous trouverez le code source de ce didacticiel dans le référentiel dotnet/samples .

Dans ce didacticiel, vous avez appris à :

• Charger un modèle TensorFlow préentraîné
• Transformer le texte du commentaire du site web en fonctionnalités adaptées au modèle
• Utiliser le modèle pour effectuer une prédiction