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

  1. Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. No Console do GCP, acesse a página Gerenciar recursos e selecione ou crie um projeto.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

  4. Ativar AutoML Vision APIs.

    Ativar APIs

  5. Instale a ferramenta de linha de comando gcloud.
  6. Siga as instruções para criar uma conta de serviço e fazer o download de um arquivo de chave.
  7. 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. Exemplo:
    export GOOGLE_APPLICATION_CREDENTIALS=key-file
  8. 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 projeto do GCP e service-account-name-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"
  9. 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"
  10. Instale a biblioteca de cliente.
  11. Defina as variáveis de ambiente PROJECT_ID e REGION_NAME.

    Substitua project-id pelo código do projeto do Google Cloud Platform. Atualmente, o AutoML Vision requer o local us-central1.
    export PROJECT_ID="project-id"
    export REGION_NAME="us-central1"
  12. Crie um intervalo do Google Cloud Storage para armazenar os documentos que serão usados para treinar o modelo personalizado.

    O nome do intervalo precisa estar no formato $PROJECT_ID-vcm. O comando a seguir cria um intervalo de armazenamento na região us-central1 denominado $PROJECT_ID-vcm.
    gsutil mb -p $PROJECT_ID -c regional -l $REGION_NAME gs://$PROJECT_ID-vcm/
  13. Copie o conjunto de dados disponível publicamente de imagens de flores de gs://cloud-ml-data/img/flower_photos/ no intervalo do Google Cloud Storage.

    Na sua sessão do Cloud Shell, insira:
    gsutil -m cp -R gs://cloud-ml-data/img/flower_photos/  gs://$PROJECT_ID-vcm/img/
    A cópia do arquivo leva cerca de 20 minutos para ser concluída.
  14. O conjunto de dados de amostra contém um arquivo .csv com o local e as etiquetas para cada imagem. Consulte Como preparar seus dados de treinamento para ver detalhes sobre o formato exigido. Atualize o arquivo .csv para apontar para os arquivos em seu próprio intervalo:
    gsutil cat gs://$PROJECT_ID-vcm/img/flower_photos/all_data.csv | sed "s:cloud-ml-data:$PROJECT_ID-vcm:" > all_data.csv
    Em seguida, copie o arquivo .csv atualizado para o intervalo:
    gsutil cp all_data.csv gs://$PROJECT_ID-vcm/csv/

Copiar os arquivos de código-fonte para a pasta do projeto do Google Cloud Platform

Python

O tutorial consiste nestes arquivos do Python:

Java

O tutorial consiste nestes arquivos do Java:

Node.js

O tutorial consiste nestes programas do Node.js:

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 permite que uma imagem seja atribuída a várias etiquetas.

Este tutorial cria um conjunto de dados chamado flowers e usa MULTICLASS.

Solicitação

Execute a função create_dataset para criar um conjunto de dados vazio. O primeiro parâmetro informa um nome para o conjunto de dados (flowers) e o segundo especifica se o conjunto de dados MULTILABEL será criado.

Python

python automl_vision_dataset.py create_dataset "flowers" "False"

Java

mvn compile exec:java -Dexec.mainClass="com.google.cloud.vision.samples.automl.DatasetApi" -Dexec.args="create_dataset flowers false"

Node.js

node automlVisionDataset.js create-dataset "flowers" "False"

Código

Python

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# dataset_name = 'DATASET_NAME_HERE'
# multilabel = True for multilabel or False for multiclass

from google.cloud import automl_v1beta1 as automl

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, compute_region)

# Classification type is assigned based on multilabel value.
classification_type = "MULTICLASS"
if multilabel:
    classification_type = "MULTILABEL"

# Specify the image classification type for the dataset.
dataset_metadata = {"classification_type": classification_type}
# Set dataset name and metadata of the dataset.
my_dataset = {
    "display_name": dataset_name,
    "image_classification_dataset_metadata": dataset_metadata,
}

# Create a dataset with the dataset metadata in the region.
dataset = client.create_dataset(project_location, my_dataset)

# Display the dataset information.
print("Dataset name: {}".format(dataset.name))
print("Dataset id: {}".format(dataset.name.split("/")[-1]))
print("Dataset display name: {}".format(dataset.display_name))
print("Image classification dataset metadata:")
print("\t{}".format(dataset.image_classification_dataset_metadata))
print("Dataset example count: {}".format(dataset.example_count))
print("Dataset create time:")
print("\tseconds: {}".format(dataset.create_time.seconds))
print("\tnanos: {}".format(dataset.create_time.nanos))

Java

/**
 * Demonstrates using the AutoML client to create a dataset
 *
 * @param projectId the Google Cloud Project ID.
 * @param computeRegion the Region name. (e.g., "us-central1")
 * @param datasetName the name of the dataset to be created.
 * @param multiLabel the type of classification problem. Set to FALSE by default. False -
 *     MULTICLASS , True - MULTILABEL
 * @throws IOException on Input/Output errors.
 */
public static void createDataset(
    String projectId, String computeRegion, String datasetName, Boolean multiLabel)
    throws IOException {
  // Instantiates a client
  AutoMlClient client = AutoMlClient.create();

  // A resource that represents Google Cloud Platform location.
  LocationName projectLocation = LocationName.of(projectId, computeRegion);

  // Classification type assigned based on multiLabel value.
  ClassificationType classificationType =
      multiLabel ? ClassificationType.MULTILABEL : ClassificationType.MULTICLASS;

  // Specify the image classification type for the dataset.
  ImageClassificationDatasetMetadata imageClassificationDatasetMetadata =
      ImageClassificationDatasetMetadata.newBuilder()
          .setClassificationType(classificationType)
          .build();

  // Set dataset with dataset name and set the dataset metadata.
  Dataset myDataset =
      Dataset.newBuilder()
          .setDisplayName(datasetName)
          .setImageClassificationDatasetMetadata(imageClassificationDatasetMetadata)
          .build();

  // Create dataset with the dataset metadata in the region.
  Dataset dataset = client.createDataset(projectLocation, myDataset);

  // Display the dataset information
  System.out.println(String.format("Dataset name: %s", dataset.getName()));
  System.out.println(
      String.format(
          "Dataset id: %s",
          dataset.getName().split("/")[dataset.getName().split("/").length - 1]));
  System.out.println(String.format("Dataset display name: %s", dataset.getDisplayName()));
  System.out.println("Image classification dataset specification:");
  System.out.print(String.format("\t%s", dataset.getImageClassificationDatasetMetadata()));
  System.out.println(String.format("Dataset example count: %d", dataset.getExampleCount()));
  System.out.println("Dataset create time:");
  System.out.println(String.format("\tseconds: %s", dataset.getCreateTime().getSeconds()));
  System.out.println(String.format("\tnanos: %s", dataset.getCreateTime().getNanos()));
}

Node.js

  const automl = require(`@google-cloud/automl`).v1beta1;

  const client = new automl.AutoMlClient();

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = `The GCLOUD_PROJECT string, e.g. "my-gcloud-project"`;
  // const computeRegion = `region-name, e.g. "us-central1"`;
  // const datasetName = `name of the dataset to create, e.g. “myDataset”`;
  // const multiLabel = `type of classification problem, true for multilabel and false for multiclass e.g. "false"`;

  // A resource that represents Google Cloud Platform location.
  const projectLocation = client.locationPath(projectId, computeRegion);

  // Classification type is assigned based on multilabel value.
  let classificationType = `MULTICLASS`;
  if (multiLabel) {
    classificationType = `MULTILABEL`;
  }

  // Specify the text classification type for the dataset.
  const datasetMetadata = {
    classificationType: classificationType,
  };

  // Set dataset name and metadata.
  const myDataset = {
    displayName: datasetName,
    imageClassificationDatasetMetadata: datasetMetadata,
  };

  // Create a dataset with the dataset metadata in the region.
  const [dataset] = await client.createDataset({
    parent: projectLocation,
    dataset: myDataset,
  });
  // Display the dataset information.
  console.log(`Dataset name: ${dataset.name}`);
  console.log(`Dataset id: ${dataset.name.split(`/`).pop(-1)}`);
  console.log(`Dataset display name: ${dataset.displayName}`);
  console.log(`Dataset example count: ${dataset.exampleCount}`);
  console.log(`Image Classification type:`);
  console.log(
    `\t ${dataset.imageClassificationDatasetMetadata.classificationType}`
  );
  console.log(`Dataset create time:`);
  console.log(`\tseconds: ${dataset.createTime.seconds}`);
  console.log(`\tnanos: ${dataset.createTime.nanos}`);

Resposta

A resposta inclui os detalhes do conjunto de dados recém-criado, incluindo o código 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 para cada uma. Consulte Preparar seus dados para ver detalhes sobre o formato necessário. Para este tutorial, usaremos as imagens rotuladas que você copiou no seu intervalo do Google Cloud Storage, listadas em gs://$PROJECT_ID-vcm/csv/all_data.csv.

Solicitação

Execute a função import_data para importar o conteúdo de treinamento. O primeiro parâmetro é o código do conjunto de dados da etapa anterior, e o segundo é o URI de all_data.csv.

  • python automl_vision_dataset.py import_data $DATASET_ID "gs://$PROJECT_ID-vcm/csv/all_data.csv" {Python}

  • mvn compile exec:java -Dexec.mainClass="com.google.cloud.vision.samples.automl.DatasetApi" -Dexec.args="import_data $DATASET_ID gs://$PROJECT_ID-vcm/csv/all_data.csv" {Java}

  • node automlVisionDataset.js import-data $DATASET_ID "gs://$PROJECT_ID-vcm/csv/all_data.csv" {Node.js}

Código

Python

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# dataset_id = 'DATASET_ID_HERE'
# path = 'gs://path/to/file.csv'

from google.cloud import automl_v1beta1 as automl

client = automl.AutoMlClient()

# Get the full path of the dataset.
dataset_full_id = client.dataset_path(
    project_id, compute_region, dataset_id
)

# Get the multiple Google Cloud Storage URIs.
input_uris = path.split(",")
input_config = {"gcs_source": {"input_uris": input_uris}}

# Import data from the input URI.
response = client.import_data(dataset_full_id, input_config)

print("Processing import...")
# synchronous check of operation status.
print("Data imported. {}".format(response.result()))

Java

/**
 * Demonstrates using the AutoML client to import labeled images.
 *
 * @param projectId the Id of the project.
 * @param computeRegion the Region name.
 * @param datasetId the Id of the dataset to which the training data will be imported.
 * @param path the Google Cloud Storage URIs. Target files must be in AutoML vision CSV format.
 * @throws Exception on AutoML Client errors
 */
public static void importData(
    String projectId, String computeRegion, String datasetId, String path) throws Exception {
  // Instantiates a client
  AutoMlClient client = AutoMlClient.create();

  // Get the complete path of the dataset.
  DatasetName datasetFullId = DatasetName.of(projectId, computeRegion, datasetId);

  GcsSource.Builder gcsSource = GcsSource.newBuilder();

  // Get multiple training data files to be imported
  String[] inputUris = path.split(",");
  for (String inputUri : inputUris) {
    gcsSource.addInputUris(inputUri);
  }

  // Import data from the input URI
  InputConfig inputConfig = InputConfig.newBuilder().setGcsSource(gcsSource).build();
  System.out.println("Processing import...");
  Empty response = client.importDataAsync(datasetFullId.toString(), inputConfig).get();
  System.out.println(String.format("Dataset imported. %s", response));
}

Node.js

  const automl = require(`@google-cloud/automl`).v1beta1;

  const client = new automl.AutoMlClient();

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = `The GCLOUD_PROJECT string, e.g. "my-gcloud-project"`;
  // const computeRegion = `region-name, e.g. "us-central1"`;
  // const datasetId = `Id of the dataset`;
  // const path = `string or array of .csv paths in AutoML Vision CSV format, e.g. “gs://myproject/traindata.csv”;`

  // Get the full path of the dataset.
  const datasetFullId = client.datasetPath(projectId, computeRegion, datasetId);

  // Get one or more Google Cloud Storage URI(s).
  const inputUris = path.split(`,`);
  const inputConfig = {
    gcsSource: {
      inputUris: inputUris,
    },
  };

  // Import the dataset from the input URI.
  const [operation] = await client.importData({
    name: datasetFullId,
    inputConfig: inputConfig,
  });
  console.log(`Processing import...`);

  const [, , response] = await operation.promise();

  // The final result of the operation.
  if (response.done) {
    console.log(`Data imported.`);
  }

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.

Solicitação

O primeiro parâmetro para a função create_model é o código do conjunto de dados das etapas anteriores. O segundo é o nome do novo modelo. O terceiro é o orçamento de treinamento. Este último é o número de horas de treinamento a ser usado no modelo. O AutoML Vision garante que o tempo real de treinamento será menor ou igual ao orçamento de treinamento.

Uma hora de treinamento representa o uso de computação interna e, por isso, não corresponde precisamente a uma hora exata no relógio.

  • python automl_vision_model.py create_model $DATASET_ID "flowers_model" "1" {Python}

  • mvn compile exec:java -Dexec.mainClass="com.google.cloud.vision.samples.automl.ModelApi" -Dexec.args="create_model $DATASET_ID flowers_model 1" {Java}

  • node automlVisionModel.js create-model $DATASET_ID "flowers_model" "1" {Node.js}

Código

Python

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# dataset_id = 'DATASET_ID_HERE'
# model_name = 'MODEL_NAME_HERE'
# train_budget = integer amount for maximum cost of model

from google.cloud import automl_v1beta1 as automl

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, compute_region)

# Set model name and model metadata for the image dataset.
my_model = {
    "display_name": model_name,
    "dataset_id": dataset_id,
    "image_classification_model_metadata": {"train_budget": train_budget}
    if train_budget
    else {},
}

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

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

Java

/**
 * Demonstrates using the AutoML client to create a model.
 *
 * @param projectId the Id of the project.
 * @param computeRegion the Region name.
 * @param dataSetId the Id of the dataset to which model is created.
 * @param modelName the Name of the model.
 * @param trainBudget the Budget for training the model.
 * @throws Exception on AutoML Client errors
 */
public static void createModel(
    String projectId,
    String computeRegion,
    String dataSetId,
    String modelName,
    String trainBudget)
    throws Exception {
  // Instantiates a client
  AutoMlClient client = AutoMlClient.create();

  // A resource that represents Google Cloud Platform location.
  LocationName projectLocation = LocationName.of(projectId, computeRegion);

  // Set model metadata.
  ImageClassificationModelMetadata imageClassificationModelMetadata =
      Long.valueOf(trainBudget) == 0
          ? ImageClassificationModelMetadata.newBuilder().build()
          : ImageClassificationModelMetadata.newBuilder()
              .setTrainBudget(Long.valueOf(trainBudget))
              .build();

  // Set model name and model metadata for the image dataset.
  Model myModel =
      Model.newBuilder()
          .setDisplayName(modelName)
          .setDatasetId(dataSetId)
          .setImageClassificationModelMetadata(imageClassificationModelMetadata)
          .build();

  // Create a model with the model metadata in the region.
  OperationFuture<Model, OperationMetadata> response =
      client.createModelAsync(projectLocation, myModel);

  System.out.println(
      String.format("Training operation name: %s", response.getInitialFuture().get().getName()));
  System.out.println("Training started...");
}

Node.js

  const automl = require(`@google-cloud/automl`).v1beta1;

  const client = new automl.AutoMlClient();

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = `The GCLOUD_PROJECT string, e.g. "my-gcloud-project"`;
  // const computeRegion = `region-name, e.g. "us-central1"`;
  // const datasetId = `Id of the dataset`;
  // const modelName = `Name of the model, e.g. "myModel"`;
  // const trainBudget = `Budget for training model, e.g. 50`;

  // A resource that represents Google Cloud Platform location.
  const projectLocation = client.locationPath(projectId, computeRegion);

  // Check train budget condition.
  if (trainBudget === 0) {
    trainBudget = {};
  } else {
    trainBudget = {trainBudget: trainBudget};
  }

  // Set model name and model metadata for the dataset.
  const myModel = {
    displayName: modelName,
    datasetId: datasetId,
    imageClassificationModelMetadata: trainBudget,
  };

  // Create a model with the model metadata in the region.
  const [operation, initialApiResponse] = await client.createModel({
    parent: projectLocation,
    model: myModel,
  });
  console.log(`Training operation name: `, initialApiResponse.name);
  console.log(`Training started...`);
  const [model] = await operation.promise();

  // Retrieve deployment state.
  let deploymentState = ``;
  if (model.deploymentState === 1) {
    deploymentState = `deployed`;
  } else if (model.deploymentState === 2) {
    deploymentState = `undeployed`;
  }

  // Display the model information.
  console.log(`Model name: ${model.name}`);
  console.log(`Model id: ${model.name.split(`/`).pop(-1)}`);
  console.log(`Model display name: ${model.displayName}`);
  console.log(`Model create time:`);
  console.log(`\tseconds: ${model.createTime.seconds}`);
  console.log(`\tnanos: ${model.createTime.nanos}`);
  console.log(`Model deployment state: ${deploymentState}`);

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 código da operação para verificar o status do treinamento. Quando o treinamento for concluído, create_model retornará o código do modelo. Do mesmo modo que o conjunto de dados, convém definir uma variável de ambiente MODEL_ID como o valor do código 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, será possível analisar a precisão, o recall e a pontuação F1 do modelo para avaliar a prontidão dele.

A função display_evaluation usa o código do modelo como parâmetro.

Solicitação

Faça uma solicitação para exibir o desempenho geral de avaliação do modelo, executando a seguinte solicitação com o tipo de operação display_evaluation. Informe o código do modelo e o filtro (opcional) como argumentos.

  • python automl_vision_model.py display_evaluation $MODEL_ID {Python}

  • mvn compile exec:java -Dexec.mainClass="com.google.cloud.vision.samples.automl.ModelApi" -Dexec.args="display_evaluation $MODEL_ID" {Java}

  • node automlVisionModel.js display-evaluation $MODEL_ID {Node.js}

Código

Python

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_id = 'MODEL_ID_HERE'
# filter_ = 'filter expression here'

from google.cloud import automl_v1beta1 as automl

client = automl.AutoMlClient()

# Get the full path of the model.
model_full_id = client.model_path(project_id, compute_region, model_id)

# List all the model evaluations in the model by applying filter.
response = client.list_model_evaluations(model_full_id, filter_)

# Iterate through the results.
for element in response:
    # There is evaluation for each class in a model and for overall model.
    # Get only the evaluation of overall model.
    if not element.annotation_spec_id:
        model_evaluation_id = element.name.split("/")[-1]

# Resource name for the model evaluation.
model_evaluation_full_id = client.model_evaluation_path(
    project_id, compute_region, model_id, model_evaluation_id
)

# Get a model evaluation.
model_evaluation = client.get_model_evaluation(model_evaluation_full_id)

class_metrics = model_evaluation.classification_evaluation_metrics
confidence_metrics_entries = class_metrics.confidence_metrics_entry

# Showing model score based on threshold of 0.5
for confidence_metrics_entry in confidence_metrics_entries:
    if confidence_metrics_entry.confidence_threshold == 0.5:
        print("Precision and recall are based on a score threshold of 0.5")
        print(
            "Model Precision: {}%".format(
                round(confidence_metrics_entry.precision * 100, 2)
            )
        )
        print(
            "Model Recall: {}%".format(
                round(confidence_metrics_entry.recall * 100, 2)
            )
        )
        print(
            "Model F1 score: {}%".format(
                round(confidence_metrics_entry.f1_score * 100, 2)
            )
        )
        print(
            "Model Precision@1: {}%".format(
                round(confidence_metrics_entry.precision_at1 * 100, 2)
            )
        )
        print(
            "Model Recall@1: {}%".format(
                round(confidence_metrics_entry.recall_at1 * 100, 2)
            )
        )
        print(
            "Model F1 score@1: {}%".format(
                round(confidence_metrics_entry.f1_score_at1 * 100, 2)
            )
        )

Java

/**
 * Demonstrates using the AutoML client to display model evaluation.
 *
 * @param projectId the Id of the project.
 * @param computeRegion the Region name.
 * @param modelId the Id of the model.
 * @param filter the filter expression.
 * @throws IOException on Input/Output errors.
 */
public static void displayEvaluation(
    String projectId, String computeRegion, String modelId, String filter) throws IOException {
  AutoMlClient client = AutoMlClient.create();

  // Get the full path of the model.
  ModelName modelFullId = ModelName.of(projectId, computeRegion, modelId);

  // List all the model evaluations in the model by applying filter.
  ListModelEvaluationsRequest modelEvaluationsrequest =
      ListModelEvaluationsRequest.newBuilder()
          .setParent(modelFullId.toString())
          .setFilter(filter)
          .build();

  // Iterate through the results.
  String modelEvaluationId = "";
  for (ModelEvaluation element :
      client.listModelEvaluations(modelEvaluationsrequest).iterateAll()) {
    if (element.getAnnotationSpecId() != null) {
      modelEvaluationId = element.getName().split("/")[element.getName().split("/").length - 1];
    }
  }

  // Resource name for the model evaluation.
  ModelEvaluationName modelEvaluationFullId =
      ModelEvaluationName.of(projectId, computeRegion, modelId, modelEvaluationId);

  // Get a model evaluation.
  ModelEvaluation modelEvaluation = client.getModelEvaluation(modelEvaluationFullId);

  ClassificationEvaluationMetrics classMetrics =
      modelEvaluation.getClassificationEvaluationMetrics();
  List<ConfidenceMetricsEntry> confidenceMetricsEntries =
      classMetrics.getConfidenceMetricsEntryList();

  // Showing model score based on threshold of 0.5
  for (ConfidenceMetricsEntry confidenceMetricsEntry : confidenceMetricsEntries) {
    if (confidenceMetricsEntry.getConfidenceThreshold() == 0.5) {
      System.out.println("Precision and recall are based on a score threshold of 0.5");
      System.out.println(
          String.format("Model Precision: %.2f ", confidenceMetricsEntry.getPrecision() * 100)
              + '%');
      System.out.println(
          String.format("Model Recall: %.2f ", confidenceMetricsEntry.getRecall() * 100) + '%');
      System.out.println(
          String.format("Model F1 score: %.2f ", confidenceMetricsEntry.getF1Score() * 100)
              + '%');
      System.out.println(
          String.format(
                  "Model Precision@1: %.2f ", confidenceMetricsEntry.getPrecisionAt1() * 100)
              + '%');
      System.out.println(
          String.format("Model Recall@1: %.2f ", confidenceMetricsEntry.getRecallAt1() * 100)
              + '%');
      System.out.println(
          String.format("Model F1 score@1: %.2f ", confidenceMetricsEntry.getF1ScoreAt1() * 100)
              + '%');
    }
  }
}

Node.js

  const automl = require(`@google-cloud/automl`).v1beta1;
  const math = require(`mathjs`);

  const client = new automl.AutoMlClient();

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = `The GCLOUD_PROJECT string, e.g. "my-gcloud-project"`;
  // const computeRegion = `region-name, e.g. "us-central1"`;
  // const modelId = `id of the model, e.g. “ICN12345”`;
  // const filter = `filter expressions, must specify field, e.g. “imageClassificationModelMetadata:*”`;

  // Get the full path of the model.
  const modelFullId = client.modelPath(projectId, computeRegion, modelId);

  // List all the model evaluations in the model by applying filter.
  const [response] = await client.listModelEvaluations({
    parent: modelFullId,
    filter: filter,
  });

  response.forEach(async element => {
    // There is evaluation for each class in a model and for overall model.
    // Get only the evaluation of overall model.
    if (!element.annotationSpecId) {
      const modelEvaluationId = element.name.split(`/`).pop(-1);

      // Resource name for the model evaluation.
      const modelEvaluationFullId = client.modelEvaluationPath(
        projectId,
        computeRegion,
        modelId,
        modelEvaluationId
      );

      const [modelEvaluation] = await client.getModelEvaluation({
        name: modelEvaluationFullId,
      });
      const classMetrics = modelEvaluation.classificationEvaluationMetrics;
      const confidenceMetricsEntries = classMetrics.confidenceMetricsEntry;

      // Showing model score based on threshold of 0.5
      confidenceMetricsEntries.forEach(confidenceMetricsEntry => {
        if (confidenceMetricsEntry.confidenceThreshold === 0.5) {
          console.log(
            `Precision and recall are based on a score threshold of 0.5`
          );
          console.log(
            `Model Precision: %`,
            math.round(confidenceMetricsEntry.precision * 100, 2)
          );
          console.log(
            `Model Recall: %`,
            math.round(confidenceMetricsEntry.recall * 100, 2)
          );
          console.log(
            `Model F1 score: %`,
            math.round(confidenceMetricsEntry.f1Score * 100, 2)
          );
          console.log(
            `Model Precision@1: %`,
            math.round(confidenceMetricsEntry.precisionAt1 * 100, 2)
          );
          console.log(
            `Model Recall@1: %`,
            math.round(confidenceMetricsEntry.recallAt1 * 100, 2)
          );
          console.log(
            `Model F1 score@1: %`,
            math.round(confidenceMetricsEntry.f1ScoreAt1 * 100, 2)
          );
        }
      });
    }
  });

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.

Solicitação

A função de predict usa como parâmetros o código do modelo, o URI da imagem a ser classificada e um limite de pontuação de confiança. Este tutorial usa 0,7 como o limite de pontuação de confiança. Ele só retorna resultados que tenham uma pontuação de pelo menos 0,7.

  • python automl_vision_predict.py predict $MODEL_ID "resources/test.png" "0.7" {Python}

  • mvn compile exec:java -Dexec.mainClass="com.google.cloud.vision.samples.automl.PredictionApi" -Dexec.args="predict $MODEL_ID resources/test.png 0.7" {Java}

  • node automlVisionPredict.js predict $MODEL_ID "resources/test.png" "0.7" {Node.js}

Código

Python

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_id = 'MODEL_ID_HERE'
# file_path = '/local/path/to/file'
# score_threshold = 'value from 0.0 to 0.5'

from google.cloud import automl_v1beta1 as automl

automl_client = automl.AutoMlClient()

# Get the full path of the model.
model_full_id = automl_client.model_path(
    project_id, compute_region, model_id
)

# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()

# Read the image and assign to payload.
with open(file_path, "rb") as image_file:
    content = image_file.read()
payload = {"image": {"image_bytes": content}}

# params is additional domain-specific parameters.
# score_threshold is used to filter the result
# Initialize params
params = {}
if score_threshold:
    params = {"score_threshold": score_threshold}

response = prediction_client.predict(model_full_id, payload, params)
print("Prediction results:")
for result in response.payload:
    print("Predicted class name: {}".format(result.display_name))
    print("Predicted class score: {}".format(result.classification.score))

Java


/**
 * Demonstrates using the AutoML client to predict an image.
 *
 * @param projectId the Id of the project.
 * @param computeRegion the Region name.
 * @param modelId the Id of the model which will be used for text classification.
 * @param filePath the Local text file path of the content to be classified.
 * @param scoreThreshold the Confidence score. Only classifications with confidence score above
 *     scoreThreshold are displayed.
 * @throws IOException on Input/Output errors.
 */
public static void predict(
    String projectId,
    String computeRegion,
    String modelId,
    String filePath,
    String scoreThreshold)
    throws IOException {

  // Instantiate client for prediction service.
  PredictionServiceClient predictionClient = PredictionServiceClient.create();

  // Get the full path of the model.
  ModelName name = ModelName.of(projectId, computeRegion, modelId);

  // Read the image and assign to payload.
  ByteString content = ByteString.copyFrom(Files.readAllBytes(Paths.get(filePath)));
  Image image = Image.newBuilder().setImageBytes(content).build();
  ExamplePayload examplePayload = ExamplePayload.newBuilder().setImage(image).build();

  // Additional parameters that can be provided for prediction e.g. Score Threshold
  Map<String, String> params = new HashMap<>();
  if (scoreThreshold != null) {
    params.put("score_threshold", scoreThreshold);
  }
  // Perform the AutoML Prediction request
  PredictResponse response = predictionClient.predict(name, examplePayload, params);

  System.out.println("Prediction results:");
  for (AnnotationPayload annotationPayload : response.getPayloadList()) {
    System.out.println("Predicted class name :" + annotationPayload.getDisplayName());
    System.out.println(
        "Predicted class score :" + annotationPayload.getClassification().getScore());
  }
}

Node.js

  const automl = require('@google-cloud/automl').v1beta1;
  const fs = require('fs');

  // Create client for prediction service.
  const client = new automl.PredictionServiceClient();

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = `The GCLOUD_PROJECT string, e.g. "my-gcloud-project"`;
  // const computeRegion = `region-name, e.g. "us-central1"`;
  // const modelId = `id of the model, e.g. “ICN12345”`;
  // const filePath = `local text file path of content to be classified, e.g. "./resources/test.txt"`;
  // const scoreThreshold = `value between 0.0 and 1.0, e.g. "0.5"';

  // Get the full path of the model.
  const modelFullId = client.modelPath(projectId, computeRegion, modelId);

  // Read the file content for prediction.
  const content = fs.readFileSync(filePath, 'base64');

  const params = {};

  if (scoreThreshold) {
    params.score_threshold = scoreThreshold;
  }

  // Set the payload by giving the content and type of the file.
  const payload = {};
  payload.image = {imageBytes: content};

  // params is additional domain-specific parameters.
  // currently there is no additional parameters supported.
  const [response] = await client.predict({
    name: modelFullId,
    payload: payload,
    params: params,
  });
  console.log(`Prediction results:`);
  response.payload.forEach(result => {
    console.log(`Predicted class name: ${result.displayName}`);
    console.log(`Predicted class score: ${result.classification.score}`);
  });

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 predição.

Solicitação

Faça uma solicitação com o tipo de operação delete_model para excluir um modelo criado usando o código do modelo como argumento.

  • python automl_vision_model.py delete_model $MODEL_ID {Python}

  • mvn compile exec:java -Dexec.mainClass="com.google.cloud.vision.samples.automl.ModelApi" -Dexec.args="delete_model $MODEL_ID" {Java}

  • node automlVisionModel.js delete-model $MODEL_ID {Node.js}

Código

Python

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_id = 'MODEL_ID_HERE'

from google.cloud import automl_v1beta1 as automl

client = automl.AutoMlClient()

# Get the full path of the model.
model_full_id = client.model_path(project_id, compute_region, model_id)

# Delete a model.
response = client.delete_model(model_full_id)

# synchronous check of operation status.
print("Model deleted. {}".format(response.result()))

Java

/**
 * Demonstrates using the AutoML client to delete a model.
 *
 * @param projectId the Id of the project.
 * @param computeRegion the Region name.
 * @param modelId the Id of the model.
 * @throws Exception on AutoML Client errors
 */
public static void deleteModel(String projectId, String computeRegion, String modelId)
    throws Exception {
  AutoMlClient client = AutoMlClient.create();

  // Get the full path of the model.
  ModelName modelFullId = ModelName.of(projectId, computeRegion, modelId);

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

  System.out.println("Model deletion started...");
}

Node.js

  const automl = require(`@google-cloud/automl`).v1beta1;

  const client = new automl.AutoMlClient();

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = `The GCLOUD_PROJECT string, e.g. "my-gcloud-project"`;
  // const computeRegion = `region-name, e.g. "us-central1"`;
  // const modelId = `id of the model, e.g. “ICN12345”`;

  // Get the full path of the model.
  const modelFullId = client.modelPath(projectId, computeRegion, modelId);

  // Delete a model.
  const [operation] = await client.deleteModel({name: modelFullId});
  const [, , response] = await operation.promise();
  // The final result of the operation.
  if (response.done) {
    console.log(`Model deleted.`);
  }

Resposta

Model deleted.
Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Cloud AutoML Vision
Precisa de ajuda? Acesse nossa página de suporte.