Oktatóanyag: ML.NET besorolási modell betanítása képek kategorizálásához

Megtudhatja, hogyan taníthat be besorolási modellt a képek kategorizálásához egy előre betanított TensorFlow-modell használatával a képfeldolgozáshoz.

A TensorFlow-modellt betanítottuk, hogy a képeket ezer kategóriába sorolja. Mivel a TensorFlow-modell tudja, hogyan ismerhet fel mintákat a képeken, a ML.NET modell a folyamat egy részét felhasználhatja a nyers képek funkciókká vagy bemenetekké alakításához a besorolási modell betanítása érdekében.

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

• A probléma ismertetése
• Az előre betanított TensorFlow-modell beépítése a ML.NET folyamatba
• A ML.NET modell betanítása és kiértékelése
• Tesztrendszerkép besorolása

Az oktatóanyag forráskódját a dotnet/samples adattárban találja. Alapértelmezés szerint az oktatóanyag .NET-projektkonfigurációja a .NET Core 2.2-t célozza meg.

Előfeltételek

• Visual Studio 2022
• Az oktatóanyag eszközkönyvtárának .ZIP fájlja
• Az InceptionV1 gépi tanulási modell

Válassza ki a megfelelő gépi tanulási feladatot

Deep learning

A mély tanulás a Gépi tanulás egy részhalmaza, amely olyan területeket forradalmasít, mint a számítógépes látás és a beszédfelismerés.

A mélytanulási modelleket nagy méretű, több tanulási réteget tartalmazó , címkézett adatokból és neurális hálózatokból álló készletekkel tanítjuk be. Mély tanulás:

• Bizonyos feladatokon, például a számítógépes látáson jobban teljesít.
• Nagy mennyiségű betanítási adatot igényel.

A képbesorolás egy adott besorolási feladat, amely lehetővé teszi, hogy automatikusan kategóriákba soroljuk a képeket, például:

• Emberi arc észlelése egy képen, vagy sem.
• Macskák és kutyák észlelése.

Vagy ahogy az alábbi képeken is látható, annak meghatározása, hogy egy kép egy élelmiszer, egy szó vagy egy berendezés:

Megjegyzés

Az előző képek a Wikimédia Commonshoz tartoznak, és a következőképpen vannak beállítva:

• "220px-Pepperoni_pizza.jpg" nyilvános tartomány, , https://commons.wikimedia.org/w/index.php?curid=79505
• "119px-Nalle_-_a_small_brown_teddy_bear.jpg" Jonik - Önfényképezett, CC BY-SA 2.0, https://commons.wikimedia.org/w/index.php?curid=48166.
• "193px-Broodrooster.jpg" Készítette : M.Minderhoud - Saját munka, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=27403

A képbesorolási modell alapoktól való betanításához több millió paramétert, egy rengeteg címkézett betanítási adatot és nagy mennyiségű számítási erőforrást (több száz GPU-órát) kell beállítani. Bár nem olyan hatékony, mint az egyéni modellek alapoktól való betanítása, az előre betanított modell használatával ezt a folyamatot több ezer képpel vagy több millió címkézett képpel dolgozhat, és viszonylag gyorsan hozhat létre testre szabott modellt (gpu nélküli gépen egy órán belül). Ez az oktatóanyag még tovább skálázza a folyamatokat, mindössze egy tucat betanítási kép használatával.

A Inception model be van tanítva, hogy a képeket ezer kategóriába sorolja, de ehhez az oktatóanyaghoz a képeket egy kisebb kategóriakészletbe kell besorolnia, és csak azokat a kategóriákat. Használhatja a Inception model"képes felismerni és besorolni a képeket az egyéni képosztályozó új korlátozott kategóriáiba.

• Élelmiszer
• Játék
• Berendezés

Ez az oktatóanyag a TensorFlow bevezetési mélytanulási modelljét használja, amely egy népszerű képfelismerő modell, amely betanított az ImageNet adathalmazra. A TensorFlow modell a teljes képeket ezer osztályba sorolja, például az "Esernyő", a "Jersey" és a "Mosogatógép" osztályba.

Mivel a Inception model rendszer már több ezer különböző képpel rendelkezik előre betanításra, belsőleg tartalmazza a képazonosításhoz szükséges képfunkciókat . Ezeket a belső rendszerkép-funkciókat a modellben felhasználhatjuk egy sokkal kevesebb osztályt tartalmazó új modell betanítása érdekében.

Az alábbi ábrán látható módon a .NET Core-ban vagy .NET-keretrendszer-alkalmazásokban lévő ML.NET NuGet-csomagokra mutató hivatkozást ad hozzá. A borítók alatt ML.NET tartalmazza és hivatkozik a natív TensorFlow kódtárra, amely lehetővé teszi egy meglévő betanított modellfájl betöltését lehetővé tevő kód írását TensorFlow .

Többosztályos besorolás

Miután a TensorFlow kezdeti modellel kinyert egy klasszikus gépi tanulási algoritmus bemeneteként alkalmas funkciókat, hozzáadunk egy ML.NET többosztályos osztályozót.

Az ebben az esetben használt konkrét tréner a többnomiális logisztikai regressziós algoritmus.

A tréner által implementált algoritmus jól teljesít számos funkcióval kapcsolatos problémák esetén, ami a képadatokon működő mélytanulási modell esetében fordul elő.

További információ: Mély tanulás és gépi tanulás .

Adatok

Két adatforrás létezik: a .tsv fájl és a képfájlok. A tags.tsv fájl két oszlopot tartalmaz: az első a következőképpen van definiálva ImagePath , a második pedig a Label képnek megfelelő. A következő példafájl nem tartalmaz fejlécsort, és így néz ki:

broccoli.jpg	food
pizza.jpg	food
pizza2.jpg	food
teddy2.jpg	toy
teddy3.jpg	toy
teddy4.jpg	toy
toaster.jpg	appliance
toaster2.png	appliance

A betanítási és tesztelési rendszerképek a zip-fájlban letöltött eszközmappákban találhatók. Ezek a képek a Wikimédia Commonshoz tartoznak.

Wikimédia Commons, az ingyenes médiaadattár. 2018. október 17. 10:48-kor lekért forrás: https://commons.wikimedia.org/wiki/Pizzahttps://commons.wikimedia.org/wiki/Toasterhttps://commons.wikimedia.org/wiki/Teddy_bear

Telepítés

Projekt létrehozása

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

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

3. 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, válassza a Tallózás lapot, keresse meg a Microsoft.ML.
   • Válassza a Telepítés gombot.
   • Válassza az OK gombot a Változások előnézete párbeszédpanelen.
   • Ha elfogadja a felsorolt csomagok licencfeltételét, válassza az Elfogadom gombot a Licenc elfogadása párbeszédpanelen.
   • Ismételje meg ezeket a lépéseket a Microsoft.ML.ImageAnalytics, a SciSharp.TensorFlow.Redist és a Microsoft.ML.TensorFlow esetében.

Eszközök letöltése

1. Töltse le a project assets könyvtár zip-fájlt, és bontsa ki.

2. Másolja a könyvtárat a assetsTransferLearningTF projektkönyvtárba. Ez a könyvtár és alkönyvtárai tartalmazzák az oktatóanyaghoz szükséges adatokat és támogatási fájlokat (kivéve az Inception modellt, amelyet a következő lépésben fog letölteni és hozzáadni).

3. Töltse le az Inception modellt, és bontsa ki.

4. Másolja ki a könyvtár tartalmát a inception5hTransferLearningTF projektkönyvtárba assets/inception . 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:

   

5. A Megoldáskezelő kattintson a jobb gombbal az eszközkönyvtárban és az alkönyvtárakban lévő fájlokra, majd válassza a Tulajdonsá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ásra, ha újabb.

Osztályok létrehozása és elérési utak definiálása

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

2. Adja hozzá a következő kódot az eszköz elérési útjainak megadásához közvetlenül az utasítások alatt lévő sorhoz:

   string _assetsPath = Path.Combine(Environment.CurrentDirectory, "assets");
   string _imagesFolder = Path.Combine(_assetsPath, "images");
   string _trainTagsTsv = Path.Combine(_imagesFolder, "tags.tsv");
   string _testTagsTsv = Path.Combine(_imagesFolder, "test-tags.tsv");
   string _predictSingleImage = Path.Combine(_imagesFolder, "toaster3.jpg");
   string _inceptionTensorFlowModel = Path.Combine(_assetsPath, "inception", "tensorflow_inception_graph.pb");
   

3. Hozzon létre osztályokat a bemeneti adatokhoz és az előrejelzésekhez.

   public class ImageData
   {
       [LoadColumn(0)]
       public string? ImagePath;
   
       [LoadColumn(1)]
       public string? Label;
   }
   

   ImageData a bemeneti kép adatosztálya, és a következő String mezőkkel rendelkezik:

   • ImagePath tartalmazza a képfájl nevét.
   • Label a képcímke értékét tartalmazza.

4. Adjon hozzá egy új osztályt a projekthez a következőhöz ImagePrediction:

   public class ImagePrediction : ImageData
   {
       public float[]? Score;
   
       public string? PredictedLabelValue;
   }
   

   ImagePrediction a kép előrejelzési osztálya, és a következő mezőkkel rendelkezik:

   • Score egy adott képbesorolás megbízhatósági százalékát tartalmazza.
   • PredictedLabelValue az előrejelzett képbesorolási címke értékét tartalmazza.

   ImagePrediction a modell betanítása után az előrejelzéshez használt osztály. A string kép elérési útjának (ImagePath) van. A Label modell újrafelhasználására és betanítása. Ez PredictedLabelValue az előrejelzés és a kiértékelés során használatos. A kiértékeléshez a betanítási adatokat, az előrejelzett értékeket és a modellt tartalmazó bemenetet használja a rendszer.

Változók inicializálása

1. Inicializálja a mlContext változót a következő új példányával MLContext: . Cserélje le a Console.WriteLine("Hello World!") sort a következő kódra:

   MLContext mlContext = new MLContext();
   

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

Az inception modell paramétereihez tartozó utasítás létrehozása

1. Az Inception modellnek számos paramétert kell megadnia. Hozzon létre egy szerkezetet a paraméterértékek rövid nevekre való leképezéséhez a következő kóddal, közvetlenül a változó inicializálása mlContext után:

   struct InceptionSettings
   {
       public const int ImageHeight = 224;
       public const int ImageWidth = 224;
       public const float Mean = 117;
       public const float Scale = 1;
       public const bool ChannelsLast = true;
   }
   

Megjelenítési segédprogram létrehozása

Mivel a képadatokat és a kapcsolódó előrejelzéseket többször is megjeleníti, hozzon létre egy megjelenítési segédprogramot a kép és az előrejelzés eredményeinek megjelenítéséhez.

1. Hozza létre a metódust DisplayResults() közvetlenül a InceptionSettings struktúra után a következő kóddal:

   void DisplayResults(IEnumerable<ImagePrediction> imagePredictionData)
   {
   
   }
   

2. Töltse ki a metódus törzsét DisplayResults :

   foreach (ImagePrediction prediction in imagePredictionData)
   {
       Console.WriteLine($"Image: {Path.GetFileName(prediction.ImagePath)} predicted as: {prediction.PredictedLabelValue} with score: {prediction.Score?.Max()} ");
   }
   

Metódus létrehozása előrejelzés készítéséhez

1. Hozza létre a metódust ClassifySingleImage() közvetlenül a DisplayResults() metódus előtt a következő kóddal:

   void ClassifySingleImage(MLContext mlContext, ITransformer model)
   {
   
   }
   

2. Hozzon létre egy ImageData objektumot, amely tartalmazza az egyetlen ImagePathteljes elérési utat és képfájlnevet. Adja hozzá a következő kódot a metódus következő soraiként ClassifySingleImage() :

   var imageData = new ImageData()
   {
       ImagePath = _predictSingleImage
   };
   

3. Egyetlen előrejelzést készíthet úgy, hogy hozzáadja a következő kódot a metódus következő soraként ClassifySingleImage :

   // Make prediction function (input = ImageData, output = ImagePrediction)
   var predictor = mlContext.Model.CreatePredictionEngine<ImageData, ImagePrediction>(model);
   var prediction = predictor.Predict(imageData);
   

   Az előrejelzés lekéréséhez használja a Predict() metódust. 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 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 ASP.NET Core webes API-ban.

   Megjegyzés

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

4. Az előrejelzési eredmény megjelenítése a metódus következő kódsoraként ClassifySingleImage() :

   Console.WriteLine($"Image: {Path.GetFileName(imageData.ImagePath)} predicted as: {prediction.PredictedLabelValue} with score: {prediction.Score?.Max()} ");
   

A ML.NET modellfolyamat létrehozása

A ML.NET modellfolyamat a becslők lánca. A folyamatépítés során nem történik végrehajtás. A becslő objektumokat a rendszer létrehozza, de nem hajtja végre.

1. Metódus hozzáadása a modell létrehozásához

   Ez a módszer az oktatóanyag lényege. Létrehoz egy folyamatot a modellhez, és betanítja a folyamatot a ML.NET modell előállítására. Emellett kiértékeli a modellt néhány korábban nem látott tesztadattal.

   Hozza létre a metódust közvetlenül a GenerateModel()InceptionSettings struktúra után és közvetlenül a DisplayResults() metódus előtt a következő kóddal:

   ITransformer GenerateModel(MLContext mlContext)
   {
   
   }
   

2. Adja hozzá a becslőket a képpontok betöltéséhez, átméretezéséhez és kinyeréséhez a képadatokból:

   IEstimator<ITransformer> pipeline = mlContext.Transforms.LoadImages(outputColumnName: "input", imageFolder: _imagesFolder, inputColumnName: nameof(ImageData.ImagePath))
                   // The image transforms transform the images into the model's expected format.
                   .Append(mlContext.Transforms.ResizeImages(outputColumnName: "input", imageWidth: InceptionSettings.ImageWidth, imageHeight: InceptionSettings.ImageHeight, inputColumnName: "input"))
                   .Append(mlContext.Transforms.ExtractPixels(outputColumnName: "input", interleavePixelColors: InceptionSettings.ChannelsLast, offsetImage: InceptionSettings.Mean))
   

   A képadatokat a TensorFlow-modell által várt formátumban kell feldolgozni. Ebben az esetben a rendszer betölti a képeket a memóriába, átméretezi egy konzisztens méretre, és a képpontokat numerikus vektorba nyeri ki.

3. Adja hozzá a becslőt a TensorFlow-modell betöltéséhez, és értékelje azt:

   .Append(mlContext.Model.LoadTensorFlowModel(_inceptionTensorFlowModel).
       ScoreTensorFlowModel(outputColumnNames: new[] { "softmax2_pre_activation" }, inputColumnNames: new[] { "input" }, addBatchDimensionInput: true))
   

   A folyamat ezen szakasza betölti a TensorFlow modellt a memóriába, majd feldolgozza a képpontértékek vektorát a TensorFlow modellhálózatán keresztül. A bemenetek mélytanulási modellre való alkalmazása és a modell használatával történő kimenet létrehozása pontozásnak nevezik. Ha a modellt teljes egészében használja, a pontozás következtetést vagy előrejelzést ad.

   Ebben az esetben az összes TensorFlow modellt használja az utolsó réteg kivételével, amely a következtetést okozó réteg. Az utolsó előtti réteg kimenete címkével van ellátva softmax_2_preactivation. Ennek a rétegnek a kimenete gyakorlatilag az eredeti bemeneti képeket jellemző jellemzők vektora.

   A TensorFlow-modell által létrehozott funkcióvektor egy ML.NET betanítási algoritmus bemeneteként lesz felhasználva.

4. Adja hozzá a becslőt a betanítási adatok sztringfeliratainak egész szám kulcsértékekkel való leképezéséhez:

   .Append(mlContext.Transforms.Conversion.MapValueToKey(outputColumnName: "LabelKey", inputColumnName: "Label"))
   

   A következőként hozzáfűzött ML.NET tréner címkéinek nem tetszőleges sztringeket, hanem formátumot kell key megadniuk. A kulcs olyan szám, amely egy-egyhez megfeleltet egy sztringértékhez.

5. Adja hozzá a ML.NET betanítási algoritmust:

   .Append(mlContext.MulticlassClassification.Trainers.LbfgsMaximumEntropy(labelColumnName: "LabelKey", featureColumnName: "softmax2_pre_activation"))
   

6. Adja hozzá a becslőt az előrejelzett kulcs értékének sztringbe való leképezéséhez:

   .Append(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabelValue", "PredictedLabel"))
   .AppendCacheCheckpoint(mlContext);
   

A modell betanítása

1. Töltse be a betanítási adatokat a LoadFromTextFile burkolóval. Adja hozzá a következő kódot a metódus következő soraként GenerateModel() :

   IDataView trainingData = mlContext.Data.LoadFromTextFile<ImageData>(path:  _trainTagsTsv, hasHeader: false);
   

   A ML.NET adatai IDataView-felületként jelennek meg. IDataView rugalmas, hatékony módja a táblázatos adatok (numerikus és szöveges) leírásának. Az adatok betölthetők szöveges fájlból vagy valós időben (például SQL-adatbázisból vagy naplófájlokból) egy IDataView objektumba.

2. A modell betanítása a fent betöltött adatokkal:

   ITransformer model = pipeline.Fit(trainingData);
   

   A Fit() metódus a betanítási adathalmaz folyamatra való alkalmazásával tanítja be a modellt.

A modell pontosságának kiértékelése

1. Töltse be és alakítsa át a tesztadatokat úgy, hogy hozzáadja a következő kódot a GenerateModel metódus következő sorához:

   IDataView testData = mlContext.Data.LoadFromTextFile<ImageData>(path: _testTagsTsv, hasHeader: false);
   IDataView predictions = model.Transform(testData);
   
   // Create an IEnumerable for the predictions for displaying results
   IEnumerable<ImagePrediction> imagePredictionData = mlContext.Data.CreateEnumerable<ImagePrediction>(predictions, true);
   DisplayResults(imagePredictionData);
   

   Van néhány mintakép, amellyel kiértékelheti a modellt. A betanítási adatokhoz hasonlóan ezeket is be kell tölteni egybe IDataView, hogy a modell átalakíthassa őket.

2. Adja hozzá a következő kódot a metódushoz a GenerateModel() modell kiértékeléséhez:

   MulticlassClassificationMetrics metrics =
       mlContext.MulticlassClassification.Evaluate(predictions,
           labelColumnName: "LabelKey",
           predictedLabelColumnName: "PredictedLabel");
   

   Miután elkészült az előrejelzési készlettel, a Evaluate() metódus:

   • Kiértékeli a modellt (összehasonlítja az előrejelzett értékeket a tesztadatkészlettel labels).
   • A modell teljesítménymetrikáit adja vissza.

3. A modell pontossági metrikáinak megjelenítése

   A metrikák megjelenítéséhez, az eredmények megosztásához és azok végrehajtásához használja az alábbi kódot:

   Console.WriteLine($"LogLoss is: {metrics.LogLoss}");
   Console.WriteLine($"PerClassLogLoss is: {String.Join(" , ", metrics.PerClassLogLoss.Select(c => c.ToString()))}");
   

   A rendszer a következő metrikákat értékeli ki a képbesoroláshoz:

   • Log-loss - lásd: Naplóvesztés. Azt szeretné, hogy a naplóvesztés a lehető legközelebb legyen a nullához.
   • Per class Log-loss. Azt szeretné, hogy osztályonként a naplóveszteség a lehető legközelebb legyen a nullához.

4. Adja hozzá a következő kódot a betanított modell következő sorként való visszaadásához:

   return model;
   

Futtassa az alkalmazást!

1. Adja hozzá a hívást GenerateModel az osztály létrehozása MLContext után:

   ITransformer model = GenerateModel(mlContext);
   

2. Adja hozzá a hívást a ClassifySingleImage() metódushoz a hívás után:GenerateModel()

   ClassifySingleImage(mlContext, model);
   

3. Futtassa a konzolalkalmazást (Ctrl + F5). Az eredményeknek az alábbi kimenethez hasonlónak kell lenniük. (Megjelenhetnek figyelmeztetések vagy üzenetek feldolgozása, de ezeket az üzeneteket eltávolítottuk az alábbi eredményekből az egyértelműség érdekében.)

   =============== Training classification model ===============
   Image: broccoli2.jpg predicted as: food with score: 0.8955513
   Image: pizza3.jpg predicted as: food with score: 0.9667718
   Image: teddy6.jpg predicted as: toy with score: 0.9797683
   =============== Classification metrics ===============
   LogLoss is: 0.0653774699265059
   PerClassLogLoss is: 0.110315812569315 , 0.0204391272836966 , 0
   =============== Making single image classification ===============
   Image: toaster3.jpg predicted as: appliance with score: 0.9646884
   

Gratulálunk! Sikeresen létrehozott egy besorolási modellt a ML.NET a képek kategorizálásához egy előre betanított TensorFlow használatával a képfeldolgozáshoz.

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:

• A probléma ismertetése
• Az előre betanított TensorFlow-modell beépítése a ML.NET folyamatba
• A ML.NET modell betanítása és kiértékelése
• Tesztrendszerkép besorolása

A kibővített képbesorolási minta megismeréséhez tekintse meg a Machine Learning-minták GitHub-adattárát.

dotnet/machinelearning-samples GitHub-adattár