Oktatóanyag: Mozgókép-vélemények hangulatának elemzése előre betanított TensorFlow-modell használatával a ML.NET

Cikk
05/10/2023

Ez az oktatóanyag bemutatja, hogyan használható egy előre betanított TensorFlow-modell a hangulat besorolására a webhely megjegyzéseiben. A bináris hangulatosztályozó egy C#-konzolalkalmazás, amelyet a Visual Studio használatával fejlesztettek ki.

Az oktatóanyagban használt TensorFlow-modell betanítása az IMDB-adatbázisból származó filmértékelések használatával történt. Miután befejezte az alkalmazás fejlesztését, megadhatja a filmküldő szöveget, és az alkalmazás megmondja, hogy az értékelés pozitív vagy negatív hangulatú-e.

Eben az oktatóanyagban az alábbiakkal fog megismerkedni:

Előre betanított TensorFlow-modell betöltése
Webhely megjegyzésszövegének átalakítása a modellnek megfelelő funkciókká
Előrejelzés készítése a modell használatával

Az oktatóanyag forráskódját a dotnet/samples adattárban találja.

Előfeltételek

A Visual Studio 2022-ben telepítve van a ".NET Desktop-fejlesztés" számítási feladat.

Telepítés

Az alkalmazás létrehozása

Hozzon létre egy "TextClassificationTF" nevű C#- konzolalkalmazást . Kattintson a Tovább gombra.
Válassza a .NET 6-ot a használni kívánt keretrendszerként. Kattintson a Létrehozás gombra.
Hozzon létre egy Data (Adatok ) nevű könyvtárat a projektben az adatkészletfájlok mentéséhez.
Telepítse a Microsoft.ML NuGet-csomagot:

Megjegyzés

Ez a minta az említett NuGet-csomagok legújabb stabil verzióját használja, hacsak másként nem rendelkezik.

A Megoldáskezelő kattintson a jobb gombbal a projektre, és válassza a Manage NuGet Packages (NuGet-csomagok kezelése) lehetőséget. Válassza a "nuget.org" lehetőséget a csomag forrásaként, majd válassza a Tallózás lapot. Keresse meg a Microsoft.ML, válassza ki a kívánt csomagot, majd kattintson a Telepítés gombra. Folytassa a telepítést a választott csomag licencfeltételeinek elfogadásával. Ismételje meg ezeket a lépéseket a Microsoft.ML.TensorFlow, a Microsoft.ML.SampleUtils és a SciSharp.TensorFlow.Redist esetében.

A TensorFlow-modell hozzáadása a projekthez

Megjegyzés

Az oktatóanyag modellje a dotnet/machinelearning-testdata GitHub-adattárból származik. A modell TensorFlow SavedModel formátumban van.

Töltse le a sentiment_model zip-fájlt, és csomagolja ki.

A zip-fájl a következőket tartalmazza:
- saved_model.pb: maga a TensorFlow modell. A modell rögzített hosszúságú (600-es méretű) egész számtömböt vesz fel, amely egy IMDB felülvizsgálati sztringben szereplő szöveget jelöl, és két valószínűséget ad ki, amelyek összege 1: annak a valószínűsége, hogy a bemeneti felülvizsgálat pozitív hangulatú, és annak valószínűsége, hogy a bemeneti felülvizsgálat negatív hangulatú.
- imdb_word_index.csv: az egyes szavakból egy egész szám értékre való leképezése. A leképezés a TensorFlow-modell bemeneti funkcióinak létrehozására szolgál.
Másolja a legbelső sentiment_model könyvtár tartalmát a TextClassificationTF projektkönyvtárba sentiment_model . Ez a könyvtár tartalmazza az oktatóanyaghoz szükséges modellt és további támogatási fájlokat, az alábbi képen látható módon:
A Megoldáskezelő kattintson a jobb gombbal az egyes fájlokra a könyvtárban és az alkönyvtárban, és válassza a sentiment_modelTulajdonságok lehetőséget. A Speciális területen módosítsa a Másolás kimeneti könyvtárra értékét Másolás, ha újabb értékre.

Hozzáadás using utasításokkal és globális változókkal

Adja hozzá a következő további using utasításokat a Program.cs fájl elejéhez:
```
using Microsoft.ML;
using Microsoft.ML.Data;
using Microsoft.ML.Transforms;
```
Hozzon létre egy globális változót közvetlenül a using utasítások után a mentett modellfájl elérési útjának tárolásához.
```
string _modelPath = Path.Combine(Environment.CurrentDirectory, "sentiment_model");
```
- _modelPath A a betanított modell fájlelérési útja.

Az adatok modellezése

A filmértékelések ingyenes formátumú szövegek. Az alkalmazás több különálló fázisban konvertálja a szöveget a modell által várt bemeneti formátumba.

Az első az, hogy a szöveget külön szavakra osztja, és a megadott leképezési fájl használatával az egyes szavakat egy egész szám kódolására képezi le. Az átalakítás eredménye egy változó hosszúságú egész számtömb, amelynek hossza megfelel a mondatban szereplő szavak számának.

Tulajdonság	Érték	Típus
Korrektúraszöveg	ez a film nagyon jó	sztring
VariableLengthFeatures	14,22,9,66,78,...	int[]

A változóhosszúságú funkciótömböt ezután a rendszer 600-ra méretezi át. Ez a TensorFlow-modell által várt hossz.

Tulajdonság	Érték	Típus
Korrektúraszöveg	ez a film nagyon jó	sztring
VariableLengthFeatures	14,22,9,66,78,...	int[]
Funkciók	14,22,9,66,78,...	int[600]

Hozzon létre egy osztályt a bemeneti adatokhoz a Program.cs fájl alján:
```
/// <summary>
/// Class to hold original sentiment data.
/// </summary>
public class MovieReview
{
    public string? ReviewText { get; set; }
}
```
A bemeneti adatosztály () MovieReviewfelhasználói megjegyzésekhez (ReviewText) tartozikstring.
Hozzon létre egy osztályt a változóhosszúság-funkciókhoz az MovieReview osztály után:
```
/// <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; }
}
```
A VariableLengthFeatures tulajdonság egy VectorType attribútummal rendelkezik, amely vektorként jelöli meg. Az összes vektorelemnek azonos típusúnak kell lennie. A nagy számú oszlopot tartalmazó adathalmazokban több oszlop egyetlen vektorként való betöltése csökkenti az adatátalakítások alkalmazásakor áthaladó adatok számát.

Ezt az osztályt használja a ResizeFeatures művelet. A tulajdonságok nevei (ebben az esetben csak egy) jelzik, hogy a DataView mely oszlopai használhatók az egyéni leképezési művelet bemeneteként .
Hozzon létre egy osztályt a rögzített hosszúságú funkciókhoz az VariableLength osztály után:
```
/// <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; }
}
```
Ezt az osztályt használja a ResizeFeatures művelet. A tulajdonságok nevei (ebben az esetben csak egy) jelzik, hogy a DataView mely oszlopai használhatók az egyéni leképezési művelet kimeneteként .

Vegye figyelembe, hogy a tulajdonság Features nevét a TensorFlow-modell határozza meg. Ez a tulajdonságnév nem módosítható.
Hozzon létre egy osztályt az előrejelzéshez az FixedLength osztály után:
```
/// <summary>
/// Class to contain the output values from the transformation.
/// </summary>
public class MovieReviewSentimentPrediction
{
    [VectorType(2)]
    public float[]? Prediction { get; set; }
}
```
MovieReviewSentimentPrediction A a modell betanítása után használt előrejelzési osztály. MovieReviewSentimentPrediction egyetlen float tömbje (Prediction) és attribútuma van VectorType .
Hozzon létre egy másik osztályt a konfigurációs értékek tárolásához, például a jellemzővektor hosszát:
```
static class Config
{
    public const int FeatureLength = 600;
}
```

Az MLContext, keresési szótár és művelet létrehozása a funkciók átméretezéséhez

Az MLContext osztály minden ML.NET művelet kiindulási pontja. Az inicializálás mlContext új ML.NET környezetet hoz létre, amely megosztható a modelllétrehozás munkafolyamat-objektumai között. Ez fogalmilag hasonló az Entity Frameworkhez DBContext .

Cserélje le a Console.WriteLine("Hello World!") sort a következő kódra az mlContext változó deklarálásához és inicializálásához:
```
MLContext mlContext = new MLContext();
```
Hozzon létre egy szótárat, amellyel a szavakat egész számokként kódolhatja a LoadFromTextFile metódussal a leképezési adatok fájlból való betöltéséhez, az alábbi táblázatban látható módon:

Word Index

Gyerekek 362

Akar 181

Rossz 355

effects 302

Érzés 547

Adja hozzá az alábbi kódot a keresési térkép létrehozásához:
```
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
Gyerekek	362
Akar	181
Rossz	355
effects	302
Érzés	547

Adjon hozzá egy értéket Action a változó hosszúságú szó egész számtömbjének átméretezéséhez egy rögzített méretű egész számtömbre a következő kódsorokkal:

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

Az előre betanított TensorFlow-modell betöltése

Adjon hozzá kódot a TensorFlow-modell betöltéséhez:
```
TensorFlowModel tensorFlowModel = mlContext.Model.LoadTensorFlowModel(_modelPath);
```
A modell betöltése után kinyerheti annak bemeneti és kimeneti sémáját. A sémák csak érdeklődési és tanulási célokra jelennek meg. A végső alkalmazás működéséhez nincs szükség erre a kódra:
```
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]})");
```
A bemeneti séma az egész szám által kódolt szavak rögzített hosszúságú tömbje. A kimeneti séma egy lebegőpontos valószínűségi tömb, amely azt jelzi, hogy egy vélemény hangulata negatív vagy pozitív. Ezek az értékek összege 1, mivel a pozitívság valószínűsége a negatív hangulat valószínűségének kiegészítése.

A ML.NET-folyamat létrehozása

Hozza létre a folyamatot, és ossza fel a bemeneti szöveget szavakra a TokenizeIntoWords átalakítással, hogy a szöveget szavakra bontsa a kód következő soraként:
```
IEstimator<ITransformer> pipeline =
    // Split the text into individual words
    mlContext.Transforms.Text.TokenizeIntoWords("TokenizedWords", "ReviewText")
```
A TokenizeIntoWords átalakítás szóközök használatával elemzi a szöveget/sztringet szavakká. Létrehoz egy új oszlopot, és az egyes bemeneti sztringeket a felhasználó által definiált elválasztó alapján részsztringek vektorára osztja fel.

Képezheti le a szavakat az egész szám kódolására a fent deklarált keresési táblával:

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

Méretezze át a változó hosszúságú egész szám kódolását a modell által megkövetelt rögzített hosszúságúra:

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

Osztályozza a bemenetet a betöltött TensorFlow-modellel:
```
// Passes the data to TensorFlow for scoring
.Append(tensorFlowModel.ScoreTensorFlowModel("Prediction/Softmax", "Features"))
```
A TensorFlow-modell kimenetének neve Prediction/Softmax. Vegye figyelembe, hogy a nevet Prediction/Softmax a TensorFlow-modell határozza meg. Ezt a nevet nem módosíthatja.
Hozzon létre egy új oszlopot a kimeneti előrejelzéshez:
```
// Retrieves the 'Prediction' from TensorFlow and copies to a column
.Append(mlContext.Transforms.CopyColumns("Prediction", "Prediction/Softmax"));
```
Az oszlopot egy olyan névvel kell átmásolnia Prediction/Softmax , amely tulajdonságként használható egy C#-osztályban: Prediction. A / karakter nem szerepelhet C#-tulajdonságnévben.

A ML.NET modell létrehozása a folyamatból

Adja hozzá a modellt a folyamatból létrehozó kódot:
```
// Create an executable model from the estimator pipeline
IDataView dataView = mlContext.Data.LoadFromEnumerable(new List<MovieReview>());
ITransformer model = pipeline.Fit(dataView);
```
Egy ML.NET modell jön létre a folyamat becslési láncából a Fit metódus meghívásával. Ebben az esetben nem illesztünk be adatokat a modell létrehozásához, mivel a TensorFlow-modellt már korábban betanítottuk. Egy üres adatnézet-objektumot adunk meg, amely megfelel a Fit metódus követelményeinek.

Előrejelzés készítése a modell használatával

Adja hozzá a metódust PredictSentiment a MovieReview osztály fölé:

void PredictSentiment(MLContext mlContext, ITransformer model)
{

}

Adja hozzá a következő kódot a PredictionEngine metódus első soraként való PredictSentiment() létrehozásához:
```
var engine = mlContext.Model.CreatePredictionEngine<MovieReview, MovieReviewSentimentPrediction>(model);
```
A PredictionEngine egy kényelmi API, amely lehetővé teszi, hogy egyetlen adatpéldányon végezzen előrejelzést. PredictionEngine nem szálbiztos. Egyszálas vagy prototípusos környezetben is használható. Az éles környezetekben a jobb teljesítmény és szálbiztonság érdekében használja a PredictionEnginePool szolgáltatást, amely objektumokat hoz létre ObjectPoolPredictionEngine az alkalmazás egészében való használatra. Ebből az útmutatóból megtudhatja, hogyan használható PredictionEnginePool ASP.NET Core webes API-kban.

Megjegyzés

PredictionEnginePool A szolgáltatásbővítmény jelenleg előzetes verzióban érhető el.
Adjon hozzá egy megjegyzést a betanított modell előrejelzésének teszteléséhez a metódusban egy Predict() példány létrehozásával MovieReview:
```
var review = new MovieReview()
{
    ReviewText = "this film is really good"
};
```
Adja át a teszt megjegyzésadatait a Prediction Engine metódus következő PredictSentiment() kódsorainak hozzáadásával:
```
var sentimentPrediction = engine.Predict(review);
```
A Predict() függvény egyetlen adatsorra ad előrejelzést:

Tulajdonság Érték Típus

Előrejelzés [0.5459937, 0.454006255] float[]

Tulajdonság	Érték	Típus
Előrejelzés	[0.5459937, 0.454006255]	float[]

Hangulat-előrejelzés megjelenítése a következő kóddal:

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

Adjon hozzá egy hívást a PredictSentiment metódus meghívása Fit() után:
```
PredictSentiment(mlContext, model);
```

Results (Eredmények)

Hozza létre és futtassa az alkalmazást.

Az eredményeknek az alábbihoz hasonlónak kell lenniük. A feldolgozás során üzenetek jelennek meg. Megjelenhetnek figyelmeztetések vagy üzenetek feldolgozása. Ezeket az üzeneteket eltávolítottuk az alábbi eredményekből az egyértelműség érdekében.

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

Gratulálunk! Sikeresen létrehozott egy gépi tanulási modellt az üzenetek hangulatának osztályozására és előrejelzésére egy előre betanított TensorFlow modell újbóli használatával ML.NET.