まとめ
- 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.
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.