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

Začněte s klientskou knihovnou Custom Vision pro .NET. Pomocí těchto kroků nainstalujte balíček a vyzkoušejte ukázkový kód pro vytvoření modelu klasifikace imagí. Vytvoříte projekt, přidáte značky, provedete projekt a použijete adresu URL koncového bodu předpovědi projektu pro programové testování. Tento příklad použijte jako šablonu pro vytvoření vlastní aplikace pro rozpoznávání imagí.

Pomocí klientské knihovny Custom Vision pro .NET:

• Vytvoření nového projektu Custom Vision
• Přidat do projektu značky
• Nahrávání a označování obrázků
• Výuka projektu
• Publikovat aktuální iteraci
• Testování koncového bodu předpovědi

Referenční dokumentace | Zdrojový kód knihovny (školení) (předpověď) | Ukázky balíčku (NuGet) ( školení ) (předpovědi | )

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma .
• Integrované vývojové prostředí (IDE) sady Visual Studio nebo aktuální verze .NET Core.
• Jakmile budete mít předplatné Azure, Custom Vision v Azure Portal, abyste vytvořili prostředek pro školení a předpověď a získali své klíče a koncový bod. Počkejte na nasazení 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. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Vytvoření nové aplikace v C#

dotnet new console -n custom-vision-quickstart

dotnet build

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

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

Z adresáře 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é pro klíč a koncový bod prostředku. Také deklarujete některé základní objekty, které budou použity později.

// You can obtain these values from the Keys and Endpoint page for your Custom Vision resource in the Azure Portal.
private static string trainingEndpoint = "PASTE_YOUR_CUSTOM_VISION_TRAINING_ENDPOINT_HERE";
private static string trainingKey = "PASTE_YOUR_CUSTOM_VISION_TRAINING_SUBSCRIPTION_KEY_HERE";
// You can obtain these values from the Keys and Endpoint page for your Custom Vision Prediction resource in the Azure Portal.
private static string predictionEndpoint = "PASTE_YOUR_CUSTOM_VISION_PREDICTION_ENDPOINT_HERE";
private static string predictionKey = "PASTE_YOUR_CUSTOM_VISION_PREDICTION_SUBSCRIPTION_KEY_HERE";
// You can obtain this value from the Properties page for your Custom Vision Prediction resource in the Azure Portal. See the "Resource ID" field. This typically has a value such as:
// /subscriptions/<your subscription ID>/resourceGroups/<your resource group>/providers/Microsoft.CognitiveServices/accounts/<your Custom Vision prediction resource name>
private static string predictionResourceId = "PASTE_YOUR_CUSTOM_VISION_PREDICTION_RESOURCE_ID_HERE";

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žívaných v rámci tohoto rychlého startu. Budete je implementovat 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);

Objektový model

Příklady kódu

Tyto fragmenty kódu ukazují, jak provádět následující úlohy pomocí klientské knihovny Custom Vision pro .NET:

• Ověření klienta
• Vytvoření nového projektu Custom Vision
• Přidat do projektu značky
• Nahrávání a označování obrázků
• Výuka projektu
• Publikovat aktuální iteraci
• Testování koncového bodu předpovědi

Ověření klienta

V nové metodě vytvořte instanci školení a předpovědí klientů pomocí svého 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ázku. Vytvořený projekt se zobrazí na webu Custom Vision. Chcete-li určit další možnosti při vytváření projektu, viz metoda CreateProject (vysvětlení najdete v průvodci vytvořením webového portálu třídění).

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

Přidat do projektu značky

Tato metoda definuje značky, na kterých budete model zaškolit.

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ávání a označování obrázků

Nejdřív Stáhněte ukázkové image pro tento projekt. Uložte obsah složky Sample images do místního zařízení.

Pak definujte pomocnou metodu pro nahrání imagí v tomto adresáři. Možná budete muset upravit argument GetFiles , aby odkazoval na umístění, kam se ukládají vaše 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žití značek podle jejich umístění složky (obrázky jsou již seřazeny). Obrázky můžete vysílat iterativním, 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 }));

}

Výuka projektu

Tato metoda vytvoří první výukovou iteraci v projektu. Dotazuje se na službu až do dokončení školení.

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

Publikovat aktuální iteraci

Tato metoda zpřístupňuje aktuální iteraci modelu, který je k dispozici pro dotazování. Název modelu můžete použít jako referenci k odeslání požadavků předpovědi. Musíte zadat vlastní hodnotu pro predictionResourceId . ID prostředku předpovědi můžete najít na kartě vlastnosti prostředku v Azure Portal, 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 načte testovací image, provede dotaz na koncový bod modelu a výstupí 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

dotnet run

Při spuštění aplikace by měl otevřít okno konzoly a zapsat následující výstup:

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 Custom Vision projekty.

Na webu Custom Visionpřejděte na projekty a v části můj nový projekt vyberte odpadkový koš.

Další kroky

Nyní jste provedli všechny kroky procesu klasifikace obrázků v kódu. Tato ukázka provádí jednu výukovou iteraci, ale často je potřeba, abyste model provedli a otestovali několikrát, aby bylo přesnější.

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

Tato příručka poskytuje pokyny a ukázkový kód, který vám pomůže začít používat Custom Vision klientské knihovny pro přejít k sestavení modelu klasifikace imagí. Vytvoříte projekt, přidáte značky, provedete projekt a použijete adresu URL koncového bodu předpovědi projektu pro programové testování. Tento příklad použijte jako šablonu pro vytvoření vlastní aplikace pro rozpoznávání imagí.

Pomocí klientské knihovny Custom Vision můžete přejít na:

• Vytvoření nového projektu Custom Vision
• Přidat do projektu značky
• Nahrávání a označování obrázků
• Výuka projektu
• Publikovat aktuální iteraci
• Testování koncového bodu předpovědi

Referenční dokumentace (školení) (předpověď)| Zdrojový kód knihovny (školení) (předpověď)

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma .
• Přejít 1.8 +
• Jakmile budete mít předplatné Azure, Custom Vision v Azure Portal, abyste vytvořili prostředek pro školení a předpověď a získali své klíče a koncový bod. Počkejte na nasazení 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. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Instalace klientské knihovny Custom Vision

K napsání aplikace pro analýzu obrázků pomocí Custom Vision for přejít 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 , v rámci vašeho spuštění úložiště:

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

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

V tomto příkladu se používají image z úložiště ukázek sady SDK Cognitive Services Python na GitHubu. Naklonujte nebo si stáhněte toto úložiště do svého vývojového prostředí. Zapamatujte si umístění složky pro pozdější krok.

Vytvoření projektu Custom Vision

Vytvořte nový soubor s názvem Sample. přejít do vašeho preferovaného adresáře projektu 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. Do odpovídajících definic vložte své klíče předplatného. Adresu URL koncového bodu si také můžete stáhnout ze stránky nastavení na webu Custom Vision.

Chcete-li určit další možnosti při vytváření projektu, viz metoda CreateProject (vysvětlení najdete v průvodci vytvořením webového portálu třídění).

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 = "<your training key>"
    prediction_key string = "<your prediction key>"
    prediction_resource_id = "<your prediction resource id>"
    endpoint string = "<your endpoint URL>"
    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

Chcete-li vytvořit klasifikační značky pro projekt, přidejte následující kód na konec Sample. přejít:

// 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ávání a označování 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 imagí.

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() })
}

Školení a publikování projektu

Tento kód vytvoří první iteraci modelu předpovědi a pak tuto iteraci publikuje do koncového bodu předpovědi. Název zadaný pro publikovanou iteraci lze použít k odeslání požadavků předpovědi. Iterace není v koncovém bodu předpovědi k dispozici, dokud není 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. přejít.

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 správné označení testovacího obrázku (ve složce v <adresa_URL_základního_obrázku>/Images/Test/). 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 Custom Vision projekty.

Na webu Custom Visionpřejděte na projekty a v části můj nový projekt vyberte odpadkový koš.

Další kroky

Nyní jste viděli, jak se každý krok procesu detekce objektů dá provést v kódu. Tato ukázka provádí jednu výukovou iteraci, ale často je potřeba, abyste model provedli a otestovali několikrát, aby bylo přesnější.

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

Začněte používat Custom Vision klientské knihovny pro Java k sestavení modelu klasifikace imagí. Pomocí těchto kroků nainstalujete balíček a vyzkoušíte ukázkový kód pro základní úlohy. Tento příklad použijte jako šablonu pro vytvoření vlastní aplikace pro rozpoznávání imagí.

Pomocí klientské knihovny Custom Vision pro jazyk Java:

• Vytvoření nového projektu Custom Vision
• Přidat do projektu značky
• Nahrávání a označování obrázků
• Výuka projektu
• Publikovat aktuální iteraci
• Testování koncového bodu předpovědi

Referenční dokumentace | Zdrojový kód knihovny (školení) (předpověď)| Artefakty (Maven) (školení ) (předpovědi)– | ukázky

Požadavky

• Předplatné Azure – můžete ho vytvořit zdarma .
• Aktuální verze sady Java Development Kit (JDK)
• Nástroj Gradle Buildnebo jiný správce závislostí.
• Jakmile budete mít předplatné Azure, Custom Vision v Azure Portal, abyste vytvořili prostředek pro školení a předpověď a získali své klíče a koncový bod. Počkejte na nasazení 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. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Vytvořit nový projekt Gradle

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

mkdir myapp && cd myapp

Spusťte gradle init 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žívá za běhu k vytvoření a konfiguraci vaší 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í vašeho preferovaného integrovaného vývojového prostředí (IDE) nebo textového editoru. Pak zkopírujte do následující konfigurace sestavení. Tato konfigurace definuje projekt jako aplikaci Java, jejíž vstupní bod je třídou 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

V pracovním adresáři spusťte následující příkaz, který vytvoří 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;

V třídě CustomVisionQuickstart aplikace vytvořte proměnné pro klíče prostředku a koncový bod.

final static String trainingApiKey = "PASTE_YOUR_CUSTOM_VISION_TRAINING_SUBSCRIPTION_KEY_HERE";
final static String trainingEndpoint = "PASTE_YOUR_CUSTOM_VISION_TRAINING_ENDPOINT_HERE";
final static String predictionApiKey = "PASTE_YOUR_CUSTOM_VISION_PREDICTION_SUBSCRIPTION_KEY_HERE";
final static String predictionEndpoint = "PASTE_YOUR_CUSTOM_VISION_PREDICTION_ENDPOINT_HERE";
final static String predictionResourceId = "PASTE_YOUR_CUSTOM_VISION_PREDICTION_RESOURCE_ID_HERE";

V metodě Main aplikace přidejte volání metod používaných v rámci tohoto rychlého startu. Později je budete definovat.

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é hlavní funkce Custom Vision klientské knihovny Java.

Příklady kódu

Tyto fragmenty kódu ukazují, jak provádět následující úlohy pomocí Custom Vision klientské knihovny pro Java:

• Ověření klienta
• Vytvoření nového projektu Custom Vision
• Přidat do projektu značky
• Nahrávání a označování obrázků
• Výuka projektu
• Publikovat aktuální iteraci
• Testování koncového bodu předpovědi

Ověření klienta

V Hlavní metodě vytvořte instanci školení a předpovědí klientů pomocí svého 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ázku. Vytvořený projekt se zobrazí na webu služby Custom Vision, který jste navštívili dříve. Pokud vytvoříte projekt (vysvětlení najdete v průvodci vytvořením webového portálu detektoru ), podívejte se na přetížení metod CreateProject a určete další možnosti.

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ých budete model zaškolit.

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ávání a označování obrázků

Nejdřív Stáhněte ukázkové image pro tento projekt. Uložte obsah složky Sample images 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 dělá použití dvou pomocných funkcí, které načítají obrázky jako proudy prostředků a odesílají je do služby (do jedné dávky můžete nahrát až 64 imagí).

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

Výuka projektu

Tato metoda vytvoří první výukovou iteraci v projektu. Dotazuje se na službu až do dokončení školení.

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

Publikovat aktuální iteraci

Tato metoda zpřístupňuje aktuální iteraci modelu, který je k dispozici pro dotazování. Název modelu můžete použít jako referenci k odeslání požadavků předpovědi. Musíte zadat vlastní hodnotu pro predictionResourceId . ID prostředku předpovědi můžete najít na kartě vlastnosti prostředku v Azure Portal, 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í bitovou kopii, provede dotaz na koncový bod modelu a výstupí 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 vytvořit pomocí:

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é Cognitive Services, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny další prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

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 Custom Vision projekty.

Na webu Custom Visionpřejděte na projekty a v části můj nový projekt vyberte odpadkový koš.

Další kroky

Nyní jste viděli, jak se každý krok procesu klasifikace obrázků dá provést v kódu. Tato ukázka provádí jednu výukovou iteraci, ale často je potřeba, abyste model provedli a otestovali několikrát, aby bylo přesnější.

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

Tato příručka poskytuje pokyny a ukázkový kód, který vám pomůže začít používat Custom Vision klientské knihovny pro Node.js k sestavení modelu klasifikace imagí. Vytvoříte projekt, přidáte značky, provedete projekt a použijete adresu URL koncového bodu předpovědi projektu pro programové testování. Tento příklad použijte jako šablonu pro vytvoření vlastní aplikace pro rozpoznávání imagí.

Pomocí klientské knihovny Custom Vision pro .NET:

• Vytvoření nového projektu Custom Vision
• Přidat do projektu značky
• Nahrávání a označování obrázků
• Výuka projektu
• Publikovat aktuální iteraci
• Testování koncového bodu předpovědi

Referenční dokumentace (školení) (předpověď) | Zdrojový kód knihovny (školení) (předpověď) | Ukázky balíčku (npm) ( školení ) (předpovědi) |

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma .
• Aktuální verze Node.js
• Jakmile budete mít předplatné Azure, Custom Vision v Azure Portal, abyste vytvořili prostředek pro školení a předpověď a získali své klíče a koncový bod. Počkejte na nasazení 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. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Vytvoření nové aplikace Node.js

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

mkdir myapp && cd myapp

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

npm init

Instalace klientské knihovny

K napsání aplikace pro analýzu obrázků pomocí Custom Vision pro Node.js budete potřebovat balíčky Custom Vision NPM. 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 vaší aplikace package.json bude aktualizován pomocí závislostí.

Vytvořte soubor s názvem index.js a importujte 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");

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

const trainingKey = "PASTE_YOUR_CUSTOM_VISION_TRAINING_SUBSCRIPTION_KEY_HERE";
const trainingEndpoint = "PASTE_YOUR_CUSTOM_VISION_TRAINING_ENDPOINT_HERE";
const predictionKey = "PASTE_YOUR_CUSTOM_VISION_PREDICTION_SUBSCRIPTION_KEY_HERE";
const predictionResourceId = "PASTE_YOUR_CUSTOM_VISION_PREDICTION_RESOURCE_ID_HERE";
const predictionEndpoint = "PASTE_YOUR_CUSTOM_VISION_PREDICTION_ENDPOINT_HERE";

Pro asynchronní volání přidejte také pole pro název projektu a parametr Timeout.

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

Objektový model

Příklady kódu

Tyto fragmenty kódu ukazují, jak provádět následující úlohy pomocí Custom Vision klientské knihovny pro JavaScript:

• Ověření klienta
• Vytvoření nového projektu Custom Vision
• Přidat do projektu značky
• Nahrávání a označování obrázků
• Výuka projektu
• Publikovat aktuální iteraci
• Testování koncového bodu předpovědi

Ověření klienta

Vytvořte instanci objektů klienta s vaším koncovým bodem a klíčem. Vytvořte objekt ApiKeyCredentials s klíčem a použijte ho u svého koncového bodu 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 vaše volání funkcí Custom Vision. Přidejte následující kód k vytvoření nového projektu Custom Vision služby.

(async () => {
    console.log("Creating project...");
    const sampleProject = await trainer.createProject("Sample Project");

Přidat do projektu značky

Chcete-li vytvořit klasifikační značky pro projekt, přidejte do funkce následující kód:

const hemlockTag = await trainer.createTag(sampleProject.id, "Hemlock");
const cherryTag = await trainer.createTag(sampleProject.id, "Japanese Cherry");

Nahrávání a označování obrázků

Nejdřív Stáhněte ukázkové image pro tento projekt. Uložte obsah složky Sample images 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);

Výuka projektu

Tento kód vytvoří první iteraci modelu předpovědi.

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

Publikovat aktuální iteraci

Tento kód publikuje vyškolenou iteraci na koncový bod předpovědi. Název zadaný pro publikovanou iteraci lze použít k odeslání požadavků předpovědi. Iterace není v koncovém bodu předpovědi k dispozici, dokud není 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

Chcete-li odeslat obrázek do koncového bodu předpovědi a načíst předpověď, přidejte do 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)}%`);
});

Potom zavřete funkci Custom Vision a zavolejte ji.

})()

Spuštění aplikace

Spusťte aplikaci pomocí node příkazu v souboru 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, zda 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 Custom Vision projekty.

Na webu Custom Visionpřejděte na projekty a v části můj nový projekt vyberte odpadkový koš.

Další kroky

Nyní jste viděli, jak se každý krok procesu detekce objektů dá provést v kódu. Tato ukázka provádí jednu výukovou iteraci, ale často je potřeba, abyste model provedli a otestovali několikrát, aby bylo přesnější.

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

Začněte s knihovnou klienta Custom Vision pro Python. Pomocí těchto kroků nainstalujte balíček a vyzkoušejte ukázkový kód pro vytvoření modelu klasifikace imagí. Vytvoříte projekt, přidáte značky, provedete projekt a použijete adresu URL koncového bodu předpovědi projektu pro programové testování. Tento příklad použijte jako šablonu pro vytvoření vlastní aplikace pro rozpoznávání imagí.

Použití klientské knihovny Custom Vision pro Python pro:

• Vytvoření nového projektu Custom Vision
• Přidat do projektu značky
• Nahrávání a označování obrázků
• Výuka projektu
• Publikovat aktuální iteraci
• Testování koncového bodu předpovědi

Referenční dokumentace | Zdrojový kód knihovny | Balíček (PyPi) | Ukázky

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma .
• Python 3.x
  • Instalace Pythonu by měla zahrnovat PIP. Pomocí příkazu na příkazovém řádku můžete zjistit, jestli máte službu PIP nainstalovanou pip --version . Získejte PIP instalací nejnovější verze Pythonu.
• Jakmile budete mít předplatné Azure, Custom Vision v Azure Portal, abyste vytvořili prostředek pro školení a předpověď a získali své klíče a koncový bod. Počkejte na nasazení 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. Vaše klíče a koncový bod budete vkládat do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Instalace klientské knihovny

K napsání aplikace pro analýzu obrázků pomocí Custom Vision pro Python budete potřebovat klientskou knihovnu Custom Vision. Po instalaci Pythonu spusťte následující příkaz v PowerShellu nebo okně konzoly:

pip install azure-cognitiveservices-vision-customvision

Vytvoření nové aplikace v Pythonu

Vytvořte nový soubor Pythonu a importujte 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

Vytvořte proměnné pro koncový bod a klíč předplatného prostředku Azure.

# Replace with valid values
ENDPOINT = "PASTE_YOUR_CUSTOM_VISION_TRAINING_ENDPOINT_HERE"
training_key = "PASTE_YOUR_CUSTOM_VISION_TRAINING_SUBSCRIPTION_KEY_HERE"
prediction_key = "PASTE_YOUR_CUSTOM_VISION_PREDICTION_SUBSCRIPTION_KEY_HERE"
prediction_resource_id = "PASTE_YOUR_CUSTOM_VISION_PREDICTION_RESOURCE_ID_HERE"

Objektový model

Příklady kódu

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

• Ověření klienta
• Vytvoření nového projektu Custom Vision
• Přidat do projektu značky
• Nahrávání a označování obrázků
• Výuka projektu
• Publikovat aktuální iteraci
• Testování koncového bodu předpovědi

Ověření klienta

Vytvořte instanci školení a předpovědi klienta s vaším koncovým bodem a klíči. Vytvořte objekty ApiKeyServiceClientCredentials pomocí vašich klíčů a použijte je u svého koncového bodu 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.

Chcete-li určit další možnosti při vytváření projektu, podívejte se do metody create_project (vysvětleno v průvodci vytvořením webového portálu třídění).

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řidat do projektu značky

Chcete-li do projektu přidat klasifikační značky, 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ávání a označování obrázků

Nejdřív Stáhněte ukázkové image pro tento projekt. Uložte obsah složky Sample images 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 imagí.

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)

Výuka projektu

Tento kód vytvoří první iteraci modelu předpovědi.

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)

Publikovat aktuální iteraci

Iterace není v koncovém bodu předpovědi k dispozici, dokud není publikována. Následující kód provede aktuální iteraci modelu, který je k dispozici 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, zda 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 Custom Vision projekty.

Na webu Custom Visionpřejděte na projekty a v části můj nový projekt vyberte odpadkový koš.

Další kroky

Nyní jste viděli, jak se každý krok procesu klasifikace obrázků dá provést v kódu. Tato ukázka provádí jednu výukovou iteraci, ale často je potřeba, abyste model provedli a otestovali několikrát, aby bylo přesnější.

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

Začněte s REST APIem Custom Vision. Postupujte podle těchto kroků a zavolejte rozhraní API a sestavte model klasifikace imagí. Vytvoříte projekt, přidáte značky, provedete projekt a použijete adresu URL koncového bodu předpovědi projektu pro programové testování. Tento příklad použijte jako šablonu pro vytvoření vlastní aplikace pro rozpoznávání imagí.

Pomocí klientské knihovny Custom Vision pro .NET:

• Vytvoření nového projektu Custom Vision
• Přidat do projektu značky
• Nahrávání a označování obrázků
• Výuka projektu
• Publikovat aktuální iteraci
• Testování koncového bodu předpovědi

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma .
• Jakmile budete mít předplatné Azure, Custom Vision v Azure Portal, abyste vytvořili prostředek pro školení a předpověď a získali své klíče a koncový bod. Počkejte na nasazení 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. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později 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

Pro 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 odběr obličeje.
• Nahraďte {endpoint} koncovým bodem, který odpovídá vašemu klíči předplatného.

  Poznámka

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

• Nahraďte {name} názvem vašeho projektu.
• Volitelně můžete nastavit další parametry adresy URL a nakonfigurovat tak typ modelu, který bude projekt používat. Možnosti najdete v tématu rozhraní API pro CreatProject .

Dostanete odpověď JSON podobnou následující. Uložte "id" 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řidat do projektu značky

Pomocí následujícího příkazu definujte značky, na kterých budete model zaškolovat.

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

• Znovu vložte svůj vlastní klíč a adresu URL koncového bodu.
• Nahraďte {projectId} svým 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 ve vašem projektu. Pokud používáte příklady poskytnutých imagí, přidejte značky "Hemlock" a "Japanese Cherry" .

Dostanete odpověď JSON jako následující. Uložte "id" 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ávání a označování obrázků

Dále si stáhněte ukázkové image pro tento projekt. Uložte obsah složky Sample images do místního zařízení.

Pomocí následujícího příkazu nahrajte obrázky a použijte značky. jednou pro image "Hemlock" a samostatně pro image z japonského výběru. Další možnosti najdete v tématu Vytvoření imagí z rozhraní API pro data.

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 svůj vlastní klíč a adresu URL koncového bodu.
• Nahraďte {projectId} svým vlastním ID projektu.
• Nahraďte {tagArray} ID značky.
• Pak naplňte text požadavku do binárních dat imagí, které chcete označit.

Výuka projektu

Tato metoda nahraje model u tagovaných imagí, 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 svůj vlastní klíč a adresu URL koncového bodu.
• Nahraďte {projectId} svým vlastním ID projektu.
• Nahraďte {tagArray} ID značky.
• Pak naplňte text požadavku do binárních dat imagí, které chcete označit.
• Volitelně můžete použít jiné parametry adresy URL. Možnosti najdete v tématu věnovaném rozhraní API pro výukové projekty .

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

Odpověď JSON obsahuje informace o vámi vyškolený projekt, včetně ID iterace ( "id" ). Tuto hodnotu uložte 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"
}

Publikovat aktuální iteraci

Tato metoda zpřístupňuje aktuální iteraci modelu, který je k dispozici pro dotazování. Název vráceného modelu použijete jako referenci k odeslání požadavků předpovědi.

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 svůj vlastní klíč a adresu URL koncového bodu.
• Nahraďte {projectId} svým vlastním ID projektu.
• Nahraďte {iterationId} identifikátorem vráceným v předchozím kroku.
• Nahraďte {publishedName} názvem, který chcete přidružit k modelu předpovědi.
• Nahraďte {predictionId} vlastním ID prostředku předpovědi. ID prostředku předpovědi můžete najít na kartě vlastnosti prostředku v Azure Portal, uvedené jako ID prostředku.
• Volitelně můžete použít jiné parametry adresy URL. Viz téma Publish iterace API.

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

Nakonec pomocí tohoto příkazu otestujte vyškolený model tak, že nahrajete nový obrázek pro klasifikaci pomocí značek. Obrázek můžete použít ve složce test ukázkových souborů, které jste 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 svůj vlastní klíč a adresu URL koncového bodu.
• Nahraďte {projectId} svým vlastním ID projektu.
• Nahraďte {publishedName} názvem, který jste použili v předchozím kroku.
• Do textu žádosti přidejte binární data místní image.
• Volitelně můžete použít jiné parametry adresy URL. Podívejte se na téma rozhraní API pro klasifikaci imagí .

Vrácená odpověď JSON bude mít aspoň každou značku, kterou model pro vaši image nastavil, spolu s 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 Custom Vision projekty.

Na webu Custom Visionpřejděte na projekty a v části můj nový projekt vyberte odpadkový koš.

Další kroky

Nyní jste provedli všechny kroky procesu klasifikace obrázků pomocí REST API. Tato ukázka provádí jednu výukovou iteraci, ale často je potřeba, abyste model provedli a otestovali několikrát, aby bylo přesnější.

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