Zelfstudie: Sentiment van websiteopmerkingen analyseren met binaire classificatie in ML.NET

Artikel
04/08/2023

In deze zelfstudie leert u hoe u een .NET Core-consoletoepassing maakt die sentiment classificeert op basis van opmerkingen op de website en de juiste actie onderneemt. De binaire gevoelsclassificatie maakt gebruik van C# in Visual Studio 2022.

In deze zelfstudie leert u het volgende:

Een consoletoepassing maken
Gegevens voorbereiden
De gegevens laden
Het model bouwen en trainen
Het model evalueren
Het model gebruiken om een voorspelling te doen
De resultaten weergeven

U vindt de broncode voor deze zelfstudie in de opslagplaats dotnet/samples .

Vereisten

Visual Studio 2022.
Gegevensset UCI Sentiment Gelabelde Zinnen (ZIP-bestand)

Een consoletoepassing maken

Maak een C# -consoletoepassing met de naam 'SentimentAnalysis'. Klik op de knop Next
Kies .NET 6 als het framework dat u wilt gebruiken. Klik op de knop Maken.
Maak een map met de naam Gegevens in uw project om uw gegevenssetbestanden op te slaan.
Installeer het Microsoft.ML NuGet-pakket:

Notitie

In dit voorbeeld wordt de meest recente stabiele versie van de vermelde NuGet-pakketten gebruikt, tenzij anders vermeld.

Klik in Solution Explorer met de rechtermuisknop op uw project en selecteer NuGet-pakketten beheren. Kies 'nuget.org' als pakketbron en selecteer vervolgens het tabblad Bladeren . Zoek naar Microsoft.ML, selecteer het gewenste pakket en selecteer vervolgens de knop Installeren . Ga verder met de installatie door akkoord te gaan met de licentievoorwaarden voor het pakket dat u kiest.

Uw gegevens voorbereiden

Notitie

De gegevenssets voor deze zelfstudie zijn afkomstig uit 'Van groep naar afzonderlijke labels met behulp van diepe functies', Kotzias et. Al. KDD 2015 en gehost op de UCI Machine Learning Repository - Dua, D. and Karra Taniskidou, E. (2017). UCI Machine Learning Repository [http://archive.ics.uci.edu/ml]. Irvine, CA: University of California, School of Information and Computer Science.

Download het ZIP-bestand van de UCI Sentiment Labeled Sentences-gegevensset en pak het bestand uit.
Kopieer het yelp_labelled.txt bestand naar de map Gegevens die u hebt gemaakt.
Klik in Solution Explorer met de rechtermuisknop op het yelp_labeled.txt bestand en selecteer Eigenschappen. Wijzig onder Geavanceerd de waarde van Kopiëren naar uitvoermap in Kopiëren indien nieuwer.

Klassen maken en paden definiëren

Voeg de volgende aanvullende using instructies toe aan het begin van het bestand Program.cs :

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

Voeg de volgende code toe aan de regel direct onder de using -instructies om een veld te maken voor het onlangs gedownloade pad naar het gegevenssetbestand:
```
string _dataPath = Path.Combine(Environment.CurrentDirectory, "Data", "yelp_labelled.txt");
```
Maak vervolgens klassen voor uw invoergegevens en voorspellingen. Voeg een nieuwe klasse toe aan uw project:
- Klik in Solution Explorer met de rechtermuisknop op het project en selecteervervolgens Nieuw itemtoevoegen>.
- Selecteer in het dialoogvenster Nieuw item toevoegen de optie Klasse en wijzig het veld Naam in SentimentData.cs. Selecteer vervolgens de knop Toevoegen .
Het bestand SentimentData.cs wordt geopend in de code-editor. Voeg de volgende using instructie toe aan het begin van SentimentData.cs:
```
using Microsoft.ML.Data;
```

Verwijder de bestaande klassedefinitie en voeg de volgende code, die twee klassen SentimentData en SentimentPredictionheeft, toe aan het bestand 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; }
}

Hoe de gegevens zijn voorbereid

De invoergegevenssetklasse, SentimentData, heeft een string voor gebruikersopmerkingen (SentimentText) en een bool (Sentiment)-waarde van 1 (positief) of 0 (negatief) voor gevoel. Aan beide velden zijn LoadColumn-kenmerken gekoppeld, waarmee de volgorde van het gegevensbestand van elk veld wordt beschreven. Bovendien heeft de Sentiment eigenschap een ColumnName-kenmerk om deze aan te wijzen als het Label veld. Het volgende voorbeeldbestand heeft geen veldnamenrij en ziet er als volgt uit:

SentimentTekst	Gevoel (label)
Serveerress was een beetje traag in dienst.	0
Korst is niet goed.	0
Wow... Hield van deze plek.	1
Service was erg snel.	1

SentimentPrediction is de voorspellingsklasse die wordt gebruikt na het trainen van het model. Het neemt van SentimentData over, zodat de invoer SentimentText samen met de uitvoervoorspelling kan worden weergegeven. De Prediction booleaanse waarde is de waarde die het model voorspelt wanneer deze wordt geleverd met nieuwe invoer SentimentText.

De uitvoerklasse SentimentPrediction bevat twee andere eigenschappen die door het model worden berekend: Score - de onbewerkte score die door het model wordt berekend en Probability - de score die is gekalibreerd op basis van de kans dat de tekst een positief gevoel heeft.

Voor deze zelfstudie is Predictionde belangrijkste eigenschap .

De gegevens laden

Gegevens in ML.NET worden weergegeven als een IDataView-interface. IDataView is een flexibele, efficiënte manier om tabelgegevens (numeriek en tekst) te beschrijven. Gegevens kunnen vanuit een tekstbestand of in realtime (bijvoorbeeld SQL-database of logboekbestanden) in een IDataView object worden geladen.

De MLContext-klasse is een startpunt voor alle ML.NET bewerkingen. Als u initialiseert mlContext , wordt er een nieuwe ML.NET omgeving gemaakt die kan worden gedeeld met de werkstroomobjecten voor het maken van modellen. Het is conceptueel DBContext vergelijkbaar met in Entity Framework.

U bereidt de app voor en laadt vervolgens gegevens:

Vervang de Console.WriteLine("Hello World!") regel door de volgende code om de variabele mlContext te declareren en te initialiseren:
```
MLContext mlContext = new MLContext();
```

Voeg het volgende toe als de volgende regel code:

TrainTestData splitDataView = LoadData(mlContext);

Maak een LoadData() methode onderaan het Program.cs bestand met behulp van de volgende code:
```
TrainTestData LoadData(MLContext mlContext)
{

}
```
Met LoadData() de methode worden de volgende taken uitgevoerd:
- Laadt de gegevens.
- Splitst de geladen gegevensset in gegevenssets voor trainen en testen.
- Retourneert de gesplitste train- en testgegevenssets.
Voeg de volgende code toe als de eerste regel van de LoadData() methode:
```
IDataView dataView = mlContext.Data.LoadFromTextFile<SentimentData>(_dataPath, hasHeader: false);
```
De methode LoadFromTextFile() definieert het gegevensschema en leest het bestand in. Het neemt de gegevenspadvariabelen op en retourneert een IDataView.

De gegevensset splitsen voor modeltraining en -tests

Wanneer u een model voorbereidt, gebruikt u een deel van de gegevensset om deze te trainen en een deel van de gegevensset om de nauwkeurigheid van het model te testen.

Als u de geladen gegevens wilt splitsen in de benodigde gegevenssets, voegt u de volgende code toe als de volgende regel in de LoadData() methode:
```
TrainTestData splitDataView = mlContext.Data.TrainTestSplit(dataView, testFraction: 0.2);
```
In de vorige code wordt de methode TrainTestSplit() gebruikt om de geladen gegevensset te splitsen in train- en testgegevenssets en deze in de DataOperationsCatalog.TrainTestData klasse te retourneren. Geef het testsetpercentage van gegevens op met de testFractionparameter . De standaardwaarde is 10%, in dit geval gebruikt u 20% om meer gegevens te evalueren.
Retourneer de splitDataView aan het einde van de LoadData() methode:
```
return splitDataView;
```

Het model bouwen en trainen

Voeg de volgende aanroep toe aan de BuildAndTrainModelmethode onder de aanroep van de LoadData methode:
```
ITransformer model = BuildAndTrainModel(mlContext, splitDataView.TrainSet);
```
Met BuildAndTrainModel() de methode worden de volgende taken uitgevoerd:
- Extraheert en transformeert de gegevens.
- Traint het model.
- Hiermee wordt het gevoel voorspeld op basis van testgegevens.
- Retourneert het model.
Maak de BuildAndTrainModel() methode, onder de LoadData() methode, met behulp van de volgende code:
```
ITransformer BuildAndTrainModel(MLContext mlContext, IDataView splitTrainSet)
{

}
```

De gegevens extraheren en transformeren

Aanroepen FeaturizeText als de volgende regel code:

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

Met FeaturizeText() de methode in de vorige code wordt de tekstkolom (SentimentText) geconverteerd naar een kolom van het type numerieke sleutel Features die wordt gebruikt door het machine learning-algoritme en wordt deze toegevoegd als een nieuwe gegevenssetkolom:

SentimentTekst	Sentiment	Functies
Serveerress was een beetje traag in dienst.	0	[0.76, 0.65, 0.44, ...]
Korst is niet goed.	0	[0.98, 0.43, 0.54, ...]
Wow... Hield van deze plek.	1	[0.35, 0.73, 0.46, ...]
Service was erg snel.	1	[0.39, 0, 0.75, ...]

Een leeralgoritmen toevoegen

Deze app maakt gebruik van een classificatie-algoritme dat items of rijen met gegevens categoriseert. De app categoriseert websiteopmerkingen als positief of negatief, dus gebruik de binaire classificatietaak.

Voeg de machine learning-taak toe aan de definities van gegevenstransformatie door het volgende toe te voegen als de volgende regel code in BuildAndTrainModel():

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

De SdcaLogisticRegressionBinaryTrainer is uw algoritme voor classificatietraining. Dit wordt toegevoegd aan de estimator en accepteert de featurized SentimentText (Features) en de Label invoerparameters om te leren van de historische gegevens.

Het model trainen

Pas het model aan de splitTrainSet gegevens aan en retourneer het getrainde model door het volgende toe te voegen als de volgende regel code in de BuildAndTrainModel() methode:

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

Met de methode Fit() wordt uw model getraind door de gegevensset te transformeren en de training toe te passen.

Het model retourneren dat is getraind voor gebruik voor evaluatie

Retourneer het model aan het einde van de BuildAndTrainModel() methode:

return model;

Het model evalueren

Nadat uw model is getraind, gebruikt u uw testgegevens om de prestaties van het model te valideren.

Maak de Evaluate() methode, net na BuildAndTrainModel(), met de volgende code:
```
void Evaluate(MLContext mlContext, ITransformer model, IDataView splitTestSet)
{

}
```
Met Evaluate() de methode worden de volgende taken uitgevoerd:
- Laadt de testgegevensset.
- Hiermee maakt u de BinaryClassification evaluator.
- Evalueert het model en maakt metrische gegevens.
- Geeft de metrische gegevens weer.
Voeg een aanroep toe aan de nieuwe methode onder de BuildAndTrainModel methode-aanroep met behulp van de volgende code:
```
Evaluate(mlContext, model, splitDataView.TestSet);
```
Transformeer de splitTestSet gegevens door de volgende code toe te voegen aan Evaluate():
```
Console.WriteLine("=============== Evaluating Model accuracy with Test data===============");
IDataView predictions = model.Transform(splitTestSet);
```
In de vorige code wordt de methode Transform() gebruikt om voorspellingen te doen voor meerdere opgegeven invoerrijen van een testgegevensset.

Evalueer het model door het volgende toe te voegen als de volgende regel code in de Evaluate() methode:

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

Zodra u de voorspellingsset (predictions) hebt, evalueert de methode Evaluate() het model, waarmee de voorspelde waarden worden vergeleken met de werkelijke Labels waarden in de testgegevensset en een GekalibreerdBinaryClassificationMetrics-object wordt geretourneerd over hoe het model presteert.

De metrische gegevens voor modelvalidatie weergeven

Gebruik de volgende code om de metrische gegevens weer te geven:

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

Het Accuracy metrische gegeven haalt de nauwkeurigheid van een model op. Dit is het aandeel van de juiste voorspellingen in de testset.
De AreaUnderRocCurve metrische waarde geeft aan hoe zeker het model de positieve en negatieve klassen correct classificeert. U wilt dat de AreaUnderRocCurve zo dicht mogelijk bij een van de twee is.
De F1Score metrische waarde krijgt de F1-score van het model, een maateenheid voor de balans tussen precisie en relevante overeenkomsten. U wilt dat de F1Score zo dicht mogelijk bij een van de twee is.

Het resultaat van de testgegevens voorspellen

Maak de UseModelWithSingleItem() methode, net na de Evaluate() methode, met behulp van de volgende code:
```
void UseModelWithSingleItem(MLContext mlContext, ITransformer model)
{

}
```
Met UseModelWithSingleItem() de methode worden de volgende taken uitgevoerd:
- Hiermee maakt u één opmerking van testgegevens.
- Hiermee wordt het gevoel voorspeld op basis van testgegevens.
- Combineert testgegevens en voorspellingen voor rapportage.
- Geeft de voorspelde resultaten weer.
Voeg een aanroep toe aan de nieuwe methode direct onder de Evaluate() methode-aanroep met behulp van de volgende code:
```
UseModelWithSingleItem(mlContext, model);
```
Voeg de volgende code toe om als eerste regel in de UseModelWithSingleItem() methode te maken:
```
PredictionEngine<SentimentData, SentimentPrediction> predictionFunction = mlContext.Model.CreatePredictionEngine<SentimentData, SentimentPrediction>(model);
```
De PredictionEngine is een handige API waarmee u een voorspelling kunt uitvoeren op één exemplaar van gegevens. PredictionEngine is niet thread-safe. Het is acceptabel om te gebruiken in omgevingen met één thread of prototype. Voor verbeterde prestaties en threadveiligheid in productieomgevingen gebruikt u de PredictionEnginePool service, waarmee een ObjectPool van PredictionEngine -objecten wordt gemaakt voor gebruik in uw toepassing. Raadpleeg deze handleiding over het gebruik PredictionEnginePool in een ASP.NET Core web-API.

Notitie

PredictionEnginePool de service-extensie is momenteel in preview.
Voeg een opmerking toe om de voorspelling van het getrainde model te testen in de UseModelWithSingleItem() methode door een exemplaar van te maken:SentimentData
```
SentimentData sampleStatement = new SentimentData
{
    SentimentText = "This was a very bad steak"
};
```
Geef de testopmerkingsgegevens door aan de PredictionEngine door het volgende toe te voegen als de volgende coderegels in de UseModelWithSingleItem() methode:
```
var resultPrediction = predictionFunction.Predict(sampleStatement);
```
De functie Predict() doet een voorspelling op één rij met gegevens.

Geef en de bijbehorende gevoelsvoorspelling weer SentimentText met behulp van de volgende code:

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

Het model gebruiken voor voorspelling

Batch-items implementeren en voorspellen

Maak de UseModelWithBatchItems() methode, net na de UseModelWithSingleItem() methode, met behulp van de volgende code:
```
void UseModelWithBatchItems(MLContext mlContext, ITransformer model)
{

}
```
Met UseModelWithBatchItems() de methode worden de volgende taken uitgevoerd:
- Hiermee worden batchtestgegevens gemaakt.
- Hiermee wordt het gevoel voorspeld op basis van testgegevens.
- Combineert testgegevens en voorspellingen voor rapportage.
- Geeft de voorspelde resultaten weer.
Voeg een aanroep toe aan de nieuwe methode direct onder de UseModelWithSingleItem() methode-aanroep met behulp van de volgende code:
```
UseModelWithBatchItems(mlContext, model);
```

Voeg enkele opmerkingen toe om de voorspellingen van het getrainde model te testen in de UseModelWithBatchItems() methode:

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

Opmerkingsentiment voorspellen

Gebruik het model om het gevoel van opmerkingsgegevens te voorspellen met behulp van de methode 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);

De voorspellingen combineren en weergeven

Maak een header voor de voorspellingen met behulp van de volgende code:

Console.WriteLine();

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

Omdat SentimentPrediction wordt overgenomen van SentimentData, wordt de Transform() methode gevuld SentimentText met de voorspelde velden. Naarmate het ML.NET proces wordt verwerkt, voegt elk onderdeel kolommen toe, waardoor de resultaten eenvoudig kunnen worden weergegeven:

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

Resultaten

De resultaten moeten er ongeveer als volgt uitzien. Tijdens de verwerking worden berichten weergegeven. Mogelijk ziet u waarschuwingen of worden berichten verwerkt. Deze zijn voor de duidelijkheid verwijderd uit de volgende resultaten.

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

Gefeliciteerd U hebt nu een machine learning-model gebouwd voor het classificeren en voorspellen van het gevoel van berichten.

Het bouwen van succesvolle modellen is een iteratief proces. Dit model heeft in eerste instantie een lagere kwaliteit omdat in de zelfstudie kleine gegevenssets worden gebruikt om snelle modeltraining te bieden. Als u niet tevreden bent met de kwaliteit van het model, kunt u proberen deze te verbeteren door grotere trainingsgegevenssets op te geven of door verschillende trainingsalgoritmen te kiezen met verschillende hyperparameters voor elk algoritme.