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

Artykuł
09/02/2024

Wprowadzenie do biblioteki klienta usługi Custom Vision dla platformy .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.

Uwaga

Jeśli chcesz skompilować i wytrenować model wykrywania obiektów bez konieczności pisania kodu, zobacz zamiast tego wskazówki oparte na przeglądarce.

Dokumentacja referencyjna | Kod źródłowy biblioteki (trenowanie) (przewidywanie) | Package (NuGet) (training) (prediction)Samples (Package (NuGet) (training) (prediction)Samples (Package (NuGet) (training) (prediction)Samples |

Wymagania wstępne

Subskrypcja platformy Azure — utwórz bezpłatnie
Środowisko IDE programu Visual Studio lub bieżąca wersja platformy .NET Core.
Po utworzeniu subskrypcji platformy Azure utwórz zasób usługi Custom Vision w witrynie Azure Portal, aby utworzyć zasób 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 napiszesz poświadczenia do zmiennych środowiskowych na komputerze lokalnym z uruchomioną aplikacją.

Przejdź do portalu Azure Portal. 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 pobrać klucze zarówno dla zasobu szkoleniowego, jak i zasobu przewidywania, wraz z punktami końcowymi interfejsu API.

Identyfikator zasobu przewidywania można znaleźć na karcie Właściwości zasobu przewidywania w witrynie Azure Portal, na liście identyfikatora zasobu.

Napiwek

Możesz również użyć https://www.customvision.ai polecenia , aby uzyskać te wartości. Po zalogowaniu wybierz ikonę Ustawienia w prawym górnym rogu. Na stronach Ustawienie można wyświetlić wszystkie klucze, identyfikator zasobu i punkty końcowe.

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> element jednym z kluczy zasobu szkoleniowego.
Aby ustawić zmienną VISION_TRAINING_ENDPOINT środowiskową, zastąp <your-training-endpoint> element punktem końcowym zasobu szkoleniowego.
Aby ustawić zmienną VISION_PREDICTION_KEY środowiskową, zastąp <your-prediction-key> element jednym z kluczy zasobu przewidywania.
Aby ustawić zmienną VISION_PREDICTION_ENDPOINT środowiskową, zastąp <your-prediction-endpoint> element punktem końcowym zasobu przewidywania.
Aby ustawić zmienną VISION_PREDICTION_RESOURCE_ID środowiskową, zastąp <your-resource-id> wartość identyfikatorem zasobu przewidywania.

Ważne

Jeśli używasz klucza interfejsu API, zapisz go bezpiecznie w innym miejscu, na przykład w usłudze Azure Key Vault. Nie dołączaj klucza interfejsu API bezpośrednio do kodu i nigdy nie publikuj go publicznie.

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Windows
Linux

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Po dodaniu zmiennych środowiskowych może być konieczne ponowne uruchomienie wszystkich uruchomionych programów, które odczytują zmienne środowiskowe, w tym okno konsoli.

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>

Po dodaniu zmiennych środowiskowych uruchom polecenie source ~/.bashrc w oknie konsoli, aby wprowadzić zmiany w życie.

Tworzenie nowej aplikacji w języku C#

Za pomocą programu Visual Studio utwórz nową aplikację .NET Core.

Instalowanie biblioteki klienta

Po utworzeniu nowego projektu zainstaluj bibliotekę klienta, klikając prawym przyciskiem myszy rozwiązanie projektu w Eksplorator rozwiązań i wybierając polecenie Zarządzaj pakietami NuGet. W menedżerze pakietów, który zostanie otwarty, wybierz pozycję Przeglądaj, zaznacz pozycję Uwzględnij wersję wstępną i wyszukaj Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training ciąg i Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction. Wybierz najnowszą wersję, a następnie pozycję Zainstaluj.

Tworzenie nowej aplikacji w języku C#

W oknie konsoli (takim jak cmd, PowerShell lub Bash) użyj dotnet new polecenia , aby utworzyć nową aplikację konsolową o nazwie custom-vision-quickstart. To polecenie tworzy prosty projekt języka C# "Hello World" z jednym plikiem źródłowym: program.cs.

dotnet new console -n custom-vision-quickstart

Zmień katalog na nowo utworzony folder aplikacji. Aplikację można skompilować za pomocą następujących funkcji:

dotnet build

Dane wyjściowe kompilacji nie powinny zawierać żadnych ostrzeżeń ani błędów.

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

Instalowanie biblioteki klienta

W katalogu aplikacji zainstaluj bibliotekę klienta usługi Custom Vision dla platformy .NET za pomocą następującego polecenia:

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

Napiwek

Czy chcesz wyświetlić cały plik z kodem przewodnika Szybki start od razu? Można go znaleźć w witrynie GitHub, która zawiera przykłady kodu z tego przewodnika Szybki start.

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 Szybki start. 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 użytkownika

W nowej metodzie utwórz wystąpienie klientów trenowania i przewidywania przy użyciu punktu końcowego i kluczy.

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 w przewodniku Tworzenie portalu internetowego narzędzia do wykrywania ).

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.

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

Uwaga

W przypadku własnych projektów, jeśli nie masz narzędzia do klikania i przeciągania, aby oznaczyć współrzędne regionów, możesz użyć internetowego interfejsu użytkownika w witrynie internetowej usługi Custom Vision. W tym przykładzie są już podane współrzędne.

Następnie to mapowanie skojarzeń jest używane, aby przekazać każdy przykładowy obraz z jego współrzędnymi regionu. W jednej partii można przekazać 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 przekazano wszystkie obrazy przykładów i otagowano je (rozwidlenie lub nożyce) ze skojarzonym prostokątem pikseli.

Szkolenie projektu

Ta metoda tworzy pierwszą iterację szkoleniową w projekcie. Wysyła zapytanie do usługi do momentu ukończenia trenowania.

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

Napiwek

Trenowanie przy użyciu wybranych tagów

Opcjonalnie możesz trenować tylko w podzestawie zastosowanych tagów. Możesz to zrobić, jeśli nie zastosowano jeszcze wystarczającej liczby niektórych tagów, ale masz wystarczająco dużo innych. W wywołaniu TrainProject użyj parametru trainingParameters . Skonstruuj właściwość TrainingParameters i ustaw jej właściwość SelectedTags na listę identyfikatorów tagów, których chcesz użyć. Model będzie trenował tak, aby rozpoznawał tylko tagi na tej liście.

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 zasobu w witrynie Azure Portal, na liście identyfikatora zasobu.

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

Visual Studio IDE
CLI

Uruchom aplikację, klikając przycisk Debuguj w górnej części okna IDE.

Uruchom aplikację z katalogu aplikacji za dotnet run pomocą polecenia .

dotnet run

Po uruchomieniu aplikacja powinna otworzyć okno konsoli i zapisać w nim 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 ]

Możesz następnie sprawdzić, czy obraz testowy (znajdujący się w folderze Images/Test/) został odpowiednio otagowany i czy region wykrywania jest poprawny. W tym momencie możesz nacisnąć dowolny klawisz, aby zakończyć działanie aplikacji.

Czyszczenie zasobów

Jeśli chcesz wdrożyć własny projekt wykrywania obiektów (lub zamiast tego wypróbować projekt klasyfikacji obrazów), możesz usunąć projekt wykrywania widelca/nożyczek 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 obszaru Projects (Projekty) i wybierz ikonę kosza w obszarze My New Project (Mój nowy projekt).

Zrzut ekranu przedstawiający panel z etykietą Mój nowy projekt z ikoną kosza.

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. Następny przewodnik dotyczy klasyfikacji obrazów. Jej zasady są podobne do wykrywania obiektów.

Testowanie i ponowne szkolenie modelu

Co to jest usługa Custom Vision?
Kod źródłowy tego przykładu można znaleźć w usłudze 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.

Uwaga

Jeśli chcesz skompilować i wytrenować model wykrywania obiektów bez konieczności pisania kodu, zobacz zamiast tego wskazówki oparte na przeglądarce.

Użyj biblioteki klienta usługi Custom Vision dla języka Go, aby:

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

Dokumentacja referencyjna (szkolenie) (przewidywanie)

Wymagania wstępne

Subskrypcja platformy Azure — utwórz bezpłatnie
Go 1.8+
Po utworzeniu subskrypcji platformy Azure utwórz zasób usługi Custom Vision w witrynie Azure Portal, aby utworzyć zasób 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 napiszesz poświadczenia do zmiennych środowiskowych na komputerze lokalnym z uruchomioną aplikacją.

Identyfikator zasobu przewidywania można znaleźć na karcie Właściwości zasobu przewidywania w witrynie Azure Portal, na liście identyfikatora zasobu.

Napiwek

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> element jednym z kluczy zasobu szkoleniowego.
Aby ustawić zmienną VISION_TRAINING_ENDPOINT środowiskową, zastąp <your-training-endpoint> element punktem końcowym zasobu szkoleniowego.
Aby ustawić zmienną VISION_PREDICTION_KEY środowiskową, zastąp <your-prediction-key> element jednym z kluczy zasobu przewidywania.
Aby ustawić zmienną VISION_PREDICTION_ENDPOINT środowiskową, zastąp <your-prediction-endpoint> element punktem końcowym zasobu przewidywania.
Aby ustawić zmienną VISION_PREDICTION_RESOURCE_ID środowiskową, zastąp <your-resource-id> wartość identyfikatorem zasobu przewidywania.

Ważne

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Windows
Linux

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Po dodaniu zmiennych środowiskowych może być konieczne ponowne uruchomienie wszystkich uruchomionych programów, które odczytują zmienne środowiskowe, w tym okno konsoli.

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>

Po dodaniu zmiennych środowiskowych uruchom polecenie source ~/.bashrc w oknie konsoli, aby wprowadzić zmiany w życie.

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 polecenia dep, w repozytorium uruchom polecenie:

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 przykładów zestawu SDK języka Python usług Azure AI w witrynie GitHub. Sklonuj lub pobierz to repozytorium do swojego środowiska projektowego. 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 Custom Vision Service.

Zobacz metodę CreateProject , aby określić inne opcje podczas tworzenia projektu (wyjaśniono w przewodniku Tworzenie portalu internetowego narzędzia do wykrywania ).

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 dla projektu, 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

Oznaczając tagami obrazy w projektach wykrywania obiektów, należy określić region każdego otagowanego obiektu za pomocą znormalizowanych współrzędnych.

Uwaga

Jeśli nie masz narzędzia do klikania i przeciągania, aby oznaczyć współrzędne regionów, możesz użyć internetowego interfejsu użytkownika w Customvision.ai. W tym przykładzie są już podane współrzędne.

Aby dodać obrazy, tagi i regiony do projektu, wstaw następujący kod po utworzeniu tagów. Pamiętaj, że w tym samouczku regiony są zakodowane w tekście. Regiony określają pole ograniczenia w znormalizowanych współrzędnych, które podaje się w kolejności: lewa krawędź, górna krawędź, 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 źródłowy języka.

Uwaga

Musisz zmienić ścieżkę do obrazów na podstawie lokalizacji, w której pobrano wcześniej projekt przykładów zestawu SDK języka Go usług Azure AI.

// 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 przewidywania, a następnie publikuje iterację w punkcie końcowym 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.

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

Używanie punktu końcowego przewidywania

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

    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 plik sample.go.

go run sample.go

Dane wyjściowe aplikacji powinny pojawić się w konsoli. Możesz następnie sprawdzić, czy obraz testowy (znajdujący się w folderze samples/vision/images/Test) został odpowiednio otagowany i czy region wykrywania jest poprawny.

Czyszczenie zasobów

W witrynie internetowej Custom Vision przejdź do obszaru Projects (Projekty) i wybierz ikonę kosza w obszarze My New Project (Mój nowy projekt).

Zrzut ekranu przedstawiający panel z etykietą Mój nowy projekt z ikoną kosza.

Następne kroki

Testowanie i ponowne szkolenie modelu

Rozpocznij korzystanie z biblioteki klienta usługi Custom Vision dla języka 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.

Uwaga

Jeśli chcesz skompilować i wytrenować model wykrywania obiektów bez konieczności pisania kodu, zobacz zamiast tego wskazówki oparte na przeglądarce.

Użyj biblioteki klienta usługi Custom Vision dla języka Java, aby:

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

Dokumentacja referencyjna | Kod źródłowy biblioteki (trenowanie) (przewidywanie)| Artefakt (Maven) (trenowanie) (przewidywanie)Przykłady |

Wymagania wstępne

Subskrypcja platformy Azure — utwórz bezpłatnie
Bieżąca wersja zestawu Java Development Kit (JDK)
Narzędzie kompilacji narzędzia Gradle lub inny menedżer zależności.
Po utworzeniu subskrypcji platformy Azure utwórz zasób usługi Custom Vision w witrynie Azure Portal, aby utworzyć zasób 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 napiszesz poświadczenia do zmiennych środowiskowych na komputerze lokalnym z uruchomioną aplikacją.

Identyfikator zasobu przewidywania można znaleźć na karcie Właściwości zasobu przewidywania w witrynie Azure Portal, na liście identyfikatora zasobu.

Napiwek

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> element jednym z kluczy zasobu szkoleniowego.
Aby ustawić zmienną VISION_TRAINING_ENDPOINT środowiskową, zastąp <your-training-endpoint> element punktem końcowym zasobu szkoleniowego.
Aby ustawić zmienną VISION_PREDICTION_KEY środowiskową, zastąp <your-prediction-key> element jednym z kluczy zasobu przewidywania.
Aby ustawić zmienną VISION_PREDICTION_ENDPOINT środowiskową, zastąp <your-prediction-endpoint> element punktem końcowym zasobu przewidywania.
Aby ustawić zmienną VISION_PREDICTION_RESOURCE_ID środowiskową, zastąp <your-resource-id> wartość identyfikatorem zasobu przewidywania.

Ważne

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Windows
Linux

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Po dodaniu zmiennych środowiskowych może być konieczne ponowne uruchomienie wszystkich uruchomionych programów, które odczytują zmienne środowiskowe, w tym okno konsoli.

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>

Po dodaniu zmiennych środowiskowych uruchom polecenie source ~/.bashrc w oknie konsoli, aby wprowadzić zmiany w życie.

Konfigurowanie

Tworzenie nowego projektu narzędzia Gradle

W oknie konsoli (na przykład cmd, PowerShell lub Bash) utwórz nowy katalog dla aplikacji i przejdź do niego.

mkdir myapp && cd myapp

gradle init Uruchom polecenie 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

Po wyświetleniu monitu wybierz pozycję Język DSL, a następnie 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 usługi 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 języka 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;

Napiwek

Czy chcesz wyświetlić cały plik z kodem przewodnika Szybki start od razu? Można go znaleźć w witrynie GitHub, która zawiera przykłady kodu z tego przewodnika Szybki start.

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 Szybki start. 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 Custom Vision Java.

Nazwa/nazwisko	opis
CustomVisionTrainingClient	Ta klasa obsługuje tworzenie, trenowanie i publikowanie modeli.
CustomVisionPredictionClient	Ta klasa obsługuje wykonywanie zapytań dotyczących modeli na potrzeby przewidywań wykrywania obiektów.
ImagePrediction	Ta klasa definiuje pojedyncze przewidywanie obiektu na jednym obrazie. Zawiera właściwości identyfikatora obiektu i nazwy, lokalizację pola ograniczenia obiektu i współczynnik ufności.

Przykłady kodu

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

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

Uwierzytelnianie użytkownika

W metodzie głównej utwórz wystąpienie klientów trenowania i przewidywania przy użyciu 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 będzie widoczny w odwiedzonej wcześniej witrynie internetowej Custom Vision. Zobacz przeciążenia metody CreateProject, aby określić inne opcje podczas tworzenia projektu (objaśnione w przewodniku Tworzenie portalu internetowego narzędzia do wykrywania).

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

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

Uwaga

Czy potrzebujesz szerszego zestawu obrazów do ukończenia szkolenia? Trove, projekt Microsoft Garage, umożliwia zbieranie i kupowanie zestawów obrazów do celów szkoleniowych. Po zebraniu obrazów możesz je pobrać, a następnie zaimportować je do projektu usługi Custom Vision w zwykły sposób. Odwiedź stronę Trove, aby dowiedzieć się więcej.

Uwaga

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 GetImage wywołań, aby wskazywały lokalizacje pobranych folderów rozwidlenia i nożyczek .

    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 do momentu ukończenia trenowania.

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

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 gradle run pomocą polecenia :

gradle run

Czyszczenie zasobów

Jeśli chcesz wyczyścić i usunąć subskrypcję usług Azure AI, 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.

W witrynie internetowej Custom Vision przejdź do obszaru Projects (Projekty) i wybierz ikonę kosza w obszarze My New Project (Mój nowy projekt).

Zrzut ekranu przedstawiający panel z etykietą Mój nowy projekt z ikoną kosza.

Następne kroki

Testowanie i ponowne szkolenie modelu

Co to jest usługa Custom Vision?
Kod źródłowy tego przykładu można znaleźć w usłudze 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.

Uwaga

Jeśli chcesz skompilować i wytrenować model wykrywania obiektów bez konieczności pisania kodu, zobacz zamiast tego wskazówki oparte na przeglądarce.

Użyj biblioteki klienta usługi Custom Vision dla platformy .NET, aby:

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

Dokumentacja referencyjna (szkolenie) (przewidywanie) | Package (npm) (training) (prediction)Samples (Package (npm) (training) (prediction)Samples (Package (npm) (training) (prediction)Samples |

Wymagania wstępne

Subskrypcja platformy Azure — utwórz bezpłatnie
Bieżąca wersja Node.js
Po utworzeniu subskrypcji platformy Azure utwórz zasób usługi Custom Vision w witrynie Azure Portal, aby utworzyć zasób 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 napiszesz poświadczenia do zmiennych środowiskowych na komputerze lokalnym z uruchomioną aplikacją.

Identyfikator zasobu przewidywania można znaleźć na karcie Właściwości zasobu przewidywania w witrynie Azure Portal, na liście identyfikatora zasobu.

Napiwek

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> element jednym z kluczy zasobu szkoleniowego.
Aby ustawić zmienną VISION_TRAINING_ENDPOINT środowiskową, zastąp <your-training-endpoint> element punktem końcowym zasobu szkoleniowego.
Aby ustawić zmienną VISION_PREDICTION_KEY środowiskową, zastąp <your-prediction-key> element jednym z kluczy zasobu przewidywania.
Aby ustawić zmienną VISION_PREDICTION_ENDPOINT środowiskową, zastąp <your-prediction-endpoint> element punktem końcowym zasobu przewidywania.
Aby ustawić zmienną VISION_PREDICTION_RESOURCE_ID środowiskową, zastąp <your-resource-id> wartość identyfikatorem zasobu przewidywania.

Ważne

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Windows
Linux

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Po dodaniu zmiennych środowiskowych może być konieczne ponowne uruchomienie wszystkich uruchomionych programów, które odczytują zmienne środowiskowe, w tym okno konsoli.

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>

Po dodaniu zmiennych środowiskowych uruchom polecenie source ~/.bashrc w oknie konsoli, aby wprowadzić zmiany w życie.

Konfigurowanie

Tworzenie nowej aplikacji Node.js

W oknie konsoli (na przykład 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 przy użyciu pliku package.json.

npm init

Instalowanie biblioteki klienta

Aby napisać aplikację do analizy obrazów za pomocą usługi Custom Vision dla Node.js, potrzebne będą 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 package.json aplikacji zostanie zaktualizowany 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");

Napiwek

Czy chcesz wyświetlić cały plik z kodem przewodnika Szybki start od razu? Można go znaleźć w witrynie GitHub, która zawiera przykłady kodu z tego przewodnika Szybki start.

Utwórz zmienne dla punktu końcowego i kluczy platformy Azure 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

Nazwa/nazwisko	opis
TrainingAPIClient	Ta klasa obsługuje tworzenie, trenowanie i publikowanie modeli.
PredictionAPIClient	Ta klasa obsługuje wykonywanie zapytań dotyczących modeli na potrzeby przewidywań wykrywania obiektów.
Przewidywanie	Ten interfejs definiuje pojedyncze przewidywanie na jednym obrazie. Zawiera właściwości identyfikatora obiektu i nazwy oraz współczynnik ufności.

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 użytkownika
Tworzenie nowego projektu usługi Custom Vision
Dodawanie tagów do projektu
Przekazywanie i tagowanie obrazów
Szkolenie projektu
Publikowanie bieżącej iteracji
Testowanie punktu końcowego przewidywania

Uwierzytelnianie użytkownika

Utwórz wystąpienie obiektów klienta przy użyciu punktu końcowego i klucza. Utwórz obiekt ApiKeyCredentials za pomocą klucza i użyj go z punktem końcowym, aby utworzyć obiekt 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, po utworzeniu tagów wstaw następujący kod. Ten kod przekazuje każdy obraz z odpowiednim tagiem. Oznaczając tagami obrazy w projektach wykrywania obiektów, należy określić region każdego otagowanego obiektu za pomocą znormalizowanych współrzędnych. Na potrzeby tego samouczka regiony są zakodowane na stałe przy użyciu kodu. Regiony określają pole ograniczenia w znormalizowanych współrzędnych, które podaje się w kolejności: lewa krawędź, górna krawędź, szerokość, wysokość. W jednej partii można przekazać 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);

Ważne

Musisz zmienić ścieżkę do obrazów (sampleDataRoot) na podstawie lokalizacji, w której pobrano repozytorium przykładów zestawu SDK języka Python dla usług AI platformy Azure.

Uwaga

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ę, wykonując polecenie node dla pliku szybkiego startu.

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 też wrócić do witryny internetowej Custom Vision i wyświetlić bieżący stan nowo utworzonego projektu.

Czyszczenie zasobów

W witrynie internetowej Custom Vision przejdź do obszaru Projects (Projekty) i wybierz ikonę kosza w obszarze My New Project (Mój nowy projekt).

Zrzut ekranu przedstawiający panel z etykietą Mój nowy projekt z ikoną kosza.

Następne kroki

Testowanie i ponowne szkolenie modelu

Co to jest usługa Custom Vision?
Kod źródłowy tego przykładu można znaleźć w usłudze GitHub
Dokumentacja referencyjna zestawu SDK (szkolenie)
Dokumentacja referencyjna zestawu SDK (przewidywanie)

Wprowadzenie do biblioteki klienta usługi Custom Vision dla języka 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.

Uwaga

Jeśli chcesz skompilować i wytrenować model wykrywania obiektów bez konieczności pisania kodu, zobacz zamiast tego wskazówki oparte na przeglądarce.

Użyj biblioteki klienta usługi Custom Vision dla języka Python, aby:

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

Dokumentacja referencyjna — przykłady | pakietu kodu | źródłowego biblioteki źródłowej (PyPI) |

Wymagania wstępne

Subskrypcja platformy Azure — utwórz bezpłatnie
Python 3.x
- Instalacja języka Python powinna zawierać narzędzie. Możesz sprawdzić, czy masz zainstalowane narzędzie, uruchamiając polecenie pip --version w wierszu polecenia. Pobierz narzędzie, instalując najnowszą wersję języka Python.
Po utworzeniu subskrypcji platformy Azure utwórz zasób usługi Custom Vision w witrynie Azure Portal, aby utworzyć zasób 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 napiszesz poświadczenia do zmiennych środowiskowych na komputerze lokalnym z uruchomioną aplikacją.

Identyfikator zasobu przewidywania można znaleźć na karcie Właściwości zasobu przewidywania w witrynie Azure Portal, na liście identyfikatora zasobu.

Napiwek

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> element jednym z kluczy zasobu szkoleniowego.
Aby ustawić zmienną VISION_TRAINING_ENDPOINT środowiskową, zastąp <your-training-endpoint> element punktem końcowym zasobu szkoleniowego.
Aby ustawić zmienną VISION_PREDICTION_KEY środowiskową, zastąp <your-prediction-key> element jednym z kluczy zasobu przewidywania.
Aby ustawić zmienną VISION_PREDICTION_ENDPOINT środowiskową, zastąp <your-prediction-endpoint> element punktem końcowym zasobu przewidywania.
Aby ustawić zmienną VISION_PREDICTION_RESOURCE_ID środowiskową, zastąp <your-resource-id> wartość identyfikatorem zasobu przewidywania.

Ważne

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Windows
Linux

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Po dodaniu zmiennych środowiskowych może być konieczne ponowne uruchomienie wszystkich uruchomionych programów, które odczytują zmienne środowiskowe, w tym okno konsoli.

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>

Po dodaniu zmiennych środowiskowych uruchom polecenie source ~/.bashrc w oknie konsoli, aby wprowadzić zmiany w życie.

Konfigurowanie

Instalowanie biblioteki klienta

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

pip install azure-cognitiveservices-vision-customvision

Tworzenie nowej aplikacji w języku Python

Utwórz nowy plik języka 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

Napiwek

Czy chcesz wyświetlić cały plik z kodem przewodnika Szybki start od razu? Można go znaleźć w witrynie GitHub, która zawiera przykłady kodu z tego przewodnika Szybki start.

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

# Replace with valid values
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"]

Model obiektów

Nazwa/nazwisko	opis
CustomVisionTrainingClient	Ta klasa obsługuje tworzenie, trenowanie i publikowanie modeli.
CustomVisionPredictionClient	Ta klasa obsługuje wykonywanie zapytań dotyczących modeli na potrzeby przewidywań wykrywania obiektów.
ImagePrediction	Ta klasa definiuje pojedyncze przewidywanie obiektu na jednym obrazie. Zawiera właściwości identyfikatora obiektu i nazwy, lokalizację pola ograniczenia obiektu i współczynnik ufności.

Przykłady kodu

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

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

Uwierzytelnianie użytkownika

Utworzenie wystąpienia klienta szkolenia i przewidywania przy użyciu 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(ENDPOINT, prediction_credentials)

Tworzenie nowego projektu usługi Custom Vision

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

Zobacz metodę create_project , aby określić inne opcje podczas tworzenia projektu (wyjaśniono w przewodniku Tworzenie portalu internetowego narzędzia do wykrywania ).

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.

Oznaczając tagami obrazy w projektach wykrywania obiektów, należy określić region każdego otagowanego obiektu za pomocą znormalizowanych współrzędnych. Następujący kod kojarzy poszczególne przykładowe obrazy z ich otagowanymi regionami. Regiony określają pole ograniczenia w znormalizowanych współrzędnych, które podaje się w kolejności: lewa krawędź, górna krawędź, 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 ]
}

Uwaga

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)

Uwaga

Musisz zmienić ścieżkę do obrazów na podstawie lokalizacji, w której pobrano repozytorium Przykładowe przykłady zestawu SDK języka Python dla usług Azure AI.

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)

Napiwek

Trenowanie przy użyciu wybranych tagów

Opcjonalnie możesz trenować tylko w podzestawie zastosowanych tagów. Możesz to zrobić, jeśli nie zastosowano jeszcze wystarczającej liczby niektórych tagów, ale masz wystarczająco dużo innych. W wywołaniu train_project ustaw opcjonalny parametr selected_tags na listę ciągów identyfikatorów tagów, których chcesz użyć. Model będzie trenował tak, aby rozpoznawał tylko tagi na tej liście.

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 uzyskać przewidywanie, dodaj na końcu pliku następujący kod:

# 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 też wrócić do witryny internetowej Custom Vision i wyświetlić bieżący stan nowo utworzonego projektu.

Czyszczenie zasobów

W witrynie internetowej Custom Vision przejdź do obszaru Projects (Projekty) i wybierz ikonę kosza w obszarze My New Project (Mój nowy projekt).

Zrzut ekranu przedstawiający panel z etykietą Mój nowy projekt z ikoną kosza.

Następne kroki

Testowanie i ponowne szkolenie modelu

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

Udostępnij za pośrednictwem

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

Wymagania wstępne

Tworzenie zmiennych środowiskowych

Konfigurowanie

Tworzenie nowej aplikacji w języku C#

Instalowanie biblioteki klienta

Uwierzytelnianie użytkownika

Tworzenie nowego projektu usługi Custom Vision

Dodawanie tagów do projektu

Przekazywanie i tagowanie obrazów

Szkolenie projektu

Publikowanie bieżącej iteracji

Testowanie punktu końcowego przewidywania

Uruchamianie aplikacji

Czyszczenie zasobów

Następne kroki

Wymagania wstępne

Tworzenie zmiennych środowiskowych

Konfigurowanie

Instalowanie biblioteki klienta usługi Custom Vision

Pobieranie przykładowych obrazów

Tworzenie projektu usługi Custom Vision

Tworzenie tagów w projekcie

Przekazywanie i tagowanie obrazów

Trenowanie i publikowanie projektu

Używanie punktu końcowego przewidywania

Uruchamianie aplikacji

Czyszczenie zasobów

Następne kroki

Wymagania wstępne

Tworzenie zmiennych środowiskowych

Konfigurowanie

Tworzenie nowego projektu narzędzia Gradle

Instalowanie biblioteki klienta

Tworzenie pliku języka Java

Model obiektów

Przykłady kodu

Uwierzytelnianie użytkownika

Tworzenie nowego projektu usługi Custom Vision

Dodanie tagów do projektu

Przekazywanie i tagowanie obrazów

Szkolenie projektu

Publikowanie bieżącej iteracji

Testowanie punktu końcowego przewidywania

Uruchamianie aplikacji

Czyszczenie zasobów

Następne kroki

Wymagania wstępne

Tworzenie zmiennych środowiskowych

Konfigurowanie

Tworzenie nowej aplikacji Node.js

Instalowanie biblioteki klienta

Model obiektów

Przykłady kodu

Uwierzytelnianie użytkownika

Dodawanie funkcji pomocnika

Tworzenie nowego projektu usługi Custom Vision

Dodawanie tagów do projektu

Przekazywanie i tagowanie obrazów

Szkolenie projektu

Publikowanie bieżącej iteracji

Testowanie punktu końcowego przewidywania

Uruchamianie aplikacji

Czyszczenie zasobów

Następne kroki

Wymagania wstępne

Tworzenie zmiennych środowiskowych

Konfigurowanie

Instalowanie biblioteki klienta

Tworzenie nowej aplikacji w języku Python

Model obiektów

Przykłady kodu

Uwierzytelnianie użytkownika

Tworzenie nowego projektu usługi Custom Vision

Dodawanie tagów do projektu

Przekazywanie i tagowanie obrazów

Szkolenie projektu

Publikowanie bieżącej iteracji

Testowanie punktu końcowego przewidywania