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

In deze zelfstudie leert u hoe u een .NET-consoletoepassing maakt die het gevoel classificeert op basis van websiteopmerkingen en de juiste actie onderneemt. De classificatie voor binaire sentimenten maakt gebruik van C# in Visual Studio 2022.

In deze handleiding leer je hoe je:

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

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

Vereiste voorwaarden

Visual Studio 2022 of hoger.
UCI Sentiment Labeled Sentences dataset (ZIP-bestand)

Een consoletoepassing maken

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

Opmerking

In dit voorbeeld wordt de laatste 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 Microsoft.ML, selecteer het gewenste pakket en selecteer vervolgens Installeren. Ga door met de installatie door akkoord te gaan met de licentievoorwaarden voor het pakket dat u kiest.

Uw gegevens voorbereiden

Opmerking

De gegevenssets voor deze zelfstudie zijn afkomstig van de 'Van groep tot afzonderlijke labels met behulp van diepe functies', Kotzias et. al. KDD 2015 en gehost door de UCI Machine Learning Repository - Dua, D. en 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 met UCI-sentimentlabels voor zinnen en pak het uit.
Kopieer het yelp_labelled.txt bestand naar de gegevensmap die u hebt gemaakt.
Klik in Solution Explorer met de rechtermuisknop op het yelp_labelled.txt bestand en selecteer Eigenschappen. Wijzig onder Geavanceerd de waarde van Kopiëren naar Uitvoermap naar Kopiëren als 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 rechts onder de using instructies om een veld te maken voor het onlangs gedownloade bestandspad van de gegevensset:
```
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 selecteerNieuw item>.
- Selecteer klasse in het dialoogvenster Nieuw item toevoegen en wijzig het veld Naamin SentimentData.cs. Selecteer vervolgens 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 toe, die twee klassen SentimentData heeft en SentimentPrediction, aan het SentimentData.cs-bestand :

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 klasse invoergegevensset, SentimentDataheeft 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, waarin de volgorde van het gegevensbestand van elk veld wordt beschreven. Bovendien heeft de Sentiment eigenschap een ColumnName-kenmerk om deze als veld Label aan te wijzen. Het volgende voorbeeldbestand heeft geen koprij en is als volgt:

SentimentTekst	Gevoel (label)
De serveerster was een beetje traag in de service.	0
Korst is niet goed.	0
Wauw... Ik hield van deze plek.	1
Service was erg prompt.	1

SentimentPrediction is de voorspellingsklasse die wordt gebruikt na modeltraining. Het erft van SentimentData zodat de invoer SentimentText samen met de uitvoervoorspelling kan worden weergegeven. De Prediction Booleaanse waarde is de waarde die het model voorspelt wanneer het 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 naar de waarschijnlijkheid van de tekst met een positief gevoel.

Voor deze zelfstudie is Prediction de 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) naar 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 in de werkstroomobjecten voor het maken van modellen. Het is vergelijkbaar, conceptueel gezien, met DBContext 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 mlContext-variabele te declareren en initialiseren:
```
MLContext mlContext = new MLContext();
```

Voeg het volgende toe als de volgende regel code:

TrainTestData splitDataView = LoadData(mlContext);

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

}
```
De LoadData() methode voert de volgende taken uit:
- Laadt de gegevens.
- Splitst de geladen gegevensset op in gegevenssets 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 in en retourneert een IDataView.

De gegevensset splitsen voor modeltraining en testen

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 gegevenssets voor trainen en testen 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 het 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 naar de LoadData methode:
```
ITransformer model = BuildAndTrainModel(mlContext, splitDataView.TrainSet);
```
De BuildAndTrainModel() methode voert de volgende taken uit:
- Hiermee worden de gegevens geëxtraheerd en getransformeerd.
- Traint het model.
- Voorspelt sentiment 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))

De FeaturizeText() methode in de vorige code converteert de tekstkolom (SentimentText) naar een numerieke sleuteltypekolom Features die wordt gebruikt door het machine learning-algoritme en voegt deze toe als een nieuwe gegevenssetkolom:

SentimentTekst	Gevoel	Features
De serveerster was een beetje traag in de service.	0	[0.76, 0.65, 0.44, …]
Korst is niet goed.	0	[0.98, 0.43, 0.54, …]
Wauw... Ik hield van deze plek.	1	[0.35, 0.73, 0.46, …]
Service was erg prompt.	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 coderegel in BuildAndTrainModel():

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

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

Het model trainen

Pas het model aan de splitTrainSet gegevens toe 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 Fit() -methode traint u uw model door de gegevensset te transformeren en de training toe te passen.

Het model retourneren dat is getraind voor evaluatie

Retourneert 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)
{

}
```
De Evaluate() methode voert de volgende taken uit:
- 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);
```
De vorige code maakt gebruik van de methode Transform() 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 waarden Labels 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 ===============");

De Accuracy metrische waarde 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 het AreaUnderRocCurve zo dicht mogelijk bij elkaar is.
De F1Score metriek haalt de F1-score van het model op, een maatstaf voor de balans tussen precisie en terugroepwaarde. U wilt dat het F1Score zo dicht mogelijk bij elkaar 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)
{

}
```
De UseModelWithSingleItem() methode voert de volgende taken uit:
- Hiermee maakt u één aantekening van testgegevens.
- Voorspelt sentiment 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 die u als eerste regel in de UseModelWithSingleItem() methode wilt maken:
```
PredictionEngine<SentimentData, SentimentPrediction> predictionFunction = mlContext.Model.CreatePredictionEngine<SentimentData, SentimentPrediction>(model);
```
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 u objecten ObjectPoolPredictionEngine maakt voor gebruik in uw toepassing. Raadpleeg deze handleiding voor het gebruik PredictionEnginePool in een ASP.NET Core Web-API.

Opmerking

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

Weergave SentimentText en bijbehorende sentimentvoorspelling 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

Batchitems implementeren en voorspellen

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

}
```
De UseModelWithBatchItems() methode voert de volgende taken uit:
- Hiermee maakt u batchtestgegevens.
- Voorspelt sentiment 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."
    }
};

Sentiment van opmerkingen voorspellen

Gebruik het model om het sentiment voor 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 deze wordt overgenomen van SentimentData, wordt de Transform() methode gevuld SentimentText met de voorspelde velden. Terwijl het ML.NET proces wordt verwerkt, voegt elk onderdeel kolommen toe en dit maakt het eenvoudig om de resultaten weer te geven:

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

Uw resultaten moeten er ongeveer als volgt uitzien. Tijdens de verwerking worden berichten weergegeven. U ziet mogelijk waarschuwingen of verwerkingsberichten. Deze zijn voor 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 initiële 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 het te verbeteren door grotere trainingsgegevenssets op te geven of door verschillende trainingsalgoritmen te kiezen met verschillende hyperparameters voor elk algoritme.