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

Artikel
12/21/2024

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

Het TensorFlow-model dat in deze zelfstudie wordt gebruikt, is getraind met behulp van filmbeoordelingen uit de IMDB-database. Zodra u klaar bent met het ontwikkelen van de toepassing, kunt u filmbeoordelingstekst opgeven en geeft de toepassing aan of de beoordeling een positief of negatief gevoel heeft.

In deze zelfstudie leert u het volgende:

Een vooraf getraind TensorFlow-model laden
Tekst van websitecommentaar omzetten 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 dotnet/samples opslagplaats.

Voorwaarden

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

Installatie

De toepassing maken

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

Notitie

In dit voorbeeld wordt de nieuwste 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. 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 uit de dotnet/machinelearning-testdata GitHub-opslagplaats. Het model is in het TensorFlow SavedModel-formaat.

Download het sentiment_model zip-bestanden pak het uit.

Het zip-bestand bevat:
- saved_model.pb: het TensorFlow-model zelf. Het model heeft een matrix met een vaste lengte (grootte 600) met functies die de tekst in een IMDB-beoordelingstekenreeks vertegenwoordigen en levert twee waarschijnlijkheden op die optellen tot 1: de kans dat de invoerbeoordeling een positief gevoel heeft en de kans dat de invoerbeoordeling een negatief gevoel heeft.
- imdb_word_index.csv: een koppeling van afzonderlijke woorden aan een geheel getal. De mapping wordt gebruikt om de invoerfuncties voor het TensorFlow-model te genereren.
Kopieer de inhoud van de binnenste sentiment_model map naar uw TextClassificationTF project sentiment_model map. Deze map bevat het model en 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 Advancedde waarde van Kopiëren naar uitvoermap in Kopiëren indien nieuwer.

`using`-instructies en globale variabelen toevoegen

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

De gegevens modelleren

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

De eerste stap is het splitsen van de tekst in afzonderlijke woorden en het opgegeven toewijzingsbestand gebruiken om elk woord naar een gehele getallen codering om te zetten. Het resultaat van deze transformatie is een matrix met variabele lengte gehele getallen met een lengte die overeenkomt met het aantal woorden in de zin.

Eigenschap	Waarde	Type
Beoordelingstekst	deze film is echt goed	string
Kenmerken van Variabele Lengte	14,22,9,66,78,...	int[]

De functiematrix voor variabele lengte wordt vervolgens aangepast aan een vaste lengte van 600. Dit is de lengte die het TensorFlow-model verwacht.

Eigenschap	Waarde	Typ
Beoordelingstekst	deze film is echt goed	snaar
Kenmerken met Variabele Lengte	14,22,9,66,78,...	int[]
Functies	14,22,9,66,78,...	int[600]

Maak een klasse voor uw invoergegevens onderaan het Program.cs-bestand:
```
/// <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 eigenschap VariableLengthFeatures heeft een VectorType- kenmerk om deze als vector aan te wijzen. Alle vectorelementen moeten hetzelfde type zijn. In gegevenssets met een groot aantal kolommen vermindert het laden van meerdere kolommen als één vector het aantal gegevens dat wordt doorgegeven wanneer u gegevenstransformaties toepast.

Deze klasse wordt gebruikt in de actie ResizeFeatures. De naam van zijn eigenschap (in dit geval slechts één) wordt gebruikt om aan te geven welke kolommen in de DataView kunnen worden gebruikt als de invoer voor de aangepaste koppelingsactie.
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 actie ResizeFeatures. 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 de uitvoer van de aangepaste toewijzingsactie.

Houd er rekening mee dat de naam van de eigenschap Features wordt bepaald door het TensorFlow-model. U kunt deze eigenschapsnaam 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 lengte van de functievector:
```
static class Config
{
    public const int FeatureLength = 600;
}
```

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

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

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

Woord Index

Kinderen 362

willen 181

verkeerd 355

Effecten 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: ','
    );
```

Woord	Index
Kinderen	362
willen	181
verkeerd	355
Effecten	302
gevoel	547

Voeg een Action toe om het formaat van de matrix met het gehele getal van het variabelelengtewoord te wijzigen in een matrix met een vaste grootte, met de volgende coderegels:

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 voor interesse en leren weergegeven. 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 met waarschijnlijkheden die aangeven of het gevoel van een beoordeling negatief of positief is. Deze waarden tellen op tot 1, omdat de kans op positieve gevoelens de aanvulling is van de waarschijnlijkheid van negatieve gevoelens.

De ML.NET-pijplijn maken

Maak de pijplijn en splits de invoertekst in woorden met behulp van TokenizeIntoWords transformeren om de tekst 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 transformatie TokenizeIntoWords maakt gebruik van spaties om de tekst/tekenreeks te parseren in woorden. Er wordt een nieuwe kolom gemaakt en elke invoertekenreeks gesplitst in een vector van subtekenreeksen op basis van het door de gebruiker gedefinieerde scheidingsteken.

Koppel de woorden aan hun gehele getalcodering met behulp van de tabel die u hierboven hebt opgesteld.

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

Herschalen de gecodeerde gehele getallen van variabele lengte naar de vaste lengte die door 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 Prediction/Softmaxgenoemd. 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 kolom Prediction/Softmax 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 op basis van 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);
```
Een ML.NET model wordt gemaakt op basis van de keten van schattingen in de pijplijn door de Fit methode aan te roepen. In dit geval past u geen gegevens aan om het model te maken, omdat het TensorFlow-model al eerder is getraind. U geeft een leeg gegevensweergaveobject op 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 klasse MovieReview:

void PredictSentiment(MLContext mlContext, ITransformer model)
{

}

Voeg de volgende code toe om de PredictionEngine als de eerste regel in de methode PredictSentiment() in te stellen:
```
var engine = mlContext.Model.CreatePredictionEngine<MovieReview, MovieReviewSentimentPrediction>(model);
```
De PredictionEngine- is een handige API waarmee u een voorspelling kunt uitvoeren op één exemplaar van gegevens. PredictionEngine is niet draadveilig. 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. Zie deze handleiding voor het gebruik van PredictionEnginePool in een ASP.NET Core Web API-.

Notitie

PredictionEnginePool service-extensie is momenteel beschikbaar als preview-versie.
Voeg een opmerking toe om de voorspelling van het getrainde model te testen in de methode Predict() door een exemplaar van MovieReviewte maken:
```
var review = new MovieReview()
{
    ReviewText = "this film is really good"
};
```
Geef de testcommentaargegevens door aan de Prediction Engine door de volgende coderegels toe te voegen in de methode PredictSentiment():
```
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[]

Sentimentvoorspelling weergeven 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 nadat u de methode Fit() hebt aangeroepen:
```
PredictSentiment(mlContext, model);
```

Resultaten

Bouw uw toepassing en voer deze uit.

Uw resultaten moeten er ongeveer als volgt uitzien. Tijdens de verwerking worden berichten weergegeven. U ziet mogelijk waarschuwingen of verwerkingsberichten. Deze berichten zijn voor 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.

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

In deze zelfstudie hebt u het volgende geleerd:

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

Delen via

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

Voorwaarden

Installatie

De toepassing maken

Het TensorFlow-model toevoegen aan het project

`using`-instructies en globale variabelen toevoegen

De gegevens modelleren

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

Het vooraf getrainde TensorFlow-model laden

De ML.NET-pijplijn maken

Het ML.NET-model maken op basis van de pijplijn

Het model gebruiken om een voorspelling te doen

Resultaten

Aanvullende resources

Delen via

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

Voorwaarden

Installatie

De toepassing maken

Het TensorFlow-model toevoegen aan het project

using-instructies en globale variabelen toevoegen

De gegevens modelleren

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

Het vooraf getrainde TensorFlow-model laden

De ML.NET-pijplijn maken

Het ML.NET-model maken op basis van de pijplijn

Het model gebruiken om een voorspelling te doen

Resultaten

Aanvullende resources

`using`-instructies en globale variabelen toevoegen