Evaluar modelos

Después de que se entrena un modelo, AutoML Natural Language utiliza documentos del conjunto TEST para evaluar la calidad y la exactitud del nuevo modelo.

AutoML Natural Language proporciona un conjunto agregado de métricas de evaluación que indican el desempeño general del modelo, así como métricas de evaluación para cada etiqueta de categoría, que indican el desempeño del modelo para esa etiqueta.

La precisión (Precision) y la recuperación (Recall) miden qué tan bien captura la información el modelo y qué omite. La precisión indica, a partir de todos los documentos identificados como una entidad o etiqueta en particular, cuántos se suponía que debían asignarse a esa entidad o etiqueta. La recuperación indica, de todos los documentos que deberían haberse identificado como una entidad o etiqueta en particular, cuántos se asignaron realmente a esa entidad o etiqueta.

La matriz de confusión (Confusion matrix) (solo disponible para modelos de una sola etiqueta por documento) representa el porcentaje de veces que se predijo cada etiqueta en el conjunto de entrenamiento durante la evaluación. Lo ideal es que la etiqueta one se asigne solo a documentos clasificados con la etiqueta one, etc., por lo 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 un documento se clasificó como one, pero el modelo predijo two, la primera fila se verá de la siguiente manera:

99  1  0  0

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

Para los modelos de opiniones:

  • El error absoluto medio (EAM) y el error cuadrático medio (ECM) miden la distancia entre el valor de la opinión que se predijo y el valor de la opinión real. Los valores más bajos significan modelos más precisos.

  • Los índices kappa con ponderación lineal y cuadrática miden el nivel de coincidencia entre los valores de opinión asignados por el modelo y los asignados por evaluadores humanos. Valores más altos indican modelos más exactos.

Usa estas métricas para evaluar la preparación de tu modelo. La presencia de puntuaciones bajas de precisión y recuperación pueden indicar que tu modelo necesita datos de entrenamiento adicionales o que tiene anotaciones incongruentes. La presencia de puntuaciones perfectas de las mismas métricas puede indicar que los datos son demasiado fáciles de evaluar y que no pueden generalizarse bien. Consulta la guía para principiantes si deseas obtener más sugerencias sobre cómo evaluar modelos.

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

  • Puedes agregar más documentos a cualquier etiqueta de calidad baja.
  • Es posible que necesites agregar diferentes tipos de documentos. Por ejemplo, documentos más largos o más cortos, o documentos de diferentes autores que utilizan diferentes palabras o estilos.
  • Puedes limpiar las etiquetas.
  • Considera eliminar las etiquetas por completo si no tiene suficientes documentos de entrenamiento.

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

IU web

Para ver las métricas de evaluación de tu modelo, sigue estos pasos:

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

    Si completaste el entrenamiento para el modelo, AutoML Natural Language mostrará las métricas de evaluación.

    Página Evaluar (Evaluate)

  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.

Muestras de código

Las muestras proporcionan una evaluación del modelo en su conjunto. También puedes obtener las métricas de una etiqueta específica (displayName) mediante un ID de evaluación.

REST

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

  • project-id: el ID de tu proyecto
  • location-id: la ubicación del recurso; us-central1 para la ubicación global o eu para la Unión Europea
  • model-id: ID del modelo

Método HTTP y URL: 

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

Para enviar tu solicitud, expande una de estas opciones:

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

{
  "modelEvaluation": [
    {
      "name": "projects/434039606874/locations/us-central1/models/7537307368641647584/modelEvaluations/9009741181387603448",
      "annotationSpecId": "17040929661974749",
      "classificationMetrics": {
        "auPrc": 0.99772006,
        "baseAuPrc": 0.21706384,
        "evaluatedExamplesCount": 377,
        "confidenceMetricsEntry": [
          {
            "recall": 1,
            "precision": -1.3877788e-17,
            "f1Score": -2.7755576e-17,
            "recallAt1": 0.9761273,
            "precisionAt1": 0.9761273,
            "f1ScoreAt1": 0.9761273
          },
          {
            "confidenceThreshold": 0.05,
            "recall": 0.997,
            "precision": 0.867,
            "f1Score": 0.92746675,
            "recallAt1": 0.9761273,
            "precisionAt1": 0.9761273,
            "f1ScoreAt1": 0.9761273
          },
          {
            "confidenceThreshold": 0.1,
            "recall": 0.995,
            "precision": 0.905,
            "f1Score": 0.9478684,
            "recallAt1": 0.9761273,
            "precisionAt1": 0.9761273,
            "f1ScoreAt1": 0.9761273
          },
          {
            "confidenceThreshold": 0.15,
            "recall": 0.992,
            "precision": 0.932,
            "f1Score": 0.96106446,
            "recallAt1": 0.9761273,
            "precisionAt1": 0.9761273,
            "f1ScoreAt1": 0.9761273
          },
          {
            "confidenceThreshold": 0.2,
            "recall": 0.989,
            "precision": 0.951,
            "f1Score": 0.96962786,
            "recallAt1": 0.9761273,
            "precisionAt1": 0.9761273,
            "f1ScoreAt1": 0.9761273
          },
          {
            "confidenceThreshold": 0.25,
            "recall": 0.987,
            "precision": 0.957,
            "f1Score": 0.9717685,
            "recallAt1": 0.9761273,
            "precisionAt1": 0.9761273,
            "f1ScoreAt1": 0.9761273
          },
        ...
        ],
      },
      "createTime": "2018-04-30T23:06:14.746840Z"
    },
    {
      "name": "projects/434039606874/locations/us-central1/models/7537307368641647584/modelEvaluations/9009741181387603671",
      "annotationSpecId": "1258823357545045636",
      "classificationMetrics": {
        "auPrc": 0.9972302,
        "baseAuPrc": 0.1883289,
      ...
      },
      "createTime": "2018-04-30T23:06:14.649260Z"
    }
  ]
}

Python

Para aprender a instalar y usar la biblioteca cliente de AutoML Natural Language, consulta Bibliotecas cliente de AutoML Natural Language. Para obtener más información, consulta la documentación de referencia de la API de Python de AutoML Natural Language.

Para autenticarte en AutoML Natural Language, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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

Java

Para aprender a instalar y usar la biblioteca cliente de AutoML Natural Language, consulta Bibliotecas cliente de AutoML Natural Language. Para obtener más información, consulta la documentación de referencia de la API de Java de AutoML Natural Language.

Para autenticarte en AutoML Natural Language, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 


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

Para aprender a instalar y usar la biblioteca cliente de AutoML Natural Language, consulta Bibliotecas cliente de AutoML Natural Language. Para obtener más información, consulta la documentación de referencia de la API de Node.js de AutoML Natural Language.

Para autenticarte en AutoML Natural Language, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

/**
 * 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();

Go

Para aprender a instalar y usar la biblioteca cliente de AutoML Natural Language, consulta Bibliotecas cliente de AutoML Natural Language. Para obtener más información, consulta la documentación de referencia de la API de Go de AutoML Natural Language.

Para autenticarte en AutoML Natural Language, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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
}

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 Natural Language 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 Natural Language para PHP.

Ruby : Sigue las Instrucciones de configuración de Ruby en la página de bibliotecas cliente y, luego, visita la documentación de referencia de AutoML Natural Language para Ruby.