Schnellstart: Erstellen eines Objekterkennungsprojekts mit der Clientbibliothek "Custom Vision"

Erste Schritte mit der Benutzerdefinierten Vision-Clientbibliothek für .NET. Führen Sie die folgenden Schritte aus, um das Paket zu installieren und den Beispielcode zum Erstellen eines Objekterkennungsmodells auszuprobieren. Sie erstellen ein Projekt, fügen Tags hinzu, trainieren das Projekt auf Beispielbildern und verwenden die URL des Vorhersageendpunkts des Projekts, um es programmgesteuert zu testen. Verwenden Sie dieses Beispiel als Vorlage zum Erstellen Ihrer eigenen Bilderkennungs-App.

Referenzdokumentation | Quellcode der Bibliothek (Training)(Vorhersage) | Paket (NuGet) (Training)(Vorhersage) | Beispiele

Voraussetzungen

• Azure-Abonnement – Create one for free
• Die Visual Studio-IDE oder die aktuelle Version von .NET Core.
• Sobald Sie Ihr Azure-Abonnement haben, erstellen Sie im Azure-Portal eine Custom Vision-Ressource, um eine Schulungs- und Vorhersageressource zu erstellen.
  • Sie können das kostenlose Preisniveau (F0) verwenden, um den Dienst zu testen und später auf eine kostenpflichtige Stufe für die Produktion zu aktualisieren.

Erstellen von Umgebungsvariablen

In diesem Beispiel schreiben Sie Ihre Anmeldeinformationen in Umgebungsvariablen auf dem lokalen Computer, auf dem die Anwendung ausgeführt wird.

Wechseln Sie zum Azure-Portal. Wenn die benutzerdefinierten Vision-Ressourcen, die Sie im Abschnitt "Voraussetzungen" erstellt haben, erfolgreich bereitgestellt wurden, wählen Sie unter "Nächste Schritte" die Schaltfläche "Gehe zu Ressource" aus. Sie finden Ihre Schlüssel und Endpunkte auf den Ressourcenschlüssel- und Endpunktseiten unter "Ressourcenverwaltung". Sie müssen die Schlüssel für Ihre Trainings- und Vorhersage Ressourcen zusammen mit den API-Endpunkten beziehen.

Sie finden die Ressourcen-ID der Vorhersage-Ressource auf der Registerkarte Properties im Azure-Portal, aufgelistet als Ressourcen-ID.

Um die Umgebungsvariablen festzulegen, öffnen Sie ein Konsolenfenster, und befolgen Sie die Anweisungen für Ihr Betriebssystem und Ihre Entwicklungsumgebung.

• Zum Festlegen der Umgebungsvariablen VISION_TRAINING KEY ersetzen Sie <your-training-key> durch einen der Schlüssel für Ihre Trainingsressource.
• Um die Umgebungsvariable VISION_TRAINING_ENDPOINT festzulegen, ersetzen Sie <your-training-endpoint> durch den Endpunkt für Ihre Schulungsressource.
• Um die Umgebungsvariable VISION_PREDICTION_KEY festzulegen, ersetzen Sie <your-prediction-key> durch einen der Schlüssel für Ihre Vorhersageressource.
• Um die Umgebungsvariable VISION_PREDICTION_ENDPOINT festzulegen, ersetzen Sie <your-prediction-endpoint> durch den Endpunkt für Ihre Vorhersageressource.
• Um die Umgebungsvariable VISION_PREDICTION_RESOURCE_ID festzulegen, ersetzen Sie <your-resource-id> durch die Ressourcen-ID für Ihre Vorhersageressource.

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>

Einrichten

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

Öffnen Sie im Projektverzeichnis die datei program.cs , und fügen Sie die folgenden using Direktiven hinzu:

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;

Erstellen Sie in der Hauptmethode der Anwendung Variablen, die die Schlüssel und den Endpunkt Ihrer Ressource aus Umgebungsvariablen abrufen. Darüber hinaus deklarieren Sie einige grundlegende Objekte, die später verwendet werden sollen.

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

Fügen Sie in der Main-Methode der Anwendung Aufrufe für die in dieser Schnellstartanleitung verwendeten Methoden hinzu. Sie werden diese später implementieren.

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

Authentifizieren des Clients

Instanziieren Sie mit einer neuen Methode Schulungs- und Vorhersage-Clients mithilfe Ihres Endpunkts und Ihrer Schlüssel.

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

Erstellen eines neuen Benutzerdefinierten Vision-Projekts

Diese nächste Methode erstellt ein Objekterkennungsprojekt. Das erstellte Projekt wird auf der Custom Vision-Website angezeigt. Sehen Sie sich die CreateProject-Methode an, um andere Optionen anzugeben, wenn Sie Ihr Projekt erstellen (erläutert im Handbuch zum Erstellen eines Detektorwebportals ).

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

Hinzufügen von Tags zum Projekt

Diese Methode definiert die Tags, mit denen Sie das Modell trainieren.

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

Hochladen und Kategorisieren von Bildern

Laden Sie zunächst die Beispielbilder für dieses Projekt herunter. Speichern Sie den Inhalt des Ordners sample Images auf Ihrem lokalen Gerät.

Wenn Sie Bilder in Objekterkennungsprojekten kategorisieren, müssen Sie den Bereich jedes markierten Objekts mithilfe normalisierter Koordinaten angeben. Der folgende Code ordnet die einzelnen Beispielbilder dem markierten Bereich zu.

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

Anschließend wird diese Zuordnungskarte verwendet, um jedes Beispielbild mit seinen Regionskoordinaten hochzuladen. Sie können bis zu 64 Bilder in einem einzigen Batch hochladen. Möglicherweise müssen Sie den imagePath Wert ändern, um auf die richtigen Ordnerspeicherorte zu verweisen.

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

Sie haben nun alle Beispielbilder hochgeladen und jedes Bild mit einem Tag für Gabel (fork) oder Schere (scissors) sowie einem zugeordneten Pixelrechteck versehen.

Projekt trainieren

Diese Methode erstellt die erste Schulungsiteration im Projekt. Der Dienst wird so lange abgefragt, bis das Training abgeschlossen ist.

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

Veröffentlichen der aktuellen Iteration

Diese Methode stellt die aktuelle Iteration des Modells für die Abfrage zur Verfügung. Sie können den Modellnamen als Verweis verwenden, um Vorhersageanforderungen zu senden. Sie müssen ihren eigenen Wert eingeben für predictionResourceId. Sie finden die Vorhersageressourcen-ID im Azure-Portal auf der Registerkarte Eigenschaften der Ressource, wo sie als Ressourcen-ID angegeben ist.

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

Testen des Vorhersageendpunkts

Diese Methode lädt das Testimage, fragt den Modellendpunkt ab und gibt Vorhersagedaten an die Konsole aus.

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

Ausführen der Anwendung

dotnet run

Während der Ausführung der Anwendung sollte ein Konsolenfenster geöffnet und die folgende Ausgabe geschrieben werden:

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 ]

Anschließend können Sie überprüfen, ob das Testbild (in Images/Test/) entsprechend markiert ist und dass der Bereich der Erkennung korrekt ist. An diesem Punkt können Sie eine beliebige Taste drücken, um die Anwendung zu beenden.

Bereinigen von Ressourcen

Wenn Sie Ihr eigenes Objekterkennungsprojekt implementieren möchten (oder stattdessen ein Bildklassifizierungsprojekt ausprobieren), können Sie das Fork/Scissors-Erkennungsprojekt aus diesem Beispiel löschen. Ein kostenloses Abonnement ermöglicht zwei Custom Vision-Projekte.

Navigieren Sie auf der Website Custom Vision zu Projects und wählen Sie den Papierkorb unter "Mein neues Project" aus.

Nächste Schritte

Jetzt haben Sie jeden Schritt des Objekterkennungsprozesses im Code ausgeführt. In diesem Beispiel wird eine einzelne Schulungsiteration ausgeführt. Häufig müssen Sie ihr Modell jedoch mehrmals trainieren und testen, um es genauer zu gestalten. Der folgende Leitfaden befasst sich mit der Bildklassifizierung, aber seine Prinzipien ähneln der Objekterkennung.

• Was ist Custom Vision?
• Der Quellcode für dieses Beispiel finden Sie unter GitHub
• SDK-Referenzdokumentation

Dieses Handbuch enthält Anweisungen und Beispielcode, die Ihnen bei den ersten Schritten mit der Custom Vision-Clientbibliothek für Go helfen, um ein Objekterkennungsmodell zu erstellen. Sie erstellen ein Projekt, fügen Tags hinzu, trainieren das Projekt und verwenden die Url des Vorhersageendpunkts des Projekts, um es programmgesteuert zu testen. Verwenden Sie dieses Beispiel als Vorlage zum Erstellen Ihrer eigenen Bilderkennungs-App.

Referenzdokumentation (training)(prediction)

Voraussetzungen

• Azure-Abonnement – Create one for free
• Gehe zu 1,8+
• Sobald Sie Ihr Azure-Abonnement haben, erstellen Sie erstellen Sie eine Custom Vision-Resource im Azure-Portal, um eine Trainings- und Prognose-Ressource zu erstellen.
  • Sie können das kostenlose Preisniveau (F0) verwenden, um den Dienst zu testen und später auf eine kostenpflichtige Stufe für die Produktion zu aktualisieren.

Erstellen von Umgebungsvariablen

In diesem Beispiel schreiben Sie Ihre Anmeldeinformationen in Umgebungsvariablen auf dem lokalen Computer, auf dem die Anwendung ausgeführt wird.

Wechseln Sie zum Azure-Portal. Wenn die benutzerdefinierten Vision-Ressourcen, die Sie im Abschnitt "Voraussetzungen" erstellt haben, erfolgreich bereitgestellt wurden, wählen Sie unter "Nächste Schritte" die Schaltfläche "Gehe zu Ressource" aus. Sie finden Ihre Schlüssel und Endpunkte auf den Ressourcenschlüssel- und Endpunktseiten unter "Ressourcenverwaltung". Sie müssen die Schlüssel für Ihre Trainings- und Vorhersage Ressourcen zusammen mit den API-Endpunkten beziehen.

Sie finden die Ressourcen-ID der Vorhersage-Ressource auf der Registerkarte Properties im Azure-Portal, aufgelistet als Ressourcen-ID.

Um die Umgebungsvariablen festzulegen, öffnen Sie ein Konsolenfenster, und befolgen Sie die Anweisungen für Ihr Betriebssystem und Ihre Entwicklungsumgebung.

• Zum Festlegen der Umgebungsvariablen VISION_TRAINING KEY ersetzen Sie <your-training-key> durch einen der Schlüssel für Ihre Trainingsressource.
• Um die Umgebungsvariable VISION_TRAINING_ENDPOINT festzulegen, ersetzen Sie <your-training-endpoint> durch den Endpunkt für Ihre Schulungsressource.
• Um die Umgebungsvariable VISION_PREDICTION_KEY festzulegen, ersetzen Sie <your-prediction-key> durch einen der Schlüssel für Ihre Vorhersageressource.
• Um die Umgebungsvariable VISION_PREDICTION_ENDPOINT festzulegen, ersetzen Sie <your-prediction-endpoint> durch den Endpunkt für Ihre Vorhersageressource.
• Um die Umgebungsvariable VISION_PREDICTION_RESOURCE_ID festzulegen, ersetzen Sie <your-resource-id> durch die Ressourcen-ID für Ihre Vorhersageressource.

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>

Einrichten

Installiere die Clientbibliothek für benutzerdefinierte Bildverarbeitung

Um eine Bildanalyse-App mit Custom Vision for Go zu schreiben, benötigen Sie die Clientbibliothek des Custom Vision-Diensts. Führen Sie den folgenden Befehl in PowerShell aus:

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

oder wenn Sie in Ihrem Repository dep verwenden, führen Sie Folgendes aus:

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

Abrufen der Beispielbilder

In diesem Beispiel werden die Bilder aus dem Repository Foundry Tools Python SDK Samples für GitHub verwendet. Klonen Sie oder laden Sie dieses Repository in Ihre Entwicklungsumgebung herunter. Merken Sie sich den Ordnerspeicherort für einen späteren Schritt.

Erstellen des Projekts "Custom Vision"

Erstellen Sie eine neue Datei namens "sample.go " in Ihrem bevorzugten Projektverzeichnis, und öffnen Sie sie in Ihrem bevorzugten Code-Editor.

Fügen Sie Ihrem Skript den folgenden Code hinzu, um ein neues Benutzerdefiniertes Vision-Dienstprojekt zu erstellen.

Sehen Sie sich die CreateProject-Methode an, um andere Optionen anzugeben, wenn Sie Ihr Projekt erstellen (erläutert im Handbuch zum Erstellen eines Detektorwebportals ).

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

Erstellen von Tags im Projekt

Um Klassifizierungstags für Ihr Projekt zu erstellen, fügen Sie am Ende von sample.go den folgenden Code hinzu:

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

Hochladen und Kategorisieren von Bildern

Wenn Sie Bilder in Objekterkennungsprojekten kategorisieren, müssen Sie den Bereich jedes markierten Objekts mithilfe normalisierter Koordinaten angeben.

Fügen Sie nach der Tagerstellung den folgenden Code ein, um dem Projekt Bilder, Tags und Regionen hinzuzufügen. Hinweis: In diesem Tutorial sind die Regionen inline hartcodiert. Die Regionen geben den Begrenzungsrahmen in normalisierten Koordinaten an, und die Koordinaten werden in der folgenden Reihenfolge angegeben: links, oben, Breite, Höhe.

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

Verwenden Sie dann diese Zuordnungszuordnung, um jedes Beispielbild mit seinen Regionskoordinaten hochzuladen (Sie können bis zu 64 Bilder in einem einzelnen Batch hochladen). Fügen Sie den folgenden Code hinzu.

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

Projekt trainieren und veröffentlichen

Dieser Code erstellt die erste Iteration des Vorhersagemodells und veröffentlicht diese Iteration dann am Vorhersageendpunkt. Der Name, der der veröffentlichten Iteration zugewiesen wird, kann zum Senden von Vorhersageanforderungen verwendet werden. Eine Iteration ist erst im Prognose-Endpunkt verfügbar, wenn sie veröffentlicht wird.

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

Verwenden Sie den Vorhersageendpunkt

Um ein Bild an den Vorhersageendpunkt zu senden und die Vorhersage abzurufen, fügen Sie am Ende der Datei den folgenden Code hinzu:

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

Ausführen der Anwendung

Führen Sie "sample.go" aus.

go run sample.go

Die Ausgabe der Anwendung sollte in der Konsole erscheinen. Anschließend können Sie überprüfen, ob das Testbild (in Beispielen/Vision/Images/Test) richtig markiert ist und dass der Bereich der Erkennung korrekt ist.

Bereinigen von Ressourcen

Wenn Sie Ihr eigenes Objekterkennungsprojekt implementieren möchten (oder stattdessen ein Bildklassifizierungsprojekt ausprobieren), können Sie das Fork/Scissors-Erkennungsprojekt aus diesem Beispiel löschen. Ein kostenloses Abonnement ermöglicht zwei Custom Vision-Projekte.

Navigieren Sie auf der Website Custom Vision zu Projects und wählen Sie den Papierkorb unter "Mein neues Project" aus.

Nächste Schritte

Jetzt haben Sie jeden Schritt des Objekterkennungsprozesses im Code ausgeführt. In diesem Beispiel wird eine einzelne Schulungsiteration ausgeführt. Häufig müssen Sie ihr Modell jedoch mehrmals trainieren und testen, um es genauer zu gestalten. Der folgende Leitfaden befasst sich mit der Bildklassifizierung, aber seine Prinzipien ähneln der Objekterkennung.

• Was ist Custom Vision?
• SDK-Referenzdokumentation (Schulung)
• SDK-Referenzdokumentation (Vorhersage)

Erste Schritte mit der Custom Vision-Clientbibliothek für Java zum Erstellen eines Objekterkennungsmodells. Führen Sie die folgenden Schritte aus, um das Paket zu installieren und den Beispielcode für grundlegende Aufgaben auszuprobieren. Verwenden Sie dieses Beispiel als Vorlage zum Erstellen Ihrer eigenen Bilderkennungs-App.

Referenzdokumentation | Quellcode (Training)(Vorhersage) | Artefakt (Maven) (Training)(Vorhersage) | Beispiele

Voraussetzungen

• Ein Azure-Abonnement – Create one for free
• Die aktuelle Version des Java Development Kit(JDK)
• Das Gradle-Buildtool oder ein anderer Abhängigkeits-Manager.
• Sobald Sie Ihr Azure-Abonnement haben, erstellen Sie im Azure-Portal eine Custom Vision-Ressource, um eine Schulungs- und Vorhersageressource zu erstellen.
  • Sie können das kostenlose Preisniveau (F0) verwenden, um den Dienst zu testen und später auf eine kostenpflichtige Stufe für die Produktion zu aktualisieren.

Erstellen von Umgebungsvariablen

In diesem Beispiel schreiben Sie Ihre Anmeldeinformationen in Umgebungsvariablen auf dem lokalen Computer, auf dem die Anwendung ausgeführt wird.

Wechseln Sie zum Azure-Portal. Wenn die benutzerdefinierten Vision-Ressourcen, die Sie im Abschnitt "Voraussetzungen" erstellt haben, erfolgreich bereitgestellt wurden, wählen Sie unter "Nächste Schritte" die Schaltfläche "Gehe zu Ressource" aus. Sie finden Ihre Schlüssel und Endpunkte auf den Ressourcenschlüssel- und Endpunktseiten unter "Ressourcenverwaltung". Sie müssen die Schlüssel für Ihre Trainings- und Vorhersage Ressourcen zusammen mit den API-Endpunkten beziehen.

Sie finden die Ressourcen-ID der Vorhersage-Ressource auf der Registerkarte Properties im Azure-Portal, aufgelistet als Ressourcen-ID.

Um die Umgebungsvariablen festzulegen, öffnen Sie ein Konsolenfenster, und befolgen Sie die Anweisungen für Ihr Betriebssystem und Ihre Entwicklungsumgebung.

• Zum Festlegen der Umgebungsvariablen VISION_TRAINING KEY ersetzen Sie <your-training-key> durch einen der Schlüssel für Ihre Trainingsressource.
• Um die Umgebungsvariable VISION_TRAINING_ENDPOINT festzulegen, ersetzen Sie <your-training-endpoint> durch den Endpunkt für Ihre Schulungsressource.
• Um die Umgebungsvariable VISION_PREDICTION_KEY festzulegen, ersetzen Sie <your-prediction-key> durch einen der Schlüssel für Ihre Vorhersageressource.
• Um die Umgebungsvariable VISION_PREDICTION_ENDPOINT festzulegen, ersetzen Sie <your-prediction-endpoint> durch den Endpunkt für Ihre Vorhersageressource.
• Um die Umgebungsvariable VISION_PREDICTION_RESOURCE_ID festzulegen, ersetzen Sie <your-resource-id> durch die Ressourcen-ID für Ihre Vorhersageressource.

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>

Einrichten

Erstellen eines neuen Gradle-Projekts

Erstellen Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und navigieren Sie zu ihr.

mkdir myapp && cd myapp

Führen Sie den gradle init Befehl aus Ihrem Arbeitsverzeichnis aus. Mit diesem Befehl werden wichtige Builddateien für Gradle erstellt, einschließlich build.gradle.kts, die zur Laufzeit zum Erstellen und Konfigurieren Ihrer Anwendung verwendet werden.

gradle init --type basic

Wenn Sie aufgefordert werden, ein DSL auszuwählen, wählen Sie Kotlin aus.

Installieren der Clientbibliothek

Suchen Sie build.gradle.kts , und öffnen Sie sie mit Ihrer bevorzugten IDE oder Ihrem Text-Editor. Kopieren Sie die folgende Buildkonfiguration. Diese Konfiguration definiert das Projekt als Java Anwendung, deren Einstiegspunkt die Klasse CustomVisionQuickstart ist. Sie importiert die benutzerdefinierten Vision-Bibliotheken.

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

Erstellen einer Java Datei

Führen Sie in Ihrem Arbeitsverzeichnis den folgenden Befehl aus, um einen Projektquellordner zu erstellen:

mkdir -p src/main/java

Navigieren Sie zum neuen Ordner, und erstellen Sie eine Datei namens CustomVisionQuickstart.java. Öffnen Sie ihn in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE und fügen Sie die folgenden import Anweisungen hinzu:

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;

Erstellen Sie in der CustomVisionQuickstart-Klasse der Anwendung Variablen, die die Schlüssel und endpunkte Ihrer Ressource aus Umgebungsvariablen abrufen.

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

Fügen Sie in der Hauptmethode der Anwendung Aufrufe für die in dieser Schnellstartanleitung verwendeten Methoden hinzu. Sie definieren diese später.

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

Objektmodell

Die folgenden Klassen und Schnittstellen behandeln einige der wichtigsten Features der Custom Vision Java-Clientbibliothek.

Codebeispiele

Diese Codeausschnitte zeigen Ihnen, wie Sie die folgenden Aufgaben mit der Benutzerdefinierten Vision-Clientbibliothek für Java ausführen:

• Authentifizieren des Clients
• Erstellen eines neuen Benutzerdefinierten Vision-Projekts
• Hinzufügen von Tags zum Projekt
• Hochladen und Kategorisieren von Bildern
• Trainieren des Projekts
• Veröffentlichen der aktuellen Iteration
• Testen des Vorhersageendpunkts

Authentifizieren des Clients

Instanziieren Sie in Ihrer main-Methode Trainings- und Vorhersageclients, indem Sie Ihren Endpunkt und die Schlüssel verwenden.

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

Erstellen eines neuen Benutzerdefinierten Vision-Projekts

Diese nächste Methode erstellt ein Objekterkennungsprojekt. Das erstellte Projekt wird auf der Zuvor besuchten Custom Vision-Website angezeigt. Sehen Sie sich die CreateProject-Methodenüberladungen an, um andere Optionen anzugeben, wenn Sie Ihr Projekt erstellen (erläutert im Handbuch zum Erstellen eines Detektorwebportals ).

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

Hinzufügen von Tags zu Ihrem Projekt

Diese Methode definiert die Tags, mit denen Sie das Modell trainieren.

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

Hochladen und Kategorisieren von Bildern

Laden Sie zunächst die Beispielbilder für dieses Projekt herunter. Speichern Sie den Inhalt des Ordners sample Images auf Ihrem lokalen Gerät.

Wenn Sie Bilder in Objekterkennungsprojekten kategorisieren, müssen Sie den Bereich jedes markierten Objekts mithilfe normalisierter Koordinaten angeben. Der folgende Code ordnet die einzelnen Beispielbilder dem markierten Bereich zu.

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

Der nächste Codeblock fügt dem Projekt die Bilder hinzu. Sie müssen die Argumente der GetImage-Aufrufe ändern, um auf die Speicherorte der heruntergeladenen Fork- und Scheren-Ordner zu verweisen.

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

Der vorherige Codeausschnitt verwendet zwei Hilfsfunktionen, die die Bilder als Ressourcenstreams abrufen und in den Dienst hochladen (Sie können bis zu 64 Bilder in einem einzigen Batch hochladen). Definieren Sie diese Methoden.

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

Projekt trainieren

Diese Methode erstellt die erste Schulungsiteration im Projekt. Der Dienst wird so lange abgefragt, bis das Training abgeschlossen ist.

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

Veröffentlichen der aktuellen Iteration

Diese Methode stellt die aktuelle Iteration des Modells für die Abfrage zur Verfügung. Sie können den Modellnamen als Verweis verwenden, um Vorhersageanforderungen zu senden. Sie müssen ihren eigenen Wert eingeben für predictionResourceId. Sie finden die Vorhersageressourcen-ID im Azure-Portal auf der Registerkarte Eigenschaften der Ressource, wo sie als Ressourcen-ID angegeben ist.

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

Testen des Vorhersageendpunkts

Diese Methode lädt das Testimage, fragt den Modellendpunkt ab und gibt Vorhersagedaten an die Konsole aus.

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

Ausführen der Anwendung

Sie können die App mit:

gradle build

Führen Sie die Anwendung mit dem gradle run Befehl aus:

gradle run

Bereinigen von Ressourcen

Wenn Sie ein Azure KI Services-Abonnement bereinigen und entfernen möchten, können Sie die Ressource oder Ressourcengruppe löschen. Durch das Löschen der Ressourcengruppe werden auch alle anderen ressourcen gelöscht, die ihr zugeordnet sind.

• Azure Portal
• Azure CLI

Wenn Sie Ihr eigenes Objekterkennungsprojekt implementieren möchten (oder stattdessen ein Bildklassifizierungsprojekt ausprobieren), können Sie das Fork/Scissors-Erkennungsprojekt aus diesem Beispiel löschen. Ein kostenloses Abonnement ermöglicht zwei Custom Vision-Projekte.

Navigieren Sie auf der Website Custom Vision zu Projects und wählen Sie den Papierkorb unter "Mein neues Project" aus.

Nächste Schritte

Jetzt haben Sie jeden Schritt des Objekterkennungsprozesses im Code ausgeführt. In diesem Beispiel wird eine einzelne Schulungsiteration ausgeführt. Häufig müssen Sie ihr Modell jedoch mehrmals trainieren und testen, um es genauer zu gestalten. Der folgende Leitfaden befasst sich mit der Bildklassifizierung, aber seine Prinzipien ähneln der Objekterkennung.

• Was ist Custom Vision?
• Der Quellcode für dieses Beispiel finden Sie unter GitHub

Dieses Handbuch enthält Anweisungen und Beispielcode, mit dem Sie mit der Benutzerdefinierten Vision-Clientbibliothek für Node.js beginnen können, um ein Objekterkennungsmodell zu erstellen. Sie erstellen ein Projekt, fügen Tags hinzu, trainieren das Projekt und verwenden die Url des Vorhersageendpunkts des Projekts, um es programmgesteuert zu testen. Verwenden Sie dieses Beispiel als Vorlage zum Erstellen Ihrer eigenen Bilderkennungs-App.

Referenzdokumentation (Schulung)(Vorhersage) | Package (npm) (Schulung)(Vorhersage) | Beispiele

Voraussetzungen

• Azure-Abonnement – Create one for free
• Die aktuelle Version von Node.js
• Sobald Sie Ihr Azure-Abonnement haben, erstellen Sie im Azure-Portal eine Custom Vision-Ressource, um eine Schulungs- und Vorhersageressource zu erstellen.
  • Sie können das kostenlose Preisniveau (F0) verwenden, um den Dienst zu testen und später auf eine kostenpflichtige Stufe für die Produktion zu aktualisieren.

Erstellen von Umgebungsvariablen

In diesem Beispiel schreiben Sie Ihre Anmeldeinformationen in Umgebungsvariablen auf dem lokalen Computer, auf dem die Anwendung ausgeführt wird.

Wechseln Sie zum Azure-Portal. Wenn die benutzerdefinierten Vision-Ressourcen, die Sie im Abschnitt "Voraussetzungen" erstellt haben, erfolgreich bereitgestellt wurden, wählen Sie unter "Nächste Schritte" die Schaltfläche "Gehe zu Ressource" aus. Sie finden Ihre Schlüssel und Endpunkte auf den Ressourcenschlüssel- und Endpunktseiten unter "Ressourcenverwaltung". Sie müssen die Schlüssel für Ihre Trainings- und Vorhersage Ressourcen zusammen mit den API-Endpunkten beziehen.

Sie finden die Ressourcen-ID der Vorhersage-Ressource auf der Registerkarte Properties im Azure-Portal, aufgelistet als Ressourcen-ID.

Um die Umgebungsvariablen festzulegen, öffnen Sie ein Konsolenfenster, und befolgen Sie die Anweisungen für Ihr Betriebssystem und Ihre Entwicklungsumgebung.

• Zum Festlegen der Umgebungsvariablen VISION_TRAINING KEY ersetzen Sie <your-training-key> durch einen der Schlüssel für Ihre Trainingsressource.
• Um die Umgebungsvariable VISION_TRAINING_ENDPOINT festzulegen, ersetzen Sie <your-training-endpoint> durch den Endpunkt für Ihre Schulungsressource.
• Um die Umgebungsvariable VISION_PREDICTION_KEY festzulegen, ersetzen Sie <your-prediction-key> durch einen der Schlüssel für Ihre Vorhersageressource.
• Um die Umgebungsvariable VISION_PREDICTION_ENDPOINT festzulegen, ersetzen Sie <your-prediction-endpoint> durch den Endpunkt für Ihre Vorhersageressource.
• Um die Umgebungsvariable VISION_PREDICTION_RESOURCE_ID festzulegen, ersetzen Sie <your-resource-id> durch die Ressourcen-ID für Ihre Vorhersageressource.

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>

Einrichten

Erstellen einer neuen Node.js Anwendung

Erstellen Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und navigieren Sie zu ihr.

mkdir myapp && cd myapp

Führen Sie den npm init Befehl aus, um eine Knotenanwendung mit einer package.json Datei zu erstellen.

npm init

Installieren der Clientbibliothek

Um eine Bildanalyse-App mit Custom Vision für Node.js zu schreiben, benötigen Sie die Custom Vision npm-Pakete. Führen Sie zum Installieren den folgenden Befehl in PowerShell aus:

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

Die Datei Ihrer App package.json wird mit den Abhängigkeiten aktualisiert.

Erstellen Sie eine Datei mit dem Namen index.js , und importieren Sie die folgenden Bibliotheken:

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

Erstellen Sie Variablen für den Azure Endpunkt und schlüssel Ihrer Ressource.

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

Fügen Sie außerdem Felder für den Projektnamen und einen Timeoutparameter für asynchrone Aufrufe hinzu.

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

Objektmodell

Codebeispiele

Diese Codeausschnitte zeigen Ihnen, wie Sie die folgenden Aufgaben mit der Custom Vision-Clientbibliothek für JavaScript ausführen:

• Authentifizieren des Clients
• Erstellen eines neuen Benutzerdefinierten Vision-Projekts
• Hinzufügen von Tags zum Projekt
• Hochladen und Kategorisieren von Bildern
• Trainieren des Projekts
• Veröffentlichen der aktuellen Iteration
• Testen des Vorhersageendpunkts

Authentifizieren des Clients

Instanziieren Sie Clientobjekte mit Ihrem Endpunkt und Schlüssel. Erstellen Sie ein ApiKeyCredentials-Objekt mit Ihrem Schlüssel, und verwenden Sie es mit Ihrem Endpunkt, um ein TrainingAPIClient - und PredictionAPIClient-Objekt zu erstellen.

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

Hilfsfunktion hinzufügen

Fügen Sie die folgende Funktion hinzu, um mehrere asynchrone Aufrufe auszuführen. Sie werden dies später verwenden.

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

Erstellen eines neuen Benutzerdefinierten Vision-Projekts

Starten Sie eine neue Funktion, die alle Custom Vision-Funktionsaufrufe enthält. Fügen Sie den folgenden Code hinzu, um ein neues Custom Vision-Dienstprojekt zu erstellen.

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

Hinzufügen von Tags zum Projekt

Um Klassifizierungstags zu Ihrem Projekt zu erstellen, fügen Sie Ihrer Funktion den folgenden Code hinzu:

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

Hochladen und Kategorisieren von Bildern

Laden Sie zunächst die Beispielbilder für dieses Projekt herunter. Speichern Sie den Inhalt des Ordners sample Images auf Ihrem lokalen Gerät.

Fügen Sie nach dem Erstellen des Tags den folgenden Code ein, um dem Projekt die Beispielbilder hinzuzufügen. Dieser Code lädt jedes Bild mit dem entsprechenden Tag hoch. Wenn Sie Bilder in Objekterkennungsprojekten kategorisieren, müssen Sie den Bereich jedes markierten Objekts mithilfe normalisierter Koordinaten angeben. Die Bereiche für dieses Tutorial werden inline mit dem Code hartcodiert. Die Regionen geben den Begrenzungsrahmen in normalisierten Koordinaten an, und die Koordinaten werden in der folgenden Reihenfolge angegeben: links, oben, Breite, Höhe. Sie können bis zu 64 Bilder in einem einzigen Batch hochladen.

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

Projekt trainieren

Dieser Code erstellt die erste Iteration des Vorhersagemodells.

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

Veröffentlichen der aktuellen Iteration

Mit diesem Code wird die trainierte Iteration für den Vorhersageendpunkt veröffentlicht. Der Name, der der veröffentlichten Iteration zugewiesen wird, kann zum Senden von Vorhersageanforderungen verwendet werden. Eine Iteration ist erst im Vorhersageendpunkt verfügbar, wenn sie veröffentlicht wurde.

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

Testen des Vorhersageendpunkts

Um ein Bild an den Vorhersageendpunkt zu senden und die Vorhersage abzurufen, fügen Sie Der Funktion den folgenden Code hinzu.

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

Schließen Sie dann die Custom Vision-Funktion und rufen Sie sie auf.

})()

Ausführen der Anwendung

Führen Sie die Anwendung mit dem node Befehl in der Schnellstartdatei aus.

node index.js

Die Ausgabe der Anwendung sollte in der Konsole erscheinen. Anschließend können Sie überprüfen, ob das Testbild (in <sampleDataRoot>/Test/) richtig markiert ist und dass der Bereich der Erkennung korrekt ist. Sie können auch zur Website "Custom Vision " zurückkehren und den aktuellen Status Ihres neu erstellten Projekts anzeigen.

Bereinigen von Ressourcen

Wenn Sie Ihr eigenes Objekterkennungsprojekt implementieren möchten (oder stattdessen ein Bildklassifizierungsprojekt ausprobieren), können Sie das Fork/Scissors-Erkennungsprojekt aus diesem Beispiel löschen. Ein kostenloses Abonnement ermöglicht zwei Custom Vision-Projekte.

Navigieren Sie auf der Website Custom Vision zu Projects und wählen Sie den Papierkorb unter "Mein neues Project" aus.

Nächste Schritte

Jetzt haben Sie jeden Schritt des Objekterkennungsprozesses im Code ausgeführt. In diesem Beispiel wird eine einzelne Schulungsiteration ausgeführt, aber häufig müssen Sie Ihr Modell mehrmals trainieren und testen, um es genauer zu gestalten. Der folgende Leitfaden befasst sich mit der Bildklassifizierung, aber seine Prinzipien ähneln der Objekterkennung.

• Was ist Custom Vision?
• Der Quellcode für dieses Beispiel finden Sie unter GitHub
• SDK-Referenzdokumentation (Schulung)
• SDK-Referenzdokumentation (Vorhersage)

Erste Schritte mit der Benutzerdefinierten Vision-Clientbibliothek für Python. Führen Sie die folgenden Schritte aus, um das Paket zu installieren und den Beispielcode zum Erstellen eines Objekterkennungsmodells auszuprobieren. Sie erstellen ein Projekt, fügen Tags hinzu, trainieren das Projekt und verwenden die Url des Vorhersageendpunkts des Projekts, um es programmgesteuert zu testen. Verwenden Sie dieses Beispiel als Vorlage zum Erstellen Ihrer eigenen Bilderkennungs-App.

Reference-Dokumentation | Bibliotheksquellcode | Package (PyPI) | Beispiele

Voraussetzungen

• Azure-Abonnement – Create one for free
• Python 3.x
  • Ihre Python-Installation sollte pip enthalten. Sie können überprüfen, ob pip installiert ist, indem Sie pip --version auf der Befehlszeile ausführen. Erhalten Sie pip durch die Installation der neuesten Version von Python.
• Sobald Sie Ihr Azure-Abonnement haben, erstellen Sie eine benutzerdefinierte Vision-Ressource im Azure-Portal, um eine Schulungs- und Vorhersageressource zu erstellen.
  • Sie können das kostenlose Preisniveau (F0) verwenden, um den Dienst zu testen und später auf eine kostenpflichtige Stufe für die Produktion zu aktualisieren.

Erstellen von Umgebungsvariablen

In diesem Beispiel schreiben Sie Ihre Anmeldeinformationen in Umgebungsvariablen auf dem lokalen Computer, auf dem die Anwendung ausgeführt wird.

Wechseln Sie zum Azure-Portal. Wenn die benutzerdefinierten Vision-Ressourcen, die Sie im Abschnitt "Voraussetzungen" erstellt haben, erfolgreich bereitgestellt wurden, wählen Sie unter "Nächste Schritte" die Schaltfläche "Gehe zu Ressource" aus. Sie finden Ihre Schlüssel und Endpunkte auf den Ressourcenschlüssel- und Endpunktseiten unter "Ressourcenverwaltung". Sie müssen die Schlüssel für Ihre Trainings- und Vorhersage Ressourcen zusammen mit den API-Endpunkten beziehen.

Sie finden die Ressourcen-ID der Vorhersage-Ressource auf der Registerkarte Properties im Azure-Portal, aufgelistet als Ressourcen-ID.

Um die Umgebungsvariablen festzulegen, öffnen Sie ein Konsolenfenster, und befolgen Sie die Anweisungen für Ihr Betriebssystem und Ihre Entwicklungsumgebung.

• Zum Festlegen der Umgebungsvariablen VISION_TRAINING KEY ersetzen Sie <your-training-key> durch einen der Schlüssel für Ihre Trainingsressource.
• Um die Umgebungsvariable VISION_TRAINING_ENDPOINT festzulegen, ersetzen Sie <your-training-endpoint> durch den Endpunkt für Ihre Schulungsressource.
• Um die Umgebungsvariable VISION_PREDICTION_KEY festzulegen, ersetzen Sie <your-prediction-key> durch einen der Schlüssel für Ihre Vorhersageressource.
• Um die Umgebungsvariable VISION_PREDICTION_ENDPOINT festzulegen, ersetzen Sie <your-prediction-endpoint> durch den Endpunkt für Ihre Vorhersageressource.
• Um die Umgebungsvariable VISION_PREDICTION_RESOURCE_ID festzulegen, ersetzen Sie <your-resource-id> durch die Ressourcen-ID für Ihre Vorhersageressource.

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>

Einrichten

Installieren der Clientbibliothek

Zum Schreiben einer Bildanalyse-App mit custom Vision for Python benötigen Sie die Clientbibliothek "Custom Vision". Führen Sie nach der Installation von Python den folgenden Befehl in PowerShell oder einem Konsolenfenster aus:

pip install azure-cognitiveservices-vision-customvision

Erstellen einer neuen Python Anwendung

Erstellen Sie eine neue Python Datei, und importieren Sie die folgenden Bibliotheken.

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

Erstellen Sie Variablen für den Azure Endpunkt und schlüssel Ihrer Ressource.

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

Objektmodell

Codebeispiele

Diese Codeausschnitte zeigen Ihnen, wie Sie die folgenden Schritte mit der Clientbibliothek "Custom Vision" für Python ausführen:

• Authentifizieren des Clients
• Erstellen eines neuen Benutzerdefinierten Vision-Projekts
• Hinzufügen von Tags zum Projekt
• Hochladen und Kategorisieren von Bildern
• Trainieren des Projekts
• Veröffentlichen der aktuellen Iteration
• Testen des Vorhersageendpunkts

Authentifizieren des Clients

Instanziieren Sie einen Schulungs- und Vorhersageclient mit Ihrem Endpunkt und Ihren Schlüsseln. Erstellen Sie ApiKeyServiceClientCredentials-Objekte mit Ihren Schlüsseln, und verwenden Sie sie mit Ihrem Endpunkt, um ein CustomVisionTrainingClient - und CustomVisionPredictionClient-Objekt zu erstellen.

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)

Erstellen eines neuen Benutzerdefinierten Vision-Projekts

Fügen Sie Ihrem Skript den folgenden Code hinzu, um ein neues Benutzerdefiniertes Vision-Dienstprojekt zu erstellen.

Sehen Sie sich die create_project Methode an, um andere Optionen anzugeben, wenn Sie Ihr Projekt erstellen (erläutert im Handbuch zum Erstellen eines Detektorwebportals ).

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)

Hinzufügen von Tags zum Projekt

Fügen Sie den folgenden Code hinzu, um Objekttags in Ihrem Projekt zu erstellen:

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

Hochladen und Kategorisieren von Bildern

Laden Sie zunächst die Beispielbilder für dieses Projekt herunter. Speichern Sie den Inhalt des Ordners sample Images auf Ihrem lokalen Gerät.

Wenn Sie Bilder in Objekterkennungsprojekten kategorisieren, müssen Sie den Bereich jedes markierten Objekts mithilfe normalisierter Koordinaten angeben. Der folgende Code ordnet die einzelnen Beispielbilder dem markierten Bereich zu. Die Regionen geben den Begrenzungsrahmen in normalisierten Koordinaten an, und die Koordinaten werden in der folgenden Reihenfolge angegeben: links, oben, Breite, Höhe.

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

Verwenden Sie dann diese Zuordnungszuordnung, um jedes Beispielbild mit seinen Regionskoordinaten hochzuladen (Sie können bis zu 64 Bilder in einem einzelnen Batch hochladen). Fügen Sie den folgenden Code hinzu.

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)

Projekt trainieren

Dieser Code erstellt die erste Iteration des Vorhersagemodells.

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)

Veröffentlichen der aktuellen Iteration

Eine Iteration ist erst im Vorhersageendpunkt verfügbar, wenn sie veröffentlicht wurde. Der folgende Code stellt die aktuelle Iteration des Modells für die Abfrage zur Verfügung.

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

Testen des Vorhersageendpunkts

Um ein Bild an den Vorhersageendpunkt zu senden und die Vorhersage abzurufen, fügen Sie am Ende der Datei den folgenden Code hinzu:

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

Ausführen der Anwendung

Führen Sie CustomVisionQuickstart.py aus.

python CustomVisionQuickstart.py

Die Ausgabe der Anwendung sollte in der Konsole erscheinen. Anschließend können Sie überprüfen, ob das Testbild (in base_image_location</images/Test)> richtig markiert ist und dass der Bereich der Erkennung korrekt ist. Sie können auch zur Website "Custom Vision " zurückkehren und den aktuellen Status Ihres neu erstellten Projekts anzeigen.

Bereinigen von Ressourcen

Wenn Sie Ihr eigenes Objekterkennungsprojekt implementieren möchten (oder stattdessen ein Bildklassifizierungsprojekt ausprobieren), können Sie das Fork/Scissors-Erkennungsprojekt aus diesem Beispiel löschen. Ein kostenloses Abonnement ermöglicht zwei Custom Vision-Projekte.

Navigieren Sie auf der Website Custom Vision zu Projects und wählen Sie den Papierkorb unter "Mein neues Project" aus.

Nächste Schritte

Jetzt haben Sie jeden Schritt des Objekterkennungsprozesses im Code ausgeführt. In diesem Beispiel wird eine einzelne Schulungsiteration ausgeführt. Häufig müssen Sie ihr Modell jedoch mehrmals trainieren und testen, um es genauer zu gestalten. Der folgende Leitfaden befasst sich mit der Bildklassifizierung, aber seine Prinzipien ähneln der Objekterkennung.

• Was ist Custom Vision?
• Der Quellcode für dieses Beispiel finden Sie unter GitHub
• SDK-Referenzdokumentation