Início rápido: Crie um projeto de classificação de imagens com o Custom Vision SDK ou API REST

Comece a usar a biblioteca cliente Custom Vision para .NET. Siga estes passos para instalar o pacote e experimentar o código de exemplo para construir um modelo de classificação de imagens. Pode criar um projeto, adicionar tags, treinar o projeto e usar a URL do endpoint de previsão do projeto para o testar programaticamente. Use este exemplo como modelo para criar a sua própria aplicação de reconhecimento de imagens.

Documentação de referência | Código-fonte da biblioteca para training e prediction | Pacote (NuGet) para training e prediction | Samples

Pré-requisitos

• Uma subscrição do Azure. Podes criar um gratuitamente.
• A versão Visual Studio IDE ou atual de .NET Core.
• Depois de ter a sua subscrição Azure, crie um recurso Custom Vision no portal Azure para criar um recurso de treino e um recurso de previsão.
  • Podes usar o escalão de preços gratuito (F0) para experimentar o serviço, e depois fazer um upgrade para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, vais escrever as tuas credenciais para variáveis de ambiente na máquina local que executa a aplicação.

Vai ao portal do Azure. Se os recursos de Visão Personalizada que criou na secção de Pré-requisitos foram implementados com sucesso, selecione o botão Ir para Recursos em Próximos passos. Pode encontrar as suas chaves e endpoints nas páginas de Chaves e Endpoints dos recursos, em Gestão de Recursos. Vais precisar de obter as chaves tanto do teu recurso de treino como do recurso de previsão, juntamente com os endpoints da API.

Pode encontrar o ID do recurso de previsão no separador Properties do recurso de previsão no portal Azure, listado como ID de Recursos.

Para definir as variáveis de ambiente, abra uma janela de consola e siga as instruções do seu sistema operativo e ambiente de desenvolvimento.

• Para definir a VISION_TRAINING KEY variável de ambiente, substitua <your-training-key> por uma das chaves do seu recurso de treino.
• Para definir a VISION_TRAINING_ENDPOINT variável de ambiente, substitua <your-training-endpoint> pelo endpoint do seu recurso de treino.
• Para definir a VISION_PREDICTION_KEY variável de ambiente, substitui <your-prediction-key> por uma das chaves do teu recurso de previsão.
• Para definir a VISION_PREDICTION_ENDPOINT variável de ambiente, substitui <your-prediction-endpoint> pelo endpoint do teu recurso de previsão.
• Para definir a VISION_PREDICTION_RESOURCE_ID variável de ambiente, substitua <your-resource-id> pelo ID do recurso para o seu recurso de previsão.

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>

Preparação

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

A partir do diretório do projeto, abra o ficheiro program.cs e adicione as seguintes using diretivas:

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;

No método da main aplicação, crie variáveis que recuperem as chaves e endpoints do seu recurso a partir das variáveis do ambiente. Também vais declarar alguns objetos básicos para serem usados mais tarde.

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

No método da main aplicação, adicione chamadas para os métodos usados neste início rápido. Implementas isto mais tarde.

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

Autenticar o cliente

Num método novo, instância clientes de treino e previsão usando o seu endpoint e chaves.

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

Criar um novo projeto Custom Vision

Este próximo pedaço de código cria um projeto de classificação de imagens. O projeto criado aparece no site da Custom Vision. Consulte o método CreateProject para especificar outras opções quando criar o seu projeto (explicado no guia do portal web Build a classifier ).

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

Adicionar etiquetas ao projeto

Este método define as etiquetas em que treinas o modelo.

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

Carregar e etiquetar imagens

Primeiro, descarregue as imagens de exemplo deste projeto. Guarda o conteúdo da pasta Imagens exemplo no teu dispositivo local.

Depois defina um método auxiliar para carregar as imagens nesse diretório. Podes precisar de editar o GetFiles argumento para apontar para o local onde as tuas imagens são guardadas.

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

De seguida, defina um método para carregar as imagens, aplicando etiquetas de acordo com a localização da sua pasta. As imagens já estão organizadas. Pode carregar e etiquetar imagens iterativamente, ou em lote (até 64 por lote). Este excerto de código contém exemplos de ambos.

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

}

Treine o projeto

Este método cria a primeira iteração de treino no projeto. Consulta o serviço até que a formação seja concluída.

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

Publicar a iteração atual

Este método disponibiliza a iteração atual do modelo para consulta. Pode usar o nome do modelo como referência para enviar pedidos de previsão. Precisa de inserir o seu próprio valor para predictionResourceId. Pode encontrar o ID de recurso de previsão no separador Properties do recurso no portal Azure, listado como Resource ID.

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
}

Testar o ponto final da previsão

Esta parte do script carrega a imagem de teste, consulta o endpoint do modelo e envia dados de previsão para a consola.

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

Executar a aplicação

dotnet run

À medida que a aplicação é executada, deve abrir uma janela de consola e escrever a seguinte saída:

Creating new project:
        Uploading images
        Training
Done!

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

Pode então verificar se a imagem de teste (encontrada em Imagens/Teste/) está devidamente marcada. Carregue em qualquer tecla para sair da aplicação. Também pode voltar ao site da Custom Vision e ver o estado atual do seu projeto recém-criado.

Recursos de limpeza

Se quiser implementar o seu próprio projeto de classificação de imagens (ou tentar um projeto de deteção de objetos ), pode querer eliminar o projeto de identificação de árvores deste exemplo. Uma subscrição gratuita permite dois projetos Custom Vision.

No site Custom Vision, navegue até Projects e selecione o caixote do lixo em My New Project.

Conteúdo relacionado

Agora já viste como cada etapa do processo de deteção de objetos pode ser feita em código. Este exemplo executa uma única iteração de treino, mas muitas vezes terá de treinar e testar o seu modelo várias vezes para o tornar mais preciso.

• O que é a Visão Personalizada?
• O código-fonte deste exemplo pode ser encontrado em GitHub
• Documentação de referência do SDK

Este guia fornece instruções e código de exemplo para o ajudar a começar a usar a biblioteca cliente Custom Vision para o Go para construir um modelo de classificação de imagens. Vais criar um projeto, adicionar etiquetas, treinar o projeto e usar a URL do endpoint de previsão do projeto para o testar programaticamente. Use este exemplo como modelo para criar a sua própria aplicação de reconhecimento de imagens.

Use a biblioteca cliente Custom Vision para ir a:

• Criar um novo projeto Custom Vision
• Adicionar etiquetas ao projeto
• Carregar e etiquetar imagens
• Treine o projeto
• Publicar a iteração atual
• Testar o ponto final da previsão

Documentação de referência para (treino) e (previsão)

Pré-requisitos

• Uma subscrição do Azure. Podes criar um gratuitamente.
• Vai para 1.8 ou mais tarde.
• Depois de ter a sua subscrição Azure, crie um recurso Custom Vision no portal Azure para criar um recurso de treino e previsão.
  • Podes usar o escalão de preços gratuito (F0) para experimentar o serviço, e depois fazer um upgrade para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, vais escrever as tuas credenciais para variáveis de ambiente na máquina local que executa a aplicação.

Vai ao portal do Azure. Se os recursos de Visão Personalizada que criou na secção de Pré-requisitos foram implementados com sucesso, selecione o botão Ir para Recursos em Próximos passos. Pode encontrar as suas chaves e endpoints nas páginas de Chaves e Endpoints dos recursos, em Gestão de Recursos. Vais precisar de obter as chaves tanto do teu recurso de treino como do recurso de previsão, juntamente com os endpoints da API.

Pode encontrar o ID do recurso de previsão no separador Properties do recurso de previsão no portal Azure, listado como ID de Recursos.

Para definir as variáveis de ambiente, abra uma janela de consola e siga as instruções do seu sistema operativo e ambiente de desenvolvimento.

• Para definir a VISION_TRAINING KEY variável de ambiente, substitua <your-training-key> por uma das chaves do seu recurso de treino.
• Para definir a VISION_TRAINING_ENDPOINT variável de ambiente, substitua <your-training-endpoint> pelo endpoint do seu recurso de treino.
• Para definir a VISION_PREDICTION_KEY variável de ambiente, substitui <your-prediction-key> por uma das chaves do teu recurso de previsão.
• Para definir a VISION_PREDICTION_ENDPOINT variável de ambiente, substitui <your-prediction-endpoint> pelo endpoint do teu recurso de previsão.
• Para definir a VISION_PREDICTION_RESOURCE_ID variável de ambiente, substitua <your-resource-id> pelo ID do recurso para o seu recurso de previsão.

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>

Preparação

Instalar a biblioteca cliente Custom Vision

Para escrever uma aplicação de análise de imagem com o Custom Vision for Go, precisa da biblioteca de clientes do serviço Custom Vision. Execute o seguinte comando no PowerShell:

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

Ou se usares dep, dentro da tua execução de repositório:

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

Obtenha as imagens de exemplo

Este exemplo utiliza as imagens do repositório Foundry Tools Python SDK Samples no GitHub. Clone ou descarregue este repositório para o seu ambiente de desenvolvimento. Lembra-te da localização da pasta para um passo posterior.

Criar o projeto Custom Vision

Cria um novo ficheiro chamado sample.go no diretório do teu projeto preferido e abre-o no editor de código que preferires.

Adicione o seguinte código ao seu script para criar um novo projeto de serviço Custom Vision.

Consulte o método CreateProject para especificar outras opções quando criar o seu projeto (explicado no guia do portal web Build a classifier ).

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

Criar etiquetas no projeto

Para criar etiquetas de classificação para o seu projeto, adicione o seguinte código ao final do 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))

Carregar e etiquetar imagens

Para adicionar as imagens de exemplo ao projeto, insira o código seguinte após a criação da etiqueta. Este código carrega cada imagem com a sua etiqueta correspondente. Pode carregar até 64 imagens num único lote.

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

Formar e publicar o projeto

Este código cria a primeira iteração do modelo de previsão e depois publica essa iteração para o ponto final de previsão. O nome dado à iteração publicada pode ser usado para enviar pedidos de previsão. Uma iteração não está disponível no endpoint de previsão até ser publicada.

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

Usar o endpoint de previsão

Para enviar uma imagem para o endpoint da previsão e recuperar a previsão, adicione o seguinte código ao final do ficheiro:

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

Executar a aplicação

Execute a aplicação usando o seguinte comando:

go run sample.go

O resultado da aplicação deve ser semelhante ao seguinte texto:

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%

Pode então verificar se a imagem de teste (encontrada em <base_image_url>/Imagens/Test/) está devidamente etiquetada. Também pode voltar ao site da Custom Vision e ver o estado atual do seu projeto recém-criado.

Recursos de limpeza

Se quiser implementar o seu próprio projeto de classificação de imagens (ou tentar um projeto de deteção de objetos ), pode querer eliminar o projeto de identificação de árvores deste exemplo. Uma subscrição gratuita permite dois projetos Custom Vision.

No site Custom Vision, navegue até Projects e selecione o caixote do lixo em My New Project.

Conteúdo relacionado

Agora já viste como cada etapa do processo de deteção de objetos pode ser feita em código. Este exemplo executa uma única iteração de treino, mas muitas vezes terá de treinar e testar o seu modelo várias vezes para o tornar mais preciso.

• O que é a Visão Personalizada?
• SDK documentação de referência (formação)
• SDK documentação de referência (previsão)

Comece a usar a biblioteca cliente Custom Vision para Java para construir um modelo de classificação de imagens. Segue estes passos para instalar o pacote e experimenta o código de exemplo para tarefas básicas. Use este exemplo como modelo para criar a sua própria aplicação de reconhecimento de imagens.

Use a biblioteca cliente Custom Vision para Java para:

• Criar um novo projeto Custom Vision
• Adicionar etiquetas ao projeto
• Carregar e etiquetar imagens
• Treine o projeto
• Publicar a iteração atual
• Testar o ponto final da previsão

Documentação de referência | Código-fonte da biblioteca para (treino) e (previsão)| Artefacto (Maven) para (treino) e (previsão) | Amostras

Pré-requisitos

• Uma subscrição do Azure. Podes criar um gratuitamente.
• A versão atual do Kit de Desenvolvimento Java (JDK).
• A ferramenta de build Gradle, ou outro gestor de dependências.
• Depois de ter a sua subscrição Azure, crie um recurso Custom Vision no portal Azure para criar um recurso de treino e previsão.
  • Podes usar o escalão de preços gratuito (F0) para experimentar o serviço, e depois fazer um upgrade para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, vais escrever as tuas credenciais para variáveis de ambiente na máquina local que executa a aplicação.

Vai ao portal do Azure. Se os recursos de Visão Personalizada que criou na secção de Pré-requisitos foram implementados com sucesso, selecione o botão Ir para Recursos em Próximos passos. Pode encontrar as suas chaves e endpoints nas páginas de Chaves e Endpoints dos recursos, em Gestão de Recursos. Vais precisar de obter as chaves tanto do teu recurso de treino como do recurso de previsão, juntamente com os endpoints da API.

Pode encontrar o ID do recurso de previsão no separador Properties do recurso de previsão no portal Azure, listado como ID de Recursos.

Para definir as variáveis de ambiente, abra uma janela de consola e siga as instruções do seu sistema operativo e ambiente de desenvolvimento.

• Para definir a VISION_TRAINING KEY variável de ambiente, substitua <your-training-key> por uma das chaves do seu recurso de treino.
• Para definir a VISION_TRAINING_ENDPOINT variável de ambiente, substitua <your-training-endpoint> pelo endpoint do seu recurso de treino.
• Para definir a VISION_PREDICTION_KEY variável de ambiente, substitui <your-prediction-key> por uma das chaves do teu recurso de previsão.
• Para definir a VISION_PREDICTION_ENDPOINT variável de ambiente, substitui <your-prediction-endpoint> pelo endpoint do teu recurso de previsão.
• Para definir a VISION_PREDICTION_RESOURCE_ID variável de ambiente, substitua <your-resource-id> pelo ID do recurso para o seu recurso de previsão.

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>

Preparação

Criar um novo projeto Gradle

Numa janela de consola (como cmd, PowerShell ou Bash), crie um novo diretório para a sua aplicação e navegue até lá.

mkdir myapp && cd myapp

Executa o gradle init comando a partir do teu diretório de trabalho. Este comando cria ficheiros de compilação essenciais para o Gradle, incluindo build.gradle.kts, que é usado em tempo de execução para criar e configurar a sua aplicação.

gradle init --type basic

Quando solicitado a escolher um DSL, selecione Kotlin.

Instalar a biblioteca cliente

Localiza build.gradle.kts e abre-o com o teu IDE ou editor de texto preferido. Depois copia a configuração de build seguinte. Esta configuração define o projeto como uma aplicação Java cujo ponto de entrada é a classe CustomVisionQuickstart. Importa as bibliotecas Custom Vision.

plugins {
    java
    application
}
application { 
    mainClassName = "CustomVisionQuickstart"
}
repositories {
    mavenCentral()
}
dependencies {
    compile(group = "com.azure", name = "azure-cognitiveservices-customvision-training", version = "1.1.0-preview.2")
    compile(group = "com.azure", name = "azure-cognitiveservices-customvision-prediction", version = "1.1.0-preview.2")
}

Criar um ficheiro Java

A partir do seu diretório de trabalho, execute o seguinte comando para criar uma pasta de origem do projeto:

mkdir -p src/main/java

Navega até à nova pasta e cria um ficheiro chamado CustomVisionQuickstart.java. Abra-o no seu editor ou IDE preferido e adicione as seguintes import instruções:

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;

Na classe da CustomVisionQuickstart aplicação, crie variáveis que recuperem as chaves e o endpoint do seu recurso a partir das variáveis do 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");

No método da main aplicação, adicione chamadas para os métodos usados neste início rápido. Vais definir estas coisas mais tarde.

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

Modelo de objetos

As seguintes classes e interfaces lidam com algumas das principais funcionalidades da biblioteca cliente Custom Vision Java.

Exemplos de código

Estes excertos de código mostram-lhe como realizar as seguintes tarefas com a biblioteca cliente Custom Vision para Java:

• Autenticar o cliente
• Criar um novo projeto Custom Vision
• Adicionar etiquetas ao projeto
• Carregar e etiquetar imagens
• Treine o projeto
• Publicar a iteração atual
• Testar o ponto final da previsão

Autenticar o cliente

No seu main método, instância clientes de treino e previsão usando o seu endpoint e chaves.

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

Criar um projeto Visão Personalizada

Este método seguinte cria um projeto de classificação de imagens. O projeto criado aparecerá no site da Custom Vision que visitou anteriormente. Consulte o método CreateProject overloads para especificar outras opções quando cria o seu projeto (explicado no guia do portal 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;
}

Adicione tags ao seu projeto

Este método define as etiquetas sobre as quais irá treinar o modelo.

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

Carregar e etiquetar imagens

Primeiro, descarregue as imagens de exemplo deste projeto. Guarda o conteúdo da pasta Imagens exemplo no teu dispositivo local.

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

O excerto de código anterior utiliza duas funções auxiliares que recuperam as imagens como fluxos de recursos e as carregam para o serviço (podes carregar até 64 imagens num único lote).

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

Treine o projeto

Este método cria a primeira iteração de treino no projeto. Consulta o serviço até que a formação seja concluída.

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

Publicar a iteração atual

Este método disponibiliza a iteração atual do modelo para consulta. Pode usar o nome do modelo como referência para enviar pedidos de previsão. Precisa de inserir o seu próprio valor para predictionResourceId. Pode encontrar o ID de recurso de previsão no separador Properties do recurso no portal Azure, listado como Resource ID.

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

Testar o ponto final da previsão

Este método carrega a imagem de teste, consulta o endpoint do modelo e envia dados de previsão para a consola.

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

Executar a aplicação

Pode construir a aplicação com:

gradle build

Execute a aplicação com o gradle run comando:

gradle run

Recursos de limpeza

Se quiseres limpar e remover uma subscrição de Serviços de IA do Azure, podes eliminar o recurso ou grupo de recursos. Eliminar o grupo de recursos também elimina quaisquer outros recursos associados a ele.

• Azure
• CLI do Azure

Se quiser implementar o seu próprio projeto de classificação de imagens (ou tentar um projeto de deteção de objetos ), pode querer eliminar o projeto de identificação de árvores deste exemplo. Uma subscrição gratuita permite dois projetos Custom Vision.

No site Custom Vision, navegue até Projects e selecione o caixote do lixo em My New Project.

Conteúdo relacionado

Agora já viste como cada etapa do processo de deteção de objetos pode ser feita em código. Este exemplo executa uma única iteração de treino, mas muitas vezes terá de treinar e testar o seu modelo várias vezes para o tornar mais preciso.

• O que é a Visão Personalizada?
• O código-fonte deste exemplo pode ser encontrado em GitHub

Este guia fornece instruções e código de exemplo para o ajudar a começar a usar a biblioteca cliente Custom Vision para Node.js construir um modelo de classificação de imagens. Podes criar um projeto, adicionar etiquetas, treinar o projeto e usar a URL do endpoint de previsão do projeto para o testar programaticamente. Use este exemplo como modelo para criar a sua própria aplicação de reconhecimento de imagens.

Use a biblioteca cliente Custom Vision para Node.js para:

• Criar um novo projeto Custom Vision
• Adicionar etiquetas ao projeto
• Carregar e etiquetar imagens
• Treine o projeto
• Publicar a iteração atual
• Testar o ponto final da previsão

Documentação de referência para (treino) e (previsão) | Pacote (npm) para (treino) e (previsão) | Samples

Pré-requisitos

• Uma subscrição do Azure. Podes criar um gratuitamente.
• A versão atual de Node.js.
• Depois de ter a sua subscrição Azure, crie um recurso Custom Vision no portal Azure para criar um recurso de treino e previsão.
  • Podes usar o escalão de preços gratuito (F0) para experimentar o serviço, e depois fazer um upgrade para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, vais escrever as tuas credenciais para variáveis de ambiente na máquina local que executa a aplicação.

Vai ao portal do Azure. Se os recursos de Visão Personalizada que criou na secção de Pré-requisitos foram implementados com sucesso, selecione o botão Ir para Recursos em Próximos passos. Pode encontrar as suas chaves e endpoints nas páginas de Chaves e Endpoints dos recursos, em Gestão de Recursos. Vais precisar de obter as chaves tanto do teu recurso de treino como do recurso de previsão, juntamente com os endpoints da API.

Pode encontrar o ID do recurso de previsão no separador Properties do recurso de previsão no portal Azure, listado como ID de Recursos.

Para definir as variáveis de ambiente, abra uma janela de consola e siga as instruções do seu sistema operativo e ambiente de desenvolvimento.

• Para definir a VISION_TRAINING KEY variável de ambiente, substitua <your-training-key> por uma das chaves do seu recurso de treino.
• Para definir a VISION_TRAINING_ENDPOINT variável de ambiente, substitua <your-training-endpoint> pelo endpoint do seu recurso de treino.
• Para definir a VISION_PREDICTION_KEY variável de ambiente, substitui <your-prediction-key> por uma das chaves do teu recurso de previsão.
• Para definir a VISION_PREDICTION_ENDPOINT variável de ambiente, substitui <your-prediction-endpoint> pelo endpoint do teu recurso de previsão.
• Para definir a VISION_PREDICTION_RESOURCE_ID variável de ambiente, substitua <your-resource-id> pelo ID do recurso para o seu recurso de previsão.

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>

Preparação

Criar uma nova aplicação Node.js

Numa janela de consola (como cmd, PowerShell ou Bash), crie um novo diretório para a sua aplicação e navegue até lá.

mkdir myapp && cd myapp

Execute o npm init comando para criar uma aplicação de nó com um package.json ficheiro. Pressione ENTER várias vezes para completar o processo.

npm init

Instalar a biblioteca cliente

Para escrever uma aplicação de análise de imagem com Custom Vision para Node.js, precisa dos pacotes Custom Vision npm. Para os instalar, execute o seguinte comando no PowerShell:

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

O ficheiro da package.json tua aplicação é atualizado com as dependências.

Crie um ficheiro nomeado index.js e importe as seguintes bibliotecas:

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

Crie variáveis para o endpoint Azure e as chaves do seu recurso.

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

Também adiciona campos para o nome do teu projeto e um parâmetro de timeout para chamadas assíncronas.

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

Modelo de objetos

Exemplos de código

Estes excertos de código mostram-lhe como realizar as seguintes tarefas com a biblioteca cliente Custom Vision para JavaScript:

• Autenticar o cliente
• Criar um novo projeto Custom Vision
• Adicionar etiquetas ao projeto
• Carregar e etiquetar imagens
• Treine o projeto
• Publicar a iteração atual
• Testar o ponto final da previsão

Autenticar o cliente

Instancia os objetos do cliente com o teu endpoint e chave. Crie um objeto ApiKeyCredentials com a sua chave e use-o com o seu endpoint para criar um objeto 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);

Criar um novo projeto Custom Vision

Inicie uma nova função para conter todas as suas chamadas de função Custom Vision. Adicione o código seguinte para criar um novo projeto de serviço Custom Vision.

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

Adicionar etiquetas ao projeto

Para criar etiquetas de classificação para o seu projeto, adicione o seguinte código à sua função:

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

Carregar e etiquetar imagens

Primeiro, descarregue as imagens de exemplo deste projeto. Guarda o conteúdo da pasta Imagens exemplo no teu dispositivo local.

Para adicionar as imagens de exemplo ao projeto, insira o código seguinte após a criação da etiqueta. Este código carrega cada imagem com a sua etiqueta correspondente.

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

Treine o projeto

Este código cria a primeira iteração do modelo de previsão.

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

Publicar a iteração atual

Este código publica a iteração treinada para o endpoint de previsão. O nome dado à iteração publicada pode ser usado para enviar pedidos de previsão. Uma iteração não está disponível no endpoint de previsão até ser publicada.

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

Testar o ponto final da previsão

Para enviar uma imagem para o endpoint de previsão e recuperar a previsão, adicione o seguinte código à sua função.

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

Depois, fecha a função de Visão Personalizada e chama-a.

})()

Executar a aplicação

Executa a aplicação com o node comando no teu ficheiro de início rápido.

node index.js

O resultado da aplicação deve ser semelhante ao seguinte texto:

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%

Pode então verificar se a imagem de teste (encontrada em <sampleDataRoot>/Test/) está devidamente marcada. Também pode voltar ao site da Custom Vision e ver o estado atual do seu projeto recém-criado.

Se quiser implementar o seu próprio projeto de classificação de imagens (ou tentar um projeto de deteção de objetos ), pode querer eliminar o projeto de identificação de árvores deste exemplo. Uma subscrição gratuita permite dois projetos Custom Vision.

No site Custom Vision, navegue até Projects e selecione o caixote do lixo em My New Project.

Conteúdo relacionado

Este guia mostra como cada etapa do processo de deteção de objetos pode ser feita em código. Este exemplo executa uma única iteração de treino, mas muitas vezes terá de treinar e testar o seu modelo várias vezes para o tornar mais preciso.

• O que é a Visão Personalizada?
• O código-fonte deste exemplo pode ser encontrado em GitHub
• SDK documentação de referência (formação)
• SDK documentação de referência (previsão)

Comece a usar a biblioteca cliente Custom Vision para Python. Siga estes passos para instalar o pacote e experimentar o código de exemplo para construir um modelo de classificação de imagens. Vais criar um projeto, adicionar etiquetas, treinar o projeto e usar a URL do endpoint de previsão do projeto para o testar programaticamente. Use este exemplo como modelo para criar a sua própria aplicação de reconhecimento de imagens.

Use a biblioteca cliente Custom Vision para Python para:

• Criar um novo projeto Custom Vision
• Adicionar etiquetas ao projeto
• Carregar e etiquetar imagens
• Treine o projeto
• Publicar a iteração atual
• Testar o ponto final da previsão

Documentação de referência | código-fonte da biblioteca | Package (PyPI) | Samples

Pré-requisitos

• Uma subscrição do Azure. Podes criar um gratuitamente.
• Python 3.x.
  • A sua instalação Python deve incluir pip. Podes verificar se tens pip instalado correndo pip --version na linha de comandos. Obtenha pip instalando a versão mais recente do Python.
• Depois de ter a sua subscrição Azure, crie um recurso Custom Vision no portal Azure para criar um recurso de treino e previsão.
  • Podes usar o escalão de preços gratuito (F0) para experimentar o serviço, e depois fazer um upgrade para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, vais escrever as tuas credenciais para variáveis de ambiente na máquina local que executa a aplicação.

Vai ao portal do Azure. Se os recursos de Visão Personalizada que criou na secção de Pré-requisitos foram implementados com sucesso, selecione o botão Ir para Recursos em Próximos passos. Pode encontrar as suas chaves e endpoints nas páginas de Chaves e Endpoints dos recursos, em Gestão de Recursos. Vais precisar de obter as chaves tanto do teu recurso de treino como do recurso de previsão, juntamente com os endpoints da API.

Pode encontrar o ID do recurso de previsão no separador Properties do recurso de previsão no portal Azure, listado como ID de Recursos.

Para definir as variáveis de ambiente, abra uma janela de consola e siga as instruções do seu sistema operativo e ambiente de desenvolvimento.

• Para definir a VISION_TRAINING KEY variável de ambiente, substitua <your-training-key> por uma das chaves do seu recurso de treino.
• Para definir a VISION_TRAINING_ENDPOINT variável de ambiente, substitua <your-training-endpoint> pelo endpoint do seu recurso de treino.
• Para definir a VISION_PREDICTION_KEY variável de ambiente, substitui <your-prediction-key> por uma das chaves do teu recurso de previsão.
• Para definir a VISION_PREDICTION_ENDPOINT variável de ambiente, substitui <your-prediction-endpoint> pelo endpoint do teu recurso de previsão.
• Para definir a VISION_PREDICTION_RESOURCE_ID variável de ambiente, substitua <your-resource-id> pelo ID do recurso para o seu recurso de previsão.

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>

Preparação

Instalar a biblioteca cliente

Para escrever uma aplicação de análise de imagens com Custom Vision para Python, precisas da biblioteca cliente Custom Vision. Depois de instalar o Python, execute o seguinte comando no PowerShell ou numa janela de consola:

pip install azure-cognitiveservices-vision-customvision

Criar uma nova aplicação Python

Crie um novo ficheiro Python e importe as seguintes bibliotecas.

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

Crie variáveis para o endpoint Azure e as chaves do seu recurso.

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

Modelo de objetos

Exemplos de código

Estes excertos de código mostram-lhe como fazer o seguinte com a biblioteca cliente Custom Vision para Python:

• Autenticar o cliente
• Criar um novo projeto Custom Vision
• Adicionar etiquetas ao projeto
• Carregar e etiquetar imagens
• Treine o projeto
• Publicar a iteração atual
• Testar o ponto final da previsão

Autenticar o cliente

Instância um cliente de treino e previsão com o seu endpoint e chaves. Crie ApiKeyServiceClientCredentials objetos com as suas chaves e use-os com o seu endpoint para criar um objeto CustomVisionTrainingClient e um objeto 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)

Criar um novo projeto Custom Vision

Adicione o seguinte código ao seu script para criar um novo projeto de serviço Custom Vision.

Consulte o método create_project para especificar outras opções quando criar o seu projeto (explicado no guia do portal web Build a Classifier ).

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)

Adicionar etiquetas ao projeto

Para adicionar etiquetas de classificação ao seu projeto, adicione o seguinte código:

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

Carregar e etiquetar imagens

Primeiro, descarregue as imagens de exemplo deste projeto. Guarda o conteúdo da pasta Imagens exemplo no teu dispositivo local.

Para adicionar as imagens de exemplo ao projeto, insira o código seguinte após a criação da etiqueta. Este código carrega cada imagem com a sua etiqueta correspondente. Pode carregar até 64 imagens num único lote.

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)

Treine o projeto

Este código cria a primeira iteração do modelo de previsão.

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)

Publicar a iteração atual

Uma iteração não está disponível no endpoint de previsão até ser publicada. O código seguinte disponibiliza a iteração atual do modelo para consulta.

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

Testar o ponto final da previsão

Para enviar uma imagem para o endpoint da previsão e recuperar a previsão, adicione o seguinte código ao final do ficheiro:

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

Executar a aplicação

Execute a aplicação usando o seguinte comando:

python CustomVisionQuickstart.py

O resultado da aplicação deve ser semelhante ao seguinte texto:

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

Pode então verificar se a imagem de teste (encontrada em <base_image_location>/imagens/Test/) está devidamente etiquetada. Também pode voltar ao site da Custom Vision e ver o estado atual do seu projeto recém-criado.

Recursos de limpeza

Se quiser implementar o seu próprio projeto de classificação de imagens (ou tentar um projeto de deteção de objetos ), pode querer eliminar o projeto de identificação de árvores deste exemplo. Uma subscrição gratuita permite dois projetos Custom Vision.

No site Custom Vision, navegue até Projects e selecione o caixote do lixo em My New Project.

Conteúdo relacionado

Agora já viste como cada etapa do processo de classificação de imagens pode ser feita em código. Este exemplo executa uma única iteração de treino, mas muitas vezes terá de treinar e testar o seu modelo várias vezes para o tornar mais preciso.

• O que é a Visão Personalizada?
• O código-fonte deste exemplo pode ser encontrado em GitHub
• Documentação de referência do SDK

Comece a usar a API Custom Vision REST. Siga estes passos para chamar a API e construir um modelo de classificação de imagem. Vais criar um projeto, adicionar etiquetas, treinar o projeto e usar a URL do endpoint de previsão do projeto para o testar programaticamente. Use este exemplo como modelo para criar a sua própria aplicação de reconhecimento de imagens.

Use a biblioteca cliente Custom Vision para a API REST para:

• Criar um novo projeto Custom Vision
• Adicionar etiquetas ao projeto
• Carregar e etiquetar imagens
• Treine o projeto
• Publicar a iteração atual
• Testar o ponto final da previsão

Pré-requisitos

• Uma subscrição do Azure. Podes criar um gratuitamente.
• Depois de ter a sua subscrição Azure, crie um recurso Custom Vision no portal Azure para criar um recurso de treino e previsão.
  • Precisa da chave e do endpoint dos recursos que cria para ligar a sua aplicação ao Custom Vision. Vais colar a tua chave e endpoint no código mais tarde no quickstart.
  • Podes usar o escalão de preços gratuito (F0) para experimentar o serviço, e depois fazer um upgrade para um nível pago para produção.
• PowerShell versão 6.0+, ou uma aplicação semelhante de linha de comandos.

Criar um novo projeto Custom Vision

Vais usar um comando como o seguinte para criar um projeto de classificação de imagens. O projeto criado aparecerá no site da Custom Vision.

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

Copie o comando para um editor de texto e faça as seguintes alterações:

• Substitua {subscription key} pela sua chave válida.
• Substitui {endpoint} pelo endpoint que corresponde à tua chave.

  Nota

  Novos recursos criados após 1 de julho de 2019 irão utilizar nomes de subdomínio personalizados. Para mais informações e uma lista completa de endpoints regionais, consulte Nomes de subdomínio personalizados para Foundry Tools.

• Substitua {name} pelo nome do seu projeto.
• Opcionalmente, defina outros parâmetros de URL para configurar que tipo de modelo o seu projeto utiliza. Consulte a API Create Project para opções.

Aparece uma resposta JSON como o exemplo seguinte. Guarde o "id" valor do seu projeto para um local temporário.

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

Adicionar etiquetas ao projeto

Use o comando seguinte para definir as etiquetas em que irá treinar o modelo.

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

• Mais uma vez, insera a sua própria chave e URL do endpoint.
• Substitui {projectId} pelo teu próprio ID de projeto.
• Substitui {name} pelo nome da etiqueta que queres usar.

Repita este processo para todas as etiquetas que gostaria de usar no seu projeto. Se estiver a usar as imagens de exemplo fornecidas, adicione as etiquetas "Hemlock" e "Japanese Cherry".

Aparece uma resposta JSON como o exemplo seguinte. Guarde o "id" valor de cada etiqueta num local temporário.

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

Carregar e etiquetar imagens

De seguida, descarregue as imagens de exemplo deste projeto. Guarda o conteúdo da pasta Imagens exemplo no teu dispositivo local.

Use o seguinte comando para carregar as imagens e aplicar etiquetas; uma vez para as imagens "Hemlock" e separadamente para as imagens da "Cerejeira Japonesa". Consulte a API Criar Imagens a partir de Dados para mais opções.

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

• Mais uma vez, insera a sua própria chave e URL do endpoint.
• Substitui {projectId} pelo teu próprio ID de projeto.
• Substitua {tagArray} pelo ID de uma etiqueta.
• Depois, preenche o corpo do pedido com os dados binários das imagens que pretende etiquetar.

Treine o projeto

Este método treina o modelo com as imagens marcadas que carregou e devolve um ID para a iteração atual do projeto.

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

• Mais uma vez, insera a sua própria chave e URL do endpoint.
• Substitui {projectId} pelo teu próprio ID de projeto.
• Substitua {tagArray} pelo ID de uma etiqueta.
• Depois, preenche o corpo do pedido com os dados binários das imagens que pretende etiquetar.
• Opcionalmente, use outros parâmetros de URL. Consulte a API Train Project para opções.

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

A resposta JSON contém informações sobre o seu projeto treinado, incluindo o ID da iteração ("id"). Guarde este valor para o próximo passo.

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

Publicar a iteração atual

Este método disponibiliza a iteração atual do modelo para consulta. Usas o nome do modelo devolvido como referência para enviar pedidos de previsão.

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

• Mais uma vez, insera a sua própria chave e URL do endpoint.
• Substitui {projectId} pelo teu próprio ID de projeto.
• Substitua {iterationId} pelo ID devolvido no passo anterior.
• Substitua {publishedName} pelo nome que gostaria de atribuir ao seu modelo de previsão.
• Substitui {predictionId} pelo teu próprio ID de recurso de previsão. Pode encontrar o ID de recurso de previsão no separador Properties do recurso no portal Azure, listado como Resource ID.
• Opcionalmente, use outros parâmetros de URL. Consulte a API de Publicar Iterações .

Testar o ponto final da previsão

Por fim, use este comando para testar o seu modelo treinado, carregando uma nova imagem para que ele a classifique com etiquetas. Podes usar a imagem na pasta de Teste dos ficheiros de exemplo que descarregaste anteriormente.

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

• Mais uma vez, insera a sua própria chave e URL do endpoint.
• Substitui {projectId} pelo teu próprio ID de projeto.
• Substitui {publishedName} pelo nome que usaste na etapa anterior.
• Adicione os dados binários da sua imagem local ao corpo do pedido.
• Opcionalmente, use outros parâmetros de URL. Consulte a API de Imagens Classificadas .

A resposta JSON devolvida lista cada uma das etiquetas que o modelo aplicou à sua imagem, juntamente com as pontuações de probabilidade para cada etiqueta.

{
  "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 quiser implementar o seu próprio projeto de classificação de imagens (ou tentar um projeto de deteção de objetos ), pode querer eliminar o projeto de identificação de árvores deste exemplo. Uma subscrição gratuita permite dois projetos Custom Vision.

No site Custom Vision, navegue até Projects e selecione o caixote do lixo em My New Project.

Conteúdo relacionado

Agora já fizeste todas as etapas do processo de classificação de imagens usando a API REST. Este exemplo executa uma única iteração de treino, mas muitas vezes terá de treinar e testar o seu modelo várias vezes para o tornar mais preciso.

• O que é a Visão Personalizada?
• Documentação de referência da API (formação)
• Documentação de referência de API (previsão)