Zelfstudie: Sentiment van filmrecensies analyseren met behulp van een vooraf getraind TensorFlow-model in ML.NET

Artikel
04/08/2023

In deze zelfstudie leert u hoe u een vooraf getraind TensorFlow-model gebruikt om gevoel in websiteopmerkingen te classificeren. De binaire gevoelsclassificatie is een C#-consoletoepassing die is ontwikkeld met Visual Studio.

Het TensorFlow-model dat in deze zelfstudie wordt gebruikt, is getraind met behulp van filmrecensies uit de IMDB-database. Zodra u klaar bent met het ontwikkelen van de toepassing, kunt u tekst voor filmbeoordeling opgeven en de toepassing zal u vertellen of de beoordeling positief of negatief is.

In deze zelfstudie leert u het volgende:

Een vooraf getraind TensorFlow-model laden
Tekst van websitecommentaar transformeren in functies die geschikt zijn voor het model
Het model gebruiken om een voorspelling te doen

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

Vereisten

Visual Studio 2022 met de workload .NET Desktop Development geïnstalleerd.

Instellen

De toepassing maken

Maak een C# -consoletoepassing met de naam TextClassificationTF. 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. Herhaal deze stappen voor Microsoft.ML.TensorFlow, Microsoft.ML.SampleUtils en SciSharp.TensorFlow.Redist.

Het TensorFlow-model toevoegen aan het project

Notitie

Het model voor deze zelfstudie is afkomstig van de GitHub-opslagplaats dotnet/machinelearning-testdata . Het model heeft de indeling TensorFlow SavedModel.

Download het zip-bestand sentiment_model en pak het uit.

Het ZIP-bestand bevat:
- saved_model.pb: het TensorFlow-model zelf. Het model maakt gebruik van een matrix met een geheel getal met vaste lengte (grootte 600) van kenmerken die de tekst in een IMDB-beoordelingsreeks vertegenwoordigen en levert twee waarschijnlijkheden uit die 1 optellen: de kans dat de invoerbeoordeling een positief gevoel heeft en de kans dat de invoerbeoordeling een negatief gevoel heeft.
- imdb_word_index.csv: een toewijzing van afzonderlijke woorden aan een geheel getal. De toewijzing wordt gebruikt om de invoerfuncties voor het TensorFlow-model te genereren.
Kopieer de inhoud van de binnenste sentiment_model map naar de projectmapsentiment_model TextClassificationTF. Deze map bevat het model en de aanvullende ondersteuningsbestanden die nodig zijn voor deze zelfstudie, zoals wordt weergegeven in de volgende afbeelding:
Klik in Solution Explorer met de rechtermuisknop op elk van de bestanden in de sentiment_model map en submap en selecteer Eigenschappen. Wijzig onder Geavanceerd de waarde van Kopiëren naar uitvoermap in Kopiëren indien nieuwer.

Gebruiksinstructies en globale variabelen toevoegen

Voeg de volgende aanvullende using instructies toe aan het begin van het bestand Program.cs :
```
using Microsoft.ML;
using Microsoft.ML.Data;
using Microsoft.ML.Transforms;
```
Maak een globale variabele direct na de using-instructies voor het opslaan van het pad naar het opgeslagen modelbestand.
```
string _modelPath = Path.Combine(Environment.CurrentDirectory, "sentiment_model");
```
- _modelPath is het bestandspad van het getrainde model.

De gegevens modelleren

Filmrecensies zijn vrije tekst. De toepassing converteert de tekst in een aantal afzonderlijke fasen naar de invoerindeling die door het model wordt verwacht.

De eerste is om de tekst op te splitsen in afzonderlijke woorden en het opgegeven toewijzingsbestand te gebruiken om elk woord toe te wijzen aan een geheel getalcodering. Het resultaat van deze transformatie is een matrix met een geheel getal met een variabele lengte met een lengte die overeenkomt met het aantal woorden in de zin.

Eigenschap	Waarde	Type
ReviewText	deze film is echt goed	tekenreeks
VariableLengthFeatures	14,22,9,66,78,...	int[]

De functiematrix met variabele lengte wordt vervolgens gewijzigd in een vaste lengte van 600. Dit is de lengte die het TensorFlow-model verwacht.

Eigenschap	Waarde	Type
ReviewText	deze film is echt goed	tekenreeks
VariableLengthFeatures	14,22,9,66,78,...	int[]
Functies	14,22,9,66,78,...	int[600]

Maak een klasse voor uw invoergegevens onderaan het bestand Program.cs :
```
/// <summary>
/// Class to hold original sentiment data.
/// </summary>
public class MovieReview
{
    public string? ReviewText { get; set; }
}
```
De invoergegevensklasse, MovieReview, heeft een string voor gebruikersopmerkingen (ReviewText).
Maak een klasse voor de functies voor variabele lengte na de MovieReview klasse:
```
/// <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; }
}
```
De VariableLengthFeatures eigenschap heeft een VectorType-kenmerk om deze aan te wijzen als een vector. Alle vectorelementen moeten van hetzelfde type zijn. Als u in gegevenssets met een groot aantal kolommen meerdere kolommen als één vector laadt, vermindert u het aantal gegevens dat wordt doorgegeven wanneer u gegevenstransformaties toepast.

Deze klasse wordt gebruikt in de ResizeFeatures actie. De namen van de eigenschappen (in dit geval slechts één) worden gebruikt om aan te geven welke kolommen in de DataView kunnen worden gebruikt als invoer voor de aangepaste toewijzingsactie.
Maak een klasse voor de functies met een vaste lengte, na de VariableLength klasse:
```
/// <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; }
}
```
Deze klasse wordt gebruikt in de ResizeFeatures actie. De namen van de eigenschappen (in dit geval slechts één) worden gebruikt om aan te geven welke kolommen in de DataView als uitvoer van de aangepaste toewijzingsactie kunnen worden gebruikt.

Houd er rekening mee dat de naam van de eigenschap Features wordt bepaald door het TensorFlow-model. U kunt de naam van deze eigenschap niet wijzigen.
Maak een klasse voor de voorspelling na de FixedLength klasse:
```
/// <summary>
/// Class to contain the output values from the transformation.
/// </summary>
public class MovieReviewSentimentPrediction
{
    [VectorType(2)]
    public float[]? Prediction { get; set; }
}
```
MovieReviewSentimentPrediction is de voorspellingsklasse die wordt gebruikt na de modeltraining. MovieReviewSentimentPrediction heeft één float matrix (Prediction) en een VectorType kenmerk.
Maak een andere klasse voor het opslaan van configuratiewaarden, zoals de functievectorlengte:
```
static class Config
{
    public const int FeatureLength = 600;
}
```

De MLContext, de opzoekwoordenlijst en de actie maken om het formaat van functies te wijzigen

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.

Vervang de Console.WriteLine("Hello World!") regel door de volgende code om de variabele mlContext te declareren en te initialiseren:
```
MLContext mlContext = new MLContext();
```
Maak een woordenlijst om woorden als gehele getallen te coderen met behulp van de LoadFromTextFile methode om toewijzingsgegevens uit een bestand te laden, zoals te zien is in de volgende tabel:

Word Index

Kinderen 362

Wilt 181

Verkeerd 355

effects 302

Gevoel 547

Voeg de onderstaande code toe om de opzoekkaart te maken:
```
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: ','
    );
```

Word	Index
Kinderen	362
Wilt	181
Verkeerd	355
effects	302
Gevoel	547

Voeg een Action toe om het formaat van het woord geheel getal met variabele lengte te wijzigen in een matrix met een geheel getal met een vaste grootte, met de volgende regels code:

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

Het vooraf getrainde TensorFlow-model laden

Voeg code toe om het TensorFlow-model te laden:
```
TensorFlowModel tensorFlowModel = mlContext.Model.LoadTensorFlowModel(_modelPath);
```
Zodra het model is geladen, kunt u het invoer- en uitvoerschema extraheren. De schema's worden alleen weergegeven voor interesse en leren. U hebt deze code niet nodig om de uiteindelijke toepassing te laten functioneren:
```
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]})");
```
Het invoerschema is de matrix met vaste lengte van met gehele getallen gecodeerde woorden. Het uitvoerschema is een floatmatrix van waarschijnlijkheden die aangeven of het gevoel van een beoordeling negatief of positief is. Deze waarden worden opgeteld tot 1, omdat de kans op positief zijn het complement is van de waarschijnlijkheid dat het gevoel negatief is.

De ML.NET-pijplijn maken

Maak de pijplijn en splits de invoertekst in woorden met de transformatie TokenizeIntoWords om de tekst op te splitsen in woorden als de volgende regel code:
```
IEstimator<ITransformer> pipeline =
    // Split the text into individual words
    mlContext.Transforms.Text.TokenizeIntoWords("TokenizedWords", "ReviewText")
```
De tokenizeIntoWords-transformatie maakt gebruik van spaties om de tekst/tekenreeks in woorden te parseren. Er wordt een nieuwe kolom gemaakt en elke invoerreeks gesplitst in een vector van subtekenreeksen op basis van het door de gebruiker gedefinieerde scheidingsteken.

Wijs de woorden toe aan de codering van gehele getallen met behulp van de opzoektabel die u hierboven hebt gedeclareerd:

// 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"))

Wijzig de grootte van de coderingen voor gehele getallen met variabele lengte in de vaste lengte die voor het model is vereist:

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

Classificeer de invoer met het geladen TensorFlow-model:
```
// Passes the data to TensorFlow for scoring
.Append(tensorFlowModel.ScoreTensorFlowModel("Prediction/Softmax", "Features"))
```
De uitvoer van het TensorFlow-model wordt genoemd Prediction/Softmax. Houd er rekening mee dat de naam Prediction/Softmax wordt bepaald door het TensorFlow-model. U kunt deze naam niet wijzigen.
Maak een nieuwe kolom voor de uitvoervoorspelling:
```
// Retrieves the 'Prediction' from TensorFlow and copies to a column
.Append(mlContext.Transforms.CopyColumns("Prediction", "Prediction/Softmax"));
```
U moet de Prediction/Softmax kolom kopiëren naar een kolom met een naam die kan worden gebruikt als een eigenschap in een C#-klasse: Prediction. Het / teken is niet toegestaan in de naam van een C#-eigenschap.

Het ML.NET-model maken vanuit de pijplijn

Voeg de code toe om het model te maken vanuit de pijplijn:
```
// Create an executable model from the estimator pipeline
IDataView dataView = mlContext.Data.LoadFromEnumerable(new List<MovieReview>());
ITransformer model = pipeline.Fit(dataView);
```
Er wordt een ML.NET-model gemaakt op basis van de keten van schattingen in de pijplijn door de methode aan Fit te roepen. In dit geval passen we geen gegevens aan om het model te maken, omdat het TensorFlow-model al eerder is getraind. We leveren een leeg gegevensweergaveobject om te voldoen aan de vereisten van de Fit methode.

Het model gebruiken om een voorspelling te doen

Voeg de PredictSentiment methode toe boven de MovieReview klasse:

void PredictSentiment(MLContext mlContext, ITransformer model)
{

}

Voeg de volgende code toe om de PredictionEngine te maken als de eerste regel in de PredictSentiment() methode:
```
var engine = mlContext.Model.CreatePredictionEngine<MovieReview, MovieReviewSentimentPrediction>(model);
```
De PredictionEngine is een gemaks-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 in de Predict() methode te testen door een exemplaar van te maken:MovieReview
```
var review = new MovieReview()
{
    ReviewText = "this film is really good"
};
```
Geef de gegevens van de testcommentaar door aan de Prediction Engine door de volgende regels code toe te voegen in de PredictSentiment() methode:
```
var sentimentPrediction = engine.Predict(review);
```
De functie Predict() doet een voorspelling voor één rij gegevens:

Eigenschap Waarde Type

Voorspelling [0.5459937, 0.454006255] float[]

Eigenschap	Waarde	Type
Voorspelling	[0.5459937, 0.454006255]	float[]

Geef sentimentvoorspelling weer met behulp van de volgende code:

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

Voeg een aanroep toe aan PredictSentiment na het aanroepen van de Fit() methode:
```
PredictSentiment(mlContext, model);
```

Resultaten

Bouw uw toepassing en voer deze uit.

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

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

Gefeliciteerd U hebt nu een machine learning-model gebouwd voor het classificeren en voorspellen van het gevoel van berichten door een vooraf getraind TensorFlow model opnieuw te gebruiken in ML.NET.