Schnellstart: Objekterkennung mit der Custom Vision-Clientbibliothek - Azure AI services

Hier erhalten Sie Informationen zu den ersten Schritten mit der Custom Vision-Clientbibliothek für .NET. Führen Sie diese 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 anhand von Beispielbildern und verwenden die Vorhersageendpunkt-URL des Projekts, um es programmgesteuert zu testen. Verwenden Sie dieses Beispiel als Vorlage für die Erstellung Ihrer eigenen Bilderkennungsanwendung.

Hinweis

Falls Sie ein Objekterkennungsmodell erstellen und trainieren möchten, ohne Code zu schreiben, sehen Sie sich stattdessen die browserbasierte Anleitung an.

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

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Die Visual Studio-IDE oder die aktuelle Version von .NET Core.
Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Custom Vision-Ressource erstellen, um eine Trainings- und Vorhersageressource zu erstellen.
- Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Erstellen von Umgebungsvariablen

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

Öffnen Sie das Azure-Portal. Wenn die im Abschnitt Voraussetzungen erstellten Custom Vision-Ressourcen erfolgreich bereitgestellt wurden, wählen Sie unter Nächste Schritte die Schaltfläche Zu Ressource wechseln aus. Ihre Schlüssel und Endpunkte finden Sie auf den entsprechenden Seiten der Ressourcen unter Ressourcenverwaltung. Sie müssen die Schlüssel für Ihre Trainings- und Vorhersageressourcen sowie die API-Endpunkte erhalten.

Sie finden die Vorhersageressourcen-ID im Azure-Portal auf der Registerkarte Eigenschaften der Vorhersageressource, wo sie als Ressourcen-ID angegeben ist.

Tipp

Sie verwenden https://www.customvision.ai/ auch, um diese Werte abzurufen. Wählen Sie nach der Anmeldung oben rechts das Symbol Einstellungen aus. Auf den Seiten Einstellung können Sie alle Schlüssel, Ressourcen-IDs und Endpunkte anzeigen.

Achtung

Fügen Sie den Schlüssel nicht direkt in Ihren Code ein, und machen Sie ihn nicht öffentlich zugänglich. Im Artikel zur Azure KI Services-Sicherheit finden Sie weitere Authentifizierungsoptionen wie zum Beispiel Azure Key Vault.

Zum Festlegen der Umgebungsvariable für Ihren Ressourcenschlüssel öffnen Sie ein Konsolenfenster und befolgen 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.
Zum Festlegen der Umgebungsvariablen VISION_TRAINING_ENDPOINT ersetzen Sie your-training-endpoint durch den Endpunkt für Ihre Trainingsressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_KEY ersetzen Sie your-prediction-key durch einen der Schlüssel für Ihre Vorhersageressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_ENDPOINT ersetzen Sie your-prediction-endpoint durch den Endpunkt für Ihre Vorhersageressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_RESOURCE_ID ersetzen Sie your-resource-id durch die Ressourcen-ID für Ihre Vorhersageressource.

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

Nachdem Sie die Umgebungsvariable hinzugefügt haben, müssen Sie unter Umständen alle ausgeführten Programme neu starten, von denen die Umgebungsvariablen gelesen werden, einschließlich des Konsolenfensters.

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

Führen Sie nach dem Hinzufügen der Umgebungsvariablen im Konsolenfenster source ~/.bashrc aus, damit die Änderungen wirksam werden.

Erstellen einer neuen C#-Anwendung

Erstellen Sie mit Visual Studio eine neue .NET Core-Anwendung.

Installieren der Clientbibliothek

Installieren Sie nach der Erstellung eines neuen Projekts die Clientbibliothek, indem Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe klicken und NuGet-Pakete verwalten auswählen. Wählen Sie im daraufhin geöffneten Paket-Manager die Option Durchsuchen aus, aktivieren Sie das Kontrollkästchen Vorabversion einbeziehen, und suchen Sie nach Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training und Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction. Wählen Sie die neueste Version und dann die Option Installieren aus.

Erstellen einer neuen C#-Anwendung

Verwenden Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) den Befehl dotnet new zum Erstellen einer neuen Konsolen-App mit dem Namen custom-vision-quickstart. Dieser Befehl erstellt ein einfaches C#-Projekt vom Typ „Hallo Welt“ mit einer einzelnen Quelldatei: program.cs.

dotnet new console -n custom-vision-quickstart

Wechseln Sie zum Ordner der neu erstellten App. Sie können die Anwendung mit folgendem Befehl erstellen:

dotnet build

Die Buildausgabe sollte keine Warnungen oder Fehler enthalten.

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

Installieren der Clientbibliothek

Installieren Sie im Anwendungsverzeichnis mit dem folgenden Befehl die Custom Vision-Clientbibliothek für .NET:

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

Tipp

Möchten Sie sich sofort die gesamte Codedatei für die Schnellstartanleitung ansehen? Die Datei steht auf GitHub zur Verfügung. Dort finden Sie die Codebeispiele aus dieser Schnellstartanleitung.

Öffnen Sie über das 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 Main-Methode der Anwendung Variablen, die die Schlüssel und den Endpunkt Ihrer Ressource aus Umgebungsvariablen abrufen. Darüber hinaus deklarieren Sie einige grundlegende Objekte zur späteren Verwendung.

    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 Methoden hinzu, die in dieser Schnellstartanleitung verwendet werden. Sie führen die Implementierung hierfür zu einem späteren Zeitpunkt durch.

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 in einer neuen Methode Trainings- und Vorhersageclients, indem Sie Ihren Endpunkt und die Schlüssel verwenden.

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 Custom Vision-Projekts

Die nächste Methode erstellt ein Objekterkennungsprojekt. Das erstellte Projekt wird auf der Custom Vision-Website angezeigt. Informationen zur Angabe weiterer Optionen bei der Erstellung Ihres Projekts finden Sie im Artikel zur Methode CreateProject. Informationen zur Projekterstellung finden Sie unter Schnellstart: Informationen zum Erstellen einer Objekterkennung mit Custom Vision.

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

Mit dieser Methode werden die Tags definiert, die Sie zum Trainieren des Modells verwenden.

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 Kennzeichnen von Bildern

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

Wenn Sie Bilder in Objekterkennungsprojekten mit Tags versehen, müssen Sie mithilfe normalisierter Koordinaten die Region des jeweiligen markierten Objekts angeben. Im folgenden Code wird jedem der Beispielbilder die entsprechende markierte Region zugeordnet.

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

Hinweis

Falls Sie für Ihre eigenen Projekte nicht über ein Hilfsprogramm zum Klicken und Ziehen verfügen, um die Koordinaten von Regionen zu markieren, können Sie die Webbenutzeroberfläche auf der Custom Vision-Website verwenden. In diesem Beispiel sind die Koordinaten bereits vorhanden.

Auf der Grundlage dieser Zuordnungen werden dann die einzelnen Bilder zusammen mit den jeweiligen Regionskoordinaten hochgeladen. Sie können bis zu 64 Bilder in einem Batch hochladen. Unter Umständen müssen Sie den Wert imagePath so ändern, dass er auf die richtigen Ordnerspeicherorte verweist.

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

Trainieren des Projekts

Mit dieser Methode wird die erste Trainingsiteration im Projekt erstellt. 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);
    }
}

Tipp

Trainieren mit ausgewählten Tags

Optional können Sie das Training nur mit einer Teilmenge der angewendeten Tags durchführen. Das ist empfehlenswert, wenn bestimmte Tags noch nicht ausreichend angewendet wurden, andere jedoch schon. Verwenden Sie den Parameter trainingParameters im TrainProject-Aufruf. Erstellen Sie eine TrainingParameters-Klasse, und legen Sie deren Eigenschaft SelectedTags auf eine Liste der zu verwendenden Tag-IDs fest. Das Modell wird darauf trainiert, nur die Tags in dieser Liste zu erkennen.

Veröffentlichen der aktuellen Iteration

Mit dieser Methode wird die aktuelle Iteration des Modells zum Abfragen verfügbar gemacht. Sie können den Modellnamen als Referenz zum Senden von Vorhersageanforderungen verwenden. Hierbei ist es erforderlich, dass Sie Ihren eigenen Wert für predictionResourceId eingeben. 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 Testbild, 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

Visual Studio-IDE
BEFEHLSZEILENSCHNITTSTELLE (CLI)

Führen Sie die Anwendung aus, indem Sie oben im IDE-Fenster auf die Schaltfläche Debuggen klicken.

Führen Sie die Anwendung mit dem Befehl dotnet run aus dem Anwendungsverzeichnis aus.

dotnet run

Während der Anwendungsausführung sollte ein Konsolenfenster mit folgender Ausgabe geöffnet 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 ]

Daraufhin können Sie sich vergewissern, dass das Testbild (unter Images/Test/ ) ordnungsgemäß gekennzeichnet und die Erkennungsregion korrekt ist. Drücken Sie eine beliebige Taste, um die Anwendung zu beenden.

Bereinigen von Ressourcen

Wenn Sie Ihr eigenes Objekterkennungsprojekt implementieren oder stattdessen ein Projekt zur Bildklassifizierung ausprobieren möchten, können Sie das Projekt zur Erkennung von Gabeln/Scheren aus diesem Beispiel löschen. Im Rahmen eines kostenlosen Abonnements können zwei Custom Vision-Projekte erstellt werden.

Navigieren Sie auf der Custom Vision-Website zu Projects (Projekte), und wählen Sie unter „My New Project“ (Mein neues Projekt) das Papierkorbsymbol.

Screenshot of a panel labeled My New Project with a trash can icon.

Nächste Schritte

Sie haben jetzt die einzelnen Schritte des Objekterkennungsprozesses im Code ausgeführt. In diesem Beispiel wird eine einzelne Trainingsiteration ausgeführt. Zur Verbesserung der Genauigkeit muss ein Modell jedoch häufig mehrmals trainiert und getestet werden. In der folgenden Anleitung wird die Bildklassifizierung behandelt. Die Prinzipien sind jedoch mit denen der Objekterkennung vergleichbar.

Testen und erneutes Trainieren eines Modells mit Custom Vision Service

Was ist Custom Vision?
Den Quellcode für dieses Beispiel finden Sie auf GitHub.
SDK-Referenzdokumentation

Dieser Leitfaden enthält Anweisungen und Beispielcode für die ersten Schritte mit der Custom Vision-Clientbibliothek für Go und unterstützt Sie beim Erstellen eines Objekterkennungsmodells. Sie erstellen ein Projekt, fügen Tags hinzu, trainieren das Projekt und verwenden die Vorhersageendpunkt-URL des Projekts, um es programmgesteuert zu testen. Verwenden Sie dieses Beispiel als Vorlage für die Erstellung Ihrer eigenen Bilderkennungsanwendung.

Hinweis

Falls Sie ein Objekterkennungsmodell erstellen und trainieren möchten, ohne Code zu schreiben, sehen Sie sich stattdessen die browserbasierte Anleitung an.

Verwenden Sie die Custom Vision-Clientbibliothek für Go für folgende Aufgaben:

Erstellen eines neuen Custom Vision-Projekts
Hinzufügen von Tags zum Projekt
Hochladen und Kennzeichnen von Bildern
Trainieren des Projekts
Veröffentlichen der aktuellen Iteration
Testen des Vorhersageendpunkts

Referenzdokumentation (Training)(Vorhersage)

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Go 1.8+
Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Custom Vision-Ressource erstellen, um eine Trainings- und Vorhersageressource zu erstellen.
- Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Erstellen von Umgebungsvariablen

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

Öffnen Sie das Azure-Portal. Wenn die im Abschnitt Voraussetzungen erstellten Custom Vision-Ressourcen erfolgreich bereitgestellt wurden, wählen Sie unter Nächste Schritte die Schaltfläche Zu Ressource wechseln aus. Ihre Schlüssel und Endpunkte finden Sie auf den entsprechenden Seiten der Ressourcen unter Ressourcenverwaltung. Sie müssen die Schlüssel für Ihre Trainings- und Vorhersageressourcen sowie die API-Endpunkte erhalten.

Sie finden die Vorhersageressourcen-ID im Azure-Portal auf der Registerkarte Eigenschaften der Vorhersageressource, wo sie als Ressourcen-ID angegeben ist.

Tipp

Sie verwenden https://www.customvision.ai/ auch, um diese Werte abzurufen. Wählen Sie nach der Anmeldung oben rechts das Symbol Einstellungen aus. Auf den Seiten Einstellung können Sie alle Schlüssel, Ressourcen-IDs und Endpunkte anzeigen.

Achtung

Fügen Sie den Schlüssel nicht direkt in Ihren Code ein, und machen Sie ihn nicht öffentlich zugänglich. Im Artikel zur Azure KI Services-Sicherheit finden Sie weitere Authentifizierungsoptionen wie zum Beispiel Azure Key Vault.

Zum Festlegen der Umgebungsvariable für Ihren Ressourcenschlüssel öffnen Sie ein Konsolenfenster und befolgen 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.
Zum Festlegen der Umgebungsvariablen VISION_TRAINING_ENDPOINT ersetzen Sie your-training-endpoint durch den Endpunkt für Ihre Trainingsressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_KEY ersetzen Sie your-prediction-key durch einen der Schlüssel für Ihre Vorhersageressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_ENDPOINT ersetzen Sie your-prediction-endpoint durch den Endpunkt für Ihre Vorhersageressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_RESOURCE_ID ersetzen Sie your-resource-id durch die Ressourcen-ID für Ihre Vorhersageressource.

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

Nachdem Sie die Umgebungsvariable hinzugefügt haben, müssen Sie unter Umständen alle ausgeführten Programme neu starten, von denen die Umgebungsvariablen gelesen werden, einschließlich des Konsolenfensters.

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

Führen Sie nach dem Hinzufügen der Umgebungsvariablen im Konsolenfenster source ~/.bashrc aus, damit die Änderungen wirksam werden.

Einrichten

Installieren der Custom Vision-Clientbibliothek

Zum Schreiben einer Bildanalyseanwendung mit Custom Vision für Go benötigen Sie die Clientbibliothek für den Custom Vision-Dienst. Führen Sie in PowerShell den folgenden Befehl aus:

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

Bei Verwendung von dep können Sie alternativ Folgendes in Ihrem Repository ausführen:

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

Abrufen der Beispielbilder

Dieses Beispiel verwendet die Bilder aus dem GitHub-Repository Azure KI Services-Beispiele für das Python SDK. Klonen Sie dieses Repository, oder laden Sie es in Ihre Entwicklungsumgebung herunter. Merken Sie sich den Speicherort des Ordners. Er wird in einem späteren Schritt benötigt.

Erstellen des Custom Vision-Projekts

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

Fügen Sie Ihrem Skript den folgenden Code hinzu, um ein neues Custom Vision Service-Projekt zu erstellen.

Informationen zur Angabe weiterer Optionen bei der Erstellung Ihres Projekts finden Sie im Artikel zur Methode CreateProject. Informationen zur Projekterstellung finden Sie unter Schnellstart: Informationen zum Erstellen einer Objekterkennung mit Custom Vision.

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

Fügen Sie am Ende der Datei sample.go den folgenden Code hinzu, um Ihrem Projekt Klassifizierungstags hinzuzufügen:

# 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 Kennzeichnen von Bildern

Wenn Sie Bilder in Objekterkennungsprojekten mit Tags versehen, müssen Sie mithilfe normalisierter Koordinaten die Region des jeweiligen markierten Objekts angeben.

Hinweis

Falls Sie über kein Hilfsprogramm zum Klicken und Ziehen verfügen, um die Koordinaten von Regionen zu markieren, können Sie die Webbenutzeroberfläche unter Customvision.ai verwenden. In diesem Beispiel sind die Koordinaten bereits vorhanden.

Wenn Sie Bilder, Tags und Regionen zum Projekt hinzufügen möchten, fügen Sie nach der Tagerstellung den folgenden Code ein. 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 },
}

Laden Sie dann auf der Grundlage dieser Zuordnungen die einzelnen Bilder zusammen mit den jeweiligen Regionskoordinaten hoch. (Sie können bis zu 64 Bilder in einem Batch hochladen.) Fügen Sie den folgenden Code hinzu.

Hinweis

Sie müssen den Pfad zu den Bildern basierend auf dem Ort ändern, von dem Sie zuvor das Azure KI Services SDK-Beispielprojekt für Go heruntergeladen haben.

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

Trainieren und Veröffentlichen des Projekts

Dieser Code erstellt die erste Iteration des Vorhersagemodells und veröffentlicht diese anschließend am Vorhersageendpunkt. Der Name der veröffentlichten Iteration kann zum Senden von Vorhersageanforderungen verwendet werden. Eine Iteration ist erst am Vorhersageendpunkt verfügbar, wenn sie veröffentlicht wurde.

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

    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 angezeigt werden. Daraufhin können Sie sich vergewissern, dass das Testbild (unter samples/vision/images/Test) ordnungsgemäß gekennzeichnet und die Erkennungsregion korrekt ist.

Bereinigen von Ressourcen

Wenn Sie Ihr eigenes Objekterkennungsprojekt implementieren oder stattdessen ein Projekt zur Bildklassifizierung ausprobieren möchten, können Sie das Projekt zur Erkennung von Gabeln/Scheren aus diesem Beispiel löschen. Im Rahmen eines kostenlosen Abonnements können zwei Custom Vision-Projekte erstellt werden.

Navigieren Sie auf der Custom Vision-Website zu Projects (Projekte), und wählen Sie unter „My New Project“ (Mein neues Projekt) das Papierkorbsymbol.

Screenshot of a panel labeled My New Project with a trash can icon.

Nächste Schritte

Sie haben jetzt die einzelnen Schritte des Objekterkennungsprozesses im Code ausgeführt. In diesem Beispiel wird eine einzelne Trainingsiteration ausgeführt. Zur Verbesserung der Genauigkeit muss ein Modell jedoch häufig mehrmals trainiert und getestet werden. In der folgenden Anleitung wird die Bildklassifizierung behandelt. Die Prinzipien sind jedoch mit denen der Objekterkennung vergleichbar.

Testen und erneutes Trainieren eines Modells mit Custom Vision Service

Erste Schritte mit der Custom Vision-Clientbibliothek für Java zum Erstellen eines Objekterkennungsmodells. Führen Sie die nachfolgenden Schritte zum Installieren des Pakets aus, und testen Sie den Beispielcode für grundlegende Aufgaben. Verwenden Sie dieses Beispiel als Vorlage für die Erstellung Ihrer eigenen Bilderkennungsanwendung.

Hinweis

Falls Sie ein Objekterkennungsmodell erstellen und trainieren möchten, ohne Code zu schreiben, sehen Sie sich stattdessen die browserbasierte Anleitung an.

Verwenden Sie die Custom Vision-Clientbibliothek für Java für folgende Aufgaben:

Erstellen eines neuen Custom Vision-Projekts
Hinzufügen von Tags zum Projekt
Hochladen und Kennzeichnen von Bildern
Trainieren des Projekts
Veröffentlichen der aktuellen Iteration
Testen des Vorhersageendpunkts

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

Voraussetzungen

Azure-Abonnement: Kostenloses Azure-Konto
Aktuelle Version des Java Development Kit (JDK)
Gradle-Buildtool oder einen anderen Abhängigkeit-Manager
Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Custom Vision-Ressource erstellen, um eine Trainings- und Vorhersageressource zu erstellen.
- Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Erstellen von Umgebungsvariablen

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

Öffnen Sie das Azure-Portal. Wenn die im Abschnitt Voraussetzungen erstellten Custom Vision-Ressourcen erfolgreich bereitgestellt wurden, wählen Sie unter Nächste Schritte die Schaltfläche Zu Ressource wechseln aus. Ihre Schlüssel und Endpunkte finden Sie auf den entsprechenden Seiten der Ressourcen unter Ressourcenverwaltung. Sie müssen die Schlüssel für Ihre Trainings- und Vorhersageressourcen sowie die API-Endpunkte erhalten.

Sie finden die Vorhersageressourcen-ID im Azure-Portal auf der Registerkarte Eigenschaften der Vorhersageressource, wo sie als Ressourcen-ID angegeben ist.

Tipp

Sie verwenden https://www.customvision.ai/ auch, um diese Werte abzurufen. Wählen Sie nach der Anmeldung oben rechts das Symbol Einstellungen aus. Auf den Seiten Einstellung können Sie alle Schlüssel, Ressourcen-IDs und Endpunkte anzeigen.

Achtung

Fügen Sie den Schlüssel nicht direkt in Ihren Code ein, und machen Sie ihn nicht öffentlich zugänglich. Im Artikel zur Azure KI Services-Sicherheit finden Sie weitere Authentifizierungsoptionen wie zum Beispiel Azure Key Vault.

Zum Festlegen der Umgebungsvariable für Ihren Ressourcenschlüssel öffnen Sie ein Konsolenfenster und befolgen 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.
Zum Festlegen der Umgebungsvariablen VISION_TRAINING_ENDPOINT ersetzen Sie your-training-endpoint durch den Endpunkt für Ihre Trainingsressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_KEY ersetzen Sie your-prediction-key durch einen der Schlüssel für Ihre Vorhersageressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_ENDPOINT ersetzen Sie your-prediction-endpoint durch den Endpunkt für Ihre Vorhersageressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_RESOURCE_ID ersetzen Sie your-resource-id durch die Ressourcen-ID für Ihre Vorhersageressource.

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

Nachdem Sie die Umgebungsvariable hinzugefügt haben, müssen Sie unter Umständen alle ausgeführten Programme neu starten, von denen die Umgebungsvariablen gelesen werden, einschließlich des Konsolenfensters.

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

Führen Sie nach dem Hinzufügen der Umgebungsvariablen im Konsolenfenster source ~/.bashrc aus, damit die Änderungen wirksam werden.

Einrichten

Erstellen eines neuen Gradle-Projekts

Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es auf.

mkdir myapp && cd myapp

Führen Sie den Befehl gradle init in Ihrem Arbeitsverzeichnis aus. Mit diesem Befehl werden grundlegende Builddateien für Gradle, u. a. die Datei build.gradle.kts, erstellt. Diese Datei wird zur Laufzeit zum Erstellen und Konfigurieren Ihrer Anwendung verwendet.

gradle init --type basic

Wenn Sie zur Auswahl einer DSL aufgefordert werden, wählen Sie Kotlin aus.

Installieren der Clientbibliothek

Navigieren Sie zur Datei build.gradle.kts, und öffnen Sie sie in Ihrer bevorzugten IDE bzw. Ihrem bevorzugten Text-Editor. Kopieren Sie anschließend die folgende Buildkonfiguration. Diese Konfiguration definiert das Projekt als Java-Anwendung, deren Einstiegspunkt die Klasse CustomVisionQuickstart ist. Die Custom Vision-Bibliotheken werden davon importiert.

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 zu dem neuen Ordner, und erstellen Sie eine Datei namens CustomVisionQuickstart.java. Öffnen Sie sie in Ihrem bevorzugten Editor bzw. 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;

Tipp

Möchten Sie sich sofort die gesamte Codedatei für die Schnellstartanleitung ansehen? Die Datei steht auf GitHub zur Verfügung. Dort finden Sie die Codebeispiele aus dieser Schnellstartanleitung.

Erstellen Sie in der CustomVisionQuickstart-Klasse der Anwendung Variablen, die die Schlüssel und den Endpunkt 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 main-Methode der Anwendung Aufrufe für die Methoden hinzu, die in dieser Schnellstartanleitung verwendet werden. Diese werden später definiert.

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 verarbeiten einige der Hauptfunktionen der Custom Vision-Java-Clientbibliothek:

Name	Beschreibung
CustomVisionTrainingClient	Diese Klasse wird für die Erstellung, das Training und die Veröffentlichung Ihrer Modelle verwendet.
CustomVisionPredictionClient	Diese Klasse wird zum Abfragen Ihrer Modelle für Vorhersagen zur Objekterkennung verwendet.
ImagePrediction	Mit dieser Klasse wird eine einzelne Objektvorhersage für ein einzelnes Bild definiert. Sie enthält Eigenschaften für die Objekt-ID und den Namen, die Position des Begrenzungsrahmens für das Objekt und eine Zuverlässigkeitsbewertung.

Codebeispiele

Diese Codeausschnitte veranschaulichen, wie die folgenden Aufgaben mit der Custom Vision-Clientbibliothek für Java durchgeführt werden:

Authentifizieren des Clients
Erstellen eines neuen Custom Vision-Projekts
Hinzufügen von Tags zum Projekt
Hochladen und Kennzeichnen 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 Custom Vision-Projekts

Die nächste Methode erstellt ein Objekterkennungsprojekt. Das erstellte Projekt wird auf der Custom Vision-Website angezeigt, die Sie zuvor besucht haben. Informationen zur Angabe weiterer Optionen bei der Erstellung Ihres Projekts finden Sie im Artikel zu Überladungen der Methode CreateProject. Informationen zur Projekterstellung finden Sie unter Schnellstart: Informationen zum Erstellen einer Objekterkennung mit Custom Vision.

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 Kategorien zu Ihrem Projekt

Mit dieser Methode werden die Tags definiert, die Sie zum Trainieren des Modells verwenden.

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 Kennzeichnen von Bildern

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

Hinweis

Benötigen Sie für Ihr Training ein größeres Spektrum von Bildern? Mit Trove, einem Microsoft Garage-Projekt, können Sie Bilder zu Trainingszwecken sammeln und erwerben. Die gesammelten Bilder können Sie dann herunterladen und wie gewohnt in Ihr Custom Vision-Projekt importieren. Weitere Informationen finden Sie unter Trove.

Wenn Sie Bilder in Objekterkennungsprojekten mit Tags versehen, müssen Sie mithilfe normalisierter Koordinaten die Region des jeweiligen markierten Objekts angeben. Im folgenden Code wird jedem der Beispielbilder die entsprechende markierte Region zugeordnet.

Hinweis

Falls Sie über kein Hilfsprogramm zum Klicken und Ziehen verfügen, um die Koordinaten von Regionen zu markieren, können Sie die Webbenutzeroberfläche unter Customvision.ai verwenden. In diesem Beispiel sind die Koordinaten bereits vorhanden.

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 die Bilder dem Projekt hinzu. Sie müssen die Argumente der Aufrufe vom Typ GetImage so ändern, dass sie auf die Speicherorte der heruntergeladenen Ordner fork und scissors 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 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;
}

Trainieren des Projekts

Mit dieser Methode wird die erste Trainingsiteration im Projekt erstellt. 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

Mit dieser Methode wird die aktuelle Iteration des Modells zum Abfragen verfügbar gemacht. Sie können den Modellnamen als Referenz zum Senden von Vorhersageanforderungen verwenden. Hierbei ist es erforderlich, dass Sie Ihren eigenen Wert für predictionResourceId eingeben. 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 Testbild, 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 folgendem Befehl erstellen:

gradle build

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

gradle run

Bereinigen von Ressourcen

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

Wenn Sie Ihr eigenes Objekterkennungsprojekt implementieren oder stattdessen ein Projekt zur Bildklassifizierung ausprobieren möchten, können Sie das Projekt zur Erkennung von Gabeln/Scheren aus diesem Beispiel löschen. Im Rahmen eines kostenlosen Abonnements können zwei Custom Vision-Projekte erstellt werden.

Navigieren Sie auf der Custom Vision-Website zu Projects (Projekte), und wählen Sie unter „My New Project“ (Mein neues Projekt) das Papierkorbsymbol.

Screenshot of a panel labeled My New Project with a trash can icon.

Nächste Schritte

Sie haben jetzt die einzelnen Schritte des Objekterkennungsprozesses im Code ausgeführt. In diesem Beispiel wird eine einzelne Trainingsiteration ausgeführt. Zur Verbesserung der Genauigkeit muss ein Modell jedoch häufig mehrmals trainiert und getestet werden. In der folgenden Anleitung wird die Bildklassifizierung behandelt. Die Prinzipien sind jedoch mit denen der Objekterkennung vergleichbar.

Testen und erneutes Trainieren eines Modells mit Custom Vision Service

Was ist Custom Vision?
Den Quellcode für dieses Beispiel finden Sie auf GitHub.

Dieser Leitfaden enthält Anweisungen und Beispielcode für die ersten Schritte mit der Custom Vision-Clientbibliothek für Node.js und unterstützt Sie beim Erstellen eines Objekterkennungsmodells. Sie erstellen ein Projekt, fügen Tags hinzu, trainieren das Projekt und verwenden die Vorhersageendpunkt-URL des Projekts, um es programmgesteuert zu testen. Verwenden Sie dieses Beispiel als Vorlage für die Erstellung Ihrer eigenen Bilderkennungsanwendung.

Hinweis

Falls Sie ein Objekterkennungsmodell erstellen und trainieren möchten, ohne Code zu schreiben, sehen Sie sich stattdessen die browserbasierte Anleitung an.

Verwenden Sie die Custom Vision-Clientbibliothek für .NET für folgende Aufgaben:

Erstellen eines neuen Custom Vision-Projekts
Hinzufügen von Tags zum Projekt
Hochladen und Kennzeichnen von Bildern
Trainieren des Projekts
Veröffentlichen der aktuellen Iteration
Testen des Vorhersageendpunkts

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

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Die aktuelle Version von Node.js
Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Custom Vision-Ressource erstellen, um eine Trainings- und Vorhersageressource zu erstellen.
- Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Erstellen von Umgebungsvariablen

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

Öffnen Sie das Azure-Portal. Wenn die im Abschnitt Voraussetzungen erstellten Custom Vision-Ressourcen erfolgreich bereitgestellt wurden, wählen Sie unter Nächste Schritte die Schaltfläche Zu Ressource wechseln aus. Ihre Schlüssel und Endpunkte finden Sie auf den entsprechenden Seiten der Ressourcen unter Ressourcenverwaltung. Sie müssen die Schlüssel für Ihre Trainings- und Vorhersageressourcen sowie die API-Endpunkte erhalten.

Sie finden die Vorhersageressourcen-ID im Azure-Portal auf der Registerkarte Eigenschaften der Vorhersageressource, wo sie als Ressourcen-ID angegeben ist.

Tipp

Sie verwenden https://www.customvision.ai/ auch, um diese Werte abzurufen. Wählen Sie nach der Anmeldung oben rechts das Symbol Einstellungen aus. Auf den Seiten Einstellung können Sie alle Schlüssel, Ressourcen-IDs und Endpunkte anzeigen.

Achtung

Fügen Sie den Schlüssel nicht direkt in Ihren Code ein, und machen Sie ihn nicht öffentlich zugänglich. Im Artikel zur Azure KI Services-Sicherheit finden Sie weitere Authentifizierungsoptionen wie zum Beispiel Azure Key Vault.

Zum Festlegen der Umgebungsvariable für Ihren Ressourcenschlüssel öffnen Sie ein Konsolenfenster und befolgen 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.
Zum Festlegen der Umgebungsvariablen VISION_TRAINING_ENDPOINT ersetzen Sie your-training-endpoint durch den Endpunkt für Ihre Trainingsressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_KEY ersetzen Sie your-prediction-key durch einen der Schlüssel für Ihre Vorhersageressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_ENDPOINT ersetzen Sie your-prediction-endpoint durch den Endpunkt für Ihre Vorhersageressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_RESOURCE_ID ersetzen Sie your-resource-id durch die Ressourcen-ID für Ihre Vorhersageressource.

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

Nachdem Sie die Umgebungsvariable hinzugefügt haben, müssen Sie unter Umständen alle ausgeführten Programme neu starten, von denen die Umgebungsvariablen gelesen werden, einschließlich des Konsolenfensters.

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

Führen Sie nach dem Hinzufügen der Umgebungsvariablen im Konsolenfenster source ~/.bashrc aus, damit die Änderungen wirksam werden.

Einrichten

Erstellen einer neuen Node.js-Anwendung

Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es auf.

mkdir myapp && cd myapp

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

npm init

Installieren der Clientbibliothek

Zum Schreiben einer Bildanalyseanwendung mit Custom Vision für Node.js benötigen Sie die Custom Vision NPM-Pakete. Führen Sie den folgenden Befehl in PowerShell aus, um sie zu installieren:

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

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

Erstellen Sie eine Datei namens 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");

Tipp

Möchten Sie sich sofort die gesamte Codedatei für die Schnellstartanleitung ansehen? Die Datei steht auf GitHub zur Verfügung. Dort finden Sie die Codebeispiele aus dieser Schnellstartanleitung.

Erstellen Sie Variablen für 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 Ihren Projektnamen und einen Timeoutparameter für asynchrone Aufrufe hinzu.

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

Objektmodell

name	BESCHREIBUNG
TrainingAPIClient	Diese Klasse wird für die Erstellung, das Training und die Veröffentlichung Ihrer Modelle verwendet.
PredictionAPIClient	Diese Klasse wird zum Abfragen Ihrer Modelle für Vorhersagen zur Objekterkennung verwendet.
Vorhersage	Mit dieser Schnittstelle wird eine einzelne Vorhersage für ein einzelnes Bild definiert. Sie enthält Eigenschaften für die Objekt-ID und den Namen sowie eine Zuverlässigkeitsbewertung.

Codebeispiele

Diese Codeausschnitte veranschaulichen, wie die folgenden Aufgaben mit der Custom Vision-Clientbibliothek für JavaScript durchgeführt werden:

Authentifizieren des Clients
Erstellen eines neuen Custom Vision-Projekts
Hinzufügen von Tags zum Projekt
Hochladen und Kennzeichnen 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 ein 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);

Hinzufügen einer Hilfsfunktion

Fügen Sie die folgende Funktion hinzu, um mehrere asynchrone Aufrufe ausführen zu können. Sie verwenden sie später.

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 Custom 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 Service-Projekt 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

Fügen Sie Ihrer Funktion den folgenden Code hinzu, um Klassifizierungstags für Ihr Projekt zu erstellen:

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

Hochladen und Kennzeichnen von Bildern

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

Um dem Projekt die Beispielbilder hinzuzufügen, fügen Sie nach der Erstellung der Kategorien den folgenden Code ein. Dieser Code lädt das Bild mit dem entsprechenden Tag hoch. Wenn Sie Bilder in Objekterkennungsprojekten mit Tags versehen, müssen Sie mithilfe normalisierter Koordinaten die Region des jeweiligen markierten Objekts 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 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);

Wichtig

Sie müssen den Pfad zu den Bildern (sampleDataRoot) basierend auf dem Ort ändern, von dem Sie das Repository mit den Azure KI Services-Beispielen für das Python-SDK heruntergeladen haben.

Hinweis

Falls Sie über kein Hilfsprogramm zum Klicken und Ziehen verfügen, um die Koordinaten von Regionen zu markieren, können Sie die Webbenutzeroberfläche unter Customvision.ai verwenden. In diesem Beispiel sind die Koordinaten bereits vorhanden.

Trainieren des Projekts

Mit diesem Code wird die erste Iteration des Vorhersagemodells erstellt.

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 veröffentlichten Iteration 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 Ihrer 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 anschließend die Custom Vision-Funktion, und rufen Sie sie auf:

})()

Ausführen der Anwendung

Führen Sie die Anwendung mit dem Befehl node für die Schnellstartdatei aus.

node index.js

Die Ausgabe der Anwendung sollte in der Konsole angezeigt werden. Daraufhin können Sie sich vergewissern, dass das Testbild (unter <sampleDataRoot>/Test/) ordnungsgemäß gekennzeichnet und die Erkennungsregion korrekt ist. Sie können auch zur Custom Vision-Website zurückgehen und den aktuellen Status Ihres neu erstellten Projekts ansehen.

Bereinigen von Ressourcen

Wenn Sie Ihr eigenes Objekterkennungsprojekt implementieren oder stattdessen ein Projekt zur Bildklassifizierung ausprobieren möchten, können Sie das Projekt zur Erkennung von Gabeln/Scheren aus diesem Beispiel löschen. Im Rahmen eines kostenlosen Abonnements können zwei Custom Vision-Projekte erstellt werden.

Navigieren Sie auf der Custom Vision-Website zu Projects (Projekte), und wählen Sie unter „My New Project“ (Mein neues Projekt) das Papierkorbsymbol.

Screenshot of a panel labeled My New Project with a trash can icon.

Nächste Schritte

Sie haben jetzt die einzelnen Schritte des Objekterkennungsprozesses im Code ausgeführt. In diesem Beispiel wird eine einzelne Trainingsiteration ausgeführt. Zur Verbesserung der Genauigkeit muss ein Modell jedoch häufig mehrmals trainiert und getestet werden. In der folgenden Anleitung wird die Bildklassifizierung behandelt. Die Prinzipien sind jedoch mit denen der Objekterkennung vergleichbar.

Testen und erneutes Trainieren eines Modells mit Custom Vision Service

Was ist Custom Vision?
Den Quellcode für dieses Beispiel finden Sie auf GitHub.
SDK-Referenzdokumentation (Training)
SDK-Referenzdokumentation (Vorhersage)

Hier erhalten Sie Informationen zu den ersten Schritten mit der Custom Vision-Clientbibliothek für Python. Führen Sie diese 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 Vorhersageendpunkt-URL des Projekts, um es programmgesteuert zu testen. Verwenden Sie dieses Beispiel als Vorlage für die Erstellung Ihrer eigenen Bilderkennungsanwendung.

Hinweis

Falls Sie ein Objekterkennungsmodell erstellen und trainieren möchten, ohne Code zu schreiben, sehen Sie sich stattdessen die browserbasierte Anleitung an.

Verwenden Sie die Custom Vision-Clientbibliothek für Python für folgende Aufgaben:

Erstellen eines neuen Custom Vision-Projekts
Hinzufügen von Tags zum Projekt
Hochladen und Kennzeichnen von Bildern
Trainieren des Projekts
Veröffentlichen der aktuellen Iteration
Testen des Vorhersageendpunkts

Referenzdokumentation | Quellcode der Bibliothek | Paket (PyPI) | Beispiele

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Python 3.x
- Ihre Python-Installation sollte pip enthalten. Sie können überprüfen, ob pip installiert ist, indem Sie pip --version in der Befehlszeile ausführen. Installieren Sie die aktuelle Python-Version, um pip zu erhalten.
Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Custom Vision-Ressource erstellen, um eine Trainings- und Vorhersageressource zu erstellen.
- Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Erstellen von Umgebungsvariablen

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

Öffnen Sie das Azure-Portal. Wenn die im Abschnitt Voraussetzungen erstellten Custom Vision-Ressourcen erfolgreich bereitgestellt wurden, wählen Sie unter Nächste Schritte die Schaltfläche Zu Ressource wechseln aus. Ihre Schlüssel und Endpunkte finden Sie auf den entsprechenden Seiten der Ressourcen unter Ressourcenverwaltung. Sie müssen die Schlüssel für Ihre Trainings- und Vorhersageressourcen sowie die API-Endpunkte erhalten.

Sie finden die Vorhersageressourcen-ID im Azure-Portal auf der Registerkarte Eigenschaften der Vorhersageressource, wo sie als Ressourcen-ID angegeben ist.

Tipp

Sie verwenden https://www.customvision.ai/ auch, um diese Werte abzurufen. Wählen Sie nach der Anmeldung oben rechts das Symbol Einstellungen aus. Auf den Seiten Einstellung können Sie alle Schlüssel, Ressourcen-IDs und Endpunkte anzeigen.

Achtung

Fügen Sie den Schlüssel nicht direkt in Ihren Code ein, und machen Sie ihn nicht öffentlich zugänglich. Im Artikel zur Azure KI Services-Sicherheit finden Sie weitere Authentifizierungsoptionen wie zum Beispiel Azure Key Vault.

Zum Festlegen der Umgebungsvariable für Ihren Ressourcenschlüssel öffnen Sie ein Konsolenfenster und befolgen 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.
Zum Festlegen der Umgebungsvariablen VISION_TRAINING_ENDPOINT ersetzen Sie your-training-endpoint durch den Endpunkt für Ihre Trainingsressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_KEY ersetzen Sie your-prediction-key durch einen der Schlüssel für Ihre Vorhersageressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_ENDPOINT ersetzen Sie your-prediction-endpoint durch den Endpunkt für Ihre Vorhersageressource.
Zum Festlegen der Umgebungsvariablen VISION_PREDICTION_RESOURCE_ID ersetzen Sie your-resource-id durch die Ressourcen-ID für Ihre Vorhersageressource.

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

Nachdem Sie die Umgebungsvariable hinzugefügt haben, müssen Sie unter Umständen alle ausgeführten Programme neu starten, von denen die Umgebungsvariablen gelesen werden, einschließlich des Konsolenfensters.

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

Führen Sie nach dem Hinzufügen der Umgebungsvariablen im Konsolenfenster source ~/.bashrc aus, damit die Änderungen wirksam werden.

Einrichten

Installieren der Clientbibliothek

Zum Schreiben einer Bildanalyseanwendung mit Custom Vision für Python benötigen Sie die Clientbibliothek für Custom Vision. Führen Sie nach der Installation von Python den folgenden Befehl in PowerShell oder in 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

Tipp

Möchten Sie sich sofort die gesamte Codedatei für die Schnellstartanleitung ansehen? Die Datei steht auf GitHub zur Verfügung. Dort finden Sie die Codebeispiele aus dieser Schnellstartanleitung.

Erstellen Sie Variablen für Azure-Endpunkt und -Schlüssel Ihrer Ressource.

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

Objektmodell

name	Beschreibung
CustomVisionTrainingClient	Diese Klasse wird für die Erstellung, das Training und die Veröffentlichung Ihrer Modelle verwendet.
CustomVisionPredictionClient	Diese Klasse wird zum Abfragen Ihrer Modelle für Vorhersagen zur Objekterkennung verwendet.
ImagePrediction	Mit dieser Klasse wird eine einzelne Objektvorhersage für ein einzelnes Bild definiert. Sie enthält Eigenschaften für die Objekt-ID und den Namen, die Position des Begrenzungsrahmens für das Objekt und eine Zuverlässigkeitsbewertung.

Codebeispiele

Diese Codeausschnitte veranschaulichen, wie die folgenden Aufgaben mit der Custom Vision-Clientbibliothek für Python durchgeführt werden:

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

Authentifizieren des Clients

Instanziieren Sie Trainings- und Vorhersageclients mit dem Endpunkt und den Schlüsseln. Erstellen Sie ApiKeyServiceClientCredentials-Objekte mit Ihren Schlüsseln, und verwenden Sie sie mit Ihrem Endpunkt, um ein CustomVisionTrainingClient- und ein 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(ENDPOINT, prediction_credentials)

Erstellen eines neuen Custom Vision-Projekts

Fügen Sie Ihrem Skript den folgenden Code hinzu, um ein neues Custom Vision Service-Projekt zu erstellen.

Informationen zur Angabe weiterer Optionen bei der Erstellung Ihres Projekts finden Sie im Artikel zur Methode create_project. Informationen zur Projekterstellung finden Sie unter Schnellstart: Informationen zum Erstellen einer Objekterkennung mit Custom Vision.

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 zum Erstellen von Objekttags in Ihrem Projekt den folgenden Code hinzu:

# 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 Kennzeichnen von Bildern

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

Wenn Sie Bilder in Objekterkennungsprojekten mit Tags versehen, müssen Sie mithilfe normalisierter Koordinaten die Region des jeweiligen markierten Objekts angeben. Im folgenden Code wird jedem der Beispielbilder die entsprechende markierte Region zugeordnet. 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 ]
}

Hinweis

Falls Sie über kein Hilfsprogramm zum Klicken und Ziehen verfügen, um die Koordinaten von Regionen zu markieren, können Sie die Webbenutzeroberfläche unter Customvision.ai verwenden. In diesem Beispiel sind die Koordinaten bereits vorhanden.

Laden Sie dann auf der Grundlage dieser Zuordnungen die einzelnen Bilder zusammen mit den jeweiligen Regionskoordinaten hoch. (Sie können bis zu 64 Bilder in einem 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)

Hinweis

Sie müssen den Pfad zu den Bildern gemäß dem Ort ändern, von dem Sie das Repository mit den Azure KI Services-Beispielen für das Python-SDK heruntergeladen haben.

Trainieren des Projekts

Mit diesem Code wird die erste Iteration des Vorhersagemodells erstellt.

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)

Tipp

Trainieren mit ausgewählten Tags

Optional können Sie das Training nur mit einer Teilmenge der angewendeten Tags durchführen. Das ist empfehlenswert, wenn bestimmte Tags noch nicht ausreichend angewendet wurden, andere jedoch schon. Legen Sie im Aufruf train_project den optionalen Parameter selected_tags auf die Liste der zu verwendenden Tag-IDs fest. Das Modell wird darauf trainiert, nur die Tags in dieser Liste zu erkennen.

Veröffentlichen der aktuellen Iteration

Eine Iteration ist erst im Vorhersageendpunkt verfügbar, wenn sie veröffentlicht wurde. Mit dem folgenden Code wird die aktuelle Iteration des Modells zum Abfragen verfügbar gemacht:

# 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 angezeigt werden. Daraufhin können Sie sich vergewissern, dass das Testbild (unter <base_image_location>/images/Test) ordnungsgemäß gekennzeichnet und die Erkennungsregion korrekt ist. Sie können auch zur Custom Vision-Website zurückgehen und den aktuellen Status Ihres neu erstellten Projekts ansehen.

Bereinigen von Ressourcen

Wenn Sie Ihr eigenes Objekterkennungsprojekt implementieren oder stattdessen ein Projekt zur Bildklassifizierung ausprobieren möchten, können Sie das Projekt zur Erkennung von Gabeln/Scheren aus diesem Beispiel löschen. Im Rahmen eines kostenlosen Abonnements können zwei Custom Vision-Projekte erstellt werden.

Navigieren Sie auf der Custom Vision-Website zu Projects (Projekte), und wählen Sie unter „My New Project“ (Mein neues Projekt) das Papierkorbsymbol.

Screenshot of a panel labeled My New Project with a trash can icon.

Nächste Schritte

Sie haben jetzt die einzelnen Schritte des Objekterkennungsprozesses im Code ausgeführt. In diesem Beispiel wird eine einzelne Trainingsiteration ausgeführt. Zur Verbesserung der Genauigkeit muss ein Modell jedoch häufig mehrmals trainiert und getestet werden. In der folgenden Anleitung wird die Bildklassifizierung behandelt. Die Prinzipien sind jedoch mit denen der Objekterkennung vergleichbar.

Testen und erneutes Trainieren eines Modells mit Custom Vision Service

Was ist Custom Vision?
Den Quellcode für dieses Beispiel finden Sie auf GitHub.
SDK-Referenzdokumentation

Schnellstart: Erstellen eines Objekterkennungsprojekts mit der Custom Vision-Clientbibliothek

Voraussetzungen

Erstellen von Umgebungsvariablen

Einrichten

Erstellen einer neuen C#-Anwendung

Installieren der Clientbibliothek

Authentifizieren des Clients

Erstellen eines neuen Custom Vision-Projekts

Hinzufügen von Tags zum Projekt

Hochladen und Kennzeichnen von Bildern

Trainieren des Projekts

Veröffentlichen der aktuellen Iteration

Testen des Vorhersageendpunkts

Ausführen der Anwendung

Bereinigen von Ressourcen

Nächste Schritte

Voraussetzungen

Erstellen von Umgebungsvariablen

Einrichten

Installieren der Custom Vision-Clientbibliothek

Abrufen der Beispielbilder

Erstellen des Custom Vision-Projekts

Erstellen von Tags im Projekt

Hochladen und Kennzeichnen von Bildern

Trainieren und Veröffentlichen des Projekts

Verwenden des Vorhersageendpunkts

Ausführen der Anwendung

Bereinigen von Ressourcen

Nächste Schritte

Voraussetzungen

Erstellen von Umgebungsvariablen

Einrichten

Erstellen eines neuen Gradle-Projekts

Installieren der Clientbibliothek

Erstellen einer Java-Datei

Objektmodell

Codebeispiele

Authentifizieren des Clients

Erstellen eines neuen Custom Vision-Projekts

Hinzufügen von Kategorien zu Ihrem Projekt

Hochladen und Kennzeichnen von Bildern

Trainieren des Projekts

Veröffentlichen der aktuellen Iteration

Testen des Vorhersageendpunkts

Ausführen der Anwendung

Bereinigen von Ressourcen

Nächste Schritte

Voraussetzungen

Erstellen von Umgebungsvariablen

Einrichten

Erstellen einer neuen Node.js-Anwendung

Installieren der Clientbibliothek

Objektmodell

Codebeispiele

Authentifizieren des Clients

Hinzufügen einer Hilfsfunktion

Erstellen eines neuen Custom Vision-Projekts

Hinzufügen von Tags zum Projekt

Hochladen und Kennzeichnen von Bildern

Trainieren des Projekts

Veröffentlichen der aktuellen Iteration

Testen des Vorhersageendpunkts

Ausführen der Anwendung

Bereinigen von Ressourcen

Nächste Schritte

Voraussetzungen

Erstellen von Umgebungsvariablen

Einrichten

Installieren der Clientbibliothek

Erstellen einer neuen Python-Anwendung

Objektmodell

Codebeispiele

Authentifizieren des Clients

Erstellen eines neuen Custom Vision-Projekts

Hinzufügen von Tags zum Projekt

Hochladen und Kennzeichnen von Bildern

Trainieren des Projekts

Veröffentlichen der aktuellen Iteration

Testen des Vorhersageendpunkts

Ausführen der Anwendung