Sdílet prostřednictvím

Rychlý start: Vytvoření projektu klasifikace obrázků pomocí klientské knihovny Custom Vision nebo rozhraní REST API

  • Článek

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 klasifikace obrázků. 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ým testům. Tento příklad použijte jako šablonu pro vytvoření vlastní aplikace pro rozpoznávání obrázků.

Poznámka:

Pokud chcete sestavit a trénovat klasifikační model 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 rámci správy prostředků. Budete muset získat klíče pro trénovací i prediktivní prostředky 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.

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í budete možná muset restartovat všechny spuštěné programy, které budou číst proměnné prostředí, včetně okna konzoly.

Nastavení

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.

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é body 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.

// Retrieve the environment variables for your credentials:
private static string trainingEndpoint = Environment.GetEnvironmentVariable("VISION_TRAINING_ENDPOINT");

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

private static string predictionResourceId = Environment.GetEnvironmentVariable("VISION_PREDICTION_RESOURCE_ID");

private static List<string> hemlockImages;
private static List<string> japaneseCherryImages;
private static Tag hemlockTag;
private static Tag japaneseCherryTag;
private static Iteration iteration;
private static string publishedModelName = "treeClassModel";
private static MemoryStream testImage;

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);
DeleteProject(trainingApi, project);

Ověření klienta

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

private static CustomVisionTrainingClient AuthenticateTraining(string endpoint, string trainingKey)
{
    // 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 static 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

Tento další bit kódu vytvoří projekt klasifikace obrázků. Vytvořený projekt se zobrazí na webu Custom Vision. Viz CreateProject metoda určit další možnosti při vytváření projektu (vysvětlení v průvodci sestavením klasifikátoru webového portálu).

private static Project CreateProject(CustomVisionTrainingClient trainingApi)
{
    // Create a new project
    Console.WriteLine("Creating new project:");
    return trainingApi.CreateProject("My New Project");
}

Přidání značek do projektu

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

private static void AddTags(CustomVisionTrainingClient trainingApi, Project project)
{
    // Make two tags in the new project
    hemlockTag = trainingApi.CreateTag(project.Id, "Hemlock");
    japaneseCherryTag = trainingApi.CreateTag(project.Id, "Japanese Cherry");
}

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í.

Pak definujte pomocnou metodu pro nahrání obrázků v tomto adresáři. Možná budete muset upravit argument GetFiles tak, aby odkazovat na umístění, kam se ukládají obrázky.

private static void LoadImagesFromDisk()
{
    // this loads the images to be uploaded from disk into memory
    hemlockImages = Directory.GetFiles(Path.Combine("Images", "Hemlock")).ToList();
    japaneseCherryImages = Directory.GetFiles(Path.Combine("Images", "Japanese_Cherry")).ToList();
    testImage = new MemoryStream(File.ReadAllBytes(Path.Combine("Images", "Test", "test_image.jpg")));
}

Dále definujte metodu pro nahrání obrázků a použijte značky podle umístění složky (obrázky jsou už seřazené). Obrázky můžete nahrávat a označovat iterativním způsobem nebo v dávce (až 64 na dávku). Tento fragment kódu obsahuje příklady obou.

private static void UploadImages(CustomVisionTrainingClient trainingApi, Project project)
{
    // Add some images to the tags
    Console.WriteLine("\tUploading images");
    LoadImagesFromDisk();

    // Images can be uploaded one at a time
    foreach (var image in hemlockImages)
    {
        using (var stream = new MemoryStream(File.ReadAllBytes(image)))
        {
            trainingApi.CreateImagesFromData(project.Id, stream, new List<Guid>() { hemlockTag.Id });
        }
    }

    // Or uploaded in a single batch 
    var imageFiles = japaneseCherryImages.Select(img => new ImageFileCreateEntry(Path.GetFileName(img), File.ReadAllBytes(img))).ToList();
    trainingApi.CreateImagesFromFiles(project.Id, new ImageFileCreateBatch(imageFiles, new List<Guid>() { japaneseCherryTag.Id }));

}

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 static 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")
    {
        Console.WriteLine("Waiting 10 seconds for training to complete...");
        Thread.Sleep(10000);

        // Re-query the iteration to get it's 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 static void PublishIteration(CustomVisionTrainingClient trainingApi, Project project)
{
    trainingApi.PublishIteration(project.Id, iteration.Id, publishedModelName, predictionResourceId);
    Console.WriteLine("Done!\n");

    // Now there is a trained endpoint, it can be used to make a prediction
}

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

Tato část skriptu nahraje testovací obrázek, odešle dotaz do koncového bodu modelu a vypíše data předpovědi do konzoly.

private static void TestIteration(CustomVisionPredictionClient predictionApi, Project project)
{

    // Make a prediction against the new project
    Console.WriteLine("Making a prediction:");
    var result = predictionApi.ClassifyImage(project.Id, publishedModelName, testImage);

    // Loop over each prediction and write out the results
    foreach (var c in result.Predictions)
    {
        Console.WriteLine($"\t{c.TagName}: {c.Probability:P1}");
    }
}

Spuštění aplikace

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

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

Creating new project:
        Uploading images
        Training
Done!

Making a prediction:
        Hemlock: 95.0%
        Japanese Cherry: 0.0%

Pak můžete ověřit správné označení testovacího obrázku (ve složce Images/Test/). Aplikaci ukončete stisknutím libovolné klávesy. 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 klasifikace obrázků (nebo místo toho vyzkoušet projekt detekce objektů), možná budete chtít odstranit projekt identifikace stromů 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.

Snímek obrazovky s panelem označeným jako Můj nový projekt s ikonou koše

Další kroky

Teď jste provedli každý krok procesu klasifikace obrázků v kódu. 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ší.

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

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 klasifikace obrázků. 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 trénovat klasifikační model 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 rámci správy prostředků. Budete muset získat klíče pro trénovací i prediktivní prostředky 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.

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í budete možná muset restartovat všechny spuštěné programy, které budou číst proměnné prostředí, včetně okna konzoly.

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.

Viz CreateProject metoda určit další možnosti při vytváření projektu (vysvětlení v průvodci sestavením klasifikátoru 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"
)

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 Project"
    iteration_publish_name = "classifyModel"
    sampleDataDirectory = "<path to sample images>"
)

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

    ctx = context.Background()

    trainer := training.New(training_key, endpoint)

    project, err := trainer.CreateProject(ctx, project_name, "sample project", nil, string(training.Multilabel))
    if (err != nil) {
        log.Fatal(err)
    }

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
hemlockTag, _ := trainer.CreateTag(ctx, *project.ID, "Hemlock", "Hemlock tree tag", string(training.Regular))
cherryTag, _ := trainer.CreateTag(ctx, *project.ID, "Japanese Cherry", "Japanese cherry tree tag", string(training.Regular))

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

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. Do jedné dávky můžete nahrát až 64 obrázků.

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.

fmt.Println("Adding images...")
japaneseCherryImages, err := ioutil.ReadDir(path.Join(sampleDataDirectory, "Japanese Cherry"))
if err != nil {
    fmt.Println("Error finding Sample images")
}

hemLockImages, err := ioutil.ReadDir(path.Join(sampleDataDirectory, "Hemlock"))
if err != nil {
    fmt.Println("Error finding Sample images")
}

for _, file := range hemLockImages {
    imageFile, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "Hemlock", file.Name()))
    imageData := ioutil.NopCloser(bytes.NewReader(imageFile))

    trainer.CreateImagesFromData(ctx, *project.ID, imageData, []string{ hemlockTag.ID.String() })
}

for _, file := range japaneseCherryImages {
    imageFile, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "Japanese Cherry", file.Name()))
    imageData := ioutil.NopCloser(bytes.NewReader(imageFile))
    trainer.CreateImagesFromData(ctx, *project.ID, imageData, []string{ cherryTag.ID.String() })
}

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 k dispozici, dokud nebude publikována.

fmt.Println("Training...")
iteration, _ := trainer.TrainProject(ctx, *project.ID)
for {
    if *iteration.Status != "Training" {
        break
    }
    fmt.Println("Training status: " + *iteration.Status)
    time.Sleep(1 * 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_image.jpg"))
    results, _ := predictor.ClassifyImage(ctx, *project.ID, iteration_publish_name, ioutil.NopCloser(bytes.NewReader(testImageData)), "")

    for _, prediction := range *results.Predictions    {
        fmt.Printf("\t%s: %.2f%%", *prediction.TagName, *prediction.Probability * 100)
        fmt.Println("")
    }
}

Spuštění aplikace

Spusťte sample.go.

go run sample.go

Výstup aplikace by se měl podobat následujícímu textu:

Creating project...
Adding images...
Training...
Training status: Training
Training status: Training
Training status: Training
Training status: Completed
Done!
        Hemlock: 93.53%
        Japanese Cherry: 0.01%

Pak můžete ověřit, jestli je testovací obrázek (nalezený v <base_image_url>/Images/Test/) správně označený. 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 klasifikace obrázků (nebo místo toho vyzkoušet projekt detekce objektů), možná budete chtít odstranit projekt identifikace stromů 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.

Snímek obrazovky s panelem označeným jako Můj nový projekt s ikonou koše

Další kroky

Teď jste viděli, jak je možné provádět každý krok procesu detekce objektů v kódu. 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ší.

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

Začněte používat klientskou knihovnu Custom Vision pro Javu k vytvoření modelu klasifikace obrázků. 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 trénovat klasifikační model 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 rámci správy prostředků. Budete muset získat klíče pro trénovací i prediktivní prostředky 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.

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í budete možná muset restartovat všechny spuštěné programy, které budou číst proměnné prostředí, včetně okna konzoly.

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");

Důležité

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ý bod najdete na stránkách klíčů a koncových bodů prostředků. Budete muset získat klíče pro trénovací i predikční prostředky spolu s koncovým bodem rozhraní API pro váš trénovací prostředek.

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

Důležité

Nezapomeňte klíče z kódu odebrat, až budete hotovi, a nikdy je veřejně neposílejte. V produkčním prostředí použijte bezpečný způsob ukládání přihlašovacích údajů a přístupu k vašim přihlašovacím údajům, jako je Azure Key Vault. Další informace najdete v článku zabezpečení služeb Azure AI.

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

Project project = createProject(trainClient);
addTags(trainClient, project);
uploadImages(trainClient, project);
trainProject(trainClient, project);
publishIteration(trainClient, project);
testProject(predictor, project);

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 klasifikace obrázků.
ImagePrediction Tato třída 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 Javu:

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í projektu Custom Vision

T## Vytvoření nového projektu Custom Vision

Tato další metoda vytvoří projekt klasifikace obrázků. 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 createProject(CustomVisionTrainingClient trainClient) {
    System.out.println("ImageClassification Sample");
    Trainings trainer = trainClient.trainings();

    System.out.println("Creating project...");
    Project project = trainer.createProject().withName("Sample Java Project").execute();

    return project;
}

Přidání značek do projektu

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

public static void addTags(CustomVisionTrainingClient trainClient, Project project) {

    Trainings trainer = trainClient.trainings();

    // create hemlock tag
    Tag hemlockTag = trainer.createTag().withProjectId(project.id()).withName("Hemlock").execute();
    // create cherry tag
    Tag cherryTag = trainer.createTag().withProjectId(project.id()).withName("Japanese Cherry").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í.

public static void uploadImages(CustomVisionTrainingClient trainClient, Project project) {
    Trainings trainer = trainClient.trainings();
    System.out.println("Adding images...");
    for (int i = 1; i <= 10; i++) {
        String fileName = "hemlock_" + i + ".jpg";
        byte[] contents = GetImage("/Hemlock", fileName);
        AddImageToProject(trainer, project, fileName, contents, hemlockTag.id(), null);
    }

    for (int i = 1; i <= 10; i++) {
        String fileName = "japanese_cherry_" + i + ".jpg";
        byte[] contents = GetImage("/Japanese_Cherry", fileName);
        AddImageToProject(trainer, project, fileName, contents, cherryTag.id(), null);
    }
}

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ů).

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 void trainProject(CustomVisionTrainingClient trainClient, Project project) {
    System.out.println("Training...");
    Trainings trainer = trainClient.trainings();

    Iteration iteration = trainer.trainProject(project.id(), new TrainProjectOptionalParameter());

    while (iteration.status().equals("Training")) {
        System.out.println("Training Status: " + iteration.status());
        Thread.sleep(1000);
        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 publishIteration(CustomVisionTrainingClient trainClient, Project project) {
    Trainings trainer = trainClient.trainings();
    // The iteration is now trained. Publish it to the prediction endpoint.
    String publishedModelName = "myModel";
    trainer.publishIteration(project.id(), iteration.id(), publishedModelName, predictionResourceId);
}

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.

// load test image
public static void testProject(CustomVisionPredictionClient predictor, Project project) {

    byte[] testImage = GetImage("/Test", "test_image.jpg");

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

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

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é.

Pokud chcete implementovat vlastní projekt klasifikace obrázků (nebo místo toho vyzkoušet projekt detekce objektů), možná budete chtít odstranit projekt identifikace stromů 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.

Snímek obrazovky s panelem označeným jako Můj nový projekt s ikonou koše

Další kroky

Teď jste viděli, jak se dá každý krok procesu klasifikace obrázků udělat v kódu. 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ší.

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

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 klasifikace obrázků. 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 trénovat klasifikační model 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 rámci správy prostředků. Budete muset získat klíče pro trénovací i prediktivní prostředky 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.

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í budete možná muset restartovat všechny spuštěné programy, které budou číst proměnné prostředí, včetně okna konzoly.

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 = "classifyModel";
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 klasifikace obrázků.
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í 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);

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 sampleProject = await trainer.createProject("Sample Project");

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 hemlockTag = await trainer.createTag(sampleProject.id, "Hemlock");
const cherryTag = await trainer.createTag(sampleProject.id, "Japanese Cherry");

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.

const sampleDataRoot = "Images";

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

const hemlockDir = `${sampleDataRoot}/Hemlock`;
const hemlockFiles = fs.readdirSync(hemlockDir);
hemlockFiles.forEach(file => {
    fileUploadPromises.push(trainer.createImagesFromData(sampleProject.id, fs.readFileSync(`${hemlockDir}/${file}`), { tagIds: [hemlockTag.id] }));
});

const cherryDir = `${sampleDataRoot}/Japanese_Cherry`;
const japaneseCherryFiles = fs.readdirSync(cherryDir);
japaneseCherryFiles.forEach(file => {
    fileUploadPromises.push(trainer.createImagesFromData(sampleProject.id, fs.readFileSync(`${cherryDir}/${file}`), { tagIds: [cherryTag.id] }));
});

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.

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);
    await setTimeoutPromise(1000, 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.classifyImage(sampleProject.id, publishIterationName, testFile);

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

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ýstup aplikace by se měl podobat následujícímu textu:

Creating project...
Adding images...
Training...
Training started...
Training status: Training
Training status: Training
Training status: Training
Training status: Completed
Results:
         Hemlock: 94.97%
         Japanese Cherry: 0.01%

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

Pokud chcete implementovat vlastní projekt klasifikace obrázků (nebo místo toho vyzkoušet projekt detekce objektů), možná budete chtít odstranit projekt identifikace stromů 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.

Snímek obrazovky s panelem označeným jako Můj nový projekt s ikonou koše

Další kroky

Teď jste viděli, jak je možné provádět každý krok procesu detekce objektů v kódu. 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ší.

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

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 klasifikace obrázků. 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 trénovat klasifikační model 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 rámci správy prostředků. Budete muset získat klíče pro trénovací i prediktivní prostředky 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.

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í budete možná muset restartovat všechny spuštěné programy, které budou číst proměnné prostředí, včetně okna konzoly.

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.

# retrieve environment variables
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 klasifikace obrázků.
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ř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 pro určení dalších možností při vytváření projektu (vysvětlení najdete v průvodci vytvořením klasifikátoru ).

publish_iteration_name = "classifyModel"

credentials = ApiKeyCredentials(in_headers={"Training-key": training_key})
trainer = CustomVisionTrainingClient(ENDPOINT, credentials)

# Create a new project
print ("Creating project...")
project_name = uuid.uuid4()
project = trainer.create_project(project_name)

Přidání značek do projektu

Pokud chcete do projektu přidat značky klasifikace, přidejte následující kód:

# Make two tags in the new project
hemlock_tag = trainer.create_tag(project.id, "Hemlock")
cherry_tag = trainer.create_tag(project.id, "Japanese Cherry")

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. Do jedné dávky můžete nahrát až 64 obrázků.

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

print("Adding images...")

image_list = []

for image_num in range(1, 11):
    file_name = "hemlock_{}.jpg".format(image_num)
    with open(os.path.join (base_image_location, "Hemlock", file_name), "rb") as image_contents:
        image_list.append(ImageFileCreateEntry(name=file_name, contents=image_contents.read(), tag_ids=[hemlock_tag.id]))

for image_num in range(1, 11):
    file_name = "japanese_cherry_{}.jpg".format(image_num)
    with open(os.path.join (base_image_location, "Japanese_Cherry", file_name), "rb") as image_contents:
        image_list.append(ImageFileCreateEntry(name=file_name, contents=image_contents.read(), tag_ids=[cherry_tag.id]))

upload_result = trainer.create_images_from_files(project.id, ImageFileCreateBatch(images=image_list))
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 na základě toho, kam jste stáhli úložiště ukázek sady Python SDK služeb 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)
    print ("Waiting 10 seconds...")
    time.sleep(10)

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
prediction_credentials = ApiKeyCredentials(in_headers={"Prediction-key": prediction_key})
predictor = CustomVisionPredictionClient(ENDPOINT, prediction_credentials)

with open(os.path.join (base_image_location, "Test/test_image.jpg"), "rb") as image_contents:
    results = predictor.classify_image(
        project.id, publish_iteration_name, image_contents.read())

    # Display the results.
    for prediction in results.predictions:
        print("\t" + prediction.tag_name +
              ": {0:.2f}%".format(prediction.probability * 100))

Spuštění aplikace

Spusťte CustomVisionQuickstart.py.

python CustomVisionQuickstart.py

Výstup aplikace by se měl podobat následujícímu textu:

Creating project...
Adding images...
Training...
Training status: Training
Training status: Completed
Done!
        Hemlock: 93.53%
        Japanese Cherry: 0.01%

Pak můžete ověřit, jestli je testovací obrázek (nalezený v <base_image_location>/images/Test/) správně označený. 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 klasifikace obrázků (nebo místo toho vyzkoušet projekt detekce objektů), možná budete chtít odstranit projekt identifikace stromů 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.

Snímek obrazovky s panelem označeným jako Můj nový projekt s ikonou koše

Další kroky

Teď jste viděli, jak se dá každý krok procesu klasifikace obrázků udělat v kódu. 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ší.

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

Začínáme s rozhraním REST API služby Custom Vision Podle těchto kroků volejte rozhraní API a sestavte model klasifikace obrázků. 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:

Custom Vision se nejčastěji používá prostřednictvím sady SDK klientské knihovny nebo pokynů založených 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

Požadavky

  • Předplatné Azure: Můžete si ho vytvořit zdarma.
  • 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 a získali klíče a koncový bod. Počkejte, až se nasazení nasadí, a klikněte na tlačítko Přejít k prostředku .
    • K připojení aplikace k Custom Vision budete potřebovat klíč a koncový bod z prostředků, které vytvoříte. Klíč a koncový bod vložíte do kódu níže v rychlém startu.
    • 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í.
  • PowerShell verze 6.0 nebo podobná aplikace příkazového řádku

Vytvoření nového projektu Custom Vision

K vytvoření projektu klasifikace obrázků použijete příkaz podobný následujícímu. Vytvořený projekt se zobrazí na webu Custom Vision.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects?name={name}"

Zkopírujte příkaz do textového editoru a proveďte následující změny:

  • Nahraďte {subscription key} platným klíčem pro rozpoznávání tváře.
  • Nahraďte {endpoint} koncovým bodem, který odpovídá vašemu klíči.

    Poznámka:

    Nové prostředky vytvořené po 1. červenci 2019 budou používat vlastní názvy subdomén. Další informace a úplný seznam regionálních koncových bodů najdete v tématu Vlastní subdomény pro služby Azure AI.

  • Nahraďte {name} názvem projektu.
  • Volitelně můžete nastavit další parametry adresy URL tak, aby nakonfigurovali, jaký typ modelu bude projekt používat. Možnosti najdete v rozhraní API CreatProject.

Zobrazí se odpověď JSON podobná následující. "id" Uložte hodnotu projektu do dočasného umístění.

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "description": "string",
  "settings": {
    "domainId": "00000000-0000-0000-0000-000000000000",
    "classificationType": "Multiclass",
    "targetExportPlatforms": [
      "CoreML"
    ],
    "useNegativeSet": true,
    "detectionParameters": "string",
    "imageProcessingSettings": {
      "augmentationMethods": {}
    }
  },
  "created": "string",
  "lastModified": "string",
  "thumbnailUri": "string",
  "drModeEnabled": true,
  "status": "Succeeded"
}

Přidání značek do projektu

Pomocí následujícího příkazu definujte značky, na které model natrénujete.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/tags?name={name}"
  • Znovu vložte vlastní klíč a adresu URL koncového bodu.
  • Nahraďte {projectId} vlastním ID projektu.
  • Nahraďte {name} názvem značky, kterou chcete použít.

Tento postup opakujte pro všechny značky, které chcete použít v projektu. Pokud používáte poskytnuté ukázkové obrázky, přidejte značky "Hemlock" a "Japanese Cherry".

Dostanete odpověď JSON, jako je následující. "id" Uložte hodnotu každé značky do dočasného umístění.

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "description": "string",
  "type": "Regular",
  "imageCount": 0
}

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

Dále 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í.

Pomocí následujícího příkazu nahrajte obrázky a použijte značky; jednou pro obrázky "Hemlock" a samostatně pro "japonské třešňové" obrázky. Další možnosti najdete v rozhraní API pro vytváření imagí z datového rozhraní API.

curl -v -X POST -H "Content-Type: multipart/form-data" -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/images?tagIds={tagArray}"
--data-ascii "{binary data}"
  • Znovu vložte vlastní klíč a adresu URL koncového bodu.
  • Nahraďte {projectId} vlastním ID projektu.
  • Nahraďte {tagArray} ID značky.
  • Pak naplnit text požadavku binárními daty obrázků, které chcete označit.

Trénování projektu

Tato metoda trénuje model na označených obrázcích, které jste nahráli, a vrátí ID pro aktuální iteraci projektu.

curl -v -X POST -H "Content-Type: application/json" -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/train"
  • Znovu vložte vlastní klíč a adresu URL koncového bodu.
  • Nahraďte {projectId} vlastním ID projektu.
  • Nahraďte {tagArray} ID značky.
  • Pak naplnit text požadavku binárními daty obrázků, které chcete označit.
  • Volitelně můžete použít jiné parametry adresy URL. Možnosti najdete v rozhraní API pro trénování projektu .

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. Do textu požadavku přidejte volitelný obsah JSON. Naplňte "selectedTags" pole ID značek, které chcete použít.

{
  "selectedTags": [
    "00000000-0000-0000-0000-000000000000"
  ]
}

Odpověď JSON obsahuje informace o vašem vytrénovaného projektu, včetně ID iterace ("id"). Uložte tuto hodnotu pro další krok.

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "status": "string",
  "created": "string",
  "lastModified": "string",
  "trainedAt": "string",
  "projectId": "00000000-0000-0000-0000-000000000000",
  "exportable": true,
  "exportableTo": [
    "CoreML"
  ],
  "domainId": "00000000-0000-0000-0000-000000000000",
  "classificationType": "Multiclass",
  "trainingType": "Regular",
  "reservedBudgetInHours": 0,
  "trainingTimeInMinutes": 0,
  "publishName": "string",
  "originalPublishResourceId": "string"
}

Publikování aktuální iterace

Tato metoda zpřístupňuje aktuální iteraci modelu pro dotazování. Vrácený název modelu použijete jako odkaz k odesílání žádostí o predikce.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/iterations/{iterationId}/publish?publishName={publishName}&predictionId={predictionId}"
  • Znovu vložte vlastní klíč a adresu URL koncového bodu.
  • Nahraďte {projectId} vlastním ID projektu.
  • Nahraďte {iterationId} ID vráceným v předchozím kroku.
  • Nahraďte {publishedName} názvem, který chcete přiřadit k prediktivnímu modelu.
  • Nahraďte {predictionId} vlastním ID prostředku předpovědi. ID prostředku predikce najdete na kartě Vlastnosti prostředku na webu Azure Portal, který je uvedený jako ID prostředku.
  • Volitelně můžete použít jiné parametry adresy URL. Podívejte se na rozhraní API pro publikování iterace .

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

Nakonec pomocí tohoto příkazu otestujte trénovaný model tak, že nahrajete nový obrázek, který klasifikuje pomocí značek. Obrázek můžete použít ve složce Test ukázkových souborů, které jste si stáhli dříve.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/iterations/{iterationId}/publish?publishName={publishName}&predictionId={predictionId}"
  • Znovu vložte vlastní klíč a adresu URL koncového bodu.
  • Nahraďte {projectId} vlastním ID projektu.
  • Nahraďte {publishedName} názvem, který jste použili v předchozím kroku.
  • Přidejte binární data místní image do textu požadavku.
  • Volitelně můžete použít jiné parametry adresy URL. Podívejte se na rozhraní API klasifikace obrázků .

Vrácená odpověď JSON zobrazí seznam všech značek, které model použil na váš obrázek, spolu se skóre pravděpodobnosti pro každou značku.

{
  "id": "00000000-0000-0000-0000-000000000000",
  "project": "00000000-0000-0000-0000-000000000000",
  "iteration": "00000000-0000-0000-0000-000000000000",
  "created": "string",
  "predictions": [
    {
      "probability": 0.0,
      "tagId": "00000000-0000-0000-0000-000000000000",
      "tagName": "string",
      "boundingBox": {
        "left": 0.0,
        "top": 0.0,
        "width": 0.0,
        "height": 0.0
      },
      "tagType": "Regular"
    }
  ]
}

Pokud chcete implementovat vlastní projekt klasifikace obrázků (nebo místo toho vyzkoušet projekt detekce objektů), možná budete chtít odstranit projekt identifikace stromů 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.

Snímek obrazovky s panelem označeným jako Můj nový projekt s ikonou koše

Další kroky

Teď jste provedli všechny kroky procesu klasifikace obrázků pomocí rozhraní REST API. 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ší.

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