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

Introduzione alla libreria client di Visione personalizzata per .NET. Seguire questi passaggi per installare il pacchetto e provare il codice di esempio per creare un modello di classificazione 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 la creazione di un'app di riconoscimento immagini personalizzata.

Nota

Se si vuole creare un modello di classificazione ed eseguirne il training senza scrivere codice, vedere invece le istruzioni basate sul browser.

Documentazione di riferimento | Codice sorgente della libreria (training)(previsione) | Pacchetti (NuGet) (training)(prediction) | Samples

Prerequisiti

• Sottoscrizione di Azure: creare un account gratuito
• IDE di Visual Studio o la versione corrente di .NET Core.
• Dopo aver creato la sottoscrizione di Azure, creare una risorsa Visione personalizzata nel portale di Azure per creare una risorsa di training e stima.
  • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento 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.

Vai al portale di Azure. Se le risorse 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 chiave ed endpoint delle risorse, in Gestione risorse. È necessario ottenere le chiavi sia per le risorse di training che per le risorse di stima, insieme agli endpoint API.

È possibile trovare l'ID risorsa di stima nella scheda Proprietà della risorsa di stima nella portale di Azure, elencata come ID risorsa.

Suggerimento

È anche possibile usare https://www.customvision.ai/ per ottenere questi valori. Dopo aver eseguito l'accesso, selezionare l'icona Impostazioni in alto a destra. Nelle pagine Impostazione è possibile visualizzare tutte le chiavi, l'ID risorsa e gli endpoint.

Attenzione

Non includere la chiave direttamente nel codice e non pubblicarla pubblicamente. Per altre opzioni di autenticazione come Azure Key Vault, vedere l'articolo sicurezza dei servizi di intelligenza artificiale di Azure.

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

1. Per impostare la VISION_TRAINING KEY variabile di ambiente, sostituire your-training-key con una delle chiavi per la risorsa di training.
2. Per impostare la VISION_TRAINING_ENDPOINT variabile di ambiente, sostituire your-training-endpoint con l'endpoint per la risorsa di training.
3. Per impostare la VISION_PREDICTION_KEY variabile di ambiente, sostituire your-prediction-key con una delle chiavi per la risorsa di stima.
4. Per impostare la VISION_PREDICTION_ENDPOINT variabile di ambiente, sostituire your-prediction-endpoint con l'endpoint per la risorsa di stima.
5. Per impostare la VISION_PREDICTION_RESOURCE_ID variabile di ambiente, sostituire your-resource-id con l'ID risorsa per la risorsa di stima.

Windows

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

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare tutti i programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

Linux

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

Dopo avere aggiunto le variabili di ambiente, eseguire source ~/.bashrc dalla finestra della console per rendere effettive le modifiche.

Configurazione

IDE di Visual Studio

Creare una nuova applicazione C#

Creare un'applicazione .NET Core con Visual Studio.

Installare la libreria client

Dopo aver creato un nuovo progetto, installare la libreria client facendo clic con il pulsante destro del mouse sulla soluzione del progetto in Esplora soluzioni e scegliendo Gestisci pacchetti NuGet. Nella finestra di dialogo Gestione pacchetti visualizzata selezionare Sfoglia, Includi versione preliminare e cercare Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training e Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction. Selezionare la versione più recente e fare clic su Installa.

CLI

Creare una nuova applicazione C#

In una finestra di una console, ad esempio cmd, PowerShell o Bash, usare il comando dotnet new per creare una nuova app console con il nome custom-vision-quickstart. Questo comando crea un semplice progetto C# "Hello World" con un unico file di origine: program.cs.

dotnet new console -n custom-vision-quickstart

Spostarsi nella cartella dell'app appena creata. È possibile compilare l'applicazione con il comando seguente:

dotnet build

L'output di compilazione non deve contenere alcun avviso o errore.

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

Installare la libreria client

Nella directory dell'applicazione installare la libreria client di Visione personalizzata per .NET con il comando seguente:

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

Suggerimento

Si vuole visualizzare l'intero file di codice dell'argomento di avvio rapido? È possibile trovarlo in GitHub, che contiene gli esempi di codice di questo argomento.

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

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 Main dell'applicazione creare variabili che recuperano le chiavi e gli endpoint della risorsa dalle variabili di ambiente. Verranno inoltre dichiarati 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 Main dell'applicazione aggiungere le chiamate per i metodi usati in questa guida di avvio rapido. Queste verranno implementate 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, creare un'istanza dei client di training e di previsione usando 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 Visione personalizzata

Il frammento di codice successivo crea un progetto di classificazione immagini. Il progetto creato verrà visualizzato nel sito Web di Visione personalizzata. Per specificare altre opzioni quando si crea il progetto, come illustrato in Creare un classificatore nella guida al portale Web, vedere il metodo CreateProject.

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 eseguirà 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 le immagini

Scaricare prima di tutto le immagini di esempio per questo progetto. Salvare il contenuto della cartella immagini di esempio 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 al percorso in cui sono 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 i tag in base al percorso della cartella (le immagini sono già ordinate). È possibile caricare e assegnare tag alle immagini in modo iterativo o in un batch (fino a 64 per batch). Questo frammento di codice contiene esempi per entrambe le opzioni.

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

}

Eseguire il training del progetto

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

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

Suggerimento

Eseguire il training con i tag selezionati

Facoltativamente, è possibile eseguire il training solo su un subset dei tag applicati. Questa operazione può essere eseguita se non è ancora stato applicato un numero sufficiente di determinati tag, ma si dispone di un numero sufficiente di altri. Nella chiamata TrainProject usare il parametro trainingParameters. Costruire un TrainingParameters e impostare la relativa proprietà SelectedTags su un elenco di ID dei tag che si intende usare. Il modello eseguirà il training in modo da riconoscere solo i tag nell'elenco.

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 previsione. È necessario immettere il valore corrente per predictionResourceId. È possibile trovare l'ID risorsa di stima nella scheda Proprietà della risorsa nella portale di Azure, elencata 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 stima

Questa parte dello script carica l'immagine di test, esegue 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

IDE di Visual Studio

Eseguire l'applicazione facendo clic sul pulsante Debug nella parte superiore della finestra dell'ambiente di sviluppo integrato.

CLI

Eseguire l'applicazione dalla directory dell'applicazione con il comando dotnet run.

dotnet run

Quando l'applicazione viene eseguita, 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%

Si può quindi verificare che all'immagine di test (disponibile in Images/Test/) siano stati applicati i tag appropriati. Premere un tasto qualsiasi per uscire dall'applicazione. È anche possibile tornare al sito Web di Visione personalizzata e vedere lo stato corrente del progetto appena creato.

Pulire le risorse

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

Nel sito Web di Visione personalizzata passare a Projects e selezionare l'icona del cestino sotto My New Project.

Passaggi successivi

A questo punto, sono stati eseguiti tutti i passaggi del processo di classificazione delle immagini nel codice. Questo esempio esegue una sola iterazione del training, ma spesso è necessario eseguire il training e il test del modello più volte per ottenere una maggiore precisione.

Testare un modello e ripeterne il training

• Che cos'è Visione personalizzata?
• Il codice sorgente per questo esempio è disponibile su GitHub
• Documentazione di riferimento sull'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 immagini. Si creerà un progetto, si aggiungeranno tag, si eseguirà il training del progetto e si userà l'URL dell'endpoint di stima del progetto per testarlo a livello di codice. Usare questo esempio come modello per la creazione di un'app di riconoscimento immagini personalizzata.

Nota

Se si vuole creare un modello di classificazione ed eseguirne il training senza scrivere codice, vedere invece le istruzioni basate sul browser.

Usare la libreria client Visione personalizzata per Vai a:

• Creare un nuovo progetto Visione personalizzata
• Aggiungere tag al progetto
• Caricare e contrassegnare le immagini
• Eseguire il training del progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di stima

Documentazione di riferimento (training)(previsione)

Prerequisiti

• Sottoscrizione di Azure: creare un account gratuito
• Go 1.8+
• Dopo aver creato la sottoscrizione di Azure, creare una risorsa Visione personalizzata nel portale di Azure per creare una risorsa di training e stima.
  • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento 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.

Vai al portale di Azure. Se le risorse 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 chiave ed endpoint delle risorse, in Gestione risorse. È necessario ottenere le chiavi sia per le risorse di training che per le risorse di stima, insieme agli endpoint API.

È possibile trovare l'ID risorsa di stima nella scheda Proprietà della risorsa di stima nella portale di Azure, elencata come ID risorsa.

Suggerimento

È anche possibile usare https://www.customvision.ai/ per ottenere questi valori. Dopo aver eseguito l'accesso, selezionare l'icona Impostazioni in alto a destra. Nelle pagine Impostazione è possibile visualizzare tutte le chiavi, l'ID risorsa e gli endpoint.

Attenzione

Non includere la chiave direttamente nel codice e non pubblicarla pubblicamente. Per altre opzioni di autenticazione come Azure Key Vault, vedere l'articolo sicurezza dei servizi di intelligenza artificiale di Azure.

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

1. Per impostare la VISION_TRAINING KEY variabile di ambiente, sostituire your-training-key con una delle chiavi per la risorsa di training.
2. Per impostare la VISION_TRAINING_ENDPOINT variabile di ambiente, sostituire your-training-endpoint con l'endpoint per la risorsa di training.
3. Per impostare la VISION_PREDICTION_KEY variabile di ambiente, sostituire your-prediction-key con una delle chiavi per la risorsa di stima.
4. Per impostare la VISION_PREDICTION_ENDPOINT variabile di ambiente, sostituire your-prediction-endpoint con l'endpoint per la risorsa di stima.
5. Per impostare la VISION_PREDICTION_RESOURCE_ID variabile di ambiente, sostituire your-resource-id con l'ID risorsa per la risorsa di stima.

Windows

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

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare tutti i programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

Linux

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

Dopo avere aggiunto le variabili di ambiente, eseguire source ~/.bashrc dalla finestra della console per rendere effettive le modifiche.

Configurazione

Installare la libreria client di Visione personalizzata

Per scrivere un'app di analisi immagini con Visione personalizzata per Go, è necessaria la libreria client di Visione personalizzata. In PowerShell eseguire questo comando:

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

o se si usa dep nell'esecuzione del repository:

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

Ottenere le immagini di esempio

Questo esempio usa le immagini del repository python SDK per i servizi di intelligenza artificiale di Azure in GitHub. Clonare o scaricare questo repository nell'ambiente di sviluppo. Ricordare il percorso della cartella per un passaggio successivo.

Creare il progetto di Visione personalizzata

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

Per creare un nuovo progetto di Servizio visione artificiale personalizzato, aggiungere il codice seguente allo script.

Per specificare altre opzioni quando si crea il progetto, come illustrato in Creare un classificatore nella guida al portale Web, vedere il metodo CreateProject.

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 i tag di classificazione per il progetto, aggiungere il codice seguente alla fine del file 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 le immagini

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

Nota

Sarà necessario modificare il percorso delle immagini in base alla posizione in cui è stato scaricato il progetto Go SDK di Azure AI Services Go SDK in precedenza.

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

Eseguire il training del progetto e pubblicarlo

Questo codice crea la prima iterazione del modello di previsione e quindi la pubblica nell'endpoint di previsione. Il nome assegnato all'iterazione pubblicata può essere usato per inviare le richieste di stima. L'iterazione è disponibile nell'endpoint di stima solo dopo che è stata 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 stima

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

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 vedere lo stato corrente del progetto appena creato.

Pulire le risorse

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

Nel sito Web di Visione personalizzata passare a Projects e selezionare l'icona del cestino sotto My New Project.

Passaggi successivi

È stato illustrato come è possibile eseguire ogni passaggio del processo di rilevamento degli oggetti nel codice. Questo esempio esegue una sola iterazione del training, ma spesso è necessario eseguire il training e il test del modello più volte per ottenere una maggiore precisione.

Testare un modello e ripeterne il training

• Che cos'è Visione personalizzata?
• Documentazione di riferimento sull'SDK (esercitazione)
• Documentazione di riferimento sull'SDK (previsione)

Iniziare a usare la libreria client di Visione personalizzata per Java per creare un modello di classificazione delle immagini. Seguire questi passaggi per installare il pacchetto e provare il codice di esempio per le attività di base. Usare questo esempio come modello per la creazione di un'app di riconoscimento immagini personalizzata.

Nota

Se si vuole creare un modello di classificazione ed eseguirne il training senza scrivere codice, vedere invece le istruzioni basate sul browser.

Usare la libreria client di Visione personalizzata per Java per:

• Creare un nuovo progetto Visione personalizzata
• Aggiungere tag al progetto
• Caricare e contrassegnare le immagini
• Eseguire il training del progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di stima

Documentazione di riferimento | Codice sorgente della libreria (training)(prediction)| Artifact (Maven) (training)(prediction) | Samples

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• La versione corrente di Java Development Kit (JDK)
• Lo strumento di compilazione Gradle o un'altra utilità di gestione dipendenze.
• Dopo aver creato la sottoscrizione di Azure, creare una risorsa Visione personalizzata nel portale di Azure per creare una risorsa di training e stima.
  • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento 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.

Vai al portale di Azure. Se le risorse 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 chiave ed endpoint delle risorse, in Gestione risorse. È necessario ottenere le chiavi sia per le risorse di training che per le risorse di stima, insieme agli endpoint API.

È possibile trovare l'ID risorsa di stima nella scheda Proprietà della risorsa di stima nella portale di Azure, elencata come ID risorsa.

Suggerimento

È anche possibile usare https://www.customvision.ai/ per ottenere questi valori. Dopo aver eseguito l'accesso, selezionare l'icona Impostazioni in alto a destra. Nelle pagine Impostazione è possibile visualizzare tutte le chiavi, l'ID risorsa e gli endpoint.

Attenzione

Non includere la chiave direttamente nel codice e non pubblicarla pubblicamente. Per altre opzioni di autenticazione come Azure Key Vault, vedere l'articolo sicurezza dei servizi di intelligenza artificiale di Azure.

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

1. Per impostare la VISION_TRAINING KEY variabile di ambiente, sostituire your-training-key con una delle chiavi per la risorsa di training.
2. Per impostare la VISION_TRAINING_ENDPOINT variabile di ambiente, sostituire your-training-endpoint con l'endpoint per la risorsa di training.
3. Per impostare la VISION_PREDICTION_KEY variabile di ambiente, sostituire your-prediction-key con una delle chiavi per la risorsa di stima.
4. Per impostare la VISION_PREDICTION_ENDPOINT variabile di ambiente, sostituire your-prediction-endpoint con l'endpoint per la risorsa di stima.
5. Per impostare la VISION_PREDICTION_RESOURCE_ID variabile di ambiente, sostituire your-resource-id con l'ID risorsa per la risorsa di stima.

Windows

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

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare tutti i programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

Linux

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

Dopo avere aggiunto le variabili di ambiente, eseguire source ~/.bashrc dalla finestra della console per rendere effettive le modifiche.

Configurazione

Creare un nuovo progetto Gradle

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

mkdir myapp && cd myapp

Eseguire il comando gradle init dalla directory di lavoro. Questo comando creerà i file di compilazione essenziali per Gradle, tra cui build.gradle.kts, che viene usato in fase di esecuzione per creare e configurare l'applicazione.

gradle init --type basic

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

Installare la libreria client

Individuare il file build.gradle.kts e aprirlo con un IDE o un editor di testo a scelta. Quindi copiare la configurazione di compilazione seguente. Questa configurazione definisce il progetto come applicazione Java il cui punto di ingresso è la classe CustomVisionQuickstart. Importa le 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 in un editor o un IDE a scelta e importare le istruzioni import seguenti:

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;

Suggerimento

Si vuole visualizzare l'intero file di codice dell'argomento di avvio rapido? È possibile trovarlo in GitHub, che contiene gli esempi di codice di questo argomento.

Nella classe CustomVisionQuickstart dell'applicazione creare variabili che recuperano le chiavi e l'endpoint della risorsa dalle variabili di 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");

Importante

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

È possibile trovare l'ID risorsa di stima nella scheda Proprietà della risorsa nella portale di Azure, elencata come ID risorsa.

Importante

Al termine, ricordarsi di rimuovere le chiavi dal codice e di non renderle mai pubbliche. Per l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere l'articolo sulla sicurezza dei servizi di intelligenza artificiale di Azure.

Nel metodo main dell'applicazione aggiungere le chiamate per i metodi usati in questa guida di avvio rapido. 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 per Java.

Nome	Descrizione
CustomVisionTrainingClient	Questa classe gestisce la creazione, il training e la pubblicazione dei modelli.
CustomVisionPredictionClient	Questa classe gestisce l'esecuzione di query sui modelli per le previsioni di classificazione immagini.
ImagePrediction	Questa classe definisce una singola previsione in una singola immagine. Include le proprietà per l'ID e il nome dell'oggetto e un punteggio di attendibilità.

Esempi di codice

Questi frammenti di codice mostrano 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
• Eseguire il training del progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di stima

Autenticare il client

Nel metodo principale, creare un'istanza dei client di training e di previsione usando l'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

T## Creare un nuovo progetto di Visione personalizzata

Il metodo successivo crea un progetto di classificazione immagini. Il progetto creato verrà visualizzato nel sito Web di Visione personalizzata visitato in precedenza. Per specificare altre opzioni quando si crea il progetto, come illustrato in Creare un rilevatore nella guida al portale Web, vedere gli overload del metodo CreateProject.

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 i tag al progetto

Questo metodo definisce i tag su cui si eseguirà 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 le immagini

Scaricare prima di tutto le immagini di esempio per questo progetto. Salvare il contenuto della cartella immagini di esempio 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;
}

Eseguire il training del progetto

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

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 previsione. È necessario immettere il valore corrente per predictionResourceId. È possibile trovare l'ID risorsa di stima nella scheda Proprietà della risorsa nella portale di Azure, elencata 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 stima

Questo metodo carica l'immagine di test, esegue 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 comando gradle run:

gradle run

Pulire le risorse

Se si vuole pulire e rimuovere una sottoscrizione dei servizi di intelligenza artificiale di Azure, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

• Portale
• Interfaccia della riga di comando di Azure

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

Nel sito Web di Visione personalizzata passare a Projects e selezionare l'icona del cestino sotto My New Project.

Passaggi successivi

In questa guida si è appreso come eseguire ogni passaggio del processo di classificazione delle immagini nel codice. Questo esempio esegue una sola iterazione del training, ma spesso è necessario eseguire il training e il test del modello più volte per ottenere una maggiore precisione.

Testare un modello e ripeterne il training

• Che cos'è Visione personalizzata?
• Il codice sorgente per questo esempio è disponibile su 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 immagini. Si creerà un progetto, si aggiungeranno tag, si eseguirà il training del progetto e si userà l'URL dell'endpoint di stima del progetto per testarlo a livello di codice. Usare questo esempio come modello per la creazione di un'app di riconoscimento immagini personalizzata.

Nota

Se si vuole creare un modello di classificazione ed eseguirne il training senza scrivere codice, vedere invece le istruzioni basate sul browser.

Usare la libreria client di Visione personalizzata per .NET per:

• Creare un nuovo progetto Visione personalizzata
• Aggiungere tag al progetto
• Caricare e contrassegnare le immagini
• Eseguire il training del progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di stima

Documentazione di riferimento (training)(previsione) | Codice sorgente della libreria (training)(previsione) | Package (npm) (training)(prediction) | Samples

Prerequisiti

• Sottoscrizione di Azure: creare un account gratuito
• Versione corrente di Node.js
• Dopo aver creato la sottoscrizione di Azure, creare una risorsa Visione personalizzata nel portale di Azure per creare una risorsa di training e stima.
  • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento 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.

Vai al portale di Azure. Se le risorse 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 chiave ed endpoint delle risorse, in Gestione risorse. È necessario ottenere le chiavi sia per le risorse di training che per le risorse di stima, insieme agli endpoint API.

È possibile trovare l'ID risorsa di stima nella scheda Proprietà della risorsa di stima nella portale di Azure, elencata come ID risorsa.

Suggerimento

È anche possibile usare https://www.customvision.ai/ per ottenere questi valori. Dopo aver eseguito l'accesso, selezionare l'icona Impostazioni in alto a destra. Nelle pagine Impostazione è possibile visualizzare tutte le chiavi, l'ID risorsa e gli endpoint.

Attenzione

Non includere la chiave direttamente nel codice e non pubblicarla pubblicamente. Per altre opzioni di autenticazione come Azure Key Vault, vedere l'articolo sicurezza dei servizi di intelligenza artificiale di Azure.

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

1. Per impostare la VISION_TRAINING KEY variabile di ambiente, sostituire your-training-key con una delle chiavi per la risorsa di training.
2. Per impostare la VISION_TRAINING_ENDPOINT variabile di ambiente, sostituire your-training-endpoint con l'endpoint per la risorsa di training.
3. Per impostare la VISION_PREDICTION_KEY variabile di ambiente, sostituire your-prediction-key con una delle chiavi per la risorsa di stima.
4. Per impostare la VISION_PREDICTION_ENDPOINT variabile di ambiente, sostituire your-prediction-endpoint con l'endpoint per la risorsa di stima.
5. Per impostare la VISION_PREDICTION_RESOURCE_ID variabile di ambiente, sostituire your-resource-id con l'ID risorsa per la risorsa di stima.

Windows

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

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare tutti i programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

Linux

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

Dopo avere aggiunto le variabili di ambiente, eseguire source ~/.bashrc dalla finestra della console per rendere effettive le modifiche.

Configurazione

Creare una nuova applicazione Node.js

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

mkdir myapp && cd myapp

Eseguire il comando npm init per creare un'applicazione Node con un file package.json.

npm init

Installare la libreria client

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

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

Il file package.json dell'app 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");

Suggerimento

Si vuole visualizzare l'intero file di codice dell'argomento di avvio rapido? È possibile trovarlo in GitHub, che contiene gli esempi di codice di questo argomento.

Creare le variabili per l'endpoint e le chiavi di 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 i 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

Nome	Descrizione
TrainingAPIClient	Questa classe gestisce la creazione, il training e la pubblicazione dei modelli.
PredictionAPIClient	Questa classe gestisce l'esecuzione di query sui modelli per le previsioni di classificazione immagini.
Previsione	Questa interfaccia definisce una singola previsione in una singola immagine. Include le proprietà per l'ID e il nome dell'oggetto e un punteggio di attendibilità.

Esempi di codice

Questi frammenti di codice mostrano 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
• Eseguire il training del progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di stima

Autenticare il client

Creare istanze degli oggetti client con l'endpoint e la chiave. Creare un oggetto ApiKeyCredentials con la chiave e usarlo con l'endpoint per creare gli oggetti 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 Visione personalizzata

Avviare una nuova funzione in cui contenere tutte le chiamate di funzione di Visione personalizzata. 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 i tag di classificazione per il 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 le immagini

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

Per aggiungere le immagini di esempio al progetto, inserire il codice seguente dopo la creazione dei 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);

Importante

È necessario modificare il percorso delle immagini (sampleDataRoot) in base alla posizione in cui è stato scaricato il repository Python SDK samples dei servizi di intelligenza artificiale di Azure.

Eseguire il training del progetto

Questo codice crea la prima iterazione del modello di previsione.

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 sottoposta a training nell'endpoint di previsione. Il nome assegnato all'iterazione pubblicata può essere usato per inviare le richieste di stima. L'iterazione è disponibile nell'endpoint di stima solo dopo che è stata pubblicata.

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

Testare l'endpoint di stima

Per inviare un'immagine all'endpoint di previsione e recuperare la previsione, 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 di Visione personalizzata e chiamarla.

})()

Eseguire l'applicazione

Eseguire l'applicazione con il comando node nel file quickstart.

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 vedere lo stato corrente del progetto appena creato.

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

Nel sito Web di Visione personalizzata passare a Projects e selezionare l'icona del cestino sotto My New Project.

Passaggi successivi

È stato illustrato come è possibile eseguire ogni passaggio del processo di rilevamento degli oggetti nel codice. Questo esempio esegue una sola iterazione del training, ma spesso è necessario eseguire il training e il test del modello più volte per ottenere una maggiore precisione.

Testare un modello e ripeterne il training

• Che cos'è Visione personalizzata?
• Il codice sorgente per questo esempio è disponibile su GitHub
• Documentazione di riferimento sull'SDK (esercitazione)
• Documentazione di riferimento sull'SDK (previsione)

Introduzione alla libreria client di Visione personalizzata per Python. Seguire questi passaggi per installare il pacchetto e provare il codice di esempio per creare un modello di classificazione immagini. Si creerà un progetto, si aggiungeranno tag, si eseguirà il training del progetto e si userà l'URL dell'endpoint di stima del progetto per testarlo a livello di codice. Usare questo esempio come modello per la creazione di un'app di riconoscimento immagini personalizzata.

Nota

Se si vuole creare un modello di classificazione ed eseguirne il training senza scrivere codice, vedere invece le istruzioni basate sul browser.

Usare la libreria client di Visione personalizzata per Python per:

• Creare un nuovo progetto Visione personalizzata
• Aggiungere tag al progetto
• Caricare e contrassegnare le immagini
• Eseguire il training del progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di stima

Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (PyPI) | Esempi

Prerequisiti

• Sottoscrizione di Azure: creare un account gratuito
• Python 3.x
  • L'installazione di Python deve includere pip. È possibile verificare se pip è installato eseguendo pip --version nella riga di comando. Ottenere pip installando la versione più recente di Python.
• Dopo aver creato la sottoscrizione di Azure, creare una risorsa Visione personalizzata nel portale di Azure per creare una risorsa di training e stima.
  • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento 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.

Vai al portale di Azure. Se le risorse 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 chiave ed endpoint delle risorse, in Gestione risorse. È necessario ottenere le chiavi sia per le risorse di training che per le risorse di stima, insieme agli endpoint API.

È possibile trovare l'ID risorsa di stima nella scheda Proprietà della risorsa di stima nella portale di Azure, elencata come ID risorsa.

Suggerimento

È anche possibile usare https://www.customvision.ai/ per ottenere questi valori. Dopo aver eseguito l'accesso, selezionare l'icona Impostazioni in alto a destra. Nelle pagine Impostazione è possibile visualizzare tutte le chiavi, l'ID risorsa e gli endpoint.

Attenzione

Non includere la chiave direttamente nel codice e non pubblicarla pubblicamente. Per altre opzioni di autenticazione come Azure Key Vault, vedere l'articolo sicurezza dei servizi di intelligenza artificiale di Azure.

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

1. Per impostare la VISION_TRAINING KEY variabile di ambiente, sostituire your-training-key con una delle chiavi per la risorsa di training.
2. Per impostare la VISION_TRAINING_ENDPOINT variabile di ambiente, sostituire your-training-endpoint con l'endpoint per la risorsa di training.
3. Per impostare la VISION_PREDICTION_KEY variabile di ambiente, sostituire your-prediction-key con una delle chiavi per la risorsa di stima.
4. Per impostare la VISION_PREDICTION_ENDPOINT variabile di ambiente, sostituire your-prediction-endpoint con l'endpoint per la risorsa di stima.
5. Per impostare la VISION_PREDICTION_RESOURCE_ID variabile di ambiente, sostituire your-resource-id con l'ID risorsa per la risorsa di stima.

Windows

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

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare tutti i programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

Linux

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

Dopo avere aggiunto le variabili di ambiente, eseguire source ~/.bashrc dalla finestra della console per rendere effettive le modifiche.

Configurazione

Installare la libreria client

Per scrivere un'app di analisi immagini con Visione personalizzata per Python, è necessaria la libreria client di Visione personalizzata. Dopo l'installazione di 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

Suggerimento

Si vuole visualizzare l'intero file di codice dell'argomento di avvio rapido? È possibile trovarlo in GitHub, che contiene gli esempi di codice di questo argomento.

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

# retrieve environment variables
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"]

Modello a oggetti

Nome	Descrizione
CustomVisionTrainingClient	Questa classe gestisce la creazione, il training e la pubblicazione dei modelli.
CustomVisionPredictionClient	Questa classe gestisce l'esecuzione di query sui modelli per le previsioni di classificazione immagini.
ImagePrediction	Questa classe definisce una singola previsione di oggetto in una singola immagine. Include le proprietà per l'ID e il nome dell'oggetto, la posizione del rettangolo di delimitazione dell'oggetto e un punteggio di attendibilità.

Esempi di codice

Questi frammenti di codice mostrano come eseguire le attività 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
• Eseguire il training del progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di stima

Autenticare il client

Creare un'istanza dei client di training e di previsione con l'endpoint e le chiavi. Creare oggetti ApiKeyServiceClientCredentials con le chiavi e usarli con l'endpoint per creare un oggetto CustomVisionTrainingClient e CustomVisionPredictionClient.

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

Creare un nuovo progetto Visione personalizzata

Per creare un nuovo progetto di Servizio visione artificiale personalizzato, aggiungere il codice seguente allo script.

Per specificare altre opzioni quando si crea il progetto, come illustrato in Creare un classificatore nella guida al portale Web, vedere il metodo create_project.

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 le immagini

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

Per aggiungere le immagini di esempio al progetto, inserire il codice seguente dopo la creazione dei 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)

Nota

Sarà necessario modificare il percorso delle immagini in base alla posizione in cui è stato scaricato il repository Python SDK samples dei servizi di intelligenza artificiale di Azure.

Eseguire il training del progetto

Questo codice crea la prima iterazione del modello di previsione.

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)

Suggerimento

Eseguire il training con i tag selezionati

Facoltativamente, è possibile eseguire il training solo su un subset dei tag applicati. Questa operazione può essere eseguita se non è ancora stato applicato un numero sufficiente di determinati tag, ma si dispone di un numero sufficiente di altri. Nella chiamata train_project impostare il parametro opzionale selected_tags su un elenco di stringhe di ID dei tag da usare. Il modello eseguirà il training in modo da riconoscere solo i tag nell'elenco.

Pubblicare l'iterazione corrente

L'iterazione è disponibile nell'endpoint di stima solo dopo che è stata 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 stima

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(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 CustomVisionQuickstart.py.

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 vedere lo stato corrente del progetto appena creato.

Pulire le risorse

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

Nel sito Web di Visione personalizzata passare a Projects e selezionare l'icona del cestino sotto My New Project.

Passaggi successivi

In questa guida si è appreso come eseguire ogni passaggio del processo di classificazione delle immagini nel codice. Questo esempio esegue una sola iterazione del training, ma spesso è necessario eseguire il training e il test del modello più volte per ottenere una maggiore precisione.

Testare un modello e ripeterne il training

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

Introduzione all'API REST Visione personalizzata. Seguire questa procedura per chiamare l'API e creare un modello di classificazione immagini. Si creerà un progetto, si aggiungeranno tag, si eseguirà il training del progetto e si userà l'URL dell'endpoint di stima del progetto per testarlo a livello di codice. Usare questo esempio come modello per la creazione di un'app di riconoscimento immagini personalizzata.

Nota

Visione personalizzata è più facile da usare tramite un SDK della libreria client o tramite le linee guida basate su browser.

Usare la libreria client di Visione personalizzata per .NET per:

• Creare un nuovo progetto Visione personalizzata
• Aggiungere tag al progetto
• Caricare e contrassegnare le immagini
• Eseguire il training del progetto
• Pubblicare l'iterazione corrente
• Testare l'endpoint di stima

Prerequisiti

• Sottoscrizione di Azure: creare un account gratuito
• Dopo aver creato la sottoscrizione di Azure, creare una risorsa Visione personalizzata nel portale di Azure per creare una risorsa di training e stima e ottenere le chiavi e l'endpoint. Attendere che venga distribuita e fare clic sul pulsante Vai alla risorsa.
  • La chiave e l'endpoint delle risorse create sono necessari per connettere l'applicazione a Visione personalizzata. La chiave e l'endpoint verranno incollati nel codice riportato di seguito nell'argomento di avvio rapido.
  • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.
• PowerShell versione 6.0+o un'applicazione della riga di comando simile.

Creare un nuovo progetto Visione personalizzata

Verrà usato un comando come il seguente per creare un progetto di classificazione immagini. 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 il tasto Viso valido.
• Sostituire {endpoint} con l'endpoint corrispondente alla chiave.

  Nota

  Le nuove risorse create dopo il 1° luglio 2019 useranno nomi di sottodomini personalizzati. Per altre informazioni e un elenco completo degli endpoint a livello di area, vedere Nomi di sottodomini personalizzati per i servizi di intelligenza artificiale di Azure.

• Sostituire {name} con il nome del progetto.
• Facoltativamente, impostare altri parametri URL per configurare il tipo di modello che userà il progetto. Per le opzioni, vedere l'API CreatProject.

Viene restituita una risposta JSON simile alla seguente. Salvare il valore "id" del progetto in una posizione temporanea.

{
  "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 in base a cui eseguire il training del modello.

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

• Inserire di nuovo la 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 restituita una risposta JSON simile alla seguente. Salvare il valore "id" di ogni tag in una posizione temporanea.

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

Caricare e contrassegnare le immagini

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

Usare il comando seguente per caricare le immagini e applicare i tag, tutti in una volta per le immagini "Hemlock" e separatamente per le immagini "Japanese Cherry". Per altre opzioni, vedere l'API Create Images From Data.

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

• Inserire di nuovo la chiave e l'URL dell'endpoint.
• Sostituire {projectId} con il proprio ID progetto.
• Sostituire {tagArray} con l'ID di un tag.
• Quindi, popolare il corpo della richiesta con i dati binari delle immagini a cui applicare i tag.

Eseguire il training del progetto

Questo metodo esegue il training del modello nelle immagini con tag che sono state 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"

• Inserire di nuovo la chiave e l'URL dell'endpoint.
• Sostituire {projectId} con il proprio ID progetto.
• Sostituire {tagArray} con l'ID di un tag.
• Quindi, popolare il corpo della richiesta con i dati binari delle immagini a cui applicare i tag.
• Facoltativamente, usare altri parametri URL. Per le opzioni, vedere l'API Train Project.

Suggerimento

Eseguire il training con i tag selezionati

Facoltativamente, è possibile eseguire il training solo su un subset dei tag applicati. Questa operazione può essere eseguita se non è ancora stato applicato un numero sufficiente di determinati tag, ma si dispone di un numero sufficiente di altri. Aggiungere il contenuto JSON facoltativo al corpo della richiesta. Popolare la matrice "selectedTags" con gli ID dei tag da usare.

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

La risposta JSON contiene informazioni sul progetto di cui è stato eseguito il training, incluso l'ID 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. Usare il nome del modello restituito come riferimento per inviare richieste di previsione.

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

• Inserire di nuovo la 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 da assegnare al modello di previsione.
• Sostituire {predictionId} con l'ID risorsa di previsione. È possibile trovare l'ID risorsa di stima nella scheda Proprietà della risorsa nella portale di Azure, elencata come ID risorsa.
• Facoltativamente, usare altri parametri URL. Vedere l'APIPublish Iteration.

Testare l'endpoint di stima

Infine, usare questo comando per testare il modello di cui è stato eseguito il training caricando una nuova immagine per la classificazione con i tag. È possibile usare l'immagine nella cartella "Test" dei file di esempio scaricata 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}"

• Inserire di nuovo la 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 Classify Image.

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 il proprio progetto di classificazione delle immagini (o provare un progetto di rilevamento degli oggetti), è possibile eliminare il progetto di identificazione degli alberi da questo esempio. Una sottoscrizione gratuita consente di creare due progetti di Visione personalizzata.

Nel sito Web di Visione personalizzata passare a Projects e selezionare l'icona del cestino sotto My New Project.

Passaggi successivi

A questo punto, sono stati eseguiti tutti i passaggi del processo di classificazione immagini usando l'API REST. Questo esempio esegue una sola iterazione del training, ma spesso è necessario eseguire il training e il test del modello più volte per ottenere una maggiore precisione.

Testare un modello e ripeterne il training

• Che cos'è Visione personalizzata?
• Documentazione di riferimento delle API (training)
• Documentazione di riferimento delle API (previsione)