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

Comece com a biblioteca cliente de 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 tags, treinar o projeto e usar a URL do endpoint 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.

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 Azure. Você pode criar um gratuitamente.
• A versão Visual Studio IDE ou atual do .NET Core.
• Depois de ter sua assinatura Azure, crie um recurso Custom Vision no portal Azure para criar um recurso de treinamento e um recurso de previsão.
  • Você pode usar o tipo de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para uma camada paga para produção.

Criar variáveis de ambiente

Neste exemplo, você escreverá suas credenciais em variáveis de ambiente no computador local que executa o aplicativo.

Vá para o portal do Azure. Se os recursos da Visão Personalizada que você criou na seção Pré-requisitos forem implantados com êxito, selecione o botão Ir para Recurso nas próximas etapas. Você pode encontrar suas chaves e pontos de extremidade nas páginas chaves e ponto de extremidade dos recursos, em Gerenciamento de Recursos. Você precisará obter as chaves para os dois recursos: o de treinamento e o de previsão, juntamente com os endpoints da API.

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

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

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

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

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>

Configurando

dotnet new console -n custom-vision-quickstart

dotnet build

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

dotnet add package Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training --version 2.0.0
dotnet add package Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction --version 2.0.0

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

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

No método main do aplicativo, crie variáveis que recuperem as chaves e os pontos de extremidade dos recursos das 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 do main 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 método inovador, instancie clientes de treinamento e previsão através do 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 aparece 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 "Construir um classificador" Build a classifier).

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

Adicionar marcas ao projeto

Esse método define as tags 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 sample Images em seu dispositivo local.

Em seguida, defina um método auxiliar para carregar as imagens neste diretório. Talvez seja necessário editar o GetFiles argumento 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 iterativamente ou em um lote (até 64 por lote). Este snippet 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 }));

}

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

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 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 Properties do recurso no portal Azure, listada como Resource ID.

private static void PublishIteration(CustomVisionTrainingClient trainingApi, Project project)
{
    trainingApi.PublishIteration(project.Id, iteration.Id, publishedModelName, predictionResourceId);
    Console.WriteLine("Done!\n");

    // Now there is a trained endpoint, it can be used to make a prediction
}

Testar o ponto 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

dotnet run

À medida que 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/) está marcada adequadamente. Pressione qualquer tecla para sair do aplicativo. Você também pode voltar ao site da Visão Personalizada e ver o estado atual do seu projeto recém-criado.

Limpar recursos

Se você quiser implementar seu próprio projeto de classificação de imagem (ou tentar um projeto de detecção de objetos ), talvez queira excluir o projeto de identificação de árvore deste exemplo. Uma assinatura gratuita permite dois projetos de Visão Personalizada.

No site Custom Vision, 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 feita 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.

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

Este guia fornece instruções e código de exemplo para ajudá-lo a começar a usar a biblioteca de clientes da Visão Personalizada para Go 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 seu próprio aplicativo de reconhecimento de imagem.

Use a biblioteca de clientes da Visão Personalizada para Ir 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 Azure. Você pode criar um gratuitamente.
• Vá para 1,8 ou posterior.
• Depois de ter sua assinatura Azure, crie um recurso Custom Vision no portal Azure para criar um recurso de treinamento e previsão.
  • Você pode usar o tipo de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para uma camada paga para produção.

Criar variáveis de ambiente

Neste exemplo, você escreverá suas credenciais em variáveis de ambiente no computador local que executa o aplicativo.

Vá para o portal do Azure. Se os recursos da Visão Personalizada que você criou na seção Pré-requisitos forem implantados com êxito, selecione o botão Ir para Recurso nas próximas etapas. Você pode encontrar suas chaves e pontos de extremidade nas páginas chaves e ponto de extremidade dos recursos, em Gerenciamento de Recursos. Você precisará obter as chaves para os dois recursos: o de treinamento e o de previsão, juntamente com os endpoints da API.

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

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

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

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

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>

Configurando

Instalar a biblioteca de clientes da Visão Personalizada

Para escrever um aplicativo de análise de imagens com o Custom Vision para Go, você precisa da biblioteca do 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 dep, execute no seu repositório:

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

Obter as imagens de exemplo

Este exemplo usa as imagens do repositório Foundry Tools Python SDK Samples no GitHub. Clone ou baixe esse repositório em seu ambiente de desenvolvimento. Lembre-se da localização da pasta para um passo posterior.

Criar o projeto de Visão Personalizada

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

Adicione o código a seguir ao script para criar um novo projeto de 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 "Construir um classificador" Build a classifier).

import(
    "context"
    "bytes"
    "fmt"
    "io/ioutil"
    "path"
    "log"
    "time"
    "github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v3.0/customvision/training"
    "github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v3.0/customvision/prediction"
)

var (
    training_key string = os.Getenv("VISION_TRAINING_KEY")
    prediction_key string = os.Getenv("VISION_PREDICTION_KEY")
    prediction_resource_id = os.Getenv("VISION_PREDICTION_RESOURCE_ID")
    endpoint string = os.Getenv("VISION_ENDPOINT")    

    project_name string = "Go Sample Project"
    iteration_publish_name = "classifyModel"
    sampleDataDirectory = "<path to sample images>"
)

func main() {
    fmt.Println("Creating project...")

    ctx = context.Background()

    trainer := training.New(training_key, endpoint)

    project, err := trainer.CreateProject(ctx, project_name, "sample project", nil, string(training.Multilabel))
    if (err != nil) {
        log.Fatal(err)
    }

Criar tags no projeto

Para criar marcas de classificação ao seu projeto, adicione o seguinte código ao final do sample.go:

// Make two tags in the new project
hemlockTag, _ := trainer.CreateTag(ctx, *project.ID, "Hemlock", "Hemlock tree tag", string(training.Regular))
cherryTag, _ := trainer.CreateTag(ctx, *project.ID, "Japanese Cherry", "Japanese cherry tree tag", string(training.Regular))

Carregar e marcar imagens

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

fmt.Println("Adding images...")
japaneseCherryImages, err := ioutil.ReadDir(path.Join(sampleDataDirectory, "Japanese Cherry"))
if err != nil {
    fmt.Println("Error finding Sample images")
}

hemLockImages, err := ioutil.ReadDir(path.Join(sampleDataDirectory, "Hemlock"))
if err != nil {
    fmt.Println("Error finding Sample images")
}

for _, file := range hemLockImages {
    imageFile, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "Hemlock", file.Name()))
    imageData := ioutil.NopCloser(bytes.NewReader(imageFile))

    trainer.CreateImagesFromData(ctx, *project.ID, imageData, []string{ hemlockTag.ID.String() })
}

for _, file := range japaneseCherryImages {
    imageFile, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "Japanese Cherry", file.Name()))
    imageData := ioutil.NopCloser(bytes.NewReader(imageFile))
    trainer.CreateImagesFromData(ctx, *project.ID, imageData, []string{ cherryTag.ID.String() })
}

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 fornecido para a iteração publicada pode ser usado para enviar solicitações de previsão. Uma iteração só está disponível no endpoint de previsão quando tiver sido 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ê pode verificar se a imagem de teste (encontrada em <base_image_url>/Images/Test/) está marcada adequadamente. Você também pode voltar ao site da Visão Personalizada e ver o estado atual do seu projeto recém-criado.

Limpar recursos

Se você quiser implementar seu próprio projeto de classificação de imagem (ou tentar um projeto de detecção de objetos ), talvez queira excluir o projeto de identificação de árvore deste exemplo. Uma assinatura gratuita permite dois projetos de Visão Personalizada.

No site Custom Vision, 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 feita 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.

• O que é a 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 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.

Use a biblioteca de clientes da Visão Personalizada para Java 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 Referência | Código-fonte da biblioteca para (treinamento) e (predição)| Artefato (Maven) para (treinamento) e (predição) | Exemplos

Pré-requisitos

• Uma assinatura Azure. Você pode criar um gratuitamente.
• A versão atual do Java Development Kit (JDK).
• A ferramenta de construção Gradle ou outro gerenciador de dependências.
• Depois de ter sua assinatura Azure, crie um recurso Custom Vision no portal Azure para criar um recurso de treinamento e previsão.
  • Você pode usar o tipo de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para uma camada paga para produção.

Criar variáveis de ambiente

Neste exemplo, você escreverá suas credenciais em variáveis de ambiente no computador local que executa o aplicativo.

Vá para o portal do Azure. Se os recursos da Visão Personalizada que você criou na seção Pré-requisitos forem implantados com êxito, selecione o botão Ir para Recurso nas próximas etapas. Você pode encontrar suas chaves e pontos de extremidade nas páginas chaves e ponto de extremidade dos recursos, em Gerenciamento de Recursos. Você precisará obter as chaves para os dois recursos: o de treinamento e o de previsão, juntamente com os endpoints da API.

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

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

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

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

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>

Configurando

Criar um novo projeto do Gradle

Em uma janela do 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 a partir do seu diretório de trabalho. Esse comando cria arquivos de build essenciais para o Gradle, incluindo build.gradle.kts, que é usado em runtime para criar e configurar seu aplicativo.

gradle init --type basic

Quando solicitado a escolher uma DSL, selecione Kotlin.

Instalar a biblioteca de clientes

Localize build.gradle.kts e abra-o com seu IDE ou editor de texto preferido. Em seguida, copie a configuração de build a seguir. Essa configuração define o projeto como um aplicativo Java cujo ponto de entrada é a classe CustomVisionQuickstart. Ele importa as bibliotecas do Custom Vision.

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

Criar um arquivo de 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 preferencial ou IDE e adicione as seguintes import instruções:

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

import com.google.common.io.ByteStreams;

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

Na classe CustomVisionQuickstart do aplicativo, crie variáveis que recuperem as chaves e o endpoint 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");

No método do main 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 cliente Java da Visão Personalizada.

Exemplos de código

Esses 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 tags 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

Em seu main método, instancie clientes de treinamento e predição usando o ponto de extremidade e as chaves.

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

Criar um projeto de Visão Personalizada

Este próximo método cria um projeto de classificação de imagem. O projeto criado aparecerá no site da Visão Personalizada que você visitou 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 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 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 marcar imagens

Primeiro, baixe as imagens de exemplo para este projeto. Salve o conteúdo da pasta sample Images 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 usa duas funções auxiliares que recuperam as imagens como fluxos de recursos e as carregam 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 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 Properties do recurso no portal Azure, listada como Resource ID.

public static String publishIteration(CustomVisionTrainingClient trainClient, Project project) {
    Trainings trainer = trainClient.trainings();
    // The iteration is now trained. Publish it to the prediction endpoint.
    String publishedModelName = "myModel";
    trainer.publishIteration(project.id(), iteration.id(), publishedModelName, predictionResourceId);
}

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

Você pode criar o aplicativo com:

gradle build

Execute o aplicativo com o gradle run comando:

gradle run

Limpar recursos

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

• Portal do Azure
• CLI do Azure

Se você quiser implementar seu próprio projeto de classificação de imagem (ou tentar um projeto de detecção de objetos ), talvez queira excluir o projeto de identificação de árvore deste exemplo. Uma assinatura gratuita permite dois projetos de Visão Personalizada.

No site Custom Vision, 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 feita 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.

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

Este guia fornece instruções e código de exemplo para ajudá-lo a começar a usar a biblioteca de clientes da Visão Personalizada para Node.js criar um modelo de classificação de imagem. Você pode criar um projeto, adicionar tags, treinar o projeto e usar a URL do endpoint de predição do projeto para testá-lo programaticamente. Use este exemplo como um modelo para criar seu próprio aplicativo de reconhecimento de imagem.

Use a biblioteca de clientes da Visão Personalizada para 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 Azure. Você pode criar um gratuitamente.
• A versão atual do Node.js.
• Depois de ter sua assinatura Azure, crie um recurso Custom Vision no portal Azure para criar um recurso de treinamento e previsão.
  • Você pode usar o tipo de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para uma camada paga para produção.

Criar variáveis de ambiente

Neste exemplo, você escreverá suas credenciais em variáveis de ambiente no computador local que executa o aplicativo.

Vá para o portal do Azure. Se os recursos da Visão Personalizada que você criou na seção Pré-requisitos forem implantados com êxito, selecione o botão Ir para Recurso nas próximas etapas. Você pode encontrar suas chaves e pontos de extremidade nas páginas chaves e ponto de extremidade dos recursos, em Gerenciamento de Recursos. Você precisará obter as chaves para os dois recursos: o de treinamento e o de previsão, juntamente com os endpoints da API.

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

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

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

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

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>

Configurando

Criar um novo aplicativo Node.js

Em uma janela do 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 Node com um arquivo package.json. Pressione 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 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 aplicativo é atualizado com as dependências.

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

const util = require('util');
const fs = require('fs');
const TrainingApi = require("@azure/cognitiveservices-customvision-training");
const PredictionApi = require("@azure/cognitiveservices-customvision-prediction");
const msRest = require("@azure/ms-rest-js");

Criar variáveis para o endpoint de Azure e as chaves de acesso 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"];

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

Exemplos de código

Esses snippets de código mostram como fazer 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 tags 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

Instancie objetos de cliente com seu endpoint e chave. Crie um objeto ApiKeyCredentials com sua chave e utilize-o com o endpoint para criar objetos 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 englobar todas as suas chamadas de função do Custom Vision. Adicione o código a seguir 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 marcas ao projeto

Para criar marcas 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 marcar imagens

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

Para adicionar as imagens de exemplo ao projeto, insira o código a seguir logo após a criação da tag. 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);

Treinar o projeto

Esse 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 no endpoint de previsão. O nome fornecido para a iteração publicada pode ser usado para enviar solicitações de previsão. Uma iteração só está disponível no endpoint de previsão quando tiver sido 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 à 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 de Visão Personalizada e depois chame-a.

})()

Executar o aplicativo

Execute o aplicativo com o node comando no 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/) está marcada adequadamente. Você também pode voltar ao site da Visão Personalizada e ver o estado atual do seu projeto recém-criado.

Se você quiser implementar seu próprio projeto de classificação de imagem (ou tentar um projeto de detecção de objetos ), talvez queira excluir o projeto de identificação de árvore deste exemplo. Uma assinatura gratuita permite dois projetos de Visão Personalizada.

No site Custom Vision, 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 única iteração de treinamento, mas muitas vezes você precisará treinar e testar seu modelo várias vezes para torná-lo mais preciso.

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

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

Use a biblioteca de clientes da Visão Personalizada para Python 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 | Código-fonte da biblioteca | Pacote (PyPI) | Amostras

Pré-requisitos

• Uma assinatura Azure. Você pode criar um gratuitamente.
• Python 3.x.
  • Sua instalação Python deve incluir pip. Você pode verificar se o pip foi instalado executando pip --version na linha de comando. Para obter o pip, instale a versão mais recente do Python.
• Depois de ter sua assinatura Azure, crie um recurso Custom Vision no portal Azure para criar um recurso de treinamento e previsão.
  • Você pode usar o tipo de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para uma camada paga para produção.

Criar variáveis de ambiente

Neste exemplo, você escreverá suas credenciais em variáveis de ambiente no computador local que executa o aplicativo.

Vá para o portal do Azure. Se os recursos da Visão Personalizada que você criou na seção Pré-requisitos forem implantados com êxito, selecione o botão Ir para Recurso nas próximas etapas. Você pode encontrar suas chaves e pontos de extremidade nas páginas chaves e ponto de extremidade dos recursos, em Gerenciamento de Recursos. Você precisará obter as chaves para os dois recursos: o de treinamento e o de previsão, juntamente com os endpoints da API.

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

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

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

setx VISION_TRAINING_KEY <your-training-key>

setx VISION_TRAINING_ENDPOINT <your-training-endpoint>

setx VISION_PREDICTION_KEY <your-prediction-key>

setx VISION_PREDICTION_ENDPOINT <your-prediction-endpoint>

setx VISION_PREDICTION_RESOURCE_ID <your-resource-id>

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>

Configurando

Instalar a biblioteca de clientes

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

pip install azure-cognitiveservices-vision-customvision

Criar um novo aplicativo Python

Crie um novo arquivo 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

Criar variáveis para o endpoint de Azure e as chaves de acesso do recurso.

# retrieve environment variables
ENDPOINT = os.environ["VISION_TRAINING_ENDPOINT"]
prediction_endpoint = os.environ["VISION_PREDICTION_ENDPOINT"]
training_key = os.environ["VISION_TRAINING_KEY"]
prediction_key = os.environ["VISION_PREDICTION_KEY"]
prediction_resource_id = os.environ["VISION_PREDICTION_RESOURCE_ID"]

Modelo de objeto

Exemplos de código

Esses snippets de código mostram como fazer o seguinte com a biblioteca de clientes da Visão Personalizada para Python:

• Autenticar o cliente
• Criar um novo projeto de Visão Personalizada
• Adicionar tags 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

Instancie um cliente de treinamento e previsão usando seu endpoint e suas chaves. Crie ApiKeyServiceClientCredentials objetos com suas chaves e utilize-as junto ao endpoint para criar objetos 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(prediction_endpoint, prediction_credentials)

Criar um novo projeto de Visão Personalizada

Adicione o código a seguir ao script para criar um novo projeto de 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 web Build a classifier).

publish_iteration_name = "classifyModel"

credentials = ApiKeyCredentials(in_headers={"Training-key": training_key})
trainer = CustomVisionTrainingClient(ENDPOINT, credentials)

# Create a new project
print ("Creating project...")
project_name = uuid.uuid4()
project = trainer.create_project(project_name)

Adicionar marcas 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 marcar imagens

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

Para adicionar as imagens de exemplo ao projeto, insira o código a seguir logo após a criação da tag. 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)

Treinar o projeto

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

print ("Training...")
iteration = trainer.train_project(project.id)
while (iteration.status != "Completed"):
    iteration = trainer.get_iteration(project.id, iteration.id)
    print ("Training status: " + iteration.status)
    print ("Waiting 10 seconds...")
    time.sleep(10)

Publicar a iteração atual

Uma iteração só está disponível no endpoint de previsão quando tiver sido 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(prediction_endpoint, prediction_credentials)

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

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

Executar 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ê pode verificar se a imagem de teste (encontrada em <base_image_location>/images/Test/) está marcada adequadamente. Você também pode voltar ao site da Visão Personalizada e ver o estado atual do seu projeto recém-criado.

Limpar recursos

Se você quiser implementar seu próprio projeto de classificação de imagem (ou tentar um projeto de detecção de objetos ), talvez queira excluir o projeto de identificação de árvore deste exemplo. Uma assinatura gratuita permite dois projetos de Visão Personalizada.

No site Custom Vision, 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 feita 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.

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

Comece com a 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 seu próprio aplicativo de reconhecimento de imagem.

Utilize a biblioteca cliente da Visão Personalizada para a 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 Azure. Você pode criar um gratuitamente.
• Depois de ter sua assinatura Azure, crie um recurso Custom Vision no portal Azure para criar um recurso de treinamento e previsão.
  • Você precisa da chave e do ponto de extremidade dos recursos que você cria para conectar seu aplicativo ao Custom Vision. Você colará sua chave e ponto de extremidade no código mais adiante no início rápido.
  • Você pode usar o tipo de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para uma camada paga 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 será exibido no site da Visão Personalizada.

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

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

• Substitua {subscription key} pela chave válida.
• Substitua {endpoint} pelo endpoint associado à 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 Ferramentas de Fundição.

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

Uma resposta JSON como o exemplo a seguir é exibida. Salve o valor "id" do seu projeto em uma localização temporária.

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

Adicionar marcas ao projeto

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

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

Uma resposta JSON como o exemplo a seguir é exibida. 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 marcar imagens

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

Use o comando a seguir para carregar as imagens e aplicar marcas; uma vez para as imagens "Hemlock" e separadamente para as imagens "Japanese Cherry". Consulte a API Criar Imagens 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 de extremidade.
• Substitua {projectId} pelo seu próprio ID do projeto.
• Substitua {tagArray} pela ID de uma tag.
• 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 própria chave e URL do ponto de extremidade.
• Substitua {projectId} pelo seu próprio ID do projeto.
• Substitua {tagArray} pela 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 Train Project para obter opções.

{
  "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 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 de extremidade.
• Substitua {projectId} pelo seu próprio ID do projeto.
• Substitua {iterationId} pela ID retornada na etapa anterior.
• Substitua {publishedName} pelo nome que você gostaria de atribuir ao seu modelo de previsão.
• Substitua {predictionId} por sua própria ID de recurso de previsão. Você pode encontrar a ID do recurso de previsão na guia Properties do recurso no portal Azure, listada como Resource ID.
• Opcionalmente, use outros parâmetros de URL. Consulte a API de Iteração de Publicação .

Testar o ponto de extremidade de previsão

Por fim, use esse comando para testar seu modelo treinado carregando uma nova imagem para que ele possa classificá-la com tags. 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 própria chave e URL do ponto de extremidade.
• Substitua {projectId} pelo seu próprio ID do 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 de Classificação de Imagem .

A resposta JSON retornada lista cada uma das marcas que o modelo aplicou à sua imagem, juntamente com pontuações de probabilidade para 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 seu próprio projeto de classificação de imagem (ou tentar um projeto de detecção de objetos ), talvez queira excluir o projeto de identificação de árvore deste exemplo. Uma assinatura gratuita permite dois projetos de Visão Personalizada.

No site Custom Vision, navegue até Projetos e selecione a lixeira em Meu Novo Projeto.

Conteúdo relacionado

Agora você fez todas as etapas do processo de classificação de imagem 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.

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