Métrica BLEU

Actualizado 2020-01-29 Lectura 3 min

Resumen

BLEU mide la calidad de una traducción mediante la coincidencia de n-gramas entre la oración candidata y la de referencia.
Se implementa el cálculo de precisión de n-gramas y la brevity penalty para analizar cómo varía la puntuación.
Se explican sus limitaciones frente al orden de palabras y sinónimos, y cómo usar múltiples referencias para mitigarlas.

1. Concepto de BLEU #

Calcular la precisión modificada para los n-gramas (normalmente hasta 4-gram).
Tomar el promedio logarítmico de las precisiones y convertirlo en promedio geométrico.
Aplicar una brevity penalty si la oración candidata es más corta que la de referencia.

El puntaje BLEU varía entre 0 y 1; valores más altos indican traducciones más cercanas a la referencia.

2. Ejemplo de Implementación en Python 3.13 #

Implementación de BLEU usando solo la biblioteca estándar de Python.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
from __future__ import annotations

import math
from collections import Counter
from collections.abc import Iterable, Sequence

def ngram_counts(tokens: Sequence[str], n: int) -> Counter[tuple[str, ...]]:
    """Cuenta la frecuencia de n-gramas en una secuencia de tokens."""
    return Counter(tuple(tokens[i : i + n]) for i in range(len(tokens) - n + 1))

def modified_precision(
    candidate: Sequence[str],
    references: Iterable[Sequence[str]],
    n: int,
) -> tuple[int, int]:
    """Devuelve el número de n-gramas coincidentes y el total de n-gramas en el candidato."""
    cand_counts = ngram_counts(candidate, n)
    max_ref: Counter[tuple[str, ...]] = Counter()
    for ref in references:
        max_ref |= ngram_counts(ref, n)
    overlap = {ng: min(count, max_ref[ng]) for ng, count in cand_counts.items()}
    return sum(overlap.values()), max(1, sum(cand_counts.values()))

def brevity_penalty(candidate_len: int, reference_lens: Iterable[int]) -> float:
    """Calcula la penalización de brevedad si la oración candidata es demasiado corta."""
    if candidate_len == 0:
        return 0.0
    closest_ref_len = min(reference_lens, key=lambda r: (abs(r - candidate_len), r))
    ratio = candidate_len / closest_ref_len
    if ratio > 1:
        return 1.0
    return math.exp(1 - 1 / ratio)

def bleu(candidate: str, references: Sequence[str], max_n: int = 4) -> float:
    """Calcula la puntuación BLEU entre la oración candidata y las referencias."""
    candidate_tokens = candidate.split()
    reference_tokens = [ref.split() for ref in references]
    precisions: list[float] = []
    for n_value in range(1, max_n + 1):
        overlap, total = modified_precision(candidate_tokens, reference_tokens, n_value)
        precisions.append(overlap / total)
    if min(precisions) == 0:
        return 0.0
    geometric_mean = math.exp(sum(math.log(p) for p in precisions) / max_n)
    penalty = brevity_penalty(len(candidate_tokens), (len(ref) for ref in reference_tokens))
    return penalty * geometric_mean

if __name__ == "__main__":
    candidate_sentence = "the cat is on the mat"
    reference_sentences = [
        "there is a cat on the mat",
        "the cat sits on the mat",
    ]
    score = bleu(candidate_sentence, reference_sentences)
    print(f"BLEU = {score:.3f}")

Ejemplo de salida:

BLEU = 0.638

3. Ventajas #

Fácil de implementar y rápido de calcular; se ha usado ampliamente en la evaluación de traducción automática.
El uso de múltiples referencias mejora la tolerancia a las paráfrasis.

4. Limitaciones #

Sensible al orden de palabras y sinónimos, por lo que una traducción correcta puede recibir una puntuación baja.
Su correlación con la evaluación humana disminuye en textos largos.
En idiomas como el japonés, se recomienda tokenizar o segmentar las palabras antes del cálculo.

Resumen #

BLEU evalúa la calidad de la traducción según la coincidencia de n-gramas y la penalización por brevedad.
Puede implementarse fácilmente en Python 3.13 con anotaciones de tipo para mejorar su reutilización.
Se recomienda combinarlo con métricas como ROUGE o METEOR para evaluar también la diversidad léxica y la similitud semántica.