Esta versão legada do AutoML Vision foi descontinuada e não estará mais disponível no Google Cloud após 31 de março de 2024. Todas as funcionalidades do AutoML Vision legado e novos recursos estão disponíveis na plataforma da Vertex AI. Consulte Migrar para a Vertex AI para saber como migrar seus recursos.

Tutorial da API do AutoML Vision

Neste tutorial, você aprende como criar um novo modelo com seu próprio conjunto de imagens de treinamento, avaliar os resultados e prever a classificação da imagem de teste usando o AutoML Vision.

O tutorial usa um conjunto de dados com imagens de cinco tipos diferentes de flores: girassóis, tulipas, margaridas, rosas e dentes-de-leão. Ele abrange a formação de um modelo personalizado, avaliando o desempenho do modelo e classificando novas imagens com base no modelo personalizado.

Pré-requisitos

Configurar o ambiente do projeto

Requisito de região: atualmente, os recursos do projeto precisam estar na região us-central1 para usar esta API.

Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs AutoML Vision.

Ative as APIs

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs AutoML Vision.

Ative as APIs

Instale a Google Cloud CLI.
Siga as instruções para criar uma conta de serviço e fazer o download de um arquivo de chave.
Defina a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS para o caminho até o arquivo de chave da conta de serviço que você salvou quando criou essa conta. Por exemplo:
```
export GOOGLE_APPLICATION_CREDENTIALS=KEY_FILE
```
Adicione a nova conta de serviço ao papel do IAM Editor do AutoML com os comandos a seguir. Substitua PROJECT_ID pelo nome do seu projeto do Google Cloud e SERVICE_ACCOUNT_NAME pelo nome da nova conta de serviço, por exemplo, service-account1@myproject.iam.gserviceaccount.com:
```
gcloud auth login
gcloud projects add-iam-policy-binding PROJECT_ID \
 --member="user:YOUR_USERID@YOUR_DOMAIN" \
 --role="roles/automl.admin"
gcloud projects add-iam-policy-binding PROJECT_ID \
 --member=serviceAccount:SERVICE_ACCOUNT_NAME \
 --role="roles/automl.editor"
```

Permita que as contas de serviço do AutoML Vision acessem os recursos do projeto do Google Cloud:

gcloud projects add-iam-policy-binding PROJECT_ID \
 --member="serviceAccount:custom-vision@appspot.gserviceaccount.com" \
 --role="roles/storage.admin"

Instale a biblioteca de cliente.
Defina as variáveis de ambiente PROJECT_ID e REGION_NAME.

Substitua PROJECT_ID pelo ID do projeto do Google Cloud. No momento, o AutoML Vision exige o local us-central1.
```
export PROJECT_ID="PROJECT_ID"
export REGION_NAME="us-central1"
```
Crie um bucket do Cloud Storage para armazenar os documentos que serão usados para treinar o modelo personalizado.

O nome do bucket precisa estar no formato: $PROJECT_ID-vcm. O comando a seguir cria um intervalo de armazenamento na região us-central1 denominada $PROJECT_ID-vcm.
```
gsutil mb -p PROJECT_ID -c regional -l us-central1 gs://PROJECT_ID-vcm/
```
Defina a variável BUCKET.
```
export BUCKET=PROJECT_ID-vcm
```
Copie o conjunto de dados disponível publicamente das imagens de flores de gs://cloud-samples-data/img/flower_photos/ para o bucket do Google Cloud Storage.

Na sessão do Cloud Shell, insira:
```
gsutil -m cp -R gs://cloud-samples-data/ai-platform/flowers/ gs://BUCKET/img/
```
A cópia do arquivo leva cerca de 20 minutos para ser concluída.

Esse comando também copia o arquivo all_data.csv, que lista os nomes de arquivo originais e os rótulos deles.
O conjunto de dados de amostra contém um arquivo CSV com o local e os rótulos de cada imagem. Consulte Como preparar os dados de treinamento para detalhes sobre o formato necessário. Atualize o arquivo .csv para apontar para os arquivos no bucket:
```
gsutil cat gs://BUCKET/img/flowers/all_data.csv | sed "s:cloud-ml-data/img/flower_photos/:BUCKET/img/flowers/:" > all_data.csv
```
Em seguida, copie o arquivo .csv atualizado para o bucket:
```
gsutil cp all_data.csv gs://BUCKET/csv/
```

Locais dos arquivos de código-fonte

Faça o download do código-fonte do local fornecido abaixo. Depois, copie o código-fonte para a pasta do projeto do AutoML Vision.

Python

O tutorial consiste nestes arquivos do Python:

vision_classification_create_dataset.py: inclui a funcionalidade para criar um conjunto de dados.
import_dataset.py: inclui a funcionalidade para importar um conjunto de dados.
vision_classification_create_model.py: inclui a funcionalidade para criar um modelo.
list_model_evaluations.py: inclui a funcionalidade para listar avaliações de modelos.
vision_classification_predict.py: inclui a funcionalidade relacionada à previsão.
delete_model.py: inclui a funcionalidade para excluir um modelo.

Java

O tutorial consiste nestes arquivos do Java:

VisionClassificationCreateDataset.java: inclui a funcionalidade para criar um conjunto de dados.
ImportDataset.java: inclui a funcionalidade para importar um conjunto de dados.
VisionClassificationCreateModel.java: inclui a funcionalidade para criar um modelo.
ListModelEvaluations.java: inclui a funcionalidade para listar avaliações de modelos.
VisionClassificationPredict.java: inclui a funcionalidade relacionada à previsão.
DeleteModel.java: inclui a funcionalidade para excluir um modelo.

Node.js

O tutorial consiste nestes programas do Node.js:

vision_classification_create_dataset.js: inclui a funcionalidade para criar um conjunto de dados.
import_dataset.js: inclui a funcionalidade para importar um conjunto de dados.
vision_classification_create_model.js: inclui a funcionalidade para criar um modelo.
list_model_evaluations.js: inclui a funcionalidade para listar avaliações de modelos.
vision_classification_predict.js: inclui a funcionalidade relacionada à previsão.
delete_model.js: inclui a funcionalidade para excluir um modelo.

Como executar o aplicativo

Etapa 1: criar o conjunto de dados de flores

A primeira etapa no desenvolvimento de um modelo personalizado é criar um conjunto de dados vazio que vai armazenar os dados de treinamento do modelo. Ao criar um conjunto de dados, você especifica o tipo de classificação que quer que seu modelo personalizado execute:

MULTICLASS atribui uma única etiqueta a cada imagem classificada.
MULTILABEL possibilita que vários rótulos sejam atribuídos a uma imagem.

Neste tutorial, você cria um conjunto de dados chamado flowers e usa MULTICLASS.

Copiar o código

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# display_name = "your_datasets_display_name"

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = f"projects/{project_id}/locations/us-central1"
# Specify the classification type
# Types:
# MultiLabel: Multiple labels are allowed for one example.
# MultiClass: At most one label is allowed per example.
# https://cloud.google.com/automl/docs/reference/rpc/google.cloud.automl.v1#classificationtype
metadata = automl.ImageClassificationDatasetMetadata(
    classification_type=automl.ClassificationType.MULTILABEL
)
dataset = automl.Dataset(
    display_name=display_name,
    image_classification_dataset_metadata=metadata,
)

# Create a dataset with the dataset metadata in the region.
response = client.create_dataset(
    parent=project_location, dataset=dataset, timeout=300
)

created_dataset = response.result()

# Display the dataset information
print(f"Dataset name: {created_dataset.name}")
print("Dataset id: {}".format(created_dataset.name.split("/")[-1]))

Java

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ClassificationType;
import com.google.cloud.automl.v1.Dataset;
import com.google.cloud.automl.v1.ImageClassificationDatasetMetadata;
import com.google.cloud.automl.v1.LocationName;
import com.google.cloud.automl.v1.OperationMetadata;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class VisionClassificationCreateDataset {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String displayName = "YOUR_DATASET_NAME";
    createDataset(projectId, displayName);
  }

  // Create a dataset
  static void createDataset(String projectId, String displayName)
      throws IOException, ExecutionException, InterruptedException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // A resource that represents Google Cloud Platform location.
      LocationName projectLocation = LocationName.of(projectId, "us-central1");

      // Specify the classification type
      // Types:
      // MultiLabel: Multiple labels are allowed for one example.
      // MultiClass: At most one label is allowed per example.
      ClassificationType classificationType = ClassificationType.MULTILABEL;
      ImageClassificationDatasetMetadata metadata =
          ImageClassificationDatasetMetadata.newBuilder()
              .setClassificationType(classificationType)
              .build();
      Dataset dataset =
          Dataset.newBuilder()
              .setDisplayName(displayName)
              .setImageClassificationDatasetMetadata(metadata)
              .build();
      OperationFuture<Dataset, OperationMetadata> future =
          client.createDatasetAsync(projectLocation, dataset);

      Dataset createdDataset = future.get();

      // Display the dataset information.
      System.out.format("Dataset name: %s\n", createdDataset.getName());
      // To get the dataset id, you have to parse it out of the `name` field. As dataset Ids are
      // required for other methods.
      // Name Form: `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`
      String[] names = createdDataset.getName().split("/");
      String datasetId = names[names.length - 1];
      System.out.format("Dataset id: %s\n", datasetId);
    }
  }
}

Node.js

Para mais informações, consulte a documentação de referência da API da AutoML VisionNode.js.

Para autenticar no AutoML Vision, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const displayName = 'YOUR_DISPLAY_NAME';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function createDataset() {
  // Construct request
  // Specify the classification type
  // Types:
  // MultiLabel: Multiple labels are allowed for one example.
  // MultiClass: At most one label is allowed per example.
  const request = {
    parent: client.locationPath(projectId, location),
    dataset: {
      displayName: displayName,
      imageClassificationDatasetMetadata: {
        classificationType: 'MULTILABEL',
      },
    },
  };

  // Create dataset
  const [operation] = await client.createDataset(request);

  // Wait for operation to complete.
  const [response] = await operation.promise();

  console.log(`Dataset name: ${response.name}`);
  console.log(`
    Dataset id: ${
      response.name
        .split('/')
        [response.name.split('/').length - 1].split('\n')[0]
    }`);
}

createDataset();

Solicitação

Execute a função create_dataset para criar um conjunto de dados vazio. Você precisa modificar as linhas de código a seguir:

Defina o project_id como o PROJECT_ID.
Defina o display_name do conjunto de dados (flowers).
Altere MULTILABEL para MULTICLASS.

Python

python3 vision_classification_create_dataset.py

Java

mvn compile exec:java -Dexec.mainClass="com.example.automl.VisionClassificationCreateDataset"

Node.js

node vision_classification_create_dataset.js

Resposta

A resposta inclui os detalhes do conjunto de dados recém-criado, como o ID do conjunto de dados que você usará para se referir a ele em solicitações futuras. Recomendamos definir uma variável de ambiente DATASET_ID como o valor do código do conjunto de dados.

Dataset name: projects/216065747626/locations/us-central1/datasets/ICN7372141011130533778
Dataset id: ICN7372141011130533778
Dataset display name: flowers
Image classification dataset specification:
       classification_type: MULTICLASS
Dataset example count: 0
Dataset create time:
       seconds: 1530251987
       nanos: 216586000

Etapa 2: importar imagens para o conjunto de dados

A próxima etapa é enviar imagens de treinamento rotuladas para o conjunto de dados usando os rótulos de destino.

A interface da função import_data recebe como entrada um arquivo .csv que lista os locais de todas as imagens de treinamento e o rótulo adequado de cada uma delas. Saiba mais sobre o formato exigido em Preparar os dados. Neste tutorial, serão usadas as imagens rotuladas que você copiou para o bucket do Cloud Storage, listadas em gs://$PROJECT_ID-vcm/csv/all_data.csv.

Copiar o código

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# dataset_id = "YOUR_DATASET_ID"
# path = "gs://YOUR_BUCKET_ID/path/to/data.csv"

client = automl.AutoMlClient()
# Get the full path of the dataset.
dataset_full_id = client.dataset_path(project_id, "us-central1", dataset_id)
# Get the multiple Google Cloud Storage URIs
input_uris = path.split(",")
gcs_source = automl.GcsSource(input_uris=input_uris)
input_config = automl.InputConfig(gcs_source=gcs_source)
# Import data from the input URI
response = client.import_data(name=dataset_full_id, input_config=input_config)

print("Processing import...")
print(f"Data imported. {response.result()}")

Java

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.DatasetName;
import com.google.cloud.automl.v1.GcsSource;
import com.google.cloud.automl.v1.InputConfig;
import com.google.cloud.automl.v1.OperationMetadata;
import com.google.protobuf.Empty;
import java.io.IOException;
import java.util.Arrays;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

class ImportDataset {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String datasetId = "YOUR_DATASET_ID";
    String path = "gs://BUCKET_ID/path_to_training_data.csv";
    importDataset(projectId, datasetId, path);
  }

  // Import a dataset
  static void importDataset(String projectId, String datasetId, String path)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // Get the complete path of the dataset.
      DatasetName datasetFullId = DatasetName.of(projectId, "us-central1", datasetId);

      // Get multiple Google Cloud Storage URIs to import data from
      GcsSource gcsSource =
          GcsSource.newBuilder().addAllInputUris(Arrays.asList(path.split(","))).build();

      // Import data from the input URI
      InputConfig inputConfig = InputConfig.newBuilder().setGcsSource(gcsSource).build();
      System.out.println("Processing import...");

      // Start the import job
      OperationFuture<Empty, OperationMetadata> operation =
          client.importDataAsync(datasetFullId, inputConfig);

      System.out.format("Operation name: %s%n", operation.getName());

      // If you want to wait for the operation to finish, adjust the timeout appropriately. The
      // operation will still run if you choose not to wait for it to complete. You can check the
      // status of your operation using the operation's name.
      Empty response = operation.get(45, TimeUnit.MINUTES);
      System.out.format("Dataset imported. %s%n", response);
    } catch (TimeoutException e) {
      System.out.println("The operation's polling period was not long enough.");
      System.out.println("You can use the Operation's name to get the current status.");
      System.out.println("The import job is still running and will complete as expected.");
      throw e;
    }
  }
}

Node.js

Para mais informações, consulte a documentação de referência da API da AutoML VisionNode.js.

Para autenticar no AutoML Vision, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const datasetId = 'YOUR_DISPLAY_ID';
// const path = 'gs://BUCKET_ID/path_to_training_data.csv';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function importDataset() {
  // Construct request
  const request = {
    name: client.datasetPath(projectId, location, datasetId),
    inputConfig: {
      gcsSource: {
        inputUris: path.split(','),
      },
    },
  };

  // Import dataset
  console.log('Proccessing import');
  const [operation] = await client.importData(request);

  // Wait for operation to complete.
  const [response] = await operation.promise();
  console.log(`Dataset imported: ${response}`);
}

importDataset();

Solicitação

Execute a função import_data para importar o conteúdo de treinamento. A primeira parte do código a ser alterada é o ID do conjunto de dados da etapa anterior, enquanto a segunda é o URI de all_data.csv. Você precisa modificar as linhas de código a seguir:

Defina o project_id como seu PROJECT_ID.
Defina o dataset_id do conjunto de dados usando a saída da etapa anterior.
Defina o path, que é o URI de gs://YOUR_PROJECT_ID-vcm/csv/all_data.csv.
python3 import_dataset.py {Python}
mvn compile exec:java -Dexec.mainClass="com.example.automl.ImportDataset" {Java}
node import_dataset.js {Node.js}

Resposta

Processing import...
Dataset imported.

Etapa 3: criar (treinar) o modelo

Agora que você tem um conjunto de dados de imagens de treinamento etiquetadas, pode treinar um novo modelo.

Copiar o código

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# dataset_id = "YOUR_DATASET_ID"
# display_name = "your_models_display_name"

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = f"projects/{project_id}/locations/us-central1"
# Leave model unset to use the default base model provided by Google
# train_budget_milli_node_hours: The actual train_cost will be equal or
# less than this value.
# https://cloud.google.com/automl/docs/reference/rpc/google.cloud.automl.v1#imageclassificationmodelmetadata
metadata = automl.ImageClassificationModelMetadata(
    train_budget_milli_node_hours=24000
)
model = automl.Model(
    display_name=display_name,
    dataset_id=dataset_id,
    image_classification_model_metadata=metadata,
)

# Create a model with the model metadata in the region.
response = client.create_model(parent=project_location, model=model)

print(f"Training operation name: {response.operation.name}")
print("Training started...")

Java

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ImageClassificationModelMetadata;
import com.google.cloud.automl.v1.LocationName;
import com.google.cloud.automl.v1.Model;
import com.google.cloud.automl.v1.OperationMetadata;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class VisionClassificationCreateModel {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String datasetId = "YOUR_DATASET_ID";
    String displayName = "YOUR_DATASET_NAME";
    createModel(projectId, datasetId, displayName);
  }

  // Create a model
  static void createModel(String projectId, String datasetId, String displayName)
      throws IOException, ExecutionException, InterruptedException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // A resource that represents Google Cloud Platform location.
      LocationName projectLocation = LocationName.of(projectId, "us-central1");
      // Set model metadata.
      ImageClassificationModelMetadata metadata =
          ImageClassificationModelMetadata.newBuilder().setTrainBudgetMilliNodeHours(24000).build();
      Model model =
          Model.newBuilder()
              .setDisplayName(displayName)
              .setDatasetId(datasetId)
              .setImageClassificationModelMetadata(metadata)
              .build();

      // Create a model with the model metadata in the region.
      OperationFuture<Model, OperationMetadata> future =
          client.createModelAsync(projectLocation, model);
      // OperationFuture.get() will block until the model is created, which may take several hours.
      // You can use OperationFuture.getInitialFuture to get a future representing the initial
      // response to the request, which contains information while the operation is in progress.
      System.out.format("Training operation name: %s\n", future.getInitialFuture().get().getName());
      System.out.println("Training started...");
    }
  }
}

Node.js

Para mais informações, consulte a documentação de referência da API da AutoML VisionNode.js.

Para autenticar no AutoML Vision, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const dataset_id = 'YOUR_DATASET_ID';
// const displayName = 'YOUR_DISPLAY_NAME';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function createModel() {
  // Construct request
  const request = {
    parent: client.locationPath(projectId, location),
    model: {
      displayName: displayName,
      datasetId: datasetId,
      imageClassificationModelMetadata: {
        trainBudgetMilliNodeHours: 24000,
      },
    },
  };

  // Don't wait for the LRO
  const [operation] = await client.createModel(request);
  console.log(`Training started... ${operation}`);
  console.log(`Training operation name: ${operation.name}`);
}

createModel();

Solicitação

Chame a função create_model para criar um modelo. Use o ID do conjunto de dados das etapas anteriores. Você precisa modificar as linhas de código a seguir:

Defina o project_id como seu PROJECT_ID.
Defina o dataset_id do conjunto de dados usando a saída da etapa anterior.
Defina o display_name do modelo (flowers_model).
python3 vision_classification_create_model.py {Python}
mvn compile exec:java -Dexec.mainClass="com.example.automl.VisionClassificationCreateModel" {Java}
node vision_classification_create_model.js {Node.js}

Resposta

A função create_model inicia uma operação de treinamento e imprime o nome da operação. O treinamento é realizado de modo assíncrono e pode levar um tempo para ser concluído. Portanto, é possível usar o ID da operação para verificar o status do treinamento. Quando o treinamento for concluído, create_model retornará o ID do modelo. Assim como você fez com o ID do conjunto de dados, defina uma variável de ambiente MODEL_ID como o valor do ID do modelo retornado.

Training operation name: projects/216065747626/locations/us-central1/operations/ICN3007727620979824033
Training started...
Model name: projects/216065747626/locations/us-central1/models/ICN7683346839371803263
Model id: ICN7683346839371803263
Model display name: flowers_model
Image classification model metadata:
Training budget: 1
Training cost: 1
Stop reason:
Base model id:
Model create time:
        seconds: 1529649600
        nanos: 966000000
Model deployment state: deployed

Etapa 4: avaliar o modelo

Após o treinamento, avalie a prontidão do modelo analisando a precisão, o recall e a pontuação F1 dele.

A função display_evaluation considera o ID do modelo como um parâmetro.

Copiar o código

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"

client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, "us-central1", model_id)

print("List of model evaluations:")
for evaluation in client.list_model_evaluations(parent=model_full_id, filter=""):
    print(f"Model evaluation name: {evaluation.name}")
    print(f"Model annotation spec id: {evaluation.annotation_spec_id}")
    print(f"Create Time: {evaluation.create_time}")
    print(f"Evaluation example count: {evaluation.evaluated_example_count}")
    print(
        "Classification model evaluation metrics: {}".format(
            evaluation.classification_evaluation_metrics
        )
    )

Java


import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ListModelEvaluationsRequest;
import com.google.cloud.automl.v1.ModelEvaluation;
import com.google.cloud.automl.v1.ModelName;
import java.io.IOException;

class ListModelEvaluations {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    listModelEvaluations(projectId, modelId);
  }

  // List model evaluations
  static void listModelEvaluations(String projectId, String modelId) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // Get the full path of the model.
      ModelName modelFullId = ModelName.of(projectId, "us-central1", modelId);
      ListModelEvaluationsRequest modelEvaluationsrequest =
          ListModelEvaluationsRequest.newBuilder().setParent(modelFullId.toString()).build();

      // List all the model evaluations in the model by applying filter.
      System.out.println("List of model evaluations:");
      for (ModelEvaluation modelEvaluation :
          client.listModelEvaluations(modelEvaluationsrequest).iterateAll()) {

        System.out.format("Model Evaluation Name: %s\n", modelEvaluation.getName());
        System.out.format("Model Annotation Spec Id: %s", modelEvaluation.getAnnotationSpecId());
        System.out.println("Create Time:");
        System.out.format("\tseconds: %s\n", modelEvaluation.getCreateTime().getSeconds());
        System.out.format("\tnanos: %s", modelEvaluation.getCreateTime().getNanos() / 1e9);
        System.out.format(
            "Evalution Example Count: %d\n", modelEvaluation.getEvaluatedExampleCount());
        System.out.format(
            "Classification Model Evaluation Metrics: %s\n",
            modelEvaluation.getClassificationEvaluationMetrics());
      }
    }
  }
}

Node.js

Para mais informações, consulte a documentação de referência da API da AutoML VisionNode.js.

Para autenticar no AutoML Vision, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function listModelEvaluations() {
  // Construct request
  const request = {
    parent: client.modelPath(projectId, location, modelId),
    filter: '',
  };

  const [response] = await client.listModelEvaluations(request);

  console.log('List of model evaluations:');
  for (const evaluation of response) {
    console.log(`Model evaluation name: ${evaluation.name}`);
    console.log(`Model annotation spec id: ${evaluation.annotationSpecId}`);
    console.log(`Model display name: ${evaluation.displayName}`);
    console.log('Model create time');
    console.log(`\tseconds ${evaluation.createTime.seconds}`);
    console.log(`\tnanos ${evaluation.createTime.nanos / 1e9}`);
    console.log(
      `Evaluation example count: ${evaluation.evaluatedExampleCount}`
    );
    console.log(
      `Classification model evaluation metrics: ${evaluation.classificationEvaluationMetrics}`
    );
  }
}

listModelEvaluations();

Solicitação

Faça a solicitação a seguir para exibir o desempenho geral da avaliação do modelo. Você precisa modificar as linhas de código a seguir:

Defina o project_id como seu PROJECT_ID.
Defina o model_id como o ID do modelo.
python3 list_model_evaluations.py {Python}
mvn compile exec:java -Dexec.mainClass="com.example.automl.ListModelEvaluations" {Java}
node list_model_evaluations.js {Node.js}

Resposta

Se as pontuações de precisão e recall forem muito baixas, você poderá fortalecer o conjunto de dados de treinamento e treinar novamente seu modelo. Para mais informações, consulte Como avaliar modelos.

Precision and recall are based on a score threshold of 0.5
Model Precision: 96.3%
Model Recall: 95.7%
Model F1 score: 96.0%
Model Precision@1: 96.33%
Model Recall@1: 95.74%
Model F1 score@1: 96.04%

Etapa 5: usar um modelo para fazer uma predição

Quando seu modelo personalizado atende aos padrões de qualidade, você pode usá-lo para classificar novas imagens de flores.

Copiar o código

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"
# file_path = "path_to_local_file.jpg"

prediction_client = automl.PredictionServiceClient()

# Get the full path of the model.
model_full_id = automl.AutoMlClient.model_path(project_id, "us-central1", model_id)

# Read the file.
with open(file_path, "rb") as content_file:
    content = content_file.read()

image = automl.Image(image_bytes=content)
payload = automl.ExamplePayload(image=image)

# params is additional domain-specific parameters.
# score_threshold is used to filter the result
# https://cloud.google.com/automl/docs/reference/rpc/google.cloud.automl.v1#predictrequest
params = {"score_threshold": "0.8"}

request = automl.PredictRequest(name=model_full_id, payload=payload, params=params)
response = prediction_client.predict(request=request)

print("Prediction results:")
for result in response.payload:
    print(f"Predicted class name: {result.display_name}")
    print(f"Predicted class score: {result.classification.score}")

Java

import com.google.cloud.automl.v1.AnnotationPayload;
import com.google.cloud.automl.v1.ExamplePayload;
import com.google.cloud.automl.v1.Image;
import com.google.cloud.automl.v1.ModelName;
import com.google.cloud.automl.v1.PredictRequest;
import com.google.cloud.automl.v1.PredictResponse;
import com.google.cloud.automl.v1.PredictionServiceClient;
import com.google.protobuf.ByteString;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

class VisionClassificationPredict {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String filePath = "path_to_local_file.jpg";
    predict(projectId, modelId, filePath);
  }

  static void predict(String projectId, String modelId, String filePath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);
      ByteString content = ByteString.copyFrom(Files.readAllBytes(Paths.get(filePath)));
      Image image = Image.newBuilder().setImageBytes(content).build();
      ExamplePayload payload = ExamplePayload.newBuilder().setImage(image).build();
      PredictRequest predictRequest =
          PredictRequest.newBuilder()
              .setName(name.toString())
              .setPayload(payload)
              .putParams(
                  "score_threshold", "0.8") // [0.0-1.0] Only produce results higher than this value
              .build();

      PredictResponse response = client.predict(predictRequest);

      for (AnnotationPayload annotationPayload : response.getPayloadList()) {
        System.out.format("Predicted class name: %s\n", annotationPayload.getDisplayName());
        System.out.format(
            "Predicted class score: %.2f\n", annotationPayload.getClassification().getScore());
      }
    }
  }
}

Node.js

Para mais informações, consulte a documentação de referência da API da AutoML VisionNode.js.

Para autenticar no AutoML Vision, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';
// const filePath = 'path_to_local_file.jpg';

// Imports the Google Cloud AutoML library
const {PredictionServiceClient} = require('@google-cloud/automl').v1;
const fs = require('fs');

// Instantiates a client
const client = new PredictionServiceClient();

// Read the file content for translation.
const content = fs.readFileSync(filePath);

async function predict() {
  // Construct request
  // params is additional domain-specific parameters.
  // score_threshold is used to filter the result
  const request = {
    name: client.modelPath(projectId, location, modelId),
    payload: {
      image: {
        imageBytes: content,
      },
    },
  };

  const [response] = await client.predict(request);

  for (const annotationPayload of response.payload) {
    console.log(`Predicted class name: ${annotationPayload.displayName}`);
    console.log(
      `Predicted class score: ${annotationPayload.classification.score}`
    );
  }
}

predict();

Solicitação

Na função predict, você precisa modificar as linhas de código a seguir:

Defina o project_id como seu PROJECT_ID.
Defina o model_id como o ID do modelo.
Defina o file_path como o arquivo salvo ("resources/test.png").
python3 vision_classification_predict.py {Python}
mvn compile exec:java -Dexec.mainClass="com.example.automl.VisionClassificationPredict" {Java}
node vision_classification_predict.js {Node.js}

Resposta

A função retorna a pontuação de acordo com a correspondência da imagem para cada categoria, excedendo o limite de confiança declarado de 0,7.

Prediction results:
Predicted class name: dandelion
Predicted class score: 0.9702693223953247

Etapa 6: excluir o modelo

Quando terminar de usar esse modelo de amostra, você poderá excluí-lo permanentemente. Não será mais possível usá-lo para previsão.

Copiar o código

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"

client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, "us-central1", model_id)
response = client.delete_model(name=model_full_id)

print(f"Model deleted. {response.result()}")

Java

import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ModelName;
import com.google.protobuf.Empty;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class DeleteModel {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    deleteModel(projectId, modelId);
  }

  // Delete a model
  static void deleteModel(String projectId, String modelId)
      throws IOException, ExecutionException, InterruptedException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // Get the full path of the model.
      ModelName modelFullId = ModelName.of(projectId, "us-central1", modelId);

      // Delete a model.
      Empty response = client.deleteModelAsync(modelFullId).get();

      System.out.println("Model deletion started...");
      System.out.println(String.format("Model deleted. %s", response));
    }
  }
}

Node.js

Para mais informações, consulte a documentação de referência da API da AutoML VisionNode.js.

Para autenticar no AutoML Vision, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function deleteModel() {
  // Construct request
  const request = {
    name: client.modelPath(projectId, location, modelId),
  };

  const [response] = await client.deleteModel(request);
  console.log(`Model deleted: ${response}`);
}

deleteModel();

Solicitação

Faça uma solicitação com o tipo de operação delete_model para excluir um modelo criado. Você precisa modificar as linhas de código a seguir:

Defina o project_id como seu PROJECT_ID.
Defina o model_id como o ID do modelo.
python3 delete_model.py {Python}
mvn compile exec:java -Dexec.mainClass="com.example.automl.DeleteModel" {Java}
node delete_model.js {Node.js}

Resposta

Model deleted.