Tutoriel : Analyser le sentiment des commentaires du site web avec la classification binaire dans ML.NET

Ce tutoriel vous montre comment créer une application console .NET qui classifie les sentiments des commentaires du site web et prend l’action appropriée. Le classifieur de sentiment binaire utilise C# dans Visual Studio 2022.

Dans ce tutoriel, vous allez apprendre à :

Création d’une application console
Préparer des données
Chargement des données
Générer et entraîner le modèle
Évaluer le modèle
Utiliser le modèle pour effectuer une prédiction
Consultation des résultats

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

Prerequisites

Création d’une application console

Créez une application console C# appelée « SentimentAnalysis ». Cliquez sur le bouton Suivant .
Choisissez .NET 8 comme framework à utiliser. Cliquez sur le bouton Créer.
Créez un répertoire nommé Data dans votre projet pour enregistrer vos fichiers de jeu de données.
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.

Préparer vos données

Note

Les jeux de données de ce didacticiel proviennent de « Des étiquettes de groupe aux étiquettes individuelles à l’aide de caractéristiques profondes », Kotzias et al. KDD 2015 et hébergé dans le référentiel UCI Machine Learning - Dua, D. et Karra Taniskidou, E. (2017). Référentiel Machine Learning UCI [http://archive.ics.uci.edu/ml]. Irvine, CA : University of California, School of Information and Computer Science.

Téléchargez le fichier ZIP du jeu de données Phrases étiquetées UCI et décompressez-le.
Copiez le yelp_labelled.txt fichier dans le répertoire de données que vous avez créé.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le yelp_labelled.txt fichier et 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.

Créer des classes et définir des chemins d’accès

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

using Microsoft.ML;
using Microsoft.ML.Data;
using SentimentAnalysis;
using static Microsoft.ML.DataOperationsCatalog;

Ajoutez le code suivant à la ligne située en dessous des using directives pour créer un champ contenant le chemin du fichier de jeu de données récemment téléchargé :
```
string _dataPath = Path.Combine(Environment.CurrentDirectory, "Data", "yelp_labelled.txt");
```
Ensuite, créez des classes pour vos données et prédictions d’entrée. Ajoutez une nouvelle classe à votre projet :
- Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis sélectionnez Ajouter>un nouvel élément.
- Dans la boîte de dialogue Ajouter un nouvel élément , sélectionnez Classe et remplacez le champ Nom par SentimentData.cs. Ensuite, sélectionnez Ajouter.
Le fichier SentimentData.cs s’ouvre dans l’éditeur de code. Ajoutez la directive suivante using en haut de SentimentData.cs :
```
using Microsoft.ML.Data;
```

Supprimez la définition de classe existante et ajoutez le code suivant, qui comporte deux classes SentimentData et SentimentPrediction, au fichier SentimentData.cs :

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

Comment les données ont été préparées

La classe du jeu de données d'entrée, SentimentData, possède une valeur de string pour les commentaires utilisateur (SentimentText) et une valeur de bool (Sentiment) de 1 (positif) ou 0 (négatif) pour le sentiment. Les deux champs ont des attributs LoadColumn attachés à eux, qui décrivent l’ordre des fichiers de données de chaque champ. En outre, la Sentiment propriété a un attribut ColumnName pour le désigner comme Label champ. L’exemple de fichier suivant n’a pas de ligne d’en-tête et ressemble à ceci :

SentimentText	Sentiment (étiquette)
La serveuse était un peu lente dans le service.	0
La croûte n’est pas bonne.	0
Waouh... J’ai adoré cet endroit.	1
Le service était très rapide.	1

SentimentPrediction est la classe de prédiction utilisée après l’entraînement du modèle. Il hérite de SentimentData afin que l'entrée SentimentText puisse être affichée avec la prédiction de sortie. La Prediction valeur booléenne prédite par le modèle lorsqu'on lui fournit une nouvelle entrée SentimentText.

La classe SentimentPrediction de sortie contient deux autres propriétés calculées par le modèle : Score le score brut calculé par le modèle et Probability le score étalonné pour la probabilité que le texte ait un sentiment positif.

Pour ce tutoriel, la propriété la plus importante est Prediction.

Chargement des données

Les données de ML.NET sont représentées sous forme d’interface IDataView. IDataView est un moyen flexible et efficace de décrire les données tabulaires (numériques et textuelles). Les données peuvent être chargées à partir d’un fichier texte ou en temps réel (par exemple, des fichiers de base de données SQL ou des fichiers journaux) dans un IDataView objet.

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.

Vous préparez l’application, puis chargez des données :

Remplacez la Console.WriteLine("Hello World!") ligne par le code suivant pour déclarer et initialiser la variable mlContext :
```
MLContext mlContext = new MLContext();
```
Ajoutez les éléments suivants comme ligne de code suivante :
```
TrainTestData splitDataView = LoadData(mlContext);
```
Créez une LoadData() méthode en bas du Program.cs fichier à l’aide du code suivant :
```
TrainTestData LoadData(MLContext mlContext)
{

}
```
La LoadData() méthode exécute les tâches suivantes :
- Charge les données.
- Fractionne le jeu de données chargé en jeux de données d’apprentissage et de test.
- Retourne les jeux de données d’apprentissage et de test fractionnés.
Ajoutez le code suivant comme première ligne de la LoadData() méthode :
```
IDataView dataView = mlContext.Data.LoadFromTextFile<SentimentData>(_dataPath, hasHeader: false);
```
La méthode LoadFromTextFile() définit le schéma de données et lit dans le fichier. Il prend les variables de chemin d’accès aux données et retourne un IDataView.

Fractionner le jeu de données pour l’entraînement et le test du modèle

Lors de la préparation d’un modèle, vous utilisez une partie du jeu de données pour l’entraîner et une partie du jeu de données pour tester la précision du modèle.

Pour fractionner les données chargées en jeux de données nécessaires, ajoutez le code suivant comme ligne suivante dans la LoadData() méthode :
```
TrainTestData splitDataView = mlContext.Data.TrainTestSplit(dataView, testFraction: 0.2);
```
Le code précédent utilise la méthode TrainTestSplit() pour fractionner le jeu de données chargé en jeux de données d’apprentissage et de test et les retourner dans la DataOperationsCatalog.TrainTestData classe. Spécifiez le pourcentage de données du jeu de tests avec le testFractionparamètre. La valeur par défaut est 10%, dans ce cas, vous utilisez 20% pour évaluer plus de données.
Retournez la splitDataView valeur à la fin de la LoadData() méthode :
```
return splitDataView;
```

Générer et entraîner le modèle

Ajoutez l’appel suivant à la BuildAndTrainModelméthode sous l’appel à la LoadData méthode :
```
ITransformer model = BuildAndTrainModel(mlContext, splitDataView.TrainSet);
```
La BuildAndTrainModel() méthode exécute les tâches suivantes :
- Extrait et transforme les données.
- Effectue l’apprentissage du modèle.
- Prédit les sentiments en fonction des données de test.
- Retourne le modèle.
Créez la BuildAndTrainModel() méthode, sous la LoadData() méthode, à l’aide du code suivant :
```
ITransformer BuildAndTrainModel(MLContext mlContext, IDataView splitTrainSet)
{

}
```

Extraire et transformer les données

Appelez FeaturizeText la ligne de code suivante :

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

La FeaturizeText() méthode du code précédent convertit la colonne de texte (SentimentText) en colonne de type Features clé numérique utilisée par l’algorithme Machine Learning et l’ajoute en tant que nouvelle colonne de jeu de données :

SentimentText	Sentiments	Fonctionnalités
La serveuse était un peu lente dans le service.	0	[0.76, 0.65, 0.44, …]
La croûte n’est pas bonne.	0	[0.98, 0.43, 0.54, …]
Pleurage... J’ai adoré cet endroit.	1	[0.35, 0.73, 0.46, …]
Le service était très rapide.	1	[0.39, 0, 0.75, …]

Ajouter un algorithme d’apprentissage

Cette application utilise un algorithme de classification qui classe les éléments ou les lignes de données. L’application catégorise les commentaires du site web comme positifs ou négatifs. Utilisez donc la tâche de classification binaire.

Ajoutez la tâche Machine Learning aux définitions de transformation de données en ajoutant ce qui suit comme ligne de code suivante dans BuildAndTrainModel():

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

SdcaLogisticRegressionBinaryTrainer est votre algorithme d’apprentissage de classification. Ceci est ajouté à estimator et accepte l'entrée caractérisée SentimentText (Features) ainsi que les paramètres d'entrée Label pour apprendre à partir des données historiques.

Entraîner le modèle

Ajuster le modèle aux splitTrainSet données et renvoyer le modèle entraîné en ajoutant la ligne de code suivante dans la BuildAndTrainModel() méthode :

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

La méthode Fit() entraîne votre modèle en transformant le jeu de données et en appliquant l’entraînement.

Retourner le modèle entraîné à utiliser pour l’évaluation

Retournez le modèle à la fin de la BuildAndTrainModel() méthode :

return model;

Évaluer le modèle

Une fois votre modèle entraîné, utilisez vos données de test pour valider les performances du modèle.

Créez la Evaluate() méthode, juste après BuildAndTrainModel(), avec le code suivant :
```
void Evaluate(MLContext mlContext, ITransformer model, IDataView splitTestSet)
{

}
```
La Evaluate() méthode exécute les tâches suivantes :
- Charge le jeu de données de test.
- Crée l’évaluateur BinaryClassification.
- Évalue le modèle et crée des métriques.
- Affiche les métriques.
Ajoutez un appel à la nouvelle méthode en dessous de l’appel à la méthode BuildAndTrainModel en utilisant le code suivant :
```
Evaluate(mlContext, model, splitDataView.TestSet);
```
Transformez les splitTestSet données en ajoutant le code suivant à Evaluate():
```
Console.WriteLine("=============== Evaluating Model accuracy with Test data===============");
IDataView predictions = model.Transform(splitTestSet);
```
Le code précédent utilise la méthode Transform() pour effectuer des prédictions pour plusieurs lignes d’entrée fournies d’un jeu de données de test.

Évaluez le modèle en ajoutant ce qui suit comme ligne de code suivante dans la Evaluate() méthode :

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

Une fois que vous avez le jeu de prédictions (predictions), la méthode Evaluate() évalue le modèle en comparant les valeurs prédites avec celles réelles du jeu de données de test Labels et retourne un objet CalibratedBinaryClassificationMetrics qui décrit la performance du modèle.

Affichage des métriques pour la validation du modèle

Utilisez le code suivant pour afficher les métriques :

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 ===============");

La Accuracy métrique obtient la précision d’un modèle, qui correspond à la proportion de prédictions correctes dans le jeu de tests.
La AreaUnderRocCurve métrique indique la confiance que le modèle classe correctement les classes positives et négatives. Vous voulez être AreaUnderRocCurve aussi proche que possible.
La F1Score métrique obtient le score F1 du modèle, qui est une mesure d’équilibre entre précision et rappel. Vous voulez être F1Score aussi proche que possible.

Prédire le résultat des données de test

Créez la UseModelWithSingleItem() méthode, juste après la Evaluate() méthode, à l’aide du code suivant :
```
void UseModelWithSingleItem(MLContext mlContext, ITransformer model)
{

}
```
La UseModelWithSingleItem() méthode exécute les tâches suivantes :
- Crée un commentaire unique de données de test.
- Prédit les sentiments en fonction des données de test.
- Combine les données de test et les prédictions pour la création de rapports.
- Affiche les résultats prédits.
Ajoutez un appel à la nouvelle méthode directement sous l'appel de méthode Evaluate() en utilisant le code suivant :
```
UseModelWithSingleItem(mlContext, model);
```
Ajoutez le code suivant pour créer en tant que première ligne dans la UseModelWithSingleItem() méthode :
```
PredictionEngine<SentimentData, SentimentPrediction> predictionFunction = mlContext.Model.CreatePredictionEngine<SentimentData, SentimentPrediction>(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.
Ajoutez un commentaire pour tester la prédiction du modèle entraîné dans la UseModelWithSingleItem() méthode en créant une instance de SentimentData:
```
SentimentData sampleStatement = new SentimentData
{
    SentimentText = "This was a very bad steak"
};
```
Transmettez les données de commentaire de test au PredictionEngine en ajoutant les lignes de code suivantes dans la méthode UseModelWithSingleItem() :
```
var resultPrediction = predictionFunction.Predict(sampleStatement);
```
La fonction Predict() effectue une prédiction sur une seule ligne de données.

Affichez SentimentText et la prédiction de sentiment correspondante à l’aide du code suivant :

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();

Utiliser le modèle pour la prédiction

Déployer et prédire des éléments de lot

Créez la UseModelWithBatchItems() méthode, juste après la UseModelWithSingleItem() méthode, à l’aide du code suivant :
```
void UseModelWithBatchItems(MLContext mlContext, ITransformer model)
{

}
```
La UseModelWithBatchItems() méthode exécute les tâches suivantes :
- Crée des données de test par lots.
- Prédit les sentiments en fonction des données de test.
- Combine les données de test et les prédictions pour la création de rapports.
- Affiche les résultats prédits.
Ajoutez un appel à la nouvelle méthode directement sous l'appel de méthode UseModelWithSingleItem() en utilisant le code suivant :
```
UseModelWithBatchItems(mlContext, model);
```

Ajoutez des commentaires pour tester les prédictions du modèle entraîné dans la UseModelWithBatchItems() méthode :

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

Prédire le sentiment de commentaire

Utilisez le modèle pour prédire le sentiment de données de commentaire à l’aide de la méthode Transform() :

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

Combiner et afficher les prédictions

Créez un en-tête pour les prédictions à l’aide du code suivant :

Console.WriteLine();

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

Étant donné qu’elle SentimentPrediction est héritée de SentimentData, la Transform() méthode remplie SentimentText avec les champs prédits. Au fur et à mesure que le processus ML.NET traite, chaque composant ajoute des colonnes, ce qui facilite l’affichage des résultats :

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 ===============");

Results

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. Ceux-ci ont été supprimés des résultats suivants pour plus de clarté.

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 . . .

Félicitations! Vous avez maintenant créé un modèle Machine Learning pour classifier et prédire les sentiments des messages.

La création de modèles réussis est un processus itératif. Ce modèle a une qualité initiale inférieure, car le didacticiel utilise de petits jeux de données pour fournir une formation rapide sur les modèles. Si vous n’êtes pas satisfait de la qualité du modèle, vous pouvez essayer de l’améliorer en fournissant des jeux de données d’entraînement plus volumineux ou en choisissant différents algorithmes d’entraînement avec différents hyper-paramètres pour chaque algorithme.