Szybki start: tworzenie projektu wykrywania obiektów za pomocą biblioteki klienta usługi Custom Vision

Rozpocznij pracę z biblioteką klienta usługi Custom Vision dla .NET. Wykonaj następujące kroki, aby zainstalować pakiet i wypróbować przykładowy kod tworzenia modelu wykrywania obiektów. Utworzysz projekt, dodasz tagi, wytrenujesz projekt na przykładowych obrazach i użyjesz adresu URL punktu końcowego przewidywania projektu, aby programowo go przetestować. Użyj tego przykładu jako szablonu do tworzenia własnej aplikacji do rozpoznawania obrazów.

dokumentacja referencyjna Reference | Kod źródłowy biblioteki (training)(prediction) | Pakiet (NuGet) (training)(prediction) | Przykłady

Wymagania wstępne

• subskrypcja Azure — Utwórz ją bezpłatnie
• Visual Studio IDE lub bieżąca wersja .NET Core.
• Po uzyskaniu subskrypcji Azure, utwórz zasób Custom Vision w portalu Azure, aby utworzyć zasób szkoleniowy i zasób przewidywań.
  • Możesz użyć warstwy cenowej bezpłatna (F0), aby wypróbować usługę, a następnie uaktualnić ją do warstwy płatnej dla środowiska produkcyjnego.

Tworzenie zmiennych środowiskowych

W tym przykładzie wstawisz swoje poświadczenia do zmiennych środowiskowych na lokalnej maszynie uruchamiającej aplikację.

Przejdź do portalu Azure. Jeśli zasoby usługi Custom Vision utworzone w sekcji Wymagania wstępne zostały wdrożone pomyślnie, wybierz przycisk Przejdź do zasobu w obszarze Następne kroki. Klucze i punkty końcowe można znaleźć na stronach Klucze i punkty końcowe zasobów w obszarze Zarządzanie zasobami. Musisz uzyskać klucze zarówno do zasobu szkoleniowego, jak i zasobu predykcyjnego, wraz z punktami końcowymi API.

Identyfikator zasobu przewidywania można znaleźć na karcie Właściwości na karcie portalu Azure, na liście Resource ID.

Aby ustawić zmienne środowiskowe, otwórz okno konsoli i postępuj zgodnie z instrukcjami dotyczącymi systemu operacyjnego i środowiska programistycznego.

• Aby ustawić zmienną VISION_TRAINING KEY środowiskową, zastąp <your-training-key> jednym z kluczy zasobu szkoleniowego.
• Aby ustawić zmienną środowiska VISION_TRAINING_ENDPOINT, zastąp <your-training-endpoint> punktem końcowym swojego zasobu szkoleniowego.
• Aby ustawić zmienną VISION_PREDICTION_KEY środowiskową, zamień <your-prediction-key> jednym z kluczy zasobu przewidywania.
• Aby ustawić zmienną VISION_PREDICTION_ENDPOINT środowiskową, zastąp <your-prediction-endpoint> punktem końcowym zasobu prognozowania.
• Aby ustawić zmienną VISION_PREDICTION_RESOURCE_ID środowiskową, zastąp <your-resource-id> wartość identyfikatorem zasobu przewidywania.

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>

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Konfigurowanie

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

W katalogu projektu otwórz plik program.cs i dodaj następujące using dyrektywy:

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;

W metodzie Main aplikacji utwórz zmienne, które pobierają klucze zasobu i punkt końcowy ze zmiennych środowiskowych. Zadeklarujesz również niektóre podstawowe obiekty, które będą używane później.

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

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

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

W metodzie Main aplikacji dodaj wywołania metod używanych w tym przewodniku wprowadzającym. Zostaną one zaimplementowane później.

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

Uwierzytelnianie klienta

W nowej metodzie utwórz instancję przy użyciu punktu końcowego i kluczy dla klientów trenowania i przewidywania.

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

Tworzenie nowego projektu usługi Custom Vision

Ta następna metoda tworzy projekt wykrywania obiektów. Utworzony projekt zostanie wyświetlony w witrynie internetowej usługi Custom Vision. Zobacz metodę CreateProject, aby określić inne opcje podczas tworzenia projektu (wyjaśniono to w przewodniku po portalu internetowym Build a detector).

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

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

    return project;
}

Dodawanie tagów do projektu

Ta metoda definiuje tagi, na których będzie trenowany model.

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

Przekazywanie i tagowanie obrazów

Najpierw pobierz przykładowe obrazy dla tego projektu. Zapisz zawartość folderu sample Images na urządzeniu lokalnym.

Podczas tagowania obrazów w projektach wykrywania obiektów należy określić region każdego obiektu oznakowanego przy użyciu znormalizowanych współrzędnych. Poniższy kod kojarzy każdy z przykładowych obrazów z oznaczonym regionem.

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

Następnie ta mapa skojarzeń służy do ładowania każdego obrazu próbki ze współrzędnymi regionów. Za jednym razem można wgrać maksymalnie 64 obrazy. Może być konieczne zmianę imagePath wartości tak, aby wskazywała prawidłowe lokalizacje folderów.

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

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

W tym momencie przesłałeś wszystkie przykładowe obrazy i otagowałeś każdy z nich (widelec lub nożyce) skojarzonym prostokątem pikseli.

Szkolenie projektu

Ta metoda tworzy pierwszą iterację szkoleniową w projekcie. Wysyła zapytanie do usługi aż do zakończenia szkolenia.

private void TrainProject(CustomVisionTrainingClient trainingApi, Project project)
{

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

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

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

Publikowanie bieżącej iteracji

Ta metoda udostępnia bieżącą iterację modelu na potrzeby wykonywania zapytań. Możesz użyć nazwy modelu jako odwołania do wysyłania żądań przewidywania. Musisz wprowadzić własną wartość dla predictionResourceId. Identyfikator zasobu przewidywania można znaleźć na karcie Właściwości w portalu Azure wyświetlonym jako Resource ID.

private void PublishIteration(CustomVisionTrainingClient trainingApi, Project project)
{

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

Testowanie punktu końcowego przewidywania

Ta metoda ładuje obraz testowy, wysyła zapytanie do punktu końcowego modelu i generuje dane przewidywania do konsoli.

private void TestIteration(CustomVisionPredictionClient predictionApi, Project project)
{

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

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

Uruchamianie aplikacji

dotnet run

Po uruchomieniu aplikacji powinno zostać otwarte okno konsoli i zapisać następujące dane wyjściowe:

Creating new project:
        Training
Done!

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

Następnie możesz sprawdzić, czy obraz testowy (znaleziony w obszarze Images/Test/) jest odpowiednio oznakowany i czy region wykrywania jest poprawny. W tym momencie możesz nacisnąć dowolny klawisz, aby zamknąć aplikację.

Czyszczenie zasobów

Jeśli chcesz zaimplementować własny projekt wykrywania obiektów (lub zamiast tego wypróbować projekt klasyfikacji obrazów ), możesz usunąć projekt wykrywania rozwidlenia/nożyczków z tego przykładu. Bezpłatna subskrypcja umożliwia korzystanie z dwóch projektów usługi Custom Vision.

W witrynie internetowej Custom Vision przejdź do Projects i wybierz kosz w obszarze Mój nowy Project.

Następne kroki

Teraz wykonano każdy krok procesu wykrywania obiektów w kodzie. Ten przykład wykonuje pojedynczą iterację trenowania, ale często trzeba będzie trenować i testować model wielokrotnie, aby był bardziej dokładny. Poniższy przewodnik dotyczy klasyfikacji obrazów, ale jego zasady są podobne do wykrywania obiektów.

• Co to jest usługa Custom Vision?
• Kod źródłowy dla tego przykładu można znaleźć w witrynie GitHub
• Dokumentacja referencyjna zestawu SDK

Ten przewodnik zawiera instrukcje i przykładowy kod, który ułatwia rozpoczęcie korzystania z biblioteki klienta usługi Custom Vision dla języka Go w celu utworzenia modelu wykrywania obiektów. Utworzysz projekt, dodasz tagi, wytrenujesz projekt i użyjesz adresu URL punktu końcowego przewidywania projektu, aby programowo go przetestować. Użyj tego przykładu jako szablonu do tworzenia własnej aplikacji do rozpoznawania obrazów.

Dokumentacja referencyjna (trening)(przewidywanie)

Wymagania wstępne

• subskrypcja Azure — Utwórz ją bezpłatnie
• Przejdź do wersji 1.8 lub nowszej
• Po utworzeniu subskrypcji usługi Azure tworzenie zasobu usługi Custom Vision w portalu Azure w celu utworzenia zasobu trenowania i przewidywania.
  • Możesz użyć warstwy cenowej bezpłatna (F0), aby wypróbować usługę, a następnie uaktualnić ją do warstwy płatnej dla środowiska produkcyjnego.

Tworzenie zmiennych środowiskowych

W tym przykładzie wstawisz swoje poświadczenia do zmiennych środowiskowych na lokalnej maszynie uruchamiającej aplikację.

Przejdź do portalu Azure. Jeśli zasoby usługi Custom Vision utworzone w sekcji Wymagania wstępne zostały wdrożone pomyślnie, wybierz przycisk Przejdź do zasobu w obszarze Następne kroki. Klucze i punkty końcowe można znaleźć na stronach Klucze i punkty końcowe zasobów w obszarze Zarządzanie zasobami. Musisz uzyskać klucze zarówno do zasobu szkoleniowego, jak i zasobu predykcyjnego, wraz z punktami końcowymi API.

Identyfikator zasobu przewidywania można znaleźć na karcie Właściwości na karcie portalu Azure, na liście Resource ID.

Aby ustawić zmienne środowiskowe, otwórz okno konsoli i postępuj zgodnie z instrukcjami dotyczącymi systemu operacyjnego i środowiska programistycznego.

• Aby ustawić zmienną VISION_TRAINING KEY środowiskową, zastąp <your-training-key> jednym z kluczy zasobu szkoleniowego.
• Aby ustawić zmienną środowiska VISION_TRAINING_ENDPOINT, zastąp <your-training-endpoint> punktem końcowym swojego zasobu szkoleniowego.
• Aby ustawić zmienną VISION_PREDICTION_KEY środowiskową, zamień <your-prediction-key> jednym z kluczy zasobu przewidywania.
• Aby ustawić zmienną VISION_PREDICTION_ENDPOINT środowiskową, zastąp <your-prediction-endpoint> punktem końcowym zasobu prognozowania.
• Aby ustawić zmienną VISION_PREDICTION_RESOURCE_ID środowiskową, zastąp <your-resource-id> wartość identyfikatorem zasobu przewidywania.

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>

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Konfigurowanie

Instalowanie biblioteki klienta usługi Custom Vision

Aby napisać aplikację do analizy obrazów za pomocą usługi Custom Vision for Go, potrzebujesz biblioteki klienta usługi Custom Vision. Uruchom następujące polecenie w programie PowerShell:

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

lub jeśli używasz dep, uruchom w repozytorium:

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

Pobieranie przykładowych obrazów

W tym przykładzie użyto obrazów z repozytorium Foundry Tools Python SDK Samples w GitHub. Sklonuj lub pobierz to repozytorium do środowiska deweloperskiego. Zapamiętaj jego lokalizację folderu w późniejszym kroku.

Tworzenie projektu usługi Custom Vision

Utwórz nowy plik o nazwie sample.go w preferowanym katalogu projektu i otwórz go w preferowanym edytorze kodu.

Dodaj następujący kod do skryptu, aby utworzyć nowy projekt usługi Custom Vision.

Zobacz metodę CreateProject, aby określić inne opcje podczas tworzenia projektu (wyjaśniono w przewodniku portalu Budowanie detektora).

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

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

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

    ctx = context.Background()

    trainer := training.New(training_key, endpoint)

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

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

Tworzenie tagów w projekcie

Aby utworzyć tagi klasyfikacji w projekcie, dodaj następujący kod na końcu pliku sample.go:

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

Przekazywanie i tagowanie obrazów

Podczas tagowania obrazów w projektach wykrywania obiektów należy określić region każdego obiektu oznakowanego przy użyciu znormalizowanych współrzędnych.

Aby dodać obrazy, tagi i regiony do projektu, wstaw następujący kod po utworzeniu tagu. Pamiętaj, że w tym samouczku regiony są zakodowane na stałe w treści. Regiony określają ramkę ograniczającą w znormalizowanych współrzędnych, a współrzędne są podane w kolejności: lewa, górna, szerokość, wysokość.

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

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

Następnie użyj tej mapy skojarzeń, aby przekazać każdy przykładowy obraz ze współrzędnymi regionu (można przekazać do 64 obrazów w jednej partii). Dodaj następujący kod.

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

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

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

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

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

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

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

Trenowanie i publikowanie projektu

Ten kod tworzy pierwszą iterację modelu predykcyjnego, a następnie publikuje ją w punkcie końcowym predykcyjnym. Nazwa nadana opublikowanej iteracji może służyć do wysyłania żądań przewidywania. Iteracja nie jest dostępna w punkcie końcowym przewidywania, dopóki nie zostanie opublikowana.

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

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

Korzystanie z punktu końcowego przewidywania

Aby wysłać obraz do punktu końcowego przewidywania i pobrać przewidywanie, dodaj następujący kod na końcu pliku:

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

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

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

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

Uruchamianie aplikacji

Uruchom sample.go.

go run sample.go

Dane wyjściowe aplikacji powinny pojawić się w konsoli. Następnie możesz sprawdzić, czy obraz testowy (znaleziony w przykładach/obrazach/obrazach/testach) jest odpowiednio oznakowany i czy region wykrywania jest poprawny.

Czyszczenie zasobów

Jeśli chcesz zaimplementować własny projekt wykrywania obiektów (lub zamiast tego wypróbować projekt klasyfikacji obrazów ), możesz usunąć projekt wykrywania rozwidlenia/nożyczków z tego przykładu. Bezpłatna subskrypcja umożliwia korzystanie z dwóch projektów usługi Custom Vision.

W witrynie internetowej Custom Vision przejdź do Projects i wybierz kosz w obszarze Mój nowy Project.

Następne kroki

Teraz wykonano każdy krok procesu wykrywania obiektów w kodzie. Ten przykład wykonuje pojedynczą iterację trenowania, ale często trzeba będzie trenować i testować model wielokrotnie, aby był bardziej dokładny. Poniższy przewodnik dotyczy klasyfikacji obrazów, ale jego zasady są podobne do wykrywania obiektów.

• Co to jest usługa Custom Vision?
• dokumentacja referencyjna SDK (szkolenie)
• dokumentacja referencyjna SDK (predykcja)

Rozpocznij korzystanie z biblioteki klienta usługi Custom Vision dla Java w celu utworzenia modelu wykrywania obiektów. Wykonaj następujące kroki, aby zainstalować pakiet i wypróbować przykładowy kod dla podstawowych zadań. Użyj tego przykładu jako szablonu do tworzenia własnej aplikacji do rozpoznawania obrazów.

dokumentacja referencyjna | Kod źródłowy biblioteki (training)(prediction)| Artifact (Maven) (training)(prediction)Przykłady

Wymagania wstępne

• Subskrypcja Azure — Utwórz ją bezpłatnie
• Bieżąca wersja zestawu Java Development Kit(JDK)
• Narzędzie budujące Gradle lub inny menedżer zależności.
• Po uzyskaniu subskrypcji Azure, utwórz zasób Custom Vision w portalu Azure, aby utworzyć zasób szkoleniowy i zasób przewidywań.
  • Możesz użyć warstwy cenowej bezpłatna (F0), aby wypróbować usługę, a następnie uaktualnić ją do warstwy płatnej dla środowiska produkcyjnego.

Tworzenie zmiennych środowiskowych

W tym przykładzie wstawisz swoje poświadczenia do zmiennych środowiskowych na lokalnej maszynie uruchamiającej aplikację.

Przejdź do portalu Azure. Jeśli zasoby usługi Custom Vision utworzone w sekcji Wymagania wstępne zostały wdrożone pomyślnie, wybierz przycisk Przejdź do zasobu w obszarze Następne kroki. Klucze i punkty końcowe można znaleźć na stronach Klucze i punkty końcowe zasobów w obszarze Zarządzanie zasobami. Musisz uzyskać klucze zarówno do zasobu szkoleniowego, jak i zasobu predykcyjnego, wraz z punktami końcowymi API.

Identyfikator zasobu przewidywania można znaleźć na karcie Właściwości na karcie portalu Azure, na liście Resource ID.

Aby ustawić zmienne środowiskowe, otwórz okno konsoli i postępuj zgodnie z instrukcjami dotyczącymi systemu operacyjnego i środowiska programistycznego.

• Aby ustawić zmienną VISION_TRAINING KEY środowiskową, zastąp <your-training-key> jednym z kluczy zasobu szkoleniowego.
• Aby ustawić zmienną środowiska VISION_TRAINING_ENDPOINT, zastąp <your-training-endpoint> punktem końcowym swojego zasobu szkoleniowego.
• Aby ustawić zmienną VISION_PREDICTION_KEY środowiskową, zamień <your-prediction-key> jednym z kluczy zasobu przewidywania.
• Aby ustawić zmienną VISION_PREDICTION_ENDPOINT środowiskową, zastąp <your-prediction-endpoint> punktem końcowym zasobu prognozowania.
• Aby ustawić zmienną VISION_PREDICTION_RESOURCE_ID środowiskową, zastąp <your-resource-id> wartość identyfikatorem zasobu przewidywania.

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>

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Konfigurowanie

Tworzenie nowego projektu narzędzia Gradle

W oknie konsoli (takim jak cmd, PowerShell lub Bash) utwórz nowy katalog dla aplikacji i przejdź do niego.

mkdir myapp && cd myapp

Uruchom polecenie gradle init z katalogu roboczego. To polecenie spowoduje utworzenie podstawowych plików kompilacji dla narzędzia Gradle, w tym pliku build.gradle.kts, który jest używany w czasie wykonywania do tworzenia i konfigurowania aplikacji.

gradle init --type basic

Kiedy zostaniesz poproszony o wybranie języka DSL, wybierz Kotlin.

Instalowanie biblioteki klienta

Znajdź plik build.gradle.kts i otwórz go przy użyciu preferowanego środowiska IDE lub edytora tekstów. Następnie skopiuj poniższą konfigurację kompilacji. Ta konfiguracja definiuje projekt jako aplikację Java, której punktem wejścia jest klasa CustomVisionQuickstart. Importuje biblioteki Custom Vision.

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

Tworzenie pliku Java

W katalogu roboczym uruchom następujące polecenie, aby utworzyć folder źródłowy projektu:

mkdir -p src/main/java

Przejdź do nowego folderu i utwórz plik o nazwie CustomVisionQuickstart.java. Otwórz go w preferowanym edytorze lub środowisku IDE i dodaj następujące import instrukcje:

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;

W klasie CustomVisionQuickstart aplikacji utwórz zmienne pobierające klucze i punkt końcowy zasobu ze zmiennych środowiskowych.

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

W głównej metodzie aplikacji dodaj wywołania metod używanych w tym przewodniku szybkiego startu. Te elementy zdefiniujesz później.

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

Model obiektów

Następujące klasy i interfejsy obsługują niektóre główne funkcje biblioteki klienta usługi Custom Vision Java.

Przykłady kodu

Te fragmenty kodu pokazują, jak wykonać następujące zadania za pomocą biblioteki klienta usługi Custom Vision dla Java:

• Uwierzytelnianie klienta
• Tworzenie nowego projektu usługi Custom Vision
• Dodawanie tagów do projektu
• Przekazywanie i tagowanie obrazów
• Trenuj projekt
• Publikowanie bieżącej iteracji
• Testowanie punktu końcowego przewidywania

Uwierzytelnianie klienta

W metodzie głównej zainicjuj klientów trenowania i przewidywania, używając swojego punktu końcowego i kluczy.

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

Tworzenie nowego projektu usługi Custom Vision

Ta następna metoda tworzy projekt wykrywania obiektów. Utworzony projekt zostanie wyświetlony na stronie Custom Vision, którą odwiedziłeś wcześniej. Zobacz wersje przeciążone metody CreateProject, aby określić inne opcje podczas tworzenia projektu (objaśnione w przewodniku portalu internetowego 'Budowanie detektora').

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

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

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

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

    return project;
}

Dodawanie tagów do projektu

Ta metoda definiuje tagi, na których będzie trenowany model.

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

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

Przekazywanie i tagowanie obrazów

Najpierw pobierz przykładowe obrazy dla tego projektu. Zapisz zawartość folderu sample Images na urządzeniu lokalnym.

Podczas tagowania obrazów w projektach wykrywania obiektów należy określić region każdego obiektu oznakowanego przy użyciu znormalizowanych współrzędnych. Poniższy kod kojarzy każdy z przykładowych obrazów z oznaczonym regionem.

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

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

Następny blok kodu dodaje obrazy do projektu. Należy zmienić argumenty wywołań GetImage, aby wskazywały lokalizacje pobranych folderów forka i scissors.

    Trainings trainer = trainClient.trainings();

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

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

Poprzedni fragment kodu korzysta z dwóch funkcji pomocnika, które pobierają obrazy jako strumienie zasobów i przekazują je do usługi (można przekazać do 64 obrazów w jednej partii). Zdefiniuj te metody.

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

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

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

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

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

Szkolenie projektu

Ta metoda tworzy pierwszą iterację szkoleniową w projekcie. Wysyła zapytanie do usługi aż do zakończenia szkolenia.

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

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

Publikowanie bieżącej iteracji

Ta metoda udostępnia bieżącą iterację modelu na potrzeby wykonywania zapytań. Możesz użyć nazwy modelu jako odwołania do wysyłania żądań przewidywania. Musisz wprowadzić własną wartość dla predictionResourceId. Identyfikator zasobu przewidywania można znaleźć na karcie Właściwości w portalu Azure wyświetlonym jako Resource ID.

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

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

Testowanie punktu końcowego przewidywania

Ta metoda ładuje obraz testowy, wysyła zapytanie do punktu końcowego modelu i generuje dane przewidywania do konsoli.

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

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

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

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

Uruchamianie aplikacji

Aplikację można skompilować za pomocą następujących funkcji:

gradle build

Uruchom aplikację za pomocą polecenia gradle run.

gradle run

Czyszczenie zasobów

Jeśli chcesz wyczyścić i usunąć subskrypcję Azure AI services, możesz usunąć zasób lub grupę zasobów. Usunięcie grupy zasobów powoduje również usunięcie wszelkich innych skojarzonych z nią zasobów.

• portal Azure
• Azure CLI

Jeśli chcesz zaimplementować własny projekt wykrywania obiektów (lub zamiast tego wypróbować projekt klasyfikacji obrazów ), możesz usunąć projekt wykrywania rozwidlenia/nożyczków z tego przykładu. Bezpłatna subskrypcja umożliwia korzystanie z dwóch projektów usługi Custom Vision.

W witrynie internetowej Custom Vision przejdź do Projects i wybierz kosz w obszarze Mój nowy Project.

Następne kroki

Teraz wykonano każdy krok procesu wykrywania obiektów w kodzie. Ten przykład wykonuje pojedynczą iterację trenowania, ale często trzeba będzie trenować i testować model wielokrotnie, aby był bardziej dokładny. Poniższy przewodnik dotyczy klasyfikacji obrazów, ale jego zasady są podobne do wykrywania obiektów.

• Co to jest usługa Custom Vision?
• Kod źródłowy dla tego przykładu można znaleźć w witrynie GitHub

Ten przewodnik zawiera instrukcje i przykładowy kod, który ułatwia rozpoczęcie korzystania z biblioteki klienta usługi Custom Vision dla Node.js w celu utworzenia modelu wykrywania obiektów. Utworzysz projekt, dodasz tagi, wytrenujesz projekt i użyjesz adresu URL punktu końcowego przewidywania projektu, aby programowo go przetestować. Użyj tego przykładu jako szablonu do tworzenia własnej aplikacji do rozpoznawania obrazów.

Dokumentacja referencyjna (training)(prediction) | Pakiet (npm) (training)(prediction) | Przykłady

Wymagania wstępne

• subskrypcja Azure — Utwórz ją bezpłatnie
• Bieżąca wersja Node.js
• Po uzyskaniu subskrypcji Azure, utwórz zasób Custom Vision w portalu Azure, aby utworzyć zasób szkoleniowy i zasób przewidywań.
  • Możesz użyć warstwy cenowej bezpłatna (F0), aby wypróbować usługę, a następnie uaktualnić ją do warstwy płatnej dla środowiska produkcyjnego.

Tworzenie zmiennych środowiskowych

W tym przykładzie wstawisz swoje poświadczenia do zmiennych środowiskowych na lokalnej maszynie uruchamiającej aplikację.

Przejdź do portalu Azure. Jeśli zasoby usługi Custom Vision utworzone w sekcji Wymagania wstępne zostały wdrożone pomyślnie, wybierz przycisk Przejdź do zasobu w obszarze Następne kroki. Klucze i punkty końcowe można znaleźć na stronach Klucze i punkty końcowe zasobów w obszarze Zarządzanie zasobami. Musisz uzyskać klucze zarówno do zasobu szkoleniowego, jak i zasobu predykcyjnego, wraz z punktami końcowymi API.

Identyfikator zasobu przewidywania można znaleźć na karcie Właściwości na karcie portalu Azure, na liście Resource ID.

Aby ustawić zmienne środowiskowe, otwórz okno konsoli i postępuj zgodnie z instrukcjami dotyczącymi systemu operacyjnego i środowiska programistycznego.

• Aby ustawić zmienną VISION_TRAINING KEY środowiskową, zastąp <your-training-key> jednym z kluczy zasobu szkoleniowego.
• Aby ustawić zmienną środowiska VISION_TRAINING_ENDPOINT, zastąp <your-training-endpoint> punktem końcowym swojego zasobu szkoleniowego.
• Aby ustawić zmienną VISION_PREDICTION_KEY środowiskową, zamień <your-prediction-key> jednym z kluczy zasobu przewidywania.
• Aby ustawić zmienną VISION_PREDICTION_ENDPOINT środowiskową, zastąp <your-prediction-endpoint> punktem końcowym zasobu prognozowania.
• Aby ustawić zmienną VISION_PREDICTION_RESOURCE_ID środowiskową, zastąp <your-resource-id> wartość identyfikatorem zasobu przewidywania.

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>

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Konfigurowanie

Tworzenie nowej aplikacji Node.js

W oknie konsoli (takim jak cmd, PowerShell lub Bash) utwórz nowy katalog dla aplikacji i przejdź do niego.

mkdir myapp && cd myapp

Uruchom polecenie npm init, aby utworzyć aplikację Node.js z plikiem package.json.

npm init

Instalowanie biblioteki klienta

Aby napisać aplikację do analizy obrazów za pomocą usługi Custom Vision dla Node.js, potrzebne są pakiety npm usługi Custom Vision. Aby je zainstalować, uruchom następujące polecenie w programie PowerShell:

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

Plik aplikacji package.json jest aktualizowany przy użyciu zależności.

Utwórz plik o nazwie index.js i zaimportuj następujące biblioteki:

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

Utwórz zmienne dla punktu końcowego Azure i kluczy zasobu.

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

Dodaj również pola dla nazwy projektu i parametr limitu czasu dla wywołań asynchronicznych.

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

Model obiektów

Przykłady kodu

Te fragmenty kodu pokazują, jak wykonać następujące zadania za pomocą biblioteki klienta usługi Custom Vision dla języka JavaScript:

• Uwierzytelnianie klienta
• Tworzenie nowego projektu usługi Custom Vision
• Dodawanie tagów do projektu
• Przekazywanie i tagowanie obrazów
• Trenuj projekt
• Publikowanie bieżącej iteracji
• Testowanie punktu końcowego przewidywania

Uwierzytelnianie klienta

Utwórz wystąpienie obiektu klienta przy użyciu Twojego punktu końcowego i Twojego klucza. Utwórz obiekt ApiKeyCredentials używając klucza, a następnie użyj go z punktem końcowym, aby utworzyć obiekty TrainingAPIClient i PredictionAPIClient.

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

Dodawanie funkcji pomocnika

Dodaj następującą funkcję, aby ułatwić wykonanie wielu wywołań asynchronicznych. Użyjesz tego później.

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

Tworzenie nowego projektu usługi Custom Vision

Uruchom nową funkcję, aby zawierała wszystkie wywołania funkcji Custom Vision. Dodaj następujący kod, aby utworzyć nowy projekt usługi Custom Vision.

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

Dodawanie tagów do projektu

Aby utworzyć tagi klasyfikacji w projekcie, dodaj następujący kod do funkcji:

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

Przekazywanie i tagowanie obrazów

Najpierw pobierz przykładowe obrazy dla tego projektu. Zapisz zawartość folderu sample Images na urządzeniu lokalnym.

Aby dodać przykładowe obrazy do projektu, wstaw następujący kod po utworzeniu tagu. Ten kod ładuje każde zdjęcie z odpowiednim tagiem. Podczas tagowania obrazów w projektach wykrywania obiektów należy określić region każdego obiektu oznakowanego przy użyciu znormalizowanych współrzędnych. Na potrzeby tego samouczka regiony są zakodowane na stałe w kodzie. Regiony określają ramkę ograniczającą w znormalizowanych współrzędnych, a współrzędne są podane w kolejności: lewa, górna, szerokość, wysokość. Za jednym razem można wgrać maksymalnie 64 obrazy.

const sampleDataRoot = "Images";

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

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

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

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

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

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

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

await Promise.all(fileUploadPromises);

Szkolenie projektu

Ten kod tworzy pierwszą iterację modelu przewidywania.

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

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

Publikowanie bieżącej iteracji

Ten kod publikuje wytrenowana iterację do punktu końcowego przewidywania. Nazwa nadana opublikowanej iteracji może służyć do wysyłania żądań przewidywania. Iteracja nie jest dostępna w punkcie końcowym przewidywania, dopóki nie zostanie opublikowana.

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

Testowanie punktu końcowego przewidywania

Aby wysłać obraz do punktu końcowego przewidywania i pobrać przewidywanie, dodaj następujący kod do funkcji.

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

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

Następnie zamknij funkcję Custom Vision i wywołaj ją.

})()

Uruchamianie aplikacji

Uruchom aplikację za pomocą node polecenia w pliku Szybki start.

node index.js

Dane wyjściowe aplikacji powinny pojawić się w konsoli. Następnie możesz sprawdzić, czy obraz testowy (znaleziony w <folderze sampleDataRoot>/Test/) jest odpowiednio oznakowany i czy region wykrywania jest poprawny. Możesz również wrócić do witryny internetowej usługi Custom Vision i zobaczyć bieżący stan nowo utworzonego projektu.

Czyszczenie zasobów

Jeśli chcesz zaimplementować własny projekt wykrywania obiektów (lub zamiast tego wypróbować projekt klasyfikacji obrazów ), możesz usunąć projekt wykrywania rozwidlenia/nożyczków z tego przykładu. Bezpłatna subskrypcja umożliwia korzystanie z dwóch projektów usługi Custom Vision.

W witrynie internetowej Custom Vision przejdź do Projects i wybierz kosz w obszarze Mój nowy Project.

Następne kroki

Teraz wykonano każdy krok procesu wykrywania obiektów w kodzie. Ten przykład wykonuje pojedynczą iterację trenowania, ale często trzeba trenować i testować model wiele razy, aby zwiększyć jego dokładność. Poniższy przewodnik dotyczy klasyfikacji obrazów, ale jego zasady są podobne do wykrywania obiektów.

• Co to jest usługa Custom Vision?
• Kod źródłowy dla tego przykładu można znaleźć w witrynie GitHub
• dokumentacja referencyjna SDK (szkolenie)
• dokumentacja referencyjna SDK (predykcja)

Rozpocznij pracę z biblioteką klienta usługi Custom Vision dla Python. Wykonaj następujące kroki, aby zainstalować pakiet i wypróbować przykładowy kod tworzenia modelu wykrywania obiektów. Utworzysz projekt, dodasz tagi, wytrenujesz projekt i użyjesz adresu URL punktu końcowego przewidywania projektu, aby programowo go przetestować. Użyj tego przykładu jako szablonu do tworzenia własnej aplikacji do rozpoznawania obrazów.

dokumentacja referencyjna | Kod źródłowy biblioteki | Package (PyPI) | Przykłady

Wymagania wstępne

• subskrypcja Azure — Utwórz ją bezpłatnie
• Python 3.x
  • Instalacja Python powinna obejmować pip. Możesz sprawdzić, czy masz zainstalowane narzędzie pip, uruchamiając polecenie pip --version w wierszu polecenia. Pobierz narzędzie pip, instalując najnowszą wersję Python.
• Po utworzeniu subskrypcji usługi Azure utwórz zasób Custom Vision w portalu Azure, aby stworzyć zasoby do szkolenia i przewidywania.
  • Możesz użyć warstwy cenowej bezpłatna (F0), aby wypróbować usługę, a następnie uaktualnić ją do warstwy płatnej dla środowiska produkcyjnego.

Tworzenie zmiennych środowiskowych

W tym przykładzie wstawisz swoje poświadczenia do zmiennych środowiskowych na lokalnej maszynie uruchamiającej aplikację.

Przejdź do portalu Azure. Jeśli zasoby usługi Custom Vision utworzone w sekcji Wymagania wstępne zostały wdrożone pomyślnie, wybierz przycisk Przejdź do zasobu w obszarze Następne kroki. Klucze i punkty końcowe można znaleźć na stronach Klucze i punkty końcowe zasobów w obszarze Zarządzanie zasobami. Musisz uzyskać klucze zarówno do zasobu szkoleniowego, jak i zasobu predykcyjnego, wraz z punktami końcowymi API.

Identyfikator zasobu przewidywania można znaleźć na karcie Właściwości na karcie portalu Azure, na liście Resource ID.

Aby ustawić zmienne środowiskowe, otwórz okno konsoli i postępuj zgodnie z instrukcjami dotyczącymi systemu operacyjnego i środowiska programistycznego.

• Aby ustawić zmienną VISION_TRAINING KEY środowiskową, zastąp <your-training-key> jednym z kluczy zasobu szkoleniowego.
• Aby ustawić zmienną środowiska VISION_TRAINING_ENDPOINT, zastąp <your-training-endpoint> punktem końcowym swojego zasobu szkoleniowego.
• Aby ustawić zmienną VISION_PREDICTION_KEY środowiskową, zamień <your-prediction-key> jednym z kluczy zasobu przewidywania.
• Aby ustawić zmienną VISION_PREDICTION_ENDPOINT środowiskową, zastąp <your-prediction-endpoint> punktem końcowym zasobu prognozowania.
• Aby ustawić zmienną VISION_PREDICTION_RESOURCE_ID środowiskową, zastąp <your-resource-id> wartość identyfikatorem zasobu przewidywania.

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>

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Konfigurowanie

Instalowanie biblioteki klienta

Aby napisać aplikację do analizy obrazów za pomocą usługi Custom Vision dla Python, potrzebujesz biblioteki klienta usługi Custom Vision. Po zainstalowaniu Python uruchom następujące polecenie w programie PowerShell lub oknie konsoli:

pip install azure-cognitiveservices-vision-customvision

Tworzenie nowej aplikacji Python

Utwórz nowy plik Python i zaimportuj następujące biblioteki.

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

Utwórz zmienne dla punktu końcowego Azure i kluczy zasobu.

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

Model obiektów

Przykłady kodu

Te fragmenty kodu pokazują, jak wykonać następujące czynności za pomocą biblioteki klienta usługi Custom Vision dla Python:

• Uwierzytelnianie klienta
• Tworzenie nowego projektu usługi Custom Vision
• Dodawanie tagów do projektu
• Przekazywanie i tagowanie obrazów
• Trenuj projekt
• Publikowanie bieżącej iteracji
• Testowanie punktu końcowego przewidywania

Uwierzytelnianie klienta

Utwórz wystąpienie klienta szkoleniowego i predykcyjnego, używając punktu końcowego i kluczy. Utwórz obiekty ApiKeyServiceClientCredentials przy użyciu kluczy i użyj ich z punktem końcowym, aby utworzyć obiekt CustomVisionTrainingClient i CustomVisionPredictionClient .

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

Tworzenie nowego projektu usługi Custom Vision

Dodaj następujący kod do skryptu, aby utworzyć nowy projekt usługi Custom Vision.

Zobacz metodę create_project, aby określić inne opcje podczas tworzenia projektu (wyjaśniono w przewodniku portalu internetowego Budowanie detektora).

publish_iteration_name = "detectModel"

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

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

Dodawanie tagów do projektu

Aby utworzyć tagi obiektów w projekcie, dodaj następujący kod:

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

Przekazywanie i tagowanie obrazów

Najpierw pobierz przykładowe obrazy dla tego projektu. Zapisz zawartość folderu sample Images na urządzeniu lokalnym.

Podczas tagowania obrazów w projektach wykrywania obiektów należy określić region każdego obiektu oznakowanego przy użyciu znormalizowanych współrzędnych. Poniższy kod kojarzy każdy z przykładowych obrazów z oznaczonym regionem. Regiony określają ramkę ograniczającą w znormalizowanych współrzędnych, a współrzędne są podane w kolejności: lewa, górna, szerokość, wysokość.

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

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

Następnie użyj tej mapy skojarzeń, aby przekazać każdy przykładowy obraz ze współrzędnymi regionu (można przekazać do 64 obrazów w jednej partii). Dodaj następujący kod.

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

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

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

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

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

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

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

Szkolenie projektu

Ten kod tworzy pierwszą iterację modelu przewidywania.

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

Publikowanie bieżącej iteracji

Iteracja nie jest dostępna w punkcie końcowym przewidywania, dopóki nie zostanie opublikowana. Poniższy kod udostępnia bieżącą iterację modelu na potrzeby wykonywania zapytań.

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

Testowanie punktu końcowego przewidywania

Aby wysłać obraz do punktu końcowego przewidywania i pobrać przewidywanie, dodaj następujący kod na końcu pliku:

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

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

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

Uruchamianie aplikacji

Uruchom CustomVisionQuickstart.py.

python CustomVisionQuickstart.py

Dane wyjściowe aplikacji powinny pojawić się w konsoli. Następnie możesz sprawdzić, czy obraz testowy (znaleziony w <base_image_location>/images/Test) jest odpowiednio oznakowany i czy region wykrywania jest poprawny. Możesz również wrócić do witryny internetowej usługi Custom Vision i zobaczyć bieżący stan nowo utworzonego projektu.

Czyszczenie zasobów

Jeśli chcesz zaimplementować własny projekt wykrywania obiektów (lub zamiast tego wypróbować projekt klasyfikacji obrazów ), możesz usunąć projekt wykrywania rozwidlenia/nożyczków z tego przykładu. Bezpłatna subskrypcja umożliwia korzystanie z dwóch projektów usługi Custom Vision.

W witrynie internetowej Custom Vision przejdź do Projects i wybierz kosz w obszarze Mój nowy Project.

Następne kroki

Teraz wykonano każdy krok procesu wykrywania obiektów w kodzie. Ten przykład wykonuje pojedynczą iterację trenowania, ale często trzeba będzie trenować i testować model wielokrotnie, aby był bardziej dokładny. Poniższy przewodnik dotyczy klasyfikacji obrazów, ale jego zasady są podobne do wykrywania obiektów.

• Co to jest usługa Custom Vision?
• Kod źródłowy dla tego przykładu można znaleźć w witrynie GitHub
• Dokumentacja referencyjna zestawu SDK