Como avaliar modelos

Depois de treinar um modelo, o AutoML Vision usa os itens do conjunto de teste para avaliar a qualidade e a precisão do novo modelo.

Visão geral da avaliação

O AutoML Vision fornece um conjunto agregado de métricas de avaliação que indicam o desempenho geral do modelo, bem como as métricas de avaliação para cada rótulo de categoria, indicando o desempenho do modelo para esse rótulo.

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

  • As curvas de limite de confiança mostram como diferentes limites de confiança afetam a precisão, o recall e as taxas de resultados verdadeiros e falsos positivos. Leia sobre a relação entre precisão e recall.

  • Matriz de confusão: presente apenas para modelos de um único rótulo por imagem. Representa a porcentagem de vezes que cada rótulo foi previsto no conjunto de treinamento durante a avaliação.

    Matriz de confusão de amostra

    O ideal é que o rótulo one seja atribuído apenas a imagens classificadas como one e etc. Desse modo, uma matriz perfeita terá a seguinte aparência:

    100  0   0   0
     0  100  0   0
     0   0  100  0
     0   0   0  100
    

    No exemplo acima, se uma imagem foi classificada como one, mas o modelo previu two, a primeira linha terá esta aparência:

    99  1  0  0
    

    Para saber mais informações, pesquise por matriz de confusão de aprendizado de máquina.

    O AutoML Vision cria a matriz de confusão para até dez rótulos. Se você tiver mais do que isso, a matriz incluirá os dez rótulos com a maior confusão (previsões incorretas).

Use esses dados para avaliar a prontidão do seu modelo. Alta confusão, baixa pontuação de 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 fáceis demais e têm pouca capacidade de generalização.

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

    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. Os campos específicos da detecção de objeto-chave estão em negrito, e uma versão reduzida das entradas classificationEvaluationMetrics é exibida para maior clareza:

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, "Classification model evaluation metrics: %v\n", evaluation.GetClassificationEvaluationMetrics())
	}

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

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(
      `Classification model evaluation metrics: ${evaluation.classificationEvaluationMetrics}`
    );
  }
}

listModelEvaluations();

PHP

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

Ver no GitHub (em inglês) Feedback
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('Classification model evaluation metrics: %s' . PHP_EOL, $modelEvaluation->getTextSentimentEvaluationMetrics());
        }
    }
} finally {
    $client->close();
}

Python

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

Ver no GitHub (em inglês) Feedback
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(
        "Classification model evaluation metrics: {}".format(
            evaluation.classification_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 "Classification model evaluation metrics: #{evaluation.classification_evaluation_metrics}"
end

Conseguir valores de avaliação do 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

  1. Abra Vision Dashboard e clique no í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 do modelo tiver sido concluído, o AutoML Vision mostrará as métricas de avaliação.

    updated evaluate page
  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

Para receber apenas as métricas de avaliação de um rótulo específico, adicione /{model-evaluation-id} à solicitação acima da resposta.

Por exemplo, você encontra o ID de avaliação do modelo para o rótulo rose (displayName) no nome da avaliação retornado da operação list:

  • "name": "projects/project-id/locations/us-central1/models/model-id/modelEvaluations/858136867710915695"

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 a esta:

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, "Classification model evaluation metrics: %v\n", evaluation.GetClassificationEvaluationMetrics())

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

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(
    `Classification model evaluation metrics: ${response.classificationEvaluationMetrics}`
  );
}

getModelEvaluation();

PHP

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

Ver no GitHub (em inglês) Feedback
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->getTextSentimentEvaluationMetrics());
} finally {
    $client->close();
}

Python

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

Ver no GitHub (em inglês) Feedback
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(
    "Classification model evaluation metrics: {}".format(
        response.classification_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 "Classification model evaluation metrics: #{model_evaluation.classification_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 verdadeiras positivas (VP), falsas negativas (FN) e falsas positivas (FP) dos conjuntos de TREINAMENTO e VALIDAÇÃO.

IU da Web

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

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 o conjunto de treinamento para melhorar o desempenho do modelo.

As imagens verdadeiras positivas são amostras fornecidas ao modelo treinado que ele anotou corretamente:

exibição de verdadeiros positivos

As imagens falsas negativas são igualmente fornecidas ao modelo treinado, mas ele não pôde anotar corretamente a imagem referente ao rótulo especificado:

exibição de falsos negativos

Por fim, as imagens falsas positivas são aquelas fornecidas ao modelo treinado que foram anotadas com o rótulo especificado, mas não precisavam ter sido anotadas:

exibição de falsos positivos

O modelo está selecionando casos específicos interessantes, o que apresenta uma oportunidade de refinar as 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 ajuda o modelo a entender se você considera uma pintura abstrata de uma rosa como "rosa" ou não.

O modelo exibirá, com ciclos repetidos de rótulo, treinamento e avaliação, outras ambiguidades desse tipo nos 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

Iterar o modelo

Se você não estiver satisfeito com os níveis de qualidade, poderá voltar às etapas anteriores para melhorar a qualidade:

  • Com o AutoML Vision, você pode classificar as imagens de acordo com o grau de confusão do modelo, pelo rótulo verdadeiro e pelo rótulo previsto correspondente. Analise essas imagens e verifique se elas estão rotuladas corretamente.
  • Pense em incluir mais documentos a qualquer rótulo com baixa qualidade.
  • Talvez seja necessário adicionar diferentes tipos de imagens (por exemplo, ângulo amplo, resolução maior ou menor, pontos de vista diferentes).
  • Pense em remover rótulos completamente se não houver imagens de treinamento suficientes.
  • Lembre-se de que a máquina não consegue ler o nome do rótulo. É apenas uma string aleatória de letras para ela. Se você tem um rótulo que diz "porta" e outro que diz "porta_com_maçaneta", a máquina não tem como descobrir a nuance além das imagens fornecidas.
  • Aumente seus dados com mais exemplos de positivos e negativos verdadeiros. Exemplos especialmente importantes são aqueles que estão próximos do limite de decisão (isto é, que provavelmente produzem confusão, mas ainda assim rotulados corretamente).
  • Especifique sua própria divisão TRAIN, TEST, VALIDATION. A ferramenta atribui aleatoriamente imagens, mas quase duplicatas podem acabar em TRAIN e VALIDATION, o que poderia levar a um sobreajuste e, em seguida, a um baixo desempenho no conjunto TEST.

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