Como avaliar modelos

Após o treinamento de um modelo, o Cloud AutoML Vision Object Detection usa imagens do conjunto de TESTE para avaliar a qualidade e a acurácia do modelo novo.

O Cloud AutoML Vision Object Detection oferece um conjunto agregado de métricas de avaliação (saídas do processo de avaliação), que indicam o desempenho geral do modelo, e também as métricas de avaliação de cada rótulo de categoria, que indicam o desempenho do modelo referente a esse rótulo.

Visão geral da avaliação

Entradas do processo de avaliação

  • Limite de IoU: Interseção sobre União (em inglês), um valor usado na detecção de objetos para medir a sobreposição de uma caixa delimitadora prevista em relação a uma caixa real de um objeto. Quanto mais próximos os valores da caixa delimitadora prevista estiverem dos valores da caixa real, maior será a interseção e maior será o valor da IoU.

  • Limite de pontuação: as métricas de saída (abaixo) são calculadas com base no pressuposto de que o modelo nunca retorna previsões com pontuação inferior a esse valor.

Saída do processo de avaliação

  • AuPRC: área sob a curva de recall/precisão (em inglês), também conhecida como "precisão média". Normalmente entre 0,5 e 1. Valores mais altos indicam modelos mais precisos.

  • Curvas de limite de confiança: mostram como limites diferentes de confiança afetariam a precisão, o recall e as taxas de verdadeiros e falsos positivos. Leia sobre a relação entre precisão e recall.

  • Pontuação F1: a média harmônica de precisão e recall. A F1 será uma métrica útil se você quiser encontrar um equilíbrio entre precisão e recall. Ela também é útil quando você tem uma distribuição de classe desigual nos dados de treinamento.

Use esses dados para avaliar a prontidão do seu modelo. Alta confusão, baixas pontuações AUC ou baixas pontuações de precisão e recall podem indicar que o modelo precisa de dados de treinamento extras ou tem rótulos inconsistentes. Uma pontuação AUC muito alta e precisão e recall perfeitos podem indicar que os dados são muito “fáceis” e talvez não sejam bem generalizados: uma AUC alta pode indicar que o modelo foi treinado com base em dados idealizados que não representam muito bem as inferências futuras.

Como gerenciar avaliações de modelo

Listar avaliações do modelo

Depois de treinar um modelo, é possível listar as métricas de avaliação dele.

IU da Web

  1. Abra a IU do Cloud AutoML Vision Detection e clique na guia Modelos, com o ícone de lâmpada, na barra de navegação à esquerda para exibir os modelos disponíveis.

    Para ver os modelos de outro projeto, selecione o projeto na lista suspensa na parte superior direita da barra de título.

  2. Clique na linha do modelo que você quer avaliar.

  3. Se necessário, clique na guia Avaliar abaixo da barra de título.

    Se o treinamento tiver sido concluído para o modelo, o Cloud AutoML Vision Object Detection mostrará as métricas de avaliação.

    Página de avaliação do modelo

  4. Para visualizar as métricas de um rótulo específico, selecione o nome dele na lista na parte inferior da página.

    Rótulo específico da página de avaliação do modelo

REST e LINHA DE CMD

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • project-id: o ID do projeto do GCP.
  • model-id: o ID do seu modelo, a partir da resposta de quando você o criou. Ele é o último elemento no nome do modelo. Por exemplo:
    • Nome do modelo: projects/project-id/locations/location-id/models/IOD4412217016962778756
    • ID do modelo: IOD4412217016962778756

Método HTTP e URL:

GET https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id/modelEvaluations

Para enviar a solicitação, escolha uma destas opções:

curl

Execute o comando a seguir:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id/modelEvaluations

PowerShell

Execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id/modelEvaluations" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante à amostra a seguir. Para melhor entendimento, os campos específicos da detecção de objeto-chave estão em negrito, e as quantidades variáveis de entradas boundingBoxMetricsEntries são mostradas:



    {
  "modelEvaluation": [
    {
      "name": "projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-eval-id",
      "annotationSpecId": "6342510834593300480",
      "createTime": "2019-07-26T22:28:56.890727Z",
      "evaluatedExampleCount": 18,
      "imageObjectDetectionEvaluationMetrics": {
        "evaluatedBoundingBoxCount": 96,
        "boundingBoxMetricsEntries": [
          {
            "iouThreshold": 0.15,
            "meanAveragePrecision": 0.6317751,
            "confidenceMetricsEntries": [
              {
                "confidenceThreshold": 0.101631254,
                "recall": 0.84375,
                "precision": 0.2555205,
                "f1Score": 0.3922518
              },
              {
                "confidenceThreshold": 0.10180253,
                "recall": 0.8333333,
                "precision": 0.25316456,
                "f1Score": 0.3883495
              },
              ...
              {
                "confidenceThreshold": 0.8791167,
                "recall": 0.020833334,
                "precision": 1,
                "f1Score": 0.040816326
              },
              {
                "confidenceThreshold": 0.8804436,
                "recall": 0.010416667,
                "precision": 1,
                "f1Score": 0.020618558
              }
            ]
          },
          {
            "iouThreshold": 0.8,
            "meanAveragePrecision": 0.15461995,
            "confidenceMetricsEntries": [
              {
                "confidenceThreshold": 0.101631254,
                "recall": 0.22916667,
                "precision": 0.06940063,
                "f1Score": 0.10653753
              },
              ...
              {
                "confidenceThreshold": 0.8804436,
                "recall": 0.010416667,
                "precision": 1,
                "f1Score": 0.020618558
              }
            ]
          },
          {
            "iouThreshold": 0.4,
            "meanAveragePrecision": 0.56170964,
            "confidenceMetricsEntries": [
              {
                "confidenceThreshold": 0.101631254,
                "recall": 0.7604167,
                "precision": 0.23028392,
                "f1Score": 0.3535109
              },
              ...
              {
                "confidenceThreshold": 0.8804436,
                "recall": 0.010416667,
                "precision": 1,
                "f1Score": 0.020618558
              }
            ]
          },
          ...
        ],
        "boundingBoxMeanAveragePrecision": 0.4306387
      },
      "displayName": "Tomato"
    },
    {
      "name": "projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-eval-id",
      "annotationSpecId": "1730824816165912576",
      "createTime": "2019-07-26T22:28:56.890727Z",
      "evaluatedExampleCount": 9,
      "imageObjectDetectionEvaluationMetrics": {
        "evaluatedBoundingBoxCount": 51,
        "boundingBoxMetricsEntries": [
          {
            ...
          }
        ],
        "boundingBoxMeanAveragePrecision": 0.29565892
      },
      "displayName": "Cheese"
    },
    {
      "name": "projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-eval-id",
      "annotationSpecId": "7495432339200147456",
      "createTime": "2019-07-26T22:28:56.890727Z",
      "evaluatedExampleCount": 4,
      "imageObjectDetectionEvaluationMetrics": {
        "evaluatedBoundingBoxCount": 22,
        "boundingBoxMetricsEntries": [
          {
            "iouThreshold": 0.2,
            "meanAveragePrecision": 0.104004614,
            "confidenceMetricsEntries": [
              {
                "confidenceThreshold": 0.1008248,
                "recall": 0.36363637,
                "precision": 0.08888889,
                "f1Score": 0.14285715
              },
              ...
              {
                "confidenceThreshold": 0.47585258,
                "recall": 0.045454547,
                "precision": 1,
                "f1Score": 0.08695653
              }
            ]
          },
          ...
        ],
        "boundingBoxMeanAveragePrecision": 0.057070773
      },
      "displayName": "Seafood"
    }
  ]
}

C#

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

/// <summary>
/// Demonstrates using the AutoML client to list model evaluations.
/// </summary>
/// <param name="projectId">GCP Project ID.</param>
/// <param name="modelId">the Id of the model.</param>
public static object ListModelEvaluations(string projectId = "YOUR-PROJECT-ID",
    string modelId = "YOUR-MODEL-ID")
{
    // Initialize the client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    AutoMlClient client = AutoMlClient.Create();

    // Get the full path of the model.
    string modelFullId = ModelName.Format(projectId, "us-central1", modelId);

    // Create list models request.
    ListModelEvaluationsRequest listModlesRequest = new ListModelEvaluationsRequest
    {
        Parent = modelFullId
    };

    // List all the model evaluations in the model by applying filter.
    Console.WriteLine("List of model evaluations:");
    foreach (ModelEvaluation modelEvaluation in client.ListModelEvaluations(listModlesRequest))
    {
        Console.WriteLine($"Model Evaluation Name: {modelEvaluation.Name}");
        Console.WriteLine($"Model Annotation Spec Id: {modelEvaluation.AnnotationSpecId}");
        Console.WriteLine("Create Time:");
        Console.WriteLine($"\tseconds: {modelEvaluation.CreateTime.Seconds}");
        Console.WriteLine($"\tnanos: {modelEvaluation.CreateTime.Nanos / 1e9}");
        Console.WriteLine(
            $"Evalution Example Count: {modelEvaluation.EvaluatedExampleCount}");
        Console.WriteLine(
            $"Object Detection Model Evaluation Metrics: {modelEvaluation.ImageObjectDetectionEvaluationMetrics}");
    }
    return 0;
}

Go

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

import (
	"context"
	"fmt"
	"io"

	automl "cloud.google.com/go/automl/apiv1"
	"google.golang.org/api/iterator"
	automlpb "google.golang.org/genproto/googleapis/cloud/automl/v1"
)

// listModelEvaluation lists existing model evaluations.
func listModelEvaluations(w io.Writer, projectID string, location string, modelID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// modelID := "TRL123456789..."

	ctx := context.Background()
	client, err := automl.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %v", err)
	}
	defer client.Close()

	req := &automlpb.ListModelEvaluationsRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s/models/%s", projectID, location, modelID),
	}

	it := client.ListModelEvaluations(ctx, req)

	// Iterate over all results
	for {
		evaluation, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("ListModelEvaluations.Next: %v", err)
		}

		fmt.Fprintf(w, "Model evaluation name: %v\n", evaluation.GetName())
		fmt.Fprintf(w, "Model annotation spec id: %v\n", evaluation.GetAnnotationSpecId())
		fmt.Fprintf(w, "Create Time:\n")
		fmt.Fprintf(w, "\tseconds: %v\n", evaluation.GetCreateTime().GetSeconds())
		fmt.Fprintf(w, "\tnanos: %v\n", evaluation.GetCreateTime().GetNanos())
		fmt.Fprintf(w, "Evaluation example count: %v\n", evaluation.GetEvaluatedExampleCount())
		fmt.Fprintf(w, "Object detection model evaluation metrics: %v\n", evaluation.GetImageObjectDetectionEvaluationMetrics())
	}

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.


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(
            "Object Detection Model Evaluation Metrics: %s\n",
            modelEvaluation.getImageObjectDetectionEvaluationMetrics());
      }
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

/**
 * 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(
      `Object detection model evaluation metrics: ${evaluation.imageObjectDetectionEvaluationMetrics}`
    );
  }
}

listModelEvaluations();

PHP

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

use Google\Cloud\AutoMl\V1\AutoMlClient;

/** Uncomment and populate these variables in your code */
// $projectId = '[Google Cloud Project ID]';
// $location = 'us-central1';
// $modelId = 'my_model_id_123';

$client = new AutoMlClient();

try {
    // get full path of model
    $formattedParent = $client->modelName(
        $projectId,
        $location,
        $modelId
    );

    // list all model evaluations
    $filter = '';
    $pagedResponse = $client->listModelEvaluations($formattedParent, $filter);

    print('List of model evaluations' . PHP_EOL);
    foreach ($pagedResponse->iteratePages() as $page) {
        foreach ($page as $modelEvaluation) {
            // display model evaluation information
            $splitName = explode('/', $modelEvaluation->getName());
            printf('Model evaluation name: %s' . PHP_EOL, $modelEvaluation->getName());
            printf('Model evaluation id: %s' . PHP_EOL, end($splitName));
            printf('Model annotation spec id: %s' . PHP_EOL, $modelEvaluation->getAnnotationSpecId());
            printf('Create time' . PHP_EOL);
            printf('seconds: %d' . PHP_EOL, $modelEvaluation->getCreateTime()->getSeconds());
            printf('nanos : %d' . PHP_EOL, $modelEvaluation->getCreateTime()->getNanos());
            printf('Evaluation example count: %s' . PHP_EOL, $modelEvaluation->getEvaluatedExampleCount());
            printf('Object detection model evaluation metrics: %s' . PHP_EOL, $modelEvaluation->getImageObjectDetectionEvaluationMetrics());
        }
    }
} finally {
    $client->close();
}

Python

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

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(model_full_id, ""):
    print("Model evaluation name: {}".format(evaluation.name))
    print(
        "Model annotation spec id: {}".format(
            evaluation.annotation_spec_id
        )
    )
    print("Create Time:")
    print("\tseconds: {}".format(evaluation.create_time.seconds))
    print("\tnanos: {}".format(evaluation.create_time.nanos / 1e9))
    print(
        "Evaluation example count: {}".format(
            evaluation.evaluated_example_count
        )
    )
    print(
        "Object detection model evaluation metrics: {}\n\n".format(
            evaluation.image_object_detection_evaluation_metrics
        )
    )

Ruby

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

require "google/cloud/automl"

project_id = "YOUR_PROJECT_ID"
model_id = "YOUR_MODEL_ID"

client = Google::Cloud::AutoML.auto_ml

# Get the full path of the model.
model_full_id = client.model_path project: project_id,
                                  location: "us-central1",
                                  model: model_id

model_evaluations = client.list_model_evaluations parent: model_full_id

puts "List of model evaluations:"

model_evaluations.each do |evaluation|
  puts "Model evaluation name: #{evaluation.name}"
  puts "Model annotation spec id: #{evaluation.annotation_spec_id}"
  puts "Create Time: #{evaluation.create_time.to_time}"
  puts "Evaluation example count: #{evaluation.evaluated_example_count}"
  puts "Object detection model evaluation metrics: #{evaluation.image_object_detection_evaluation_metrics}"
end

Acessar avaliações de modelo

Também é possível conseguir uma avaliação do modelo específica para um rótulo (displayName) usando um ID de avaliação.

IU da Web

Na IU do Cloud AutoML Vision Object Detection, a operação equivalente está disponível ao acessar a página Modelos e selecionar seu modelo. Depois de selecionar seu modelo, vá até a guia Avaliar e selecione o rótulo para visualizar avaliações específicas dele.

Rótulo específico da página de avaliação do modelo

REST e LINHA DE CMD

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • project-id: o ID do projeto do GCP.
  • model-id: o ID do seu modelo, a partir da resposta de quando você o criou. Ele é o último elemento no nome do modelo. Por exemplo:
    • Nome do modelo: projects/project-id/locations/location-id/models/IOD4412217016962778756
    • ID do modelo: IOD4412217016962778756
  • model-evaluation-id: o valor do ID da avaliação do modelo. É possível conseguir IDs de avaliação do modelo por meio da operação de avaliações de modelo list.

Método HTTP e URL:

GET https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-evaluation-id

Para enviar a solicitação, escolha uma destas opções:

curl

Execute o comando a seguir:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-evaluation-id

PowerShell

Execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-evaluation-id" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante à amostra a seguir. Para melhor entendimento, os campos específicos da detecção de objeto-chave estão em negrito, e uma versão reduzida das entradas boundingBoxMetricsEntries é mostrada:



    {
  "name": "projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-evaluation-id",
  "annotationSpecId": "6342510834593300480",
  "createTime": "2019-07-26T22:28:56.890727Z",
  "evaluatedExampleCount": 18,
  "imageObjectDetectionEvaluationMetrics": {
    "evaluatedBoundingBoxCount": 96,
    "boundingBoxMetricsEntries": [
      {
        "iouThreshold": 0.15,
        "meanAveragePrecision": 0.6317751,
        "confidenceMetricsEntries": [
          {
            "confidenceThreshold": 0.101631254,
            "recall": 0.84375,
            "precision": 0.2555205,
            "f1Score": 0.3922518
          },
          ...
          {
            "confidenceThreshold": 0.8804436,
            "recall": 0.010416667,
            "precision": 1,
            "f1Score": 0.020618558
          }
        ]
      },
      {
        "iouThreshold": 0.8,
        "meanAveragePrecision": 0.15461995,
        "confidenceMetricsEntries": [
          {
            "confidenceThreshold": 0.101631254,
            "recall": 0.22916667,
            "precision": 0.06940063,
            "f1Score": 0.10653753
          },
          ...
          {
            "confidenceThreshold": 0.8804436,
            "recall": 0.010416667,
            "precision": 1,
            "f1Score": 0.020618558
          }
        ]
      },
      {
        "iouThreshold": 0.4,
        "meanAveragePrecision": 0.56170964,
        "confidenceMetricsEntries": [
          {
            "confidenceThreshold": 0.101631254,
            "recall": 0.7604167,
            "precision": 0.23028392,
            "f1Score": 0.3535109
          },
          ...
          {
            "confidenceThreshold": 0.8804436,
            "recall": 0.010416667,
            "precision": 1,
            "f1Score": 0.020618558
          }
        ]
      },
      ...
    ],
    "boundingBoxMeanAveragePrecision": 0.4306387
  },
  "displayName": "Tomato"
}

C#

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

/// <summary>
/// Demonstrates using the AutoML client to get model evaluations.
/// </summary>
/// <param name="projectId">GCP Project ID.</param>
/// <param name="modelId">the Id of the model.</param>
/// <param name="modelEvaluationId">the Id of your model evaluation.</param>
public static object GetModelEvaluation(string projectId = "YOUR-PROJECT-ID",
    string modelId = "YOUR-MODEL-ID",
    string modelEvaluationId = " YOUR-MODEL-EVAL-ID")
{
    // Initialize the client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    AutoMlClient client = AutoMlClient.Create();

    // Get the full path of the model evaluation.
    string modelEvaluationFullId =
        ModelEvaluationName.Format(projectId, "us-central1", modelId, modelEvaluationId);

    // Get complete detail of the model evaluation.
    ModelEvaluation modelEvaluation = client.GetModelEvaluation(modelEvaluationFullId);

    Console.WriteLine($"Model Evaluation Name: {modelEvaluation.Name}");
    Console.WriteLine($"Model Annotation Spec Id: {modelEvaluation.AnnotationSpecId}");
    Console.WriteLine("Create Time:");
    Console.WriteLine($"\tseconds: {modelEvaluation.CreateTime.Seconds}");
    Console.WriteLine($"\tnanos: {modelEvaluation.CreateTime.Nanos / 1e9}");
    Console.WriteLine(
        $"Evalution Example Count: {modelEvaluation.EvaluatedExampleCount}");

    Console.WriteLine(
        $"Object Detection Model Evaluation Metrics: {modelEvaluation.ImageObjectDetectionEvaluationMetrics}");
    return 0;
}

Go

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

import (
	"context"
	"fmt"
	"io"

	automl "cloud.google.com/go/automl/apiv1"
	automlpb "google.golang.org/genproto/googleapis/cloud/automl/v1"
)

// getModelEvaluation gets a model evaluation.
func getModelEvaluation(w io.Writer, projectID string, location string, modelID string, modelEvaluationID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// modelID := "TRL123456789..."
	// modelEvaluationID := "123456789..."

	ctx := context.Background()
	client, err := automl.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %v", err)
	}
	defer client.Close()

	req := &automlpb.GetModelEvaluationRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/models/%s/modelEvaluations/%s", projectID, location, modelID, modelEvaluationID),
	}

	evaluation, err := client.GetModelEvaluation(ctx, req)
	if err != nil {
		return fmt.Errorf("GetModelEvaluation: %v", err)
	}

	fmt.Fprintf(w, "Model evaluation name: %v\n", evaluation.GetName())
	fmt.Fprintf(w, "Model annotation spec id: %v\n", evaluation.GetAnnotationSpecId())
	fmt.Fprintf(w, "Create Time:\n")
	fmt.Fprintf(w, "\tseconds: %v\n", evaluation.GetCreateTime().GetSeconds())
	fmt.Fprintf(w, "\tnanos: %v\n", evaluation.GetCreateTime().GetNanos())
	fmt.Fprintf(w, "Evaluation example count: %v\n", evaluation.GetEvaluatedExampleCount())
	fmt.Fprintf(w, "Object detection model evaluation metrics: %v\n", evaluation.GetImageObjectDetectionEvaluationMetrics())

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.


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

class GetModelEvaluation {

  static void getModelEvaluation() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String modelEvaluationId = "YOUR_MODEL_EVALUATION_ID";
    getModelEvaluation(projectId, modelId, modelEvaluationId);
  }

  // Get a model evaluation
  static void getModelEvaluation(String projectId, String modelId, String modelEvaluationId)
      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 evaluation.
      ModelEvaluationName modelEvaluationFullId =
          ModelEvaluationName.of(projectId, "us-central1", modelId, modelEvaluationId);

      // Get complete detail of the model evaluation.
      ModelEvaluation modelEvaluation = client.getModelEvaluation(modelEvaluationFullId);

      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(
          "Object Detection Model Evaluation Metrics: %s\n",
          modelEvaluation.getImageObjectDetectionEvaluationMetrics());
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

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

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

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

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

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

  console.log(`Model evaluation name: ${response.name}`);
  console.log(`Model annotation spec id: ${response.annotationSpecId}`);
  console.log(`Model display name: ${response.displayName}`);
  console.log('Model create time');
  console.log(`\tseconds ${response.createTime.seconds}`);
  console.log(`\tnanos ${response.createTime.nanos / 1e9}`);
  console.log(`Evaluation example count: ${response.evaluatedExampleCount}`);
  console.log(
    `Object detection model evaluation metrics: ${response.imageObjectDetectionEvaluationMetrics}`
  );
}

getModelEvaluation();

PHP

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

use Google\Cloud\AutoMl\V1\AutoMlClient;

/** Uncomment and populate these variables in your code */
// $projectId = '[Google Cloud Project ID]';
// $location = 'us-central1';
// $modelId = 'my_model_id_123';
// $modeEvaluationId = 'my_model_evaluation_id_123';

$client = new AutoMlClient();

try {
    // get full path of the model evaluation
    $formattedName = $client->modelEvaluationName(
        $projectId,
        $location,
        $modelId,
        $modelEvaluationId
    );

    $modelEvaluation = $client->getModelEvaluation($formattedName);

    // display model evaluation information
    $splitName = explode('/', $modelEvaluation->getName());
    printf('Model evaluation name: %s' . PHP_EOL, $modelEvaluation->getName());
    printf('Model evaluation id: %s' . PHP_EOL, end($splitName));
    printf('Model annotation spec id: %s' . PHP_EOL, $modelEvaluation->getAnnotationSpecId());
    printf('Create time' . PHP_EOL);
    printf('seconds: %d' . PHP_EOL, $modelEvaluation->getCreateTime()->getSeconds());
    printf('nanos : %d' . PHP_EOL, $modelEvaluation->getCreateTime()->getNanos());
    printf('Evaluation example count: %s' . PHP_EOL, $modelEvaluation->getEvaluatedExampleCount());
    printf('Model evaluation metrics: %s' . PHP_EOL, $modelEvaluation->getImageObjectDetectionEvaluationMetrics());

} finally {
    $client->close();
}

Python

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

from google.cloud import automl

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

client = automl.AutoMlClient()
# Get the full path of the model evaluation.
model_evaluation_full_id = client.model_evaluation_path(
    project_id, "us-central1", model_id, model_evaluation_id
)

# Get complete detail of the model evaluation.
response = client.get_model_evaluation(model_evaluation_full_id)

print("Model evaluation name: {}".format(response.name))
print("Model annotation spec id: {}".format(response.annotation_spec_id))
print("Create Time:")
print("\tseconds: {}".format(response.create_time.seconds))
print("\tnanos: {}".format(response.create_time.nanos / 1e9))
print(
    "Evaluation example count: {}".format(response.evaluated_example_count)
)
print(
    "Object detection model evaluation metrics: {}".format(
        response.image_object_detection_evaluation_metrics
    )
)

Ruby

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

require "google/cloud/automl"

project_id = "YOUR_PROJECT_ID"
model_id = "YOUR_MODEL_ID"
model_evaluation_id = "YOUR_MODEL_EVALUATION_ID"

client = Google::Cloud::AutoML.auto_ml

# Get the full path of the model evaluation.
model_evaluation_full_id = client.model_evaluation_path project: project_id,
                                                        location: "us-central1",
                                                        model: model_id,
                                                        model_evaluation: model_evaluation_id

# Get complete detail of the model evaluation.
model_evaluation = client.get_model_evaluation name: model_evaluation_full_id

puts "Model evaluation name: #{model_evaluation.name}"
puts "Model annotation spec id: #{model_evaluation.annotation_spec_id}"
puts "Create Time: #{model_evaluation.create_time.to_time}"
puts "Evaluation example count: #{model_evaluation.evaluated_example_count}"
puts "Object detection model evaluation metrics: #{model_evaluation.image_object_detection_evaluation_metrics}"

Verdadeiros positivos, falsos negativos e falsos positivos (somente IU)

Nela, é possível observar exemplos específicos de desempenho de modelo, ou seja, instâncias de verdadeiro positivo (VP), falso negativo (FN) e falso positivo (FP) dos conjuntos de TREINAMENTO e VALIDAÇÃO.

IU da Web

Acesse a visualização VP, FN e FP na interface do usuário selecionando a guia Avaliar e, em seguida, selecionando qualquer rótulo específico.

Ao visualizar as tendências nessas previsões, é possível modificar seu conjunto de treinamento para melhorar o desempenho do modelo.

Imagens de verdadeiros positivos são caixas de validação fornecidas ao modelo treinado anotado corretamente pelo modelo:

exibição de verdadeiros positivos

Imagens de falsos negativos são fornecidas de maneira semelhante ao modelo treinado, mas o modelo não anotou corretamente uma instância de um objeto:

exibição de falsos negativos

Por último, as imagens de falsos positivos são aquelas fornecidas ao modelo treinado que anotou instâncias de um objeto, mas que não foram anotadas na área especificada:

exibição de falsos positivos

O modelo está selecionando casos específicos interessantes, o que apresenta uma oportunidade de refinar suas definições e rótulos para ajudar o modelo a entender as interpretações do rótulo. Por exemplo, uma definição mais rígida ajudaria o modelo a entender se você considera um pimentão recheado como uma salada, ou não. Com ciclos repetidos de rótulo, treinamento e avaliação, seu modelo exibirá outras ambiguidades desse tipo nos seus dados.

Também é possível ajustar o limite de pontuação nessa visualização na interface do usuário, e as imagens VP, FN e FP exibidas mostrarão a alteração do limite:

verdadeiros positivos com limite atualizado

Como interpretar métricas de avaliação

Os modelos de detecção de objetos geram muitas caixas delimitadoras para uma imagem de entrada. Cada caixa vem com 1) um rótulo e 2) uma pontuação ou confiança. As métricas de avaliação ajudarão você a responder a várias perguntas importantes sobre o desempenho do seu modelo:

  • Estou recebendo o número certo de caixas?
  • O modelo tende a dar a casos marginais pontuações mais baixas?
  • Qual é a proximidade das caixas previstas com minhas caixas de informações empíricas?

Essas métricas, assim como as de classificação de vários rótulos, não apontarão nenhuma confusão de classe além de pontuações genéricas menores.

Ao examinar a saída do modelo por imagem, é preciso analisar um par de caixas (a caixa de informações empíricas e a caixa prevista) e determinar a qualidade de uma correspondência. Considere itens como:

  • As duas caixas têm o mesmo rótulo?
  • Qual é a qualidade da sobreposição das caixas?
  • Com que confiança o modelo previu a caixa?

Para abordar o segundo requisito, introduzimos uma nova medida, chamada de interseção sobre união ou IoU, na sigla em inglês.

IoU e o respectivo limite

visualização da intersecção de caixas sobre caixas

A interseção sobre união determina a correspondência entre duas caixas. O valor da IoU varia de 0 (sem sobreposição) a 1 (as caixas são idênticas) e é calculado por meio da divisão da área em comum entre as duas caixas pela área incluída em pelo menos uma das caixas. O serviço AutoML permite examinar o desempenho do seu modelo em vários limites de IoU.

Por que você quer alterar o limite de IoU?

Considere o caso de uso de contagem de carros em um estacionamento. Você não se importa se as coordenadas da caixa são muito precisas, apenas se tem o número total certo de caixas. Nesse caso, um limite baixo de IoU é adequado.

visualização de caixas de limite baixo em torno de carros
Créditos da imagem: Nacho, "Smart" (CC BY 2.0, caixas delimitadoras e texto adicionados).

Se preferir, tente medir o tamanho de uma mancha de tecido. Nesse caso, você precisa de coordenadas muito precisas e, assim, um limite de IoU muito mais alto é apropriado.

visualização da caixa de limite alto ao redor da mancha de tecido
Créditos da imagem: Housing Works Thrift Shops, "Modern Sofa" (CC BY-SA 2.0, caixas delimitadoras e texto adicionados).

Você não precisará treinar seu modelo novamente se mudar de ideia quanto ao limite certo para seu caso de uso. Você já tem acesso às métricas de avaliação em vários limites de IoU.

Pontuação e o respectivo limite

Assim como os modelos de classificação, as saídas do modelo de detecção de objetos (agora caixas) vêm com pontuações. Assim como na classificação de imagens, há um limite de pontuação para você especificar após o treinamento a fim de determinar o que é (ou não) uma correspondência “boa”. Alterar o limite de pontuação permite ajustar as taxas do falso positivo e do verdadeiro positivo às necessidades específicas do seu modelo. Um usuário que quer um recall muito alto geralmente usa um limite de pontuação mais baixo no processamento da saída do modelo.

Iterar o modelo

Se você não estiver satisfeito com os níveis de qualidade, volte às etapas anteriores para melhorá-los:

  • Considere adicionar mais imagens a qualquer rótulo de caixa delimitadora com baixa qualidade.
  • Talvez seja necessário adicionar tipos de imagens diferentes, por exemplo, ângulo maior, resolução maior ou menor, pontos de vista diferentes.
  • Considere remover completamente os rótulos de caixa delimitadora se você não tiver imagens de treinamento suficientes.
  • Nossos algoritmos de treinamento não usam os nomes dos seus rótulos. Se você tem um rótulo "porta" e outro "porta_com_maçaneta", o algoritmo não tem como detectar a nuance, a não ser pelas imagens que você fornece.
  • Expanda seus dados com mais exemplos de verdadeiros positivos e negativos. Exemplos particularmente importantes são aqueles que estão próximos da fronteira de decisão (isto é, que costumam produzir confusão, mas ainda assim são rotulados corretamente).
  • Especifique sua própria divisão de TREINAMENTO, TESTE e VALIDAÇÃO. A ferramenta atribui aleatoriamente imagens, mas quase duplicatas podem acabar em TREINAMENTO e VALIDAÇÃO, o que pode levar a um overfitting e, em seguida, a um baixo desempenho no conjunto de TESTE.

Depois de fazer as alterações, treine e avalie um novo modelo até atingir um nível de qualidade alto o suficiente.