Dela via

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

  • Artikel

Kom igång med Custom Vision-klientbiblioteket för .NET. Följ de här stegen för att installera paketet och prova exempelkoden för att skapa en bildklassificeringsmodell. Du kan skapa ett projekt, lägga till taggar, träna projektet och använda projektets förutsägelseslutpunkts-URL för att testa det programmatiskt. Använd det här exemplet som en mall för att skapa en egen app för bildigenkänning.

Kommentar

Om du vill skapa och träna en klassificeringsmodell utan att skriva kod kan du läsa den webbläsarbaserade vägledningen.

Referensdokumentation | Biblioteks källkod för träning och förutsägelse | Paket (NuGet) för tränings- och förutsägelseexempel |

Förutsättningar

  • En Azure-prenumeration. Du kan skapa en kostnadsfritt.
  • Visual Studio IDE eller den aktuella versionen av .NET Core.
  • När du har din Azure-prenumeration skapar du en Custom Vision-resurs i Azure Portal för att skapa en träningsresurs och en förutsägelseresurs.
    • 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.

Skapa miljövariabler

I det här exemplet skriver du dina autentiseringsuppgifter till miljövariabler på den lokala dator som kör programmet.

Gå till Azure-portalen. Om de Custom Vision-resurser som du skapade i avsnittet Förutsättningar har distribuerats väljer du knappen Gå till resurs under Nästa steg. Du hittar dina nycklar och slutpunkter på resursernas nycklar och slutpunktssidor under Resurshantering. Du måste hämta nycklarna för både träningsresursen och förutsägelseresursen, tillsammans med API-slutpunkterna.

Du hittar förutsägelseresurs-ID:t på fliken Egenskaper för förutsägelseresursen i Azure Portal, som visas som Resurs-ID.

Dricks

Du använder https://www.customvision.ai också för att hämta dessa värden. När du har loggat in väljer du ikonen Inställningar längst upp till höger. På sidorna Inställning kan du visa alla nycklar, resurs-ID och slutpunkter.

Om du vill ange miljövariablerna öppnar du ett konsolfönster och följer anvisningarna för operativsystemet och utvecklingsmiljön.

  • Om du vill ange VISION_TRAINING KEY miljövariabeln ersätter du <your-training-key> med en av nycklarna för träningsresursen.
  • Om du vill ange VISION_TRAINING_ENDPOINT miljövariabeln ersätter <your-training-endpoint> du med slutpunkten för träningsresursen.
  • Om du vill ange VISION_PREDICTION_KEY miljövariabeln ersätter du <your-prediction-key> med en av nycklarna för din förutsägelseresurs.
  • Om du vill ange VISION_PREDICTION_ENDPOINT miljövariabeln ersätter du <your-prediction-endpoint> med slutpunkten för förutsägelseresursen.
  • Om du vill ange VISION_PREDICTION_RESOURCE_ID miljövariabeln ersätter du <your-resource-id> med resurs-ID:t för din förutsägelseresurs.

Viktigt!

Om du använder en API-nyckel lagrar du den på ett säkert sätt någon annanstans, till exempel i Azure Key Vault. Inkludera inte API-nyckeln direkt i koden och publicera den aldrig offentligt.

Mer information om säkerhet för AI-tjänster finns i Autentisera begäranden till Azure AI-tjänster.

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

När du har lagt till miljövariablerna kan du behöva starta om alla program som körs som läser miljövariablerna, inklusive konsolfönstret.

Konfigurera

Skapa ett nytt C#-program

Skapa ett nytt .NET Core-program med Hjälp av Visual Studio.

Installera klientbiblioteket

När du har skapat ett nytt projekt installerar du klientbiblioteket genom att högerklicka på projektlösningen i Solution Explorer och välja Hantera NuGet-paket. Välj Bläddra i pakethanteraren som öppnas och kontrollera sedan Inkludera förhandsversion och sök Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training efter och Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction. Välj den senaste versionen och välj sedan Installera.

Dricks

Vill du visa hela snabbstartskodfilen på en gång? Du hittar den på GitHub, som innehåller kodexemplen i den här snabbstarten.

Öppna filen program.cs från projektkatalogen och lägg 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 som hämtar resursens nycklar och slutpunkter från miljövariabler. Du deklarerar också några grundläggande objekt som ska användas senare.

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

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

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

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

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

Autentisera klienten

I en ny metod instansierar du tränings- och förutsägelseklienter med hjälp av slutpunkten och nycklarna.

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 kodbit skapar ett bildklassificeringsprojekt. Det skapade projektet visas på Custom Vision-webbplatsen. Se metoden CreateProject för att ange andra alternativ när du skapar projektet (förklaras i webbportalguiden Skapa en klassificerare).

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

Lägga till taggar till projektet

Den här metoden definierar de taggar som du tränar 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 GetFiles argumentet för att peka på platsen 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);
    }
}

Dricks

Träna med markerade taggar

Du kan också träna på endast en delmängd av dina tillämpade taggar. Du kanske vill göra detta om du inte har tillämpat tillräckligt många av vissa taggar ännu, men du har tillräckligt med andra. Använd parametern i TrainProject-anropettrainingParameters. Skapa en TrainingParameters och ange dess SelectedTags egenskap till en lista över ID:t för de taggar som du vill använda. Modellen tränar för att endast identifiera taggarna i listan.

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 förutsägelseresurs-ID:t på resursens egenskapsflik i Azure Portal, som visas 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 testbilden, frågar modellslutpunkten och genererar förutsägelsedata 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ör appen

Kör programmet genom att klicka på felsökningsknappen överst i IDE-fönstret.

När programmet körs ska det öppna ett konsolfö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. En kostnadsfri prenumeration tillåter två Custom Vision-projekt.

På Custom Vision-webbplatsen går du till Projects (Projekt) och väljer papperskorgen under My New Project (Mitt nya projekt).

Skärmbild av en panel med etiketten Mitt nya projekt med en papperskorgsikon.

Relaterat innehåll

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

Testa och träna om en modell

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

Kommentar

Om du vill skapa och träna en klassificeringsmodell utan att skriva kod kan du läsa den webbläsarbaserade vägledningen.

Använd Custom Vision-klientbiblioteket för Gå till:

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

Referensdokumentation för (träning) och (förutsägelse)

Förutsättningar

  • En Azure-prenumeration. Du kan skapa en kostnadsfritt.
  • Gå 1.8 eller senare.
  • När du har din Azure-prenumeration skapar du en Custom Vision-resurs i Azure Portal för att skapa en tränings- och förutsägelseresurs.
    • 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.

Skapa miljövariabler

I det här exemplet skriver du dina autentiseringsuppgifter till miljövariabler på den lokala dator som kör programmet.

Gå till Azure-portalen. Om de Custom Vision-resurser som du skapade i avsnittet Förutsättningar har distribuerats väljer du knappen Gå till resurs under Nästa steg. Du hittar dina nycklar och slutpunkter på resursernas nycklar och slutpunktssidor under Resurshantering. Du måste hämta nycklarna för både träningsresursen och förutsägelseresursen, tillsammans med API-slutpunkterna.

Du hittar förutsägelseresurs-ID:t på fliken Egenskaper för förutsägelseresursen i Azure Portal, som visas som Resurs-ID.

Dricks

Du använder https://www.customvision.ai också för att hämta dessa värden. När du har loggat in väljer du ikonen Inställningar längst upp till höger. På sidorna Inställning kan du visa alla nycklar, resurs-ID och slutpunkter.

Om du vill ange miljövariablerna öppnar du ett konsolfönster och följer anvisningarna för operativsystemet och utvecklingsmiljön.

  • Om du vill ange VISION_TRAINING KEY miljövariabeln ersätter du <your-training-key> med en av nycklarna för träningsresursen.
  • Om du vill ange VISION_TRAINING_ENDPOINT miljövariabeln ersätter <your-training-endpoint> du med slutpunkten för träningsresursen.
  • Om du vill ange VISION_PREDICTION_KEY miljövariabeln ersätter du <your-prediction-key> med en av nycklarna för din förutsägelseresurs.
  • Om du vill ange VISION_PREDICTION_ENDPOINT miljövariabeln ersätter du <your-prediction-endpoint> med slutpunkten för förutsägelseresursen.
  • Om du vill ange VISION_PREDICTION_RESOURCE_ID miljövariabeln ersätter du <your-resource-id> med resurs-ID:t för din förutsägelseresurs.

Viktigt!

Om du använder en API-nyckel lagrar du den på ett säkert sätt någon annanstans, till exempel i Azure Key Vault. Inkludera inte API-nyckeln direkt i koden och publicera den aldrig offentligt.

Mer information om säkerhet för AI-tjänster finns i Autentisera begäranden till Azure AI-tjänster.

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

När du har lagt till miljövariablerna kan du behöva starta om alla program som körs som läser miljövariablerna, inklusive konsolfönstret.

Konfigurera

Installera Custom Vision-klientbiblioteket

Om du vill skriva en bildanalysapp med Custom Vision for Go behöver du Custom Vision Service-klientbiblioteket. Kör följande kommando i PowerShell:

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

Eller om du använder dep, inom din lagringsplatskörning:

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

Hämta exempelbilderna

I det här exemplet används avbildningarna från Azure AI-tjänsternas Python SDK-exempellagringsplats på GitHub. Klona eller ladda ned den här lagringsplatsen till din utvecklingsmiljö. Kom ihåg dess mappplats för ett senare steg.

Skapa Custom Vision-projektet

Skapa en ny fil med namnet sample.go i önskad projektkatalog och öppna den i önskad kodredigerare.

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

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

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

var (
    training_key string = os.Getenv("VISION_TRAINING_KEY")
    prediction_key string = os.Getenv("VISION_PREDICTION_KEY")
    prediction_resource_id = os.Getenv("VISION_PREDICTION_RESOURCE_ID")
    endpoint string = os.Getenv("VISION_ENDPOINT")    

    project_name string = "Go Sample Project"
    iteration_publish_name = "classifyModel"
    sampleDataDirectory = "<path to sample images>"
)

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

    ctx = context.Background()

    trainer := training.New(training_key, endpoint)

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

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 bilder i en enda batch.

Kommentar

Du måste ändra sökvägen till avbildningarna baserat på var du laddade ned Azure AI-tjänsterna Go SDK Samples-projektet tidigare.

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ägelsemodellen och publicerar sedan iterationen till förutsägelseslutpunkten. Namnet på den publicerade iterationen kan användas för att skicka förutsägelsebegäranden. En iteration är inte tillgänglig i förutsägelseslutpunkten 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ända en förutsägelseslutpunkt

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 appen

Kör programmet med hjälp av följande kommando:

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 (som finns i <base_image_url>/Images/Test/) har taggats korrekt. 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. En kostnadsfri prenumeration tillåter två Custom Vision-projekt.

På Custom Vision-webbplatsen går du till Projects (Projekt) och väljer papperskorgen under My New Project (Mitt nya projekt).

Skärmbild av en panel med etiketten Mitt nya projekt med en papperskorgsikon.

Relaterat innehåll

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

Testa och träna om en modell

Kom igång använda Custom Vision-klientbiblioteket 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 app för bildigenkänning.

Kommentar

Om du vill skapa och träna en klassificeringsmodell utan att skriva kod kan du läsa den webbläsarbaserade vägledningen.

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

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

Referensdokumentation | Bibliotekets källkod för (träning) och (förutsägelse)| Artefakt (Maven) för (träning) och (förutsägelse) | Exempel

Förutsättningar

  • En Azure-prenumeration. Du kan skapa en kostnadsfritt.
  • Den aktuella versionen av Java Development Kit(JDK).
  • Build-verktyget Gradle eller en annan beroendehanterare.
  • När du har din Azure-prenumeration skapar du en Custom Vision-resurs i Azure Portal för att skapa en tränings- och förutsägelseresurs.
    • 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.

Skapa miljövariabler

I det här exemplet skriver du dina autentiseringsuppgifter till miljövariabler på den lokala dator som kör programmet.

Gå till Azure-portalen. Om de Custom Vision-resurser som du skapade i avsnittet Förutsättningar har distribuerats väljer du knappen Gå till resurs under Nästa steg. Du hittar dina nycklar och slutpunkter på resursernas nycklar och slutpunktssidor under Resurshantering. Du måste hämta nycklarna för både träningsresursen och förutsägelseresursen, tillsammans med API-slutpunkterna.

Du hittar förutsägelseresurs-ID:t på fliken Egenskaper för förutsägelseresursen i Azure Portal, som visas som Resurs-ID.

Dricks

Du använder https://www.customvision.ai också för att hämta dessa värden. När du har loggat in väljer du ikonen Inställningar längst upp till höger. På sidorna Inställning kan du visa alla nycklar, resurs-ID och slutpunkter.

Om du vill ange miljövariablerna öppnar du ett konsolfönster och följer anvisningarna för operativsystemet och utvecklingsmiljön.

  • Om du vill ange VISION_TRAINING KEY miljövariabeln ersätter du <your-training-key> med en av nycklarna för träningsresursen.
  • Om du vill ange VISION_TRAINING_ENDPOINT miljövariabeln ersätter <your-training-endpoint> du med slutpunkten för träningsresursen.
  • Om du vill ange VISION_PREDICTION_KEY miljövariabeln ersätter du <your-prediction-key> med en av nycklarna för din förutsägelseresurs.
  • Om du vill ange VISION_PREDICTION_ENDPOINT miljövariabeln ersätter du <your-prediction-endpoint> med slutpunkten för förutsägelseresursen.
  • Om du vill ange VISION_PREDICTION_RESOURCE_ID miljövariabeln ersätter du <your-resource-id> med resurs-ID:t för din förutsägelseresurs.

Viktigt!

Om du använder en API-nyckel lagrar du den på ett säkert sätt någon annanstans, till exempel i Azure Key Vault. Inkludera inte API-nyckeln direkt i koden och publicera den aldrig offentligt.

Mer information om säkerhet för AI-tjänster finns i Autentisera begäranden till Azure AI-tjänster.

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

När du har lagt till miljövariablerna kan du behöva starta om alla program som körs som läser miljövariablerna, inklusive konsolfönstret.

Konfigurera

Skapa ett nytt Gradle-projekt

Skapa en ny katalog för din app i ett konsolfönster (till exempel cmd, PowerShell eller bash) och navigera till den.

mkdir myapp && cd myapp

Kör kommandot från arbetskatalogen gradle init . 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 i följande byggkonfiguration. Den här konfigurationen definierar projektet som ett Java-program vars startpunkt är klassen CustomVisionQuickstart. Den importerar 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

Från arbetskatalogen kör du följande kommando för att skapa en projektkällmapp:

mkdir -p src/main/java

Gå till den nya mappen och skapa en fil med namnet CustomVisionQuickstart.java. Öppna den i önskad redigerare 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;

Dricks

Vill du visa hela snabbstartskodfilen på en gång? Du hittar den på GitHub, som innehåller kodexemplen i den här snabbstarten.

I programmets CustomVisionQuickstart klass skapar du variabler som hämtar resursens nycklar och slutpunkt från miljövariabler.

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

Viktigt!

Kom ihåg att ta bort nycklarna från koden när du är klar och publicera dem aldrig offentligt. För produktion använder du ett säkert sätt att lagra och komma åt dina autentiseringsuppgifter som Azure Key Vault. Mer information finns i säkerhetsartikeln för Azure AI-tjänster.

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.

Name beskrivning
CustomVisionTrainingClient Den här klassen hanterar skapande, träning och publicering av dina modeller.
CustomVisionPredictionClient Den här klassen hanterar frågor till dina modeller för förutsägelser om bildklassificering.
ImagePrediction Den här klassen definierar en enda förutsägelse på en enda bild. Den innehåller egenskaper för objekt-ID och namn samt en konfidenspoäng.

Kodexempel

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

Autentisera klienten

I din main metod instansierar du tränings- och förutsägelseklienter med hjälp av slutpunkten och nycklarna.

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

Skapa ett 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-metoden för att ange andra alternativ när du skapar projektet (förklaras i webbportalguiden 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);
    }
}

Det tidigare kodfragmentet 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 enda 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 förutsägelseresurs-ID:t på resursens egenskapsflik i Azure Portal, som visas 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 appen

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 Azure AI-tjänstprenumeration kan du ta bort resursen eller resursgruppen. Om du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

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. En kostnadsfri prenumeration tillåter två Custom Vision-projekt.

På Custom Vision-webbplatsen går du till Projects (Projekt) och väljer papperskorgen under My New Project (Mitt nya projekt).

Skärmbild av en panel med etiketten Mitt nya projekt med en papperskorgsikon.

Relaterat innehåll

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

Testa och träna om en modell

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 för att skapa en bildklassificeringsmodell. Du kan skapa ett projekt, lägga till taggar, träna projektet och använda projektets förutsägelseslutpunkts-URL för att testa det programmatiskt. Använd det här exemplet som en mall för att skapa en egen app för bildigenkänning.

Kommentar

Om du vill skapa och träna en klassificeringsmodell utan att skriva kod kan du läsa den webbläsarbaserade vägledningen.

Använd Custom Vision-klientbiblioteket för Node.js för att:

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

Referensdokumentation för (träning) och (förutsägelse) | Paket (npm) för (träning) och (förutsägelse) | Exempel

Förutsättningar

  • En Azure-prenumeration. Du kan skapa en kostnadsfritt.
  • Den aktuella versionen av Node.js.
  • När du har din Azure-prenumeration skapar du en Custom Vision-resurs i Azure Portal för att skapa en tränings- och förutsägelseresurs.
    • 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.

Skapa miljövariabler

I det här exemplet skriver du dina autentiseringsuppgifter till miljövariabler på den lokala dator som kör programmet.

Gå till Azure-portalen. Om de Custom Vision-resurser som du skapade i avsnittet Förutsättningar har distribuerats väljer du knappen Gå till resurs under Nästa steg. Du hittar dina nycklar och slutpunkter på resursernas nycklar och slutpunktssidor under Resurshantering. Du måste hämta nycklarna för både träningsresursen och förutsägelseresursen, tillsammans med API-slutpunkterna.

Du hittar förutsägelseresurs-ID:t på fliken Egenskaper för förutsägelseresursen i Azure Portal, som visas som Resurs-ID.

Dricks

Du använder https://www.customvision.ai också för att hämta dessa värden. När du har loggat in väljer du ikonen Inställningar längst upp till höger. På sidorna Inställning kan du visa alla nycklar, resurs-ID och slutpunkter.

Om du vill ange miljövariablerna öppnar du ett konsolfönster och följer anvisningarna för operativsystemet och utvecklingsmiljön.

  • Om du vill ange VISION_TRAINING KEY miljövariabeln ersätter du <your-training-key> med en av nycklarna för träningsresursen.
  • Om du vill ange VISION_TRAINING_ENDPOINT miljövariabeln ersätter <your-training-endpoint> du med slutpunkten för träningsresursen.
  • Om du vill ange VISION_PREDICTION_KEY miljövariabeln ersätter du <your-prediction-key> med en av nycklarna för din förutsägelseresurs.
  • Om du vill ange VISION_PREDICTION_ENDPOINT miljövariabeln ersätter du <your-prediction-endpoint> med slutpunkten för förutsägelseresursen.
  • Om du vill ange VISION_PREDICTION_RESOURCE_ID miljövariabeln ersätter du <your-resource-id> med resurs-ID:t för din förutsägelseresurs.

Viktigt!

Om du använder en API-nyckel lagrar du den på ett säkert sätt någon annanstans, till exempel i Azure Key Vault. Inkludera inte API-nyckeln direkt i koden och publicera den aldrig offentligt.

Mer information om säkerhet för AI-tjänster finns i Autentisera begäranden till Azure AI-tjänster.

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

När du har lagt till miljövariablerna kan du behöva starta om alla program som körs som läser miljövariablerna, inklusive konsolfönstret.

Konfigurera

Skapa ett nytt Node.js-program

Skapa en ny katalog för din app i ett konsolfönster (till exempel cmd, PowerShell eller bash) och navigera till den.

mkdir myapp && cd myapp

Kör kommandot npm init för att skapa ett nodprogram med en package.json-fil. Tryck på RETUR flera gånger för att slutföra processen.

npm init

Installera klientbiblioteket

Om du vill skriva en bildanalysapp med Custom Vision för Node.js behöver du Custom Vision npm-paketen. Installera dem genom att köra följande kommando i PowerShell:

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

Appens package.json fil uppdateras med beroendena.

Skapa en fil med namnet index.js 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");

Dricks

Vill du visa hela snabbstartskodfilen på en gång? Du hittar den på GitHub, som innehåller kodexemplen i den här snabbstarten.

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

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

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

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

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

Objektmodell

Name beskrivning
TrainingAPIClient Den här klassen hanterar skapande, träning och publicering av dina modeller.
PredictionAPIClient Den här klassen hanterar frågor till dina modeller för förutsägelser om bildklassificering.
Prediktion Det här gränssnittet definierar en enda förutsägelse på en enda bild. Den innehåller egenskaper för objekt-ID och namn samt en konfidenspoäng.

Kodexempel

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

Autentisera klienten

Instansiera klientobjekt med slutpunkten och nyckeln. 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 för att innehålla alla dina Custom Vision-funktionsanrop. Lägg till följande kod för att skapa ett nytt Custom Vision Service-projekt.

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

Lägga till taggar till 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 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.

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

Viktigt!

Du måste ändra sökvägen till bilderna (sampleDataRoot) baserat på var du laddade ned Azure AI-tjänsterna Python SDK Samples-lagringsplatsen.

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. Namnet på den publicerade iterationen kan användas för att skicka förutsägelsebegäranden. 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-funktion och anropa den.

})()

Kör appen

Kör programmet med kommandot node på din snabbstartsfil.

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 (som finns i <sampleDataRoot>/Test/) har taggats korrekt. 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. En kostnadsfri prenumeration tillåter två Custom Vision-projekt.

På Custom Vision-webbplatsen går du till Projects (Projekt) och väljer papperskorgen under My New Project (Mitt nya projekt).

Skärmbild av en panel med etiketten Mitt nya projekt med en papperskorgsikon.

Relaterat innehåll

Den här guiden visar hur varje steg i objektidentifieringsprocessen kan göras i kod. Det här exemplet kör en enda tränings iteration, men ofta måste du träna och testa din modell flera gånger för att göra den mer exakt.

Testa och träna om en modell

Kom igång med Custom Vision-klientbiblioteket 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 förutsägelseslutpunkts-URL för att testa det programmatiskt. Använd det här exemplet som en mall för att skapa en egen app för bildigenkänning.

Kommentar

Om du vill skapa och träna en klassificeringsmodell utan att skriva kod kan du läsa den webbläsarbaserade vägledningen.

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

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

Exempel på källkodspaket (PyPI) | för referensdokumentation | |

Förutsättningar

  • En Azure-prenumeration. Du kan skapa en kostnadsfritt.
  • Python 3.x.
    • Python-installationen bör innehålla pip. Du kan kontrollera om du har pip installerat genom att köra pip --version 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 i Azure Portal för att skapa en tränings- och förutsägelseresurs.
    • 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.

Skapa miljövariabler

I det här exemplet skriver du dina autentiseringsuppgifter till miljövariabler på den lokala dator som kör programmet.

Gå till Azure-portalen. Om de Custom Vision-resurser som du skapade i avsnittet Förutsättningar har distribuerats väljer du knappen Gå till resurs under Nästa steg. Du hittar dina nycklar och slutpunkter på resursernas nycklar och slutpunktssidor under Resurshantering. Du måste hämta nycklarna för både träningsresursen och förutsägelseresursen, tillsammans med API-slutpunkterna.

Du hittar förutsägelseresurs-ID:t på fliken Egenskaper för förutsägelseresursen i Azure Portal, som visas som Resurs-ID.

Dricks

Du använder https://www.customvision.ai också för att hämta dessa värden. När du har loggat in väljer du ikonen Inställningar längst upp till höger. På sidorna Inställning kan du visa alla nycklar, resurs-ID och slutpunkter.

Om du vill ange miljövariablerna öppnar du ett konsolfönster och följer anvisningarna för operativsystemet och utvecklingsmiljön.

  • Om du vill ange VISION_TRAINING KEY miljövariabeln ersätter du <your-training-key> med en av nycklarna för träningsresursen.
  • Om du vill ange VISION_TRAINING_ENDPOINT miljövariabeln ersätter <your-training-endpoint> du med slutpunkten för träningsresursen.
  • Om du vill ange VISION_PREDICTION_KEY miljövariabeln ersätter du <your-prediction-key> med en av nycklarna för din förutsägelseresurs.
  • Om du vill ange VISION_PREDICTION_ENDPOINT miljövariabeln ersätter du <your-prediction-endpoint> med slutpunkten för förutsägelseresursen.
  • Om du vill ange VISION_PREDICTION_RESOURCE_ID miljövariabeln ersätter du <your-resource-id> med resurs-ID:t för din förutsägelseresurs.

Viktigt!

Om du använder en API-nyckel lagrar du den på ett säkert sätt någon annanstans, till exempel i Azure Key Vault. Inkludera inte API-nyckeln direkt i koden och publicera den aldrig offentligt.

Mer information om säkerhet för AI-tjänster finns i Autentisera begäranden till Azure AI-tjänster.

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

När du har lagt till miljövariablerna kan du behöva starta om alla program som körs som läser miljövariablerna, inklusive konsolfönstret.

Konfigurera

Installera klientbiblioteket

Om du vill skriva en bildanalysapp med 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

Dricks

Vill du visa hela snabbstartskodfilen på en gång? Du hittar den på GitHub, som innehåller kodexemplen i den här snabbstarten.

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

# retrieve environment variables
ENDPOINT = os.environ["VISION_TRAINING_ENDPOINT"]
training_key = os.environ["VISION_TRAINING_KEY"]
prediction_key = os.environ["VISION_PREDICTION_KEY"]
prediction_resource_id = os.environ["VISION_PREDICTION_RESOURCE_ID"]

Objektmodell

Name beskrivning
CustomVisionTrainingClient Den här klassen hanterar skapande, träning och publicering av dina modeller.
CustomVisionPredictionClient Den här klassen hanterar frågor till dina modeller för förutsägelser om bildklassificering.
ImagePrediction Den här klassen definierar en förutsägelse av ett enskilt objekt på en enda bild. Den innehåller egenskaper för objekt-ID och namn, objektets avgränsningsruta och en konfidenspoäng.

Kodexempel

De här kodfragmenten visar hur du gör följande med Custom Vision-klientbiblioteket för Python:

Autentisera klienten

Instansiera en tränings- och förutsägelseklient med slutpunkten och nycklarna. 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 create_project-metoden för att ange andra alternativ när du skapar projektet (förklaras i webbportalguiden Skapa en klassificerare).

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ägga till taggar till 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)

Kommentar

Du måste ändra sökvägen till avbildningarna baserat på var du laddade ned Azure AI-tjänsternas Python SDK-exempel-lagringsplats.

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)

Dricks

Träna med markerade taggar

Du kan också träna på endast en delmängd av dina tillämpade taggar. Du kanske vill göra detta om du inte har tillämpat tillräckligt många av vissa taggar ännu, men du har tillräckligt med andra. I anropet train_project anger du den valfria parametern selected_tags till en lista över ID-strängarna för de taggar som du vill använda. Modellen tränar för att endast identifiera taggarna i listan.

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 appen

Kör programmet med hjälp av följande kommando:

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 (som finns i <base_image_location>/images/Test/) har taggats korrekt. 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. En kostnadsfri prenumeration tillåter två Custom Vision-projekt.

På Custom Vision-webbplatsen går du till Projects (Projekt) och väljer papperskorgen under My New Project (Mitt nya projekt).

Skärmbild av en panel med etiketten Mitt nya projekt med en papperskorgsikon.

Relaterat innehåll

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

Testa och träna om en modell

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 förutsägelseslutpunkts-URL för att testa det programmatiskt. Använd det här exemplet som en mall för att skapa en egen app för bildigenkänning.

Kommentar

Custom Vision används enklast via ett klientbiblioteks-SDK eller via webbläsarbaserad vägledning.

Använd Custom Vision-klientbiblioteket för REST API för att:

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

Förutsättningar

  • En Azure-prenumeration. Du kan skapa en kostnadsfritt.
  • När du har din Azure-prenumeration skapar du en Custom Vision-resurs i Azure Portal för att skapa en tränings- och förutsägelseresurs.
    • Du behöver nyckeln och slutpunkten från de resurser du skapar för att ansluta ditt program till Custom Vision. Du klistrar in nyckeln och slutpunkten i koden 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-webbplatsen.

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 din giltiga nyckel.
  • Ersätt {endpoint} med slutpunkten som motsvarar din nyckel.

    Kommentar

    Nya resurser som skapats efter den 1 juli 2019 använder anpassade underdomännamn. Mer information och en fullständig lista över regionala slutpunkter finns i Anpassade underdomännamn för Azure AI-tjänster.

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

Ett JSON-svar som i följande exempel visas. Spara värdet för "id" 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ägga till taggar till 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å taggen 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 exempelbilderna lägger du till taggarna "Hemlock" och "Japanese Cherry".

Ett JSON-svar som i följande exempel visas. Spara värdet för "id" varje tagg till 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 exempelmappen Bilder 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 "Japanese Cherry"-bilderna. Fler alternativ finns i SKAPA avbildningar från data-API :et.

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 brödtexten i begäran 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 laddade 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 brödtexten i begäran med binära data för de bilder som du vill tagga.
  • Du kan också använda andra URL-parametrar. Se API:et träna projekt för alternativ.

Dricks

Träna med markerade taggar

Du kan också träna på endast en delmängd av dina tillämpade taggar. Du kanske vill göra detta om du inte har tillämpat tillräckligt många av vissa taggar ännu, men du har tillräckligt med andra. Lägg till det valfria JSON-innehållet i brödtexten i din begäran. Fyll i matrisen "selectedTags" med ID:t för de taggar som du vill använda.

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

JSON-svaret innehåller information om ditt tränade projekt, 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 förutsägelseresurs-ID. Du hittar förutsägelseresurs-ID:t på resursens egenskapsflik i Azure Portal, som visas som resurs-ID.
  • Du kan också använda andra URL-parametrar. Se API:et Publicera 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 avbildning så att den kan klassificeras med taggar. Du kan använda avbildningen i mappen Test för de exempelfiler 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 avbildning i begärandetexten.
  • Du kan också använda andra URL-parametrar. Se API:et Klassificera avbildning .

Det returnerade JSON-svaret visar var och en av taggarna som modellen tillämpade på din bild, 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. En kostnadsfri prenumeration tillåter två Custom Vision-projekt.

På Custom Vision-webbplatsen går du till Projects (Projekt) och väljer papperskorgen under My New Project (Mitt nya projekt).

Skärmbild av en panel med etiketten Mitt nya projekt med en papperskorgsikon.

Relaterat innehåll

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

Testa och träna om en modell