Évaluer des modèles

Après avoir entraîné un modèle, AutoML Translation évalue la qualité et la précision du nouveau modèle à l'aide des éléments présents dans les ensembles de VALIDATION et de TEST. AutoML Translation exprime la qualité du modèle grâce à son score BLEU (Bilingual Evaluation Understudy), qui indique la similitude entre la traduction automatique et les textes de référence. Plus ce score est proche de 1, plus les textes sont similaires.

Le score BLEU fournit une évaluation globale de la qualité du modèle. Vous pouvez également évaluer la sortie du modèle pour des éléments de données spécifiques en exportant l'ensemble de TEST avec les prédictions du modèle. Les données exportées incluent à la fois le texte de référence (issu de l'ensemble de données d'origine) et la traduction automatique du modèle.

Évaluez l'état de préparation de votre modèle à l'aide de ces données. Si vous n'êtes pas satisfait de la qualité, envisagez d'ajouter des paires de phrases d'entraînement supplémentaires (et plus diversifiées). Vous pouvez effectuer cette opération en cliquant sur le lien Ajouter des fichiers dans la barre de titre. Une fois vos fichiers ajoutés, entraînez un nouveau modèle en cliquant sur le bouton Entraîner le nouveau modèle de la page Entraînement. Répétez le processus jusqu'à atteindre un niveau de qualité correct.

Obtenir l'évaluation du modèle

UI Web

  1. Ouvrez la console AutoML Translation, puis cliquez sur l'icône représentant une ampoule à côté de Modèles dans la barre de navigation de gauche. Les modèles disponibles s'affichent. Pour chaque modèle, les informations suivantes sont incluses : l'ensemble de données (à partir duquel le modèle a été entraîné), la (langue) source, la (langue) cible et le modèle de base (utilisé pour entraîner le modèle).

    Onglet

    Pour afficher les modèles d'un autre projet, sélectionnez le projet dans la liste déroulante située en haut à droite de la barre de titre.

  2. Cliquez sur la ligne du modèle que vous souhaitez évaluer.

    L'onglet Predict (Prédiction) s'ouvre.

    Dans cet onglet, vous pouvez tester votre modèle, et consulter les résultats du modèle personnalisé et du modèle de base qui a servi à l'entraînement.

  3. Cliquez sur l'onglet Entraînement situé juste en dessous de la barre de titre.

    Une fois l'entraînement du modèle terminé, AutoML Translation affiche ses métriques d'évaluation.

    Onglet

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • model-name : nom complet de votre modèle qui inclut le nom et l'emplacement de votre projet. Voici un exemple de nom de modèle : projects/project-id/locations/us-central1/models/model-id.

Méthode HTTP et URL :

GET https://automl.googleapis.com/v1/model-name/modelEvaluations

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

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

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 com.google.protobuf.Timestamp;
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:");
      Timestamp createdTime = modelEvaluation.getCreateTime();
      System.out.format("\tseconds: %s%n", createdTime.getSeconds());
      System.out.format("\tnanos: %s", createdTime.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

Pour pouvoir exécuter cet exemple de code, vous devez installer les bibliothèques clientes Python.

  • Le paramètre model_id correspond à l'ID de votre modèle. L'ID est le dernier élément du nom du modèle. Par exemple, si le nom de votre modèle est projects/434039606874/locations/us-central1/models/3745331181667467569, son ID est 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
    )
)

Exporter des données de test avec les prédictions d'un modèle

Après avoir entraîné un modèle, AutoML Translation évalue sa qualité et sa précision à l'aide des éléments de l'ensemble de TEST. La console AutoML Translation vous permet d'exporter l'ensemble de TEST afin de comparer la sortie du modèle au texte de référence issu de l'ensemble de données d'origine. AutoML Translation enregistre un fichier TSV dans le bucket Google Cloud Storage, chaque ligne ayant le format suivant :

Source sentence tabulation Reference translation tabulation Model candidate translation

UI Web

  1. Ouvrez la console AutoML Translation, puis cliquez sur l'icône représentant une ampoule à gauche de Models (Modèles) dans la barre de navigation de gauche pour afficher les modèles disponibles.

    Onglet Models (Modèles) répertoriant un modèle

    Pour afficher les modèles d'un autre projet, sélectionnez le projet dans la liste déroulante située en haut à droite de la barre de titre.

  2. Sélectionnez le modèle.

  3. Cliquez sur le bouton Exporter des données dans la barre de titre.

  4. Entrez le chemin d'accès complet au bucket Google Cloud Storage dans lequel vous souhaitez enregistrer le fichier .tsv exporté.

    Le bucket doit être associé au projet en cours.

  5. Choisissez le modèle dont vous souhaitez exporter les données de TEST.

    La liste déroulante Ensemble de test avec prédictions de modèle répertorie les modèles entraînés à l'aide du même ensemble de données en entrée.

  6. Cliquez sur Exporter.

    AutoML Translation écrit un fichier nommé model-name_evaluated.tsv dans le bucket Google Cloud Storage spécifié.

Évaluer et comparer des modèles à l'aide d'un nouvel ensemble de test

Depuis la console AutoML Translation, vous pouvez réévaluer les modèles existants en utilisant un nouvel ensemble de données de test. Dans une même évaluation, vous pouvez inclure jusqu'à cinq modèles différents, puis comparer leurs résultats.

Importez vos données de test dans Cloud Storage en tant que fichier de valeurs séparées par des tabulations (.tsv) ou en tant que fichier d'Translation Memory eXchange (.tmx).

AutoML Translation évalue vos modèles par rapport à l'ensemble de test, puis génère des scores. Vous pouvez éventuellement enregistrer les résultats pour chaque modèle en tant que fichier .tsv dans un bucket Cloud Storage, chaque ligne ayant le format suivant :

Source sentence tab Model candidate translation tab Reference translation

UI Web

  1. Ouvrez la console AutoML Translation et cliquez sur Models (Modèles) dans le volet de navigation de gauche pour afficher les modèles disponibles.

    Onglet Models (Modèles) répertoriant un modèle

    Pour afficher les modèles d'un autre projet, sélectionnez le projet dans la liste déroulante située en haut à droite de la barre de titre.

  2. Sélectionnez l'un des modèles que vous souhaitez évaluer.

  3. Cliquez sur l'onglet Evaluate (Évaluation) situé juste en dessous de la barre de titre.

    Onglet

  4. Dans l'onglet Évaluer, cliquez sur Nouvelle évaluation.

    Onglet

    • Sélectionnez les modèles que vous souhaitez évaluer et comparer. Le modèle actuel doit être sélectionné. Google NMT est sélectionné par défaut et vous pouvez retirer cette sélection.
    • Indiquez le Nom de l'ensemble de test afin de le distinguer des autres évaluations, puis sélectionnez votre nouvel ensemble de test à partir de Cloud Storage.
    • Si vous souhaitez exporter les prédictions basées sur votre ensemble de test, spécifiez un bucket Cloud Storage dans lequel les résultats seront stockés (le tarif standard par caractère s'applique).
  5. Cliquez sur OK.

    AutoML Translation présente les scores d'évaluation sous forme de table dans la console une fois l'évaluation terminée. Vous ne pouvez exécuter qu'une seule évaluation à la fois. Si vous avez spécifié un bucket pour stocker les résultats de la prédiction, AutoML Translation écrit des fichiers nommés model-name_test-set-name.tsv dans le bucket.

Comprendre le score BLEU

La métrique BLEU (BiLingual Evaluation Understudy) permet d'évaluer une traduction automatique. Le score BLEU est représenté par un nombre entre zéro et un, qui mesure la similitude entre un texte traduit automatiquement et un ensemble de traductions de référence de haute qualité. Une valeur égale à 0 indique que la traduction automatique ne correspond en rien à la traduction de référence (mauvaise qualité), tandis qu'une valeur égale à 1 signale une correspondance parfaite avec les traductions de référence (haute qualité).

Il a été démontré que les scores BLEU coïncident fortement avec ce qu'un humain peut penser de la qualité d'une traduction. Notez que même les traducteurs humains n'atteignent pas un score parfait de 1,0.

Plutôt que d'utiliser un nombre décimal compris entre 0 et 1, AutoML exprime les scores BLEU sous forme de pourcentage.

Interprétation

Nous vous déconseillons fortement d'essayer de comparer des scores BLEU entre plusieurs corpus et plusieurs langues. Même si vous comparez des scores BLEU pour un même corpus, mais avec un nombre de traductions de référence différent, le résultat peut se révéler extrêmement trompeur.

Toutefois, l'interprétation suivante des scores BLEU (exprimés en pourcentages et non en décimales) peut s'avérer utile à titre indicatif :

Score BLEU Interprétation
< 10 Traductions presque inutiles
10 à 19 L'idée générale est difficilement compréhensible
20 à 29 L'idée générale apparaît clairement, mais le texte comporte de nombreuses erreurs grammaticales
30 à 40 Résultats compréhensibles à traductions correctes
40 à 50 Traductions de haute qualité
50 à 60 Traductions de très haute qualité, adéquates et fluides
> 60 Qualité souvent meilleure que celle d'une traduction humaine

Le dégradé de couleur suivant peut vous servir à interpréter le score BLEU de manière générale :

Interprétabilité générale

Explication mathématique

Mathématiquement, le score BLEU est défini de la manière suivante :

$$ \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}} $$

par

\[ 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}} \]

où :

  • \(m_{cand}^i\hphantom{xi}\) est le nombre d'i-grammes dans la traduction automatique qui correspondent à la traduction de référence.
  • \(m_{ref}^i\hphantom{xxx}\) est le nombre d'i-grammes dans la traduction de référence.
  • \(w_t^i\hphantom{m_{max}}\) est le nombre total d'i-grammes dans la traduction automatique.

La formule se compose de deux parties : la pénalité de concision et la correspondance de n-grammes.

  • Pénalité de concision
    La pénalité de concision pénalise les traductions générées qui sont trop courtes par rapport à la longueur de référence la plus proche, avec une décroissance exponentielle. Cette pénalité compense le fait que le score BLEU ne dispose pas de terme de rappel.

  • Correspondance de n-grammes
    La correspondance de n-grammes compte le nombre d'unigrammes, de bigrammes, de trigrammes et de quadrigrammes (i = 1,…,4) qui correspondent à leur équivalent de n-grammes au sein des traductions de référence. Ce terme agit comme une métrique de précision. Les unigrammes rendent compte de l'adéquation, tandis que les n-grammes plus longs rendent compte de la fluidité de la traduction. Pour éviter tout surdénombrement, le nombre de n-grammes est réduit au nombre maximal de n-grammes présents dans la référence (\(m_{ref}^n\)).

Exemples

Calculer \(precision_1\)

Prenons cette phrase de référence ainsi que cette traduction automatique :

Référence : the cat is on the mat
Traduction automatique : the the the cat mat

La première étape consiste à compter le nombre d'occurrences de chaque unigramme dans la référence et dans la traduction automatique. Notez que la métrique BLEU est sensible à la casse.

Unigramme \(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

Le nombre total d'unigrammes dans la traduction automatique (\(w_t^1\)) est de 5, donc \(precision_1\) = (2 + 1 + 1)/5 = 0,8.

Calculer le score BLEU

Référence :     The NASA Opportunity rover is battling a massive dust storm on Mars .
Traduction automatique 1 : The Opportunity rover is combating a big sandstorm on Mars .
Traduction automatique 2 : A NASA rover is fighting a massive storm on Mars .

L'exemple ci-dessus comprend un texte de référence et deux traductions automatiques. Avant que le score BLEU soit calculé tel que décrit ci-dessus, les phrases sont tokenisées. Par exemple, le point final est comptabilisé comme un jeton distinct.

Afin de calculer le score BLEU de chaque traduction, nous calculons les statistiques suivantes :

  • Précision des n-grammes
    Le tableau suivant indique la précision des n-grammes pour les deux traductions automatiques.
  • Pénalité de concision
    La pénalité de concision est la même pour les traductions automatiques 1 et 2, car les deux phrases se composent de 11 jetons.
  • Score BLEU
    Notez que pour obtenir un score supérieur à 0, les textes doivent posséder au moins un quadrigramme correspondant. Comme aucun quadrigramme ne correspond dans la traduction automatique 1, son score BLEU est de 0.
Métrique Traduction automatique 1 Traduction automatique 2
\(precision_1\) (unigramme) 8/11 9/11
\(precision_2\) (bigramme) 4/10 5/10
\(precision_3\) (trigramme) 1/9 2/9
\(precision_4\) (quadrigramme) 0/8 1/8
Pénalité de concision 0,83 0,83
Score BLEU 0,0 0,27

Propriétés

  • La métrique BLEU est basée sur un corpus
    La métrique BLEU ne permet pas d'évaluer efficacement des phrases individuelles. Ainsi, bien qu'ils restituent en grande partie le sens d'origine, les deux exemples de phrases présentent des scores BLEU très bas. Comme les statistiques relatives aux n-grammes s'avèrent moins pertinentes pour les phrases individuelles, la métrique BLEU est, par nature, une métrique basée sur un corpus. En d'autres termes, les statistiques sont obtenues à partir d'un corpus entier lors du calcul du score. Notez que la métrique BLEU définie ci-dessus ne peut pas être factorisée pour des phrases individuelles.

  • Aucune distinction n'est faite entre le contenu et les mots-outils
    La métrique BLEU ne fait pas la distinction entre le contenu et les mots-outils. Par exemple, la pénalité liée à l'omission d'un mot-outil tel que "un" est identique à la pénalité appliquée en cas de remplacement du terme "NASA" par "ESA".

  • La métrique BLEU restitue mal le sens et la grammaticalité d'une phrase
    L'omission d'un seul terme tel que "non" peut inverser le sens d'une phrase. De même, en ne prenant en compte que les n-grammes où n ≤ 4, la métrique BLEU ignore les longues dépendances. Elle n'impose donc souvent qu'une faible pénalité aux phrases non grammaticales.

  • Normalisation et tokenisation
    Avant le calcul du score BLEU, les traductions de référence et les traductions automatiques sont normalisées et tokenisées. Le choix des étapes de normalisation et de tokenisation affecte considérablement le score BLEU final.