Início Rápido: Criar um projeto de classificação de imagem com a biblioteca de clientes da Visão Personalizada ou a API REST

  • Artigo

Introdução à biblioteca de clientes da Visão Personalizada para .NET. Siga estas etapas para instalar o pacote e experimentar o código de exemplo para criar um modelo de classificação de imagem. Você criará um projeto, adicionará marcas, treinará o projeto e usará a URL do ponto de extremidade de previsão do projeto para testá-lo programaticamente. Use este exemplo como um modelo para criar o próprio aplicativo de reconhecimento de imagem.

Observação

Se desejar criar e treinar um modelo de classificação sem escrever código, confira as diretrizes baseadas em navegador.

Documentação de referência | Código-fonte da biblioteca (treinamento)(previsão) | Pacote (NuGet) (treinamento)(previsão) | Exemplos

Pré-requisitos

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Acesse o portal do Azure. Se os recursos da Visão Personalizada que você criou na seção Pré-requisitos tiverem sido implantados com sucesso, selecione o botão Acessar o Recurso em Próximas Etapas. Encontre as chaves e os pontos de extremidade nas páginas de chave e ponto de extremidade dos recursos, em gerenciamento de recursos. Você precisará obter as chaves para os recursos de treinamento e de previsão, juntamente com os pontos de extremidades da API.

Encontre a ID do recurso de previsão na guia Propriedades do recurso de previsão no portal do Azure, listada como ID do Recurso.

Dica

Você também usa https://www.customvision.ai/ para obter esses valores. Depois de se conectar, selecione o ícone Configurações no canto superior direito. Nas páginas Configuração, você pode ver todas as chaves, a ID do recurso e os pontos de extremidade.

Cuidado

Não inclua a chave diretamente no código e nunca a divulgue publicamente. Confira o artigo de segurança dos Serviços de IA do Azure para obter mais opções de autenticação como o Azure Key Vault.

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

  1. Para definir a variável de ambiente VISION_TRAINING KEY, substitua your-training-key por uma das chaves do recurso de treinamento.
  2. Para definir a variável de ambiente VISION_TRAINING_ENDPOINT, substitua your-training-endpoint pelo ponto de extremidade do recurso de treinamento.
  3. Para definir a variável de ambiente VISION_PREDICTION_KEY, substitua your-prediction-key por uma das chaves do recurso de previsão.
  4. Para definir a variável de ambiente VISION_PREDICTION_ENDPOINT, substitua your-prediction-endpoint pelo ponto de extremidade do recurso de previsão.
  5. Para definir a variável de ambiente VISION_PREDICTION_RESOURCE_ID, substitua your-resource-id pelo ID do 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

Depois de adicionar as variáveis de ambiente, é aconselhável reiniciar todos os programas em execução que precisarem lê-las, incluindo a janela do console.

Configurando

Criar um aplicativo em C#

Usando o Visual Studio, crie um aplicativo .NET Core.

Instalar a biblioteca de clientes

Depois de criar um projeto, instale a biblioteca de clientes clicando com o botão direito do mouse na solução do projeto no Gerenciador de Soluções e selecionando Gerenciar Pacotes NuGet. No gerenciador de pacotes aberto, selecione Procurar, marque Incluir pré-lançamento e pesquise Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training e Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction. Selecione a versão mais recente e escolha Instalar.

Dica

Deseja exibir todo o arquivo de código do início rápido de uma vez? Você pode encontrá-lo no GitHub, que contém os exemplos de código neste início rápido.

No diretório do projeto, abra o arquivo program.cs e adicione as seguintes diretivas using:

using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction;
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training;
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.Models;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;

No método Main do aplicativo, crie variáveis que recuperem as chaves e os pontos de extremidade do recurso de variáveis de ambiente. Você também declarará alguns objetos básicos para serem usados posteriormente.

// 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 Main do aplicativo, adicione chamadas para os métodos usados neste guia de início rápido. Você os implementará 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

Em um novo método, crie uma instância de clientes de treinamento e previsão usando o ponto de extremidade e as 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 de Visão Personalizada

Essa próxima parte do código cria um projeto de classificação de imagem. O projeto criado será exibido no site da Visão Personalizada. Confira o método CreateProject para especificar outras opções ao criar seu projeto (explicado no guia do portal da Web Criar um classificador).

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

Adicionar marcas ao projeto

Esse método define as marcas em que você treinará 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 marcar imagens

Primeiro, baixe as imagens de exemplo para este projeto. Salve o conteúdo da pasta de imagens de exemplo em seu dispositivo local.

Em seguida, defina um método auxiliar para carregar as imagens nesse diretório. Talvez seja necessário editar o argumento GetFiles para apontar para a localização em que as imagens são salvas.

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

Em seguida, defina um método para carregar as imagens, aplicando marcas de acordo com a localização da pasta (as imagens já estão classificadas). Você pode carregar e marcar imagens de modo iterativo ou em um lote (até 64 por lote). Este snippet de código contém exemplos de ambos os modos.

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

}

Treinar o projeto

Esse método cria a primeira iteração de treinamento no projeto. Ele consulta o serviço até que o treinamento seja concluído.

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

Dica

Fazer o treinamento com marcas selecionadas

Opcionalmente, você pode treinar apenas um subconjunto de suas marcas aplicadas. Talvez seja interessante fazer isso se você ainda não tiver aplicado um número suficiente de determinadas marcas, mas tiver outras delas. Na chamada TrainProject, use o parâmetro trainingParameters. Construa um TrainingParameters e defina a propriedade SelectedTags dele como uma lista de IDs das marcas que você deseja usar. O modelo será treinado para reconhecer apenas as marcas nessa lista.

Publicar a iteração atual

Esse método disponibiliza a iteração atual do modelo para consulta. Você pode usar o nome do modelo como uma referência para enviar solicitações de previsão. Você precisa inserir o seu valor para predictionResourceId. Encontre a ID do recurso de previsão na guia Propriedades do recurso no portal do Azure, listado como ID do Recurso.

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 de extremidade de previsão

Essa parte do script carrega a imagem de teste, consulta o ponto de extremidade do modelo e gera dados de previsão para o 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}");
    }
}

Executar o aplicativo

Execute o aplicativo clicando no botão Depurar na parte superior da janela do IDE.

Enquanto o aplicativo é executado, ele deve abrir uma janela do console e gravar a seguinte saída:

Creating new project:
        Uploading images
        Training
Done!

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

Em seguida, você pode verificar se a imagem de teste (encontrada em imagens/teste/) foi marcada apropriadamente. Pressione qualquer tecla para sair do aplicativo. Você pode também voltar para o site da Visão Personalizada e ver o estado atual do projeto recém-criado.

Limpar os recursos

Se você deseja implementar seu próprio projeto de classificação de imagens (ou experimentar um projeto de detecção de objeto em vez disso), você talvez queira excluir o projeto de identificação de árvore deste exemplo. Uma assinatura gratuita permite dois projetos da Visão Personalizada.

No site de Visão Personalizada, navegue até Projetos e selecione a Lixeira em Meu novo projeto.

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

Próximas etapas

Agora, você concluiu cada etapa do processo de classificação de imagens no código. Este exemplo executa uma iteração de treinamento única, mas muitas vezes você precisará treinar e testar o modelo várias vezes para torná-lo mais preciso.

Testar e readaptar um modelo

Este artigo fornece informações e um código de exemplo para ajudar você a começar a usar a biblioteca de clientes da Visão Personalizada para Go, a fim de criar um modelo de classificação de imagem. Você criará um projeto, adicionará marcas, treinará o projeto e usará a URL do ponto de extremidade de previsão do projeto para testá-lo programaticamente. Use este exemplo como um modelo para criar o próprio aplicativo de reconhecimento de imagem.

Observação

Se desejar criar e treinar um modelo de classificação sem escrever código, confira as diretrizes baseadas em navegador.

Use a biblioteca de clientes da Visão Personalizada para Go para:

  • Criar um novo projeto de Visão Personalizada
  • Adicionar marcas ao projeto
  • Carregar e marcar imagens
  • Treinar o projeto
  • Publicar a iteração atual
  • Testar o ponto de extremidade de previsão

Documentação de referência (treinamento)(previsão)

Pré-requisitos

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Acesse o portal do Azure. Se os recursos da Visão Personalizada que você criou na seção Pré-requisitos tiverem sido implantados com sucesso, selecione o botão Acessar o Recurso em Próximas Etapas. Encontre as chaves e os pontos de extremidade nas páginas de chave e ponto de extremidade dos recursos, em gerenciamento de recursos. Você precisará obter as chaves para os recursos de treinamento e de previsão, juntamente com os pontos de extremidades da API.

Encontre a ID do recurso de previsão na guia Propriedades do recurso de previsão no portal do Azure, listada como ID do Recurso.

Dica

Você também usa https://www.customvision.ai/ para obter esses valores. Depois de se conectar, selecione o ícone Configurações no canto superior direito. Nas páginas Configuração, você pode ver todas as chaves, a ID do recurso e os pontos de extremidade.

Cuidado

Não inclua a chave diretamente no código e nunca a divulgue publicamente. Confira o artigo de segurança dos Serviços de IA do Azure para obter mais opções de autenticação como o Azure Key Vault.

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

  1. Para definir a variável de ambiente VISION_TRAINING KEY, substitua your-training-key por uma das chaves do recurso de treinamento.
  2. Para definir a variável de ambiente VISION_TRAINING_ENDPOINT, substitua your-training-endpoint pelo ponto de extremidade do recurso de treinamento.
  3. Para definir a variável de ambiente VISION_PREDICTION_KEY, substitua your-prediction-key por uma das chaves do recurso de previsão.
  4. Para definir a variável de ambiente VISION_PREDICTION_ENDPOINT, substitua your-prediction-endpoint pelo ponto de extremidade do recurso de previsão.
  5. Para definir a variável de ambiente VISION_PREDICTION_RESOURCE_ID, substitua your-resource-id pelo ID do 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

Depois de adicionar as variáveis de ambiente, é aconselhável reiniciar todos os programas em execução que precisarem lê-las, incluindo a janela do console.

Configurando

Instalar a biblioteca de clientes da Visão Personalizada

Para escrever um aplicativo de análise de imagem com a Visão Personalizada para Go, você precisará da biblioteca de clientes do serviço de Visão Personalizada. Execute o seguinte comando no PowerShell:

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

ou, se você usar o dep, execute o seguinte no repositório:

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

Obter as imagens de exemplo

Esse exemplo usa as imagens do repositório de Amostras do SDK do Python dos Serviços de IA do Azure no GitHub. Clone ou baixe este repositório para o seu ambiente de desenvolvimento. Lembre-se da localização da pasta para uso em uma etapa posterior.

Criar o projeto de Visão Personalizada

Crie um arquivo chamado sample.go em seu diretório de projeto preferido e abra-o em seu editor de código preferido.

Adicione o código a seguir ao seu script para criar um novo projeto do Serviço de Visão Personalizada.

Confira o método CreateProject para especificar outras opções ao criar seu projeto (explicado no guia do portal da Web Criar um classificador).

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 marcas no projeto

Para criar marcas de classificação para o projeto, adicione o seguinte código ao final de 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 marcar imagens

Para adicionar imagens de exemplo ao projeto, insira o código a seguir após a criação da marca. Esse código carrega cada imagem com sua marca correspondente. Você pode carregar até 64 imagens em um único lote.

Observação

Você precisará alterar o caminho para as imagens com base no local onde baixou o projeto de Amostras do SDK do Go para os Serviços de IA do Azure anteriormente.

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

Treinar e publicar o projeto

Este código cria a primeira iteração do modelo de previsão e, em seguida, publica essa iteração no ponto de extremidade de previsão. O nome dado à iteração publicada pode ser usado para enviar solicitações de previsão. Uma iteração não fica disponível no ponto de extremidade 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 ponto de extremidade de previsão

Para enviar uma imagem para o ponto de extremidade de previsão e recuperar a previsão, adicione o seguinte código ao final do arquivo:

    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 o aplicativo

Execute sample.go.

go run sample.go

A saída do aplicativo 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%

Em seguida, você poderá verificar se a imagem de teste (encontrada em <base_image_url>/Images/Test/) foi marcada apropriadamente. Você pode também voltar para o site da Visão Personalizada e ver o estado atual do projeto recém-criado.

Limpar os recursos

Se você deseja implementar seu próprio projeto de classificação de imagens (ou experimentar um projeto de detecção de objeto em vez disso), você talvez queira excluir o projeto de identificação de árvore deste exemplo. Uma assinatura gratuita permite dois projetos da Visão Personalizada.

No site de Visão Personalizada, navegue até Projetos e selecione a Lixeira em Meu novo projeto.

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

Próximas etapas

Agora você viu como cada etapa do processo de detecção de objetos pode ser executada em código. Este exemplo executa uma iteração de treinamento única, mas muitas vezes você precisará treinar e testar o modelo várias vezes para torná-lo mais preciso.

Testar e readaptar um modelo

Comece a usar a biblioteca de clientes da Visão Personalizada para Java a fim de criar um modelo de classificação de imagem. Siga essas etapas para instalar o pacote e testar o código de exemplo para tarefas básicas. Use este exemplo como um modelo para criar o próprio aplicativo de reconhecimento de imagem.

Observação

Se desejar criar e treinar um modelo de classificação sem escrever código, confira as diretrizes baseadas em navegador.

Use a biblioteca de clientes da Visão Personalizada para Java a fim de:

  • Criar um novo projeto de Visão Personalizada
  • Adicionar marcas ao projeto
  • Carregar e marcar imagens
  • Treinar o projeto
  • Publicar a iteração atual
  • Testar o ponto de extremidade de previsão

Documentação de referência | Código-fonte da biblioteca (treinamento)(previsão) | Artifact (Maven) (treinamento)(previsão) | Exemplos

Pré-requisitos

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Acesse o portal do Azure. Se os recursos da Visão Personalizada que você criou na seção Pré-requisitos tiverem sido implantados com sucesso, selecione o botão Acessar o Recurso em Próximas Etapas. Encontre as chaves e os pontos de extremidade nas páginas de chave e ponto de extremidade dos recursos, em gerenciamento de recursos. Você precisará obter as chaves para os recursos de treinamento e de previsão, juntamente com os pontos de extremidades da API.

Encontre a ID do recurso de previsão na guia Propriedades do recurso de previsão no portal do Azure, listada como ID do Recurso.

Dica

Você também usa https://www.customvision.ai/ para obter esses valores. Depois de se conectar, selecione o ícone Configurações no canto superior direito. Nas páginas Configuração, você pode ver todas as chaves, a ID do recurso e os pontos de extremidade.

Cuidado

Não inclua a chave diretamente no código e nunca a divulgue publicamente. Confira o artigo de segurança dos Serviços de IA do Azure para obter mais opções de autenticação como o Azure Key Vault.

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

  1. Para definir a variável de ambiente VISION_TRAINING KEY, substitua your-training-key por uma das chaves do recurso de treinamento.
  2. Para definir a variável de ambiente VISION_TRAINING_ENDPOINT, substitua your-training-endpoint pelo ponto de extremidade do recurso de treinamento.
  3. Para definir a variável de ambiente VISION_PREDICTION_KEY, substitua your-prediction-key por uma das chaves do recurso de previsão.
  4. Para definir a variável de ambiente VISION_PREDICTION_ENDPOINT, substitua your-prediction-endpoint pelo ponto de extremidade do recurso de previsão.
  5. Para definir a variável de ambiente VISION_PREDICTION_RESOURCE_ID, substitua your-resource-id pelo ID do 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

Depois de adicionar as variáveis de ambiente, é aconselhável reiniciar todos os programas em execução que precisarem lê-las, incluindo a janela do console.

Configurando

Criar um novo projeto Gradle

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

mkdir myapp && cd myapp

Execute o comando gradle init em seu diretório de trabalho. Esse comando criará arquivos de build essenciais para o Gradle, incluindo o build.gradle.kts, que é usado no runtime para criar e configurar seu aplicativo.

gradle init --type basic

Quando solicitado a escolher uma DSL, escolha Kotlin.

Instalar a biblioteca de clientes

Localize o build.gradle.kts e abra-o com seu IDE ou editor de texto preferencial. Depois copie nessa configuração de build a seguir. Esta configuração define o projeto como um aplicativo Java cujo ponto de entrada é a classe CustomVisionQuickstart. Ela importa as bibliotecas da Visão Personalizada.

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 arquivo Java

Em seu diretório de trabalho, execute o comando a seguir para criar uma pasta de origem do projeto:

mkdir -p src/main/java

Navegue até a nova pasta e crie um arquivo chamado CustomVisionQuickstart.java. Abra-a no editor ou IDE de sua preferência e adicione as seguintes instruções import:

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;

import com.google.common.io.ByteStreams;

import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Classifier;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Domain;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.DomainType;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.ImageFileCreateBatch;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.ImageFileCreateEntry;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Iteration;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Project;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Region;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.TrainProjectOptionalParameter;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.CustomVisionTrainingClient;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.Trainings;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.CustomVisionTrainingManager;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.models.ImagePrediction;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.models.Prediction;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.CustomVisionPredictionClient;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.CustomVisionPredictionManager;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Tag;

Dica

Deseja exibir todo o arquivo de código do início rápido de uma vez? Você pode encontrá-lo no GitHub, que contém os exemplos de código neste início rápido.

Na classe CustomVisionQuickstart do aplicativo, crie variáveis que recuperem as chaves e os pontos de extremidade do recurso de variáveis de 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

Vá para o portal do Azure. Se os recursos da Visão Personalizada que você criou na seção Pré-requisitos foram implantados com êxito, selecione o botão Ir para o Recurso em Próximas Etapas. Encontre as chaves e o ponto de extremidade nas páginas de chave e ponto de extremidade dos recursos. Você precisará obter as chaves para os recursos de treinamento e de previsão, juntamente com o ponto de extremidade de API para seu recurso de treinamento.

Encontre a ID do recurso de previsão na guia Propriedades do recurso no portal do Azure, listado como ID do Recurso.

Importante

Lembre-se de remover as chaves do código quando terminar e nunca poste-as publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Confira o artigo sobre segurança dos serviços de IA do Azure para obter mais informações.

No método main do aplicativo, adicione chamadas para os métodos usados neste guia de início rápido. Você os definirá mais tarde.

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

Modelo de objeto

As classes e interfaces a seguir lidam com alguns dos principais recursos da biblioteca de clientes do Java da Visão Personalizada.

Nome Descrição
CustomVisionTrainingClient Essa classe lida com a criação, o treinamento e a publicação de seus modelos.
CustomVisionPredictionClient Essa classe lida com a consulta de seus modelos para obter previsões de classificação de imagem.
ImagePrediction Essa classe define uma previsão em uma imagem. Ela inclui propriedades para a ID e o nome do objeto e uma pontuação de confiança.

Exemplos de código

Estes snippets de código mostram como realizar as seguintes tarefas com a biblioteca de clientes da Visão Personalizada para Java:

Autenticar o cliente

No método main crie uma instância de clientes de treinamento e previsão usando o ponto de extremidade e as chaves.

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

Criar um projeto de Visão Personalizada

T## Criar um projeto de Visão Personalizada

O próximo método cria um projeto de classificação de imagem. O projeto criado será exibido no site da Visão Personalizada visitado anteriormente. Confira as sobrecargas do método CreateProject para especificar outras opções ao criar seu projeto (explicado no guia do portal da Web Criar um 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;
}

Adicionar marcas ao seu projeto

Esse método define as marcas em que você 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 marcar imagens

Primeiro, baixe as imagens de exemplo para este projeto. Salve o conteúdo da pasta de imagens de exemplo em seu 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 snippet de código anterior faz uso de duas funções auxiliares que recuperam as imagens como fluxos de recurso e as carrega no serviço (você pode carregar até 64 imagens em um ú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;
}

Treinar o projeto

Esse método cria a primeira iteração de treinamento no projeto. Ele consulta o serviço até que o treinamento seja concluído.

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

Esse método disponibiliza a iteração atual do modelo para consulta. Você pode usar o nome do modelo como uma referência para enviar solicitações de previsão. Você precisa inserir o seu valor para predictionResourceId. Encontre a ID do recurso de previsão na guia Propriedades do recurso no portal do Azure, listado como ID do Recurso.

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 de extremidade de previsão

Este método carrega a imagem de teste, consulta o ponto de extremidade do modelo e gera dados de previsão para o 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));
    }
}

Executar o aplicativo

É possível criar o aplicativo com:

gradle build

Execute o aplicativo com o comando gradle run:

gradle run

Limpar os recursos

Se quiser limpar e remover uma assinatura dos Serviços de IA do Azure, você poderá excluir o recurso ou grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele.

Se você deseja implementar seu próprio projeto de classificação de imagens (ou experimentar um projeto de detecção de objeto em vez disso), você talvez queira excluir o projeto de identificação de árvore deste exemplo. Uma assinatura gratuita permite dois projetos da Visão Personalizada.

No site de Visão Personalizada, navegue até Projetos e selecione a Lixeira em Meu novo projeto.

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

Próximas etapas

Agora você viu como cada etapa do processo de classificação de imagem pode ser executada em código. Este exemplo executa uma iteração de treinamento única, mas muitas vezes você precisará treinar e testar o modelo várias vezes para torná-lo mais preciso.

Testar e readaptar um modelo

  • O que é Visão Personalizada?
  • O código-fonte dessa amostra pode ser encontrado no GitHub

Este artigo fornece informações e um código de exemplo para ajudar você a começar a usar a biblioteca de clientes da Visão Personalizada para Node.js, a fim de criar um modelo de classificação de imagem. Você criará um projeto, adicionará marcas, treinará o projeto e usará a URL do ponto de extremidade de previsão do projeto para testá-lo programaticamente. Use este exemplo como um modelo para criar o próprio aplicativo de reconhecimento de imagem.

Observação

Se desejar criar e treinar um modelo de classificação sem escrever código, confira as diretrizes baseadas em navegador.

Use a biblioteca de clientes da Visão Personalizada para .NET para:

  • Criar um novo projeto de Visão Personalizada
  • Adicionar marcas ao projeto
  • Carregar e marcar imagens
  • Treinar o projeto
  • Publicar a iteração atual
  • Testar o ponto de extremidade de previsão

Documentação de referência (treinamento)(previsão) | Código-fonte de biblioteca (treinamento)(previsão) | Pacote (npm) (treinamento)(previsão) | Exemplos

Pré-requisitos

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Acesse o portal do Azure. Se os recursos da Visão Personalizada que você criou na seção Pré-requisitos tiverem sido implantados com sucesso, selecione o botão Acessar o Recurso em Próximas Etapas. Encontre as chaves e os pontos de extremidade nas páginas de chave e ponto de extremidade dos recursos, em gerenciamento de recursos. Você precisará obter as chaves para os recursos de treinamento e de previsão, juntamente com os pontos de extremidades da API.

Encontre a ID do recurso de previsão na guia Propriedades do recurso de previsão no portal do Azure, listada como ID do Recurso.

Dica

Você também usa https://www.customvision.ai/ para obter esses valores. Depois de se conectar, selecione o ícone Configurações no canto superior direito. Nas páginas Configuração, você pode ver todas as chaves, a ID do recurso e os pontos de extremidade.

Cuidado

Não inclua a chave diretamente no código e nunca a divulgue publicamente. Confira o artigo de segurança dos Serviços de IA do Azure para obter mais opções de autenticação como o Azure Key Vault.

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

  1. Para definir a variável de ambiente VISION_TRAINING KEY, substitua your-training-key por uma das chaves do recurso de treinamento.
  2. Para definir a variável de ambiente VISION_TRAINING_ENDPOINT, substitua your-training-endpoint pelo ponto de extremidade do recurso de treinamento.
  3. Para definir a variável de ambiente VISION_PREDICTION_KEY, substitua your-prediction-key por uma das chaves do recurso de previsão.
  4. Para definir a variável de ambiente VISION_PREDICTION_ENDPOINT, substitua your-prediction-endpoint pelo ponto de extremidade do recurso de previsão.
  5. Para definir a variável de ambiente VISION_PREDICTION_RESOURCE_ID, substitua your-resource-id pelo ID do 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

Depois de adicionar as variáveis de ambiente, é aconselhável reiniciar todos os programas em execução que precisarem lê-las, incluindo a janela do console.

Configurando

Criar um novo aplicativo do Node.js

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

mkdir myapp && cd myapp

Execute o comando npm init para criar um aplicativo do Node com um arquivo package.json.

npm init

Instalar a biblioteca de clientes

Para escrever um aplicativo de análise de imagem com a Visão Personalizada para Node.js, você precisará dos pacotes NPM de Visão Personalizada. Para instalá-los, execute o seguinte comando no PowerShell:

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

O arquivo package.json do seu aplicativo será atualizado com as dependências.

Crie um arquivo chamado 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");

Dica

Deseja exibir todo o arquivo de código do início rápido de uma vez? Você pode encontrá-lo no GitHub, que contém os exemplos de código neste início rápido.

Crie variáveis para as chaves e o ponto de extremidade do Azure do 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"];

Além disso, adicione campos para o nome do projeto e um parâmetro de tempo limite para chamadas assíncronas.

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

Modelo de objeto

Nome Descrição
TrainingAPIClient Essa classe lida com a criação, o treinamento e a publicação de seus modelos.
PredictionAPIClient Essa classe lida com a consulta de seus modelos para obter previsões de classificação de imagem.
Previsão Essa interface define uma previsão em uma imagem. Ela inclui propriedades para a ID e o nome do objeto e uma pontuação de confiança.

Exemplos de código

Estes snippets de código mostram como realizar as seguintes tarefas com a biblioteca de clientes da Visão Personalizada para JavaScript:

Autenticar o cliente

Crie uma instância de objetos do cliente com o ponto de extremidade e a chave. Crie um objeto ApiKeyCredentials com a sua chave e use-o com o ponto de extremidade 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 de Visão Personalizada

Inicie uma nova função para conter todas as suas chamadas de função de Visão Personalizada. Adicione o código a seguir para criar um projeto do serviço de Visão Personalizada.

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

Adicionar marcas ao projeto

Para criar marcas de classificação para o 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 marcar imagens

Primeiro, baixe as imagens de exemplo para este projeto. Salve o conteúdo da pasta de imagens de exemplo em seu dispositivo local.

Para adicionar imagens de exemplo ao projeto, insira o código a seguir após a criação da marca. Esse código carrega cada imagem com sua marca 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);

Importante

Você precisará alterar o caminho para as imagens (sampleDataRoot) com base no local em que baixou o repositório de Amostras de SDK do Python dos serviços de IA do Azure.

Treinar 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

Esse código publica a iteração treinada no ponto de extremidade de previsão. O nome dado à iteração publicada pode ser usado para enviar solicitações de previsão. Uma iteração não fica disponível no ponto de extremidade 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 de extremidade de previsão

Para enviar uma imagem para o ponto de extremidade de previsão e recuperar a previsão, adicione o código a seguir à 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)}%`);
});

Em seguida, feche a função Visão Personalizada e chame-a.

})()

Executar o aplicativo

Execute o aplicativo com o comando node no seu arquivo de início rápido.

node index.js

A saída do aplicativo 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%

Em seguida, você pode verificar se a imagem de teste (encontrada em <sampleDataRoot>/Test/) foi marcada apropriadamente. Você pode também voltar para o site da Visão Personalizada e ver o estado atual do projeto recém-criado.

Se você deseja implementar seu próprio projeto de classificação de imagens (ou experimentar um projeto de detecção de objeto em vez disso), você talvez queira excluir o projeto de identificação de árvore deste exemplo. Uma assinatura gratuita permite dois projetos da Visão Personalizada.

No site de Visão Personalizada, navegue até Projetos e selecione a Lixeira em Meu novo projeto.

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

Próximas etapas

Agora você viu como cada etapa do processo de detecção de objetos pode ser executada em código. Este exemplo executa uma iteração de treinamento única, mas muitas vezes você precisará treinar e testar o modelo várias vezes para torná-lo mais preciso.

Testar e readaptar um modelo

Introdução à biblioteca de clientes da Visão Personalizada para Python. Siga estas etapas para instalar o pacote e experimentar o código de exemplo para criar um modelo de classificação de imagem. Você criará um projeto, adicionará marcas, treinará o projeto e usará a URL do ponto de extremidade de previsão do projeto para testá-lo programaticamente. Use este exemplo como um modelo para criar o próprio aplicativo de reconhecimento de imagem.

Observação

Se desejar criar e treinar um modelo de classificação sem escrever código, confira as diretrizes baseadas em navegador.

Use a biblioteca de clientes da Visão Personalizada para Python a fim de:

  • Criar um novo projeto de Visão Personalizada
  • Adicionar marcas ao projeto
  • Carregar e marcar imagens
  • Treinar o projeto
  • Publicar a iteração atual
  • Testar o ponto de extremidade de previsão

Documentação de referência | Código-fonte da biblioteca | Pacote (PyPI) | Amostras

Pré-requisitos

  • Assinatura do Azure – Criar uma gratuitamente
  • Python 3.x
    • A instalação do Python deve incluir o pip. Você pode executar pip --version na linha de comando para verificar se o pip está instalado. Instale a versão mais recente do Python para obter o pip.
  • Após obter a assinatura do Azure, crie um recurso da Visão Personalizada no portal do Azure para criar um recurso de treinamento e previsão.
    • Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Acesse o portal do Azure. Se os recursos da Visão Personalizada que você criou na seção Pré-requisitos tiverem sido implantados com sucesso, selecione o botão Acessar o Recurso em Próximas Etapas. Encontre as chaves e os pontos de extremidade nas páginas de chave e ponto de extremidade dos recursos, em gerenciamento de recursos. Você precisará obter as chaves para os recursos de treinamento e de previsão, juntamente com os pontos de extremidades da API.

Encontre a ID do recurso de previsão na guia Propriedades do recurso de previsão no portal do Azure, listada como ID do Recurso.

Dica

Você também usa https://www.customvision.ai/ para obter esses valores. Depois de se conectar, selecione o ícone Configurações no canto superior direito. Nas páginas Configuração, você pode ver todas as chaves, a ID do recurso e os pontos de extremidade.

Cuidado

Não inclua a chave diretamente no código e nunca a divulgue publicamente. Confira o artigo de segurança dos Serviços de IA do Azure para obter mais opções de autenticação como o Azure Key Vault.

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

  1. Para definir a variável de ambiente VISION_TRAINING KEY, substitua your-training-key por uma das chaves do recurso de treinamento.
  2. Para definir a variável de ambiente VISION_TRAINING_ENDPOINT, substitua your-training-endpoint pelo ponto de extremidade do recurso de treinamento.
  3. Para definir a variável de ambiente VISION_PREDICTION_KEY, substitua your-prediction-key por uma das chaves do recurso de previsão.
  4. Para definir a variável de ambiente VISION_PREDICTION_ENDPOINT, substitua your-prediction-endpoint pelo ponto de extremidade do recurso de previsão.
  5. Para definir a variável de ambiente VISION_PREDICTION_RESOURCE_ID, substitua your-resource-id pelo ID do 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

Depois de adicionar as variáveis de ambiente, é aconselhável reiniciar todos os programas em execução que precisarem lê-las, incluindo a janela do console.

Configurando

Instalar a biblioteca de clientes

Para escrever um aplicativo de análise de imagem com a Visão Personalizada para Python, você precisará da biblioteca de clientes da Visão Personalizada. Depois de instalar o Python, execute o seguinte comando no PowerShell ou em uma janela de console:

pip install azure-cognitiveservices-vision-customvision

Criar um novo aplicativo Python

Crie um arquivo do Python e importe as bibliotecas a seguir.

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

Dica

Deseja exibir todo o arquivo de código do início rápido de uma vez? Você pode encontrá-lo no GitHub, que contém os exemplos de código neste início rápido.

Crie variáveis para as chaves e o ponto de extremidade do Azure do recurso.

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

Modelo de objeto

Nome Descrição
CustomVisionTrainingClient Essa classe lida com a criação, o treinamento e a publicação de seus modelos.
CustomVisionPredictionClient Essa classe lida com a consulta de seus modelos para obter previsões de classificação de imagem.
ImagePrediction Essa classe define uma previsão de objeto em uma imagem. Ela inclui propriedades para a ID e o nome do objeto, a localização da caixa delimitadora do objeto e uma pontuação de confiança.

Exemplos de código

Estes snippets de código mostram como realizar as seguintes tarefas com a biblioteca de clientes da Visão Personalizada para Python:

Autenticar o cliente

Crie um cliente de treinamento e previsão usando seu ponto de extremidade e suas chaves. Crie objetos ApiKeyServiceClientCredentials com suas chaves e use-os com seu ponto de extremidade para criar um objeto 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)

Criar um novo projeto de Visão Personalizada

Adicione o código a seguir ao seu script para criar um novo projeto do Serviço de Visão Personalizada.

Confira o método create_project para especificar outras opções ao criar seu projeto (explicado no guia do portal da Web Criar um classificador).

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 marcas ao projeto

Para adicionar marcas de classificação ao 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 marcar imagens

Primeiro, baixe as imagens de exemplo para este projeto. Salve o conteúdo da pasta de imagens de exemplo em seu dispositivo local.

Para adicionar imagens de exemplo ao projeto, insira o código a seguir após a criação da marca. Esse código carrega cada imagem com sua marca correspondente. Você pode carregar até 64 imagens em um ú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)

Observação

Você precisará alterar o caminho para as imagens com base no local em que baixou o repositório de Amostras de SDK do Python dos serviços de IA do Azure.

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

Dica

Fazer o treinamento com marcas selecionadas

Opcionalmente, você pode treinar apenas um subconjunto de suas marcas aplicadas. Talvez seja interessante fazer isso se você ainda não tiver aplicado um número suficiente de determinadas marcas, mas tiver outras delas. Na chamada train_project , defina o parâmetro opcional selected_tags como uma lista das cadeias de caracteres de ID das marcas que você deseja usar. O modelo será treinado para reconhecer apenas as marcas nessa lista.

Publicar a iteração atual

Uma iteração não fica disponível no ponto de extremidade de previsão até ser publicada. O código a seguir 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 de extremidade de previsão

Para enviar uma imagem para o ponto de extremidade de previsão e recuperar a previsão, adicione o seguinte código ao final do arquivo:

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

Executar o aplicativo

Execute CustomVisionQuickstart.py.

python CustomVisionQuickstart.py

A saída do aplicativo 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%

Em seguida, você poderá verificar se a imagem de teste (encontrada em <base_image_location>/images/Test/) foi marcada apropriadamente. Você pode também voltar para o site da Visão Personalizada e ver o estado atual do projeto recém-criado.

Limpar os recursos

Se você deseja implementar seu próprio projeto de classificação de imagens (ou experimentar um projeto de detecção de objeto em vez disso), você talvez queira excluir o projeto de identificação de árvore deste exemplo. Uma assinatura gratuita permite dois projetos da Visão Personalizada.

No site de Visão Personalizada, navegue até Projetos e selecione a Lixeira em Meu novo projeto.

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

Próximas etapas

Agora você viu como cada etapa do processo de classificação de imagem pode ser executada em código. Este exemplo executa uma iteração de treinamento única, mas muitas vezes você precisará treinar e testar o modelo várias vezes para torná-lo mais preciso.

Testar e readaptar um modelo

Introdução à API REST da Visão Personalizada. Siga estas etapas para chamar a API e criar um modelo de classificação de imagem. Você criará um projeto, adicionará marcas, treinará o projeto e usará a URL do ponto de extremidade de previsão do projeto para testá-lo programaticamente. Use este exemplo como um modelo para criar o próprio aplicativo de reconhecimento de imagem.

Observação

A Visão Personalizada é usada com mais facilidade por meio de um SDK de biblioteca de clientes ou por meio de diretrizes baseadas em navegador.

Use a biblioteca de clientes da Visão Personalizada para .NET para:

  • Criar um novo projeto de Visão Personalizada
  • Adicionar marcas ao projeto
  • Carregar e marcar imagens
  • Treinar o projeto
  • Publicar a iteração atual
  • Testar o ponto de extremidade de previsão

Pré-requisitos

  • Assinatura do Azure – Criar uma gratuitamente
  • Após obter a assinatura do Azure, crie um recurso da Visão Personalizada no portal do Azure para criar um recurso de treinamento e previsão e obter as chaves e o ponto de extremidade. Aguarde até que ele seja implantado e clique no botão Ir para o recurso.
    • Você precisará da chave e do ponto de extremidade dos recursos criados para conectar seu aplicativo à Visão Personalizada. Cole a chave e o ponto de extremidade no código abaixo mais adiante no guia de início rápido.
    • Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.
  • PowerShell versão 6.0+ ou um aplicativo de linha de comando semelhante.

Criar um novo projeto de Visão Personalizada

Você usará um comando como o exibido a seguir para criar um projeto de classificação de imagem. O projeto criado será exibido no site da Visão Personalizada.

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 de Detecção Facial válida.
  • Substitua {endpoint} pelo ponto de extremidade que corresponde à sua chave.

    Observação

    Os novos recursos criados após 1º de julho de 2019 usarão nomes de subdomínio personalizados. Para obter mais informações e uma lista completa de pontos de extremidade regionais, confira Nomes de subdomínio personalizados para os serviços de IA do Azure.

  • Substitua {name} pelo nome do projeto.
  • Opcionalmente, defina outros parâmetros de URL para configurar o tipo de modelo que seu projeto usará. Confira a API CreatProject para obter opções.

Uma resposta JSON semelhante à seguinte será exibida. Salve o valor "id" do seu projeto em uma localização temporária.

{
  "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 marcas ao projeto

Use o comando a seguir para definir as marcas em que você treinará o modelo.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/tags?name={name}"
  • Novamente, insira sua chave e URL de ponto de extremidade.
  • Substitua {projectId} pela ID do projeto.
  • Substitua {name} pelo nome da marca que você deseja usar.

Repita esse processo para todas as marcas que você gostaria de usar em seu projeto. Se você estiver usando as imagens de exemplo fornecidas, adicione as marcas "Hemlock" e "Japanese Cherry".

Uma resposta JSON semelhante à seguinte será mostrada. Salve o valor "id" de cada marca em uma localização temporária.

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

Carregar e marcar imagens

Em seguida, baixe as imagens de exemplo para este projeto. Salve o conteúdo da pasta de imagens de exemplo em seu dispositivo local.

Use o comando a seguir para carregar as imagens e aplicar marcas; uma vez para as imagens "Cicuta" e separadamente para as imagens "Cerejeira". Confira a API Criar imagens dos dados para obter 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}"
  • Novamente, insira sua chave e URL de ponto de extremidade.
  • Substitua {projectId} pela ID do projeto.
  • Substitua {tagArray} pela ID da marca.
  • Em seguida, preencha o corpo da solicitação com os dados binários das imagens que você deseja marcar.

Treinar o projeto

Este método treina o modelo nas imagens marcadas que você carregou e retorna uma ID para a iteração do projeto atual.

curl -v -X POST -H "Content-Type: application/json" -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/train"
  • Novamente, insira sua chave e URL de ponto de extremidade.
  • Substitua {projectId} pela ID do projeto.
  • Substitua {tagArray} pela ID da marca.
  • Em seguida, preencha o corpo da solicitação com os dados binários das imagens que você deseja marcar.
  • Opcionalmente, use outros parâmetros de URL. Confira a API Treinar Projeto para obter opções.

Dica

Fazer o treinamento com marcas selecionadas

Opcionalmente, você pode treinar apenas um subconjunto de suas marcas aplicadas. Talvez seja interessante fazer isso se você ainda não tiver aplicado um número suficiente de determinadas marcas, mas tiver outras delas. Adicione o conteúdo JSON opcional ao corpo da solicitação. Preencha a matriz de "selectedTags" com as IDs das marcas que você deseja usar.

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

A resposta JSON contém informações sobre seu projeto treinado, incluindo a ID de iteração ("id"). Salve esse valor para a próxima etapa.

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

Esse método disponibiliza a iteração atual do modelo para consulta. Use o nome do modelo como uma referência para enviar solicitações 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}"
  • Novamente, insira sua chave e URL de ponto de extremidade.
  • Substitua {projectId} pela ID do projeto.
  • Substitua {iterationId} pela ID retornada na etapa anterior.
  • Substitua {publishedName} pelo nome que você deseja atribuir ao modelo de previsão.
  • Substitua {predictionId} pela sua ID de recurso de previsão. Encontre a ID do recurso de previsão na guia Propriedades do recurso no portal do Azure, listado como ID do Recurso.
  • Opcionalmente, use outros parâmetros de URL. Confira a API Publicar Iteração.

Testar o ponto de extremidade de previsão

Por fim, use este comando para testar seu modelo treinado carregando uma nova imagem para classificar com marcas. Você pode usar a imagem na pasta "Teste" dos arquivos de exemplo baixados 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}"
  • Novamente, insira sua chave e URL de ponto de extremidade.
  • Substitua {projectId} pela ID do projeto.
  • Substitua {publishedName} pelo nome usado na etapa anterior.
  • Adicione os dados binários de sua imagem local ao corpo da solicitação.
  • Opcionalmente, use outros parâmetros de URL. Confira a API Classificar Imagem.

A resposta JSON retornada listará cada uma das marcas que o modelo aplicou à imagem, além de pontuações de probabilidade individuais para elas.

{
  "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 você deseja implementar seu próprio projeto de classificação de imagens (ou experimentar um projeto de detecção de objeto em vez disso), você talvez queira excluir o projeto de identificação de árvore deste exemplo. Uma assinatura gratuita permite dois projetos da Visão Personalizada.

No site de Visão Personalizada, navegue até Projetos e selecione a Lixeira em Meu novo projeto.

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

Próximas etapas

Agora, você concluiu cada etapa do processo de classificação de imagens usando a API REST. Este exemplo executa uma iteração de treinamento única, mas muitas vezes você precisará treinar e testar o modelo várias vezes para torná-lo mais preciso.

Testar e readaptar um modelo