Oktatóanyag: Automatizált vizuális ellenőrzés átviteles tanulással a ML.NET Képbesorolási API-val

  • Cikk

Megtudhatja, hogyan taníthat be egyéni mélytanulási modellt átadási tanulással, egy előre betanított TensorFlow-modellel és a ML.NET Képbesorolási API-val, hogy a konkrét felületek képeit repedezettnek vagy töretlennek minősítse.

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

  • A probléma ismertetése
  • Tudnivalók a ML.NET Képbesorolási API-ról
  • Az előre betanított modell ismertetése
  • Egyéni TensorFlow-rendszerképbesorolási modell betanítása átviteli tanulással
  • Képek osztályozása az egyéni modellel

Előfeltételek

Képbesorolás átvitelének tanulási mintája – áttekintés

Ez a minta egy C# .NET Core-konzolalkalmazás, amely egy előre betanított TensorFlow-modellel osztályozza a képeket. A minta kódja a mintaböngészőben található.

A probléma ismertetése

A képbesorolás egy számítógépes látási probléma. A képbesorolás bemenetként veszi fel a képet, és kategorizálja azt egy előírt osztályba. A képbesorolási modelleket általában mélytanulási és neurális hálózatok használatával tanítják be. További információ: Mély tanulás és gépi tanulás .

Néhány olyan forgatókönyv, ahol a képbesorolás hasznos:

  • Arcfelismerés
  • Érzelemészlelés
  • Orvosi diagnózis
  • Tájékozódási pont észlelése

Ez az oktatóanyag betanít egy egyéni képbesorolási modellt a hídfedélzetek automatizált vizuális vizsgálatának elvégzésére a repedések által sérült struktúrák azonosításához.

ML.NET Képbesorolási API

ML.NET a képbesorolás különböző módjait kínálja. Ez az oktatóanyag a Képbesorolási API használatával alkalmazza a transzfertanulást. A Képbesorolási API a TensorFlow.NET, egy alacsony szintű kódtárat használ, amely C#-kötéseket biztosít a TensorFlow C++ API-hoz.

Mi az a tudásátadás?

Az átadási tanulás az egyik probléma megoldásából szerzett ismereteket egy másik kapcsolódó problémára alkalmazza.

A mélytanulási modell alapoktól való betanításához több paramétert, nagy mennyiségű 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. Az előre betanított modell és az átadási tanulás használata lehetővé teszi a betanítási folyamat gyorsítását.

Betanítási folyamat

A Képbesorolási API egy előre betanított TensorFlow-modell betöltésével indítja el a betanítási folyamatot. A betanítási folyamat két lépésből áll:

  1. Szűk keresztmetszet fázisa
  2. Betanítási fázis

Betanítási lépések

Szűk keresztmetszet fázisa

A szűk keresztmetszeti fázisban a rendszer betölti a betanítási képek készletét, és a képpontértékeket használja bemenetként vagy funkciókként az előre betanított modell fagyasztott rétegeihez. A fagyasztott rétegek a neurális hálózat összes rétegét tartalmazzák az utolsó előtti rétegig, informálisan szűk keresztmetszeti rétegként. Ezeket a rétegeket fagyasztottnak nevezzük, mert ezeken a rétegeken nem történik betanítás, és a műveletek át lesznek adva. Ezekben a befagyott rétegekben vannak kiszámítva az alacsonyabb szintű minták, amelyek segítenek a modellnek megkülönböztetni a különböző osztályokat. Minél nagyobb a rétegek száma, annál nagyobb számítási igényű ez a lépés. Szerencsére, mivel ez egy egyszeri számítás, az eredmények gyorsítótárazhatók és felhasználhatók későbbi futtatásokban, amikor különböző paraméterekkel kísérleteznek.

Betanítási fázis

A szűk keresztmetszeti fázis kimeneti értékeinek kiszámítása után a rendszer bemenetként használja őket a modell végső rétegének újratanításához. Ez a folyamat iteratív, és a modellparaméterek által megadott számú alkalommal fut. Minden futtatás során a rendszer kiértékeli a veszteséget és a pontosságot. Ezután a megfelelő módosításokat a modell javítása érdekében hajtják végre azzal a céllal, hogy minimalizálja a veszteséget és maximalizálja a pontosságot. A betanítás befejezése után két modellformátum lesz kimenet. Az egyik a .pb modell verziója, a másik pedig a .zip modell ML.NET szerializált verziója. Ha ML.NET által támogatott környezetben dolgozik, ajánlott a .zip modell verzióját használni. Olyan környezetekben azonban, ahol a ML.NET nem támogatott, lehetősége van a .pb verzió használatára.

Az előre betanított modell ismertetése

Az oktatóanyagban használt előre betanított modell a ResNet v2-modell 101 rétegű változata. Az eredeti modell be van tanítva, hogy a képeket ezer kategóriába sorolja. A modell bemenetként egy 224 x 224-es méretű képet vesz fel, és a betanított osztályok osztály-valószínűségeit adja ki. Ennek a modellnek a része egy új modell betanítása egyéni rendszerképek használatával, hogy előrejelzéseket készítsen két osztály között.

Konzolalkalmazás létrehozása

Most, hogy általános ismereteket szerezhet az átadási tanulásról és a Képbesorolási API-ról, ideje felépíteni az alkalmazást.

  1. Hozzon létre egy "DeepLearning_ImageClassification_Binary" 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.

    1. A Megoldáskezelő kattintson a jobb gombbal a projektre, és válassza a Manage NuGet Packages (NuGet-csomagok kezelése) lehetőséget.
    2. Válassza a "nuget.org" lehetőséget a Csomag forrásaként.
    3. Válassza a Tallózás lapot.
    4. Jelölje be az Előzetes befoglalás jelölőnégyzetet.
    5. Keresse meg a Microsoft.ML.
    6. Válassza a Telepítés gombot.
    7. Válassza az OK gombot a Változások előnézete párbeszédpanelen, majd válassza az Elfogadom gombot a Licenc elfogadása párbeszédpanelen, ha elfogadja a felsorolt csomagok licencfeltételét.
    8. Ismételje meg ezeket a lépéseket a Microsoft.ML.Vision, a SciSharp.TensorFlow.Redist2.3.1-es és a Microsoft.ML.ImageAnalytics NuGet-csomagok esetében.

Az adatok előkészítése és értelmezése

Megjegyzés

Az oktatóanyag adathalmazai Maguire, Marc; Dorafshan, Sattar; és Thomas, Robert J., "SDNET2018: Egy konkrét kiváló képadatkészlet gépi tanulási alkalmazásokhoz" (2018). Tallózás az összes adatkészlet között. 48- os papír. https://digitalcommons.usu.edu/all_datasets/48

Az SDNET2018 egy olyan képadatkészlet, amely széljegyzeteket tartalmaz repedezett és nem repedezett betonszerkezetekhez (hídfedélzetekhez, falakhoz és járdákhoz).

SDNET2018 adathalmaz hídfedélzeti mintái

Az adatok három alkönyvtárba kerülnek:

  • A D hídfedélzeti rendszerképeket tartalmaz
  • A P járdaképeket tartalmaz
  • A W faliképeket tartalmaz

Ezen alkönyvtárak mindegyike két további előtaggal rendelkező alkönyvtárat tartalmaz:

  • C a repedezett felületekhez használt előtag
  • U a nem átfedt felületekhez használt előtag

Ebben az oktatóanyagban csak a hídfedélzeti rendszerképeket használja a rendszer.

  1. Töltse le az adathalmazt, és bontsa ki.
  2. Hozzon létre egy "assets" nevű könyvtárat a projektben az adathalmazfájlok mentéséhez.
  3. Másolja a CD- és UD-alkönyvtárakat a nemrég kicsomagolt könyvtárból az eszközök könyvtárába.

Bemeneti és kimeneti osztályok létrehozása

  1. Nyissa meg a Program.cs fájlt, és cserélje le a fájl tetején lévő meglévő using utasításokat a következőre:

    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. Program A Program.cs osztálya alatt hozzon létre egy nevű osztálytImageData. Ez az osztály az eredetileg betöltött adatok megjelenítésére szolgál.

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

    public string Label { get; set; }
}

    ImageData a következő tulajdonságokat tartalmazza:

    • ImagePath A a teljes elérési út, ahol a rendszerképet tárolja.
    • Label az a kategória, amelyhez a kép tartozik. Ezt az értéket kell előrejelezni.

  3. Osztályok létrehozása a bemeneti és kimeneti adatokhoz

    1. ImageData Az osztály alatt adja meg a bemeneti adatok sémáját egy nevű új osztálybanModelInput.

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

    public string ImagePath { get; set; }

    public string Label { get; set; }
}

      ModelInput a következő tulajdonságokat tartalmazza:

      • Imagebyte[] a kép ábrázolása. A modell elvárja, hogy a képadatok ilyen típusúak legyenek a betanításhoz.
      • LabelAsKey A a numerikus ábrázolása Label.
      • ImagePath A a teljes elérési út, ahol a rendszerképet tárolja.
      • Label az a kategória, amelyhez a kép tartozik. Ezt az értéket kell előrejelezni.

      Csak Image a és LabelAsKey a használatával taníthatja be a modellt, és előrejelzéseket készíthet. A ImagePath és Label a tulajdonság az eredeti képfájl nevének és kategóriájának egyszerű eléréséhez szükséges.

    2. Ezután a ModelInput osztály alatt definiálja a kimeneti adatok sémáját egy nevű új osztályban ModelOutput.

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

    public string Label { get; set; }

    public string PredictedLabel { get; set; }
}

      ModelOutput a következő tulajdonságokat tartalmazza:

      • ImagePath A a teljes elérési út, ahol a rendszerképet tárolja.
      • Label az az eredeti kategória, amelyhez a kép tartozik. Ezt az értéket kell előrejelezni.
      • PredictedLabel A a modell által előrejelzett érték.

      A -hez ModelInputhasonlóan csak a PredictedLabel szükséges az előrejelzések készítéséhez, mivel tartalmazza a modell által készített előrejelzést. A ImagePath és Label a tulajdonságok megmaradnak az eredeti képfájl nevének és kategóriájának eléréséhez.

Munkaterület-címtár létrehozása

Ha a betanítási és érvényesítési adatok nem változnak gyakran, érdemes gyorsítótárazni a kiszámított szűk keresztmetszeti értékeket a további futtatásokhoz.

  1. A projektben hozzon létre egy munkaterület nevű új könyvtárat a modell kiszámított szűk keresztmetszeti értékeinek és .pb verziójának tárolásához.

Elérési utak definiálása és változók inicializálása

  1. A using utasítások alatt adja meg az objektumok helyét, a kiszámított szűk keresztmetszeti értékeket és .pb a modell verzióját.

    var projectDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../"));
var workspaceRelativePath = Path.Combine(projectDirectory, "workspace");
var assetsRelativePath = Path.Combine(projectDirectory, "assets");

  2. Inicializálja a változót mlContext az MLContext új példányával.

    MLContext mlContext = new MLContext();

    Az MLContext osztály minden ML.NET művelet kiindulási pontja, és az mlContext inicializálása 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 adatok betöltése

Adatbetöltési segédprogram létrehozása

A rendszerképek két alkönyvtárban vannak tárolva. Az adatok betöltése előtt azokat objektumlistává ImageData kell formázni. Ehhez hozza létre a metódust LoadImagesFromDirectory .

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

}

  1. LoadImagesFromDirectoryA fájlon belül adja hozzá a következő kódot az alkönyvtárakban található összes fájlelérési út lekéréséhez:

    var files = Directory.GetFiles(folder, "*",
    searchOption: SearchOption.AllDirectories);

  2. Ezután iterálja végig az egyes fájlokat egy foreach utasítással.

    foreach (var file in files)
{

}

  3. A utasításon foreach belül ellenőrizze, hogy a fájlkiterjesztések támogatottak-e. A Képbesorolási API támogatja a JPEG- és PNG-formátumokat.

    if ((Path.GetExtension(file) != ".jpg") && (Path.GetExtension(file) != ".png"))
    continue;

  4. Ezután kérje le a fájl címkéjét. Ha a useFolderNameAsLabel paraméter értéke true, akkor a rendszer a szülőkönyvtárat használja címkeként, ahová a fájlt menti. Ellenkező esetben arra számít, hogy a címke a fájlnév vagy maga a fájlnév előtagja lesz.

    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. Végül hozzon létre egy új példányt a fájlból ModelInput.

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

Az adatok előkészítése

  1. Hívja meg a LoadImagesFromDirectory segédprogram metódust a betanításhoz használt képek listájának lekéréséhez a változó inicializálása mlContext után.

    IEnumerable<ImageData> images = LoadImagesFromDirectory(folder: assetsRelativePath, useFolderNameAsLabel: true);

  2. Ezután töltse be a képeket egy IDataView metódussal LoadFromEnumerable .

    IDataView imageData = mlContext.Data.LoadFromEnumerable(images);

  3. Az adatok abban a sorrendben töltődnek be, amelyben a címtárakból beolvasták. Az adatok kiegyensúlyozásához keverje össze azokat a ShuffleRows metódussal.

    IDataView shuffledData = mlContext.Data.ShuffleRows(imageData);

  4. A gépi tanulási modellek elvárják, hogy a bemenet numerikus formátumú legyen. Ezért a betanítás előtt némi előfeldolgozást kell végezni az adatokon. Hozzon létre egy EstimatorChain és egy átalakításból álló MapValueToKeyLoadRawImageBytes elemet. Az MapValueToKey átalakítás felveszi az oszlop kategorikus Label értékét, numerikus KeyType értékké alakítja, és egy nevű új oszlopban LabelAsKeytárolja. A LoadImages az oszlop értékeit ImagePath és a paramétert használja a imageFolder képek betanításhoz való betöltéséhez.

    var preprocessingPipeline = mlContext.Transforms.Conversion.MapValueToKey(
        inputColumnName: "Label",
        outputColumnName: "LabelAsKey")
    .Append(mlContext.Transforms.LoadRawImageBytes(
        outputColumnName: "Image",
        imageFolder: assetsRelativePath,
        inputColumnName: "ImagePath"));

  5. Fit A metódussal alkalmazza az adatokat a preprocessingPipelineEstimatorChain következő Transform metódusra, amely az IDataView előre feldolgozott adatokat tartalmazó értéket adja vissza.

    IDataView preProcessedData = preprocessingPipeline
                    .Fit(shuffledData)
                    .Transform(shuffledData);

  6. A modellek betanításához fontos, hogy legyen betanítási és érvényesítési adathalmaza. A modell betanítása a betanítási készleten történik. A nem látható adatokra vonatkozó előrejelzéseket az érvényesítési készlethez viszonyított teljesítmény méri. A teljesítmény eredményei alapján a modell módosításokat hajt végre a tanultakon a fejlesztés érdekében. Az érvényesítési készlet származhat az eredeti adathalmaz felosztásából, vagy egy másik forrásból, amelyet erre a célra már félretett. Ebben az esetben az előre feldolgozott adatkészlet betanítási, ellenőrzési és tesztelési készletekre van felosztva.

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

    A fenti kódminta két felosztást hajt végre. Először az előre feldolgozott adatok fel lesznek osztva, a betanításhoz pedig 70%, míg a fennmaradó 30% az ellenőrzéshez. Ezután a 30%-os érvényesítési készletet tovább osztja az érvényesítési és tesztelési készletekre, ahol 90%-ot az ellenőrzéshez, 10%-ot pedig teszteléshez használnak.

    Az adatpartíciók rendeltetését úgy lehet átgondolni, ha vizsgát vesznek. A vizsgára való tanulás során áttekintheti jegyzeteit, könyveit vagy egyéb erőforrásait, hogy megismerkedjen a vizsgán szereplő fogalmakkal. Erre való a vonatkészlet. Ezután próbavizsga utánzatot vehet fel a tudása érvényesítéséhez. Itt hasznos az érvényesítési készlet. A tényleges vizsga előtt ellenőrizni szeretné, hogy jól érti-e a fogalmakat. Az eredmények alapján tudomásul veszi, hogy mi a baj, vagy nem értette jól, és beépíti a módosításokat, amikor áttekinti az igazi vizsga. Végül vizsgáztok. Erre szolgál a tesztkészlet. Még soha nem látta a vizsgán szereplő kérdéseket, és most a betanításból és ellenőrzésből tanultakat felhasználva alkalmazza tudását a feladatra.

  7. Rendelje hozzá a partíciókhoz a megfelelő értékeket a betanított, érvényesítési és tesztelési adatokhoz.

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

A betanítási folyamat meghatározása

A modell betanítása néhány lépésből áll. Először is az Image Classification API-t használjuk a modell betanítása érdekében. Ezután az oszlop kódolt PredictedLabel címkéi vissza lesznek alakítva az eredeti kategorikus értékükre az MapKeyToValue átalakítással.

  1. Hozzon létre egy új változót, amely egy kötelező és nem kötelező paraméterkészletet tárol egy ImageClassificationTraineradott változóhoz.

    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
};

    Az an ImageClassificationTrainer több választható paramétert is igénybe vesz:

    • FeatureColumnName A a modell bemeneteként használt oszlop.
    • LabelColumnName az előrejelezendő érték oszlopa.
    • ValidationSet az érvényesítési IDataView adatokat tartalmazó érték.
    • Arch az előre betanított modellarchitektúrák közül melyiket használja. Ez az oktatóanyag a ResNetv2 modell 101 rétegű változatát használja.
    • MetricsCallback Egy függvényt köt össze a betanítási folyamat nyomon követéséhez.
    • TestOnTrainSet arra utasítja a modellt, hogy mérje a teljesítményt a betanítási készlethez, ha nincs érvényesítési készlet.
    • ReuseTrainSetBottleneckCachedValues azt jelzi a modellnek, hogy a szűk keresztmetszeti fázisban lévő gyorsítótárazott értékeket használja-e a későbbi futtatások során. A szűk keresztmetszeti fázis egy egyszeri átmenő számítás, amely az első végrehajtásakor számításigényes. Ha a betanítási adatok nem változnak, és eltérő számú alapidőszak vagy kötegméret használatával szeretne kísérletezni, a gyorsítótárazott értékek használata jelentősen csökkenti a modell betanításához szükséges időt.
    • ReuseValidationSetBottleneckCachedValuesReuseTrainSetBottleneckCachedValues hasonló ahhoz, mint ami ebben az esetben az érvényesítési adatkészlethez tartozik.
    • WorkspacePath meghatározza azt a könyvtárat, ahol tárolni kívánja a modell kiszámított szűk keresztmetszeti értékeit és .pb verzióját.

  2. Határozza meg a betanítási EstimatorChain folyamatot, amely a és a mapLabelEstimatorImageClassificationTrainerrészből is áll.

    var trainingPipeline = mlContext.MulticlassClassification.Trainers.ImageClassification(classifierOptions)
    .Append(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabel"));

  3. A metódus használatával Fit taníthatja be a modellt.

    ITransformer trainedModel = trainingPipeline.Fit(trainSet);

A modell használata

Most, hogy betanította a modellt, itt az ideje, hogy felhasználja a képek besorolásához.

Hozzon létre egy nevű OutputPrediction új segédprogramot az előrejelzési információk konzolon való megjelenítéséhez.

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

Egyetlen kép besorolása

  1. Hozzon létre egy nevű új metódust ClassifySingleImage egyetlen kép előrejelzésének létrehozásához és kimenetéhez.

    void ClassifySingleImage(MLContext mlContext, IDataView data, ITransformer trainedModel)
{

}

  2. Hozzon létre egy belső PredictionEngine metódust ClassifySingleImage . A PredictionEngine egy kényelmi API, amely lehetővé teszi az adatok egyetlen példányának átadását, majd az előrejelzés végrehajtását.

    PredictionEngine<ModelInput, ModelOutput> predictionEngine = mlContext.Model.CreatePredictionEngine<ModelInput, ModelOutput>(trainedModel);

  3. Egyetlen ModelInput példány eléréséhez konvertálja a-t dataIDataView egy IEnumerableCreateEnumerable metódussá, majd kérje le az első megfigyelést.

    ModelInput image = mlContext.Data.CreateEnumerable<ModelInput>(data,reuseRowObject:true).First();

  4. A metódus használatával Predict osztályozza a képet.

    ModelOutput prediction = predictionEngine.Predict(image);

  5. Adja ki az előrejelzést a konzolnak a OutputPrediction metódussal.

    Console.WriteLine("Classifying single image");
OutputPrediction(prediction);

  6. Hívja ClassifySingleImage meg alább a metódust Fit a rendszerképek tesztkészletével.

    ClassifySingleImage(mlContext, testSet, trainedModel);

Több kép besorolása

  1. Adjon hozzá egy új metódust ClassifyImages a metódus alatt, ClassifySingleImage amely több kép-előrejelzést hoz létre és ad ki.

    void ClassifyImages(MLContext mlContext, IDataView data, ITransformer trainedModel)
{

}

  2. Hozzon létre egy IDataView , az előrejelzéseket tartalmazót a Transform metódussal. Adja hozzá a következő kódot a metódushoz ClassifyImages .

    IDataView predictionData = trainedModel.Transform(data);

  3. Az előrejelzések iterálásához konvertálja a predictionDataIDataView metódust egy IEnumerableCreateEnumerable metódussá, majd kérje le az első 10 megfigyelést.

    IEnumerable<ModelOutput> predictions = mlContext.Data.CreateEnumerable<ModelOutput>(predictionData, reuseRowObject: true).Take(10);

  4. Iterálja és adja ki az előrejelzések eredeti és előrejelzett címkéit.

    Console.WriteLine("Classifying multiple images");
foreach (var prediction in predictions)
{
    OutputPrediction(prediction);
}

  5. Végül hívja ClassifyImages meg a metódust a ClassifySingleImage() rendszerképek tesztkészletével.

    ClassifyImages(mlContext, testSet, trainedModel);

Az alkalmazás futtatása

Futtassa a konzolalkalmazást. A kimenetnek az alábbihoz hasonlónak kell lennie. Megjelenhetnek figyelmeztetések vagy üzenetek feldolgozása, de az egyértelműség kedvéért ezek az üzenetek el lettek távolítva az alábbi eredményekből. A rövidség kedvéért a kimenet kondenzálva lett.

Szűk keresztmetszeti fázis

A rendszer nem nyomtat értéket a kép nevének, mert a rendszer betölti byte[] a képeket, ezért nincs megjeleníthető képnév.

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

Betanítási fázis

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

Képek kimenetének besorolása

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

A 7001-220.jpg kép ellenőrzésekor láthatja, hogy valójában nincs repedt.

Előrejelzéshez használt SDNET2018-adathalmaz képe

Gratulálunk! Sikeresen létrehozott egy mélytanulási modellt a képek besorolásához.

A modell továbbfejlesztése

Ha nem elégedett a modell eredményeivel, megpróbálhatja javítani a teljesítményét az alábbi megközelítések némelyikével:

  • További adatok: Minél több példát tanul egy modell, annál jobb teljesítményt nyújt. Töltse le a teljes SDNET2018-adatkészletet , és használja a betanítása gombra.
  • Az adatok bővítése: Az adatok változatossá vitelének gyakori módszere az adatok bővítése egy kép készítésével és különböző átalakítások (forgatás, tükrözés, eltolás, körülvágás) alkalmazásával. Ez változatosabb példákat ad a modellhez, amelyből tanulhat.
  • Betanítása hosszabb ideig: Minél tovább tanítja be, annál jobban finomhangolja a modellt. Az alapidőszakok számának növelése javíthatja a modell teljesítményét.
  • Kísérletezzen a hiperparaméterekkel: Az oktatóanyagban használt paraméterek mellett más paraméterek is hangolhatók a teljesítmény javítása érdekében. A tanulási sebesség módosítása, amely meghatározza, hogy az egyes alapidőszakok után milyen mértékű frissítések történtek a modellen, javíthatja a teljesítményt.
  • Eltérő modellarchitektúra használata: Attól függően, hogy az adatok hogyan néznek ki, a jellemzőket legjobban ismerő modell eltérhet. Ha nem elégedett a modell teljesítményével, próbálja meg módosítani az architektúrát.

Következő lépések

Ebben az oktatóanyagban megtanulta, hogyan hozhat létre egyéni mélytanulási modellt átadási tanulással, egy előre betanított képbesorolási TensorFlow-modellel és a ML.NET Képbesorolási API-val, amely a konkrét felületek képeit repedtként vagy leképezetlenként sorolja be.

További információért lépjen tovább a következő oktatóanyagra.

Objektumészlelés