Esta página se ha traducido con Cloud Translation API.
Switch to English

Evaluar modelos

Después de entrenar un modelo, la detección de objetos de AutoML Vision usa imágenes del conjunto TEST para evaluar la calidad y precisión del modelo nuevo.

AutoML Vision Object Detection proporciona un conjunto agregado de métricas de evaluación (resultados del proceso de evaluación) que indican el rendimiento general del modelo, así como métricas de evaluación para cada etiqueta de categoría, que indican el nivel de eficacia de modelo funciona para esa etiqueta.

Descripción general de la evaluación

Entradas del proceso de evaluación

  • Umbral de IoU: Intersección sobre la unión, es un valor que se usa en la detección de objetos a fin de medir la superposición de un cuadro de límite previsto y uno real para un objeto. Mientras más cerca estén los valores del cuadro de límite previsto y los valores del cuadro real, mayores serán la intersección y el valor de IoU.

  • Umbral de puntuación: Las métricas de salida (que se encuentran a continuación) se calculan con la suposición de que el modelo nunca muestra predicciones con una puntuación inferior a este valor.

Resultado del proceso de evaluación

  • AuPRC : Área bajo la curva de Precisión/Recuperación, también conocida como "precisión promedio". Por lo general, se encuentra entre 0.5 y 1.0. Valores más altos indican modelos más exactos.

  • Curvas de umbral de confianza: Muestran cómo los diferentes umbrales de confianza podrían afectar las tasas de precisión, recuperación y de verdaderos y falsos positivos. Obtén información sobre la relación entre precisión y recuperación.

  • Puntuación F1: La media armónica de precisión y recuperación. F1 es una métrica útil si deseas encontrar un equilibrio entre la precisión y la recuperación. También es conveniente cuando tienes una distribución de clases desigual en los datos de entrenamiento.

Usa estos datos para evaluar la preparación de tu modelo. La confusión alta, la puntuación baja de AUC o las puntuaciones bajas de precisión y recuperación pueden indicar que tu modelo necesita datos de entrenamiento adicionales o que tiene etiquetas incoherentes. Una puntuación de AUC muy alta y una precisión y recuperación perfectas pueden indicar que los datos son demasiado “fáciles” y pueden no generalizarse bien. Un AUC alto puede indicar que el modelo se entrenó en datos idealizados que no representan de forma correcta futuras inferencias.

Administra evaluaciones de modelos

Enumera evaluaciones de modelos

Una vez que hayas entrenado un modelo, puedes enumerar sus métricas de evaluación.

IU web

  1. Abre la IU de la detección de objetos de Cloud AutoML Vision y haz clic en la pestaña Modelos (el ícono de la bombilla) en la barra de navegación izquierda para ver los modelos disponibles.

    Para ver los de un proyecto diferente, selecciónalo de la lista desplegable en la parte superior derecha de la barra de título.

  2. Haz clic en la fila del modelo que deseas evaluar.

  3. Si es necesario, haz clic en la pestaña Evaluar justo debajo de la barra de título.

    Si se completó el entrenamiento del modelo, la detección de objetos de Cloud AutoML Vision mostrará sus métricas de evaluación.

    Página de evaluación del modelo

  4. Para ver las métricas de una etiqueta específica, selecciona el nombre de la etiqueta de la lista que aparece en la parte inferior de la página.

    Etiqueta específica de la página de evaluación del modelo

LÍNEA DE CMD Y REST

Antes de usar cualquiera de los siguientes datos de solicitud, realiza estos reemplazos:

  • project-id: Es el ID de tu proyecto de GCP.
  • model-id: Es el ID del modelo, que se muestra en la respuesta que recibiste cuando lo creaste. El ID es el último elemento del nombre del modelo. Por ejemplo:
    • Nombre del modelo: projects/project-id/locations/location-id/models/IOD4412217016962778756
    • ID del modelo: IOD4412217016962778756

Método HTTP y URL:

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

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el siguiente comando:

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

PowerShell

Ejecuta el siguiente comando:

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

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

Deberías recibir una respuesta JSON similar a la siguiente. Los campos específicos de detección de objetos clave están en negrita, y se muestran las siguientes cantidades variables de entradas boundingBoxMetricsEntries para brindar una vista más clara:



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

Comienza a usarlo

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

import (
	"context"
	"fmt"
	"io"

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

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

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

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

	it := client.ListModelEvaluations(ctx, req)

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

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

	return nil
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas 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 probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas 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 probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas 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("Model evaluation name: {}".format(evaluation.name))
    print("Model annotation spec id: {}".format(evaluation.annotation_spec_id))
    print("Create Time: {}".format(evaluation.create_time))
    print("Evaluation example count: {}".format(evaluation.evaluated_example_count))
    print(
        "Object detection model evaluation metrics: {}\n\n".format(
            evaluation.image_object_detection_evaluation_metrics
        )
    )

Idiomas adicionales

C#: Sigue las instrucciones de configuración de C# en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de la detección de objetos de AutoML Vision para .NET.

PHP: Sigue las instrucciones de configuración de PHP que se muestran en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de detección de objetos de AutoML Vision para PHP.

Ruby: sigue las instrucciones de configuración de Ruby en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de la detección de objetos de AutoML Vision para Ruby.

Obtener evaluaciones de modelos

También puedes obtener una evaluación de modelo específica para una etiqueta (displayName) mediante un ID de evaluación.

IU web

En la IU de la detección de objetos de AutoML Vision, puedes realizar la misma operación si ingresas en la página Modelos y, luego, seleccionas tu modelo. Después de seleccionar el modelo, ve a la pestaña Evaluate (Evaluar) y selecciona la etiqueta para ver las evaluaciones específicas de esa etiqueta.

Etiqueta específica de la página de evaluación del modelo

LÍNEA DE CMD Y REST

Antes de usar cualquiera de los siguientes datos de solicitud, realiza estos reemplazos:

  • project-id: Es el ID de tu proyecto de GCP.
  • model-id: Es el ID del modelo, que se muestra en la respuesta que recibiste cuando lo creaste. El ID es el último elemento del nombre del modelo. Por ejemplo:
    • Nombre del modelo: projects/project-id/locations/location-id/models/IOD4412217016962778756
    • ID del modelo: IOD4412217016962778756
  • model-evaluation-id: Es el valor de ID de la evaluación del modelo. Puedes obtener los ID de evaluación de modelos a partir de la operación list de evaluación de modelos.

Método HTTP y URL:

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

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el siguiente comando:

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

Ejecuta el siguiente comando:

$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

Deberías recibir una respuesta JSON similar a la siguiente. Los campos específicos de detección de objetos clave están en negrita, y se muestra una versión abreviada de las entradas boundingBoxMetricsEntries para brindar una vista más clara:



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

Comienza a usarlo

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

	return nil
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas 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 probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas 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 probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas 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("Model evaluation name: {}".format(response.name))
print("Model annotation spec id: {}".format(response.annotation_spec_id))
print("Create Time: {}".format(response.create_time))
print("Evaluation example count: {}".format(response.evaluated_example_count))
print(
    "Object detection model evaluation metrics: {}".format(
        response.image_object_detection_evaluation_metrics
    )
)

Idiomas adicionales

C#: Sigue las instrucciones de configuración de C# en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de la detección de objetos de AutoML Vision para .NET.

PHP: Sigue las instrucciones de configuración de PHP que se muestran en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de detección de objetos de AutoML Vision para PHP.

Ruby: sigue las instrucciones de configuración de Ruby en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de la detección de objetos de AutoML Vision para Ruby.

Verdaderos positivos, falsos negativos y falsos positivos (solo IU)

En la interfaz de usuario, se pueden observar ejemplos específicos del rendimiento del modelo, es decir, instancias de verdadero positivo (VP), falso negativo (FN), y falso positivo (FP) de tus conjuntos TRAINING y VALIDATION.

IU web

Puedes acceder a la vista de VP, FN y FP en la IU. Para ello, selecciona la pestaña Evaluar y, luego, selecciona cualquier etiqueta específica.

Mediante la visualización de tendencias en estas predicciones, puedes modificar el conjunto de entrenamiento para mejorar el rendimiento del modelo.

Las imágenes con verdaderos positivos son cuadros de validación que se proporcionan al modelo entrenado y que el modelo anotó de forma correcta:

Se muestran verdaderos positivos

Las imágenes con falsos negativos se proporcionan de manera similar al modelo entrenado, pero este no pudo anotar de forma correcta una instancia de un objeto:

Se muestran falsos negativos

Por último, las imágenes con falsos positivos son aquellas que se proporcionan al modelo entrenado que anotó instancias de un objeto que no se anotaron en el área especificada:

Se muestran falsos positivos

El modelo selecciona casos excepcionales interesantes, lo que presenta una oportunidad para definir mejor las etiquetas y definiciones a fin de ayudar al modelo a entender las interpretaciones de las etiquetas. Por ejemplo, una definición más estricta ayudaría a que el modelo entienda si consideras que un pimiento relleno es una “ensalada” (o no). Con etiquetas repetidas, entrenamiento y bucles de evaluación, el modelo mostrará otras ambigüedades similares en tus datos.

También puedes ajustar el umbral de puntuación en esta vista en la interfaz de usuario, y las imágenes con VP, FN y FP que se muestran reflejarán el cambio de umbral:

Verdaderos positivos con umbral actualizado

Interpreta las métricas de evaluación

Los modelos de detección de objetos muestran muchos cuadros de límite para una imagen de entrada. Cada cuadro contiene una etiqueta y una puntuación o confianza. Las métricas de evaluación te ayudarán a responder varias preguntas clave sobre el rendimiento del modelo:

  • ¿Recibo la cantidad correcta de cuadros?
  • ¿El modelo tiende a dar puntuaciones más bajas a los casos marginales?
  • ¿En qué medida coinciden los cuadros previstos con los cuadros de verdad fundamental?

Ten en cuenta que estas métricas, al igual que las de clasificación con varias etiquetas, no señalarán ninguna confusión de clase más que las de puntuaciones genéricamente más bajas.

Cuando analizas el resultado del modelo por imagen, necesitas una forma de examinar un par de cuadros (el cuadro de verdad fundamental y el previsto) y determinar el grado de coincidencia entre ellos. Debes tener en cuenta los siguientes puntos:

  • ¿Ambos cuadros tienen la misma etiqueta?
  • ¿Qué tan bien se superponen los cuadros?
  • ¿Con qué seguridad el modelo predijo el cuadro?

Para abordar el segundo requisito, presentamos una medición nueva llamada intersección sobre la unión o IoU.

IoU y el umbral de IoU

Ilustración de intersección de cuadros sobre unión de cuadros

La intersección sobre la unión determina el grado de coincidencia entre dos cuadros. El valor de IoU varía entre 0 (sin superposición) y 1 (los cuadros son idénticos) y se calcula mediante la división del área en común entre los dos cuadros por el área incluida en al menos uno de los cuadros. El servicio de AutoML te permite examinar el rendimiento de tu modelo en varios umbrales de IoU.

¿Por qué deberías cambiar el umbral de IoU?

Considera el caso práctico de contar autos en un estacionamiento. No importa si las coordenadas del cuadro son muy precisas, solo te interesa tener el número total de cuadros correcto. En este caso, un umbral de IoU bajo es adecuado.

Ilustración de cuadros de umbral bajo alrededor de automóviles
Crédito de la imagen: Nacho, “Smart” (CC BY 2.0, cuadros de límite y texto agregado).

También puedes intentar medir el tamaño de una mancha sobre una tela. En este caso, necesitas coordenadas muy precisas y, por lo tanto, es apropiado un umbral de IoU mucho más alto.

Ilustración de un cuadro de umbral alto alrededor de la mancha
Crédito de la imagen: Housing Works Thrift Shops, “Modern Sofa” (CC BY-SA 2.0, cuadros de límite y texto agregado).

Ten en cuenta que no necesitas volver a entrenar el modelo si cambias de parecer en cuanto al umbral correcto para tu caso práctico. Ya tienes acceso a las métricas de evaluación en varios umbrales de IoU.

Puntuación y umbral de puntuación

Al igual que en los modelos de clasificación, los resultados de modelos de detección de objetos (ahora cuadros) incluyen puntuaciones. También, como en la clasificación de imágenes, existe un umbral de puntuación que puedes especificar después del entrenamiento para determinar qué es (o no es) una coincidencia “adecuada”. Cambiar el umbral de puntuación te permite ajustar las tasas de falsos positivos y verdaderos positivos según las necesidades de tu modelo específico. Un usuario que desea una recuperación muy alta suele usar un umbral de puntuación más bajo en el procesamiento del resultado del modelo.

Realiza iteraciones en tu modelo

Si no estás satisfecho con los niveles de calidad, puedes volver a realizar los pasos anteriores para mejorarla:

  • Considera agregar más imágenes a cualquier etiqueta de cuadro de límite con baja calidad.
  • Es posible que tengas que agregar diferentes tipos de imágenes (p. ej., un ángulo más amplio, una mayor o menor resolución, diferentes puntos de vista).
  • Puedes quitar por completo las etiquetas del cuadro de límite si no tienes suficientes imágenes de entrenamiento.
  • Nuestros algoritmos de entrenamiento no usan los nombres de tus etiquetas. Si tienes una etiqueta que dice “door” (puerta) y otra que dice “door_with_knob” (puerta con picaporte), el algoritmo no puede notar la diferencia más allá de las imágenes que le proporcionaste.
  • Mejora los datos con más ejemplos de verdaderos positivos y negativos. Los ejemplos más importantes son los que están cerca del límite de decisión (es decir, los que pueden producir confusión, pero tienen la etiqueta correcta).
  • Especifica tu propia división de TRAIN, TEST y VALIDATE. La herramienta asigna imágenes de forma aleatoria, pero las que están casi duplicadas pueden terminar en TRAIN y VALIDATE, lo que puede llevar a un sobreajuste y un rendimiento deficiente en el conjunto TEST.

Una vez que hayas hecho los cambios, entrena y evalúa un modelo nuevo hasta que alcances un nivel de calidad satisfactorio.