Evaluar modelos

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

Descripción general de la evaluación

AutoML Vision proporciona un conjunto agregado de métricas 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 rendimiento del modelo en la etiqueta.

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

  • Las Curvas del umbral de confianza muestran de qué manera los diferentes umbrales de confidencia 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.

  • Matriz de confusión: solo está presente en modelos de una sola etiqueta por imagen. Representa el porcentaje de veces que se predijo cada etiqueta en el conjunto de entrenamiento durante la evaluación.

    Muestra de matriz de confusión

    Lo ideal es que la etiqueta one se asigne solo a imágenes clasificadas con la etiqueta one, etc., de modo que una matriz perfecta se vería así:

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

    En el ejemplo anterior, si una imagen se clasificó como one, pero el modelo predijo two, la primera fila se vería así:

    99  1  0  0

    Puedes encontrar más información si buscas “aprendizaje automático de la matriz de confusión”.

    AutoML Vision crea la matriz de confusión para un máximo de 10 etiquetas. Si tienes más de 10, la matriz incluye las 10 etiquetas con mayor confusión (predicciones incorrectas).

Usa estos datos para evaluar la preparación de tu modelo. La confusión alta, la puntuación baja de AUC o las puntuaciones de precisión y recuperación bajos pueden indicar que tu modelo necesita datos de entrenamiento adicionales o tiene etiquetas incoherentes. Una puntuación 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.

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 AutoML Vision y haz clic en la pestaña Modelos (con el ícono de la bombilla) en la barra de navegación izquierda para ver los modelos disponibles.

    Para ver los modelos 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 Evaluate (Evaluar) justo debajo de la barra de título.

    Si se completó el entrenamiento para el modelo, AutoML Vision mostrará las métricas de evaluación.

    Página de evaluación del modelo

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • project-id: El ID del 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 print-access-token)" \
     -H "x-goog-user-project: project-id" \
     "https://automl.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/models/MODEL_ID/modelEvaluations/MODEL_EVALUATION_ID"

PowerShell

Ejecuta el siguiente comando: 

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

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

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 classificationEvaluationMetrics para brindar una vista más clara:

Go

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

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

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

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

	it := client.ListModelEvaluations(ctx, req)

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

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

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

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

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(f"Model evaluation name: {evaluation.name}")
    print(f"Model annotation spec id: {evaluation.annotation_spec_id}")
    print(f"Create Time: {evaluation.create_time}")
    print(f"Evaluation example count: {evaluation.evaluated_example_count}")
    print(
        "Classification model evaluation metrics: {}".format(
            evaluation.classification_evaluation_metrics
        )
    )

Idiomas adicionales

C#: sigue las instrucciones de configuración de C# en la página Bibliotecas cliente y, luego, visita la documentación de referencia de AutoML Vision para .NET.

PHP: sigue las instrucciones de configuración de PHP en la página Bibliotecas cliente y, luego, visita la documentación de referencia de AutoML Vision para PHP.

Ruby: sigue las instrucciones de configuración de Ruby en la página Bibliotecas cliente y, luego, visita la documentación de referencia de AutoML Vision para Ruby.

Obtén valores de evaluación del modelo

También puedes obtener una evaluación de modelo específica para una etiqueta (displayName) mediante un ID de evaluación. Para obtener el ID de evaluación del modelo, ejecuta la función de lista de evaluaciones de modelos que se muestra en Mostrar lista de evaluaciones de modelo.

IU web

  1. Abre Vision Dashboard y haz clic en el ícono de la bombilla en la barra de navegación izquierda para ver los modelos disponibles.

    Para ver los modelos 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 Evaluate (Evaluar) justo debajo de la barra de título.

    Si se completó el entrenamiento para el modelo, AutoML Vision mostrará las métricas de evaluación.

    updated evaluate page

  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

REST

Para obtener solo las métricas de evaluación de una etiqueta específica, agrega /{MODEL_EVALUATION_ID} a la solicitud anterior desde la respuesta.

Por ejemplo, puedes encontrar el ID de la evaluación del modelo para la etiqueta rose (displayName) en el nombre de la evaluación que se muestra en la operación de la lista:

  • "name": "projects/PROJECT_ID/locations/us-central1/models/MODEL_ID/modelEvaluations/858136867710915695"

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • project-id: El ID del 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 print-access-token)" \
     -H "x-goog-user-project: project-id" \
     "https://automl.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/models/MODEL_ID/modelEvaluations/MODEL_EVALUATION_ID"

PowerShell

Ejecuta el siguiente comando: 

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

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

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

Go

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

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

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

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

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

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

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

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

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(f"Model evaluation name: {response.name}")
print(f"Model annotation spec id: {response.annotation_spec_id}")
print(f"Create Time: {response.create_time}")
print(f"Evaluation example count: {response.evaluated_example_count}")
print(
    "Classification model evaluation metrics: {}".format(
        response.classification_evaluation_metrics
    )
)

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 los conjuntos TRAINING y VALIDATION.

IU web

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

Puedes acceder a la vista de VP, FN y FP en la IU. Para ello, selecciona la pestaña Evaluate (Evaluate) 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 True positive (Verdadero positivo) son imágenes de muestra proporcionadas al modelo entrenado y que el modelo anotó de manera correcta:

Se muestran verdaderos positivos

Las imágenes False negative (Falso negativo) se proporcionan al modelo entrenado de manera similar, pero el modelo no pudo anotar de manera correcta la imagen para la etiqueta asignada:

Se muestran falsos negativos

Por último, las imágenes False positive (Falso positivo) son aquellas proporcionadas al modelo entrenado que sí se anotaron con la etiqueta asignada, pero no deberían haberse anotado:

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 tú consideras que una pintura abstracta de una rosa es una “rosa” (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

Realiza iteraciones en tu modelo

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

  • AutoML Vision te permite ordenar las imágenes según la “confusión” del modelo, la etiqueta verdadera y la etiqueta predicha. Revisa estas imágenes y asegúrate de que estén etiquetadas de forma correcta.
  • Considera agregar más imágenes a cualquier etiqueta con baja calidad.
  • Es posible que debas agregar diferentes tipos de imágenes (p. ej., un ángulo más amplio, mayor o menor resolución, diferentes puntos de vista).
  • Considera quitar etiquetas si no tienes suficientes imágenes de entrenamiento.
  • Recuerda que las máquinas no pueden leer el nombre de tu etiqueta; solo la ven como una string de letras al azar. Si tienes una etiqueta que dice "puerta" y otra que dice "puerta_con_picaporte", la máquina no puede distinguir el matiz más allá de las imágenes que le proporciones.
  • Mejora tus 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 Entrenamiento, Prueba y Validación. La herramienta asigna imágenes al azar, pero las que sean casi idénticas pueden terminar en Entrenamiento y Validación, lo que podría llevar a un sobreajuste y un rendimiento deficiente en el conjunto de Prueba.

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