Como avaliar modelos

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

O 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.

Observação: você também pode filtrar ao listar recursos, operações e métricas. Para informações sobre como filtrar, consulte Como filtrar ao listar.

IU da Web

1. Para exibir os modelos disponíveis, abra a interface de usuário do AutoML Vision Object Detection e clique na guia Modelos (com o ícone de lâmpada) na barra de navegação à esquerda.

   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 do modelo tiver sido concluído, o AutoML Vision Object Detection mostrará as métricas de avaliação.

   

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

   

REST

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

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. É possível verificar a conta ativa atual executando gcloud auth list.

execute o seguinte comando:

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

PowerShell

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

execute o seguinte comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

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"
    }
  ]
}

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"
	"cloud.google.com/go/automl/apiv1/automlpb"
	"google.golang.org/api/iterator"
)

// 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: %w", 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: %w", 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();

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(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(
        "Object detection model evaluation metrics: {}\n\n".format(
            evaluation.image_object_detection_evaluation_metrics
        )
    )

Outras linguagens

C#: Siga as Instruções de configuração do C# na página das bibliotecas de cliente e acesse a Documentação de referência do AutoML Vision Object Detection para .NET.

PHP: Siga as Instruções de configuração do PHP na página das bibliotecas de cliente e acesse a Documentação de referência do AutoML Vision Object Detection para PHP.

Ruby Siga estas instruções:Instruções de configuração do Ruby na página das bibliotecas de cliente e, em seguida, visite oDocumentação de referência do AutoML Vision Object Detection para Ruby.

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 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.

REST

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

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. É possível verificar a conta ativa atual executando gcloud auth list.

execute o seguinte comando:

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: project-id" \
     "https://automl.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/models/MODEL_ID/modelEvaluations/MODEL_EVALUATION_ID"

PowerShell

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

execute o seguinte comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

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"
}

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"
	"cloud.google.com/go/automl/apiv1/automlpb"
)

// 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: %w", 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: %w", 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();

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_path = client.model_path(project_id, "us-central1", model_id)
model_evaluation_full_id = f"{model_path}/modelEvaluations/{model_evaluation_id}"

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

print(f"Model evaluation name: {response.name}")
print(f"Model annotation spec id: {response.annotation_spec_id}")
print(f"Create Time: {response.create_time}")
print(f"Evaluation example count: {response.evaluated_example_count}")
print(
    "Object detection model evaluation metrics: {}".format(
        response.image_object_detection_evaluation_metrics
    )
)

Outras linguagens

C#: Siga as Instruções de configuração do C# na página das bibliotecas de cliente e acesse a Documentação de referência do AutoML Vision Object Detection para .NET.

PHP: Siga as Instruções de configuração do PHP na página das bibliotecas de cliente e acesse a Documentação de referência do AutoML Vision Object Detection para PHP.

Ruby: Siga as Instruções de configuração do Ruby na página das bibliotecas de cliente e acesse a Documentação de referência do AutoML Vision Object Detection para Ruby.

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

Observação: essa funcionalidade só está disponível na interface do usuário (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.

Nossa interface do usuário fornece categorias de correção (por exemplo, VP, FP, FN) para cada caixa em cada imagem. Isso significa que uma única imagem pode aparecer em várias linhas da interface do usuário, cada vez demonstrando um problema diferente. Além disso, como pode haver várias caixas em cada imagem, a IU mostrará apenas o par de caixas de informações empíricas e previstas que demonstram esse comportamento.

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:

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:

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:

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:

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

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.

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.

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.