Snabbstart: Skapa ett bildklassificeringsprojekt med Custom Vision klientbibliotek eller REST API

Kom igång med Custom Vision klientbibliotek för .NET. Följ de här stegen för att installera paketet och prova exempelkoden för att skapa en bildklassificeringsmodell. Du skapar ett projekt, lägger till taggar, tränar projektet och använder projektets slutpunkts-URL för förutsägelse för att testa det programmatiskt. Använd det här exemplet som en mall för att skapa en egen bildigenkänningsapp.

Använd Custom Vision för .NET för att:

• Skapa ett nytt Custom Vision-projekt
• Lägg till taggar i projektet
• Ladda upp och tagga bilder
• Träna projektet
• Publicera den aktuella iterationen
• Testa förutsägelseslutpunkten

Referensdokumentation | Bibliotekskällkod (träning) (förutsägelse) | Paketexempel (NuGet) (träning) (förutsägelse) |

Förutsättningar

• Azure-prenumeration – Skapa en kostnadsfritt
• Den Visual Studio IDE eller den aktuella versionen av .NET Core.
• När du har din Azure-prenumeration skapar du en Custom Vision-resurs för att skapa en Custom Vision-resurs i Azure Portal för att skapa en resurs för träning och förutsägelse och hämta dina nycklar och slutpunkter. Vänta tills den har distribuerats och klicka på knappen Gå till resurs.
  • Du behöver nyckeln och slutpunkten från de resurser som du skapar för att ansluta ditt program till Custom Vision. Du klistrar in din nyckel och slutpunkt i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

Inrätta

Skapa ett nytt C#-program

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

Från projektkatalogen öppnar du filen program.cs och lägger till följande using -direktiv:

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;

I programmets Main-metod skapar du variabler för resursens nyckel och slutpunkt. Du kommer också att deklarera vissa grundläggande objekt som ska användas senare.

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

I programmets Main-metod lägger du till anrop för de metoder som används i den här snabbstarten. Du implementerar dessa senare.

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

Objektmodell

Kodexempel

De här kodfragmenten visar hur du utför följande uppgifter med Custom Vision klientbibliotek för .NET:

• Autentisera klienten
• Skapa ett nytt Custom Vision-projekt
• Lägg till taggar i projektet
• Ladda upp och tagga bilder
• Träna projektet
• Publicera den aktuella iterationen
• Testa förutsägelseslutpunkten

Autentisera klienten

I en ny metod instansierar du tränings- och förutsägelseklienter med hjälp av din slutpunkt och dina nycklar.

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

Skapa ett nytt Custom Vision-projekt

Nästa kod skapar ett bildklassificeringsprojekt. Det skapade projektet visas på Custom Vision webbplats. Se metoden CreateProject för att ange andra alternativ när du skapar projektet (förklaras i guiden Skapa en klassificerare i webbportalen).

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

Lägg till taggar i projektet

Den här metoden definierar de taggar som du ska träna modellen på.

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

Ladda upp och tagga bilder

Ladda först ned exempelbilderna för det här projektet. Spara innehållet i exempelmappen Bilder på din lokala enhet.

Definiera sedan en hjälpmetod för att ladda upp bilderna i den här katalogen. Du kan behöva redigera argumentet GetFiles så att det pekar på den plats där bilderna sparas.

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

Definiera sedan en metod för att ladda upp bilderna och tillämpa taggar enligt deras mappplats (bilderna är redan sorterade). Du kan ladda upp och tagga bilder iterativt eller i en batch (upp till 64 per batch). Det här kodfragmentet innehåller exempel på båda.

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äna projektet

Den här metoden skapar den första tränings iterationen i projektet. Den frågar tjänsten tills träningen har slutförts.

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

Publicera den aktuella iterationen

Den här metoden gör den aktuella iterationen av modellen tillgänglig för frågor. Du kan använda modellnamnet som referens för att skicka förutsägelsebegäranden. Du måste ange ett eget värde för predictionResourceId . Du hittar resurs-ID:t för förutsägelsen på fliken Egenskaper för resursen i Azure Portal som resurs-ID.

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
}

Testa förutsägelseslutpunkten

Den här delen av skriptet läser in test avbildningen, frågar modell slut punkten och matar ut förutsägelse data till-konsolen.

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

Köra appen

dotnet run

När programmet körs ska det öppna ett konsol fönster och skriva följande utdata:

Creating new project:
        Uploading images
        Training
Done!

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

Du kan sedan kontrollera att testbilden (som finns i Images/Test/) har taggats på rätt sätt. Avsluta programmet genom att trycka på valfri tangent. Du kan också gå tillbaka till Custom Vision-webbplatsen och se det aktuella tillståndet för det nyskapade projektet.

Rensa resurser

Om du vill implementera ett eget bildklassificeringsprojekt (eller prova ett objektidentifieringsprojekt istället) kan du vilja ta bort projektet för trädidentifiering från det här exemplet. Med en kostnads fri prenumeration kan du använda två Custom Vision projekt.

Navigera till projekt på Custom vision webbplatsoch välj pappers korgen under mitt nya projekt.

Nästa steg

Nu har du gjort varje steg i bildklassificeringsprocessen i kod. Det här exemplet kör en enda tränings iteration, men ofta behöver du träna och testa din modell flera gånger för att göra den mer exakt.

• Vad är Custom Vision?
• Källkoden för det här exemplet finns på GitHub
• Referensdokumentation för SDK

Den här guiden innehåller instruktioner och exempel kod som hjälper dig att komma igång med Custom Vision klient biblioteket för Go för att skapa en bild klassificerings modell. Du skapar ett projekt, lägger till taggar, tränar projektet och använder projektets förutsäga slut punkts-URL för att program mässigt testa det. Använd det här exemplet som mall för att skapa en egen bild igenkännings app.

Använd Custom Vision klient bibliotek för att gå till:

• Skapa ett nytt Custom Vision-projekt
• Lägg till taggar i projektet
• Ladda upp och tagga bilder
• Träna projektet
• Publicera den aktuella iterationen
• Testa förutsägelse slut punkten

Referens dokumentation (utbildning) (förutsägelse)| Biblioteks käll kod (utbildning) (förutsägelse)

Förutsättningar

• Azure-prenumeration – skapa en kostnads fritt
• Go 1.8+
• När du har en Azure-prenumeration skapar du skapa en Custom vision resurs i Azure Portal för att skapa en utbildnings-och förutsägelse resurs och hämta nycklar och slut punkt. Vänta tills den har distribuerats och klicka på knappen gå till resurs .
  • Du behöver nyckeln och slut punkten från de resurser som du skapar för att ansluta ditt program till Custom Vision. Du klistrar in nyckeln och slut punkten i koden nedan i snabb starten.
  • Du kan använda den kostnads fria pris nivån ( F0 ) för att testa tjänsten och senare uppgradera till en betald nivå för produktion.

Konfigurera

Installera klient biblioteket för Custom Vision

Om du vill skriva en app Analysis-app med Custom Vision för Go behöver du Custom Vision-tjänstens klient bibliotek. Kör följande kommando i PowerShell:

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

eller om du använder dep i din lagrings platsen kör du:

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

Hämta exempelbilderna

I det här exemplet används bilderna från lagrings platsen Cognitive Services python SDK-exempel på GitHub. Klona eller ladda ned den här lagringsplatsen till din utvecklingsmiljö. Kom ihåg mappens plats för ett senare steg.

Skapa Custom Vision-projektet

Skapa en ny fil med namnet Sample. gå till önskad projekt katalog och öppna den i önskad kod redigerare.

Lägg till följande kod i skriptet för att skapa ett nytt Custom Vision Service-projekt. Infoga dina prenumerationsnycklar i lämpliga definitioner. Hämta även slut punkts-URL: en från sidan Inställningar på webbplatsen för Custom Vision.

Se CreateProject -metoden för att ange andra alternativ när du skapar ditt projekt (förklaras i guiden skapa en klassificerings webb Portal).

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

Skapa taggar i projektet

Om du vill skapa klassificeringstaggar i projektet lägger du till följande kod i slutet av sample.go:

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

Ladda upp och tagga bilder

Infoga följande kod efter att taggen har skapats för att lägga till exempelbilder i projektet. Den här koden laddar upp varje bild med dess motsvarande tagg. Du kan ladda upp upp till 64 avbildningar i en enda batch.

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äna och publicera projektet

Den här koden skapar den första iterationen av förutsägelse modellen och publicerar sedan en upprepning till förutsägelse slut punkten. Det namn som ges till den publicerade iterationen kan användas för att skicka förutsägelse begär Anden. En iteration är inte tillgänglig i förutsägelse slut punkten förrän den har publicerats.

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

Använd förutsägelse slut punkten

Om du vill skicka en bild till slutpunkten för förutsägelse och hämta förutsägelsen lägger du till följande kod i slutet av filen:

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

Kör programmet

Kör sample.go.

go run sample.go

Programmets utdata bör ser ut ungefär som nedanstående text:

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%

Du kan sedan kontrollera att testbilden (finns i <base_image_url>/Images/Test/) har taggats på rätt sätt. Du kan också gå tillbaka till Custom Vision-webbplatsen och se det aktuella tillståndet för det nyskapade projektet.

Rensa resurser

Om du vill implementera ett eget bildklassificeringsprojekt (eller prova ett objektidentifieringsprojekt istället) kan du vilja ta bort projektet för trädidentifiering från det här exemplet. Med en kostnads fri prenumeration kan du använda två Custom Vision projekt.

Navigera till projekt på Custom vision webbplatsoch välj pappers korgen under mitt nya projekt.

Nästa steg

Nu har du sett hur varje steg i objekt identifierings processen kan göras i kod. Det här exemplet kör en enda inlärnings upprepning, men ofta behöver du träna och testa din modell flera gånger för att göra den mer exakt.

• Vad är Custom Vision?
• SDK Reference Documentation (utbildning)
• SDK Reference Documentation (förutsägelse)

Kom igång med att Custom Vision klientbibliotek för Java för att skapa en bildklassificeringsmodell. Följ de här stegen för att installera paketet och prova exempelkoden för grundläggande uppgifter. Använd det här exemplet som en mall för att skapa en egen bildigenkänningsapp.

Använd Custom Vision för Java för att:

• Skapa ett nytt Custom Vision-projekt
• Lägg till taggar i projektet
• Ladda upp och tagga bilder
• Träna projektet
• Publicera den aktuella iterationen
• Testa förutsägelseslutpunkten

Referensdokumentation | Bibliotekskällkod (träning) (förutsägelse)| Artefaktexempel (Maven) (träning) (förutsägelse) |

Förutsättningar

• En Azure-prenumeration – Skapa en kostnadsfritt
• Den aktuella versionen av Java Development Kit (JDK)
• Gradle-byggverktyget, eller någon annan beroendehanterare.
• När du har din Azure-prenumeration skapar du en Custom Vision-resurs för att skapa en Custom Vision-resurs i Azure Portal för att skapa en resurs för träning och förutsägelse och hämta dina nycklar och slutpunkter. Vänta tills den har distribuerats och klicka på knappen Gå till resurs.
  • Du behöver nyckeln och slutpunkten från de resurser som du skapar för att ansluta ditt program till Custom Vision. Du klistrar in din nyckel och slutpunkt i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

Inrätta

Skapa ett nytt Gradle-projekt

I ett konsolfönster (till exempel cmd, PowerShell eller Bash) skapar du en ny katalog för din app och navigerar till den.

mkdir myapp && cd myapp

Kör kommandot gradle init från arbetskatalogen. Det här kommandot skapar viktiga byggfiler för Gradle, inklusive build.gradle.kts, som används vid körning för att skapa och konfigurera ditt program.

gradle init --type basic

Välj en DSL när du uppmanas till det och välj Kotlin.

Installera klientbiblioteket

Leta upp build.gradle.kts och öppna det med önskad IDE eller textredigerare. Kopiera sedan följande byggkonfiguration. Den här konfigurationen definierar projektet som ett Java-program vars startpunkt är klassen CustomVisionQuickstart. Den importerar de Custom Vision biblioteken.

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

Skapa en Java-fil

Kör följande kommando från arbetskatalogen för att skapa en projektkällmapp:

mkdir -p src/main/java

Navigera till den nya mappen och skapa en fil med namnet CustomVisionQuickstart.java. Öppna den i önskat redigeringsprogram eller IDE och lägg till följande import -instruktioner:

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;

I programmets CustomVisionQuickstart-klass skapar du variabler för resursens nycklar och slutpunkt.

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

I programmets main-metod lägger du till anrop för de metoder som används i den här snabbstarten. Du definierar dessa senare.

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

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Custom Vision Java-klientbiblioteket.

Kodexempel

De här kodfragmenten visar hur du utför följande uppgifter med Custom Vision klientbibliotek för Java:

• Autentisera klienten
• Skapa ett nytt Custom Vision-projekt
• Lägg till taggar i projektet
• Ladda upp och tagga bilder
• Träna projektet
• Publicera den aktuella iterationen
• Testa förutsägelseslutpunkten

Autentisera klienten

I huvudmetoden instansierar du tränings- och förutsägelseklienter med hjälp av din slutpunkt och dina nycklar.

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

Skapa ett Custom Vision projekt

T## Skapa ett nytt Custom Vision-projekt

Nästa metod skapar ett bildklassificeringsprojekt. Det skapade projektet visas på den Custom Vision-webbplats som du besökte tidigare. Se överlagringar av createProject-metoder för att ange andra alternativ när du skapar projektet (förklaras i webbportalsguiden Skapa en detektor).

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

Lägga till taggar till projektet

Den här metoden definierar de taggar som du ska träna modellen på.

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

Ladda upp och tagga bilder

Ladda först ned exempelbilderna för det här projektet. Spara innehållet i exempelmappen Bilder på din lokala enhet.

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

Föregående kodfragment använder två hjälpfunktioner som hämtar bilderna som resursströmmar och laddar upp dem till tjänsten (du kan ladda upp upp till 64 bilder i en batch).

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äna projektet

Den här metoden skapar den första tränings iterationen i projektet. Den frågar tjänsten tills träningen har slutförts.

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

Publicera den aktuella iterationen

Den här metoden gör den aktuella iterationen av modellen tillgänglig för frågor. Du kan använda modellnamnet som referens för att skicka förutsägelsebegäranden. Du måste ange ett eget värde för predictionResourceId . Du hittar resurs-ID:t för förutsägelsen på fliken Egenskaper för resursen i Azure Portal listad som Resurs-ID.

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

Testa förutsägelseslutpunkten

Den här metoden läser in testbilden, frågar modellslutpunkten och matar ut förutsägelsedata till konsolen.

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

Kör programmet

Du kan skapa appen med:

gradle build

Kör programmet med gradle run kommandot :

gradle run

Rensa resurser

Om du vill rensa och ta bort en Cognitive Services prenumeration kan du ta bort resursen eller resursgruppen. När du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

• Portal
• Azure CLI

Om du vill implementera ett eget bildklassificeringsprojekt (eller prova ett objektidentifieringsprojekt istället) kan du vilja ta bort projektet för trädidentifiering från det här exemplet. Med en kostnads fri prenumeration kan du använda två Custom Vision projekt.

Navigera till projekt på Custom vision webbplatsoch välj pappers korgen under mitt nya projekt.

Nästa steg

Nu har du sett hur varje steg i bildklassificeringsprocessen kan utföras i kod. Det här exemplet kör en enda tränings-iteration, men ofta behöver du träna och testa din modell flera gånger för att göra den mer exakt.

• Vad är Custom Vision?
• Källkoden för det här exemplet finns på GitHub

Den här guiden innehåller instruktioner och exempelkod som hjälper dig att komma igång med Custom Vision-klientbiblioteket för Node.js att skapa en bildklassificeringsmodell. Du skapar ett projekt, lägger till taggar, tränar projektet och använder projektets slutpunkts-URL för förutsägelse för att testa det programmatiskt. Använd det här exemplet som en mall för att skapa en egen bildigenkänningsapp.

Använd Custom Vision för .NET för att:

• Skapa ett nytt Custom Vision-projekt
• Lägg till taggar i projektet
• Ladda upp och tagga bilder
• Träna projektet
• Publicera den aktuella iterationen
• Testa förutsägelseslutpunkten

Referensdokumentation (träning) (förutsägelse) | Bibliotekskällkod (träning) (förutsägelse) | Paketexempel (npm) (träning) (förutsägelse) |

Förutsättningar

• Azure-prenumeration – Skapa en kostnadsfritt
• Den aktuella versionen av Node.js
• När du har din Azure-prenumeration skapar du en Custom Vision-resurs för att skapa en Custom Vision-resurs i Azure Portal för att skapa en tränings- och förutsägelseresurs och hämta dina nycklar och slutpunkter. Vänta tills den har distribuerats och klicka på knappen Gå till resurs.
  • Du behöver nyckeln och slutpunkten från de resurser som du skapar för att ansluta programmet till Custom Vision. Du klistrar in din nyckel och slutpunkt i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

Inrätta

Skapa ett nytt Node.js-program

I ett konsolfönster (till exempel cmd, PowerShell eller Bash) skapar du en ny katalog för din app och navigerar till den.

mkdir myapp && cd myapp

Kör kommandot npm init för att skapa ett nodprogram med en package.json fil.

npm init

Installera klientbiblioteket

Om du vill skriva en bildanalysapp med Custom Vision för Node.js behöver du de Custom Vision NPM-paketen. Kör följande kommando i PowerShell för att installera dem:

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

Appens package.json fil uppdateras med beroendena.

Skapa en fil med index.js namnet och importera följande bibliotek:

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

Skapa variabler för resursens Azure-slutpunkt och nycklar.

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

Lägg även till fält för projektnamnet och en timeout-parameter för asynkrona anrop.

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

Objektmodell

Kodexempel

De här kodfragmenten visar hur du utför följande uppgifter med Custom Vision klientbibliotek för JavaScript:

• Autentisera klienten
• Skapa ett nytt Custom Vision-projekt
• Lägg till taggar i projektet
• Ladda upp och tagga bilder
• Träna projektet
• Publicera den aktuella iterationen
• Testa förutsägelseslutpunkten

Autentisera klienten

Instansiera klientobjekt med din slutpunkt och nyckel. Skapa ett ApiKeyCredentials-objekt med din nyckel och använd det med slutpunkten för att skapa ett TrainingAPIClient- och PredictionAPIClient-objekt.

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

Skapa ett nytt Custom Vision-projekt

Starta en ny funktion som ska innehålla alla dina Custom Vision funktionsanrop. Lägg till följande kod i för att skapa ett nytt Custom Vision-tjänstprojekt.

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

Lägg till taggar i projektet

Om du vill skapa klassificeringstaggar i projektet lägger du till följande kod i funktionen:

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

Ladda upp och tagga bilder

Ladda först ned exempelbilderna för det här projektet. Spara innehållet i mappen Avbildningsexempel på din lokala enhet.

Infoga följande kod efter att taggen har skapats för att lägga till exempelbilder i projektet. Den här koden laddar upp varje bild med dess motsvarande tagg.

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

Träna projektet

Den här koden skapar den första iterationen av förutsägelsemodellen.

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

Publicera den aktuella iterationen

Den här koden publicerar den tränade iterationen till förutsägelseslutpunkten. Det namn som ges till den publicerade iterationen kan användas för att skicka förutsägelse begär Anden. En iteration är inte tillgänglig i förutsägelseslutpunkten förrän den har publicerats.

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

Testa förutsägelseslutpunkten

Om du vill skicka en bild till förutsägelseslutpunkten och hämta förutsägelsen lägger du till följande kod i funktionen.

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

Stäng sedan din Custom Vision och anropa den.

})()

Kör programmet

Kör programmet med kommandot node i snabbstartsfilen.

node index.js

Programmets utdata bör ser ut ungefär som nedanstående text:

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%

Du kan sedan kontrollera att testbilden (finns i <sampleDataRoot> /Test/) har taggats på rätt sätt. Du kan också gå tillbaka till Custom Vision-webbplatsen och se det aktuella tillståndet för det nyskapade projektet.

Om du vill implementera ett eget bildklassificeringsprojekt (eller prova ett objektidentifieringsprojekt istället) kan du vilja ta bort projektet för trädidentifiering från det här exemplet. Med en kostnads fri prenumeration kan du använda två Custom Vision projekt.

Navigera till projekt på Custom vision webbplatsoch välj pappers korgen under mitt nya projekt.

Nästa steg

Nu har du sett hur varje steg i objektidentifieringsprocessen kan utföras i kod. Det här exemplet kör en enda tränings iteration, men ofta behöver du träna och testa din modell flera gånger för att göra den mer exakt.

• Vad är Custom Vision?
• Källkoden för det här exemplet finns på GitHub
• SDK-referensdokumentation (utbildning)
• SDK-referensdokumentation (förutsägelse)

Kom igång med Custom Vision klientbibliotek för Python. Följ de här stegen för att installera paketet och prova exempelkoden för att skapa en bildklassificeringsmodell. Du skapar ett projekt, lägger till taggar, tränar projektet och använder projektets slutpunkts-URL för förutsägelse för att testa det programmatiskt. Använd det här exemplet som en mall för att skapa en egen bildigenkänningsapp.

Använd Custom Vision för Python för att:

• Skapa ett nytt Custom Vision-projekt
• Lägg till taggar i projektet
• Ladda upp och tagga bilder
• Träna projektet
• Publicera den aktuella iterationen
• Testa förutsägelseslutpunkten

Referensdokumentation | Bibliotekskällkod | Paket (PyPI) | Exempel

Förutsättningar

• Azure-prenumeration – Skapa en utan kostnad
• Python 3.x
  • Python-installationen bör innehålla pip. Du kan kontrollera om du har installerat pip genom pip --version att köra på kommandoraden. Hämta pip genom att installera den senaste versionen av Python.
• När du har din Azure-prenumeration skapar du en Custom Vision-resurs för att skapa en Custom Vision-resurs i Azure Portal för att skapa en utbildnings- och förutsägelseresurs och hämta dina nycklar och slutpunkter. Vänta tills den har distribuerats och klicka på knappen Gå till resurs.
  • Du behöver nyckeln och slutpunkten från de resurser som du skapar för att ansluta ditt program till Custom Vision. Du klistrar in dina nycklar och slutpunkter i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och uppgradera senare till en betald nivå för produktion.

Inrätta

Installera klientbiblioteket

Om du vill skriva en bildanalysapp Custom Vision för Python behöver du Custom Vision klientbiblioteket. När du har installerat Python kör du följande kommando i PowerShell eller ett konsolfönster:

pip install azure-cognitiveservices-vision-customvision

Skapa ett nytt Python-program

Skapa en ny Python-fil och importera följande bibliotek.

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

Skapa variabler för resursens Azure-slutpunkt och prenumerationsnycklar.

# 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"

Objektmodell

Kodexempel

Dessa kodfragment visar hur du gör följande med Custom Vision klientbibliotek för Python:

• Autentisera klienten
• Skapa ett nytt Custom Vision-projekt
• Lägg till taggar i projektet
• Ladda upp och tagga bilder
• Träna projektet
• Publicera den aktuella iterationen
• Testa förutsägelseslutpunkten

Autentisera klienten

Instansiera en tränings- och förutsägelseklient med din slutpunkt och dina nycklar. Skapa ApiKeyServiceClientCredentials-objekt med dina nycklar och använd dem med slutpunkten för att skapa ett CustomVisionTrainingClient- och CustomVisionPredictionClient-objekt.

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)

Skapa ett nytt Custom Vision-projekt

Lägg till följande kod i skriptet för att skapa ett nytt Custom Vision Service-projekt.

Se metoden create_project för att ange andra alternativ när du skapar projektet (förklaras i guiden Skapa en klassificerare i webbportalen).

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)

Lägg till taggar i projektet

Lägg till följande kod för att lägga till klassificeringstaggar i projektet:

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

Ladda upp och tagga bilder

Ladda först ned exempelbilderna för det här projektet. Spara innehållet i exempelmappen Bilder på din lokala enhet.

Infoga följande kod efter att taggen har skapats för att lägga till exempelbilder i projektet. Den här koden laddar upp varje bild med dess motsvarande tagg. Du kan ladda upp upp till 64 bilder i en enda batch.

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)

Träna projektet

Den här koden skapar den första iterationen av förutsägelsemodellen.

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)

Publicera den aktuella iterationen

En iteration är inte tillgänglig i förutsägelseslutpunkten förrän den har publicerats. Följande kod gör den aktuella iterationen av modellen tillgänglig för frågor.

# 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!")

Testa förutsägelseslutpunkten

Om du vill skicka en bild till slutpunkten för förutsägelse och hämta förutsägelsen lägger du till följande kod i slutet av filen:

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

Kör programmet

Kör CustomVisionQuickstart.py.

python CustomVisionQuickstart.py

Programmets utdata bör ser ut ungefär som nedanstående text:

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

Du kan sedan kontrollera att testbilden (finns i <base_image_location>/images/Test/) har taggats på rätt sätt. Du kan också gå tillbaka till Custom Vision-webbplatsen och se det aktuella tillståndet för det nyskapade projektet.

Rensa resurser

Om du vill implementera ett eget bildklassificeringsprojekt (eller prova ett objektidentifieringsprojekt istället) kan du vilja ta bort projektet för trädidentifiering från det här exemplet. Med en kostnads fri prenumeration kan du använda två Custom Vision projekt.

Navigera till projekt på Custom vision webbplatsoch välj pappers korgen under mitt nya projekt.

Nästa steg

Nu har du sett hur varje steg i bildklassificeringsprocessen kan utföras i kod. Det här exemplet kör en enda tränings iteration, men ofta behöver du träna och testa din modell flera gånger för att göra den mer exakt.

• Vad är Custom Vision?
• Källkoden för det här exemplet finns på GitHub
• Referensdokumentation för SDK

Kom igång med Custom Vision REST API. Följ de här stegen för att anropa API:et och skapa en bildklassificeringsmodell. Du skapar ett projekt, lägger till taggar, tränar projektet och använder projektets slutpunkts-URL för förutsägelse för att testa det programmatiskt. Använd det här exemplet som en mall för att skapa en egen bildigenkänningsapp.

Använd Custom Vision för .NET för att:

• Skapa ett nytt Custom Vision-projekt
• Lägg till taggar i projektet
• Ladda upp och tagga bilder
• Träna projektet
• Publicera den aktuella iterationen
• Testa förutsägelseslutpunkten

Förutsättningar

• Azure-prenumeration – Skapa en utan kostnad
• När du har din Azure-prenumeration skapar du en Custom Vision-resurs för att skapa en Custom Vision-resurs i Azure Portal för att skapa en utbildnings- och förutsägelseresurs och hämta dina nycklar och slutpunkter. Vänta tills den har distribuerats och klicka på knappen Gå till resurs.
  • Du behöver nyckeln och slutpunkten från de resurser som du skapar för att ansluta ditt program till Custom Vision. Du klistrar in nyckeln och slutpunkten i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och uppgradera senare till en betald nivå för produktion.
• PowerShell version 6.0+eller ett liknande kommandoradsprogram.

Skapa ett nytt Custom Vision-projekt

Du använder ett kommando som följande för att skapa ett bildklassificeringsprojekt. Det skapade projektet visas på Custom Vision webbplats.

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

Kopiera kommandot till en textredigerare och gör följande ändringar:

• Ersätt {subscription key} med en giltig ansiktsprenumerationsnyckel.
• Ersätt {endpoint} med den slutpunkt som motsvarar din prenumerationsnyckel.

  Anteckning

  Nya resurser som skapats efter den 1 juli 2019 kommer att använda anpassade under domän namn. Mer information och en fullständig lista över regionala slut punkter finns i anpassade under domän namn för Cognitive Services.

• Ersätt {name} med namnet på ditt projekt.
• Du kan också ange andra URL-parametrar för att konfigurera vilken typ av modell projektet ska använda. Se CreatProject API för alternativ.

Du får ett JSON-svar som liknar följande. Spara värdet "id" för projektet på en tillfällig plats.

{
  "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"
}

Lägg till taggar i projektet

Använd följande kommando för att definiera de taggar som du ska träna modellen på.

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

• Infoga återigen din egen nyckel och slutpunkts-URL.
• Ersätt {projectId} med ditt eget projekt-ID.
• Ersätt {name} med namnet på den tagg som du vill använda.

Upprepa den här processen för alla taggar som du vill använda i projektet. Om du använder de exempelbilder som tillhandahålls lägger du till taggarna "Hemlock" och "Japanese Cherry" .

Du får ett JSON-svar som liknar följande. Spara värdet "id" för varje tagg på en tillfällig plats.

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

Ladda upp och tagga bilder

Ladda sedan ned exempelbilderna för det här projektet. Spara innehållet i mappen Avbildningsexempel på din lokala enhet.

Använd följande kommando för att ladda upp bilderna och tillämpa taggar. en gång för "Hemlock"-bilderna och separat för "Japanska Cherry"-bilder. Fler alternativ finns i Create Images From Data API (Skapa avbildningar från data-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}"

• Infoga återigen din egen nyckel och slutpunkts-URL.
• Ersätt {projectId} med ditt eget projekt-ID.
• Ersätt {tagArray} med ID:t för en tagg.
• Fyll sedan i begärans brödtext med binära data för de bilder som du vill tagga.

Träna projektet

Den här metoden tränar modellen på de taggade bilder som du har laddat upp och returnerar ett ID för den aktuella projekt iterationen.

curl -v -X POST -H "Content-Type: application/json" -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/train"

• Infoga återigen din egen nyckel och slutpunkts-URL.
• Ersätt {projectId} med ditt eget projekt-ID.
• Ersätt {tagArray} med ID:t för en tagg.
• Fyll sedan i begärans brödtext med binära data för de bilder som du vill tagga.
• Du kan också använda andra URL-parametrar. Se API:et Train Project (Träna projekt) för alternativ.

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

JSON-svaret innehåller information om det tränade projektet, inklusive iterations-ID ( "id" ). Spara det här värdet för nästa steg.

{
  "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"
}

Publicera den aktuella iterationen

Den här metoden gör den aktuella iterationen av modellen tillgänglig för frågor. Du använder det returnerade modellnamnet som referens för att skicka förutsägelsebegäranden.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/iterations/{iterationId}/publish?publishName={publishName}&predictionId={predictionId}"

• Infoga återigen din egen nyckel och slutpunkts-URL.
• Ersätt {projectId} med ditt eget projekt-ID.
• Ersätt {iterationId} med DET ID som returnerades i föregående steg.
• Ersätt {publishedName} med det namn som du vill tilldela till din förutsägelsemodell.
• Ersätt {predictionId} med ditt eget resurs-ID för förutsägelse. Du hittar resurs-ID:t för förutsägelsen på fliken Egenskaper för resursen i Azure Portal som resurs-ID.
• Du kan också använda andra URL-parametrar. Se API:et Publish Iteration.

Testa förutsägelseslutpunkten

Använd slutligen det här kommandot för att testa din tränade modell genom att ladda upp en ny bild som den kan klassificera med taggar. Du kan använda avbildningen i mappen "Test" i exempelfilerna som du laddade ned tidigare.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/iterations/{iterationId}/publish?publishName={publishName}&predictionId={predictionId}"

• Infoga återigen din egen nyckel och slutpunkts-URL.
• Ersätt {projectId} med ditt eget projekt-ID.
• Ersätt {publishedName} med det namn som du använde i föregående steg.
• Lägg till binära data för din lokala bild i begärandetexten.
• Du kan också använda andra URL-parametrar. Se API:et Klassificera bild.

Det returnerade JSON-svaret är minst var och en av de taggar som modellen tillämpade på bilden, tillsammans med sannolikhetspoäng för varje tagg.

{
  "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"
    }
  ]
}

Om du vill implementera ett eget bildklassificeringsprojekt (eller prova ett objektidentifieringsprojekt istället) kan du vilja ta bort projektet för trädidentifiering från det här exemplet. Med en kostnads fri prenumeration kan du använda två Custom Vision projekt.

Navigera till projekt på Custom vision webbplatsoch välj pappers korgen under mitt nya projekt.

Nästa steg

Nu har du gjort varje steg i bildklassificeringsprocessen med hjälp av REST API. Det här exemplet kör en enda tränings iteration, men ofta behöver du träna och testa din modell flera gånger för att göra den mer exakt.

• Vad är Custom Vision?
• API-referensdokumentation (utbildning)
• API-referensdokumentation (förutsägelse)