Esta documentación es para AutoML Natural Language, que es diferente de la API de Vertex. Si usas la IA de Vertex, consulta la documentación de Vertex AI.

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 y la recuperación 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 (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 Evaluate (Evaluar) 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

  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.

LÍNEA DE REST Y CMD

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

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(
        "Classification model evaluation metrics: {}".format(
            evaluation.classification_evaluation_metrics
        )
    )

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

Comienza a usarlo

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
}

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.