Início Rápido: criar um projeto de classificação de imagem com o SDK de Visão Personalizada ou a API REST

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ê pode 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 você quiser criar e treinar um modelo de classificação sem escrever o código, consulte as diretrizes baseadas em navegador.

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

Pré-requisitos

• Uma assinatura do Azure. É possível criar uma gratuitamente.
• O IDE do Visual Studio ou a versão atual do .NET Core.
• Depois de ter sua assinatura do Azure, crie um recurso de Visão Personalizada no portal do Azure para criar um recurso de treinamento e um recurso de 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 forem implantados com sucesso, selecione o botão Ir para o Recurso em Próximas etapas. Você pode encontrar suas chaves e pontos de extremidade nas páginas de chaves e pontos de extremidade dos recursos, em Gerenciamento de recursos. Você precisará obter as chaves para o recurso de treinamento e o recurso de previsão, juntamente com os pontos de extremidade 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.

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.

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

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, veja Autenticar solicitações para serviços de IA do Azure.

Windows

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Depois de adicionar as variáveis de ambiente, talvez seja necessário reiniciar todos os programas em execução que leem as variáveis de ambiente, incluindo a janela do console.

Linux

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Depois de adicionar as variáveis de ambiente, execute source ~/.bashrc na janela do console para que as alterações entrem em vigor.

Configurando

Visual Studio IDE

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. Selecione Procurar no gerenciador de pacotes que é aberto e verifique 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.

CLI

Criar um aplicativo em C#

Em uma janela de console (como cmd, PowerShell ou Bash), use o comando dotnet new para criar um novo aplicativo do console com o nome custom-vision-quickstart. Esse comando cria o projeto C# Olá, Mundo simples com um único arquivo de origem: program.cs.

dotnet new console -n custom-vision-quickstart

Altere o diretório para a pasta do aplicativo recém-criado. É possível criar o aplicativo com:

dotnet build

A saída de compilação não deve conter nenhum aviso ou erro.

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

Instalar a biblioteca de clientes

No diretório do aplicativo, instale a biblioteca de clientes da Visão Personalizada para .NET com o seguinte comando:

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

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 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 é exibido no site 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 nas quais você treina 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 você precise editar o argumento GetFiles para apontar para o local onde suas 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 o local 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 sua propriedade SelectedTags em uma lista de IDs das marcas que você quer 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

Visual Studio IDE

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

CLI

Execute o aplicativo do seu diretório de aplicativo com o comando dotnet run.

dotnet run

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ê quiser implementar o seu próprio projeto de classificação de imagem (ou experimentar um projeto de detecção de objetos), talvez seja bom 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.

Conteúdo relacionado

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

• O que é Visão Personalizada?
• O código-fonte dessa amostra pode ser encontrado no GitHub
• Documentação de referência do SDK

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 você quiser criar e treinar um modelo de classificação sem escrever o código, consulte 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 para (treinamento) e (previsão)

Pré-requisitos

• Uma assinatura do Azure. É possível criar uma gratuitamente.
• Go 1.8 ou posterior.
• 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 forem implantados com sucesso, selecione o botão Ir para o Recurso em Próximas etapas. Você pode encontrar suas chaves e pontos de extremidade nas páginas de chaves e pontos de extremidade dos recursos, em Gerenciamento de recursos. Você precisará obter as chaves para o recurso de treinamento e o recurso de previsão, juntamente com os pontos de extremidade 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.

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.

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

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, veja Autenticar solicitações para serviços de IA do Azure.

Windows

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Depois de adicionar as variáveis de ambiente, talvez seja necessário reiniciar todos os programas em execução que leem as variáveis de ambiente, incluindo a janela do console.

Linux

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Depois de adicionar as variáveis de ambiente, execute source ~/.bashrc na janela do console para que as alterações entrem em vigor.

Configurando

Instalar a biblioteca de clientes da Visão Personalizada

Para escrever um aplicativo de análise de imagens com a Visão Personalizada para Go, você precisa 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 dep, na sua execução de 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 está disponível no ponto de extremidade de previsão até que seja 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 o aplicativo usando o seguinte comando:

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ê quiser implementar o seu próprio projeto de classificação de imagem (ou experimentar um projeto de detecção de objetos), talvez seja bom 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.

Conteúdo relacionado

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

• O que é Visão Personalizada?
• Documentação de referência do SDK (treinamento)
• Documentação de referência do SDK (previsão)

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 você quiser criar e treinar um modelo de classificação sem escrever o código, consulte 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 para (treinamento) e (previsão)| Artefato (Maven) para (treinamento) e (previsão) | Exemplos

Pré-requisitos

• Uma assinatura do Azure. É possível criar uma gratuitamente.
• A versão atual do Kit de Desenvolvimento do Java(JDK).
• A ferramenta de build Gradle ou outro gerenciador de dependência.
• 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 forem implantados com sucesso, selecione o botão Ir para o Recurso em Próximas etapas. Você pode encontrar suas chaves e pontos de extremidade nas páginas de chaves e pontos de extremidade dos recursos, em Gerenciamento de recursos. Você precisará obter as chaves para o recurso de treinamento e o recurso de previsão, juntamente com os pontos de extremidade 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.

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.

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

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, veja Autenticar solicitações para serviços de IA do Azure.

Windows

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Depois de adicionar as variáveis de ambiente, talvez seja necessário reiniciar todos os programas em execução que leem as variáveis de ambiente, incluindo a janela do console.

Linux

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Depois de adicionar as variáveis de ambiente, execute source ~/.bashrc na janela do console para que as alterações entrem em vigor.

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 cria 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. Essa 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 o ponto 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

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

Autenticar o cliente

No seu método main, instancie os clientes de treinamento e de previsão usando seu ponto de extremidade e 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

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.

• Portal do Azure
• CLI do Azure

Se você quiser implementar o seu próprio projeto de classificação de imagem (ou experimentar um projeto de detecção de objetos), talvez seja bom 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.

Conteúdo relacionado

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

• 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ê pode 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 você quiser criar e treinar um modelo de classificação sem escrever o código, consulte as diretrizes baseadas em navegador.

Use a biblioteca de clientes da Visão Personalizada do Node.js 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 para (treinamento) e (previsão) | Pacote (npm) para (treinamento) e (previsão) | Exemplos

Pré-requisitos

• Uma assinatura do Azure. É possível criar uma gratuitamente.
• A versão atual do Node.js.
• 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 forem implantados com sucesso, selecione o botão Ir para o Recurso em Próximas etapas. Você pode encontrar suas chaves e pontos de extremidade nas páginas de chaves e pontos de extremidade dos recursos, em Gerenciamento de recursos. Você precisará obter as chaves para o recurso de treinamento e o recurso de previsão, juntamente com os pontos de extremidade 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.

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.

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

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, veja Autenticar solicitações para serviços de IA do Azure.

Windows

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Depois de adicionar as variáveis de ambiente, talvez seja necessário reiniciar todos os programas em execução que leem as variáveis de ambiente, incluindo a janela do console.

Linux

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Depois de adicionar as variáveis de ambiente, execute source ~/.bashrc na janela do console para que as alterações entrem em vigor.

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. Clique em ENTER várias vezes para concluir o processo.

npm init

Instalar a biblioteca de clientes

Para escrever um aplicativo de análise de imagens com a Visão Personalizada para Node.js, você precisa dos pacotes npm da 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 é 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
• 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

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ê precisa alterar o caminho para as imagens (sampleDataRoot) com base no local em que você baixou o repositório de Exemplos do 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 está disponível no ponto de extremidade de previsão até que seja 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ê quiser implementar o seu próprio projeto de classificação de imagem (ou experimentar um projeto de detecção de objetos), talvez seja bom 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.

Conteúdo relacionado

Este guia mostra como cada etapa do processo de detecção de objetos pode ser feita 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

• O que é Visão Personalizada?
• O código-fonte dessa amostra pode ser encontrado no GitHub
• Documentação de referência do SDK (treinamento)
• Documentação de referência do SDK (previsão)

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 você quiser criar e treinar um modelo de classificação sem escrever o código, consulte 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

• Uma assinatura do Azure. É possível 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 forem implantados com sucesso, selecione o botão Ir para o Recurso em Próximas etapas. Você pode encontrar suas chaves e pontos de extremidade nas páginas de chaves e pontos de extremidade dos recursos, em Gerenciamento de recursos. Você precisará obter as chaves para o recurso de treinamento e o recurso de previsão, juntamente com os pontos de extremidade 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.

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.

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

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Azure Key Vault. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre a segurança dos serviços de IA, veja Autenticar solicitações para serviços de IA do Azure.

Windows

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

Depois de adicionar as variáveis de ambiente, talvez seja necessário reiniciar todos os programas em execução que leem as variáveis de ambiente, incluindo a janela do console.

Linux

export VISION_TRAINING_KEY=<your-training-key>

export VISION_TRAINING_ENDPOINT=<your-training-endpoint>

export VISION_PREDICTION_KEY=<your-prediction-key>

export VISION_PREDICTION_ENDPOINT=<your-prediction-endpoint>

export VISION_PREDICTION_RESOURCE_ID=<your-resource-id>

Depois de adicionar as variáveis de ambiente, execute source ~/.bashrc na janela do console para que as alterações entrem em vigor.

Configurando

Instalar a biblioteca de clientes

Para escrever um aplicativo de análise de imagens com a Visão Personalizada para Python, você precisa 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
• 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

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ê precisa alterar o caminho para as imagens com base no local em que baixou o repositório de Exemplos do 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 em uma lista das cadeias de caracteres da ID das marcas que você quer usar. O modelo será treinado para reconhecer apenas as marcas nessa lista.

Publicar a iteração atual

Uma iteração não está disponível no ponto de extremidade de previsão até que seja 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 o aplicativo usando o seguinte comando:

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ê quiser implementar o seu próprio projeto de classificação de imagem (ou experimentar um projeto de detecção de objetos), talvez seja bom 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.

Conteúdo relacionado

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
• Documentação de referência do SDK

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 da API REST 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

• Uma assinatura do Azure. É possível 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.
  • Você precisa da chave e do ponto de extremidade dos recursos criados para conectar seu aplicativo à Visão Personalizada. Você vai colar a chave e o ponto de extremidade no código 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} por sua chave 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 da URL para configurar que tipo de modelo seu projeto usa. Consulte Criar a API do Projeto para obter opções.

É exibida uma resposta JSON como o exemplo a seguir. 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 nas quais 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".

É exibida uma resposta JSON como o exemplo a seguir. 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

Esse 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 que você baixou 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 lista cada uma das marcas que o modelo aplicou à sua imagem, juntamente com as pontuações de probabilidade de cada marca.

{
  "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ê quiser implementar o seu próprio projeto de classificação de imagem (ou experimentar um projeto de detecção de objetos), talvez seja bom 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.

Conteúdo relacionado

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

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