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

Ez az oktatóanyag bemutatja, hogyan használhat előre betanított TensorFlow-modellt a hangulatok webhely-megjegyzésekbe való besorolásához. A bináris hangulatosztályozó egy C#-konzolalkalmazás, amelyet a Visual Studióval fejlesztettek ki.

Az oktatóanyagban használt TensorFlow-modell betanítása az IMDB-adatbázisból származó filmes felülvizsgálatokkal történt. Miután befejezte az alkalmazás fejlesztését, megadhatja a film felülvizsgálati szövegét, és az alkalmazás meg fogja tudni mondani, hogy a vélemény pozitív vagy negatív hangulatú-e.

Ebben az oktatóanyagban a következőket sajátíthatja el:

• Előre betanított TensorFlow-modell betöltése
• A 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 vagy újabb verziója telepítve van a .NET Desktop Development számítási feladattal.

Beállítás

Az alkalmazás létrehozása

1. Hozzon létre egy "TextClassificationTF" nevű C#- konzolalkalmazást . Kattintson a Tovább gombra.

2. Válassza a .NET 8-at a használni kívánt keretrendszerként. Kattintson a Létrehozás gombra.

3. Hozzon létre egy Data nevű könyvtárat a projektben az adatkészletfájlok mentéséhez.

4. 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őben kattintson a jobb gombbal a projektre, és válassza a 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 válassza a Telepítés lehetőséget. 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.

1. Töltse le a sentiment_model zip-fájlt, és bontsa 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 elemből álló) egész számtömböt használ, amely az IMDB értékelés szövegét reprezentálja, és két valószínűséget ad ki, melyek összege 1: annak a valószínűsége, hogy a bemeneti értékelés pozitív érzelmű, és annak a valószínűsége, hogy a bemeneti értékelés negatív érzelmű.
   • 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.

2. 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, ahogyan az alábbi képen látható:

   

3. A Megoldáskezelőben kattintson a jobb gombbal a könyvtárban és az alkönyvtárban lévő fájlokra, és válassza a sentiment_modelTulajdonságok lehetőséget. A Speciális területen módosítsa a Kimeneti könyvtárba másolás értékét Másolás, ha újabb.

Irányelvek és globális változók hozzáadása using

1. Adja hozzá a következő további using irányelveket a Program.cs fájl elejéhez:

   using Microsoft.ML;
   using Microsoft.ML.Data;
   using Microsoft.ML.Transforms;
   

2. Hozzon létre egy globális változót közvetlenül az using irányelvek 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 betanított modell fájlútvonala.

Adatok modellezése

A filmkritikák szabad formájú 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 minden szót egy egész szám kódolására képez le. Az átalakítás eredménye egy változó hosszúságú egész számtömb, amelynek hossza a mondatban szereplő szavak számának felel meg.

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

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

Ingatlan	Érték	Típus
Korrektúraszöveg	ez a film nagyon jó	karakterlánc
VariableLengthFeatures	14,22,9,66,78,...	int[]
Features	14,22,9,66,78,...	int[600]

1. 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ésekkel (string) rendelkezikReviewText.

2. 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 VektorTípus attribútummal rendelkezik, amely vektorként jelöli meg. Minden vektorelemnek azonos típusúnak kell lennie. A nagy számú oszlopot tartalmazó adathalmazokban a több oszlop egyetlen vektorként való betöltése csökkenti az adatátjárók számát az adatátalakítások alkalmazásakor.

   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 .

3. 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. Ezt a tulajdonságnevet nem módosíthatja.

4. 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 modell betanítása után használt előrejelzési osztály. MovieReviewSentimentPrediction egyetlen float tömbből (Prediction) és attribútumból VectorType áll.

5. Hozzon létre egy másik osztályt a konfigurációs értékek tárolásához, például a funkcióvektor hosszához:

   static class Config
   {
       public const int FeatureLength = 600;
   }
   

Az MLContext, a lekérdezési szótár és a funkciók átméretezésére szolgáló művelet létrehozása

Az MLContext osztály minden ML.NET művelet kiinduló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 .

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

2. Hozzon létre egy szótárt, amely egész számként kódolja a szavakat a LoadFromTextFile módszer segítségével a leképezési adatok fájlból való betöltésére, ahogyan az a következő táblázatban látható.

   Word	Index
   Gyerekek	362
   akar	181
   rossz	355
   ingóságok	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: ','
       );
   

3. Addjon hozzá egy Action-t, amely a változó hosszúságú szó egész tömböt rögzített méretű egész számtömbbé alakítja az alábbi kódsorok segítségével:

   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

1. Kód hozzáadása 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és és tanulás céljából jelennek meg. A végleges 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 a valószínűségek lebegőpontos tömbje, amely azt jelzi, hogy egy vélemény hangulata negatív vagy pozitív. Ezek az értékek 1-et tartalmaznak, 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

1. 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övetkező kódsorké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 bontja fel a szöveget vagy karakterláncot szavakra. Létrehoz egy új oszlopot, és minden bemeneti sztringet feloszt a felhasználó által definiált elválasztó alapján az alsztringek vektorára.

2. Térképezze fel a szavakat a fent létrehozott keresési táblával az egész szám kódolásukra.

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

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

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

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

5. 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"));
   

   Egy tulajdonságként használható névvel kell átmásolnia a Prediction/Softmax oszlopot egy C# osztályban: Prediction. A / karakter C# tulajdonságnévben nem engedélyezett.

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

1. Adja hozzá a kódot a modell folyamatból való létrehozásához:

   // 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 be adatokat a modell létrehozásához, mivel a TensorFlow-modell már be van tanítva. A metódus követelményeinek Fit megfelelően üres adatnézet-objektumot ad meg.

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

1. Adja hozzá a metódust PredictSentiment az MovieReview osztály felett:

   void PredictSentiment(MLContext mlContext, ITransformer model)
   {
   
   }
   

2. 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 egyszerű API, amely lehetővé teszi az előrejelzés végrehajtását egyetlen adatpéldányon. PredictionEngine nincs szálbiztos. Egyszálas vagy prototípusos környezetben is használható. Az éles környezetekben a jobb teljesítmény és a szálbiztonság érdekében használja a PredictionEnginePool szolgáltatást, amely objektumokat hoz létre ObjectPoolPredictionEngine az alkalmazás teljes területén való használatra. Ebből az útmutatóból megtudhatja, hogyan használható PredictionEnginePool egy ASP.NET Core Web API-ban.

   Megjegyzés:

   PredictionEnginePool A szolgáltatásbővítmény jelenleg előzetes verzióban érhető el.

3. Megjegyzés hozzáadása a betanított modell előrejelzésének a metódusban való teszteléséhez a Predict() következő példány MovieReviewlétrehozásával:

   var review = new MovieReview()
   {
       ReviewText = "this film is really good"
   };
   

4. Adja át a teszt megjegyzésadatait a Prediction Engine metódus következő kódsorainak PredictSentiment() hozzáadásával:

   var sentimentPrediction = engine.Predict(review);
   

5. A Predict() függvény egyetlen adatsorra készít előrejelzést:

   Ingatlan	Érték	Típus
   előrejelzés	[0.5459937, 0.454006255]	lebegőpontos[]

6. 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.")}");
   

7. Hívás hozzáadása a PredictSentiment metódus meghívása Fit() után:

   PredictSentiment(mlContext, model);
   

Results

Készítse el és futtassa az alkalmazását.

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 a rendszer eltávolította az alábbi eredményekből az egyértelműség érdekében.

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

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

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

Ez az oktatóanyag bemutatta, hogyan végezheti el az alábbi műveleteket:

• Előre betanított TensorFlow-modell betöltése
• A 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