Guida introduttiva: Creare un progetto di classificazione delle immagini con l'SDK di Visione personalizzata o l'API REST

Inizia con la libreria client Custom Vision per .NET. Seguire questa procedura per installare il pacchetto e provare il codice di esempio per la compilazione di un modello di classificazione delle immagini. È possibile creare un progetto, aggiungere tag, eseguire il training del progetto e usare l'URL dell'endpoint di previsione del progetto per testarlo a livello di codice. Usare questo esempio come modello per creare un'app di riconoscimento delle immagini personalizzata.

documentazione di Reference | Codice sorgente della libreria per training e prediction | Pacchetto (NuGet) per training e prediction | Samples

Prerequisiti

• Sottoscrizione Azure. È possibile crearne uno gratuitamente.
• La versione attuale di IDE di Visual Studio o di .NET Core.
• Una volta che hai la tua sottoscrizione Azure, crea una risorsa Custom Vision nel portale di Azure per generare una risorsa di addestramento e una risorsa di previsione.
  • È possibile usare il piano tariffario gratuito (F0) per provare il servizio e eseguire l'aggiornamento in un secondo momento a un livello a pagamento per la produzione.

Creare variabili di ambiente

In questo esempio si scriveranno le credenziali nelle variabili di ambiente nel computer locale che esegue l'applicazione.

Passare al portale di Azure. Se le risorse di Visione personalizzata create nella sezione Prerequisiti sono state distribuite correttamente, selezionare il pulsante Vai alla risorsa in Passaggi successivi. È possibile trovare le chiavi e gli endpoint nelle pagine Chiavi ed endpoint delle risorse, in Gestione risorse. Sarà necessario ottenere le chiavi sia per la risorsa di training che per la risorsa di stima, insieme agli endpoint API.

È possibile trovare l'ID risorsa di stima nella scheda Properties della risorsa di stima nel portale di Azure, elencato come ID Di risorse.

Per impostare le variabili di ambiente, aprire una finestra della console e seguire le istruzioni per il sistema operativo e l'ambiente di sviluppo.

• Per impostare la VISION_TRAINING KEY variabile di ambiente, sostituire <your-training-key> con una delle chiavi per la risorsa di training.
• Per impostare la VISION_TRAINING_ENDPOINT variabile di ambiente, sostituire <your-training-endpoint> con l'endpoint per la risorsa di allenamento.
• Per impostare la VISION_PREDICTION_KEY variabile di ambiente, sostituire <your-prediction-key> con una delle chiavi per la risorsa di stima.
• Per impostare la VISION_PREDICTION_ENDPOINT variabile di ambiente, sostituire <your-prediction-endpoint> con l'endpoint per la risorsa di stima.
• Per impostare la VISION_PREDICTION_RESOURCE_ID variabile di ambiente, sostituire <your-resource-id> con l'ID risorsa per la risorsa di previsione.

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Configurazione

dotnet new console -n custom-vision-quickstart

dotnet build

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

dotnet add package Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training --version 2.0.0
dotnet add package Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction --version 2.0.0

Dalla directory del progetto aprire il file program.cs e aggiungere le direttive seguenti using :

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;

Nel metodo dell'applicazione, creare variabili che recuperano dalle variabili di ambiente le chiavi e gli endpoint della tua risorsa. Si dichiareranno anche alcuni oggetti di base da usare in un secondo momento.

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

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

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

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

Nel metodo dell'applicazione main aggiungere invocazioni dei metodi usati in questa guida introduttiva. Questi elementi verranno implementati in un secondo momento.

CustomVisionTrainingClient trainingApi = AuthenticateTraining(trainingEndpoint, trainingKey);
CustomVisionPredictionClient predictionApi = AuthenticatePrediction(predictionEndpoint, predictionKey);

Project project = CreateProject(trainingApi);
AddTags(trainingApi, project);
UploadImages(trainingApi, project);
TrainProject(trainingApi, project);
PublishIteration(trainingApi, project);
TestIteration(predictionApi, project);
DeleteProject(trainingApi, project);

Autenticare il client

In un nuovo metodo, instanziare i client di training e predizione utilizzando l'endpoint e le chiavi.

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

Creare un nuovo progetto di Visione personalizzata

Questo bit di codice successivo crea un progetto di classificazione delle immagini. Il progetto creato viene visualizzato nel sito Web di Visione personalizzata. Vedere il metodo CreateProject per specificare altre opzioni quando si crea il progetto (illustrato nella guida Creare un classificatore del portale Web).

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

Aggiungere tag al progetto

Questo metodo definisce i tag su cui si esegue il training del modello.

private static void AddTags(CustomVisionTrainingClient trainingApi, Project project)
{
    // Make two tags in the new project
    hemlockTag = trainingApi.CreateTag(project.Id, "Hemlock");
    japaneseCherryTag = trainingApi.CreateTag(project.Id, "Japanese Cherry");
}

Caricare e contrassegnare immagini

Prima di tutto, scaricare le immagini di esempio per questo progetto. Salvare il contenuto della cartella immagini sample nel dispositivo locale.

Definire quindi un metodo helper per caricare le immagini in questa directory. Potrebbe essere necessario modificare l'argomento GetFiles in modo che punti alla posizione in cui vengono salvate le immagini.

private static void LoadImagesFromDisk()
{
    // this loads the images to be uploaded from disk into memory
    hemlockImages = Directory.GetFiles(Path.Combine("Images", "Hemlock")).ToList();
    japaneseCherryImages = Directory.GetFiles(Path.Combine("Images", "Japanese_Cherry")).ToList();
    testImage = new MemoryStream(File.ReadAllBytes(Path.Combine("Images", "Test", "test_image.jpg")));
}

Definire quindi un metodo per caricare le immagini, applicando tag in base al percorso della cartella. Le immagini sono già ordinate. È possibile caricare e contrassegnare le immagini in modo iterativo o in un batch (fino a 64 per batch). Questo frammento di codice contiene esempi di entrambi.

private static void UploadImages(CustomVisionTrainingClient trainingApi, Project project)
{
    // Add some images to the tags
    Console.WriteLine("\tUploading images");
    LoadImagesFromDisk();

    // Images can be uploaded one at a time
    foreach (var image in hemlockImages)
    {
        using (var stream = new MemoryStream(File.ReadAllBytes(image)))
        {
            trainingApi.CreateImagesFromData(project.Id, stream, new List<Guid>() { hemlockTag.Id });
        }
    }

    // Or uploaded in a single batch 
    var imageFiles = japaneseCherryImages.Select(img => new ImageFileCreateEntry(Path.GetFileName(img), File.ReadAllBytes(img))).ToList();
    trainingApi.CreateImagesFromFiles(project.Id, new ImageFileCreateBatch(imageFiles, new List<Guid>() { japaneseCherryTag.Id }));

}

Formare il progetto

Questo metodo crea la prima iterazione di training nel progetto. Esegue una query sul servizio fino al completamento dell'addestramento.

private static void TrainProject(CustomVisionTrainingClient trainingApi, Project project)
{
    // Now there are images with tags start training the project
    Console.WriteLine("\tTraining");
    iteration = trainingApi.TrainProject(project.Id);

    // The returned iteration will be in progress, and can be queried periodically to see when it has completed
    while (iteration.Status == "Training")
    {
        Console.WriteLine("Waiting 10 seconds for training to complete...");
        Thread.Sleep(10000);

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

Pubblicare l'iterazione corrente

Questo metodo rende disponibile l'iterazione corrente del modello per l'esecuzione di query. È possibile usare il nome del modello come riferimento per inviare richieste di stima. È necessario immettere il proprio valore per predictionResourceId. È possibile trovare l'ID della risorsa di previsione nella scheda Properties nel portale di Azure, elencato come ID Risorsa.

private static void PublishIteration(CustomVisionTrainingClient trainingApi, Project project)
{
    trainingApi.PublishIteration(project.Id, iteration.Id, publishedModelName, predictionResourceId);
    Console.WriteLine("Done!\n");

    // Now there is a trained endpoint, it can be used to make a prediction
}

Testare l'endpoint di predizione

Questa parte dello script carica l'immagine di test, esegue una query sull'endpoint del modello e restituisce i dati di stima nella console.

private static void TestIteration(CustomVisionPredictionClient predictionApi, Project project)
{

    // Make a prediction against the new project
    Console.WriteLine("Making a prediction:");
    var result = predictionApi.ClassifyImage(project.Id, publishedModelName, testImage);

    // Loop over each prediction and write out the results
    foreach (var c in result.Predictions)
    {
        Console.WriteLine($"\t{c.TagName}: {c.Probability:P1}");
    }
}

Eseguire l'applicazione

dotnet run

Durante l'esecuzione dell'applicazione, dovrebbe aprire una finestra della console e scrivere l'output seguente:

Creating new project:
        Uploading images
        Training
Done!

Making a prediction:
        Hemlock: 95.0%
        Japanese Cherry: 0.0%

È quindi possibile verificare che l'immagine di test (disponibile in Images/Test/) sia contrassegnata in modo appropriato. Premere un tasto qualsiasi per uscire dall'applicazione. È anche possibile tornare al sito Web di Visione personalizzata e visualizzare lo stato corrente del progetto appena creato.

Pulire le risorse

Se si vuole implementare un progetto di classificazione delle immagini personalizzato (o provare invece un progetto di rilevamento oggetti), è possibile eliminare il progetto di identificazione albero da questo esempio. Una sottoscrizione gratuita consente due progetti di Visione personalizzata.

Nel sito Web di Custom Vision passare a Projects e selezionare il cestino in My New Project.

Contenuto correlato

A questo punto si è visto come è possibile eseguire ogni passaggio del processo di rilevamento degli oggetti nel codice. Questo esempio esegue una singola iterazione di training, ma spesso è necessario eseguire il training e il test del modello più volte per renderlo più accurato.

• Che cos'è Visione personalizzata?
• Il codice sorgente per questo esempio è disponibile in GitHub
• Documentazione di riferimento dell'SDK

Questa guida fornisce istruzioni e codice di esempio per iniziare a usare la libreria client di Visione personalizzata per Go per creare un modello di classificazione delle immagini. Si creerà un progetto, si aggiungeranno tag, si eseguirà il training del progetto e si userà l'URL dell'endpoint di previsione del progetto per testarlo a livello di codice. Usare questo esempio come modello per creare un'app di riconoscimento delle immagini personalizzata.

Usare la libreria client di Custom Vision per Go.

• Creare un nuovo progetto di Visione personalizzata
• Aggiungere tag al progetto
• Caricare e contrassegnare immagini
• Formare il progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di predizione

Documentazione di riferimento per (training) e (prediction)

Prerequisiti

• Sottoscrizione Azure. È possibile crearne uno gratuitamente.
• Passare alla versione 1.8 o successiva.
• Dopo aver sottoscritto un abbonamento Azure, crea una risorsa Custom Vision nel portale di Azure per una risorsa di addestramento e predizione.
  • È possibile usare il piano tariffario gratuito (F0) per provare il servizio e eseguire l'aggiornamento in un secondo momento a un livello a pagamento per la produzione.

Creare variabili di ambiente

In questo esempio si scriveranno le credenziali nelle variabili di ambiente nel computer locale che esegue l'applicazione.

Passare al portale di Azure. Se le risorse di Visione personalizzata create nella sezione Prerequisiti sono state distribuite correttamente, selezionare il pulsante Vai alla risorsa in Passaggi successivi. È possibile trovare le chiavi e gli endpoint nelle pagine Chiavi ed endpoint delle risorse, in Gestione risorse. Sarà necessario ottenere le chiavi sia per la risorsa di training che per la risorsa di stima, insieme agli endpoint API.

È possibile trovare l'ID risorsa di stima nella scheda Properties della risorsa di stima nel portale di Azure, elencato come ID Di risorse.

Per impostare le variabili di ambiente, aprire una finestra della console e seguire le istruzioni per il sistema operativo e l'ambiente di sviluppo.

• Per impostare la VISION_TRAINING KEY variabile di ambiente, sostituire <your-training-key> con una delle chiavi per la risorsa di training.
• Per impostare la VISION_TRAINING_ENDPOINT variabile di ambiente, sostituire <your-training-endpoint> con l'endpoint per la risorsa di allenamento.
• Per impostare la VISION_PREDICTION_KEY variabile di ambiente, sostituire <your-prediction-key> con una delle chiavi per la risorsa di stima.
• Per impostare la VISION_PREDICTION_ENDPOINT variabile di ambiente, sostituire <your-prediction-endpoint> con l'endpoint per la risorsa di stima.
• Per impostare la VISION_PREDICTION_RESOURCE_ID variabile di ambiente, sostituire <your-resource-id> con l'ID risorsa per la risorsa di previsione.

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Configurazione

Installare la libreria client di Visione personalizzata

Per scrivere un'app di analisi delle immagini con Visione personalizzata per Go, è necessaria la libreria client del servizio Visione personalizzata. Eseguire il comando seguente in PowerShell:

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

In alternativa, se usi dep, all'interno del tuo repository, esegui:

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

Ottenere le immagini di esempio

Questo esempio usa le immagini del repository Foundry Tools Python SDK Samples su GitHub. Clona o scarica questo repository nel tuo ambiente di sviluppo. Ricordare il percorso della cartella per un passaggio successivo.

Creare il progetto Visione personalizzata

Creare un nuovo file denominato sample.go nella directory di progetto preferita e aprirlo nell'editor di codice preferito.

Aggiungere il codice seguente allo script per creare un nuovo progetto di servizio Visione personalizzata.

Vedere il metodo CreateProject per specificare altre opzioni quando si crea il progetto (illustrato nella guida Creare un classificatore del portale Web).

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

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

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

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

    ctx = context.Background()

    trainer := training.New(training_key, endpoint)

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

Creare tag nel progetto

Per creare tag di classificazione al progetto, aggiungere il codice seguente alla fine di sample.go:

// Make two tags in the new project
hemlockTag, _ := trainer.CreateTag(ctx, *project.ID, "Hemlock", "Hemlock tree tag", string(training.Regular))
cherryTag, _ := trainer.CreateTag(ctx, *project.ID, "Japanese Cherry", "Japanese cherry tree tag", string(training.Regular))

Caricare e contrassegnare immagini

Per aggiungere le immagini di esempio al progetto, inserire il codice seguente dopo la creazione del tag. Questo codice carica ogni immagine con il tag corrispondente. È possibile caricare fino a 64 immagini in un singolo batch.

fmt.Println("Adding images...")
japaneseCherryImages, err := ioutil.ReadDir(path.Join(sampleDataDirectory, "Japanese Cherry"))
if err != nil {
    fmt.Println("Error finding Sample images")
}

hemLockImages, err := ioutil.ReadDir(path.Join(sampleDataDirectory, "Hemlock"))
if err != nil {
    fmt.Println("Error finding Sample images")
}

for _, file := range hemLockImages {
    imageFile, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "Hemlock", file.Name()))
    imageData := ioutil.NopCloser(bytes.NewReader(imageFile))

    trainer.CreateImagesFromData(ctx, *project.ID, imageData, []string{ hemlockTag.ID.String() })
}

for _, file := range japaneseCherryImages {
    imageFile, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "Japanese Cherry", file.Name()))
    imageData := ioutil.NopCloser(bytes.NewReader(imageFile))
    trainer.CreateImagesFromData(ctx, *project.ID, imageData, []string{ cherryTag.ID.String() })
}

Effettuare l'addestramento e pubblicare il progetto

Questo codice crea la prima iterazione del modello di stima e quindi pubblica l'iterazione nell'endpoint di stima. Il nome assegnato all'iterazione pubblicata può essere usato per inviare richieste di stima. Un'iterazione non è disponibile nell'endpoint di stima fino a quando non viene pubblicata.

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

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

Usare l'endpoint di previsione

Per inviare un'immagine all'endpoint di stima e recuperare la stima, aggiungere il codice seguente alla fine del file:

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

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

    for _, prediction := range *results.Predictions    {
        fmt.Printf("\t%s: %.2f%%", *prediction.TagName, *prediction.Probability * 100)
        fmt.Println("")
    }
}

Eseguire l'applicazione

Eseguire l'applicazione usando il comando seguente:

go run sample.go

L'output dell'applicazione dovrebbe essere simile al testo seguente:

Creating project...
Adding images...
Training...
Training status: Training
Training status: Training
Training status: Training
Training status: Completed
Done!
        Hemlock: 93.53%
        Japanese Cherry: 0.01%

È quindi possibile verificare che l'immagine di test (disponibile in <base_image_url>/Images/Test/) sia contrassegnata in modo appropriato. È anche possibile tornare al sito Web di Visione personalizzata e visualizzare lo stato corrente del progetto appena creato.

Pulire le risorse

Se si vuole implementare un progetto di classificazione delle immagini personalizzato (o provare invece un progetto di rilevamento oggetti), è possibile eliminare il progetto di identificazione albero da questo esempio. Una sottoscrizione gratuita consente due progetti di Visione personalizzata.

Nel sito Web di Custom Vision passare a Projects e selezionare il cestino in My New Project.

Contenuto correlato

A questo punto si è visto come è possibile eseguire ogni passaggio del processo di rilevamento degli oggetti nel codice. Questo esempio esegue una singola iterazione di training, ma spesso è necessario eseguire il training e il test del modello più volte per renderlo più accurato.

• Che cos'è Visione personalizzata?
• documentazione di riferimento per SDK (formazione)
• documentazione di riferimento SDK (previsione)

Introduzione all'uso della libreria client di Visione personalizzata per Java per creare un modello di classificazione delle immagini. Seguire questa procedura per installare il pacchetto e provare il codice di esempio per le attività di base. Usare questo esempio come modello per creare un'app di riconoscimento delle immagini personalizzata.

Usare la libreria client di Visione personalizzata per Java per:

• Creare un nuovo progetto di Visione personalizzata
• Aggiungere tag al progetto
• Caricare e contrassegnare immagini
• Formare il progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di predizione

Documentazione di riferimento | Codice sorgente della libreria per (addestramento) e (predizione)| Artifact (Maven) per (addestramento) e (predizione) |

Prerequisiti

• Sottoscrizione Azure. È possibile crearne uno gratuitamente.
• Versione corrente del Java Development Kit(JDK).
• Lo strumento di compilazione Gradle o un altro gestore delle dipendenze.
• Dopo aver sottoscritto un abbonamento Azure, crea una risorsa Custom Vision nel portale di Azure per una risorsa di addestramento e predizione.
  • È possibile usare il piano tariffario gratuito (F0) per provare il servizio e eseguire l'aggiornamento in un secondo momento a un livello a pagamento per la produzione.

Creare variabili di ambiente

In questo esempio si scriveranno le credenziali nelle variabili di ambiente nel computer locale che esegue l'applicazione.

Passare al portale di Azure. Se le risorse di Visione personalizzata create nella sezione Prerequisiti sono state distribuite correttamente, selezionare il pulsante Vai alla risorsa in Passaggi successivi. È possibile trovare le chiavi e gli endpoint nelle pagine Chiavi ed endpoint delle risorse, in Gestione risorse. Sarà necessario ottenere le chiavi sia per la risorsa di training che per la risorsa di stima, insieme agli endpoint API.

È possibile trovare l'ID risorsa di stima nella scheda Properties della risorsa di stima nel portale di Azure, elencato come ID Di risorse.

Per impostare le variabili di ambiente, aprire una finestra della console e seguire le istruzioni per il sistema operativo e l'ambiente di sviluppo.

• Per impostare la VISION_TRAINING KEY variabile di ambiente, sostituire <your-training-key> con una delle chiavi per la risorsa di training.
• Per impostare la VISION_TRAINING_ENDPOINT variabile di ambiente, sostituire <your-training-endpoint> con l'endpoint per la risorsa di allenamento.
• Per impostare la VISION_PREDICTION_KEY variabile di ambiente, sostituire <your-prediction-key> con una delle chiavi per la risorsa di stima.
• Per impostare la VISION_PREDICTION_ENDPOINT variabile di ambiente, sostituire <your-prediction-endpoint> con l'endpoint per la risorsa di stima.
• Per impostare la VISION_PREDICTION_RESOURCE_ID variabile di ambiente, sostituire <your-resource-id> con l'ID risorsa per la risorsa di previsione.

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Configurazione

Creare un nuovo progetto Gradle

In una finestra della console ,ad esempio cmd, PowerShell o Bash, creare una nuova directory per l'app e passare a essa.

mkdir myapp && cd myapp

Esegui il comando gradle init dalla directory di lavoro. Questo comando crea file di compilazione essenziali per Gradle, incluso build.gradle.kts, usato in fase di esecuzione per creare e configurare l'applicazione.

gradle init --type basic

Quando viene richiesto di scegliere un linguaggio DSL, selezionare Kotlin.

Installare la libreria client

Individuare build.gradle.kts e aprirlo con l'IDE o l'editor di testo preferito. Copiare quindi nella configurazione di compilazione seguente. Questa configurazione definisce il progetto come applicazione Java il cui punto di ingresso è la classe CustomVisionQuickstart. Importa librerie di Visione Personalizzata.

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

Creare un file Java

Dalla directory di lavoro eseguire il comando seguente per creare una cartella di origine del progetto:

mkdir -p src/main/java

Passare alla nuova cartella e creare un file denominato CustomVisionQuickstart.java. Aprirlo nell'editor o nell'IDE preferito e aggiungere le istruzioni seguenti import :

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;

Nella classe dell'applicazione CustomVisionQuickstart, crea variabili che recuperano le chiavi e l'endpoint delle tue risorse dalle variabili d'ambiente.

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

Nel metodo dell'applicazione main aggiungere invocazioni dei metodi usati in questa guida introduttiva. Questi valori verranno definiti in un secondo momento.

Project project = createProject(trainClient);
addTags(trainClient, project);
uploadImages(trainClient, project);
trainProject(trainClient, project);
publishIteration(trainClient, project);
testProject(predictor, project);

Modello a oggetti

Le classi e le interfacce seguenti gestiscono alcune delle principali funzionalità della libreria client di Visione personalizzata Java.

Esempi di codice

Questi frammenti di codice illustrano come eseguire le attività seguenti con la libreria client di Visione personalizzata per Java:

• Autenticare il client
• Creare un nuovo progetto di Visione personalizzata
• Aggiungere tag al progetto
• Caricare e contrassegnare immagini
• Addestrare il progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di stima

Autenticare il client

Nel tuo metodo main, crea un'istanza dei client di training e predizione utilizzando il tuo endpoint e le chiavi.

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

Creare un progetto di Visione personalizzata

Questo metodo successivo crea un progetto di classificazione delle immagini. Il progetto creato verrà visualizzato nel sito Web di Visione personalizzata visitato in precedenza. Consulta gli overload del metodo CreateProject per specificare altre opzioni quando si crea il progetto (come spiegato nella guida del portale web Build a detector).

public static Project createProject(CustomVisionTrainingClient trainClient) {
    System.out.println("ImageClassification Sample");
    Trainings trainer = trainClient.trainings();

    System.out.println("Creating project...");
    Project project = trainer.createProject().withName("Sample Java Project").execute();

    return project;
}

Aggiungere tag al progetto

Questo metodo definisce i tag su cui verrà eseguito il training del modello.

public static void addTags(CustomVisionTrainingClient trainClient, Project project) {

    Trainings trainer = trainClient.trainings();

    // create hemlock tag
    Tag hemlockTag = trainer.createTag().withProjectId(project.id()).withName("Hemlock").execute();
    // create cherry tag
    Tag cherryTag = trainer.createTag().withProjectId(project.id()).withName("Japanese Cherry").execute();
}

Caricare e contrassegnare immagini

Prima di tutto, scaricare le immagini di esempio per questo progetto. Salvare il contenuto della cartella immagini sample nel dispositivo locale.

public static void uploadImages(CustomVisionTrainingClient trainClient, Project project) {
    Trainings trainer = trainClient.trainings();
    System.out.println("Adding images...");
    for (int i = 1; i <= 10; i++) {
        String fileName = "hemlock_" + i + ".jpg";
        byte[] contents = GetImage("/Hemlock", fileName);
        AddImageToProject(trainer, project, fileName, contents, hemlockTag.id(), null);
    }

    for (int i = 1; i <= 10; i++) {
        String fileName = "japanese_cherry_" + i + ".jpg";
        byte[] contents = GetImage("/Japanese_Cherry", fileName);
        AddImageToProject(trainer, project, fileName, contents, cherryTag.id(), null);
    }
}

Il frammento di codice precedente usa due funzioni helper che recuperano le immagini come flussi di risorse e le caricano nel servizio (è possibile caricare fino a 64 immagini in un singolo batch).

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

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

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

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

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

Formare il progetto

Questo metodo crea la prima iterazione di training nel progetto. Esegue una query sul servizio fino al completamento dell'addestramento.

public static void trainProject(CustomVisionTrainingClient trainClient, Project project) {
    System.out.println("Training...");
    Trainings trainer = trainClient.trainings();

    Iteration iteration = trainer.trainProject(project.id(), new TrainProjectOptionalParameter());

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

Pubblicare l'iterazione corrente

Questo metodo rende disponibile l'iterazione corrente del modello per l'esecuzione di query. È possibile usare il nome del modello come riferimento per inviare richieste di stima. È necessario immettere il proprio valore per predictionResourceId. È possibile trovare l'ID della risorsa di previsione nella scheda Properties nel portale di Azure, elencato come ID Risorsa.

public static String publishIteration(CustomVisionTrainingClient trainClient, Project project) {
    Trainings trainer = trainClient.trainings();
    // The iteration is now trained. Publish it to the prediction endpoint.
    String publishedModelName = "myModel";
    trainer.publishIteration(project.id(), iteration.id(), publishedModelName, predictionResourceId);
}

Testare l'endpoint di predizione

Questo metodo carica l'immagine di test, esegue una query sull'endpoint del modello e restituisce i dati di stima nella console.

// load test image
public static void testProject(CustomVisionPredictionClient predictor, Project project) {

    byte[] testImage = GetImage("/Test", "test_image.jpg");

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

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

Eseguire l'applicazione

È possibile compilare l'app con:

gradle build

Eseguire l'applicazione con il gradle run comando :

gradle run

Pulire le risorse

Se si vuole pulire e rimuovere una sottoscrizione Servizi di Azure AI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse elimina anche tutte le altre risorse associate.

• Portale Azure
• interfaccia della riga di comando di Azure

Se si vuole implementare un progetto di classificazione delle immagini personalizzato (o provare invece un progetto di rilevamento oggetti), è possibile eliminare il progetto di identificazione albero da questo esempio. Una sottoscrizione gratuita consente due progetti di Visione personalizzata.

Nel sito Web di Custom Vision passare a Projects e selezionare il cestino in My New Project.

Contenuto correlato

A questo punto si è visto come è possibile eseguire ogni passaggio del processo di rilevamento degli oggetti nel codice. Questo esempio esegue una singola iterazione di training, ma spesso è necessario eseguire il training e il test del modello più volte per renderlo più accurato.

• Che cos'è Visione personalizzata?
• Il codice sorgente per questo esempio è disponibile in GitHub

Questa guida fornisce istruzioni e codice di esempio per iniziare a usare la libreria client di Visione personalizzata per Node.js per creare un modello di classificazione delle immagini. È possibile creare un progetto, aggiungere tag, eseguire il training del progetto e usare l'URL dell'endpoint di previsione del progetto per testarlo a livello di codice. Usare questo esempio come modello per creare un'app di riconoscimento delle immagini personalizzata.

Usare la libreria client di Custom Vision per Node.js per:

• Creare un nuovo progetto di Visione personalizzata
• Aggiungere tag al progetto
• Caricare e contrassegnare immagini
• Formare il progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di predizione

Documentazione di riferimento per (training) e (previsione) | Pacchetto (npm) per (training) e (previsione) | Esempi

Prerequisiti

• Sottoscrizione Azure. È possibile crearne uno gratuitamente.
• Versione corrente di Node.js.
• Dopo aver sottoscritto un abbonamento Azure, crea una risorsa Custom Vision nel portale di Azure per una risorsa di addestramento e predizione.
  • È possibile usare il piano tariffario gratuito (F0) per provare il servizio e eseguire l'aggiornamento in un secondo momento a un livello a pagamento per la produzione.

Creare variabili di ambiente

In questo esempio si scriveranno le credenziali nelle variabili di ambiente nel computer locale che esegue l'applicazione.

Passare al portale di Azure. Se le risorse di Visione personalizzata create nella sezione Prerequisiti sono state distribuite correttamente, selezionare il pulsante Vai alla risorsa in Passaggi successivi. È possibile trovare le chiavi e gli endpoint nelle pagine Chiavi ed endpoint delle risorse, in Gestione risorse. Sarà necessario ottenere le chiavi sia per la risorsa di training che per la risorsa di stima, insieme agli endpoint API.

È possibile trovare l'ID risorsa di stima nella scheda Properties della risorsa di stima nel portale di Azure, elencato come ID Di risorse.

Per impostare le variabili di ambiente, aprire una finestra della console e seguire le istruzioni per il sistema operativo e l'ambiente di sviluppo.

• Per impostare la VISION_TRAINING KEY variabile di ambiente, sostituire <your-training-key> con una delle chiavi per la risorsa di training.
• Per impostare la VISION_TRAINING_ENDPOINT variabile di ambiente, sostituire <your-training-endpoint> con l'endpoint per la risorsa di allenamento.
• Per impostare la VISION_PREDICTION_KEY variabile di ambiente, sostituire <your-prediction-key> con una delle chiavi per la risorsa di stima.
• Per impostare la VISION_PREDICTION_ENDPOINT variabile di ambiente, sostituire <your-prediction-endpoint> con l'endpoint per la risorsa di stima.
• Per impostare la VISION_PREDICTION_RESOURCE_ID variabile di ambiente, sostituire <your-resource-id> con l'ID risorsa per la risorsa di previsione.

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Configurazione

Creare una nuova applicazione Node.js

In una finestra della console ,ad esempio cmd, PowerShell o Bash, creare una nuova directory per l'app e passare a essa.

mkdir myapp && cd myapp

Eseguire il npm init comando per creare un'applicazione node con un package.json file. Premere INVIO più volte per completare il processo.

npm init

Installare la libreria client

Per scrivere un'app di analisi delle immagini con Visione personalizzata per Node.js, sono necessari i pacchetti npm di Visione personalizzata. Per installarli, eseguire il comando seguente in PowerShell:

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

Il file dell'app package.json viene aggiornato con le dipendenze.

Creare un file denominato index.js e importare le librerie seguenti:

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

Creare variabili per l'endpoint e le chiavi Azure della risorsa.

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

Aggiungere anche campi per il nome del progetto e un parametro di timeout per le chiamate asincrone.

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

Modello a oggetti

Esempi di codice

Questi frammenti di codice illustrano come eseguire le attività seguenti con la libreria client di Visione personalizzata per JavaScript:

• Autenticare il client
• Creare un nuovo progetto di Visione personalizzata
• Aggiungere tag al progetto
• Caricare e contrassegnare immagini
• Addestrare il progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di stima

Autenticare il client

Instanziare oggetti client utilizzando l'endpoint e la chiave API. Creare un oggetto ApiKeyCredentials con la chiave e usarlo con l'endpoint per creare un oggetto TrainingAPIClient e PredictionAPIClient .

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

Creare un nuovo progetto di Visione personalizzata

Avvia una nuova funzione per contenere tutte le chiamate all'API di Custom Vision. Aggiungere il codice seguente per creare un nuovo progetto di servizio Visione personalizzata.

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

Aggiungere tag al progetto

Per creare tag di classificazione al progetto, aggiungere il codice seguente alla funzione:

const hemlockTag = await trainer.createTag(sampleProject.id, "Hemlock");
const cherryTag = await trainer.createTag(sampleProject.id, "Japanese Cherry");

Caricare e contrassegnare immagini

Prima di tutto, scaricare le immagini di esempio per questo progetto. Salvare il contenuto della cartella immagini sample nel dispositivo locale.

Per aggiungere le immagini di esempio al progetto, inserire il codice seguente dopo la creazione del tag. Questo codice carica ogni immagine con il tag corrispondente.

const sampleDataRoot = "Images";

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

const hemlockDir = `${sampleDataRoot}/Hemlock`;
const hemlockFiles = fs.readdirSync(hemlockDir);
hemlockFiles.forEach(file => {
    fileUploadPromises.push(trainer.createImagesFromData(sampleProject.id, fs.readFileSync(`${hemlockDir}/${file}`), { tagIds: [hemlockTag.id] }));
});

const cherryDir = `${sampleDataRoot}/Japanese_Cherry`;
const japaneseCherryFiles = fs.readdirSync(cherryDir);
japaneseCherryFiles.forEach(file => {
    fileUploadPromises.push(trainer.createImagesFromData(sampleProject.id, fs.readFileSync(`${cherryDir}/${file}`), { tagIds: [cherryTag.id] }));
});

await Promise.all(fileUploadPromises);

Formare il progetto

Questo codice crea la prima iterazione del modello di stima.

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

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

Pubblicare l'iterazione corrente

Questo codice pubblica l'iterazione addestrata nell'endpoint di previsione. Il nome assegnato all'iterazione pubblicata può essere usato per inviare richieste di stima. Un'iterazione non è disponibile nell'endpoint di stima fino a quando non viene pubblicata.

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

Testare l'endpoint di predizione

Per inviare un'immagine all'endpoint di stima e recuperare la stima, aggiungere il codice seguente alla funzione.

const testFile = fs.readFileSync(`${sampleDataRoot}/Test/test_image.jpg`);

const results = await predictor.classifyImage(sampleProject.id, publishIterationName, testFile);

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

Chiudere quindi la funzione Visione personalizzata e chiamarla.

})()

Eseguire l'applicazione

Eseguire l'applicazione con il node comando nel file di avvio rapido.

node index.js

L'output dell'applicazione dovrebbe essere simile al testo seguente:

Creating project...
Adding images...
Training...
Training started...
Training status: Training
Training status: Training
Training status: Training
Training status: Completed
Results:
         Hemlock: 94.97%
         Japanese Cherry: 0.01%

È quindi possibile verificare che l'immagine di test (disponibile in <sampleDataRoot>/Test/) sia contrassegnata in modo appropriato. È anche possibile tornare al sito Web di Visione personalizzata e visualizzare lo stato corrente del progetto appena creato.

Se si vuole implementare un progetto di classificazione delle immagini personalizzato (o provare invece un progetto di rilevamento oggetti), è possibile eliminare il progetto di identificazione albero da questo esempio. Una sottoscrizione gratuita consente due progetti di Visione personalizzata.

Nel sito Web di Custom Vision passare a Projects e selezionare il cestino in My New Project.

Contenuto correlato

Questa guida illustra come eseguire ogni passaggio del processo di rilevamento degli oggetti nel codice. Questo esempio esegue una singola iterazione di training, ma spesso è necessario eseguire il training e il test del modello più volte per renderlo più accurato.

• Che cos'è Visione personalizzata?
• Il codice sorgente per questo esempio è disponibile in GitHub
• documentazione di riferimento per SDK (formazione)
• documentazione di riferimento SDK (previsione)

Inizia con la libreria client Custom Vision per Python. Seguire questa procedura per installare il pacchetto e provare il codice di esempio per la compilazione di un modello di classificazione delle immagini. Si creerà un progetto, si aggiungeranno tag, si eseguirà il training del progetto e si userà l'URL dell'endpoint di previsione del progetto per testarlo a livello di codice. Usare questo esempio come modello per creare un'app di riconoscimento delle immagini personalizzata.

Usare la libreria client di Visione personalizzata per Python per:

• Creare un nuovo progetto di Visione personalizzata
• Aggiungere tag al progetto
• Caricare e contrassegnare immagini
• Formare il progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di predizione

documentazione Reference | Codice sorgente della libreria | Package (PyPI) | Samples

Prerequisiti

• Sottoscrizione Azure. È possibile crearne uno gratuitamente.
• Python 3.x.
  • L'installazione Python deve includere pip. È possibile verificare se pip è installato eseguendo pip --version nella riga di comando. Ottieni pip installando l'ultima versione di Python.
• Dopo aver sottoscritto un abbonamento Azure, crea una risorsa Custom Vision nel portale di Azure per una risorsa di addestramento e predizione.
  • È possibile usare il piano tariffario gratuito (F0) per provare il servizio e eseguire l'aggiornamento in un secondo momento a un livello a pagamento per la produzione.

Creare variabili di ambiente

In questo esempio si scriveranno le credenziali nelle variabili di ambiente nel computer locale che esegue l'applicazione.

Passare al portale di Azure. Se le risorse di Visione personalizzata create nella sezione Prerequisiti sono state distribuite correttamente, selezionare il pulsante Vai alla risorsa in Passaggi successivi. È possibile trovare le chiavi e gli endpoint nelle pagine Chiavi ed endpoint delle risorse, in Gestione risorse. Sarà necessario ottenere le chiavi sia per la risorsa di training che per la risorsa di stima, insieme agli endpoint API.

È possibile trovare l'ID risorsa di stima nella scheda Properties della risorsa di stima nel portale di Azure, elencato come ID Di risorse.

Per impostare le variabili di ambiente, aprire una finestra della console e seguire le istruzioni per il sistema operativo e l'ambiente di sviluppo.

• Per impostare la VISION_TRAINING KEY variabile di ambiente, sostituire <your-training-key> con una delle chiavi per la risorsa di training.
• Per impostare la VISION_TRAINING_ENDPOINT variabile di ambiente, sostituire <your-training-endpoint> con l'endpoint per la risorsa di allenamento.
• Per impostare la VISION_PREDICTION_KEY variabile di ambiente, sostituire <your-prediction-key> con una delle chiavi per la risorsa di stima.
• Per impostare la VISION_PREDICTION_ENDPOINT variabile di ambiente, sostituire <your-prediction-endpoint> con l'endpoint per la risorsa di stima.
• Per impostare la VISION_PREDICTION_RESOURCE_ID variabile di ambiente, sostituire <your-resource-id> con l'ID risorsa per la risorsa di previsione.

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Configurazione

Installare la libreria client

Per scrivere un'app di analisi delle immagini con Visione personalizzata per Python, è necessaria la libreria client di Visione personalizzata. Dopo aver installato Python, eseguire il comando seguente in PowerShell o in una finestra della console:

pip install azure-cognitiveservices-vision-customvision

Creare una nuova applicazione Python

Creare un nuovo file Python e importare le librerie seguenti.

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

Creare variabili per l'endpoint e le chiavi Azure della risorsa.

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

Modello a oggetti

Esempi di codice

Questi frammenti di codice illustrano come eseguire le operazioni seguenti con la libreria client di Visione personalizzata per Python:

• Autenticare il client
• Creare un nuovo progetto di Visione personalizzata
• Aggiungere tag al progetto
• Caricare e contrassegnare immagini
• Addestrare il progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di stima

Autenticare il client

Creare un'istanza di un client di training e stima con l'endpoint e le chiavi. Creare ApiKeyServiceClientCredentials oggetti con le tue chiavi e utilizzarli con il tuo endpoint per creare un oggetto CustomVisionTrainingClient e un CustomVisionPredictionClient.

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

Creare un nuovo progetto di Visione personalizzata

Aggiungere il codice seguente allo script per creare un nuovo progetto di servizio Visione personalizzata.

Vedere il metodo create_project per specificare altre opzioni quando si crea il progetto (illustrato nella guida Creare un classificatore del portale Web).

publish_iteration_name = "classifyModel"

credentials = ApiKeyCredentials(in_headers={"Training-key": training_key})
trainer = CustomVisionTrainingClient(ENDPOINT, credentials)

# Create a new project
print ("Creating project...")
project_name = uuid.uuid4()
project = trainer.create_project(project_name)

Aggiungere tag al progetto

Per aggiungere tag di classificazione al progetto, aggiungere il codice seguente:

# Make two tags in the new project
hemlock_tag = trainer.create_tag(project.id, "Hemlock")
cherry_tag = trainer.create_tag(project.id, "Japanese Cherry")

Caricare e contrassegnare immagini

Prima di tutto, scaricare le immagini di esempio per questo progetto. Salvare il contenuto della cartella immagini sample nel dispositivo locale.

Per aggiungere le immagini di esempio al progetto, inserire il codice seguente dopo la creazione del tag. Questo codice carica ogni immagine con il tag corrispondente. È possibile caricare fino a 64 immagini in un singolo batch.

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

print("Adding images...")

image_list = []

for image_num in range(1, 11):
    file_name = "hemlock_{}.jpg".format(image_num)
    with open(os.path.join (base_image_location, "Hemlock", file_name), "rb") as image_contents:
        image_list.append(ImageFileCreateEntry(name=file_name, contents=image_contents.read(), tag_ids=[hemlock_tag.id]))

for image_num in range(1, 11):
    file_name = "japanese_cherry_{}.jpg".format(image_num)
    with open(os.path.join (base_image_location, "Japanese_Cherry", file_name), "rb") as image_contents:
        image_list.append(ImageFileCreateEntry(name=file_name, contents=image_contents.read(), tag_ids=[cherry_tag.id]))

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

Formare il progetto

Questo codice crea la prima iterazione del modello di stima.

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

Pubblicare l'iterazione corrente

Un'iterazione non è disponibile nell'endpoint di stima fino a quando non viene pubblicata. Il codice seguente rende disponibile l'iterazione corrente del modello per l'esecuzione di query.

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

Testare l'endpoint di predizione

Per inviare un'immagine all'endpoint di stima e recuperare la stima, aggiungere il codice seguente alla fine del file:

# Now there is a trained endpoint that can be used to make a prediction
prediction_credentials = ApiKeyCredentials(in_headers={"Prediction-key": prediction_key})
predictor = CustomVisionPredictionClient(prediction_endpoint, prediction_credentials)

with open(os.path.join (base_image_location, "Test/test_image.jpg"), "rb") as image_contents:
    results = predictor.classify_image(
        project.id, publish_iteration_name, image_contents.read())

    # Display the results.
    for prediction in results.predictions:
        print("\t" + prediction.tag_name +
              ": {0:.2f}%".format(prediction.probability * 100))

Eseguire l'applicazione

Eseguire l'applicazione usando il comando seguente:

python CustomVisionQuickstart.py

L'output dell'applicazione dovrebbe essere simile al testo seguente:

Creating project...
Adding images...
Training...
Training status: Training
Training status: Completed
Done!
        Hemlock: 93.53%
        Japanese Cherry: 0.01%

È quindi possibile verificare che l'immagine di test (disponibile in <base_image_location>/images/Test/) sia contrassegnata in modo appropriato. È anche possibile tornare al sito Web di Visione personalizzata e visualizzare lo stato corrente del progetto appena creato.

Pulire le risorse

Se si vuole implementare un progetto di classificazione delle immagini personalizzato (o provare invece un progetto di rilevamento oggetti), è possibile eliminare il progetto di identificazione albero da questo esempio. Una sottoscrizione gratuita consente due progetti di Visione personalizzata.

Nel sito Web di Custom Vision passare a Projects e selezionare il cestino in My New Project.

Contenuto correlato

A questo punto è stato illustrato come eseguire ogni passaggio del processo di classificazione delle immagini nel codice. Questo esempio esegue una singola iterazione di training, ma spesso è necessario eseguire il training e il test del modello più volte per renderlo più accurato.

• Che cos'è Visione personalizzata?
• Il codice sorgente per questo esempio è disponibile in GitHub
• Documentazione di riferimento dell'SDK

Inizia con l'API REST di Visone Personalizzata. Seguire questa procedura per chiamare l'API e creare un modello di classificazione delle immagini. Si creerà un progetto, si aggiungeranno tag, si eseguirà il training del progetto e si userà l'URL dell'endpoint di previsione del progetto per testarlo a livello di codice. Usare questo esempio come modello per creare un'app di riconoscimento delle immagini personalizzata.

Usare la libreria client Custom Vision per il REST API:

• Creare un nuovo progetto di Visione personalizzata
• Aggiungere tag al progetto
• Caricare e contrassegnare immagini
• Formare il progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di predizione

Prerequisiti

• Sottoscrizione Azure. È possibile crearne uno gratuitamente.
• Dopo aver sottoscritto un abbonamento Azure, crea una risorsa Custom Vision nel portale di Azure per una risorsa di addestramento e predizione.
  • È necessaria la chiave e l'endpoint dalle risorse da voi create per connettere l'applicazione a Custom Vision. La chiave e l'endpoint verranno incollati nel codice più avanti nella procedura rapida.
  • È possibile usare il piano tariffario gratuito (F0) per provare il servizio e eseguire l'aggiornamento in un secondo momento a un livello a pagamento per la produzione.
• PowerShell versione 6.0+o un'applicazione della riga di comando simile.

Creare un nuovo progetto di Visione personalizzata

Per creare un progetto di classificazione delle immagini si userà un comando simile al seguente. Il progetto creato verrà visualizzato nel sito Web di Visione personalizzata.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects?name={name}"

Copiare il comando in un editor di testo e apportare le modifiche seguenti:

• Sostituire {subscription key} con la chiave valida.
• Sostituire {endpoint} con l'endpoint corrispondente alla chiave.

  Nota

  Le nuove risorse create dopo il 1° luglio 2019 useranno nomi di sottodomini personalizzati. Per ulteriori informazioni e un elenco completo degli endpoint regionali, vedere Nomi di sottodomini personalizzati per gli strumenti Foundry.

• Sostituire {name} con il nome del progetto.
• Facoltativamente, impostare altri parametri URL per configurare il tipo di modello usato dal progetto. Per le opzioni, vedere Creare Project API.

Viene visualizzata una risposta JSON simile all'esempio seguente. Salvate il "id" valore del progetto in un percorso temporaneo.

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "description": "string",
  "settings": {
    "domainId": "00000000-0000-0000-0000-000000000000",
    "classificationType": "Multiclass",
    "targetExportPlatforms": [
      "CoreML"
    ],
    "useNegativeSet": true,
    "detectionParameters": "string",
    "imageProcessingSettings": {
      "augmentationMethods": {}
    }
  },
  "created": "string",
  "lastModified": "string",
  "thumbnailUri": "string",
  "drModeEnabled": true,
  "status": "Succeeded"
}

Aggiungere tag al progetto

Usare il comando seguente per definire i tag su cui verrà eseguito il training del modello.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/tags?name={name}"

• Anche in questo caso, inserire la propria chiave e l'URL dell'endpoint.
• Sostituire {projectId} con il proprio ID progetto.
• Sostituire {name} con il nome del tag da usare.

Ripetere questo processo per tutti i tag da usare nel progetto. Se si usano le immagini di esempio fornite, aggiungere i tag "Hemlock" e "Japanese Cherry".

Viene visualizzata una risposta JSON simile all'esempio seguente. Salvare il "id" valore di ogni tag in una posizione temporanea.

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "description": "string",
  "type": "Regular",
  "imageCount": 0
}

Caricare e contrassegnare immagini

Scaricare quindi le immagini di esempio per questo progetto. Salvare il contenuto della cartella immagini sample nel dispositivo locale.

Usare il comando seguente per caricare le immagini e applicare tag; una volta per le immagini "Hemlock" e separatamente per le immagini "Japanese Cherry". Per altre opzioni, vedere l'API Crea immagini da dati .

curl -v -X POST -H "Content-Type: multipart/form-data" -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/images?tagIds={tagArray}"
--data-ascii "{binary data}"

• Anche in questo caso, inserire la propria chiave e l'URL dell'endpoint.
• Sostituire {projectId} con il proprio ID progetto.
• Sostituire {tagArray} con l'ID di un tag.
• Popolare quindi il corpo della richiesta con i dati binari delle immagini che si desidera contrassegnare.

Formare il progetto

Questo metodo esegue il training del modello sulle immagini contrassegnate caricate e restituisce un ID per l'iterazione del progetto corrente.

curl -v -X POST -H "Content-Type: application/json" -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/train"

• Anche in questo caso, inserire la propria chiave e l'URL dell'endpoint.
• Sostituire {projectId} con il proprio ID progetto.
• Sostituire {tagArray} con l'ID di un tag.
• Popolare quindi il corpo della richiesta con i dati binari delle immagini che si desidera contrassegnare.
• Facoltativamente, usare altri parametri URL. Per le opzioni, vedere Train Project API.

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

La risposta JSON contiene informazioni sul progetto sottoposto a training, incluso l'ID di iterazione ("id"). Salvare questo valore per il passaggio successivo.

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "status": "string",
  "created": "string",
  "lastModified": "string",
  "trainedAt": "string",
  "projectId": "00000000-0000-0000-0000-000000000000",
  "exportable": true,
  "exportableTo": [
    "CoreML"
  ],
  "domainId": "00000000-0000-0000-0000-000000000000",
  "classificationType": "Multiclass",
  "trainingType": "Regular",
  "reservedBudgetInHours": 0,
  "trainingTimeInMinutes": 0,
  "publishName": "string",
  "originalPublishResourceId": "string"
}

Pubblicare l'iterazione corrente

Questo metodo rende disponibile l'iterazione corrente del modello per l'esecuzione di query. Il nome del modello restituito viene usato come riferimento per inviare richieste di stima.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/iterations/{iterationId}/publish?publishName={publishName}&predictionId={predictionId}"

• Anche in questo caso, inserire la propria chiave e l'URL dell'endpoint.
• Sostituire {projectId} con il proprio ID progetto.
• Sostituire {iterationId} con l'ID restituito nel passaggio precedente.
• Sostituire {publishedName} con il nome che si vuole assegnare al modello di stima.
• Sostituire {predictionId} con il proprio ID risorsa di previsione. È possibile trovare l'ID della risorsa di previsione nella scheda Properties nel portale di Azure, elencato come ID Risorsa.
• Facoltativamente, usare altri parametri URL. Vedi l'API Pubblica Iterazione.

Testare l'endpoint di predizione

Usare infine questo comando per testare il modello sottoposto a training caricando una nuova immagine per classificarla con i tag. È possibile usare l'immagine nella cartella Test dei file di esempio scaricati in precedenza.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/iterations/{iterationId}/publish?publishName={publishName}&predictionId={predictionId}"

• Anche in questo caso, inserire la propria chiave e l'URL dell'endpoint.
• Sostituire {projectId} con il proprio ID progetto.
• Sostituire {publishedName} con il nome usato nel passaggio precedente.
• Aggiungere i dati binari dell'immagine locale al corpo della richiesta.
• Facoltativamente, usare altri parametri URL. Vedere l'API Classifica immagine .

La risposta JSON restituita elenca ognuno dei tag applicati al modello all'immagine, insieme ai punteggi di probabilità per ogni tag.

{
  "id": "00000000-0000-0000-0000-000000000000",
  "project": "00000000-0000-0000-0000-000000000000",
  "iteration": "00000000-0000-0000-0000-000000000000",
  "created": "string",
  "predictions": [
    {
      "probability": 0.0,
      "tagId": "00000000-0000-0000-0000-000000000000",
      "tagName": "string",
      "boundingBox": {
        "left": 0.0,
        "top": 0.0,
        "width": 0.0,
        "height": 0.0
      },
      "tagType": "Regular"
    }
  ]
}

Se si vuole implementare un progetto di classificazione delle immagini personalizzato (o provare invece un progetto di rilevamento oggetti), è possibile eliminare il progetto di identificazione albero da questo esempio. Una sottoscrizione gratuita consente due progetti di Visione personalizzata.

Nel sito Web di Custom Vision passare a Projects e selezionare il cestino in My New Project.

Contenuto correlato

A questo punto è stato eseguito ogni passaggio del processo di classificazione delle immagini usando l'API REST. Questo esempio esegue una singola iterazione di training, ma spesso è necessario eseguire il training e il test del modello più volte per renderlo più accurato.

• Che cos'è Visione personalizzata?
• Documentazione di riferimento sulle API (training)
• Documentazione di riferimento sulle API (stima)