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 oferece um conjunto agregado de métricas de avaliação que indicam o desempenho geral do modelo. Ele também inclui 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 (em inglês).

  • 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. 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 tem esta aparência:

    99  1  0  0
        

    Para mais informações, pesquise confusion matrix machine learning (em inglês).

    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 confusão maior (previsões incorretas).

Use esses dados para avaliar a prontidão do seu modelo. Alta confusão e baixas pontuações de AUC, precisão e recall podem indicar que o modelo precisa de mais dados de treinamento ou tem rótulos inconsistentes. Uma pontuação de 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 dele.

    Página de avaliação do modelo

REST e LINHA DE COMANDO

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

  • project-id: o ID do projeto do GCP.
  • model-id: o ID do modelo exibido na resposta no momento da criação dele. O ID é 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 à seguinte amostra. 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:

C#

Ver no GitHub (em inglês) Feedback
/// <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(
                $"Classificatio Model Evaluation Metrics: {modelEvaluation.ClassificationEvaluationMetrics}");
        }
        return 0;
    }

Go

Ver no GitHub (em inglês) Feedback
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


    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

/**
     * 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

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

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

Ver no GitHub (em inglês) Feedback
require "google/cloud/automl"

    project_id = "YOUR_PROJECT_ID"
    model_id = "YOUR_MODEL_ID"

    client = Google::Cloud::AutoML::AutoML.new

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

    model_evaluations = client.list_model_evaluations 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.

AutoML Vision UI Evaluate page

IU da Web

  1. Abra 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 dele.

  4. Para ver 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

IU integrada

Vision Dashboard updated evaluate page
  1. Abra 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 dele.

  4. Para ver 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 COMANDO

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 seguintes substituições:

  • project-id: o ID do projeto do GCP.
  • model-id: o ID do modelo exibido na resposta no momento da criação dele. O ID é 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:

C#

Ver no GitHub (em inglês) Feedback
/// <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(
            $"Classificatio Model Evaluation Metrics: {modelEvaluation.ClassificationEvaluationMetrics}");
        return 0;
    }
    

Go

Ver no GitHub (em inglês) Feedback
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


    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

/**
     * 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

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

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

Ver no GitHub (em inglês) Feedback
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::AutoML.new

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

    # Get complete detail of the model evaluation.
    model_evaluation = client.get_model_evaluation 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

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.

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 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 ajuda o modelo a entender se você considera uma pintura abstrata de uma rosa como "rosa" (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

Iterar no modelo

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

  • Com o AutoML Vision, é possível 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.
  • Inclua mais imagens em qualquer rótulo com baixa qualidade.
  • Talvez seja necessário adicionar diferentes tipos de imagens. Por exemplo, ângulo amplo, resolução maior ou menor e pontos de vista diferentes.
  • Remova rótulos completamente se não houver imagens de treinamento suficientes.
  • A máquina não consegue ler o nome do rótulo. Para ela, trata-se apenas de uma string aleatória de letras. 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.
  • Amplie seus dados com mais exemplos de verdadeiros positivos e negativos. Exemplos especialmente importantes são aqueles que estão próximos da fronteira de decisão, ou seja, que provavelmente produzem confusão, mas ainda estão rotulados corretamente.
  • Especifique sua própria divisão de TREINAMENTO, TESTE e VALIDAÇÃO. A ferramenta atribui imagens aleatoriamente, 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.