Rychlý start: Vytvoření projektu detekce objektů pomocí klientské knihovny Custom Vision

Začínáme s klientskou knihovnou Custom Vision pro .NET Podle těchto kroků nainstalujte balíček a vyzkoušejte ukázkový kód pro sestavení modelu rozpoznávání objektů. Vytvoříte projekt, přidáte značky, vytrénujete projekt na ukázkových obrázcích a pomocí adresy URL koncového bodu předpovědi projektu ho programově otestujete. Tento příklad použijte jako šablonu pro vytvoření vlastní aplikace pro rozpoznávání obrázků.

Poznámka:

Pokud chcete sestavit a vytrénovat model detekce objektů bez psaní kódu, přečtěte si místo toho pokyny založené na prohlížeči.

Referenční dokumentace | Zdrojový kód knihovny (trénování) (predikce) | Package (NuGet) (training) (prediction)Samples |

Požadavky

• Předplatné Azure: Můžete si ho vytvořit zdarma.
• Integrované vývojové prostředí sady Visual Studio nebo aktuální verze .NET Core.
• Jakmile budete mít předplatné Azure, vytvořte na webu Azure Portal prostředek Custom Vision, abyste vytvořili prostředek pro trénování a predikci.
  • K vyzkoušení služby můžete použít cenovou úroveňF0 Free a později upgradovat na placenou úroveň pro produkční prostředí.

Vytvoření proměnných prostředí

V tomto příkladu napíšete přihlašovací údaje do proměnných prostředí na místním počítači, na kterém běží aplikace.

Přejděte na Azure Portal. Pokud se prostředky Služby Custom Vision, které jste vytvořili v části Požadavky, úspěšně nasadíte, vyberte tlačítko Přejít k prostředku v části Další kroky. Klíče a koncové body najdete na stránkách klíčů a koncových bodů prostředků v části Správa prostředků. Budete muset získat klíče pro váš trénovací prostředek i prostředek predikce spolu s koncovými body rozhraní API.

ID prediktivního prostředku najdete na kartě Vlastnosti prediktivního prostředku na webu Azure Portal, který je uvedený jako ID prostředku.

Tip

Tyto https://www.customvision.ai hodnoty získáte také pomocí těchto hodnot. Po přihlášení vyberte ikonu Nastavení v pravém horním rohu. Na stránkách Nastavení můžete zobrazit všechny klíče, ID prostředku a koncové body.

Pokud chcete nastavit proměnné prostředí, otevřete okno konzoly a postupujte podle pokynů pro operační systém a vývojové prostředí.

• Pokud chcete nastavit proměnnou VISION_TRAINING KEY prostředí, nahraďte <your-training-key> jedním z klíčů vašeho trénovacího prostředku.
• Pokud chcete nastavit proměnnou VISION_TRAINING_ENDPOINT prostředí, nahraďte <your-training-endpoint> koncovým bodem vašeho trénovacího prostředku.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_KEY prostředí, nahraďte <your-prediction-key> jedním z klíčů pro prostředek předpovědi.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_ENDPOINT prostředí, nahraďte <your-prediction-endpoint> koncový bod pro prostředek predikce.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_RESOURCE_ID prostředí, nahraďte <your-resource-id> ID prostředku pro prostředek predikce.

Důležité

Pokud používáte klíč rozhraní API, uložte ho bezpečně někam jinam, například ve službě Azure Key Vault. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně.

Další informace o zabezpečení služeb AI najdete v tématu Ověřování požadavků na služby Azure AI.

Windows

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Po přidání proměnných prostředí možná budete muset restartovat všechny spuštěné programy, které čtou proměnné prostředí, včetně okna konzoly.

Linux

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Po přidání proměnných prostředí spusťte source ~/.bashrc z okna konzoly, aby změny byly efektivní.

Nastavení

Visual Studio IDE

Vytvoření nové aplikace jazyka C#

Pomocí sady Visual Studio vytvořte novou aplikaci .NET Core.

Instalace klientské knihovny

Po vytvoření nového projektu nainstalujte klientskou knihovnu tak, že v Průzkumník řešení kliknete pravým tlačítkem na řešení projektu a vyberete Spravovat balíčky NuGet. Ve správci balíčků, který se otevře vyberte Procházet, zaškrtněte políčko Zahrnout předběžné verze a vyhledejte Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training a Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction. Vyberte nejnovější verzi a pak nainstalujte.

Rozhraní příkazového řádku

Vytvoření nové aplikace jazyka C#

V okně konzoly (například cmd, PowerShell nebo Bash) pomocí dotnet new příkazu vytvořte novou konzolovou aplikaci s názvem custom-vision-quickstart. Tento příkaz vytvoří jednoduchý projekt "Hello World" C# s jedním zdrojovým souborem: program.cs.

dotnet new console -n custom-vision-quickstart

Změňte adresář na nově vytvořenou složku aplikace. Aplikaci můžete sestavit pomocí následujících:

dotnet build

Výstup sestavení by neměl obsahovat žádná upozornění ani chyby.

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

Instalace klientské knihovny

V adresáři aplikace nainstalujte klientskou knihovnu Custom Vision pro .NET pomocí následujícího příkazu:

dotnet add package Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training --version 2.0.0
dotnet add package Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction --version 2.0.0

Tip

Chcete zobrazit celý soubor s kódem rychlého startu najednou? Soubor s příklady kódu v tomto rychlém startu najdete na GitHubu.

V adresáři projektu otevřete soubor program.cs a přidejte následující using direktivy:

using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction;
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training;
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.Models;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;

V metodě Main aplikace vytvořte proměnné, které načítají klíče a koncový bod vašeho prostředku z proměnných prostředí. Budete také deklarovat některé základní objekty, které se mají použít později.

    string trainingEndpoint = Environment.GetEnvironmentVariable("VISION_TRAINING_ENDPOINT");

    string trainingKey = Environment.GetEnvironmentVariable("VISION_TRAINING_KEY");
    string predictionEndpoint = Environment.GetEnvironmentVariable("VISION_PREDICTION_ENDPOINT");
    string predictionKey = Environment.GetEnvironmentVariable("VISION_PREDICTION_KEY");

    private static Iteration iteration;
    private static string publishedModelName = "CustomODModel";

V metodě Main aplikace přidejte volání metod použitých v tomto rychlém startu. Tyto funkce implementujete později.

CustomVisionTrainingClient trainingApi = AuthenticateTraining(trainingEndpoint, trainingKey);
CustomVisionPredictionClient predictionApi = AuthenticatePrediction(predictionEndpoint, predictionKey);

Project project = CreateProject(trainingApi);
AddTags(trainingApi, project);
UploadImages(trainingApi, project);
TrainProject(trainingApi, project);
PublishIteration(trainingApi, project);
TestIteration(predictionApi, project);

Ověření klienta

V nové metodě vytvořte instanci klientů pro trénování a predikce pomocí koncového bodu a klíčů.

private CustomVisionTrainingClient AuthenticateTraining(string endpoint, string trainingKey, string predictionKey)
{
    // Create the Api, passing in the training key
    CustomVisionTrainingClient trainingApi = new CustomVisionTrainingClient(new Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.ApiKeyServiceClientCredentials(trainingKey))
    {
        Endpoint = endpoint
    };
    return trainingApi;
}
private CustomVisionPredictionClient AuthenticatePrediction(string endpoint, string predictionKey)
{
    // Create a prediction endpoint, passing in the obtained prediction key
    CustomVisionPredictionClient predictionApi = new CustomVisionPredictionClient(new Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction.ApiKeyServiceClientCredentials(predictionKey))
    {
        Endpoint = endpoint
    };
    return predictionApi;
}

Vytvoření nového projektu Custom Vision

Tato další metoda vytvoří projekt detekce objektů. Vytvořený projekt se zobrazí na webu Custom Vision. Podívejte se na metodu CreateProject k určení dalších možností při vytváření projektu (vysvětlení v průvodci sestavením detektoru webového portálu).

private Project CreateProject(CustomVisionTrainingClient trainingApi)
{
    // Find the object detection domain
    var domains = trainingApi.GetDomains();
    var objDetectionDomain = domains.FirstOrDefault(d => d.Type == "ObjectDetection");

    // Create a new project
    Console.WriteLine("Creating new project:");
    project = trainingApi.CreateProject("My New Project", null, objDetectionDomain.Id);

    return project;
}

Přidání značek do projektu

Tato metoda definuje značky, na které model natrénujete.

private void AddTags(CustomVisionTrainingClient trainingApi, Project project)
{
    // Make two tags in the new project
    var forkTag = trainingApi.CreateTag(project.Id, "fork");
    var scissorsTag = trainingApi.CreateTag(project.Id, "scissors");
}

Nahrání a označení obrázků

Nejprve si stáhněte ukázkové obrázky pro tento projekt. Uložte obsah ukázkové složky Obrázky do místního zařízení.

Při označování obrázků v projektech detekce obrázků je potřeba zadat oblast každého označeného objektu pomocí normalizovaných souřadnic. Následující kód přidruží jednotlivé ukázkové obrázky k odpovídající označené oblasti.

private void UploadImages(CustomVisionTrainingClient trainingApi, Project project)
{
    Dictionary<string, double[]> fileToRegionMap = new Dictionary<string, double[]>()
    {
        // FileName, Left, Top, Width, Height
        {"scissors_1", new double[] { 0.4007353, 0.194068655, 0.259803921, 0.6617647 } },
        {"scissors_2", new double[] { 0.426470578, 0.185898721, 0.172794119, 0.5539216 } },
        {"scissors_3", new double[] { 0.289215684, 0.259428144, 0.403186262, 0.421568632 } },
        {"scissors_4", new double[] { 0.343137264, 0.105833367, 0.332107842, 0.8055556 } },
        {"scissors_5", new double[] { 0.3125, 0.09766343, 0.435049027, 0.71405226 } },
        {"scissors_6", new double[] { 0.379901975, 0.24308826, 0.32107842, 0.5718954 } },
        {"scissors_7", new double[] { 0.341911763, 0.20714055, 0.3137255, 0.6356209 } },
        {"scissors_8", new double[] { 0.231617644, 0.08459154, 0.504901946, 0.8480392 } },
        {"scissors_9", new double[] { 0.170343131, 0.332957536, 0.767156839, 0.403594762 } },
        {"scissors_10", new double[] { 0.204656869, 0.120539248, 0.5245098, 0.743464053 } },
        {"scissors_11", new double[] { 0.05514706, 0.159754932, 0.799019635, 0.730392158 } },
        {"scissors_12", new double[] { 0.265931368, 0.169558853, 0.5061275, 0.606209159 } },
        {"scissors_13", new double[] { 0.241421565, 0.184264734, 0.448529422, 0.6830065 } },
        {"scissors_14", new double[] { 0.05759804, 0.05027781, 0.75, 0.882352948 } },
        {"scissors_15", new double[] { 0.191176474, 0.169558853, 0.6936275, 0.6748366 } },
        {"scissors_16", new double[] { 0.1004902, 0.279036, 0.6911765, 0.477124184 } },
        {"scissors_17", new double[] { 0.2720588, 0.131977156, 0.4987745, 0.6911765 } },
        {"scissors_18", new double[] { 0.180147052, 0.112369314, 0.6262255, 0.6666667 } },
        {"scissors_19", new double[] { 0.333333343, 0.0274019931, 0.443627447, 0.852941155 } },
        {"scissors_20", new double[] { 0.158088237, 0.04047389, 0.6691176, 0.843137264 } },
        {"fork_1", new double[] { 0.145833328, 0.3509314, 0.5894608, 0.238562092 } },
        {"fork_2", new double[] { 0.294117659, 0.216944471, 0.534313738, 0.5980392 } },
        {"fork_3", new double[] { 0.09191177, 0.0682516545, 0.757352948, 0.6143791 } },
        {"fork_4", new double[] { 0.254901975, 0.185898721, 0.5232843, 0.594771266 } },
        {"fork_5", new double[] { 0.2365196, 0.128709182, 0.5845588, 0.71405226 } },
        {"fork_6", new double[] { 0.115196079, 0.133611143, 0.676470637, 0.6993464 } },
        {"fork_7", new double[] { 0.164215669, 0.31008172, 0.767156839, 0.410130739 } },
        {"fork_8", new double[] { 0.118872553, 0.318251669, 0.817401946, 0.225490168 } },
        {"fork_9", new double[] { 0.18259804, 0.2136765, 0.6335784, 0.643790841 } },
        {"fork_10", new double[] { 0.05269608, 0.282303959, 0.8088235, 0.452614367 } },
        {"fork_11", new double[] { 0.05759804, 0.0894935, 0.9007353, 0.3251634 } },
        {"fork_12", new double[] { 0.3345588, 0.07315363, 0.375, 0.9150327 } },
        {"fork_13", new double[] { 0.269607842, 0.194068655, 0.4093137, 0.6732026 } },
        {"fork_14", new double[] { 0.143382356, 0.218578458, 0.7977941, 0.295751631 } },
        {"fork_15", new double[] { 0.19240196, 0.0633497, 0.5710784, 0.8398692 } },
        {"fork_16", new double[] { 0.140931368, 0.480016381, 0.6838235, 0.240196079 } },
        {"fork_17", new double[] { 0.305147052, 0.2512582, 0.4791667, 0.5408496 } },
        {"fork_18", new double[] { 0.234068632, 0.445702642, 0.6127451, 0.344771236 } },
        {"fork_19", new double[] { 0.219362751, 0.141781077, 0.5919118, 0.6683006 } },
        {"fork_20", new double[] { 0.180147052, 0.239820287, 0.6887255, 0.235294119 } }
    };

Poznámka:

Pokud pro vlastní projekty nemáte nástroj klikni a přetáhněte, abyste označili souřadnice oblastí, můžete použít webové uživatelské rozhraní na webu Custom Vision. V tomto příkladu jsou již zadané souřadnice.

Potom se pomocí této mapy přidružení nahrají jednotlivé ukázkové obrázky s odpovídajícími souřadnicemi oblasti. Do jedné dávky můžete nahrát až 64 obrázků. Možná budete muset změnit imagePath hodnotu tak, aby odkazovat na správná umístění složek.

    // Add all images for fork
    var imagePath = Path.Combine("Images", "fork");
    var imageFileEntries = new List<ImageFileCreateEntry>();
    foreach (var fileName in Directory.EnumerateFiles(imagePath))
    {
        var region = fileToRegionMap[Path.GetFileNameWithoutExtension(fileName)];
        imageFileEntries.Add(new ImageFileCreateEntry(fileName, File.ReadAllBytes(fileName), null, new List<Region>(new Region[] { new Region(forkTag.Id, region[0], region[1], region[2], region[3]) })));
    }
    trainingApi.CreateImagesFromFiles(project.Id, new ImageFileCreateBatch(imageFileEntries));

    // Add all images for scissors
    imagePath = Path.Combine("Images", "scissors");
    imageFileEntries = new List<ImageFileCreateEntry>();
    foreach (var fileName in Directory.EnumerateFiles(imagePath))
    {
        var region = fileToRegionMap[Path.GetFileNameWithoutExtension(fileName)];
        imageFileEntries.Add(new ImageFileCreateEntry(fileName, File.ReadAllBytes(fileName), null, new List<Region>(new Region[] { new Region(scissorsTag.Id, region[0], region[1], region[2], region[3]) })));
    }
    trainingApi.CreateImagesFromFiles(project.Id, new ImageFileCreateBatch(imageFileEntries));
}

V tomto okamžiku jste nahráli všechny ukázkové obrázky a označili každý z nich (fork nebo nůžky) s přidruženým obdélníkem pixelů.

Trénování projektu

Tato metoda vytvoří první trénovací iteraci v projektu. Dotazuje se na službu, dokud se trénování nedokončil.

private void TrainProject(CustomVisionTrainingClient trainingApi, Project project)
{

    // Now there are images with tags start training the project
    Console.WriteLine("\tTraining");
    iteration = trainingApi.TrainProject(project.Id);

    // The returned iteration will be in progress, and can be queried periodically to see when it has completed
    while (iteration.Status == "Training")
    {
        Thread.Sleep(1000);

        // Re-query the iteration to get its updated status
        iteration = trainingApi.GetIteration(project.Id, iteration.Id);
    }
}

Tip

Trénovat s vybranými značkami

Volitelně můžete trénovat jenom na podmnožině použitých značek. Můžete to udělat, pokud jste ještě nepoužili dostatek určitých značek, ale máte dostatek dalších. Ve volání TrainProject použijte parametr trainingParameters. Vytvořte TrainingParameters a nastavte jeho Vlastnost SelectedTags na seznam ID značek, které chcete použít. Model bude trénovat tak, aby rozpoznával pouze značky v daném seznamu.

Publikování aktuální iterace

Tato metoda zpřístupňuje aktuální iteraci modelu pro dotazování. Název modelu můžete použít jako odkaz k odesílání žádostí o predikce. Musíte zadat vlastní hodnotu pro predictionResourceId. ID prostředku predikce najdete na kartě Vlastnosti prostředku na webu Azure Portal, který je uvedený jako ID prostředku.

private void PublishIteration(CustomVisionTrainingClient trainingApi, Project project)
{

    // The iteration is now trained. Publish it to the prediction end point.
    var predictionResourceId = Environment.GetEnvironmentVariable("VISION_PREDICTION_RESOURCE_ID");
    trainingApi.PublishIteration(project.Id, iteration.Id, publishedModelName, predictionResourceId);
    Console.WriteLine("Done!\n");
}

Testování koncového bodu předpovědi

Tato metoda načte testovací obrázek, dotáže se koncového bodu modelu a vypíše data předpovědi do konzoly.

private void TestIteration(CustomVisionPredictionClient predictionApi, Project project)
{

    // Make a prediction against the new project
    Console.WriteLine("Making a prediction:");
    var imageFile = Path.Combine("Images", "test", "test_image.jpg");
    using (var stream = File.OpenRead(imageFile))
    {
        var result = predictionApi.DetectImage(project.Id, publishedModelName, stream);

        // Loop over each prediction and write out the results
        foreach (var c in result.Predictions)
        {
            Console.WriteLine($"\t{c.TagName}: {c.Probability:P1} [ {c.BoundingBox.Left}, {c.BoundingBox.Top}, {c.BoundingBox.Width}, {c.BoundingBox.Height} ]");
        }
    }
    Console.ReadKey();
}

Spuštění aplikace

Visual Studio IDE

Spusťte aplikaci kliknutím na tlačítko Ladit v horní části okna integrovaného vývojového prostředí ( IDE).

Rozhraní příkazového řádku

Spusťte aplikaci z adresáře aplikace pomocí dotnet run příkazu.

dotnet run

Když je aplikace spuštěná, mělo by se otevřít okno konzoly s následujícím výstupem:

Creating new project:
        Training
Done!

Making a prediction:
        fork: 98.2% [ 0.111609578, 0.184719115, 0.6607002, 0.6637112 ]
        scissors: 1.2% [ 0.112389535, 0.119195729, 0.658031344, 0.7023591 ]

Pak můžete ověřit správné označení testovacího obrázku (ve složce Images/Test/) a správnost oblasti detekce. V tuto chvíli můžete aplikaci ukončit stisknutím libovolné klávesy.

Vyčištění prostředků

Pokud chcete implementovat vlastní projekt detekce objektů (nebo místo toho vyzkoušet projekt klasifikace obrázků), možná budete chtít odstranit projekt detekce vidliček a nůžek z tohoto příkladu. Bezplatné předplatné umožňuje dva projekty Custom Vision.

Na webu služby Custom Vision přejděte do části Projekty a vyberte ikonu koše pod projektem My New Project.

Další kroky

Teď jste v kódu provedli všechny kroky procesu detekce objektů. Tato ukázka provede jednu iteraci trénování, ale často budete muset model vytrénovat a otestovat několikrát, aby bylo přesnější. Následující příručka se zabývá klasifikací obrázků, ale její principy jsou podobné jako u detekce objektů.

Testování a přetrénování modelu

• Co je Custom Vision?
• Zdrojový kód pro tuto ukázku najdete na GitHubu.
• Referenční dokumentace k sadě SDK

Tato příručka obsahuje pokyny a ukázkový kód, které vám pomůžou začít používat klientskou knihovnu Custom Vision pro Go k vytvoření modelu rozpoznávání objektů. Vytvoříte projekt, přidáte značky, vytrénujete projekt a použijete adresu URL koncového bodu předpovědi projektu k programovému otestování. Tento příklad použijte jako šablonu pro vytvoření vlastní aplikace pro rozpoznávání obrázků.

Poznámka:

Pokud chcete sestavit a vytrénovat model detekce objektů bez psaní kódu, přečtěte si místo toho pokyny založené na prohlížeči.

Pomocí klientské knihovny Služby Custom Vision přejděte na:

• Vytvoření nového projektu Custom Vision
• Přidání značek do projektu
• Nahrání a označení obrázků
• Trénování projektu
• Publikování aktuální iterace
• Testování koncového bodu předpovědi

Referenční dokumentace (trénování) (predikce)

Požadavky

• Předplatné Azure: Můžete si ho vytvořit zdarma.
• Go 1.8+
• Jakmile budete mít předplatné Azure, vytvořte na webu Azure Portal prostředek Custom Vision, abyste vytvořili prostředek pro trénování a predikci.
  • K vyzkoušení služby můžete použít cenovou úroveňF0 Free a později upgradovat na placenou úroveň pro produkční prostředí.

Vytvoření proměnných prostředí

V tomto příkladu napíšete přihlašovací údaje do proměnných prostředí na místním počítači, na kterém běží aplikace.

Přejděte na Azure Portal. Pokud se prostředky Služby Custom Vision, které jste vytvořili v části Požadavky, úspěšně nasadíte, vyberte tlačítko Přejít k prostředku v části Další kroky. Klíče a koncové body najdete na stránkách klíčů a koncových bodů prostředků v části Správa prostředků. Budete muset získat klíče pro váš trénovací prostředek i prostředek predikce spolu s koncovými body rozhraní API.

ID prediktivního prostředku najdete na kartě Vlastnosti prediktivního prostředku na webu Azure Portal, který je uvedený jako ID prostředku.

Tip

Tyto https://www.customvision.ai hodnoty získáte také pomocí těchto hodnot. Po přihlášení vyberte ikonu Nastavení v pravém horním rohu. Na stránkách Nastavení můžete zobrazit všechny klíče, ID prostředku a koncové body.

Pokud chcete nastavit proměnné prostředí, otevřete okno konzoly a postupujte podle pokynů pro operační systém a vývojové prostředí.

• Pokud chcete nastavit proměnnou VISION_TRAINING KEY prostředí, nahraďte <your-training-key> jedním z klíčů vašeho trénovacího prostředku.
• Pokud chcete nastavit proměnnou VISION_TRAINING_ENDPOINT prostředí, nahraďte <your-training-endpoint> koncovým bodem vašeho trénovacího prostředku.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_KEY prostředí, nahraďte <your-prediction-key> jedním z klíčů pro prostředek předpovědi.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_ENDPOINT prostředí, nahraďte <your-prediction-endpoint> koncový bod pro prostředek predikce.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_RESOURCE_ID prostředí, nahraďte <your-resource-id> ID prostředku pro prostředek predikce.

Důležité

Pokud používáte klíč rozhraní API, uložte ho bezpečně někam jinam, například ve službě Azure Key Vault. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně.

Další informace o zabezpečení služeb AI najdete v tématu Ověřování požadavků na služby Azure AI.

Windows

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Po přidání proměnných prostředí možná budete muset restartovat všechny spuštěné programy, které čtou proměnné prostředí, včetně okna konzoly.

Linux

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Po přidání proměnných prostředí spusťte source ~/.bashrc z okna konzoly, aby změny byly efektivní.

Nastavení

Instalace klientské knihovny Služby Custom Vision

Pokud chcete napsat aplikaci pro analýzu obrázků pomocí služby Custom Vision for Go, budete potřebovat klientskou knihovnu služby Custom Vision. V PowerShellu spusťte následující příkaz:

go get -u github.com/Azure/azure-sdk-for-go/...

nebo pokud používáte dep, spusťte v úložišti:

dep ensure -add github.com/Azure/azure-sdk-for-go

Získání ukázkových obrázků

Tento příklad používá image z úložiště ukázek sady Python SDK služby Azure AI na GitHubu. Naklonujte nebo si stáhněte toto úložiště do svého vývojového prostředí. Umístění složky si zapamatujte pro pozdější krok.

Vytvoření projektu Custom Vision

V upřednostňovaném adresáři projektu vytvořte nový soubor s názvem sample.go a otevřete ho v preferovaném editoru kódu.

Přidáním následujícího kódu do svého skriptu vytvořte nový projekt služby Custom Vision.

Podívejte se na metodu CreateProject k určení dalších možností při vytváření projektu (vysvětlení v průvodci sestavením detektoru webového portálu).

import(
    "context"
    "bytes"
    "fmt"
    "io/ioutil"
    "path"
    "log"
    "time"
    "github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v3.0/customvision/training"
    "github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v3.0/customvision/prediction"
)

// retrieve environment variables:
var (
    training_key string = os.Getenv("VISION_TRAINING_KEY")
    prediction_key string = os.Getenv("VISION_PREDICTION_KEY")
    prediction_resource_id = os.Getenv("VISION_PREDICTION_RESOURCE_ID")
    endpoint string = os.Getenv("VISION_ENDPOINT")
   
    project_name string = "Go Sample OD Project"
    iteration_publish_name = "detectModel"
    sampleDataDirectory = "<path to sample images>"
)

func main() {
    fmt.Println("Creating project...")

    ctx = context.Background()

    trainer := training.New(training_key, endpoint)

    var objectDetectDomain training.Domain
    domains, _ := trainer.GetDomains(ctx)

    for _, domain := range *domains.Value {
        fmt.Println(domain, domain.Type)
        if domain.Type == "ObjectDetection" && *domain.Name == "General" {
            objectDetectDomain = domain
            break
        }
    }
    fmt.Println("Creating project...")
    project, _ := trainer.CreateProject(ctx, project_name, "", objectDetectDomain.ID, "")

Vytvoření značek v projektu

Pokud chcete vytvořit značky klasifikace do projektu, přidejte na konec souboru sample.go následující kód:

# Make two tags in the new project
forkTag, _ := trainer.CreateTag(ctx, *project.ID, "fork", "A fork", string(training.Regular))
scissorsTag, _ := trainer.CreateTag(ctx, *project.ID, "scissors", "Pair of scissors", string(training.Regular))

Nahrání a označení obrázků

Při označování obrázků v projektech detekce obrázků je potřeba zadat oblast každého označeného objektu pomocí normalizovaných souřadnic.

Poznámka:

Pokud nemáte nástroj pro kliknutí a přetažení k označení souřadnic oblastí, můžete použít webové uživatelské rozhraní na Customvision.ai. V tomto příkladu jsou již zadané souřadnice.

Obrázky, značky a oblasti do projektu přidáte tak, že po vytvoření značky vložíte následující kód. Všimněte si, že v tomto kurzu jsou oblasti pevně zakódované jako vložené. Oblasti určují ohraničující rámeček s normalizovanými souřadnicemi, které jsou v tomto pořadí: vlevo, nahoře, šířka, výška.

forkImageRegions := map[string][4]float64{
    "fork_1.jpg": [4]float64{ 0.145833328, 0.3509314, 0.5894608, 0.238562092 },
    "fork_2.jpg": [4]float64{ 0.294117659, 0.216944471, 0.534313738, 0.5980392 },
    "fork_3.jpg": [4]float64{ 0.09191177, 0.0682516545, 0.757352948, 0.6143791 },
    "fork_4.jpg": [4]float64{ 0.254901975, 0.185898721, 0.5232843, 0.594771266 },
    "fork_5.jpg": [4]float64{ 0.2365196, 0.128709182, 0.5845588, 0.71405226 },
    "fork_6.jpg": [4]float64{ 0.115196079, 0.133611143, 0.676470637, 0.6993464 },
    "fork_7.jpg": [4]float64{ 0.164215669, 0.31008172, 0.767156839, 0.410130739 },
    "fork_8.jpg": [4]float64{ 0.118872553, 0.318251669, 0.817401946, 0.225490168 },
    "fork_9.jpg": [4]float64{ 0.18259804, 0.2136765, 0.6335784, 0.643790841 },
    "fork_10.jpg": [4]float64{ 0.05269608, 0.282303959, 0.8088235, 0.452614367 },
    "fork_11.jpg": [4]float64{ 0.05759804, 0.0894935, 0.9007353, 0.3251634 },
    "fork_12.jpg": [4]float64{ 0.3345588, 0.07315363, 0.375, 0.9150327 },
    "fork_13.jpg": [4]float64{ 0.269607842, 0.194068655, 0.4093137, 0.6732026 },
    "fork_14.jpg": [4]float64{ 0.143382356, 0.218578458, 0.7977941, 0.295751631 },
    "fork_15.jpg": [4]float64{ 0.19240196, 0.0633497, 0.5710784, 0.8398692 },
    "fork_16.jpg": [4]float64{ 0.140931368, 0.480016381, 0.6838235, 0.240196079 },
    "fork_17.jpg": [4]float64{ 0.305147052, 0.2512582, 0.4791667, 0.5408496 },
    "fork_18.jpg": [4]float64{ 0.234068632, 0.445702642, 0.6127451, 0.344771236 },
    "fork_19.jpg": [4]float64{ 0.219362751, 0.141781077, 0.5919118, 0.6683006 },
    "fork_20.jpg": [4]float64{ 0.180147052, 0.239820287, 0.6887255, 0.235294119 },
}

scissorsImageRegions := map[string][4]float64{
    "scissors_1.jpg": [4]float64{ 0.4007353, 0.194068655, 0.259803921, 0.6617647 },
    "scissors_2.jpg": [4]float64{ 0.426470578, 0.185898721, 0.172794119, 0.5539216 },
    "scissors_3.jpg": [4]float64{ 0.289215684, 0.259428144, 0.403186262, 0.421568632 },
    "scissors_4.jpg": [4]float64{ 0.343137264, 0.105833367, 0.332107842, 0.8055556 },
    "scissors_5.jpg": [4]float64{ 0.3125, 0.09766343, 0.435049027, 0.71405226 },
    "scissors_6.jpg": [4]float64{ 0.379901975, 0.24308826, 0.32107842, 0.5718954 },
    "scissors_7.jpg": [4]float64{ 0.341911763, 0.20714055, 0.3137255, 0.6356209 },
    "scissors_8.jpg": [4]float64{ 0.231617644, 0.08459154, 0.504901946, 0.8480392 },
    "scissors_9.jpg": [4]float64{ 0.170343131, 0.332957536, 0.767156839, 0.403594762 },
    "scissors_10.jpg": [4]float64{ 0.204656869, 0.120539248, 0.5245098, 0.743464053 },
    "scissors_11.jpg": [4]float64{ 0.05514706, 0.159754932, 0.799019635, 0.730392158 },
    "scissors_12.jpg": [4]float64{ 0.265931368, 0.169558853, 0.5061275, 0.606209159 },
    "scissors_13.jpg": [4]float64{ 0.241421565, 0.184264734, 0.448529422, 0.6830065 },
    "scissors_14.jpg": [4]float64{ 0.05759804, 0.05027781, 0.75, 0.882352948 },
    "scissors_15.jpg": [4]float64{ 0.191176474, 0.169558853, 0.6936275, 0.6748366 },
    "scissors_16.jpg": [4]float64{ 0.1004902, 0.279036, 0.6911765, 0.477124184 },
    "scissors_17.jpg": [4]float64{ 0.2720588, 0.131977156, 0.4987745, 0.6911765 },
    "scissors_18.jpg": [4]float64{ 0.180147052, 0.112369314, 0.6262255, 0.6666667 },
    "scissors_19.jpg": [4]float64{ 0.333333343, 0.0274019931, 0.443627447, 0.852941155 },
    "scissors_20.jpg": [4]float64{ 0.158088237, 0.04047389, 0.6691176, 0.843137264 },
}

Pak pomocí této mapy přidružení nahrajte každý ukázkový obrázek se souřadnicemi oblasti (v jedné dávce můžete nahrát až 64 obrázků). Přidejte následující kód.

Poznámka:

Budete muset změnit cestu k imagím na základě toho, kam jste si stáhli projekt Ukázek sady Sdk pro Azure AI.

// Go through the data table above and create the images
fmt.Println("Adding images...")
var fork_images []training.ImageFileCreateEntry
for file, region := range forkImageRegions {
    imageFile, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "fork", file))

    regiontest := forkImageRegions[file]
    imageRegion := training.Region{
        TagID:  forkTag.ID,
        Left:   &regiontest[0],
        Top:    &regiontest[1],
        Width:  &regiontest[2],
        Height: &regiontest[3],
    }
    var fileName string = file

    fork_images = append(fork_images, training.ImageFileCreateEntry{
        Name:     &fileName,
        Contents: &imageFile,
        Regions:  &[]training.Region{imageRegion}
    })
}
    
fork_batch, _ := trainer.CreateImagesFromFiles(ctx, *project.ID, training.ImageFileCreateBatch{ 
    Images: &fork_images,
})

if (!*fork_batch.IsBatchSuccessful) {
    fmt.Println("Batch upload failed.")
}

var scissor_images []training.ImageFileCreateEntry
for file, region := range scissorsImageRegions {
    imageFile, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "scissors", file))

    imageRegion := training.Region { 
        TagID:scissorsTag.ID,
        Left:&region[0],
        Top:&region[1],
        Width:&region[2],
        Height:&region[3],
    }

    scissor_images = append(scissor_images, training.ImageFileCreateEntry {
        Name: &file,
        Contents: &imageFile,
        Regions: &[]training.Region{ imageRegion },
    })
}
    
scissor_batch, _ := trainer.CreateImagesFromFiles(ctx, *project.ID, training.ImageFileCreateBatch{ 
    Images: &scissor_images,
})
    
if (!*scissor_batch.IsBatchSuccessful) {
    fmt.Println("Batch upload failed.")
}     

Trénujte a publikujte projekt.

Tento kód vytvoří první iteraci prediktivního modelu a pak tuto iteraci publikuje do koncového bodu předpovědi. Název předaný publikované iteraci se dá použít k odesílání žádostí o predikci. Iterace není v koncovém bodu předpovědi dostupná, dokud nebude publikovaná.

iteration, _ := trainer.TrainProject(ctx, *project.ID)
fmt.Println("Training status:", *iteration.Status)
for {
    if *iteration.Status != "Training" {
        break
    }
    time.Sleep(5 * time.Second)
    iteration, _ = trainer.GetIteration(ctx, *project.ID, *iteration.ID)
    fmt.Println("Training status:", *iteration.Status)
}

trainer.PublishIteration(ctx, *project.ID, *iteration.ID, iteration_publish_name, prediction_resource_id))

Použití koncového bodu předpovědi

Pokud chcete odeslat obrázek do koncového bodu předpovědi a načíst předpověď, přidejte na konec souboru následující kód:

    fmt.Println("Predicting...")
    predictor := prediction.New(prediction_key, endpoint)

    testImageData, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "Test", "test_od_image.jpg"))
    results, _ := predictor.DetectImage(ctx, *project.ID, iteration_publish_name, ioutil.NopCloser(bytes.NewReader(testImageData)), "")

    for _, prediction := range *results.Predictions    {
        boundingBox := *prediction.BoundingBox

        fmt.Printf("\t%s: %.2f%% (%.2f, %.2f, %.2f, %.2f)", 
            *prediction.TagName,
            *prediction.Probability * 100,
            *boundingBox.Left,
            *boundingBox.Top,
            *boundingBox.Width,
            *boundingBox.Height)
        fmt.Println("")
    }
}

Spuštění aplikace

Spusťte sample.go.

go run sample.go

V konzole by se měl zobrazit výstup aplikace. Pak můžete ověřit správné označení testovacího obrázku (ve složce samples/vision/images/Test) a správnost oblasti detekce.

Vyčištění prostředků

Pokud chcete implementovat vlastní projekt detekce objektů (nebo místo toho vyzkoušet projekt klasifikace obrázků), možná budete chtít odstranit projekt detekce vidliček a nůžek z tohoto příkladu. Bezplatné předplatné umožňuje dva projekty Custom Vision.

Na webu služby Custom Vision přejděte do části Projekty a vyberte ikonu koše pod projektem My New Project.

Další kroky

Teď jste v kódu provedli všechny kroky procesu detekce objektů. Tato ukázka provede jednu iteraci trénování, ale často budete muset model vytrénovat a otestovat několikrát, aby bylo přesnější. Následující příručka se zabývá klasifikací obrázků, ale její principy jsou podobné jako u detekce objektů.

Testování a přetrénování modelu

• Co je Custom Vision?
• Referenční dokumentace k sadě SDK (školení)
• Referenční dokumentace k sadě SDK (předpověď)

Začněte používat klientskou knihovnu Custom Vision pro Javu k vytvoření modelu rozpoznávání objektů. Podle těchto kroků nainstalujte balíček a vyzkoušejte ukázkový kód pro základní úlohy. Tento příklad použijte jako šablonu pro vytvoření vlastní aplikace pro rozpoznávání obrázků.

Poznámka:

Pokud chcete sestavit a vytrénovat model detekce objektů bez psaní kódu, přečtěte si místo toho pokyny založené na prohlížeči.

Pomocí klientské knihovny Custom Vision pro Javu můžete:

• Vytvoření nového projektu Custom Vision
• Přidání značek do projektu
• Nahrání a označení obrázků
• Trénování projektu
• Publikování aktuální iterace
• Testování koncového bodu předpovědi

Referenční dokumentace | Zdrojový kód knihovny (trénování) (predikce)| Artefakt (Maven) (trénování) (predikce) | Ukázky

Požadavky

• Předplatné Azure – Vytvoření předplatného zdarma
• Aktuální verze sady Java Development Kit(JDK)
• Nástroj sestavení Gradle nebo jiný správce závislostí.
• Jakmile budete mít předplatné Azure, vytvořte na webu Azure Portal prostředek Custom Vision, abyste vytvořili prostředek pro trénování a predikci.
  • K vyzkoušení služby můžete použít cenovou úroveňF0 Free a později upgradovat na placenou úroveň pro produkční prostředí.

Vytvoření proměnných prostředí

V tomto příkladu napíšete přihlašovací údaje do proměnných prostředí na místním počítači, na kterém běží aplikace.

Přejděte na Azure Portal. Pokud se prostředky Služby Custom Vision, které jste vytvořili v části Požadavky, úspěšně nasadíte, vyberte tlačítko Přejít k prostředku v části Další kroky. Klíče a koncové body najdete na stránkách klíčů a koncových bodů prostředků v části Správa prostředků. Budete muset získat klíče pro váš trénovací prostředek i prostředek predikce spolu s koncovými body rozhraní API.

ID prediktivního prostředku najdete na kartě Vlastnosti prediktivního prostředku na webu Azure Portal, který je uvedený jako ID prostředku.

Tip

Tyto https://www.customvision.ai hodnoty získáte také pomocí těchto hodnot. Po přihlášení vyberte ikonu Nastavení v pravém horním rohu. Na stránkách Nastavení můžete zobrazit všechny klíče, ID prostředku a koncové body.

Pokud chcete nastavit proměnné prostředí, otevřete okno konzoly a postupujte podle pokynů pro operační systém a vývojové prostředí.

• Pokud chcete nastavit proměnnou VISION_TRAINING KEY prostředí, nahraďte <your-training-key> jedním z klíčů vašeho trénovacího prostředku.
• Pokud chcete nastavit proměnnou VISION_TRAINING_ENDPOINT prostředí, nahraďte <your-training-endpoint> koncovým bodem vašeho trénovacího prostředku.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_KEY prostředí, nahraďte <your-prediction-key> jedním z klíčů pro prostředek předpovědi.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_ENDPOINT prostředí, nahraďte <your-prediction-endpoint> koncový bod pro prostředek predikce.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_RESOURCE_ID prostředí, nahraďte <your-resource-id> ID prostředku pro prostředek predikce.

Důležité

Pokud používáte klíč rozhraní API, uložte ho bezpečně někam jinam, například ve službě Azure Key Vault. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně.

Další informace o zabezpečení služeb AI najdete v tématu Ověřování požadavků na služby Azure AI.

Windows

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Po přidání proměnných prostředí možná budete muset restartovat všechny spuštěné programy, které čtou proměnné prostředí, včetně okna konzoly.

Linux

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Po přidání proměnných prostředí spusťte source ~/.bashrc z okna konzoly, aby změny byly efektivní.

Nastavení

Vytvoření nového projektu Gradle

V okně konzoly (například cmd, PowerShell nebo Bash) vytvořte pro vaši aplikaci nový adresář a přejděte do něj.

mkdir myapp && cd myapp

gradle init Spusťte příkaz z pracovního adresáře. Tento příkaz vytvoří základní soubory sestavení pro Gradle, včetně build.gradle.kts, které se používají za běhu k vytvoření a konfiguraci aplikace.

gradle init --type basic

Po zobrazení výzvy k výběru DSL vyberte Kotlin.

Instalace klientské knihovny

Vyhledejte build.gradle.kts a otevřete ho pomocí preferovaného integrovaného vývojového prostředí (IDE) nebo textového editoru. Pak zkopírujte následující konfiguraci sestavení. Tato konfigurace definuje projekt jako aplikaci Java, jejíž vstupním bodem je třída CustomVisionQuickstart. Importuje knihovny Custom Vision.

plugins {
    java
    application
}
application { 
    mainClassName = "CustomVisionQuickstart"
}
repositories {
    mavenCentral()
}
dependencies {
    compile(group = "com.azure", name = "azure-cognitiveservices-customvision-training", version = "1.1.0-preview.2")
    compile(group = "com.azure", name = "azure-cognitiveservices-customvision-prediction", version = "1.1.0-preview.2")
}

Vytvoření souboru Java

Spuštěním následujícího příkazu z pracovního adresáře vytvořte zdrojovou složku projektu:

mkdir -p src/main/java

Přejděte do nové složky a vytvořte soubor s názvem CustomVisionQuickstart.java. Otevřete ho v preferovaném editoru nebo integrovaném vývojovém prostředí a přidejte následující import příkazy:

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;

import com.google.common.io.ByteStreams;

import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Classifier;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Domain;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.DomainType;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.ImageFileCreateBatch;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.ImageFileCreateEntry;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Iteration;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Project;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Region;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.TrainProjectOptionalParameter;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.CustomVisionTrainingClient;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.Trainings;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.CustomVisionTrainingManager;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.models.ImagePrediction;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.models.Prediction;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.CustomVisionPredictionClient;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.CustomVisionPredictionManager;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Tag;

Tip

Chcete zobrazit celý soubor s kódem rychlého startu najednou? Soubor s příklady kódu v tomto rychlém startu najdete na GitHubu.

Ve třídě CustomVisionQuickstart aplikace vytvořte proměnné, které načítají klíče a koncový bod vašeho prostředku z proměnných prostředí.

// retrieve environment variables
final static String trainingApiKey = System.getenv("VISION_TRAINING_KEY");
final static String trainingEndpoint = System.getenv("VISION_TRAINING_ENDPOINT");
final static String predictionApiKey = System.getenv("VISION_PREDICTION_KEY");
final static String predictionEndpoint = System.getenv("VISION_PREDICTION_ENDPOINT");
final static String predictionResourceId = System.getenv("VISION_PREDICTION_RESOURCE_ID");

V hlavní metodě aplikace přidejte volání metod použitých v tomto rychlém startu. Tyto údaje definujete později.

Project projectOD = createProjectOD(trainClient);
addTagsOD(trainClient, projectOD);
uploadImagesOD(trainClient, projectOD);
trainProjectOD(trainClient, projectOD);
publishIterationOD(trainClient, project);
testProjectOD(predictor, projectOD);

Objektový model

Následující třídy a rozhraní zpracovávají některé z hlavních funkcí klientské knihovny Custom Vision v Javě.

Název	Popis
CustomVisionTrainingClient	Tato třída zpracovává vytváření, trénování a publikování modelů.
CustomVisionPredictionClient	Tato třída zpracovává dotazování modelů na predikce detekce objektů.
ImagePrediction	Tato třída definuje jednu předpověď objektu na jednom obrázku. Obsahuje vlastnosti ID a názvu objektu, umístění ohraničujícího rámečku objektu a skóre spolehlivosti.

Příklady kódu

Tyto fragmenty kódu ukazují, jak provádět následující úlohy s klientskou knihovnou Custom Vision pro Javu:

• Ověření klienta
• Vytvoření nového projektu Custom Vision
• Přidání značek do projektu
• Nahrání a označování obrázků
• Trénovat projekt
• Publikování aktuální iterace
• Testování koncového bodu předpovědi

Ověření klienta

V hlavní metodě vytvořte instanci trénovacích a prediktivních klientů pomocí koncového bodu a klíčů.

// Authenticate
CustomVisionTrainingClient trainClient = CustomVisionTrainingManager
        .authenticate(trainingEndpoint, trainingApiKey)
        .withEndpoint(trainingEndpoint);
CustomVisionPredictionClient predictor = CustomVisionPredictionManager
        .authenticate(predictionEndpoint, predictionApiKey)
        .withEndpoint(predictionEndpoint);

Vytvoření nového projektu Custom Vision

Tato další metoda vytvoří projekt detekce objektů. Vytvořený projekt se zobrazí na webu služby Custom Vision, který jste navštívili dříve. Podívejte se na přetížení Metody CreateProject určit další možnosti při vytváření projektu (vysvětlení v průvodci sestavením detektoru webového portálu).

public static Project createProjectOD(CustomVisionTrainingClient trainClient) {
    Trainings trainer = trainClient.trainings();

    // find the object detection domain to set the project type
    Domain objectDetectionDomain = null;
    List<Domain> domains = trainer.getDomains();
    for (final Domain domain : domains) {
        if (domain.type() == DomainType.OBJECT_DETECTION) {
            objectDetectionDomain = domain;
            break;
        }
    }

    if (objectDetectionDomain == null) {
        System.out.println("Unexpected result; no objects were detected.");
    }

    System.out.println("Creating project...");
    // create an object detection project
    Project project = trainer.createProject().withName("Sample Java OD Project")
            .withDescription("Sample OD Project").withDomainId(objectDetectionDomain.id())
            .withClassificationType(Classifier.MULTILABEL.toString()).execute();

    return project;
}

Přidání značek do projektu

Tato metoda definuje značky, na které model natrénujete.

public static void addTagsOD(CustomVisionTrainingClient trainClient, Project project) {
    Trainings trainer = trainClient.trainings();
    // create fork tag
    Tag forkTag = trainer.createTag().withProjectId(project.id()).withName("fork").execute();

    // create scissors tag
    Tag scissorsTag = trainer.createTag().withProjectId(project.id()).withName("scissor").execute();
}

Nahrání a označení obrázků

Nejprve si stáhněte ukázkové obrázky pro tento projekt. Uložte obsah ukázkové složky Obrázky do místního zařízení.

Poznámka:

Potřebujete k dokončení trénování širší sadu obrázků? Trove, projekt Microsoft Garage, umožňuje shromažďovat a nakupovat sady obrázků pro účely trénování. Jakmile shromáždíte obrázky, můžete si je stáhnout a pak je importovat do projektu Custom Vision obvyklým způsobem. Další informace najdete na stránce Trove.

Při označování obrázků v projektech detekce obrázků je potřeba zadat oblast každého označeného objektu pomocí normalizovaných souřadnic. Následující kód přidruží jednotlivé ukázkové obrázky k odpovídající označené oblasti.

Poznámka:

Pokud nemáte nástroj pro kliknutí a přetažení k označení souřadnic oblastí, můžete použít webové uživatelské rozhraní na Customvision.ai. V tomto příkladu jsou již zadané souřadnice.

public static void uploadImagesOD(CustomVisionTrainingClient trainClient, Project project) {
    // Mapping of filenames to their respective regions in the image. The
    // coordinates are specified
    // as left, top, width, height in normalized coordinates. I.e. (left is left in
    // pixels / width in pixels)

    // This is a hardcoded mapping of the files we'll upload along with the bounding
    // box of the object in the
    // image. The boudning box is specified as left, top, width, height in
    // normalized coordinates.
    // Normalized Left = Left / Width (in Pixels)
    // Normalized Top = Top / Height (in Pixels)
    // Normalized Bounding Box Width = (Right - Left) / Width (in Pixels)
    // Normalized Bounding Box Height = (Bottom - Top) / Height (in Pixels)
    HashMap<String, double[]> regionMap = new HashMap<String, double[]>();
    regionMap.put("scissors_1.jpg", new double[] { 0.4007353, 0.194068655, 0.259803921, 0.6617647 });
    regionMap.put("scissors_2.jpg", new double[] { 0.426470578, 0.185898721, 0.172794119, 0.5539216 });
    regionMap.put("scissors_3.jpg", new double[] { 0.289215684, 0.259428144, 0.403186262, 0.421568632 });
    regionMap.put("scissors_4.jpg", new double[] { 0.343137264, 0.105833367, 0.332107842, 0.8055556 });
    regionMap.put("scissors_5.jpg", new double[] { 0.3125, 0.09766343, 0.435049027, 0.71405226 });
    regionMap.put("scissors_6.jpg", new double[] { 0.379901975, 0.24308826, 0.32107842, 0.5718954 });
    regionMap.put("scissors_7.jpg", new double[] { 0.341911763, 0.20714055, 0.3137255, 0.6356209 });
    regionMap.put("scissors_8.jpg", new double[] { 0.231617644, 0.08459154, 0.504901946, 0.8480392 });
    regionMap.put("scissors_9.jpg", new double[] { 0.170343131, 0.332957536, 0.767156839, 0.403594762 });
    regionMap.put("scissors_10.jpg", new double[] { 0.204656869, 0.120539248, 0.5245098, 0.743464053 });
    regionMap.put("scissors_11.jpg", new double[] { 0.05514706, 0.159754932, 0.799019635, 0.730392158 });
    regionMap.put("scissors_12.jpg", new double[] { 0.265931368, 0.169558853, 0.5061275, 0.606209159 });
    regionMap.put("scissors_13.jpg", new double[] { 0.241421565, 0.184264734, 0.448529422, 0.6830065 });
    regionMap.put("scissors_14.jpg", new double[] { 0.05759804, 0.05027781, 0.75, 0.882352948 });
    regionMap.put("scissors_15.jpg", new double[] { 0.191176474, 0.169558853, 0.6936275, 0.6748366 });
    regionMap.put("scissors_16.jpg", new double[] { 0.1004902, 0.279036, 0.6911765, 0.477124184 });
    regionMap.put("scissors_17.jpg", new double[] { 0.2720588, 0.131977156, 0.4987745, 0.6911765 });
    regionMap.put("scissors_18.jpg", new double[] { 0.180147052, 0.112369314, 0.6262255, 0.6666667 });
    regionMap.put("scissors_19.jpg", new double[] { 0.333333343, 0.0274019931, 0.443627447, 0.852941155 });
    regionMap.put("scissors_20.jpg", new double[] { 0.158088237, 0.04047389, 0.6691176, 0.843137264 });
    regionMap.put("fork_1.jpg", new double[] { 0.145833328, 0.3509314, 0.5894608, 0.238562092 });
    regionMap.put("fork_2.jpg", new double[] { 0.294117659, 0.216944471, 0.534313738, 0.5980392 });
    regionMap.put("fork_3.jpg", new double[] { 0.09191177, 0.0682516545, 0.757352948, 0.6143791 });
    regionMap.put("fork_4.jpg", new double[] { 0.254901975, 0.185898721, 0.5232843, 0.594771266 });
    regionMap.put("fork_5.jpg", new double[] { 0.2365196, 0.128709182, 0.5845588, 0.71405226 });
    regionMap.put("fork_6.jpg", new double[] { 0.115196079, 0.133611143, 0.676470637, 0.6993464 });
    regionMap.put("fork_7.jpg", new double[] { 0.164215669, 0.31008172, 0.767156839, 0.410130739 });
    regionMap.put("fork_8.jpg", new double[] { 0.118872553, 0.318251669, 0.817401946, 0.225490168 });
    regionMap.put("fork_9.jpg", new double[] { 0.18259804, 0.2136765, 0.6335784, 0.643790841 });
    regionMap.put("fork_10.jpg", new double[] { 0.05269608, 0.282303959, 0.8088235, 0.452614367 });
    regionMap.put("fork_11.jpg", new double[] { 0.05759804, 0.0894935, 0.9007353, 0.3251634 });
    regionMap.put("fork_12.jpg", new double[] { 0.3345588, 0.07315363, 0.375, 0.9150327 });
    regionMap.put("fork_13.jpg", new double[] { 0.269607842, 0.194068655, 0.4093137, 0.6732026 });
    regionMap.put("fork_14.jpg", new double[] { 0.143382356, 0.218578458, 0.7977941, 0.295751631 });
    regionMap.put("fork_15.jpg", new double[] { 0.19240196, 0.0633497, 0.5710784, 0.8398692 });
    regionMap.put("fork_16.jpg", new double[] { 0.140931368, 0.480016381, 0.6838235, 0.240196079 });
    regionMap.put("fork_17.jpg", new double[] { 0.305147052, 0.2512582, 0.4791667, 0.5408496 });
    regionMap.put("fork_18.jpg", new double[] { 0.234068632, 0.445702642, 0.6127451, 0.344771236 });
    regionMap.put("fork_19.jpg", new double[] { 0.219362751, 0.141781077, 0.5919118, 0.6683006 });
    regionMap.put("fork_20.jpg", new double[] { 0.180147052, 0.239820287, 0.6887255, 0.235294119 });

Další blok kódu přidá obrázky do projektu. Budete muset změnit argumenty GetImage volání tak, aby ukazovaly na umístění složek forku a nůžek , které jste stáhli.

    Trainings trainer = trainClient.trainings();

    System.out.println("Adding images...");
    for (int i = 1; i <= 20; i++) {
        String fileName = "fork_" + i + ".jpg";
        byte[] contents = GetImage("/fork", fileName);
        AddImageToProject(trainer, project, fileName, contents, forkTag.id(), regionMap.get(fileName));
    }

    for (int i = 1; i <= 20; i++) {
        String fileName = "scissors_" + i + ".jpg";
        byte[] contents = GetImage("/scissors", fileName);
        AddImageToProject(trainer, project, fileName, contents, scissorsTag.id(), regionMap.get(fileName));
    }
}

Předchozí fragment kódu využívá dvě pomocné funkce, které načítají obrázky jako streamy prostředků a nahrávají je do služby (v jedné dávce můžete nahrát až 64 obrázků). Definujte tyto metody.

private static void AddImageToProject(Trainings trainer, Project project, String fileName, byte[] contents,
        UUID tag, double[] regionValues) {
    System.out.println("Adding image: " + fileName);
    ImageFileCreateEntry file = new ImageFileCreateEntry().withName(fileName).withContents(contents);

    ImageFileCreateBatch batch = new ImageFileCreateBatch().withImages(Collections.singletonList(file));

    // If Optional region is specified, tack it on and place the tag there,
    // otherwise
    // add it to the batch.
    if (regionValues != null) {
        Region region = new Region().withTagId(tag).withLeft(regionValues[0]).withTop(regionValues[1])
                .withWidth(regionValues[2]).withHeight(regionValues[3]);
        file = file.withRegions(Collections.singletonList(region));
    } else {
        batch = batch.withTagIds(Collections.singletonList(tag));
    }

    trainer.createImagesFromFiles(project.id(), batch);
}

private static byte[] GetImage(String folder, String fileName) {
    try {
        return ByteStreams.toByteArray(CustomVisionSamples.class.getResourceAsStream(folder + "/" + fileName));
    } catch (Exception e) {
        System.out.println(e.getMessage());
        e.printStackTrace();
    }
    return null;
}

Trénování projektu

Tato metoda vytvoří první trénovací iteraci v projektu. Dotazuje se na službu, dokud se trénování nedokončil.

public static String trainProjectOD(CustomVisionTrainingClient trainClient, Project project) {
    Trainings trainer = trainClient.trainings();
    System.out.println("Training...");
    Iteration iteration = trainer.trainProject(project.id(), new TrainProjectOptionalParameter());

    while (iteration.status().equals("Training")) {
        System.out.println("Training Status: " + iteration.status());
        Thread.sleep(5000);
        iteration = trainer.getIteration(project.id(), iteration.id());
    }
    System.out.println("Training Status: " + iteration.status());
}

Publikování aktuální iterace

Tato metoda zpřístupňuje aktuální iteraci modelu pro dotazování. Název modelu můžete použít jako odkaz k odesílání žádostí o predikce. Musíte zadat vlastní hodnotu pro predictionResourceId. ID prostředku predikce najdete na kartě Vlastnosti prostředku na webu Azure Portal, který je uvedený jako ID prostředku.

public static String publishIterationOD(CustomVisionTrainingClient trainClient, Project project) {
    Trainings trainer = trainClient.trainings();

    // The iteration is now trained. Publish it to the prediction endpoint.
    String publishedModelName = "myModel";
    String predictionID = "<your-prediction-resource-ID>";
    trainer.publishIteration(project.id(), iteration.id(), publishedModelName, predictionID);
    return publishedModelName;
}

Testování koncového bodu předpovědi

Tato metoda načte testovací obrázek, dotáže se koncového bodu modelu a vypíše data předpovědi do konzoly.

public static void testProjectOD(CustomVisionPredictionClient predictor, Project project) {

    // load test image
    byte[] testImage = GetImage("/ObjectTest", "test_image.jpg");

    // predict
    ImagePrediction results = predictor.predictions().detectImage().withProjectId(project.id())
            .withPublishedName(publishedModelName).withImageData(testImage).execute();

    for (Prediction prediction : results.predictions()) {
        System.out.println(String.format("\t%s: %.2f%% at: %.2f, %.2f, %.2f, %.2f", prediction.tagName(),
                prediction.probability() * 100.0f, prediction.boundingBox().left(), prediction.boundingBox().top(),
                prediction.boundingBox().width(), prediction.boundingBox().height()));
    }
}

Spuštění aplikace

Aplikaci můžete sestavit pomocí následujících:

gradle build

Spusťte aplikaci pomocí gradle run příkazu:

gradle run

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné služeb Azure AI, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Pokud chcete implementovat vlastní projekt detekce objektů (nebo místo toho vyzkoušet projekt klasifikace obrázků), možná budete chtít odstranit projekt detekce vidliček a nůžek z tohoto příkladu. Bezplatné předplatné umožňuje dva projekty Custom Vision.

Na webu služby Custom Vision přejděte do části Projekty a vyberte ikonu koše pod projektem My New Project.

Další kroky

Teď jste v kódu provedli všechny kroky procesu detekce objektů. Tato ukázka provede jednu iteraci trénování, ale často budete muset model vytrénovat a otestovat několikrát, aby bylo přesnější. Následující příručka se zabývá klasifikací obrázků, ale její principy jsou podobné jako u detekce objektů.

Testování a přetrénování modelu

• Co je Custom Vision?
• Zdrojový kód pro tuto ukázku najdete na GitHubu.

Tato příručka obsahuje pokyny a ukázkový kód, které vám pomůžou začít používat klientskou knihovnu Custom Vision pro Node.js k vytvoření modelu rozpoznávání objektů. Vytvoříte projekt, přidáte značky, vytrénujete projekt a použijete adresu URL koncového bodu předpovědi projektu k programovému otestování. Tento příklad použijte jako šablonu pro vytvoření vlastní aplikace pro rozpoznávání obrázků.

Poznámka:

Pokud chcete sestavit a vytrénovat model detekce objektů bez psaní kódu, přečtěte si místo toho pokyny založené na prohlížeči.

Pomocí klientské knihovny Custom Vision pro .NET můžete:

• Vytvoření nového projektu Custom Vision
• Přidání značek do projektu
• Nahrání a označení obrázků
• Trénování projektu
• Publikování aktuální iterace
• Testování koncového bodu předpovědi

Referenční dokumentace (trénování) (předpověď) | Balíček (npm) (trénování) (predikce) | Ukázky

Požadavky

• Předplatné Azure: Můžete si ho vytvořit zdarma.
• Aktuální verze Node.js
• Jakmile budete mít předplatné Azure, vytvořte na webu Azure Portal prostředek Custom Vision, abyste vytvořili prostředek pro trénování a predikci.
  • K vyzkoušení služby můžete použít cenovou úroveňF0 Free a později upgradovat na placenou úroveň pro produkční prostředí.

Vytvoření proměnných prostředí

V tomto příkladu napíšete přihlašovací údaje do proměnných prostředí na místním počítači, na kterém běží aplikace.

Přejděte na Azure Portal. Pokud se prostředky Služby Custom Vision, které jste vytvořili v části Požadavky, úspěšně nasadíte, vyberte tlačítko Přejít k prostředku v části Další kroky. Klíče a koncové body najdete na stránkách klíčů a koncových bodů prostředků v části Správa prostředků. Budete muset získat klíče pro váš trénovací prostředek i prostředek predikce spolu s koncovými body rozhraní API.

ID prediktivního prostředku najdete na kartě Vlastnosti prediktivního prostředku na webu Azure Portal, který je uvedený jako ID prostředku.

Tip

Tyto https://www.customvision.ai hodnoty získáte také pomocí těchto hodnot. Po přihlášení vyberte ikonu Nastavení v pravém horním rohu. Na stránkách Nastavení můžete zobrazit všechny klíče, ID prostředku a koncové body.

Pokud chcete nastavit proměnné prostředí, otevřete okno konzoly a postupujte podle pokynů pro operační systém a vývojové prostředí.

• Pokud chcete nastavit proměnnou VISION_TRAINING KEY prostředí, nahraďte <your-training-key> jedním z klíčů vašeho trénovacího prostředku.
• Pokud chcete nastavit proměnnou VISION_TRAINING_ENDPOINT prostředí, nahraďte <your-training-endpoint> koncovým bodem vašeho trénovacího prostředku.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_KEY prostředí, nahraďte <your-prediction-key> jedním z klíčů pro prostředek předpovědi.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_ENDPOINT prostředí, nahraďte <your-prediction-endpoint> koncový bod pro prostředek predikce.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_RESOURCE_ID prostředí, nahraďte <your-resource-id> ID prostředku pro prostředek predikce.

Důležité

Pokud používáte klíč rozhraní API, uložte ho bezpečně někam jinam, například ve službě Azure Key Vault. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně.

Další informace o zabezpečení služeb AI najdete v tématu Ověřování požadavků na služby Azure AI.

Windows

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Po přidání proměnných prostředí možná budete muset restartovat všechny spuštěné programy, které čtou proměnné prostředí, včetně okna konzoly.

Linux

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Po přidání proměnných prostředí spusťte source ~/.bashrc z okna konzoly, aby změny byly efektivní.

Nastavení

Vytvoření nové aplikace Node.js

V okně konzoly (například cmd, PowerShell nebo Bash) vytvořte pro vaši aplikaci nový adresář a přejděte do něj.

mkdir myapp && cd myapp

Spuštěním příkazu npm init vytvoříte aplikaci uzlu se souborem package.json.

npm init

Instalace klientské knihovny

Pokud chcete napsat aplikaci pro analýzu obrázků pomocí služby Custom Vision pro Node.js, budete potřebovat balíčky NPM služby Custom Vision. Pokud je chcete nainstalovat, spusťte v PowerShellu následující příkaz:

npm install @azure/cognitiveservices-customvision-training
npm install @azure/cognitiveservices-customvision-prediction

Soubor package.json vaší aplikace se bude aktualizovat s využitím závislostí.

Vytvořte soubor s názvem index.js a naimportujte následující knihovny:

const util = require('util');
const fs = require('fs');
const TrainingApi = require("@azure/cognitiveservices-customvision-training");
const PredictionApi = require("@azure/cognitiveservices-customvision-prediction");
const msRest = require("@azure/ms-rest-js");

Tip

Chcete zobrazit celý soubor s kódem rychlého startu najednou? Soubor s příklady kódu v tomto rychlém startu najdete na GitHubu.

Vytvořte proměnné pro koncový bod a klíče Azure vašeho prostředku.

// retrieve environment variables
const trainingKey = process.env["VISION_TRAINING_KEY"];
const trainingEndpoint = process.env["VISION_TRAINING_ENDPOINT"];

const predictionKey = process.env["VISION_PREDICTION_KEY"];
const predictionResourceId = process.env["VISION_PREDICTION_RESOURCE_ID"];
const predictionEndpoint = process.env["VISION_PREDICTION_ENDPOINT"];

Přidejte také pole pro název projektu a parametr časového limitu pro asynchronní volání.

const publishIterationName = "detectModel";
const setTimeoutPromise = util.promisify(setTimeout);

Objektový model

Název	Popis
TrainingAPIClient	Tato třída zpracovává vytváření, trénování a publikování modelů.
PredictionAPIClient	Tato třída zpracovává dotazování modelů na predikce detekce objektů.
Predikce	Toto rozhraní definuje jednu předpověď na jednom obrázku. Zahrnuje vlastnosti ID a názvu objektu a skóre spolehlivosti.

Příklady kódu

Tyto fragmenty kódu ukazují, jak provádět následující úlohy s klientskou knihovnou Custom Vision pro JavaScript:

• Ověření klienta
• Vytvoření nového projektu Custom Vision
• Přidání značek do projektu
• Nahrání a označování obrázků
• Trénovat projekt
• Publikování aktuální iterace
• Testování koncového bodu předpovědi

Ověření klienta

Vytvoření instance klientských objektů pomocí koncového bodu a klíče Vytvořte objekt ApiKeyCredentials s klíčem a použijte ho s koncovým bodem k vytvoření objektu TrainingAPIClient a PredictionAPIClient .

const credentials = new msRest.ApiKeyCredentials({ inHeader: { "Training-key": trainingKey } });
const trainer = new TrainingApi.TrainingAPIClient(credentials, trainingEndpoint);
const predictor_credentials = new msRest.ApiKeyCredentials({ inHeader: { "Prediction-key": predictionKey } });
const predictor = new PredictionApi.PredictionAPIClient(predictor_credentials, predictionEndpoint);

Přidání pomocné funkce

Přidejte následující funkci, která pomáhá provádět více asynchronních volání. Použijete to později.

const credentials = new msRest.ApiKeyCredentials({ inHeader: { "Training-key": trainingKey } });
const trainer = new TrainingApi.TrainingAPIClient(credentials, trainingEndpoint);
const predictor_credentials = new msRest.ApiKeyCredentials({ inHeader: { "Prediction-key": predictionKey } });
const predictor = new PredictionApi.PredictionAPIClient(predictor_credentials, predictionEndpoint);

Vytvoření nového projektu Custom Vision

Spusťte novou funkci, která bude obsahovat všechna volání funkce Custom Vision. Přidejte následující kód pro vytvoření nového projektu služby Custom Vision.

(async () => {
    console.log("Creating project...");
    const domains = await trainer.getDomains()
    const objDetectDomain = domains.find(domain => domain.type === "ObjectDetection");
    const sampleProject = await trainer.createProject("Sample Obj Detection Project", { domainId: objDetectDomain.id });

Přidání značek do projektu

Pokud chcete vytvořit značky klasifikace do projektu, přidejte do své funkce následující kód:

const forkTag = await trainer.createTag(sampleProject.id, "Fork");
const scissorsTag = await trainer.createTag(sampleProject.id, "Scissors");

Nahrání a označení obrázků

Nejprve si stáhněte ukázkové obrázky pro tento projekt. Uložte obsah ukázkové složky Obrázky do místního zařízení.

Ukázkové obrázky do projektu přidáte tak, že po vytvoření značky vložíte následující kód. Tento kód nahraje jednotlivé obrázky s odpovídající značkou. Při označování obrázků v projektech detekce obrázků je potřeba zadat oblast každého označeného objektu pomocí normalizovaných souřadnic. Pro účely tohoto kurzu jsou oblasti pevně zakódované v kódu. Oblasti určují ohraničující rámeček s normalizovanými souřadnicemi, které jsou v tomto pořadí: vlevo, nahoře, šířka, výška. Do jedné dávky můžete nahrát až 64 obrázků.

const sampleDataRoot = "Images";

const forkImageRegions = {
    "fork_1.jpg": [0.145833328, 0.3509314, 0.5894608, 0.238562092],
    "fork_2.jpg": [0.294117659, 0.216944471, 0.534313738, 0.5980392],
    "fork_3.jpg": [0.09191177, 0.0682516545, 0.757352948, 0.6143791],
    "fork_4.jpg": [0.254901975, 0.185898721, 0.5232843, 0.594771266],
    "fork_5.jpg": [0.2365196, 0.128709182, 0.5845588, 0.71405226],
    "fork_6.jpg": [0.115196079, 0.133611143, 0.676470637, 0.6993464],
    "fork_7.jpg": [0.164215669, 0.31008172, 0.767156839, 0.410130739],
    "fork_8.jpg": [0.118872553, 0.318251669, 0.817401946, 0.225490168],
    "fork_9.jpg": [0.18259804, 0.2136765, 0.6335784, 0.643790841],
    "fork_10.jpg": [0.05269608, 0.282303959, 0.8088235, 0.452614367],
    "fork_11.jpg": [0.05759804, 0.0894935, 0.9007353, 0.3251634],
    "fork_12.jpg": [0.3345588, 0.07315363, 0.375, 0.9150327],
    "fork_13.jpg": [0.269607842, 0.194068655, 0.4093137, 0.6732026],
    "fork_14.jpg": [0.143382356, 0.218578458, 0.7977941, 0.295751631],
    "fork_15.jpg": [0.19240196, 0.0633497, 0.5710784, 0.8398692],
    "fork_16.jpg": [0.140931368, 0.480016381, 0.6838235, 0.240196079],
    "fork_17.jpg": [0.305147052, 0.2512582, 0.4791667, 0.5408496],
    "fork_18.jpg": [0.234068632, 0.445702642, 0.6127451, 0.344771236],
    "fork_19.jpg": [0.219362751, 0.141781077, 0.5919118, 0.6683006],
    "fork_20.jpg": [0.180147052, 0.239820287, 0.6887255, 0.235294119]
};

const scissorsImageRegions = {
    "scissors_1.jpg": [0.4007353, 0.194068655, 0.259803921, 0.6617647],
    "scissors_2.jpg": [0.426470578, 0.185898721, 0.172794119, 0.5539216],
    "scissors_3.jpg": [0.289215684, 0.259428144, 0.403186262, 0.421568632],
    "scissors_4.jpg": [0.343137264, 0.105833367, 0.332107842, 0.8055556],
    "scissors_5.jpg": [0.3125, 0.09766343, 0.435049027, 0.71405226],
    "scissors_6.jpg": [0.379901975, 0.24308826, 0.32107842, 0.5718954],
    "scissors_7.jpg": [0.341911763, 0.20714055, 0.3137255, 0.6356209],
    "scissors_8.jpg": [0.231617644, 0.08459154, 0.504901946, 0.8480392],
    "scissors_9.jpg": [0.170343131, 0.332957536, 0.767156839, 0.403594762],
    "scissors_10.jpg": [0.204656869, 0.120539248, 0.5245098, 0.743464053],
    "scissors_11.jpg": [0.05514706, 0.159754932, 0.799019635, 0.730392158],
    "scissors_12.jpg": [0.265931368, 0.169558853, 0.5061275, 0.606209159],
    "scissors_13.jpg": [0.241421565, 0.184264734, 0.448529422, 0.6830065],
    "scissors_14.jpg": [0.05759804, 0.05027781, 0.75, 0.882352948],
    "scissors_15.jpg": [0.191176474, 0.169558853, 0.6936275, 0.6748366],
    "scissors_16.jpg": [0.1004902, 0.279036, 0.6911765, 0.477124184],
    "scissors_17.jpg": [0.2720588, 0.131977156, 0.4987745, 0.6911765],
    "scissors_18.jpg": [0.180147052, 0.112369314, 0.6262255, 0.6666667],
    "scissors_19.jpg": [0.333333343, 0.0274019931, 0.443627447, 0.852941155],
    "scissors_20.jpg": [0.158088237, 0.04047389, 0.6691176, 0.843137264]
};

console.log("Adding images...");
let fileUploadPromises = [];

const forkDir = `${sampleDataRoot}/fork`;
const forkFiles = fs.readdirSync(forkDir);

await asyncForEach(forkFiles, async (file) => {
    const region = { tagId: forkTag.id, left: forkImageRegions[file][0], top: forkImageRegions[file][1], width: forkImageRegions[file][2], height: forkImageRegions[file][3] };
    const entry = { name: file, contents: fs.readFileSync(`${forkDir}/${file}`), regions: [region] };
    const batch = { images: [entry] };
    // Wait one second to accommodate rate limit.
    await setTimeoutPromise(1000, null);
    fileUploadPromises.push(trainer.createImagesFromFiles(sampleProject.id, batch));
});

const scissorsDir = `${sampleDataRoot}/scissors`;
const scissorsFiles = fs.readdirSync(scissorsDir);

await asyncForEach(scissorsFiles, async (file) => {
    const region = { tagId: scissorsTag.id, left: scissorsImageRegions[file][0], top: scissorsImageRegions[file][1], width: scissorsImageRegions[file][2], height: scissorsImageRegions[file][3] };
    const entry = { name: file, contents: fs.readFileSync(`${scissorsDir}/${file}`), regions: [region] };
    const batch = { images: [entry] };
    // Wait one second to accommodate rate limit.
    await setTimeoutPromise(1000, null);
    fileUploadPromises.push(trainer.createImagesFromFiles(sampleProject.id, batch));
});

await Promise.all(fileUploadPromises);

Důležité

Budete muset změnit cestu k imagím (sampleDataRoot) na základě toho, kam jste stáhli úložiště ukázek sady Python SDK služeb Azure AI.

Poznámka:

Pokud nemáte nástroj pro kliknutí a přetažení k označení souřadnic oblastí, můžete použít webové uživatelské rozhraní na Customvision.ai. V tomto příkladu jsou již zadané souřadnice.

Trénování projektu

Tento kód vytvoří první iteraci prediktivního modelu.

console.log("Training...");
let trainingIteration = await trainer.trainProject(sampleProject.id);

// Wait for training to complete
console.log("Training started...");
while (trainingIteration.status == "Training") {
    console.log("Training status: " + trainingIteration.status);
    // wait for ten seconds
    await setTimeoutPromise(10000, null);
    trainingIteration = await trainer.getIteration(sampleProject.id, trainingIteration.id)
}
console.log("Training status: " + trainingIteration.status);

Publikování aktuální iterace

Tento kód publikuje trénovanou iteraci do koncového bodu předpovědi. Název předaný publikované iteraci se dá použít k odesílání žádostí o predikci. Iterace není v koncovém bodu předpovědi k dispozici, dokud nebude publikována.

// Publish the iteration to the end point
await trainer.publishIteration(sampleProject.id, trainingIteration.id, publishIterationName, predictionResourceId);    

Testování koncového bodu předpovědi

Pokud chcete odeslat obrázek do koncového bodu předpovědi a načíst predikci, přidejte do své funkce následující kód.

const testFile = fs.readFileSync(`${sampleDataRoot}/test/test_image.jpg`);
const results = await predictor.detectImage(sampleProject.id, publishIterationName, testFile)

// Show results
console.log("Results:");
results.predictions.forEach(predictedResult => {
    console.log(`\t ${predictedResult.tagName}: ${(predictedResult.probability * 100.0).toFixed(2)}% ${predictedResult.boundingBox.left},${predictedResult.boundingBox.top},${predictedResult.boundingBox.width},${predictedResult.boundingBox.height}`);
});

Pak funkci Custom Vision zavřete a zavolejte ji.

})()

Spuštění aplikace

Spusťte aplikaci pomocí příkazu node pro soubor rychlého startu.

node index.js

V konzole by se měl zobrazit výstup aplikace. Pak můžete ověřit, jestli je testovací obrázek (nalezený v <sampleDataRoot>/Test/) správně označený a zda je oblast detekce správná. Můžete se také vrátit na web služby Custom Vision a zobrazit aktuální stav nově vytvořeného projektu.

Vyčištění prostředků

Pokud chcete implementovat vlastní projekt detekce objektů (nebo místo toho vyzkoušet projekt klasifikace obrázků), možná budete chtít odstranit projekt detekce vidliček a nůžek z tohoto příkladu. Bezplatné předplatné umožňuje dva projekty Custom Vision.

Na webu služby Custom Vision přejděte do části Projekty a vyberte ikonu koše pod projektem My New Project.

Další kroky

Teď jste v kódu provedli všechny kroky procesu detekce objektů. Tato ukázka provede jednu iteraci trénování, ale často budete muset model vytrénovat a otestovat několikrát, aby bylo přesnější. Následující příručka se zabývá klasifikací obrázků, ale její principy jsou podobné jako u detekce objektů.

Testování a přetrénování modelu

• Co je Custom Vision?
• Zdrojový kód pro tuto ukázku najdete na GitHubu.
• Referenční dokumentace k sadě SDK (školení)
• Referenční dokumentace k sadě SDK (předpověď)

Začínáme s klientskou knihovnou Služby Custom Vision pro Python Podle těchto kroků nainstalujte balíček a vyzkoušejte ukázkový kód pro sestavení modelu rozpoznávání objektů. Vytvoříte projekt, přidáte značky, vytrénujete projekt a použijete adresu URL koncového bodu předpovědi projektu k programovému otestování. Tento příklad použijte jako šablonu pro vytvoření vlastní aplikace pro rozpoznávání obrázků.

Poznámka:

Pokud chcete sestavit a vytrénovat model detekce objektů bez psaní kódu, přečtěte si místo toho pokyny založené na prohlížeči.

Pomocí klientské knihovny Custom Vision pro Python můžete:

• Vytvoření nového projektu Custom Vision
• Přidání značek do projektu
• Nahrání a označení obrázků
• Trénování projektu
• Publikování aktuální iterace
• Testování koncového bodu předpovědi

Ukázky zdrojového kódu | knihovny referenční dokumentace | (PyPI) |

Požadavky

• Předplatné Azure: Můžete si ho vytvořit zdarma.
• Python 3.x
  • Vaše instalace Pythonu by měla obsahovat pip. Spuštěním na příkazovém pip --version řádku můžete zkontrolovat, jestli máte nainstalovaný pip. Získejte pip instalací nejnovější verze Pythonu.
• Jakmile budete mít předplatné Azure, vytvořte na webu Azure Portal prostředek Custom Vision, abyste vytvořili prostředek pro trénování a predikci.
  • K vyzkoušení služby můžete použít cenovou úroveňF0 Free a později upgradovat na placenou úroveň pro produkční prostředí.

Vytvoření proměnných prostředí

V tomto příkladu napíšete přihlašovací údaje do proměnných prostředí na místním počítači, na kterém běží aplikace.

Přejděte na Azure Portal. Pokud se prostředky Služby Custom Vision, které jste vytvořili v části Požadavky, úspěšně nasadíte, vyberte tlačítko Přejít k prostředku v části Další kroky. Klíče a koncové body najdete na stránkách klíčů a koncových bodů prostředků v části Správa prostředků. Budete muset získat klíče pro váš trénovací prostředek i prostředek predikce spolu s koncovými body rozhraní API.

ID prediktivního prostředku najdete na kartě Vlastnosti prediktivního prostředku na webu Azure Portal, který je uvedený jako ID prostředku.

Tip

Tyto https://www.customvision.ai hodnoty získáte také pomocí těchto hodnot. Po přihlášení vyberte ikonu Nastavení v pravém horním rohu. Na stránkách Nastavení můžete zobrazit všechny klíče, ID prostředku a koncové body.

Pokud chcete nastavit proměnné prostředí, otevřete okno konzoly a postupujte podle pokynů pro operační systém a vývojové prostředí.

• Pokud chcete nastavit proměnnou VISION_TRAINING KEY prostředí, nahraďte <your-training-key> jedním z klíčů vašeho trénovacího prostředku.
• Pokud chcete nastavit proměnnou VISION_TRAINING_ENDPOINT prostředí, nahraďte <your-training-endpoint> koncovým bodem vašeho trénovacího prostředku.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_KEY prostředí, nahraďte <your-prediction-key> jedním z klíčů pro prostředek předpovědi.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_ENDPOINT prostředí, nahraďte <your-prediction-endpoint> koncový bod pro prostředek predikce.
• Pokud chcete nastavit proměnnou VISION_PREDICTION_RESOURCE_ID prostředí, nahraďte <your-resource-id> ID prostředku pro prostředek predikce.

Důležité

Pokud používáte klíč rozhraní API, uložte ho bezpečně někam jinam, například ve službě Azure Key Vault. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně.

Další informace o zabezpečení služeb AI najdete v tématu Ověřování požadavků na služby Azure AI.

Windows

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Po přidání proměnných prostředí možná budete muset restartovat všechny spuštěné programy, které čtou proměnné prostředí, včetně okna konzoly.

Linux

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Po přidání proměnných prostředí spusťte source ~/.bashrc z okna konzoly, aby změny byly efektivní.

Nastavení

Instalace klientské knihovny

Pokud chcete napsat aplikaci pro analýzu obrázků pomocí služby Custom Vision pro Python, budete potřebovat klientskou knihovnu Custom Vision. Po instalaci Pythonu spusťte v PowerShellu nebo okně konzoly následující příkaz:

pip install azure-cognitiveservices-vision-customvision

Vytvoření nové aplikace v Pythonu

Vytvořte nový soubor Pythonu a naimportujte následující knihovny.

from azure.cognitiveservices.vision.customvision.training import CustomVisionTrainingClient
from azure.cognitiveservices.vision.customvision.prediction import CustomVisionPredictionClient
from azure.cognitiveservices.vision.customvision.training.models import ImageFileCreateBatch, ImageFileCreateEntry, Region
from msrest.authentication import ApiKeyCredentials
import os, time, uuid

Tip

Chcete zobrazit celý soubor s kódem rychlého startu najednou? Soubor s příklady kódu v tomto rychlém startu najdete na GitHubu.

Vytvořte proměnné pro koncový bod a klíče Azure vašeho prostředku.

# Replace with valid values
ENDPOINT = os.environ["VISION_TRAINING_ENDPOINT"]
training_key = os.environ["VISION_TRAINING_KEY"]
prediction_key = os.environ["VISION_PREDICTION_KEY"]
prediction_resource_id = os.environ["VISION_PREDICTION_RESOURCE_ID"]

Objektový model

Název	Popis
CustomVisionTrainingClient	Tato třída zpracovává vytváření, trénování a publikování modelů.
CustomVisionPredictionClient	Tato třída zpracovává dotazování modelů na predikce detekce objektů.
ImagePrediction	Tato třída definuje jednu předpověď objektu na jednom obrázku. Obsahuje vlastnosti ID a názvu objektu, umístění ohraničujícího rámečku objektu a skóre spolehlivosti.

Příklady kódu

Tyto fragmenty kódu ukazují, jak pomocí klientské knihovny Custom Vision pro Python provést následující akce:

• Ověření klienta
• Vytvoření nového projektu Custom Vision
• Přidání značek do projektu
• Nahrání a označování obrázků
• Trénovat projekt
• Publikování aktuální iterace
• Testování koncového bodu předpovědi

Ověření klienta

Vytvořte instanci klienta pro trénování a predikci pomocí koncového bodu a klíčů. Vytvořte objekty ApiKeyServiceClientCredentials s klíči a použijte je s koncovým bodem k vytvoření objektu CustomVisionTrainingClient a CustomVisionPredictionClient .

credentials = ApiKeyCredentials(in_headers={"Training-key": training_key})
trainer = CustomVisionTrainingClient(ENDPOINT, credentials)
prediction_credentials = ApiKeyCredentials(in_headers={"Prediction-key": prediction_key})
predictor = CustomVisionPredictionClient(ENDPOINT, prediction_credentials)

Vytvoření nového projektu Custom Vision

Přidáním následujícího kódu do svého skriptu vytvořte nový projekt služby Custom Vision.

Podívejte se na metodu create_project a určete další možnosti při vytváření projektu (vysvětlení najdete v průvodci sestavením webového portálu detektoru ).

publish_iteration_name = "detectModel"

# Find the object detection domain
obj_detection_domain = next(domain for domain in trainer.get_domains() if domain.type == "ObjectDetection" and domain.name == "General")

# Create a new project
print ("Creating project...")
# Use uuid to avoid project name collisions.
project = trainer.create_project(str(uuid.uuid4()), domain_id=obj_detection_domain.id)

Přidání značek do projektu

Pokud chcete vytvořit značky objektů v projektu, přidejte následující kód:

# Make two tags in the new project
fork_tag = trainer.create_tag(project.id, "fork")
scissors_tag = trainer.create_tag(project.id, "scissors")

Nahrání a označení obrázků

Nejprve si stáhněte ukázkové obrázky pro tento projekt. Uložte obsah ukázkové složky Obrázky do místního zařízení.

Při označování obrázků v projektech detekce obrázků je potřeba zadat oblast každého označeného objektu pomocí normalizovaných souřadnic. Následující kód přidruží jednotlivé ukázkové obrázky k odpovídající označené oblasti. Oblasti určují ohraničující rámeček s normalizovanými souřadnicemi, které jsou v tomto pořadí: vlevo, nahoře, šířka, výška.

fork_image_regions = {
    "fork_1": [ 0.145833328, 0.3509314, 0.5894608, 0.238562092 ],
    "fork_2": [ 0.294117659, 0.216944471, 0.534313738, 0.5980392 ],
    "fork_3": [ 0.09191177, 0.0682516545, 0.757352948, 0.6143791 ],
    "fork_4": [ 0.254901975, 0.185898721, 0.5232843, 0.594771266 ],
    "fork_5": [ 0.2365196, 0.128709182, 0.5845588, 0.71405226 ],
    "fork_6": [ 0.115196079, 0.133611143, 0.676470637, 0.6993464 ],
    "fork_7": [ 0.164215669, 0.31008172, 0.767156839, 0.410130739 ],
    "fork_8": [ 0.118872553, 0.318251669, 0.817401946, 0.225490168 ],
    "fork_9": [ 0.18259804, 0.2136765, 0.6335784, 0.643790841 ],
    "fork_10": [ 0.05269608, 0.282303959, 0.8088235, 0.452614367 ],
    "fork_11": [ 0.05759804, 0.0894935, 0.9007353, 0.3251634 ],
    "fork_12": [ 0.3345588, 0.07315363, 0.375, 0.9150327 ],
    "fork_13": [ 0.269607842, 0.194068655, 0.4093137, 0.6732026 ],
    "fork_14": [ 0.143382356, 0.218578458, 0.7977941, 0.295751631 ],
    "fork_15": [ 0.19240196, 0.0633497, 0.5710784, 0.8398692 ],
    "fork_16": [ 0.140931368, 0.480016381, 0.6838235, 0.240196079 ],
    "fork_17": [ 0.305147052, 0.2512582, 0.4791667, 0.5408496 ],
    "fork_18": [ 0.234068632, 0.445702642, 0.6127451, 0.344771236 ],
    "fork_19": [ 0.219362751, 0.141781077, 0.5919118, 0.6683006 ],
    "fork_20": [ 0.180147052, 0.239820287, 0.6887255, 0.235294119 ]
}

scissors_image_regions = {
    "scissors_1": [ 0.4007353, 0.194068655, 0.259803921, 0.6617647 ],
    "scissors_2": [ 0.426470578, 0.185898721, 0.172794119, 0.5539216 ],
    "scissors_3": [ 0.289215684, 0.259428144, 0.403186262, 0.421568632 ],
    "scissors_4": [ 0.343137264, 0.105833367, 0.332107842, 0.8055556 ],
    "scissors_5": [ 0.3125, 0.09766343, 0.435049027, 0.71405226 ],
    "scissors_6": [ 0.379901975, 0.24308826, 0.32107842, 0.5718954 ],
    "scissors_7": [ 0.341911763, 0.20714055, 0.3137255, 0.6356209 ],
    "scissors_8": [ 0.231617644, 0.08459154, 0.504901946, 0.8480392 ],
    "scissors_9": [ 0.170343131, 0.332957536, 0.767156839, 0.403594762 ],
    "scissors_10": [ 0.204656869, 0.120539248, 0.5245098, 0.743464053 ],
    "scissors_11": [ 0.05514706, 0.159754932, 0.799019635, 0.730392158 ],
    "scissors_12": [ 0.265931368, 0.169558853, 0.5061275, 0.606209159 ],
    "scissors_13": [ 0.241421565, 0.184264734, 0.448529422, 0.6830065 ],
    "scissors_14": [ 0.05759804, 0.05027781, 0.75, 0.882352948 ],
    "scissors_15": [ 0.191176474, 0.169558853, 0.6936275, 0.6748366 ],
    "scissors_16": [ 0.1004902, 0.279036, 0.6911765, 0.477124184 ],
    "scissors_17": [ 0.2720588, 0.131977156, 0.4987745, 0.6911765 ],
    "scissors_18": [ 0.180147052, 0.112369314, 0.6262255, 0.6666667 ],
    "scissors_19": [ 0.333333343, 0.0274019931, 0.443627447, 0.852941155 ],
    "scissors_20": [ 0.158088237, 0.04047389, 0.6691176, 0.843137264 ]
}

Poznámka:

Pokud nemáte nástroj pro kliknutí a přetažení k označení souřadnic oblastí, můžete použít webové uživatelské rozhraní na Customvision.ai. V tomto příkladu jsou již zadané souřadnice.

Pak pomocí této mapy přidružení nahrajte každý ukázkový obrázek se souřadnicemi oblasti (v jedné dávce můžete nahrát až 64 obrázků). Přidejte následující kód.

base_image_location = os.path.join (os.path.dirname(__file__), "Images")

# Go through the data table above and create the images
print ("Adding images...")
tagged_images_with_regions = []

for file_name in fork_image_regions.keys():
    x,y,w,h = fork_image_regions[file_name]
    regions = [ Region(tag_id=fork_tag.id, left=x,top=y,width=w,height=h) ]

    with open(os.path.join (base_image_location, "fork", file_name + ".jpg"), mode="rb") as image_contents:
        tagged_images_with_regions.append(ImageFileCreateEntry(name=file_name, contents=image_contents.read(), regions=regions))

for file_name in scissors_image_regions.keys():
    x,y,w,h = scissors_image_regions[file_name]
    regions = [ Region(tag_id=scissors_tag.id, left=x,top=y,width=w,height=h) ]

    with open(os.path.join (base_image_location, "scissors", file_name + ".jpg"), mode="rb") as image_contents:
        tagged_images_with_regions.append(ImageFileCreateEntry(name=file_name, contents=image_contents.read(), regions=regions))

upload_result = trainer.create_images_from_files(project.id, ImageFileCreateBatch(images=tagged_images_with_regions))
if not upload_result.is_batch_successful:
    print("Image batch upload failed.")
    for image in upload_result.images:
        print("Image status: ", image.status)
    exit(-1)

Poznámka:

Budete muset změnit cestu k imagím podle toho, kam jste si stáhli úložiště ukázek sady Python SDK služby Azure AI.

Trénování projektu

Tento kód vytvoří první iteraci prediktivního modelu.

print ("Training...")
iteration = trainer.train_project(project.id)
while (iteration.status != "Completed"):
    iteration = trainer.get_iteration(project.id, iteration.id)
    print ("Training status: " + iteration.status)
    time.sleep(1)

Tip

Trénovat s vybranými značkami

Volitelně můžete trénovat jenom na podmnožině použitých značek. Můžete to udělat, pokud jste ještě nepoužili dostatek určitých značek, ale máte dostatek dalších. Ve volání train_project nastavte volitelný parametr selected_tags na seznam řetězců ID značek, které chcete použít. Model bude trénovat tak, aby rozpoznával pouze značky v daném seznamu.

Publikování aktuální iterace

Iterace není v koncovém bodu předpovědi k dispozici, dokud nebude publikována. Následující kód zpřístupní aktuální iteraci modelu pro dotazování.

# The iteration is now trained. Publish it to the project endpoint
trainer.publish_iteration(project.id, iteration.id, publish_iteration_name, prediction_resource_id)
print ("Done!")

Testování koncového bodu předpovědi

Pokud chcete odeslat obrázek do koncového bodu předpovědi a načíst předpověď, přidejte na konec souboru následující kód:

# Now there is a trained endpoint that can be used to make a prediction

# Open the sample image and get back the prediction results.
with open(os.path.join (base_image_location, "test", "test_image.jpg"), mode="rb") as test_data:
    results = predictor.detect_image(project.id, publish_iteration_name, test_data)

# Display the results.    
for prediction in results.predictions:
    print("\t" + prediction.tag_name + ": {0:.2f}% bbox.left = {1:.2f}, bbox.top = {2:.2f}, bbox.width = {3:.2f}, bbox.height = {4:.2f}".format(prediction.probability * 100, prediction.bounding_box.left, prediction.bounding_box.top, prediction.bounding_box.width, prediction.bounding_box.height))

Spuštění aplikace

Spusťte CustomVisionQuickstart.py.

python CustomVisionQuickstart.py

V konzole by se měl zobrazit výstup aplikace. Pak můžete ověřit, jestli je testovací obrázek (nalezený v <base_image_location>/images/Test) správně označený a zda je oblast detekce správná. Můžete se také vrátit na web služby Custom Vision a zobrazit aktuální stav nově vytvořeného projektu.

Vyčištění prostředků

Pokud chcete implementovat vlastní projekt detekce objektů (nebo místo toho vyzkoušet projekt klasifikace obrázků), možná budete chtít odstranit projekt detekce vidliček a nůžek z tohoto příkladu. Bezplatné předplatné umožňuje dva projekty Custom Vision.

Na webu služby Custom Vision přejděte do části Projekty a vyberte ikonu koše pod projektem My New Project.

Další kroky

Teď jste v kódu provedli všechny kroky procesu detekce objektů. Tato ukázka provede jednu iteraci trénování, ale často budete muset model vytrénovat a otestovat několikrát, aby bylo přesnější. Následující příručka se zabývá klasifikací obrázků, ale její principy jsou podobné jako u detekce objektů.

Testování a přetrénování modelu

• Co je Custom Vision?
• Zdrojový kód pro tuto ukázku najdete na GitHubu.
• Referenční dokumentace k sadě SDK