Evalúa modelos

Después de entrenar un modelo, AutoML Translation usa elementos de los conjuntos de VALIDATION y TEST para evaluar la calidad y precisión del modelo nuevo. AutoML Translation expresa la calidad del modelo mediante su puntuación BLEU (Bilingual Evaluation Understudy), que indica el grado de similitud entre el texto candidato y los textos de referencia; los valores cercanos a uno representan textos más similares.

La puntuación BLEU proporciona una evaluación general de la calidad del modelo. También puedes evaluar la salida del modelo para elementos de datos específicos mediante la exportación del conjunto de PRUEBA con las predicciones del modelo. Los datos exportados incluyen el texto de referencia (del conjunto de datos original) y el texto candidato del modelo.

Usa estos datos para evaluar la preparación de tu modelo. Si no estás satisfecho con el nivel de calidad, considera agregar más pares de oraciones de entrenamiento (y más diversos). Una opción es agregar más pares de oraciones. Usa el vínculo Agregar archivos en la barra de título. Una vez que agregaste archivos, entrena un modelo nuevo; para eso, haz clic en el botón Entrenar modelo nuevo en la página Entrenar. Repite este proceso hasta que alcances un nivel de calidad lo suficientemente alto.

Obtener la evaluación del modelo

IU web

  1. Abre la IU de AutoML Translation y haz clic en el ícono de la bombilla junto a Modelos en la barra de navegación izquierda. Se muestran los modelos disponibles. Para cada modelo, se incluye la siguiente información: Conjunto de datos (Dataset), a partir del cual se entrenó el modelo; Idioma fuente (Source); Idioma objetivo (Target); Modelo base (Base model), que se usa para entrenar el modelo.

    Pestaña Modelos (Models) que muestra un modelo

    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.

    Se abrirá la pestaña Predecir (Predict).

    Aquí, puedes probar tu modelo y ver los resultados tanto del modelo personalizado como del modelo base con el que entrenabas.

  3. Haz clic en la pestaña Entrenar (Train) justo debajo de la barra de título.

    Cuando se completa el entrenamiento del modelo, AutoML Translation muestra sus métricas de evaluación.

    Pestaña Entrenar (Train) de my_dataset que muestra la evaluación del modelo

LÍNEA DE CMD Y REST

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

  • model-name: el nombre completo de tu modelo. Incluye el nombre y la ubicación del proyecto. El nombre de un modelo es similar al siguiente ejemplo: projects/project-id/locations/us-central1/models/model-id.

Método HTTP y URL:

GET https://automl.googleapis.com/v1/model-name/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/project-number/locations/us-central1/models/model-id/modelEvaluations/evaluation-id",
      "createTime": "2019-10-02T00:20:30.972732Z",
      "evaluatedExampleCount": 872,
      "translationEvaluationMetrics": {
        "bleuScore": 48.355409502983093,
        "baseBleuScore": 39.071375131607056
      }
    }
  ]
}

C#

/// <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(
        $"Model Evaluation Metrics: {modelEvaluation.TranslationEvaluationMetrics}");
    return 0;
}

Go

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, "Translation model evaluation metrics: %v\n", evaluation.GetTranslationEvaluationMetrics())

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

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

getModelEvaluation();

PHP

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->getTranslationEvaluationMetrics());
} finally {
    $client->close();
}

Python

Antes de que puedas ejecutar este ejemplo de código, debes instalar las bibliotecas cliente de Python.

  • El parámetro model_id es el ID de tu modelo. El ID es el último elemento del nombre de tu modelo. Por ejemplo, si el nombre de tu modelo es projects/434039606874/locations/us-central1/models/3745331181667467569, entonces el ID de tu modelo es 3745331181667467569.
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(
    "Translation model evaluation metrics: {}".format(
        response.translation_evaluation_metrics
    )
)

Exporta datos de prueba con las predicciones de modelo

Después de entrenar un modelo, AutoML Translation usa elementos del conjunto TEST para evaluar la calidad y exactitud del modelo nuevo. Desde la IU de AutoML Translation, puedes exportar el conjunto TEST para ver cómo se compara el resultado del modelo con el texto de referencia del conjunto de datos original. AutoML Translation guarda un archivo TSV en tu depósito de Google Cloud Storage, donde cada fila tiene este formato:

Source sentence tab Reference translation tab Model candidate translation

IU web

  1. Abre la IU de AutoML Translation y haz clic en el ícono de la bombilla a la izquierda de “Modelos” en la barra de navegación izquierda para ver los modelos disponibles.

    Pestaña Modelos (Models) que muestra un modelo

    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. Selecciona el modelo.

  3. Haz clic en el botón Exportar datos en la barra de título.

  4. Ingresa la ruta de acceso completa al depósito de Google Cloud Storage donde quieres guardar el archivo .tsv exportado.

    Debes usar un depósito asociado con el proyecto actual.

  5. Selecciona el modelo cuyos datos de PRUEBA quieres exportar.

    La lista desplegable Conjunto de prueba con predicciones de modelo enumera los modelos entrenados mediante el mismo conjunto de datos de entrada.

  6. Haz clic en Exportar.

    AutoML Translation escribe un archivo llamado model-name_evaluated.tsv en el depósito de Google Cloud Storage especificado.

Evalúa y compara modelos mediante el uso de un conjunto de prueba nuevo

Desde la IU de AutoML Translation, puedes evaluar y comparar modelos mediante el uso de un conjunto de prueba nuevo. Puedes seleccionar hasta 5 modelos y preparar un conjunto de prueba de un archivo TSV en un depósito de Google Cloud Storage, en el que cada fila tiene este formato:

Source sentence tab Reference translation

AutoML Translation evaluará los modelos seleccionados en el conjunto de prueba, producirá puntuaciones de evaluación y, de forma opcional, guardará un archivo TSV por modelo en tu depósito de Google Cloud Storage, en el que cada fila tiene este formato:

Source sentence tab Model candidate translation tab Reference translation

IU web

  1. Abre la IU de AutoML Translation y haz clic en el ícono de la bombilla a la izquierda de “Modelos” en la barra de navegación izquierda para ver los modelos disponibles.

    Pestaña Models (Modelos) que muestra un modelo

    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. Selecciona el modelo.

  3. Haz clic en la pestaña Evaluar que se encuentra justo debajo de la barra de título.

    Pestaña Evaluar del conjunto de datos my_dataset

  4. Haz clic en el botón “New Evaluation” (Nueva evaluación) de la página.

    Pestaña Nueva evaluación del modelo my_model

    • Selecciona los modelos que deseas evaluar y comparar. Se debe seleccionar el modelo actual. La NMT de Google se selecciona de forma predeterminada. Puedes anular la selección de los modelos de NMT de Google o seleccionar otros para la comparación.
    • Especifica un Nombre de conjunto de prueba para distinguir con más facilidad tus evaluaciones y selecciona el conjunto de prueba nuevo como un archivo TSV en el depósito de Google Cloud Storage, en el que cada fila tiene este formato: Source sentence tab Reference translation
    • Personaliza la salida. La evaluación del modelo incluye un conjunto de prueba de exportación evaluado para el depósito de Google Cloud Storage seleccionado (se aplica el precio de tarifa por carácter estándar). Puedes seleccionar la opción de no exportar el conjunto de prueba evaluado para evitar cargos de traducción por carácter.
  5. Haz clic en Listo y AutoML Translation escribirá archivos con el nombre model-name _ test-set-name.tsv en el depósito de Google Cloud Storage especificado, y mostrará las puntuaciones de evaluación en el formato de tabla en la IU después de realizar la evaluación. Solo puedes ejecutar una evaluación a la vez.

Comprende la puntuación BLEU

BLEU (BiLingual Evaluation Understudy) es una métrica para evaluar de forma automática el texto traducido automáticamente. La puntuación BLEU es un número entre cero y uno que mide la similitud del texto traducido de manera automática con un conjunto de traducciones de referencia de alta calidad. Un valor de 0 significa que la traducción automática de salida no se superpone con la traducción de referencia (calidad baja), mientras que un valor de 1 significa que se superpone perfectamente con las traducciones de referencia (calidad alta).

Se ha demostrado que las puntuaciones BLEU se correlacionan adecuadamente con el criterio humano de la calidad de la traducción. Ten en cuenta que incluso los traductores humanos no logran la puntuación perfecta de 1.0.

AutoML expresa las puntuaciones BLEU como un porcentaje en vez de como un decimal entre 0 y 1.

Interpretación

No se recomienda intentar comparar las puntuaciones BLEU en diferentes idiomas y contenidos. Incluso la comparación de puntuaciones BLEU para el mismo contenido, pero con diferentes números de traducciones de referencia puede ser altamente engañosa.

Sin embargo, como una mera indicación, la siguiente interpretación de puntuaciones BLEU (expresadas como porcentajes antes de que como decimales) podría ser útil.

Puntuación BLEU Interpretación
< 10 Casi inútil
10 - 19 Difícil de capar la esencia
20 - 29 La esencia es clara, pero tiene errores gramaticales significativos
30 - 40 Comprensible por buenas traducciones
40 - 50 Traducciones de alta calidad
50 - 60 Traducciones de calidad muy alta, adecuadas y fluidas
> 60 Calidad que suele ser mejor que la humana

El gradiente de color a continuación se puede usar como una interpretación de la puntuación BLEU de escala general:

Interpretabilidad general de la escala

Los detalles matemáticos

Matemáticamente, la puntuación BLEU se define como:

$$ \text{BLEU} = \underbrace{\vphantom{\prod_i^4}\min\Big(1, \exp\big(1-\frac{\text{reference-length}} {\text{output-length}}\big)\Big)}_{\text{brevity penalty}} \underbrace{\Big(\prod_{i=1}^{4} precision_i\Big)^{1/4}}_{\text{n-gram overlap}}$$

con

\[ precision_i = \dfrac{\sum_{\text{snt}\in\text{Cand-Corpus}}\sum_{i\in\text{snt}}\min(m^i_{cand}, m^i_{ref})} {w_t^i = \sum_{\text{snt'}\in\text{Cand-Corpus}}\sum_{i'\in\text{snt'}} m^{i'}_{cand}} \]

donde:

  • \(m_{cand}^i\hphantom{xi}\) es el recuento de i-grama en el candidato que coincide con la traducción de referencia
  • \(m_{ref}^i\hphantom{xxx}\) es el recuento de i-grama en la traducción de referencia
  • \(w_t^i\hphantom{m_{max}}\) es el número total de i-gramas en la traducción candidata

La fórmula consta dos partes: la penalización por brevedad y la superposición de n-grama.

  • Penalización por brevedad
    La penalización por brevedad penaliza las traducciones generadas que son demasiado cortas en comparación con la longitud de referencia más cercana con una disminución exponencial. La penalización por brevedad compensa el hecho de que la puntuación BLEU no tiene un término de recuperación.

  • Superposición de n-grama
    La superposición de n-grama cuenta cuántos unigramas, bigramas, trigramas y cuatro-gramas (i=1,…, 4 ) coinciden con su contraparte de n-grama en las traducciones de referencia. Este término actúa como una métrica de precisión. Los unigramas explican la adecuación, mientras que los n-gramas más largos explican la fluidez de la traducción. Para evitar el recuento excesivo, los recuentos del n-grama se acortan al recuento máximo del n-grama que aparece en la referencia (\(m_{ref}^n\)).

Ejemplos

Calcular \(precision_1\)

Considera esta oración de referencia y traducción candidata:

Referencia: the cat is on the mat
Candidato: the the the cat mat

El primer paso es contar las ocurrencias de cada unigrama en la referencia y en el candidato. Ten en cuenta que la métrica BLEU distingue entre mayúsculas y minúsculas.

Unigrama \(m_{cand}^i\hphantom{xi}\) \(m_{ref}^i\hphantom{xxx}\) \(\min(m^i_{cand}, m^i_{ref})\)
the 3 2 2
cat 1 1 1
is 0 1 0
on 0 1 0
mat 1 1 1

El número total de unigramas en el candidato (\(w_t^1\)) es 5, por lo tanto \(precision_1\) = (2 + 1 + 1)/5 = 0.8.

Calcula la puntuación BLEU

Referencia: The NASA Opportunity rover is battling a massive dust storm on Mars .
Candidato 1: The Opportunity rover is combating a big sandstorm on Mars .
Candidato 2: A NASA rover is fighting a massive storm on Mars .

El ejemplo anterior consta de una sola referencia y de dos traducciones candidatas. A las oraciones se le asignan tokens antes de calcular la puntuación BLEU como se muestra arriba; por ejemplo, el punto final se cuenta como un token separado.

Para calcular la puntuación BLEU de cada traducción, calculamos las estadísticas a continuación.

  • Precisiones de N-grama
    En la siguiente tabla, se muestran las precisiones de n-grama para ambos candidatos.
  • Penalización por brevedad
    La penalización por brevedad es la misma para el candidato 1 y el candidato 2, ya que ambas oraciones constan de 11 tokens.
  • Puntuación BLEU
    Ten en cuenta que se requiere al menos un 4-grama que coincida para obtener una puntuación BLEU > 0. Dado que la traducción candidata 1 no tiene un 4-grama equivalente, tiene una puntuación BLEU de 0.
Métrica Candidato 1 Candidato 2
\(precision_1\) (1grama) 8/11 9/11
\(precision_2\) (2grama) 4/10 5/10
\(precision_3\) (3grama) 1/9 2/9
\(precision_4\) (4grama) 0/8 1/8
Penalización por brevedad 0.83 0.83
Puntuación BLEU 0.0 0.27

Propiedades

  • BLEU es una métrica basada en corpus
    La métrica BLEU tiene un mal rendimiento cuando se usa para evaluar oraciones individuales. Por ejemplo, ambas oraciones de ejemplo obtienen puntuaciones BLEU muy bajas a pesar de que capturan la mayor parte del significado. Debido a que las estadísticas del n-grama para oraciones individuales son menos significativas, BLEU es por diseño una métrica basada en el contenido, es decir, las estadísticas se acumulan sobre todo el contenido cuando se calcula la puntuación. Ten en cuenta que la métrica BLEU que se definió antes no se puede factorizar para oraciones individuales.

  • No hay distinción entre palabras de contenido y de función
    La métrica BLEU no distingue entre palabras de contenido y función, es decir, una palabra de función omitida como “un” obtiene la misma penalización que si el nombre “NASA” se reemplazara de forma errónea por “ESA”.

  • No es buena para captar el significado y la gramaticalidad de una oración
    La eliminación de una sola palabra como “no” puede cambiar la polaridad de una oración. Además, si solo se tienen en cuenta los n-gramas con n≤4, se ignoran las dependencias de largo alcance y, por lo tanto, BLEU suele imponer solo una pequeña penalización para las oraciones no gramaticales.

  • Normalización y asignación de token
    Antes de calcular la puntuación BLEU, tanto la traducción candidata como la referencia se normalizan y se les asigna un token. La elección de los pasos de normalización y asignación de token afectan de manera significativa la puntuación BLEU final.