Avaliar modelos

Depois de treinar um modelo, o AutoML Translation usa os itens dos conjuntos VALIDATION e TEST para avaliar a qualidade e a acurácia do novo modelo. O AutoML Translation expressa a qualidade do modelo por meio da pontuação Bilingual Evaluation Understudy (BLEU). Ela indica como o texto candidato é parecido com os de referência, com valores mais próximos ao que representa textos mais similares.

A pontuação BLEU fornece uma avaliação geral da qualidade do modelo. Você também pode avaliar a saída do modelo para itens de dados específicos exportando o conjunto TEST com as previsões do modelo. Os dados exportados incluem o texto de referência (do conjunto de dados original) e o texto candidato do modelo.

Use esses dados para avaliar a prontidão do seu modelo. Se você não está satisfeito com o nível de qualidade, convém adicionar outros pares de frases de treinamento (mais diversificados). Uma opção é adicionar outros pares de frases. Use o link Adicionar arquivos na barra de título. Depois de adicionar arquivos, treine o novo modelo. Basta clicar no botão Treinar novo modelo na página Treinar. Repita esse processo até atingir o nível suficiente de alta qualidade.

Como acessar a avaliação do modelo

IU da Web

  1. Abra o console do AutoML Translation e clique no ícone de lâmpada ao lado de Modelos na barra de navegação à esquerda. Os modelos disponíveis são exibidos. Em cada modelo, as informações a seguir estão incluídas: conjunto de dados (em que o treinamento do modelo se baseia), origem e chegada (idioma) e modelo base (usado para treinar o modelo).

    Guia

    Para ver os modelos de outro projeto, selecione o projeto na lista suspensa na parte superior direita da barra de título.

  2. Clique na linha do modelo que você quer avaliar.

    A guia Prever será aberta.

    Nela, você testa o modelo e vê os resultados dos modelos personalizado e do básico usados no treinamento.

  3. Clique na guia Treinar logo abaixo da barra de título.

    Quando o treinamento for concluído no modelo, o AutoML Translation mostrará as métricas de avaliação dele.

    Guia

REST e linha de comando

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • model-name: pelo nome completo do modelo. Ele inclui o nome e o local do projeto e é semelhante a projects/project-id/locations/us-central1/models/model-id.

Método HTTP e URL:

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

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

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

Antes de executar este código de exemplo, é preciso instalar as bibliotecas de cliente do Python.

  • O parâmetro model_id é o ID do modelo. O ID é o último elemento no nome do modelo. Por exemplo, se o nome do modelo for projects/434039606874/locations/us-central1/models/3745331181667467569, o ID será 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
    )
)

Como exportar dados de teste com previsões de modelo

Depois de treinar um modelo, o AutoML Translation usa itens do conjunto TEST para avaliar a qualidade e a acurácia desse modelo. No console do AutoML Translation, é possível exportar o conjunto TEST para ver como a saída do modelo se compara ao texto de referência do conjunto de dados original. O AutoML Translation salva um arquivo TSV no bucket do Google Cloud Storage, em que cada linha tem este formato:

Source sentence tab Reference translation tab Model candidate translation

IU da Web

  1. Abra o Console do AutoML Translation e clique no ícone de lâmpada à esquerda de ModelsModelos", na barra de navegação à esquerda, para exibir os modelos disponíveis.

    Guia

    Para ver os modelos de outro projeto, selecione o projeto na lista suspensa na parte superior direita da barra de título.

  2. Selecione o modelo.

  3. Clique no botão Exportar dados na barra de título.

  4. Insira o caminho completo do bucket do Google Cloud Storage em que você quer salvar o arquivo .tsv exportado.

    É preciso usar um bucket associado ao projeto atual.

  5. Escolha o modelo cujos dados de teste você quer exportar.

    A lista suspensa Conjunto de testes com previsões do modelo lista os modelos treinados usando o mesmo conjunto de dados de entrada.

  6. Clique em Exportar.

    O AutoML Translation grava um arquivo chamado model-name_evaluated.tsv no bucket especificado do Google Cloud Storage.

Avaliar e comparar modelos usando um novo conjunto de testes

No console do AutoML Translation, você pode reavaliar modelos existentes usando um novo conjunto de dados de teste. Em uma única avaliação, inclua até cinco modelos diferentes e compare os resultados.

Fazer upload dos dados de teste para o Cloud Storage valores separados por tabulação (.tsv ) ou como uma apresentação eXchange de memória de tradução (.tmx).

O AutoML Translation avalia seus modelos em relação ao conjunto de testes e produz pontuações de avaliação. É possível salvar os resultados para cada modelo como um arquivo .tsv em um bucket do Cloud Storage, em que cada linha tem o seguinte formato:

Source sentence tab Model candidate translation tab Reference translation

IU da Web

  1. Abra o Console do AutoML Translation e clique em Modelos no painel de navegação à esquerda para exibir os modelos disponíveis.

    Guia

    Para ver os modelos de outro projeto, selecione o projeto na lista suspensa na parte superior direita da barra de título.

  2. Selecione um dos modelos que você quer avaliar.

  3. Clique na guia Avaliar logo abaixo da barra de título.

    Guia

  4. Na guia Avaliar, clique em Nova avaliação.

    Nova guia de avaliação do modelo my_model

    • Selecione os modelos que você quer avaliar e comparar. O modelo atual precisa ser selecionado, e o Google NMT é selecionado por padrão, que pode ser desmarcado.
    • Especifique um nome para o nome do conjunto de teste para ajudá-lo a diferenciá-lo de outras avaliações e, em seguida, selecione seu novo conjunto de teste do Cloud Storage.
    • Se você quiser exportar as previsões baseadas no seu conjunto de testes, especifique um intervalo do Cloud Storage em que os resultados serão armazenados (padrão por taxa de caracteres preços aplicáveis).
  5. Clique em Done.

    O AutoML Translation apresenta pontuações de avaliação em um formato de tabela no console após a conclusão da avaliação. É possível executar apenas uma avaliação por vez. Se você especificou um intervalo para armazenar os resultados da previsão, o AutoML Translation gravará arquivos chamados model-name_test-set-name.tsv no bucket.

Como entender a pontuação BLEU

BLEU (BiLingual Evaluation Understudy) [em inglês] é uma métrica de avaliação automática do texto traduzido por máquina. A pontuação BLEU é um número entre zero e um que compara a similaridade do texto traduzido por máquina com um conjunto de traduções de referência de alta qualidade. O valor 0 significa que a saída da tradução de máquina não coincide com a tradução de referência (baixa qualidade). O valor 1 significa perfeita correspondência com as traduções de referência (alta qualidade).

As pontuações BLEU têm demonstrado boa correlação com a avaliação humana da qualidade das traduções. Mesmo tradutores humanos não atingem a pontuação perfeita de 1.

O AutoML expressa as pontuações BLEU em porcentagem, e não em decimal entre 0 e 1.

Interpretação

Não recomendamos tentar comparar as pontuações BLEU entre corpora e idiomas diferentes. Mesmo a comparação das pontuações BLEU para o mesmo corpus, mas números diferentes de traduções de referência, pode ser extremamente confusa.

No entanto, como orientação geral, a seguinte interpretação das pontuações BLEU (indicadas como porcentagens em vez de decimais) pode ser útil.

Pontuação BLEU Interpretação
< 10 Praticamente inútil
10 - 19 Difícil de compreender o sentido
20 - 29 O sentido está claro, mas há erros gramaticais graves
30 - 40 Pode ser entendido como boas traduções
40 - 50 Traduções de alta qualidade
50 - 60 Traduções de qualidade muito alta, adequadas e fluentes
> 60 Em geral, qualidade superior à humana

É possível usar o gradiente de cor a seguir como escala geral para interpretar a pontuação BLEU (em inglês):

Interpretabilidade geral da escala

Detalhes matemáticos

Em termos matemáticos, a pontuação BLEU é definida 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}} $$

com

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

em que

  • \(m_{cand}^i\hphantom{xi}\) é a contagem de i-gram no candidato que corresponde à tradução de referência;
  • \(m_{ref}^i\hphantom{xxx}\) é a contagem de i-gram na tradução de referência;
  • \(w_t^i\hphantom{m_{max}}\) é o número total de i-grams na tradução candidata.

A fórmula consiste em duas partes: "brevity penalty" e "n-gram overlap".

  • Brevity penalty
    Penaliza com um decaimento exponencial as traduções geradas que são muito menores do que o tamanho da referência mais próxima. Ela compensa o fato de que a pontuação BLEU não tem um termo de recall.

  • N-gram overlap
    Conta quantos unigramas, bigramas, trigramas e quadrigramas (i=1,...,4) correspondem ao equivalente de "n-gram" nas traduções de referência. Esse termo funciona como uma métrica de precisão. Os unigramas consideram a adequação da tradução. Já os "n-grams" mais longos consideram a fluência. Para evitar a contagem excessiva, as contagens de "n-gram" são vinculadas à contagem máxima de "n-gram" que ocorre na referência (\(m_{ref}^n\)).

Exemplos

Como calcular \(precision_1\)

Considere esta frase de referência e possível tradução:

Referência: the cat is on the mat
Tradução: the the the cat mat

A primeira etapa é contar as ocorrências de cada unigrama na referência e na possível tradução. Observe que a métrica BLEU faz distinção entre maiúsculas e 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

O número total de unigramas no candidato (\(w_t^1\)) é 5, portanto \(precision_1\) = (2 + 1 + 1)/5 = 0,8.

Como calcular a pontuação BLEU

Referência: The NASA Opportunity rover is battling a massive dust storm on Mars .
Tradução 1: The Opportunity rover is combating a big sandstorm on Mars .
Tradução 2: A NASA rover is fighting a massive storm on Mars .

O exemplo acima é formado por uma única referência e duas possíveis traduções. As frases são tokenizadas antes de calcular a pontuação BLEU, conforme representado acima. Por exemplo, o ponto final é contado como um token separado.

Para calcular a pontuação BLEU de cada tradução, calculamos as estatísticas a seguir.

  • N-gram precisions
    A tabela a seguir contém as n-gram precisions de ambas as possíveis traduções.
  • Brevity penalty
    É a mesma para os candidatos 1 e 2, já que as duas frases são formadas por 11 tokens.
  • Pontuação BLEU
    Pelo menos um quadrigrama correspondente é necessário para atingir uma pontuação BLEU maior que 0. Como a possível tradução 1 não tem um quadrigrama correspondente, a pontuação BLEU dela é 0.
Métrica Candidato 1 Candidato 2
\(precision_1\) (1gram) 8/11 9/11
\(precision_2\) (2gram) 4/10 5/10
\(precision_3\) (3gram) 1/9 2/9
\(precision_4\) (4gram) 0/8 1/8
Brevity-Penalty 0,83 0,83
Pontuação BLEU 0 0,27

Propriedades

  • A BLEU é uma métrica baseada em corpus
    A métrica BLEU não apresenta bons resultados quando usada para avaliar frases individuais. No exemplo dado, as duas frases atingem pontuações BLEU muito baixas mesmo capturando grande parte do significado. Como as estatísticas de "n-gram" das frases individuais apresentam menor significado, por concepção, a pontuação BLEU é uma métrica com base no corpus. Ou seja, as estatísticas são acumuladas em um corpus inteiro na hora de calcular a pontuação. Não é possível fatorar a métrica BLEU definida acima em frases individuais.

  • Não há distinção entre palavras de conteúdo e função
    A métrica BLEU não distingue as palavras de conteúdo e função, ou seja, uma palavra de função solta, como "um", recebe a mesma penalidade de um nome "NASA" que é incorretamente substituído por "ESA".

  • Baixa qualidade na captura de significado e gramática de uma frase
    Uma única palavra solta, como "não", pode mudar a polaridade de uma frase. Além disso, o fato de considerar apenas "n-grams" menores que quadrigramas ignora as dependências de longo alcance. Portanto, a BLEU costuma impor somente uma pequena penalidade para frases gramaticalmente incorretas.

  • Normalização e tokenização
    Antes de calcular a pontuação BLEU, as possíveis traduções e as de referência são normalizadas e tokenizadas. A escolha das etapas de normalização e tokenização afeta consideravelmente a pontuação BLEU final.