Kurz: automatizované vizuální prověřování pomocí přenosu přenosu s rozhraním API pro klasifikaci imagí ML.NETTutorial: Automated visual inspection using transfer learning with the ML.NET Image Classification API

Naučte se naučit vlastní model hloubkového učení s využitím učení přenosu, předTensorFlowho modelu a rozhraní API pro klasifikaci imagí ml.NET pro klasifikaci imagí konkrétních povrchů jako prasklé nebo prolomené.Learn how to train a custom deep learning model using transfer learning, a pretrained TensorFlow model and the ML.NET Image Classification API to classify images of concrete surfaces as cracked or uncracked.

V tomto kurzu se naučíte:In this tutorial, you learn how to:

  • Pochopení problémuUnderstand the problem
  • Další informace o rozhraní API pro klasifikaci imagí ML.NETLearn about ML.NET Image Classification API
  • Pochopení předvýukového modeluUnderstand the pretrained model
  • Použití učení transferu k výuce vlastního modelu klasifikace imagí TensorFlowUse transfer learning to train a custom TensorFlow image classification model
  • Klasifikace imagí pomocí vlastního modeluClassify images with the custom model

PožadavkyPrerequisites

Přehled výukového kurzu přenosu klasifikace obrázkůImage classification transfer learning sample overview

Tato ukázka je Konzolová aplikace C# .NET Core, která klasifikuje Image pomocí předvýukového modelu TensorFlow hloubkového učení.This sample is a C# .NET Core console application that classifies images using a pretrained deep learning TensorFlow model. Kód pro tuto ukázku najdete v úložišti dotnet/machinelearning-Samples na GitHubu.The code for this sample can be found on the dotnet/machinelearning-samples repository on GitHub.

Pochopení problémuUnderstand the problem

Klasifikace obrázku je problém počítačové vize.Image classification is a computer vision problem. Klasifikace obrázku bere jako vstup obrázek a zařadí ho do předepsané třídy.Image classification takes an image as input and categorizes it into a prescribed class. Některé scénáře, kde je klasifikace obrázku užitečná, zahrnují:Some scenarios where image classification is useful include:

  • Rozpoznávání obličejeFacial recognition
  • Detekce emoceEmotion detection
  • Lékařské diagnostikyMedical diagnosis
  • Detekce orientačních bodůLandmark detection

V tomto kurzu se nasazuje model klasifikace vlastních imagí, který provede automatizovanou vizuální kontrolu balíčku mostu a identifikuje tak struktury, které jsou poškozené prasklinami.This tutorial trains a custom image classification model to perform automated visual inspection of bridge decks to identify structures that are damaged by cracks.

Rozhraní API pro klasifikaci imagí ML.NETML.NET Image Classification API

ML.NET poskytuje různé způsoby provádění klasifikace imagí.ML.NET provides various ways of performing image classification. Tento kurz se týká učení přenosu pomocí rozhraní API klasifikace imagí.This tutorial applies transfer learning using the Image Classification API. Rozhraní API pro klasifikaci imagí využívá TensorFlow.NETknihovnu nižší úrovně, která poskytuje C# vazby pro rozhraní TensorFlow C++ API.The Image Classification API makes use of TensorFlow.NET, a low-level library that provides C# bindings for the TensorFlow C++ API.

Co je učení přenosu?What is transfer learning?

Učení pro přenos používá znalostní bázi získaná od řešení jednoho problému s jiným souvisejícím problémem.Transfer learning applies knowledge gained from solving one problem to another related problem.

Školení modelu hloubkového učení od začátku vyžaduje nastavení několika parametrů, velkého množství podrobných školicích dat a obrovského množství výpočetních prostředků (stovky hodin GPU).Training a deep learning model from scratch requires setting several parameters, a large amount of labeled training data, and a vast amount of compute resources (hundreds of GPU hours). Použití předzpracovaného modelu spolu s učením přenosu vám umožní zástupce školicího procesu.Using a pretrained model along with transfer learning allows you to shortcut the training process.

Školicí procesTraining process

Rozhraní API klasifikace imagí spustí školicí proces načtením předinstalovaného modelu TensorFlow.The Image Classification API starts the training process by loading a pretrained TensorFlow model. Školicí proces se skládá ze dvou kroků:The training process consists of two steps:

  1. Fáze kritického boduBottleneck phase
  2. Fáze školeníTraining phase

Postup školení

Fáze kritického boduBottleneck phase

Během fáze kritických míst se načte sada školicích imagí a jako vstup a funkce se použijí pixelové hodnoty pro zmrazené vrstvy předinstalovaného modelu.During the bottleneck phase, the set of training images is loaded and the pixel values are used as input, or features, for the frozen layers of the pretrained model. Zmrazené vrstvy zahrnují všechny vrstvy v neuronové síti až do poslední vrstvy, která je Poznáma jako kritická vrstva.The frozen layers include all of the layers in the neural network up to the penultimate layer, informally known as the bottleneck layer. Tyto vrstvy se označují jako zmrazené, protože na těchto vrstvách a operacích neproběhne žádné školení.These layers are referred to as frozen because no training will occur on these layers and operations are pass-through. Je v těchto zmrazených vrstvách, kde jsou vypočítány vzory nižší úrovně, které usnadňují model odlišení různých tříd.It's at these frozen layers where the lower-level patterns that help a model differentiate between the different classes are computed. Čím větší je počet vrstev, tím více výpočetně náročné je tento krok.The larger the number of layers, the more computationally intensive this step is. Naštěstí, protože se jedná o jednorázový výpočet, mohou být výsledky uloženy do mezipaměti a použity v pozdějších spuštěních při experimentování s různými parametry.Fortunately, since this is a one-time calculation, the results can be cached and used in later runs when experimenting with different parameters.

Fáze školeníTraining phase

Až budou výstupní hodnoty z kritické fáze vypočítány, používají se jako vstup k přeškolování finální vrstvy modelu.Once the output values from the bottleneck phase are computed, they are used as input to retrain the final layer of the model. Tento proces je iterativní a spouští se v počtu pokusů určených parametry modelu.This process is iterative and runs for the number of times specified by model parameters. Během každého spuštění jsou vyhodnocovány ztráty a přesnost.During each run, the loss and accuracy are evaluated. Pak jsou provedeny příslušné úpravy pro zlepšení modelu s cílem minimalizovat ztrátu a maximalizovat přesnost.Then, the appropriate adjustments are made to improve the model with the goal of minimizing the loss and maximizing the accuracy. Po dokončení školení jsou výstupem dva formáty modelů.Once training is finished, two model formats are output. Jednou z nich je .pb verze modelu a druhá je serializovaná verze modelu .zip ML.NET.One of them is the .pb version of the model and the other is the .zip ML.NET serialized version of the model. Při práci v prostředích podporovaných aplikací ML.NET se doporučuje použít verzi modelu .zip.When working in environments supported by ML.NET, it is recommended to use the .zip version of the model. V prostředích, kde ML.NET není podporovaný, máte ale možnost použít verzi .pb.However, in environments where ML.NET is not supported, you have the option of using the .pb version.

Pochopení předvýukového modeluUnderstand the pretrained model

Předem vydaný model použitý v tomto kurzu je 101 varianta modelu zbytkové sítě (ResNet) v2.The pretrained model used in this tutorial is the 101-layer variant of the Residual Network (ResNet) v2 model. Původní model je vyškolen pro klasifikaci imagí do tisíc kategorií.The original model is trained to classify images into a thousand categories. Model bere jako vstup obrázek o velikosti 224 × 224 a vypisuje pravděpodobnosti třídy pro každou třídu, na které je technologie IT vyškolená.The model takes as input an image of size 224 x 224 and outputs the class probabilities for each of the classes it's trained on. Součástí tohoto modelu je vyučování nového modelu pomocí vlastních imagí, aby bylo možné předpovědi mezi dvěma třídami.Part of this model is used to train a new model using custom images to make predictions between two classes.

Vytvoření konzolové aplikaceCreate console application

Teď, když máte obecné znalosti o učení přenosů a rozhraní API klasifikace imagí, je čas sestavování aplikace.Now that you have a general understanding of transfer learning and the Image Classification API, it's time to build the application.

  1. Vytvořte C# konzolovou aplikaci .NET Core nazvanou "DeepLearning_ImageClassification_Binary".Create a C# .NET Core Console Application called "DeepLearning_ImageClassification_Binary".
  2. Nainstalujte balíček NuGet verze Microsoft.ml 1.4.0 :Install the Microsoft.ML version 1.4.0 NuGet Package:
    1. V Průzkumník řešení klikněte pravým tlačítkem na projekt a vyberte Spravovat balíčky NuGet.In Solution Explorer, right-click on your project and select Manage NuGet Packages.
    2. Jako zdroj balíčku vyberte "nuget.org".Choose "nuget.org" as the Package source.
    3. Vyberte kartu Procházet.Select the Browse tab.
    4. Zaškrtněte políčko zahrnout předběžné verze .Check the Include prerelease checkbox.
    5. Vyhledejte Microsoft.ml.Search for Microsoft.ML.
    6. Vyberte tlačítko instalovat .Select the Install button.
    7. Pokud souhlasíte s licenčními podmínkami pro uvedené balíčky, klikněte na tlačítko OK v dialogovém okně Náhled změn a potom v dialogovém okně pro přijetí licence vyberte tlačítko přijmout .Select the OK button on the Preview Changes dialog and then select the I Accept button on the License Acceptance dialog if you agree with the license terms for the packages listed.
    8. Opakujte tyto kroky pro balíček Microsoft. ml. Vision verze 1.4.0, SciSharp. TensorFlow. Redist verze 1.15.0a Microsoft. ml. ImageAnalytics verze 1.4.0 NuGet Packages.Repeat these steps for the Microsoft.ML.Vision version 1.4.0, SciSharp.TensorFlow.Redist version 1.15.0, and Microsoft.ML.ImageAnalytics version 1.4.0 NuGet packages.

Příprava a pochopení datPrepare and understand the data

Poznámka

Datové sady pro tento kurz jsou z Maguire, matolin; Dorafshan, Sattar; a Tomáš, Robert J., "SDNET2018: konkrétní datová sada obrázku trhlin pro aplikace pro strojové učení" (2018).The datasets for this tutorial are from Maguire, Marc; Dorafshan, Sattar; and Thomas, Robert J., "SDNET2018: A concrete crack image dataset for machine learning applications" (2018). Procházet všechny datové sady.Browse all Datasets. Papír 48.Paper 48. https://digitalcommons.usu.edu/all_datasets/48https://digitalcommons.usu.edu/all_datasets/48

SDNET2018 je datová sada obrázků, která obsahuje poznámky pro neprasklé a neprasklé konkrétní struktury (balíčky mostů, stěny a Pavement).SDNET2018 is an image dataset that contains annotations for cracked and non-cracked concrete structures (bridge decks, walls, and pavement).

Ukázky balíčku pro přemostění datových sad SDNET2018

Data jsou uspořádaná ve třech podadresářích:The data is organized in three subdirectories:

  • D obsahuje obrázky na balíčku mostu.D contains bridge deck images
  • P obsahuje image PavementP contains pavement images
  • W obsahuje obrázky na zdiW contains wall images

Každý z těchto podadresářů obsahuje dva další předem opravené podadresáře:Each of these subdirectories contains two additional prefixed subdirectories:

  • C je předpona používaná pro prasklé povrchyC is the prefix used for cracked surfaces
  • U je předpona používaná pro prolomené povrchy.U is the prefix used for uncracked surfaces

V tomto kurzu se používají jenom balíčky balíčku mostu.In this tutorial, only bridge deck images are used.

  1. Stáhněte si datovou sadu a rozbalte ji.Download the dataset and unzip.
  2. Vytvořte ve svém projektu adresář s názvem "assety" a uložte soubory DataSet.Create a directory named "assets" in your project to save your dataset files.
  3. Zkopírujte podadresáře CD a ud z naposledy nekomprimovaného adresáře do adresáře assety .Copy the CD and UD subdirectories from the recently unzipped directory to the assets directory.

Vytvoření vstupní a výstupní třídyCreate input and output classes

  1. Otevřete soubor program.cs a nahraďte existující příkazy using v horní části souboru následujícím způsobem:Open the Program.cs file and replace the existing using statements at the top of the file with the following:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.IO;
    using Microsoft.ML;
    using static Microsoft.ML.DataOperationsCatalog;
    using Microsoft.ML.Vision;
    
  2. Pod třídou Program v program.csvytvořte třídu s názvem ImageData.Below the Program class in Program.cs, create a class called ImageData. Tato třída slouží k reprezentaci počátečních načtených dat.This class is used to represent the initially loaded data.

    class ImageData
    {
        public string ImagePath { get; set; }
    
        public string Label { get; set; }
    }
    

    ImageData obsahuje následující vlastnosti:ImageData contains the following properties:

    • ImagePath je plně kvalifikovaná cesta, kde je obrázek uložený.ImagePath is the fully qualified path where the image is stored.
    • Label je kategorie, do které patří obrázek.Label is the category the image belongs to. Toto je hodnota, která se má předpovědět.This is the value to predict.
  3. Vytváření tříd pro vstupní a výstupní dataCreate classes for your input and output data

    1. Pod ImageData třídou definujte schéma vstupních dat v nové třídě s názvem ModelInput.Below the ImageData class, define the schema of your input data in a new class called ModelInput.

      class ModelInput
      {
          public byte[] Image { get; set; }
          
          public UInt32 LabelAsKey { get; set; }
      
          public string ImagePath { get; set; }
      
          public string Label { get; set; }
      }
      

      ModelInput obsahuje následující vlastnosti:ModelInput contains the following properties:

      • ImagePath je plně kvalifikovaná cesta, kde je obrázek uložený.ImagePath is the fully qualified path where the image is stored.
      • Label je kategorie, do které patří obrázek.Label is the category the image belongs to. Toto je hodnota, která se má předpovědět.This is the value to predict.
      • Image je byte[] reprezentace obrázku.Image is the byte[] representation of the image. Model očekává, že budou data obrázku tohoto typu pro účely školení.The model expects image data to be of this type for training.
      • LabelAsKey je numerická reprezentace Label.LabelAsKey is the numerical representation of the Label.

      Pro výuku modelu a předpovědi se používají jenom Image a LabelAsKey.Only Image and LabelAsKey are used to train the model and make predictions. Vlastnosti ImagePath a Label jsou pro usnadnění přístupu k původnímu názvu souboru bitové kopie a kategorii zachovány.The ImagePath and Label properties are kept for convenience to access the original image file name and category.

    2. Pak pod ModelInput třídy definujte schéma výstupních dat v nové třídě s názvem ModelOutput.Then, below the ModelInput class, define the schema of your output data in a new class called ModelOutput.

      class ModelOutput
      {
          public string ImagePath { get; set; }
      
          public string Label { get; set; }
      
          public string PredictedLabel { get; set; }
      }
      

      ModelOutput obsahuje následující vlastnosti:ModelOutput contains the following properties:

      • ImagePath je plně kvalifikovaná cesta, kde je obrázek uložený.ImagePath is the fully qualified path where the image is stored.
      • Label je původní kategorie, do které patří obrázek.Label is the original category the image belongs to. Toto je hodnota, která se má předpovědět.This is the value to predict.
      • PredictedLabel je hodnota předpokládaná modelem.PredictedLabel is the value predicted by the model.

      Podobně jako u ModelInputse vyžaduje jenom PredictedLabel k předpovědi, protože obsahuje předpovědi vytvořenou modelem.Similar to ModelInput, only the PredictedLabel is required to make predictions since it contains the prediction made by the model. Vlastnosti ImagePath a Label jsou pro usnadnění přístupu k původnímu názvu souboru bitové kopie a kategorii zachovány.The ImagePath and Label properties are retained for convenience to access the original image file name and category.

Vytvořit adresář pracovního prostoruCreate workspace directory

Když se data o školení a ověřování často nemění, je vhodné při dalších spuštěních ukládat do mezipaměti vypočtené kritické hodnoty.When training and validation data do not change often, it is good practice to cache the computed bottleneck values for further runs.

  1. V projektu vytvořte nový adresář s názvem pracovní prostor pro uložení vypočítaných kritických hodnot a .pb verze modelu.In your project, create a new directory called workspace to store the computed bottleneck values and .pb version of the model.

Definování cest a inicializovat proměnnéDefine paths and initialize variables

  1. V rámci metody Main definujte umístění vašich assetů, vypočtených kritických hodnot a .pb verze modelu.Inside the Main method, define the location of your assets, computed bottleneck values and .pb version of the model.

    var projectDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../"));
    var workspaceRelativePath = Path.Combine(projectDirectory, "workspace");
    var assetsRelativePath = Path.Combine(projectDirectory, "assets");
    
  2. Pak inicializujte mlContext proměnnou novou instancí třídy MLContext.Then, initialize the mlContext variable with a new instance of MLContext.

    MLContext mlContext = new MLContext();
    

    Třída MLContext je výchozím bodem pro všechny operace ml.NET a inicializuje MLContext vytvoří nové prostředí ml.NET, které lze sdílet napříč objekty pracovního postupu pro vytváření modelů.The MLContext class is a starting point for all ML.NET operations, and initializing mlContext creates a new ML.NET environment that can be shared across the model creation workflow objects. Je podobný a koncepčně DBContext v Entity Framework.It's similar, conceptually, to DBContext in Entity Framework.

Načtení datLoad the data

Metoda vytvoření nástroje pro načítání datCreate data loading utility method

Bitové kopie jsou uloženy ve dvou podadresářích.The images are stored in two subdirectories. Před načtením dat je třeba ji naformátovat na seznam ImageData objektů.Before loading the data, it needs to be formatted into a list of ImageData objects. Provedete to tak, že vytvoříte metodu LoadImagesFromDirectory pod metodou Main.To do so, create the LoadImagesFromDirectory method below the Main method.

public static IEnumerable<ImageData> LoadImagesFromDirectory(string folder, bool useFolderNameAsLabel = true)
{

}
  1. Uvnitř LoadImagesDirectory přidejte následující kód pro získání všech cest k souborům z podadresářů:Inside the LoadImagesDirectory add the following code to get all of the file paths from the subdirectories:

    var files = Directory.GetFiles(folder, "*",
        searchOption: SearchOption.AllDirectories);
    
  2. Potom Iterujte každý ze souborů pomocí příkazu foreach.Then, iterate through each of the files using a foreach statement.

    foreach (var file in files)
    {
    
    }
    
  3. V rámci příkazu foreach ověřte, zda jsou přípony souborů podporovány.Inside the foreach statement, check that the file extensions are supported. Rozhraní API klasifikace obrázků podporuje formáty JPEG a PNG.The Image Classification API supports JPEG and PNG formats.

    if ((Path.GetExtension(file) != ".jpg") && (Path.GetExtension(file) != ".png"))
        continue;
    
  4. Pak Získejte popisek pro soubor.Then, get the label for the file. Je-li parametr useFolderNameAsLabel nastaven na hodnotu true, bude jako popisek použit nadřazený adresář, kde je soubor uložen.If the useFolderNameAsLabel parameter is set to true, then the parent directory where the file is saved is used as the label. V opačném případě očekává, že popisek bude prefixem názvu souboru nebo samotného názvu souboru.Otherwise, it expects the label to be a prefix of the file name or the file name itself.

    var label = Path.GetFileName(file);
    
    if (useFolderNameAsLabel)
        label = Directory.GetParent(file).Name;
    else
    {
        for (int index = 0; index < label.Length; index++)
        {
            if (!char.IsLetter(label[index]))
            {
                label = label.Substring(0, index);
                break;
            }
        }
    }
    
  5. Nakonec vytvořte novou instanci ModelInput.Finally, create a new instance of ModelInput.

    yield return new ImageData()
    {
        ImagePath = file,
        Label = label
    };
    

Příprava datPrepare the data

  1. Zpět v metodě Main použijte metodu LoadFromDirectory Utility k získání seznamu imagí použitých pro školení.Back in the Main method, use the LoadFromDirectory utility method to get the list of images used for training.

    IEnumerable<ImageData> images = LoadImagesFromDirectory(folder: assetsRelativePath, useFolderNameAsLabel: true);
    
  2. Pak načtěte obrázky do IDataView pomocí metody LoadFromEnumerable .Then, load the images into an IDataView using the LoadFromEnumerable method.

    IDataView imageData = mlContext.Data.LoadFromEnumerable(images);
    
  3. Data se načítají v pořadí, v jakém byla načtena z adresářů.The data is loaded in the order it was read from the directories. Chcete-li vyrovnávat data, přemístěte je pomocí metody ShuffleRows .To balance the data, shuffle it using the ShuffleRows method.

    IDataView shuffledData = mlContext.Data.ShuffleRows(imageData);
    
  4. Modely strojového učení očekávají, že vstup bude v číselném formátu.Machine learning models expect input to be in numerical format. Proto je nutné před školením provést některé předzpracování dat.Therefore, some preprocessing needs to be done on the data prior to training. Vytvoří EstimatorChain tvořená MapValueToKey a LoadRawImageBytesmi transformacemi.Create an EstimatorChain made up of the MapValueToKey and LoadRawImageBytes transforms. MapValueToKey transformace přebírá hodnotu kategorií ve sloupci Label, převede ji na číselnou KeyType hodnotu a uloží ji do nového sloupce s názvem LabelAsKey.The MapValueToKey transform takes the categorical value in the Label column, converts it to a numerical KeyType value and stores it in a new column called LabelAsKey. LoadImages přebírá hodnoty z ImagePath sloupce spolu s parametrem imageFolder pro načtení imagí pro školení.The LoadImages takes the values from the ImagePath column along with the imageFolder parameter to load images for training.

    var preprocessingPipeline = mlContext.Transforms.Conversion.MapValueToKey(
            inputColumnName: "Label",
            outputColumnName: "LabelAsKey")
        .Append(mlContext.Transforms.LoadRawImageBytes(
            outputColumnName: "Image",
            imageFolder: assetsRelativePath,
            inputColumnName: "ImagePath"));
    
  5. Použijte metodu Fit pro použití dat na preprocessingPipeline EstimatorChain následovaný metodou Transform , která vrací IDataView obsahující předem zpracovaná data.Use the Fit method to apply the data to the preprocessingPipeline EstimatorChain followed by the Transform method, which returns an IDataView containing the pre-processed data.

    IDataView preProcessedData = preprocessingPipeline
                        .Fit(shuffledData)
                        .Transform(shuffledData);
    
  6. Pro výuku modelu je důležité, abyste měli školicí datovou sadu i ověřovací datovou sadu.To train a model, it's important to have a training dataset as well as a validation dataset. Model je vyškolený v sadě školení.The model is trained on the training set. Jak dobře je předpovědi na nezpracovaných datech, je měřeno výkonem proti sadě ověřování.How well it makes predictions on unseen data is measured by the performance against the validation set. V závislosti na výsledcích tohoto výkonu model provádí úpravy podle toho, co se naučilo ve snaze zlepšit.Based on the results of that performance, the model makes adjustments to what it has learned in an effort to improve. Sada ověření může pocházet z rozdělení původní datové sady nebo z jiného zdroje, který již byl pro tento účel vyhrazen.The validation set can come from either splitting your original dataset or from another source that has already been set aside for this purpose. V tomto případě je předem zpracovaná datová sada rozdělena do školicích, ověřovacích a testovacích sad.In this case, the pre-processed dataset is split into training, validation and test sets.

    TrainTestData trainSplit = mlContext.Data.TrainTestSplit(data: preProcessedData, testFraction: 0.3);
    TrainTestData validationTestSplit = mlContext.Data.TrainTestSplit(trainSplit.TestSet);
    

    Výše uvedený vzor kódu provádí dvě rozdělení.The code sample above performs two splits. Předem zpracovaná data jsou nejprve rozdělena a 70% se používá pro školení, zatímco se k ověřování používá zbývajících 30%.First, the pre-processed data is split and 70% is used for training while the remaining 30% is used for validation. Potom je 30% ověřovací sada dále rozdělena na ověřování a sady testů, kde se pro ověřování používá 90% a pro testování se používá 10%.Then, the 30% validation set is further split into validation and test sets where 90% is used for validation and 10% is used for testing.

    Způsob, jak se zamyslet na účel těchto datových oddílů, je provedení zkoušky.A way to think about the purpose of these data partitions is taking an exam. Při studiu pro zkoušku si Projděte poznámky, knihy nebo jiné prostředky, abyste získali informace o konceptech, které se na této zkoušce nacházejí.When studying for an exam, you review your notes, books, or other resources to get a grasp on the concepts that are on the exam. To je to, pro který je vlaková sada.This is what the train set is for. Pak můžete pořizovat napodobnou zkoušku k ověření vašeho vědomí.Then, you might take a mock exam to validate your knowledge. Tady se objeví ověřovací sada.This is where the validation set comes in handy. Chcete před provedením samotné zkoušky ověřit, zda máte dobré pojetí konceptů.You want to check whether you have a good grasp of the concepts before taking the actual exam. Na základě těchto výsledků si poznamenejte, co se vám nepovedlo nebo nerozumělo, a zahrňte své změny do kontroly skutečné zkoušky.Based on those results, you take note of what you got wrong or didn't understand well and incorporate your changes as you review for the real exam. Nakonec můžete provést zkoušku.Finally, you take the exam. To je to, co je testovací sada používána pro.This is what the test set is used for. Nikdy jste neviděli otázky, které se týkají zkoušky, a teď pomocí toho, co jste se naučili při školení a ověřování, abyste mohli vaše znalosti na úkol použít.You've never seen the questions that are on the exam and now use what you learned from training and validation to apply your knowledge to the task at hand.

  7. Přiřaďte oddíly jejich příslušné hodnoty pro data vlaku, ověřování a testování.Assign the partitions their respective values for the train, validation and test data.

    IDataView trainSet = trainSplit.TrainSet;
    IDataView validationSet = validationTestSplit.TrainSet;
    IDataView testSet = validationTestSplit.TestSet;
    

Definování školicího kanáluDefine the training pipeline

Školení modelů se skládá z několika kroků.Model training consists of a couple of steps. Rozhraní API pro klasifikaci imagí slouží jako první, používá se k učení modelu.First, Image Classification API is used to train the model. Zakódované popisky ve sloupci PredictedLabel se pak převádějí zpátky na původní hodnotu kategorií pomocí MapKeyToValue transformaci.Then, the encoded labels in the PredictedLabel column are converted back to their original categorical value using the MapKeyToValue transform.

  1. Vytvořte novou proměnnou pro uložení sady požadovaných a volitelných parametrů pro ImageClassificationTrainer.Create a new variable to store a set of required and optional parameters for an ImageClassificationTrainer.

    var classifierOptions = new ImageClassificationTrainer.Options()
    {
        FeatureColumnName = "Image",
        LabelColumnName = "LabelAsKey",
        ValidationSet = validationSet,
        Arch = ImageClassificationTrainer.Architecture.ResnetV2101,
        MetricsCallback = (metrics) => Console.WriteLine(metrics),
        TestOnTrainSet = false,
        ReuseTrainSetBottleneckCachedValues = true,
        ReuseValidationSetBottleneckCachedValues = true,
        WorkspacePath=workspaceRelativePath
    };
    

    ImageClassificationTrainer přebírá několik volitelných parametrů:An ImageClassificationTrainer takes several optional parameters:

    • FeatureColumnName je sloupec, který se používá jako vstup pro model.FeatureColumnName is the column that is used as input for the model.
    • LabelColumnName je sloupec, jehož hodnota se má předpovědět.LabelColumnName is the column for the value to predict.
    • ValidationSet je IDataView obsahující ověřovací data.ValidationSet is the IDataView containing the validation data.
    • Arch definuje, které z předdefinovaných architektur modelů se mají použít.Arch defines which of the pretrained model architectures to use. V tomto kurzu použijeme 101 variant modelu ResNetv2.This tutorial uses the 101-layer variant of the ResNetv2 model.
    • MetricsCallback váže funkci, aby sledovala průběh během školení.MetricsCallback binds a function to track the progress during training.
    • TestOnTrainSet oznamuje modelu, aby měřil výkon proti školicí sadě, když není k dispozici žádná ověřovací sada.TestOnTrainSet tells the model to measure performance against the training set when no validation set is present.
    • ReuseTrainSetBottleneckCachedValues instruuje model, zda se mají v následných fázích použít hodnoty uložené v mezipaměti z fáze kritického bodu.ReuseTrainSetBottleneckCachedValues tells the model whether to use the cached values from the bottleneck phase in subsequent runs. Kritická fáze je jednorázové výpočtu předávacího přenosu, který je výpočetně náročný při prvním provedení.The bottleneck phase is a one-time pass-through computation that is computationally intensive the first time it is performed. Pokud se školicí data nezmění a chcete experimentovat s jiným počtem epochs nebo dávky, použití hodnot uložených v mezipaměti významně zkracuje dobu potřebnou k výuce modelu.If the training data does not change and you want to experiment using a different number of epochs or batch size, using the cached values significantly reduces the amount of time required to train a model.
    • ReuseValidationSetBottleneckCachedValues je podobná ReuseTrainSetBottleneckCachedValues pouze v tomto případě je to pro datovou sadu ověřování.ReuseValidationSetBottleneckCachedValues is similar to ReuseTrainSetBottleneckCachedValues only that in this case it's for the validation dataset.
    • WorkspacePath definuje adresář, kam se mají ukládat vypočítané kritické hodnoty a .pb verze modelu.WorkspacePath defines the directory where to store the computed bottleneck values and .pb version of the model.
  2. Definujte kanál školení EstimatorChain , který se skládá z mapLabelEstimator a ImageClassificationTrainer.Define the EstimatorChain training pipeline that consists of both the mapLabelEstimator and the ImageClassificationTrainer.

    var trainingPipeline = mlContext.MulticlassClassification.Trainers.ImageClassification(classifierOptions)
        .Append(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabel"));
    
  3. Pro výuku modelu použijte metodu Fit .Use the Fit method to train your model.

    ITransformer trainedModel = trainingPipeline.Fit(trainSet);
    

Použití modeluUse the model

Teď, když jste si proškole svůj model, je čas ho použít ke klasifikaci imagí.Now that you have trained your model, it's time to use it to classify images.

Pod metodou Main vytvořte novou metodu Utility nazvanou OutputPrediction, která zobrazí informace o předpovědi v konzole nástroje.Below the Main method, create a new utility method called OutputPrediction to display prediction information in the console.

private static void OutputPrediction(ModelOutput prediction)
{
    string imageName = Path.GetFileName(prediction.ImagePath);
    Console.WriteLine($"Image: {imageName} | Actual Value: {prediction.Label} | Predicted Value: {prediction.PredictedLabel}");
}

Klasifikace jednoho obrázkuClassify a single image

  1. Přidejte novou metodu nazvanou ClassifySingleImage pod Main metodu pro vytvoření a výstup jedné předpovědi imagí.Add a new method called ClassifySingleImage below the Main method to make and output a single image prediction.

    public static void ClassifySingleImage(MLContext mlContext, IDataView data, ITransformer trainedModel)
    {
    
    }
    
  2. V rámci metody ClassifySingleImage vytvořte PredictionEngine .Create a PredictionEngine inside the ClassifySingleImage method. PredictionEngine je praktické rozhraní API, které umožňuje předat a následně provést předpovědi pro jednu instanci dat.The PredictionEngine is a convenience API, which allows you to pass in and then perform a prediction on a single instance of data.

    PredictionEngine<ModelInput, ModelOutput> predictionEngine = mlContext.Model.CreatePredictionEngine<ModelInput, ModelOutput>(trainedModel);
    
  3. Chcete-li získat přístup k jedné instanci ModelInput, převeďte IDataView data na IEnumerable pomocí metody CreateEnumerable a poté Získejte první sledování.To access a single ModelInput instance, convert the data IDataView into an IEnumerable using the CreateEnumerable method and then get the first observation.

    ModelInput image = mlContext.Data.CreateEnumerable<ModelInput>(data,reuseRowObject:true).First();
    
  4. K klasifikaci obrázku použijte metodu Predict .Use the Predict method to classify the image.

    ModelOutput prediction = predictionEngine.Predict(image);
    
  5. Výstup předpovědi do konzoly s metodou OutputPrediction.Output the prediction to the console with the OutputPrediction method.

    Console.WriteLine("Classifying single image");
    OutputPrediction(prediction);
    
  6. Uvnitř metody Main volejte ClassifySingleImage pomocí testovací sady imagí.Inside the Main method, call ClassifySingleImage using the test set of images.

    ClassifySingleImage(mlContext, testSet, trainedModel);
    

Klasifikace více imagíClassify multiple images

  1. Přidejte novou metodu nazvanou ClassifyImages pod ClassifySingleImage metodu pro vytvoření a výstup více předpovědi obrázků.Add a new method called ClassifyImages below the ClassifySingleImage method to make and output multiple image predictions.

    public static void ClassifyImages(MLContext mlContext, IDataView data, ITransformer trainedModel)
    {
    
    }
    
  2. Vytvořte IDataView obsahující předpovědi pomocí metody Transform .Create an IDataView containing the predictions by using the Transform method. Do metody ClassifyImages přidejte následující kód.Add the following code inside the ClassifyImages method.

    IDataView predictionData = trainedModel.Transform(data);
    
  3. Chcete-li iterovat přes předpovědi, převeďte predictionData IDataView na IEnumerable pomocí metody CreateEnumerable a potom Získejte prvních 10 pozorování.In order to iterate over the predictions, convert the predictionData IDataView into an IEnumerable using the CreateEnumerable method and then get the first 10 observations.

    IEnumerable<ModelOutput> predictions = mlContext.Data.CreateEnumerable<ModelOutput>(predictionData, reuseRowObject: true).Take(10);
    
  4. Iterujte a navýstupujte původní a předpovězené popisky pro předpovědi.Iterate and output the original and predicted labels for the predictions.

    Console.WriteLine("Classifying multiple images");
    foreach (var prediction in predictions)
    {
        OutputPrediction(prediction);
    }
    
  5. Nakonec v rámci metody Main volejte ClassifyImages pomocí testovací sady imagí.Finally, inside the Main method, call ClassifyImages using the test set of images.

    ClassifyImages(mlContext, testSet, trainedModel);
    

Spuštění aplikaceRun the application

Spusťte konzolovou aplikaci.Run your console app. Výstup by měl vypadat podobně jako na následujícím obrázku.The output should be similar to that below. Můžou se zobrazovat upozornění nebo zprávy o zpracování, ale tyto zprávy se z následujících výsledků odebraly z důvodu srozumitelnosti.You may see warnings or processing messages, but these messages have been removed from the following results for clarity. V případě zkrácení byl výstup zúžený.For brevity, the output has been condensed.

Fáze kritického boduBottleneck phase

Pro název Image se nevytiskne žádná hodnota, protože image jsou načtené jako byte[] proto, že není k dispozici žádný název Image k zobrazení.No value is printed for the image name because the images are loaded as a byte[] therefore there is no image name to display.

Phase: Bottleneck Computation, Dataset used:      Train, Image Index: 279
Phase: Bottleneck Computation, Dataset used:      Train, Image Index: 280
Phase: Bottleneck Computation, Dataset used: Validation, Image Index:   1
Phase: Bottleneck Computation, Dataset used: Validation, Image Index:   2

Fáze školeníTraining phase

Phase: Training, Dataset used: Validation, Batch Processed Count:   6, Epoch:  21, Accuracy:  0.6797619
Phase: Training, Dataset used: Validation, Batch Processed Count:   6, Epoch:  22, Accuracy:  0.7642857
Phase: Training, Dataset used: Validation, Batch Processed Count:   6, Epoch:  23, Accuracy:  0.7916667

Klasifikovat výstup imagíClassify images output

Classifying single image
Image: 7001-220.jpg | Actual Value: UD | Predicted Value: UD

Classifying multiple images
Image: 7001-220.jpg | Actual Value: UD | Predicted Value: UD
Image: 7001-163.jpg | Actual Value: UD | Predicted Value: UD
Image: 7001-210.jpg | Actual Value: UD | Predicted Value: UD

Po kontrole obrázku 7001 -220. jpg vidíte, že ve skutečnosti není prasklý.Upon inspection of the 7001-220.jpg image, you can see that it in fact is not cracked.

Obrázek datové sady SDNET2018 použité pro předpověď

Blahopřejeme!Congratulations! Teď jste úspěšně vytvořili model hloubkového učení pro klasifikaci imagí.You've now successfully built a deep learning model for classifying images.

Zlepšení modeluImprove the model

Pokud nejste spokojeni s výsledky modelu, můžete se pokusit zvýšit jeho výkon tak, že zkusíte některé z následujících přístupů:If you're not satisfied with the results of your model, you can try to improve its performance by trying some of the following approaches:

  • Další data: Další příklady, ze kterých se model učí, je lepší.More Data: The more examples a model learns from, the better it performs. Stáhněte si úplnou datovou sadu SDNET2018 a využijte ji ke školení.Download the full SDNET2018 dataset and use it to train.
  • Rozšíření dat: běžnou technikou pro přidání různých druhů dat je rozšíření dat pomocí obrázku a použití různých transformací (otočení, překlopení, posunutí a oříznutí).Augment the data: A common technique to add variety to the data is to augment the data by taking an image and applying different transforms (rotate, flip, shift, crop). Tím se přidá více různých příkladů modelu, ze kterého se naučíte.This adds more varied examples for the model to learn from.
  • Školení pro delší dobu: čím delší je, tím bude model lépe vyladěný.Train for a longer time: The longer you train, the more tuned the model will be. Zvýšení počtu epochs může zlepšit výkon modelu.Increasing the number of epochs may improve the performance of your model.
  • Experiment s parametrem Hyper-Parameters: Kromě parametrů používaných v tomto kurzu můžete další parametry vyladit tak, aby potenciálně vylepšily výkon.Experiment with the hyper-parameters: In addition to the parameters used in this tutorial, other parameters can be tuned to potentially improve performance. Změna studijní frekvence, která určuje velikost aktualizací v modelu po každém epocha, může zlepšit výkon.Changing the learning rate, which determines the magnitude of updates made to the model after each epoch may improve performance.
  • Použití jiné architektury modelů: v závislosti na tom, jak vaše data vypadají, se může model, který se nejlépe učí jeho funkcí, lišit.Use a different model architecture: Depending on what your data looks like, the model that can best learn its features may differ. Pokud nejste spokojeni s výkonem modelu, zkuste změnit architekturu.If you're not satisfied with the performance of your model, try changing the architecture.

Další materiály a zdroje informacíAdditional Resources

Další krokyNext steps

V tomto kurzu jste zjistili, jak vytvořit vlastní model hloubkového učení s využitím učení přenosu, předTensorFlowho modelu klasifikace imagí a rozhraní API pro klasifikaci ml.NET pro klasifikaci imagí konkrétních povrchů jako prasklé nebo prolomené.In this tutorial, you learned how to build a custom deep learning model using transfer learning, a pretrained image classification TensorFlow model and the ML.NET Image Classification API to classify images of concrete surfaces as cracked or uncracked.

Pokud se chcete dozvědět víc, přejděte k dalšímu kurzu.Advance to the next tutorial to learn more.