Guia de início rápido: crie um projeto de classificação de imagem com a biblioteca de cliente Custom Vision ou a API REST

Introdução à biblioteca de cliente Custom Vision 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á tags, 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 seu próprio aplicativo de reconhecimento de imagem.

Nota

Se você quiser criar e treinar um modelo de classificação sem escrever código, consulte as diretrizes baseadas em navegador.

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

Pré-requisitos

• Subscrição do Azure - 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 previsão.
  • Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, você gravará suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Aceda ao portal do Azure. Se os recursos da Visão Personalizada criados na seção Pré-requisitos forem implantados com êxito, 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 finais dos recursos, em Gerenciamento de recursos. Você precisará obter as chaves para seus recursos de treinamento e previsão, juntamente com os pontos de extremidade da API.

Você pode encontrar a ID do recurso de previsão na guia Propriedades do recurso de previsão no portal do Azure, listada como ID do Recurso.

Gorjeta

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

Atenção

Não inclua a chave diretamente no seu código e nunca a publique publicamente. Consulte 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 de console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

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

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 lerão 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 a partir da janela do console para tornar as alterações efetivas.

Configuração

Visual Studio IDE

Criar um novo aplicativo C#

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

Instalar a biblioteca de cliente

Depois de criar um novo projeto, instale a biblioteca de cliente 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 procure Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training e Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction. Selecione a versão mais recente e, em seguida, Instalar.

CLI

Criar um novo aplicativo C#

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

dotnet new console -n custom-vision-quickstart

Altere seu diretório para a pasta do aplicativo recém-criada. Você pode criar o aplicativo com:

dotnet build

A saída da compilação não deve conter avisos ou erros.

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

Instalar a biblioteca de cliente

Dentro do diretório do aplicativo, instale a biblioteca de cliente Custom Vision 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

Gorjeta

Quer ver todo o ficheiro de código do início rápido de uma vez? Pode encontrá-lo no GitHub, que contém os exemplos de código deste início rápido.

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

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

No método Main do aplicativo, crie variáveis que recuperem as chaves e os pontos de extremidade do recurso a partir de variáveis de ambiente. Você também declarará alguns objetos básicos a 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ê irá implementá-los 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, instancie clientes de treinamento e previsão usando seu endpoint e chaves.

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

Criar um novo projeto de Visão Personalizada

Este próximo bit de código cria um projeto de classificação de imagem. O projeto criado aparecerá no site da Visão Personalizada. Consulte 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 etiquetas ao projeto

Esse método define as tags nas quais 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 etiquetar imagens

Primeiro, faça o download das imagens de exemplo para este projeto. Salve o conteúdo da pasta Imagens de exemplo em seu dispositivo local.

Em seguida, defina um método auxiliar para carregar as imagens neste diretório. Talvez seja necessário editar o argumento GetFiles para apontar para o local onde 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 tags de acordo com a localização da pasta (as imagens já estão classificadas). Você pode carregar e marcar imagens iterativamente ou em um lote (até 64 por lote). Este trecho de código contém exemplos de ambos.

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

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

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

}

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

Gorjeta

Treinar com tags selecionadas

Opcionalmente, você pode treinar apenas em um subconjunto de suas tags aplicadas. Você pode querer fazer isso se ainda não aplicou o suficiente de certas tags, mas você tem o suficiente de outras. Na chamada TrainProject, use o parâmetro trainingParameters. Construa um TrainingParameters e defina sua propriedade SelectedTags como uma lista de IDs das tags que você deseja usar. O modelo treinará para reconhecer apenas as tags nessa lista.

Publicar a iteração atual

Esse método torna a iteração atual do modelo disponível para consulta. Você pode usar o nome do modelo como referência para enviar solicitações de previsão. Você precisa inserir seu próprio valor para predictionResourceId. Você pode encontrar a ID do recurso de previsão na guia Propriedades do recurso no portal do Azure, listada 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

Esta parte do script carrega a imagem de teste, consulta o ponto final do modelo e produz dados de predição na consola.

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

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

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

Executar a aplicação

Visual Studio IDE

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

CLI

Execute o aplicativo a partir do diretório do aplicativo com o dotnet run comando.

dotnet run

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

Creating new project:
        Uploading images
        Training
Done!

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

Depois, pode confirmar se a imagem de teste (que se encontra em Images/Test/) está etiquetada adequadamente. Prima qualquer tecla para sair da aplicação. Também pode regressar ao site da Visão Personalizada e ver o estado atual do projeto criado recentemente.

Clean up resources (Limpar recursos)

Se desejar implementar o seu próprio projeto de classificação de imagens (ou, em vez disso, experimentar um projeto de deteção de objetos), deve eliminar o projeto de identificação de árvores deste exemplo. Uma assinatura gratuita permite dois projetos de Visão Personalizada.

No Site de Visão Personalizada, navegue para Projetos e selecione o caixote do lixo em O Meu Novo Projeto.

Próximos passos

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

Test and retrain a model (Testar e voltar a preparar um modelo)

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

Este guia fornece instruções e código de exemplo para ajudá-lo a começar a usar a biblioteca de cliente Custom Vision for Go para criar um modelo de classificação de imagem. Você criará um projeto, adicionará tags, 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 seu próprio aplicativo de reconhecimento de imagem.

Nota

Se você quiser criar e treinar um modelo de classificação sem escrever código, consulte as diretrizes baseadas em navegador.

Use a biblioteca de cliente da Visão Personalizada para Ir para:

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

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

Pré-requisitos

• Subscrição do Azure - Criar uma gratuitamente
• Ir 1.8+
• 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 previsão.
  • Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, você gravará suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Aceda ao portal do Azure. Se os recursos da Visão Personalizada criados na seção Pré-requisitos forem implantados com êxito, 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 finais dos recursos, em Gerenciamento de recursos. Você precisará obter as chaves para seus recursos de treinamento e previsão, juntamente com os pontos de extremidade da API.

Você pode encontrar a ID do recurso de previsão na guia Propriedades do recurso de previsão no portal do Azure, listada como ID do Recurso.

Gorjeta

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

Atenção

Não inclua a chave diretamente no seu código e nunca a publique publicamente. Consulte 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 de console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

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

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 lerão 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 a partir da janela do console para tornar as alterações efetivas.

Configuração

Instalar a biblioteca de cliente do Custom Vision

Para escrever um aplicativo de análise de imagem com o Custom Vision for Go, você precisará da biblioteca de cliente do serviço Custom Vision. Execute o seguinte comando no PowerShell:

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

ou se você usar depo , dentro da sua execução de recompra:

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

Obter imagens de amostra

Este exemplo usa as imagens do repositório de exemplos do SDK do Python dos serviços de IA do Azure no GitHub. Clone ou transfira este repositório para o seu ambiente de desenvolvimento. Lembre-se do local da pasta para uma etapa posterior.

Criar o projeto Visão Personalizada

Crie um novo 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 seguinte ao seu script para criar um novo projeto do serviço de Visão Personalizada.

Consulte 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 etiquetas no projeto

Para criar marcas de classificação ao seu 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 etiquetar imagens

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

Nota

Você precisará alterar o caminho para as imagens com base em onde você baixou o projeto Azure AI services Go SDK Samples 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

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

Utilizar o ponto final de predição

Para enviar uma imagem para o ponto final de predição e obter a mesma, adicione o seguinte código no fim do ficheiro:

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

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

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

Executar a aplicação

Execute sample.go.

go run sample.go

O resultado da aplicação deverá 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ê pode verificar se a imagem de teste (encontrada em <base_image_url>/Images/Test/) está marcada adequadamente. Também pode regressar ao site da Visão Personalizada e ver o estado atual do projeto criado recentemente.

Clean up resources (Limpar recursos)

Se desejar implementar o seu próprio projeto de classificação de imagens (ou, em vez disso, experimentar um projeto de deteção de objetos), deve eliminar o projeto de identificação de árvores deste exemplo. Uma assinatura gratuita permite dois projetos de Visão Personalizada.

No Site de Visão Personalizada, navegue para Projetos e selecione o caixote do lixo em O Meu Novo Projeto.

Próximos passos

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

Test and retrain a model (Testar e voltar a preparar 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 cliente Custom Vision para Java para criar um modelo de classificação de imagem. Siga estas etapas para instalar o pacote e experimentar o código de exemplo para tarefas básicas. Use este exemplo como um modelo para criar seu próprio aplicativo de reconhecimento de imagem.

Nota

Se você quiser criar e treinar um modelo de classificação sem escrever código, consulte as diretrizes baseadas em navegador.

Use a biblioteca de cliente Custom Vision para Java para:

• Criar um novo projeto de Visão Personalizada
• Adicionar etiquetas ao projeto
• Carregar e etiquetar imagens
• Preparar 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 (formação)(previsão)| Artefato (Maven) (treinamento)(previsão) | Amostras

Pré-requisitos

• Uma assinatura do Azure - Crie uma gratuitamente
• A versão atual do Java Development Kit (JDK)
• A ferramenta de compilação Gradle ou outro gerenciador de dependência.
• 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 previsão.
  • Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, você gravará suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Aceda ao portal do Azure. Se os recursos da Visão Personalizada criados na seção Pré-requisitos forem implantados com êxito, 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 finais dos recursos, em Gerenciamento de recursos. Você precisará obter as chaves para seus recursos de treinamento e previsão, juntamente com os pontos de extremidade da API.

Você pode encontrar a ID do recurso de previsão na guia Propriedades do recurso de previsão no portal do Azure, listada como ID do Recurso.

Gorjeta

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

Atenção

Não inclua a chave diretamente no seu código e nunca a publique publicamente. Consulte 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 de console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

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

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 lerão 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 a partir da janela do console para tornar as alterações efetivas.

Configuração

Criar um novo projeto Gradle

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

mkdir myapp && cd myapp

Execute o comando a gradle init partir do seu diretório de trabalho. Este comando criará arquivos de compilação essenciais para o Gradle, incluindo build.gradle.kts, que é usado em tempo de execução para criar e configurar seu aplicativo.

gradle init --type basic

Quando solicitado a escolher uma DSL, selecione Kotlin.

Instalar a biblioteca de cliente

Localize build.gradle.kts e abra-o com o seu IDE ou editor de texto preferido. Em seguida, copie na seguinte configuração de compilação. Esta configuração define o projeto como uma aplicação Java cujo ponto de entrada é a classe CustomVisionQuickstart. Ele importa as bibliotecas de 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

No diretório de trabalho, execute o seguinte comando 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-o em seu editor ou IDE preferido e adicione as seguintes import instruções:

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

import com.google.common.io.ByteStreams;

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

Gorjeta

Quer ver todo o ficheiro de código do início rápido de uma vez? Pode encontrá-lo no GitHub, que contém os exemplos de código deste início rápido.

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

Aceda ao portal do Azure. Se os recursos da Visão Personalizada criados na seção Pré-requisitos forem implantados com êxito, selecione o botão Ir para o recurso em Próximas etapas. Você pode encontrar suas chaves e ponto de extremidade nas páginas de chave e ponto final dos recursos. Você precisará obter as chaves para seus recursos de treinamento e previsão, juntamente com o ponto de extremidade da API para seu recurso de treinamento.

Você pode encontrar a ID do recurso de previsão na guia Propriedades do recurso no portal do Azure, listada como ID do Recurso.

Importante

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

No método principal 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 cliente Java Custom Vision.

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

Exemplos de código

Esses trechos de código mostram como executar as seguintes tarefas com a biblioteca de cliente Custom Vision para Java:

• Autenticar o cliente
• Criar um novo projeto de Visão Personalizada
• Adicionar tags ao projeto
• Carregue e marque imagens
• Treinar o projeto
• Publicar a iteração atual
• Testar o ponto de extremidade de previsão

Autenticar o cliente

Em seu método principal, instancie clientes de treinamento e previsão usando seu endpoint 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

T## Criar um novo projeto de Visão Personalizada

Este próximo método cria um projeto de classificação de imagem. O projeto criado aparece no site da Visão Personalizada ao qual acedeu anteriormente. Consulte as sobrecargas do método CreateProject para especificar outras opções ao criar seu projeto (explicado no guia do portal da Web Criar um detetor).

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 etiquetas ao seu projeto

Esse método define as tags nas quais 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 etiquetar imagens

Primeiro, faça o download das imagens de exemplo para este projeto. Salve o conteúdo da pasta 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 trecho de código anterior faz uso de duas funções auxiliares que recuperam as imagens como fluxos de recursos e as carregam para o 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;
}

Preparar 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 torna a iteração atual do modelo disponível para consulta. Você pode usar o nome do modelo como referência para enviar solicitações de previsão. Você precisa inserir seu próprio valor para predictionResourceId. Você pode encontrar a ID do recurso de previsão na guia Propriedades do recurso no portal do Azure, listada 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

Esse 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 a aplicação

Você pode criar o aplicativo com:

gradle build

Execute o aplicativo com o gradle run comando:

gradle run

Clean up resources (Limpar recursos)

Se quiser limpar e remover uma assinatura de serviços do Azure AI, você pode excluir o recurso ou grupo de recursos. A exclusão do grupo de recursos também exclui quaisquer outros recursos associados a ele.

• Portal
• CLI do Azure

Se desejar implementar o seu próprio projeto de classificação de imagens (ou, em vez disso, experimentar um projeto de deteção de objetos), deve eliminar o projeto de identificação de árvores deste exemplo. Uma assinatura gratuita permite dois projetos de Visão Personalizada.

No Site de Visão Personalizada, navegue para Projetos e selecione o caixote do lixo em O Meu Novo Projeto.

Próximos passos

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

Test and retrain a model (Testar e voltar a preparar um modelo)

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

Este guia fornece instruções e código de exemplo para ajudá-lo a começar a usar a biblioteca de cliente da Visão Personalizada para Node.js para criar um modelo de classificação de imagem. Você criará um projeto, adicionará tags, 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 seu próprio aplicativo de reconhecimento de imagem.

Nota

Se você quiser criar e treinar um modelo de classificação sem escrever código, consulte as diretrizes baseadas em navegador.

Use a biblioteca de cliente Custom Vision para .NET para:

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

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

Pré-requisitos

• Subscrição do Azure - Criar uma gratuitamente
• A versão atual do Node.js
• 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 previsão.
  • Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, você gravará suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Aceda ao portal do Azure. Se os recursos da Visão Personalizada criados na seção Pré-requisitos forem implantados com êxito, 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 finais dos recursos, em Gerenciamento de recursos. Você precisará obter as chaves para seus recursos de treinamento e previsão, juntamente com os pontos de extremidade da API.

Você pode encontrar a ID do recurso de previsão na guia Propriedades do recurso de previsão no portal do Azure, listada como ID do Recurso.

Gorjeta

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

Atenção

Não inclua a chave diretamente no seu código e nunca a publique publicamente. Consulte 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 de console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

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

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 lerão 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 a partir da janela do console para tornar as alterações efetivas.

Configuração

Criar uma nova aplicação Node.js

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

mkdir myapp && cd myapp

Execute o comando npm init para criar uma aplicação de nó com um ficheiro package.json.

npm init

Instalar a biblioteca de cliente

Para escrever um aplicativo de análise de imagem com o Custom Vision for Node.js, você precisará dos pacotes Custom Vision NPM. Para instalá-los, execute o seguinte comando no PowerShell:

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

O ficheiro package.json da sua aplicação 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");

Gorjeta

Quer ver todo o ficheiro de código do início rápido de uma vez? Pode encontrá-lo no GitHub, que contém os exemplos de código deste início rápido.

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

// retrieve environment variables
const trainingKey = process.env["VISION_TRAINING_KEY"];
const trainingEndpoint = process.env["VISION_TRAINING_ENDPOINT"];

const predictionKey = process.env["VISION_PREDICTION_KEY"];
const predictionResourceId = process.env["VISION_PREDICTION_RESOURCE_ID"];
const predictionEndpoint = process.env["VISION_PREDICTION_ENDPOINT"];

Adicione também 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
FormaçãoAPIClient	Esta classe lida com a criação, treinamento e publicação de seus modelos.
PrevisãoAPIClient	Esta classe lida com a consulta de seus modelos para previsões de classificação de imagem.
Predição	Essa interface define uma única previsão em uma única imagem. Inclui propriedades para o ID e o nome do objeto e uma pontuação de confiança.

Exemplos de código

Esses trechos de código mostram como executar as seguintes tarefas com a biblioteca de cliente Custom Vision para JavaScript:

• Autenticar o cliente
• Criar um novo projeto de Visão Personalizada
• Adicionar tags ao projeto
• Carregue e marque imagens
• Treinar o projeto
• Publicar a iteração atual
• Testar o ponto de extremidade de previsão

Autenticar o cliente

Instancie objetos de cliente com seu ponto de extremidade e chave. Crie um objeto ApiKeyCredentials com sua chave e use-o com seu 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 Visão Personalizada. Adicione o seguinte código para criar um novo projeto de serviço de Visão Personalizada.

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

Adicionar etiquetas ao projeto

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

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

Carregar e etiquetar imagens

Primeiro, faça o download das imagens de exemplo para este projeto. Salve o conteúdo da pasta Imagens de exemplo em seu dispositivo local.

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

const sampleDataRoot = "Images";

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

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

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

await Promise.all(fileUploadPromises);

Importante

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

Preparar o projeto

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

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

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

Publicar a iteração atual

Este código publica a iteração treinada para o 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 seguinte código à sua função.

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

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

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

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

})()

Executar a aplicação

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

node index.js

O resultado da aplicação deverá 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/) está marcada apropriadamente. Também pode regressar ao site da Visão Personalizada e ver o estado atual do projeto criado recentemente.

Se desejar implementar o seu próprio projeto de classificação de imagens (ou, em vez disso, experimentar um projeto de deteção de objetos), deve eliminar o projeto de identificação de árvores deste exemplo. Uma assinatura gratuita permite dois projetos de Visão Personalizada.

No Site de Visão Personalizada, navegue para Projetos e selecione o caixote do lixo em O Meu Novo Projeto.

Próximos passos

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

Test and retrain a model (Testar e voltar a preparar um modelo)

• O que é Visão Personalizada?
• O código-fonte deste exemplo 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 cliente Custom Vision 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á tags, 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 seu próprio aplicativo de reconhecimento de imagem.

Nota

Se você quiser criar e treinar um modelo de classificação sem escrever código, consulte as diretrizes baseadas em navegador.

Use a biblioteca de cliente Custom Vision para Python para:

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

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

Pré-requisitos

• Subscrição do Azure - Criar uma gratuitamente
• Python 3.x
  • Sua instalação do Python deve incluir pip. Você pode verificar se você tem pip instalado executando pip --version na linha de comando. Obtenha pip instalando a versão mais recente do Python.
• 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 previsão.
  • Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, você gravará suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Aceda ao portal do Azure. Se os recursos da Visão Personalizada criados na seção Pré-requisitos forem implantados com êxito, 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 finais dos recursos, em Gerenciamento de recursos. Você precisará obter as chaves para seus recursos de treinamento e previsão, juntamente com os pontos de extremidade da API.

Você pode encontrar a ID do recurso de previsão na guia Propriedades do recurso de previsão no portal do Azure, listada como ID do Recurso.

Gorjeta

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

Atenção

Não inclua a chave diretamente no seu código e nunca a publique publicamente. Consulte 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 de console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

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

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 lerão 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 a partir da janela do console para tornar as alterações efetivas.

Configuração

Instalar a biblioteca de cliente

Para escrever um aplicativo de análise de imagem com o Custom Vision for Python, você precisará da biblioteca de cliente do Custom Vision. Depois de instalar o Python, execute o seguinte comando no PowerShell ou em uma janela do console:

pip install azure-cognitiveservices-vision-customvision

Criar uma aplicação Python nova

Crie um novo arquivo Python e importe as seguintes bibliotecas.

from azure.cognitiveservices.vision.customvision.training import CustomVisionTrainingClient
from azure.cognitiveservices.vision.customvision.prediction import CustomVisionPredictionClient
from azure.cognitiveservices.vision.customvision.training.models import ImageFileCreateBatch, ImageFileCreateEntry, Region
from msrest.authentication import ApiKeyCredentials
import os, time, uuid

Gorjeta

Quer ver todo o ficheiro de código do início rápido de uma vez? Pode encontrá-lo no GitHub, que contém os exemplos de código deste início rápido.

Crie variáveis para o ponto de extremidade e as chaves do Azure do seu 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	Esta classe lida com a criação, treinamento e publicação de seus modelos.
CustomVisionPredictionClient	Esta classe lida com a consulta de seus modelos para previsões de classificação de imagem.
ImagePrediction	Essa classe define uma previsão de objeto único em uma única imagem. Ele inclui propriedades para o ID e o nome do objeto, o local da caixa delimitadora do objeto e uma pontuação de confiança.

Exemplos de código

Esses trechos de código mostram como fazer o seguinte com a biblioteca de cliente Custom Vision para Python:

• Autenticar o cliente
• Criar um novo projeto de Visão Personalizada
• Adicionar tags ao projeto
• Carregue e marque imagens
• Treinar o projeto
• Publicar a iteração atual
• Testar o ponto de extremidade de previsão

Autenticar o cliente

Instancie um cliente de treinamento e previsão com seu endpoint e 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 seguinte ao seu script para criar um novo projeto do serviço de Visão Personalizada.

Consulte 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 etiquetas ao projeto

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

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

Carregar e etiquetar imagens

Primeiro, faça o download das imagens de exemplo para este projeto. Salve o conteúdo da pasta Imagens de exemplo em seu dispositivo local.

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

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

print("Adding images...")

image_list = []

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

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

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

Nota

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

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

Gorjeta

Treinar com tags selecionadas

Opcionalmente, você pode treinar apenas em um subconjunto de suas tags aplicadas. Você pode querer fazer isso se ainda não aplicou o suficiente de certas tags, mas você tem o suficiente de outras. Na chamada train_project, defina o parâmetro opcional selected_tags para uma lista das cadeias de caracteres de ID das tags que você deseja usar. O modelo treinará para reconhecer apenas as tags 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 torna a iteração atual do modelo disponível 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 final de predição e obter a mesma, adicione o seguinte código no fim do ficheiro:

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

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

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

Executar a aplicação

Execute CustomVisionQuickstart.py.

python CustomVisionQuickstart.py

O resultado da aplicação deverá 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ê pode verificar se a imagem de teste (encontrada em <base_image_location>/images/Test/) está marcada adequadamente. Também pode regressar ao site da Visão Personalizada e ver o estado atual do projeto criado recentemente.

Clean up resources (Limpar recursos)

Se desejar implementar o seu próprio projeto de classificação de imagens (ou, em vez disso, experimentar um projeto de deteção de objetos), deve eliminar o projeto de identificação de árvores deste exemplo. Uma assinatura gratuita permite dois projetos de Visão Personalizada.

No Site de Visão Personalizada, navegue para Projetos e selecione o caixote do lixo em O Meu Novo Projeto.

Próximos passos

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

Test and retrain a model (Testar e voltar a preparar um modelo)

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

Comece a usar a API REST do Custom Vision. Siga estas etapas para chamar a API e criar um modelo de classificação de imagem. Você criará um projeto, adicionará tags, 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 seu próprio aplicativo de reconhecimento de imagem.

Nota

A Visão Personalizada é mais facilmente usada por meio de um SDK de biblioteca de cliente ou por meio da orientação baseada em navegador.

Use a biblioteca de cliente Custom Vision para .NET para:

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

Pré-requisitos

• Subscrição do Azure - Criar uma gratuitamente
• 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 previsão e obter suas chaves e ponto de extremidade. Aguarde a implantação e clique no botão Ir para recurso.
  • Você precisará da chave e do ponto de extremidade dos recursos criados para conectar seu aplicativo à Visão Personalizada. Você colará sua chave e ponto de extremidade no código abaixo mais adiante no início rápido.
  • Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente 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 seguinte para criar um projeto de classificação de imagem. O projeto criado aparecerá 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 rosto válida.
• Substitua {endpoint} pelo ponto de extremidade que corresponde à sua chave.

  Nota

  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, consulte Nomes de subdomínio personalizados para serviços de IA do Azure.

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

Você receberá uma resposta JSON como a seguinte. Salve o "id" valor do seu projeto em um local temporário.

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

Adicionar etiquetas ao projeto

Use o comando a seguir para definir as tags 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 própria chave e URL do ponto final.
• Substitua {projectId} pelo seu próprio ID de projeto.
• Substitua {name} pelo nome da tag que você deseja usar.

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

Você receberá uma resposta JSON como a seguinte. Salve o "id" valor de cada tag em um local temporário.

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

Carregar e etiquetar imagens

Em seguida, faça o download das imagens de exemplo para este projeto. Salve o conteúdo da pasta Imagens de exemplo em seu dispositivo local.

Use o seguinte comando para carregar as imagens e aplicar tags; uma vez para as imagens de "Cicuta" e separadamente para as imagens de "Cereja Japonesa". Consulte a API Criar imagens a partir de 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 própria chave e URL do ponto final.
• Substitua {projectId} pelo seu próprio ID de projeto.
• Substitua {tagArray} pelo ID de uma tag.
• Em seguida, preencha o corpo da solicitação com os dados binários das imagens que você deseja marcar.

Preparar o projeto

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

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

• Novamente, insira sua própria chave e URL do ponto final.
• Substitua {projectId} pelo seu próprio ID de projeto.
• Substitua {tagArray} pelo ID de uma tag.
• 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. Consulte a API do projeto Train para obter opções.

Gorjeta

Treinar com tags selecionadas

Opcionalmente, você pode treinar apenas em um subconjunto de suas tags aplicadas. Você pode querer fazer isso se ainda não aplicou o suficiente de certas tags, mas você tem o suficiente de outras. Adicione o conteúdo JSON opcional ao corpo da sua solicitação. Preencha a "selectedTags" matriz com as IDs das tags que você deseja usar.

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

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

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

Publicar a iteração atual

Esse método torna a iteração atual do modelo disponível para consulta. Use o nome do modelo retornado como 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 própria chave e URL do ponto final.
• Substitua {projectId} pelo seu próprio ID de projeto.
• Substitua {iterationId} pelo ID retornado na etapa anterior.
• Substitua {publishedName} pelo nome que você gostaria de atribuir ao seu modelo de previsão.
• Substitua {predictionId} pelo seu próprio ID de recurso de previsão. Você pode encontrar a ID do recurso de previsão na guia Propriedades do recurso no portal do Azure, listada como ID do Recurso.
• Opcionalmente, use outros parâmetros de URL. Consulte a API de iteração de publicação.

Testar o ponto de extremidade de previsão

Finalmente, use este comando para testar seu modelo treinado carregando uma nova imagem para que ele classifique com tags. Você pode usar a imagem na pasta "Test" 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 própria chave e URL do ponto final.
• Substitua {projectId} pelo seu próprio ID de projeto.
• Substitua {publishedName} pelo nome usado na etapa anterior.
• Adicione os dados binários da imagem local ao corpo da solicitação.
• Opcionalmente, use outros parâmetros de URL. Consulte a API Classify Image .

A resposta JSON retornada listará cada uma das tags que o modelo aplicou à sua imagem, juntamente com pontuações de probabilidade para cada tag.

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

Se desejar implementar o seu próprio projeto de classificação de imagens (ou, em vez disso, experimentar um projeto de deteção de objetos), deve eliminar o projeto de identificação de árvores deste exemplo. Uma assinatura gratuita permite dois projetos de Visão Personalizada.

No Site de Visão Personalizada, navegue para Projetos e selecione o caixote do lixo em O Meu Novo Projeto.

Próximos passos

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

Test and retrain a model (Testar e voltar a preparar um modelo)

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