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

Megtudhatja, hogyan taníthat be egy 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 modell be lett tanítva, hogy a képeket ezer kategóriába sorolja. Mivel a TensorFlow modell tudja, hogyan ismerheti fel a képek mintáit, 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 modellek betanítása érdekében.

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

• 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
• Tesztkép besorolása

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

Előfeltételek

• Visual Studio 2022 vagy újabb
• Az oktatóanyag eszközkönyvtára .ZIP fájl
• Az InceptionV1 gépi tanulási modell

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

mélytanulás

A mély tanulás a Machine Learning egy részhalmaza, amely forradalmasítja az olyan területeket, 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 adatokkal és neurális hálózatokkal tanítjuk be. Mély tanulás:

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

A képbesorolás egy adott besorolási feladat, amely lehetővé teszi a képek automatikus besorolását olyan kategóriákba, mint 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 élelmiszer, játék vagy berendezés-e:

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" By Jonik - Saját készítésű fénykép, CC BY-SA 2.0, https://commons.wikimedia.org/w/index.php?curid=48166.
• "193px-Broodrooster.jpg" By M.Minderhoud - Saját munka, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=27403

A képosztályozási modell alapoktól való betanításához több millió paramétert kell beállítani, 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). Bár nem olyan hatékony, mint egy egyéni modell alapoktól való betanítása, az előre betanított modell használatával megrövidítheti ezt a folyamatot azáltal, hogy több ezer képet használ, szemben a több millió címkézett képpel, és viszonylag gyorsan, akár egy órán belül elkészítheti a testreszabott modellt GPU nélküli gépen. Ez az oktatóanyag még tovább skálázza a folyamatot, mindössze egy tucat betanítási kép használatával.

A Inception model rendszer betanítja, 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. Az egyéni képosztályozó új korlátozott kategóriáihoz használhatja a Inception modelképek felismerésének és besorolásának képességét.

• Élelmiszer
• Játék
• Készülék

Ez az oktatóanyag a TensorFlow Bevezetés mélytanulási modelljét használja, amely egy népszerű képfelismerési modell, amely betanított az ImageNet adathalmazon. 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 rendszert már több ezer különböző képen betanították, belsőleg tartalmazza a képazonosításhoz szükséges képi jellemzőket. Ezeket a belső rendszerkép-funkciókat a modellben felhasználhatjuk egy sokkal kevesebb osztályt tartalmazó új modell betanítására.

Ahogy az alábbi ábrán is látható, a .NET- vagy .NET-keretrendszer-alkalmazásokban lévő ML.NET NuGet-csomagokra mutató hivatkozást ad hozzá. A háttérben az ML.NET tartalmazza és hivatkozik a natív TensorFlow könyvtárra, amely lehetővé teszi egy meglévő betanított TensorFlow modelfájl betöltését lehetővé tevő kód írását.

Többosztályos besorolás

Miután a TensorFlow kezdeti modell használatával kinyerte a klasszikus gépi tanulási algoritmus bemenetének megfelelő funkciókat, hozzáad egy ML.NET többosztályos osztályozót.

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

Az oktató által implementált algoritmus számos funkcióval kapcsolatos problémák esetén jól működik, ami a képadatokon működő mélytanulási modellek esetében fordul elő.

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

Adat

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ő. Az alábbi 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 képek az eszközök mappákban találhatók, amelyeket egy zip-fájlban fog letölteni. Ezek a képek a Wikimédia Commonshoz tartoznak.

Wikimédia Commons, az ingyenes médiatárház. Beolvasva: 2018. október 17. 10:48, forrás: https://commons.wikimedia.org/wiki/Pizzahttps://commons.wikimedia.org/wiki/Toasterhttps://commons.wikimedia.org/wiki/Teddy_bear

Beállí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 8-at 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ő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 csomagforrásként, válassza a Tallózás lapot, és 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 letölt és hozzáad).

3. Töltse le a kezdeti modellt, és bontsa ki.

4. Másolja a nemrég kibontott inception5h könyvtár tartalmát a TransferLearningTF projekt assets/inception könyvtárába. 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ó:

   

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

Osztályok létrehozása és útvonalak definiálása

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;
   

2. Adja hozzá az alábbi kódot az irányelvek alatti using sorhoz az eszközútvonalak megadásához:

   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őket tartalmazza:

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

4. Új osztály hozzáadása 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őket tartalmazza:

   • 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. Van egy string (ImagePath), amely a kép elérési útját jelöli. Ez Label a modell újrafelhasználására és betanítása céljából használható. Ez PredictedLabelValue az előrejelzés és az é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áljuk.

Változók inicializálása

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

   MLContext mlContext = new MLContext();
   

   Az MLContext osztály minden ML.NET művelet kiindulópontja, és az inicializálás mlContext ú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 .

A kezdeti modell paramétereinek strukturálása

1. Az inception modell több paraméterrel rendelkezik, amelyet át kell adnia. Hozzon létre egy szerkezetet a paraméterértékek felhasználóbarát nevekre való leképezéséhez a következő kóddal, 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 többször is megjeleníti a képadatokat és a kapcsolódó előrejelzéseket, hozzon létre egy megjelenítési segédprogramot a kép és az előrejelzési eredmények megjelenítésének kezelésére.

1. Hozza létre a metódust DisplayResults() a InceptionSettings szerkezet 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() a metódus előtt DisplayResults() , a következő kóddal:

   void ClassifySingleImage(MLContext mlContext, ITransformer model)
   {
   
   }
   

2. Hozzon létre egy ImageData objektumot, amely tartalmazza az egyetlen teljes elérési útját és képfájlnevét ImagePath. 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 a következő kódot adja hozzá 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 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.

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

Az ML.NET modellfolyamat egy becslőkből álló lánc. 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 középpontjában áll. Létrehoz egy folyamatot a modellhez, és betanítja a folyamatot a ML.NET modell előállításához. Emellett kiértékeli a modellt néhány korábban nem látott tesztadat alapján.

   Hozza létre a metódust GenerateModel() a InceptionSettings struktúra után és a metódus előtt DisplayResults() , 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 adja hozzá a pontszámot:

   .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 használva.

4. Adja hozzá a becslőt a betanítási adatok karakterlánc feliratainak integer kulcsértékekre 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 oktató címkéinek nem tetszőleges sztringek, hanem formátumuknak key kell lenniük. A kulcs olyan szám, amely egy-egy megfeleltetésben van egy karakterlánc értékkel.

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, hogy az előrejelzett kulcs értékét karakterláncra képezze le.

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

A modell betanítása

1. Töltse be a tanulá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 jelenik meg. IDataView a táblázatos adatok (numerikus és szöveges) leírásának rugalmas, hatékony módja. Az adatok betölthetők szövegfá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 GenerateModel() modell kiértékeléséhez:

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

   Ha már rendelkezik 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;
   

Az alkalmazás futtatása

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 metódushoz a ClassifySingleImage() metódus hívása GenerateModel() után:

   ClassifySingleImage(mlContext, model);
   

3. A konzolalkalmazás futtatása (Ctrl + F5). Az eredményeknek az alábbi kimenethez hasonlónak kell lenniük. (Megjelenhetnek figyelmeztetések vagy üzenetek feldolgozása, de ezek az üzenetek el lettek távolítva 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álok! Sikeresen létrehozott egy osztályozási modellt az ML.NET segítségével a képfelismeréshez, egy előzetesen betanított TensorFlow modul használatá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:

• 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
• Tesztkép besorolása

A bővített képosztályozási minta megismeréséhez tekintse meg a Machine Learning-mintákat a GitHub-adattárban.

dotnet/machinelearning-samples GitHub-adattár