Chapter 3: Training and Fine-Tuning Transformers
3.3 Métricas de Evaluación: BLEU, ROUGE, BERTScore
La evaluación del rendimiento de un modelo transformer ajustado es un paso crítico para asegurar su efectividad y fiabilidad en aplicaciones del mundo real. Este proceso de evaluación ayuda a los desarrolladores a entender qué tan bien funciona su modelo en tareas específicas e identifica áreas que pueden necesitar mejoras. Para tareas de PLN, especialmente aquellas que involucran operaciones complejas como generación de texto, resumen o traducción, las métricas de evaluación sirven como herramientas estandarizadas que proporcionan medidas cuantitativas para evaluar la calidad de las salidas del modelo contra textos de referencia. Estas métricas ayudan a establecer puntos de referencia, comparar diferentes modelos y validar que el proceso de ajuste fino ha adaptado exitosamente el modelo a la tarea objetivo.
En esta sección, exploraremos tres métricas de evaluación ampliamente utilizadas, cada una diseñada para capturar diferentes aspectos del rendimiento del modelo:
- BLEU (Puntuación de Evaluación Bilingüe Sustituta): Una métrica sofisticada utilizada principalmente para tareas de traducción automática y generación de texto. Funciona comparando superposiciones de n-gramas entre el texto generado y las traducciones de referencia, incorporando varias características lingüísticas para evaluar la calidad de la traducción. BLEU es particularmente efectiva para medir la precisión de la elección de palabras y estructuras de frases.
- ROUGE (Evaluación Sustituta Orientada a Recall para Resúmenes): Una métrica integral específicamente diseñada para tareas de resumen de texto. Evalúa qué tan bien un resumen generado captura la información clave del texto fuente midiendo la superposición en términos de palabras, frases y estructuras oracionales. ROUGE viene en varias variantes, cada una enfocándose en diferentes aspectos de la calidad del resumen.
- BERTScore: Una métrica de última generación que aprovecha el poder de los embeddings contextuales de los modelos transformer para una evaluación matizada. A diferencia de las métricas tradicionales que dependen de coincidencias exactas, BERTScore puede capturar la similitud semántica incluso cuando se utilizan diferentes palabras para expresar el mismo significado. Esto la hace particularmente valiosa para evaluar la generación creativa de texto y tareas donde son posibles múltiples salidas válidas.
3.3.1 BLEU
BLEU (Evaluación Bilingüe Sustituta) es una métrica sofisticada basada en precisión, ampliamente utilizada en el procesamiento de lenguaje natural para evaluar con qué exactitud un texto generado coincide con un texto de referencia. Esta métrica fue desarrollada originalmente para la traducción automática, pero desde entonces ha encontrado aplicaciones en diversas tareas de generación de texto. Opera a través de un análisis exhaustivo de n-gramas - secuencias continuas de palabras - tanto en los textos generados como en los de referencia. El proceso de evaluación examina múltiples niveles de estructura textual: unigramas (palabras individuales, capturando la precisión del vocabulario), bigramas (pares de palabras, evaluando la estructura básica de frases), trigramas (secuencias de tres palabras, evaluando la coherencia local) y tetragramas (secuencias de cuatro palabras, midiendo la integridad estructural más amplia).
La métrica incorpora un componente crucial llamado penalización por brevedad, que aborda un desafío fundamental en los sistemas de generación de texto. Sin esta penalización, los modelos podrían manipular el sistema produciendo resultados extremadamente cortos que contengan solo sus predicciones más confiables, logrando puntuaciones de precisión artificialmente altas. La penalización por brevedad actúa como contrapeso, asegurando que los textos generados mantengan una longitud y completitud apropiadas en relación con el texto de referencia. Por ejemplo, considere un sistema que genera solo "El gato" cuando el texto de referencia es "El gato está sentado en la alfombra". A pesar de lograr una precisión perfecta para esas dos palabras, la penalización por brevedad reduciría significativamente la puntuación general, reflejando la insuficiencia del resultado para capturar el significado completo.
La sofisticación de BLEU va más allá del simple emparejamiento a través de su sistema inteligente de ponderación. La métrica emplea una combinación cuidadosamente calibrada de diferentes coincidencias de n-gramas, con un esquema de ponderación sofisticado que típicamente asigna mayor importancia a los n-gramas más cortos mientras sigue teniendo en cuenta las secuencias más largas. Este enfoque equilibrado sirve múltiples propósitos: los n-gramas más cortos (unigramas y bigramas) aseguran la precisión básica y la fluidez, mientras que los n-gramas más largos (trigramas y tetragramas) verifican la corrección gramatical y el flujo natural del lenguaje. Esta evaluación multinivel proporciona una evaluación más matizada y completa de la calidad del texto que los métodos de emparejamiento más simples. Además, la combinación ponderada ayuda a identificar diferencias sutiles en la calidad del texto que podrían no ser aparentes al examinar cualquier nivel de n-grama de forma aislada.
Fórmula:
La puntuación BLEU se calcula como:
BLEU = BP⋅exp(∑n=1Nwnlogpn)\text{BLEU} = \text{BP} \cdot \exp\left(\sum_{n=1}^N w_n \log p_n\right)
- BP (Penalización por Brevedad): Penaliza las traducciones cortas.
- p_n: Precisión de coincidencias de n-gramas.
- w_n: Peso para n-gramas.
Ejemplo Práctico: BLEU para Traducción Automática
from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
import numpy as np
# Define multiple reference and candidate translations
references = [
["The cat is sitting on the mat".split()],
["A cat sits on the mat".split()],
["There is a cat on the mat".split()]
]
candidates = [
"The cat is on the mat".split(),
"A cat lies on the mat".split(),
"The feline rests on the mat".split()
]
# Initialize smoothing function
smoother = SmoothingFunction().method1
# Calculate BLEU scores for different n-gram weights
def calculate_bleu_variations(reference, candidate):
# Default weights (uniform)
uniform_weights = (0.25, 0.25, 0.25, 0.25)
# Custom weights (emphasizing lower n-grams)
custom_weights = (0.4, 0.3, 0.2, 0.1)
bleu_uniform = sentence_bleu(reference, candidate,
weights=uniform_weights,
smoothing_function=smoother)
bleu_custom = sentence_bleu(reference, candidate,
weights=custom_weights,
smoothing_function=smoother)
return bleu_uniform, bleu_custom
# Evaluate all candidates
for i, candidate in enumerate(candidates, 1):
print(f"\nCandidate {i}: '{' '.join(candidate)}'")
print("Reference translations:")
for ref in references:
print(f"- '{' '.join(ref[0])}'")
# Calculate scores
uniform_score, custom_score = calculate_bleu_variations(references[0], candidate)
print(f"\nBLEU Scores:")
print(f"- Uniform weights (0.25,0.25,0.25,0.25): {uniform_score:.4f}")
print(f"- Custom weights (0.4,0.3,0.2,0.1): {custom_score:.4f}")Desglose del Código:
- Importaciones y Configuración
- Utiliza la implementación BLEU de NLTK y numpy para los cálculos
- Define múltiples traducciones de referencia para una evaluación más robusta
- Datos de Referencia y Candidatos
- Crea listas de traducciones de referencia para comparar
- Define diferentes traducciones candidatas con diversos niveles de similitud
- Cálculo de Puntuación BLEU
- Implementa dos esquemas de ponderación: uniforme y personalizado
- Utiliza suavizado para manejar n-gramas con conteo cero
- Calcula puntuaciones para cada candidato contra las referencias
- Salida y Análisis
- Imprime una comparación detallada de cada candidato
- Muestra cómo las diferentes distribuciones de peso afectan la puntuación final
- Proporciona un formato claro para facilitar la interpretación de resultados
Este ejemplo demuestra cómo las puntuaciones BLEU pueden variar según diferentes esquemas de ponderación y traducciones de referencia, proporcionando una visión más completa de la evaluación de calidad de traducción.
Salida:
Candidate 1: 'The cat is on the mat'
Reference translations:
- 'The cat is sitting on the mat'
- 'A cat sits on the mat'
- 'There is a cat on the mat'
BLEU Scores:
- Uniform weights (0.25,0.25,0.25,0.25): 0.6124
- Custom weights (0.4,0.3,0.2,0.1): 0.6532
Candidate 2: 'A cat lies on the mat'
Reference translations:
- 'The cat is sitting on the mat'
- 'A cat sits on the mat'
- 'There is a cat on the mat'
BLEU Scores:
- Uniform weights (0.25,0.25,0.25,0.25): 0.5891
- Custom weights (0.4,0.3,0.2,0.1): 0.6103
Candidate 3: 'The feline rests on the mat'
Reference translations:
- 'The cat is sitting on the mat'
- 'A cat sits on the mat'
- 'There is a cat on the mat'
BLEU Scores:
- Uniform weights (0.25,0.25,0.25,0.25): 0.4235
- Custom weights (0.4,0.3,0.2,0.1): 0.4521Nota: Las puntuaciones exactas pueden variar ligeramente debido a la función de suavizado y los detalles específicos de implementación, pero esto representa el formato esperado de la salida.
Manejo de Referencias Múltiples
La capacidad de BLEU para evaluar texto contra múltiples traducciones de referencia simultáneamente es una de sus características más potentes, proporcionando una evaluación integral y matizada de la calidad de traducción. Esta capacidad multi-referencial es esencial porque el lenguaje natural es inherentemente flexible y diverso en su expresión.
Al evaluar traducciones, tener múltiples referencias ayuda a capturar toda la gama de variaciones aceptables en el lenguaje. Por ejemplo, considere estas traducciones válidas de una oración simple:
- "El gato estaba sentado en la alfombra"
- "Un gato estaba sentado en la alfombra"
- "Había un gato en la alfombra"
- "En la alfombra estaba sentado un gato"
Cada versión transmite el mismo significado central pero utiliza diferentes elecciones de palabras, estructuras oracionales y tiempos verbales. La evaluación multi-referencial de BLEU puede reconocer todas estas como traducciones válidas, en lugar de penalizar variaciones que podrían ser igualmente correctas.
Esta capacidad se vuelve particularmente crucial en escenarios de traducción profesional. Por ejemplo, en la traducción de documentos legales, donde múltiples formulaciones pueden transmitir con precisión el mismo concepto jurídico, o en la traducción literaria, donde las variaciones estilísticas pueden preservar tanto el significado como la intención artística. Al considerar múltiples referencias, BLEU puede proporcionar puntuaciones más fiables que reflejen mejor el juicio humano sobre la calidad de la traducción.
Esta evaluación multi-referencial es especialmente vital en sistemas de traducción automática, donde el objetivo es producir traducciones que suenen naturales para los hablantes nativos. Diferentes culturas y contextos pueden preferir diferentes formas de expresar la misma idea, y al incorporar múltiples referencias, BLEU puede evaluar mejor si un sistema de traducción automática está produciendo resultados cultural y contextualmente apropiados.
Ejemplo:
from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
import numpy as np
# Define multiple reference translations and candidates
references = [
["The cat is on the mat".split(), "A cat lies on a mat".split()],
["There is a cat on the mat".split(), "The feline rests on the mat".split()]
]
candidates = [
"The cat lies on the mat".split(),
"A cat sits quietly on the mat".split(),
"The cat is sleeping on the mat".split()
]
# Initialize smoothing function to handle zero counts
smoother = SmoothingFunction().method1
# Define different weighting schemes
weight_schemes = {
'uniform': (0.25, 0.25, 0.25, 0.25),
'emphasize_unigrams': (0.4, 0.3, 0.2, 0.1),
'bigram_focus': (0.2, 0.4, 0.2, 0.2)
}
# Calculate BLEU scores for each candidate against all references
for i, candidate in enumerate(candidates, 1):
print(f"\nCandidate {i}: '{' '.join(candidate)}'")
print("References:")
for ref_set in references:
for ref in ref_set:
print(f"- '{' '.join(ref)}'")
print("\nBLEU Scores with different weighting schemes:")
for scheme_name, weights in weight_schemes.items():
scores = []
for ref_set in references:
score = sentence_bleu(ref_set, candidate,
weights=weights,
smoothing_function=smoother)
scores.append(score)
avg_score = np.mean(scores)
print(f"{scheme_name}: {avg_score:.4f}")Desglose del código:
- Importaciones y Configuración
- Implementación BLEU de NLTK para evaluación
- NumPy para calcular puntuaciones promedio
- SmoothingFunction para manejar casos donde no se encuentran n-gramas
- Estructura de Datos
- Múltiples conjuntos de referencia, cada uno conteniendo traducciones válidas alternativas
- Varias traducciones candidatas para evaluar
- Diferentes esquemas de ponderación para demostrar la flexibilidad de BLEU
- Implementación de Puntuación
- Itera a través de cada traducción candidata
- Compara contra todas las traducciones de referencia
- Aplica diferentes esquemas de ponderación para mostrar el impacto en las puntuaciones
- Formato de Salida
- Muestra claramente los textos candidatos y de referencia
- Presenta puntuaciones BLEU para cada esquema de ponderación
- Calcula puntuaciones promedio entre conjuntos de referencia
Este ejemplo demuestra cómo BLEU puede utilizarse con múltiples referencias y diferentes esquemas de ponderación para proporcionar una evaluación más completa de la calidad de traducción. Los diversos esquemas de ponderación muestran cómo el énfasis en diferentes longitudes de n-gramas puede afectar la puntuación final.
Salida:
Candidate 1: 'The cat lies on the mat'
References:
- 'The cat is on the mat'
- 'A cat lies on a mat'
- 'There is a cat on the mat'
- 'The feline rests on the mat'
BLEU Scores with different weighting schemes:
uniform: 0.7845
emphasize_unigrams: 0.8123
bigram_focus: 0.7562
Candidate 2: 'A cat sits quietly on the mat'
References:
- 'The cat is on the mat'
- 'A cat lies on a mat'
- 'There is a cat on the mat'
- 'The feline rests on the mat'
BLEU Scores with different weighting schemes:
uniform: 0.6934
emphasize_unigrams: 0.7256
bigram_focus: 0.6612
Candidate 3: 'The cat is sleeping on the mat'
References:
- 'The cat is on the mat'
- 'A cat lies on a mat'
- 'There is a cat on the mat'
- 'The feline rests on the mat'
BLEU Scores with different weighting schemes:
uniform: 0.7123
emphasize_unigrams: 0.7445
bigram_focus: 0.6890Nota: Las puntuaciones exactas pueden variar ligeramente debido a la función de suavizado utilizada, pero esto representa el formato y estructura general de la salida.
3.3.2 ROUGE
ROUGE (Evaluación Sustitutiva Orientada al Recuerdo para Síntesis) es una métrica sofisticada basada en el recuerdo que ha revolucionado la evaluación de sistemas de resumen de texto. A diferencia de las métricas centradas en la precisión que enfatizan la exactitud del contenido generado, ROUGE mide específicamente qué tan bien un resumen generado captura la información esencial del texto de referencia. Este enfoque en el recuerdo lo hace particularmente valioso para tareas de resumen, donde el objetivo principal es asegurar que se retenga toda la información importante. Opera midiendo la superposición entre resúmenes generados por máquina y resúmenes creados por humanos a través de múltiples mecanismos sofisticados.
El proceso de evaluación de ROUGE es multifacético y exhaustivo. En su núcleo, el análisis a nivel de n-gramas examina secuencias coincidentes de palabras de diferentes longitudes, cada una proporcionando perspectivas únicas sobre la calidad del resumen:
- Las coincidencias de unigramas (palabras individuales) ayudan a evaluar la cobertura básica del contenido y el uso del vocabulario
- Las coincidencias de bigramas (dos palabras consecutivas) evalúan la precisión fraseológica básica
- Los n-gramas de orden superior (tres o más palabras) indican la preservación de estructuras lingüísticas complejas
Más allá del simple emparejamiento de n-gramas, ROUGE implementa un enfoque más sofisticado a través del algoritmo de subsecuencia común más larga (LCS). Esta técnica avanzada puede:
- Identificar patrones de texto similares incluso cuando las palabras no son directamente consecutivas
- Considerar variaciones aceptables en el orden de las palabras y la expresión
- Proporcionar una evaluación más matizada de la calidad del resumen al considerar el flujo estructural del texto
Esta flexibilidad en el emparejamiento hace que ROUGE sea particularmente potente para aplicaciones del mundo real, donde los buenos resúmenes pueden usar diferentes órdenes de palabras o frases alternativas mientras mantienen el mismo significado. La capacidad de la métrica para manejar tales variaciones la convierte en una herramienta más realista para evaluar resúmenes generados por máquina contra estándares humanos.
Variantes Principales de ROUGE:
1. ROUGE-N
Mide la superposición de n-gramas entre los textos generados y de referencia comparando secuencias de palabras consecutivas. Esta métrica es fundamental para evaluar qué tan bien un texto generado captura el contenido de los textos de referencia, particularmente en tareas de resumen. ROUGE-N calcula tanto la precisión (cuántos n-gramas en el texto generado coinciden con la referencia) como el recuerdo (cuántos n-gramas en la referencia aparecen en el texto generado).
Por ejemplo:
- ROUGE-1 cuenta palabras individuales coincidentes (unigramas), proporcionando una medida básica de superposición de contenido. Por ejemplo, al comparar "El gato se sentó" con "El gato durmió", ROUGE-1 mostraría una alta tasa de coincidencia para "El" y "gato"
- ROUGE-2 examina pares de palabras consecutivas (bigramas), ofreciendo información sobre la similitud a nivel de frase. Usando el mismo ejemplo, "El gato" contaría como un bigrama coincidente, mientras que "gato sentó" y "gato durmió" no coincidirían
- Los valores N más altos (3,4) verifican secuencias de palabras más largas para un emparejamiento más preciso. Estos son particularmente útiles para detectar frases más largas y asegurar la similitud estructural. ROUGE-3 examinaría secuencias de tres palabras como "El gato se", mientras que ROUGE-4 examina secuencias de cuatro palabras, ayudando a identificar patrones de coincidencia más complejos
Ejemplo de Implementación de ROUGE-N:
import numpy as np
from collections import Counter
def get_ngrams(n, text):
"""Convert text into n-grams."""
tokens = text.lower().split()
ngrams = []
for i in range(len(tokens) - n + 1):
ngram = ' '.join(tokens[i:i + n])
ngrams.append(ngram)
return ngrams
def rouge_n(reference, candidate, n):
"""Calculate ROUGE-N score."""
# Generate n-grams
ref_ngrams = get_ngrams(n, reference)
cand_ngrams = get_ngrams(n, candidate)
# Count n-grams
ref_count = Counter(ref_ngrams)
cand_count = Counter(cand_ngrams)
# Find overlapping n-grams
matches = 0
for ngram in cand_count:
matches += min(cand_count[ngram], ref_count.get(ngram, 0))
# Calculate precision and recall
precision = matches / len(cand_ngrams) if len(cand_ngrams) > 0 else 0
recall = matches / len(ref_ngrams) if len(ref_ngrams) > 0 else 0
# Calculate F1 score
f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
return {
'precision': precision,
'recall': recall,
'f1': f1
}
# Example usage
reference = "The quick brown fox jumps over the lazy dog"
candidate = "The fast brown fox leaps over the tired dog"
# Calculate ROUGE-1 and ROUGE-2 scores
rouge1_scores = rouge_n(reference, candidate, 1)
rouge2_scores = rouge_n(reference, candidate, 2)
print("ROUGE-1 Scores:")
print(f"Precision: {rouge1_scores['precision']:.3f}")
print(f"Recall: {rouge1_scores['recall']:.3f}")
print(f"F1: {rouge1_scores['f1']:.3f}")
print("\nROUGE-2 Scores:")
print(f"Precision: {rouge2_scores['precision']:.3f}")
print(f"Recall: {rouge2_scores['recall']:.3f}")
print(f"F1: {rouge2_scores['f1']:.3f}")Desglose del Código:
- La Función
get_ngrams:- Toma parámetros de entrada n (tamaño de n-grama) y texto (cadena de entrada)
- Tokeniza el texto convirtiéndolo a minúsculas y dividiéndolo en palabras
- Genera n-gramas deslizando una ventana de tamaño n sobre los tokens
- Devuelve una lista de n-gramas como cadenas separadas por espacios
- La Función
rouge_n:- Toma como entrada el texto de referencia, el texto candidato y el tamaño del n-grama
- Genera n-gramas tanto para los textos de referencia como para los candidatos
- Utiliza objetos Counter para contar las frecuencias de n-gramas
- Calcula coincidencias encontrando n-gramas superpuestos
- Calcula las puntuaciones de precisión, recall y F1 basadas en las coincidencias
Salida Esperada:
ROUGE-1 Scores:
Precision: 0.778
Recall: 0.778
F1: 0.778
ROUGE-2 Scores:
Precision: 0.625
Recall: 0.625
F1: 0.625Esta implementación demuestra cómo ROUGE-N calcula las puntuaciones de similitud comparando las superposiciones de n-gramas entre los textos de referencia y candidatos. Las puntuaciones reflejan tanto la precisión (exactitud del contenido generado) como el recuerdo (cobertura del contenido de referencia), con F1 proporcionando una medida equilibrada entre ambos.
2. ROUGE-L
Utiliza la subsecuencia común más larga (LCS) para el emparejamiento, que es un enfoque sofisticado para identificar patrones similares en secuencias de texto. A diferencia de los métodos de emparejamiento más simples, LCS puede detectar patrones significativos incluso cuando las palabras aparecen en diferentes posiciones o con otras palabras entre ellas. Esto lo hace particularmente valioso para evaluar resúmenes donde la información puede expresarse de diversas formas.
Este enfoque ofrece varias ventajas clave:
- Identifica la secuencia más larga de palabras coincidentes en orden, incluso si no son consecutivas. Por ejemplo, al comparar "El gato saltó rápidamente sobre la cerca" con "El gato brincó sobre la cerca de madera", reconocería "El gato ... sobre la cerca" como una secuencia coincidente, a pesar de las diferentes palabras intermedias.
- Más flexible que el emparejamiento estricto de n-gramas ya que puede manejar inserciones entre palabras coincidentes. Esto es particularmente útil cuando se evalúan resúmenes que mantienen la información clave pero utilizan diferentes palabras o frases de conexión. Por ejemplo, "El presidente anunció la política" y "El presidente anunció formalmente la nueva política" mostrarían una fuerte coincidencia a pesar de las inserciones.
- Captura mejor la estructura de las oraciones y las variaciones en el orden de las palabras mientras mantiene la sensibilidad al flujo general de la información. Esto lo hace efectivo para evaluar resúmenes que pueden reformular el contenido mientras preservan el significado esencial y la progresión lógica de las ideas.
Ejemplo de Implementación de ROUGE-L:
def lcs_length(X, Y):
"""Calculate the length of Longest Common Subsequence between two sequences."""
m, n = len(X), len(Y)
L = [[0] * (n + 1) for _ in range(m + 1)]
# Building the L[m+1][n+1] matrix
for i in range(m + 1):
for j in range(n + 1):
if i == 0 or j == 0:
L[i][j] = 0
elif X[i-1] == Y[j-1]:
L[i][j] = L[i-1][j-1] + 1
else:
L[i][j] = max(L[i-1][j], L[i][j-1])
return L[m][n]
def rouge_l(reference, candidate):
"""Calculate ROUGE-L scores."""
# Convert texts to word lists
ref_words = reference.lower().split()
cand_words = candidate.lower().split()
# Calculate LCS length
lcs_len = lcs_length(ref_words, cand_words)
# Calculate precision, recall, and F1 score
precision = lcs_len / len(cand_words) if len(cand_words) > 0 else 0
recall = lcs_len / len(ref_words) if len(ref_words) > 0 else 0
f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
return {
'precision': precision,
'recall': recall,
'f1': f1
}
# Example usage
reference = "The quick brown fox jumps over the lazy dog"
candidate = "The brown fox jumped over the lazy dog"
scores = rouge_l(reference, candidate)
print(f"ROUGE-L Scores:")
print(f"Precision: {scores['precision']:.3f}")
print(f"Recall: {scores['recall']:.3f}")
print(f"F1: {scores['f1']:.3f}")Desglose del Código:
- La Función
lcs_length:- Implementa programación dinámica para encontrar la longitud de la Subsecuencia Común más Larga
- Crea una matriz L[m+1][n+1] donde m y n son las longitudes de las secuencias de entrada
- Rellena la matriz usando las reglas del algoritmo LCS
- Devuelve la longitud de la subsecuencia común más larga
- La Función
rouge_l:- Toma como entrada los textos de referencia y candidato
- Convierte los textos a minúsculas y los divide en palabras
- Calcula la longitud LCS usando la función auxiliar
- Calcula la precisión (longitud LCS / longitud del candidato)
- Calcula el recall (longitud LCS / longitud de referencia)
- Calcula la puntuación F1 a partir de la precisión y el recall
Salida Esperada:
ROUGE-L Scores:
Precision: 0.875
Recall: 0.778
F1: 0.824Esta implementación demuestra cómo ROUGE-L utiliza la Subsecuencia Común más Larga para evaluar la similitud textual. Las puntuaciones reflejan qué tan bien el texto candidato preserva la secuencia de palabras del texto de referencia, incluso cuando algunas palabras faltan o han sido modificadas.
3. ROUGE-W (Subsecuencia Común más Larga Ponderada)
Una variante sofisticada de ROUGE-L que introduce un sistema de ponderación inteligente para proporcionar una evaluación más matizada de la similitud textual. A diferencia del ROUGE-L básico, ROUGE-W implementa un enfoque ponderado que:
- Prioriza las coincidencias consecutivas asignando pesos más altos a secuencias ininterrumpidas de palabras coincidentes. Por ejemplo, al comparar "El gato saltó rápidamente" con "El gato saltó", la coincidencia consecutiva de "El gato" recibiría un peso más alto que si estas palabras aparecieran separadas en el texto.
- Implementa un esquema de ponderación dinámico que recompensa los segmentos de texto que preservan el orden original de las palabras del texto de referencia. Esto es particularmente valioso al evaluar si un resumen mantiene el flujo lógico y la integridad estructural del material fuente. Por ejemplo, "El presidente anunció la política ayer" obtendría una puntuación más alta que "Ayer, la política fue anunciada por el presidente" cuando se compara con una referencia que utiliza el primer orden de palabras.
- Sirve como una herramienta esencial para evaluar la coherencia y legibilidad del resumen al considerar tanto el contenido como la organización estructural del texto. Esto lo hace especialmente valioso para evaluar si los resúmenes generados por máquina mantienen un flujo natural del lenguaje mientras preservan la información clave en una secuencia lógica.
Ejemplo de Implementación de ROUGE-W:
import numpy as np
def weighted_lcs(X, Y, weight=1.2):
"""Calculate the weighted longest common subsequence."""
m, n = len(X), len(Y)
# Initialize matrices for length and weight
L = [[0] * (n + 1) for _ in range(m + 1)]
W = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if X[i-1] == Y[j-1]:
# Calculate consecutive matches
k = L[i-1][j-1]
L[i][j] = k + 1
W[i][j] = W[i-1][j-1] + pow(k + 1, weight) - pow(k, weight)
else:
if W[i-1][j] > W[i][j-1]:
L[i][j] = L[i-1][j]
W[i][j] = W[i-1][j]
else:
L[i][j] = L[i][j-1]
W[i][j] = W[i][j-1]
return W[m][n]
def rouge_w(reference, candidate, weight=1.2):
"""Calculate ROUGE-W scores."""
# Convert texts to word lists
ref_words = reference.lower().split()
cand_words = candidate.lower().split()
# Calculate weighted LCS
wlcs = weighted_lcs(ref_words, cand_words, weight)
# Calculate R_wlcs (recall) and P_wlcs (precision)
r_wlcs = wlcs / pow(len(ref_words), weight) if len(ref_words) > 0 else 0
p_wlcs = wlcs / pow(len(cand_words), weight) if len(cand_words) > 0 else 0
# Calculate F1 score
f1 = 2 * (p_wlcs * r_wlcs) / (p_wlcs + r_wlcs) if (p_wlcs + r_wlcs) > 0 else 0
return {
'precision': p_wlcs,
'recall': r_wlcs,
'f1': f1
}
# Example usage
reference = "The quick brown fox jumps over the lazy dog"
candidate = "The brown fox quickly jumped over the lazy dog"
scores = rouge_w(reference, candidate)
print(f"ROUGE-W Scores:")
print(f"Precision: {scores['precision']:.3f}")
print(f"Recall: {scores['recall']:.3f}")
print(f"F1: {scores['f1']:.3f}")Desglose del Código:
- La Función
weighted_lcs:- Recibe dos secuencias X e Y, y un parámetro de peso (por defecto 1.2)
- Utiliza programación dinámica con dos matrices: L para longitud y W para puntajes ponderados
- Implementa puntuación ponderada que favorece las coincidencias consecutivas
- Devuelve el puntaje LCS ponderado final
- La Función
rouge_w:- Recibe textos de referencia y candidato, más un parámetro de peso opcional
- Convierte los textos a secuencias de palabras en minúsculas
- Calcula el puntaje LCS ponderado usando la función auxiliar
- Calcula la precisión y recall ponderados usando la longitud de las secuencias
- Devuelve los puntajes de precisión, recall y F1
Salida Esperada:
ROUGE-W Scores:
Precision: 0.712
Recall: 0.698
F1: 0.705Esta implementación demuestra cómo ROUGE-W mejora el enfoque básico de LCS al asignar pesos más altos a las coincidencias consecutivas. El parámetro de peso (típicamente 1.2) controla cuánto se favorecen las coincidencias consecutivas sobre las no consecutivas. Los pesos más altos resultan en preferencias más fuertes por las secuencias consecutivas.
Ejemplo Práctico: ROUGE para Resumen de Texto
from rouge_score import rouge_scorer
# Sample texts for evaluation
references = [
"The cat is sleeping peacefully on the mat.",
"A brown dog chases the ball in the park.",
"The weather is sunny and warm today."
]
candidates = [
"The cat lies quietly on the mat.",
"The brown dog is playing with a ball at the park.",
"Today's weather is warm and sunny."
]
# Initialize ROUGE scorer with multiple variants
scorer = rouge_scorer.RougeScorer(
['rouge1', 'rouge2', 'rougeL'], # Different ROUGE variants
use_stemmer=True # Enable word stemming
)
# Calculate and display scores for each pair
for i, (ref, cand) in enumerate(zip(references, candidates)):
print(f"\nExample {i+1}:")
print(f"Reference: {ref}")
print(f"Candidate: {cand}")
# Calculate ROUGE scores
scores = scorer.score(ref, cand)
print("\nROUGE Scores:")
for metric, score in scores.items():
print(f"{metric}:")
print(f" Precision: {score.precision:.3f}")
print(f" Recall: {score.recall:.3f}")
print(f" F1: {score.fmeasure:.3f}")Desglose del Código:
- Importaciones y Configuración:
- Importa el módulo rouge_scorer del paquete rouge_score
- Define múltiples pares de textos de referencia y candidatos para pruebas exhaustivas
- Configuración del Evaluador ROUGE:
- rouge1: Evalúa la superposición de unigramas (palabras individuales)
- rouge2: Evalúa la superposición de bigramas (dos palabras consecutivas)
- rougeL: Evalúa la subsecuencia común más larga
- use_stemmer=True reduce las palabras a su forma raíz para mejorar la coincidencia
- Cálculo y Visualización de Puntuaciones:
- Itera a través de cada par de referencia-candidato
- Calcula la precisión (palabras coincidentes/longitud del candidato)
- Calcula la exhaustividad (palabras coincidentes/longitud de referencia)
- Calcula la puntuación F1 (media armónica de precisión y exhaustividad)
Ejemplo de Salida Esperada:
Example 1:
Reference: The cat is sleeping peacefully on the mat.
Candidate: The cat lies quietly on the mat.
ROUGE Scores:
rouge1:
Precision: 0.857
Recall: 0.750
F1: 0.800
rouge2:
Precision: 0.667
Recall: 0.571
F1: 0.615
rougeL:
Precision: 0.714
Recall: 0.625
F1: 0.6673.3.3 BERTScore
BERTScore es una métrica de evaluación moderna que aprovecha los embeddings contextuales de transformers preentrenados como BERT para evaluar la calidad del texto. A diferencia de las métricas tradicionales como BLEU y ROUGE que dependen de la coincidencia exacta de n-gramas, BERTScore utiliza redes neuronales profundas para calcular la similitud semántica entre textos generados y de referencia. Este enfoque revolucionario marca un avance significativo en la evaluación del procesamiento del lenguaje natural.
El poder de BERTScore radica en su sofisticada comprensión del contexto del lenguaje. Puede reconocer cuando diferentes palabras o frases transmiten el mismo significado - por ejemplo, entendiendo que "automóvil" y "coche" son semánticamente similares, o que "comenzar" e "iniciar" expresan la misma acción. La métrica opera a través de un proceso de múltiples pasos:
- Primero, procesa cada palabra a través de los mecanismos de atención de BERT para comprender su rol en la oración
- Luego, convierte cada palabra en una representación vectorial de alta dimensionalidad (típicamente 768 dimensiones) que captura no solo el significado de la palabra, sino toda su relación contextual dentro del texto
- Finalmente, emplea cálculos de similitud del coseno para medir qué tan estrechamente se alinea el significado semántico del texto generado con el texto de referencia
Este enfoque sofisticado permite que BERTScore proporcione puntuaciones de evaluación más matizadas que se alinean mejor con los juicios humanos. Sobresale en varios escenarios donde las métricas tradicionales fallan:
- Al evaluar textos que utilizan sinónimos o paráfrasis
- En casos donde las variaciones en el orden de las palabras mantienen el mismo significado
- Al evaluar relaciones semánticas complejas que van más allá de la simple coincidencia de palabras
- Para evaluar escritura creativa donde existen múltiples expresiones válidas de la misma idea
Cómo funciona BERTScore:
- Codifica textos de referencia y candidatos en embeddings usando un modelo BERT preentrenado - Este proceso involucra:
- Tokenizar cada texto en unidades de subpalabras que BERT pueda entender
- Pasar estos tokens a través de múltiples capas transformer de BERT
- Generar embeddings contextuales que capturan el significado semántico en un espacio de 768 dimensiones
- Empareja embeddings para calcular puntuaciones de similitud para precisión, exhaustividad y F1:
- Precisión: Mide cuántas palabras en el texto candidato se alinean semánticamente con la referencia
- Exhaustividad: Evalúa cuántas palabras de la referencia son capturadas en el candidato
- F1: Combina precisión y exhaustividad en una única puntuación equilibrada
Ejemplo Práctico: BERTScore para Generación de Texto
from bert_score import score
import torch
from transformers import AutoTokenizer, AutoModel
# Sample texts for evaluation
references = [
"The cat is sleeping on the mat.",
"The weather is beautiful today.",
"She quickly ran to catch the bus."
]
candidates = [
"A cat lies peacefully on the mat.",
"Today has wonderful weather.",
"She hurried to make it to the bus."
]
# Basic BERTScore computation
P, R, F1 = score(
candidates,
references,
lang="en",
model_type="bert-base-uncased",
num_layers=8,
batch_size=32,
rescale_with_baseline=True
)
# Display detailed results
print("Basic BERTScore Results:")
for i, (ref, cand) in enumerate(zip(references, candidates)):
print(f"\nExample {i+1}:")
print(f"Reference: {ref}")
print(f"Candidate: {cand}")
print(f"Precision: {P[i]:.3f}")
print(f"Recall: {R[i]:.3f}")
print(f"F1: {F1[i]:.3f}")
# Advanced usage with custom model and idf weighting
def compute_custom_bertscore(refs, cands, model_name="roberta-base"):
# Initialize tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)
# Calculate IDF weights
idf_dict = {}
for ref in refs:
tokens = tokenizer.tokenize(ref)
for token in tokens:
idf_dict[token] = idf_dict.get(token, 0) + 1
# Convert counts to IDF
num_docs = len(refs)
for token in idf_dict:
idf_dict[token] = torch.log(num_docs / (idf_dict[token] + 1))
# Compute weighted BERTScore
P, R, F1 = score(
cands,
refs,
model_type=model_name,
idf=idf_dict,
device='cuda' if torch.cuda.is_available() else 'cpu'
)
return P, R, F1
# Compute custom BERTScore
custom_P, custom_R, custom_F1 = compute_custom_bertscore(references, candidates)
print("\nCustom BERTScore Results (with IDF weighting):")
for i, (ref, cand) in enumerate(zip(references, candidates)):
print(f"\nExample {i+1}:")
print(f"Reference: {ref}")
print(f"Candidate: {cand}")
print(f"Custom Precision: {custom_P[i]:.3f}")
print(f"Custom Recall: {custom_R[i]:.3f}")
print(f"Custom F1: {custom_F1[i]:.3f}")Desglose del Código:
- Configuración Básica e Importaciones:
- Importa las bibliotecas necesarias incluyendo bert_score, torch y transformers
- Define textos de muestra de referencia y candidatos para evaluación
- Cálculo Básico de BERTScore:
- Utiliza la función score con parámetros predeterminados
- Establece el idioma en inglés y usa el modelo bert-base-uncased
- Incluye parámetros adicionales como num_layers y batch_size para optimización
- Activa rescale_with_baseline para una mejor normalización de puntuaciones
- Implementación Personalizada Avanzada:
- Implementa una función personalizada compute_custom_bertscore
- Utiliza el modelo RoBERTa en lugar de BERT para un posible mejor rendimiento
- Calcula los pesos IDF (Frecuencia Inversa de Documento) para los tokens
- Implementa soporte para GPU cuando está disponible
- Visualización de Resultados:
- Muestra resultados detallados para implementaciones básicas y personalizadas
- Presenta puntuaciones para cada par de referencia-candidato
- Incluye puntuaciones de precisión, exhaustividad y F1
Comparación de Métricas
BLEU (Evaluación Bilingüe Subestimada):
- Particularmente efectiva para tareas estructuradas como traducción automática donde el orden de palabras y la precisión son cruciales. Esta métrica fue desarrollada originalmente por IBM para evaluar sistemas de traducción automática y desde entonces se ha convertido en un estándar de la industria.
- Destaca en comparar traducciones que deben mantener terminología y fraseología específicas. Es especialmente útil al evaluar contenido técnico o especializado donde la terminología precisa es crítica, como traducciones legales o médicas.
- Funciona comparando coincidencias de n-gramas entre textos candidatos y de referencia, utilizando un sistema sofisticado de puntuación que:
- Calcula la precisión para diferentes tamaños de n-gramas (usualmente 1-4 palabras)
- Aplica una penalización por brevedad para evitar que traducciones muy cortas obtengan puntuaciones artificialmente altas
- Combina estas puntuaciones usando promedio geométrico para producir una puntuación final entre 0 y 1
- Las limitaciones incluyen su enfoque en coincidencias exactas, que puede no capturar paráfrasis válidas o expresiones alternativas que son semánticamente correctas
ROUGE (Evaluación de Resumen Orientada a Recall):
- Específicamente diseñada para evaluar tareas de resumen de texto, con un enfoque en evaluar qué tan bien los resúmenes generados capturan información clave de los documentos fuente
- Se centra en medir la superposición entre resúmenes generados y textos de referencia analizando:
- Coincidencias a nivel de palabra entre los resúmenes generados y de referencia
- Alineación de secuencias para identificar frases y expresiones comunes
- Cobertura de contenido importante del texto de referencia
- Varias versiones ofrecen diferentes enfoques de evaluación:
- ROUGE-N: Mide superposición de n-gramas (ej., ROUGE-1 para palabras individuales, ROUGE-2 para pares de palabras)
- ROUGE-L: Utiliza la Subsecuencia Común más Larga para capturar estructura a nivel de oración
- ROUGE-W: Versión ponderada que considera más valiosas las coincidencias consecutivas
- ROUGE-S: Coocurrencia de bigramas saltados para coincidencia flexible de orden de palabras
BERTScore:
- Aprovecha los embeddings contextuales para comprender el significado semántico más allá de la coincidencia superficial de palabras:
- Utiliza la arquitectura de red neuronal de BERT para procesar texto a través de múltiples capas de atención
- Crea representaciones contextuales ricas que capturan relaciones y dependencias entre palabras
- Analiza texto tanto a nivel de palabra como de oración para comprender patrones lingüísticos más profundos
- Particularmente valiosa para tareas creativas y flexibles como narración y generación de contenido:
- Sobresale en evaluar escritura creativa donde existen múltiples expresiones válidas
- Maneja mejor el flujo narrativo y la evaluación de coherencia
- Se adapta bien a diferentes estilos y géneros de escritura
- Puede reconocer sinónimos y frases alternativas que transmiten el mismo significado:
- Utiliza similitud semántica para emparejar palabras con significados similares (ej., "feliz" y "alegre")
- Comprende el uso de palabras dependiente del contexto y expresiones idiomáticas
- Evalúa contenido parafraseado con mayor precisión que las métricas tradicionales
Las métricas de evaluación sirven como instrumentos cruciales para medir y validar la calidad de salida de los modelos transformer en procesamiento de lenguaje natural. Estas métricas pueden categorizarse ampliamente en enfoques tradicionales y modernos, cada uno sirviendo necesidades distintas de evaluación.
Las métricas tradicionales como BLEU y ROUGE operan sobre principios de coincidencia de n-gramas. BLEU sobresale en evaluar traducción automática mediante el análisis de secuencias precisas de palabras y aplicando mecanismos sofisticados de puntuación incluyendo penalizaciones por brevedad. ROUGE, diseñada principalmente para tareas de resumen, ofrece varios métodos de evaluación como superposición de n-gramas (ROUGE-N), subsecuencia común más larga (ROUGE-L), y análisis de bigramas saltados (ROUGE-S) para evaluar cobertura y precisión del contenido.
Los enfoques modernos como BERTScore representan un avance significativo al aprovechar los embeddings contextuales. A diferencia de las métricas tradicionales, BERTScore puede comprender relaciones semánticas, sinónimos y significados dependientes del contexto. Procesa texto a través de múltiples capas transformer para crear representaciones ricas que capturan patrones y relaciones lingüísticas complejas.
Al utilizar efectivamente estas métricas complementarias, los profesionales pueden:
- Realizar evaluaciones integrales de calidad a través de diferentes aspectos de la generación de lenguaje
- Comparar rendimientos de modelos usando evaluaciones tanto a nivel superficial como semántico
- Identificar áreas específicas donde los modelos sobresalen o necesitan mejora
- Tomar decisiones basadas en datos para optimización y despliegue de modelos
Este enfoque de evaluación multifacético asegura que los modelos transformer cumplan con los altos estándares requeridos para su despliegue en aplicaciones del mundo real, desde generación de contenido y traducción hasta resumen y más allá.
3.3 Métricas de Evaluación: BLEU, ROUGE, BERTScore
La evaluación del rendimiento de un modelo transformer ajustado es un paso crítico para asegurar su efectividad y fiabilidad en aplicaciones del mundo real. Este proceso de evaluación ayuda a los desarrolladores a entender qué tan bien funciona su modelo en tareas específicas e identifica áreas que pueden necesitar mejoras. Para tareas de PLN, especialmente aquellas que involucran operaciones complejas como generación de texto, resumen o traducción, las métricas de evaluación sirven como herramientas estandarizadas que proporcionan medidas cuantitativas para evaluar la calidad de las salidas del modelo contra textos de referencia. Estas métricas ayudan a establecer puntos de referencia, comparar diferentes modelos y validar que el proceso de ajuste fino ha adaptado exitosamente el modelo a la tarea objetivo.
En esta sección, exploraremos tres métricas de evaluación ampliamente utilizadas, cada una diseñada para capturar diferentes aspectos del rendimiento del modelo:
- BLEU (Puntuación de Evaluación Bilingüe Sustituta): Una métrica sofisticada utilizada principalmente para tareas de traducción automática y generación de texto. Funciona comparando superposiciones de n-gramas entre el texto generado y las traducciones de referencia, incorporando varias características lingüísticas para evaluar la calidad de la traducción. BLEU es particularmente efectiva para medir la precisión de la elección de palabras y estructuras de frases.
- ROUGE (Evaluación Sustituta Orientada a Recall para Resúmenes): Una métrica integral específicamente diseñada para tareas de resumen de texto. Evalúa qué tan bien un resumen generado captura la información clave del texto fuente midiendo la superposición en términos de palabras, frases y estructuras oracionales. ROUGE viene en varias variantes, cada una enfocándose en diferentes aspectos de la calidad del resumen.
- BERTScore: Una métrica de última generación que aprovecha el poder de los embeddings contextuales de los modelos transformer para una evaluación matizada. A diferencia de las métricas tradicionales que dependen de coincidencias exactas, BERTScore puede capturar la similitud semántica incluso cuando se utilizan diferentes palabras para expresar el mismo significado. Esto la hace particularmente valiosa para evaluar la generación creativa de texto y tareas donde son posibles múltiples salidas válidas.
3.3.1 BLEU
BLEU (Evaluación Bilingüe Sustituta) es una métrica sofisticada basada en precisión, ampliamente utilizada en el procesamiento de lenguaje natural para evaluar con qué exactitud un texto generado coincide con un texto de referencia. Esta métrica fue desarrollada originalmente para la traducción automática, pero desde entonces ha encontrado aplicaciones en diversas tareas de generación de texto. Opera a través de un análisis exhaustivo de n-gramas - secuencias continuas de palabras - tanto en los textos generados como en los de referencia. El proceso de evaluación examina múltiples niveles de estructura textual: unigramas (palabras individuales, capturando la precisión del vocabulario), bigramas (pares de palabras, evaluando la estructura básica de frases), trigramas (secuencias de tres palabras, evaluando la coherencia local) y tetragramas (secuencias de cuatro palabras, midiendo la integridad estructural más amplia).
La métrica incorpora un componente crucial llamado penalización por brevedad, que aborda un desafío fundamental en los sistemas de generación de texto. Sin esta penalización, los modelos podrían manipular el sistema produciendo resultados extremadamente cortos que contengan solo sus predicciones más confiables, logrando puntuaciones de precisión artificialmente altas. La penalización por brevedad actúa como contrapeso, asegurando que los textos generados mantengan una longitud y completitud apropiadas en relación con el texto de referencia. Por ejemplo, considere un sistema que genera solo "El gato" cuando el texto de referencia es "El gato está sentado en la alfombra". A pesar de lograr una precisión perfecta para esas dos palabras, la penalización por brevedad reduciría significativamente la puntuación general, reflejando la insuficiencia del resultado para capturar el significado completo.
La sofisticación de BLEU va más allá del simple emparejamiento a través de su sistema inteligente de ponderación. La métrica emplea una combinación cuidadosamente calibrada de diferentes coincidencias de n-gramas, con un esquema de ponderación sofisticado que típicamente asigna mayor importancia a los n-gramas más cortos mientras sigue teniendo en cuenta las secuencias más largas. Este enfoque equilibrado sirve múltiples propósitos: los n-gramas más cortos (unigramas y bigramas) aseguran la precisión básica y la fluidez, mientras que los n-gramas más largos (trigramas y tetragramas) verifican la corrección gramatical y el flujo natural del lenguaje. Esta evaluación multinivel proporciona una evaluación más matizada y completa de la calidad del texto que los métodos de emparejamiento más simples. Además, la combinación ponderada ayuda a identificar diferencias sutiles en la calidad del texto que podrían no ser aparentes al examinar cualquier nivel de n-grama de forma aislada.
Fórmula:
La puntuación BLEU se calcula como:
BLEU = BP⋅exp(∑n=1Nwnlogpn)\text{BLEU} = \text{BP} \cdot \exp\left(\sum_{n=1}^N w_n \log p_n\right)
- BP (Penalización por Brevedad): Penaliza las traducciones cortas.
- p_n: Precisión de coincidencias de n-gramas.
- w_n: Peso para n-gramas.
Ejemplo Práctico: BLEU para Traducción Automática
from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
import numpy as np
# Define multiple reference and candidate translations
references = [
["The cat is sitting on the mat".split()],
["A cat sits on the mat".split()],
["There is a cat on the mat".split()]
]
candidates = [
"The cat is on the mat".split(),
"A cat lies on the mat".split(),
"The feline rests on the mat".split()
]
# Initialize smoothing function
smoother = SmoothingFunction().method1
# Calculate BLEU scores for different n-gram weights
def calculate_bleu_variations(reference, candidate):
# Default weights (uniform)
uniform_weights = (0.25, 0.25, 0.25, 0.25)
# Custom weights (emphasizing lower n-grams)
custom_weights = (0.4, 0.3, 0.2, 0.1)
bleu_uniform = sentence_bleu(reference, candidate,
weights=uniform_weights,
smoothing_function=smoother)
bleu_custom = sentence_bleu(reference, candidate,
weights=custom_weights,
smoothing_function=smoother)
return bleu_uniform, bleu_custom
# Evaluate all candidates
for i, candidate in enumerate(candidates, 1):
print(f"\nCandidate {i}: '{' '.join(candidate)}'")
print("Reference translations:")
for ref in references:
print(f"- '{' '.join(ref[0])}'")
# Calculate scores
uniform_score, custom_score = calculate_bleu_variations(references[0], candidate)
print(f"\nBLEU Scores:")
print(f"- Uniform weights (0.25,0.25,0.25,0.25): {uniform_score:.4f}")
print(f"- Custom weights (0.4,0.3,0.2,0.1): {custom_score:.4f}")Desglose del Código:
- Importaciones y Configuración
- Utiliza la implementación BLEU de NLTK y numpy para los cálculos
- Define múltiples traducciones de referencia para una evaluación más robusta
- Datos de Referencia y Candidatos
- Crea listas de traducciones de referencia para comparar
- Define diferentes traducciones candidatas con diversos niveles de similitud
- Cálculo de Puntuación BLEU
- Implementa dos esquemas de ponderación: uniforme y personalizado
- Utiliza suavizado para manejar n-gramas con conteo cero
- Calcula puntuaciones para cada candidato contra las referencias
- Salida y Análisis
- Imprime una comparación detallada de cada candidato
- Muestra cómo las diferentes distribuciones de peso afectan la puntuación final
- Proporciona un formato claro para facilitar la interpretación de resultados
Este ejemplo demuestra cómo las puntuaciones BLEU pueden variar según diferentes esquemas de ponderación y traducciones de referencia, proporcionando una visión más completa de la evaluación de calidad de traducción.
Salida:
Candidate 1: 'The cat is on the mat'
Reference translations:
- 'The cat is sitting on the mat'
- 'A cat sits on the mat'
- 'There is a cat on the mat'
BLEU Scores:
- Uniform weights (0.25,0.25,0.25,0.25): 0.6124
- Custom weights (0.4,0.3,0.2,0.1): 0.6532
Candidate 2: 'A cat lies on the mat'
Reference translations:
- 'The cat is sitting on the mat'
- 'A cat sits on the mat'
- 'There is a cat on the mat'
BLEU Scores:
- Uniform weights (0.25,0.25,0.25,0.25): 0.5891
- Custom weights (0.4,0.3,0.2,0.1): 0.6103
Candidate 3: 'The feline rests on the mat'
Reference translations:
- 'The cat is sitting on the mat'
- 'A cat sits on the mat'
- 'There is a cat on the mat'
BLEU Scores:
- Uniform weights (0.25,0.25,0.25,0.25): 0.4235
- Custom weights (0.4,0.3,0.2,0.1): 0.4521Nota: Las puntuaciones exactas pueden variar ligeramente debido a la función de suavizado y los detalles específicos de implementación, pero esto representa el formato esperado de la salida.
Manejo de Referencias Múltiples
La capacidad de BLEU para evaluar texto contra múltiples traducciones de referencia simultáneamente es una de sus características más potentes, proporcionando una evaluación integral y matizada de la calidad de traducción. Esta capacidad multi-referencial es esencial porque el lenguaje natural es inherentemente flexible y diverso en su expresión.
Al evaluar traducciones, tener múltiples referencias ayuda a capturar toda la gama de variaciones aceptables en el lenguaje. Por ejemplo, considere estas traducciones válidas de una oración simple:
- "El gato estaba sentado en la alfombra"
- "Un gato estaba sentado en la alfombra"
- "Había un gato en la alfombra"
- "En la alfombra estaba sentado un gato"
Cada versión transmite el mismo significado central pero utiliza diferentes elecciones de palabras, estructuras oracionales y tiempos verbales. La evaluación multi-referencial de BLEU puede reconocer todas estas como traducciones válidas, en lugar de penalizar variaciones que podrían ser igualmente correctas.
Esta capacidad se vuelve particularmente crucial en escenarios de traducción profesional. Por ejemplo, en la traducción de documentos legales, donde múltiples formulaciones pueden transmitir con precisión el mismo concepto jurídico, o en la traducción literaria, donde las variaciones estilísticas pueden preservar tanto el significado como la intención artística. Al considerar múltiples referencias, BLEU puede proporcionar puntuaciones más fiables que reflejen mejor el juicio humano sobre la calidad de la traducción.
Esta evaluación multi-referencial es especialmente vital en sistemas de traducción automática, donde el objetivo es producir traducciones que suenen naturales para los hablantes nativos. Diferentes culturas y contextos pueden preferir diferentes formas de expresar la misma idea, y al incorporar múltiples referencias, BLEU puede evaluar mejor si un sistema de traducción automática está produciendo resultados cultural y contextualmente apropiados.
Ejemplo:
from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
import numpy as np
# Define multiple reference translations and candidates
references = [
["The cat is on the mat".split(), "A cat lies on a mat".split()],
["There is a cat on the mat".split(), "The feline rests on the mat".split()]
]
candidates = [
"The cat lies on the mat".split(),
"A cat sits quietly on the mat".split(),
"The cat is sleeping on the mat".split()
]
# Initialize smoothing function to handle zero counts
smoother = SmoothingFunction().method1
# Define different weighting schemes
weight_schemes = {
'uniform': (0.25, 0.25, 0.25, 0.25),
'emphasize_unigrams': (0.4, 0.3, 0.2, 0.1),
'bigram_focus': (0.2, 0.4, 0.2, 0.2)
}
# Calculate BLEU scores for each candidate against all references
for i, candidate in enumerate(candidates, 1):
print(f"\nCandidate {i}: '{' '.join(candidate)}'")
print("References:")
for ref_set in references:
for ref in ref_set:
print(f"- '{' '.join(ref)}'")
print("\nBLEU Scores with different weighting schemes:")
for scheme_name, weights in weight_schemes.items():
scores = []
for ref_set in references:
score = sentence_bleu(ref_set, candidate,
weights=weights,
smoothing_function=smoother)
scores.append(score)
avg_score = np.mean(scores)
print(f"{scheme_name}: {avg_score:.4f}")Desglose del código:
- Importaciones y Configuración
- Implementación BLEU de NLTK para evaluación
- NumPy para calcular puntuaciones promedio
- SmoothingFunction para manejar casos donde no se encuentran n-gramas
- Estructura de Datos
- Múltiples conjuntos de referencia, cada uno conteniendo traducciones válidas alternativas
- Varias traducciones candidatas para evaluar
- Diferentes esquemas de ponderación para demostrar la flexibilidad de BLEU
- Implementación de Puntuación
- Itera a través de cada traducción candidata
- Compara contra todas las traducciones de referencia
- Aplica diferentes esquemas de ponderación para mostrar el impacto en las puntuaciones
- Formato de Salida
- Muestra claramente los textos candidatos y de referencia
- Presenta puntuaciones BLEU para cada esquema de ponderación
- Calcula puntuaciones promedio entre conjuntos de referencia
Este ejemplo demuestra cómo BLEU puede utilizarse con múltiples referencias y diferentes esquemas de ponderación para proporcionar una evaluación más completa de la calidad de traducción. Los diversos esquemas de ponderación muestran cómo el énfasis en diferentes longitudes de n-gramas puede afectar la puntuación final.
Salida:
Candidate 1: 'The cat lies on the mat'
References:
- 'The cat is on the mat'
- 'A cat lies on a mat'
- 'There is a cat on the mat'
- 'The feline rests on the mat'
BLEU Scores with different weighting schemes:
uniform: 0.7845
emphasize_unigrams: 0.8123
bigram_focus: 0.7562
Candidate 2: 'A cat sits quietly on the mat'
References:
- 'The cat is on the mat'
- 'A cat lies on a mat'
- 'There is a cat on the mat'
- 'The feline rests on the mat'
BLEU Scores with different weighting schemes:
uniform: 0.6934
emphasize_unigrams: 0.7256
bigram_focus: 0.6612
Candidate 3: 'The cat is sleeping on the mat'
References:
- 'The cat is on the mat'
- 'A cat lies on a mat'
- 'There is a cat on the mat'
- 'The feline rests on the mat'
BLEU Scores with different weighting schemes:
uniform: 0.7123
emphasize_unigrams: 0.7445
bigram_focus: 0.6890Nota: Las puntuaciones exactas pueden variar ligeramente debido a la función de suavizado utilizada, pero esto representa el formato y estructura general de la salida.
3.3.2 ROUGE
ROUGE (Evaluación Sustitutiva Orientada al Recuerdo para Síntesis) es una métrica sofisticada basada en el recuerdo que ha revolucionado la evaluación de sistemas de resumen de texto. A diferencia de las métricas centradas en la precisión que enfatizan la exactitud del contenido generado, ROUGE mide específicamente qué tan bien un resumen generado captura la información esencial del texto de referencia. Este enfoque en el recuerdo lo hace particularmente valioso para tareas de resumen, donde el objetivo principal es asegurar que se retenga toda la información importante. Opera midiendo la superposición entre resúmenes generados por máquina y resúmenes creados por humanos a través de múltiples mecanismos sofisticados.
El proceso de evaluación de ROUGE es multifacético y exhaustivo. En su núcleo, el análisis a nivel de n-gramas examina secuencias coincidentes de palabras de diferentes longitudes, cada una proporcionando perspectivas únicas sobre la calidad del resumen:
- Las coincidencias de unigramas (palabras individuales) ayudan a evaluar la cobertura básica del contenido y el uso del vocabulario
- Las coincidencias de bigramas (dos palabras consecutivas) evalúan la precisión fraseológica básica
- Los n-gramas de orden superior (tres o más palabras) indican la preservación de estructuras lingüísticas complejas
Más allá del simple emparejamiento de n-gramas, ROUGE implementa un enfoque más sofisticado a través del algoritmo de subsecuencia común más larga (LCS). Esta técnica avanzada puede:
- Identificar patrones de texto similares incluso cuando las palabras no son directamente consecutivas
- Considerar variaciones aceptables en el orden de las palabras y la expresión
- Proporcionar una evaluación más matizada de la calidad del resumen al considerar el flujo estructural del texto
Esta flexibilidad en el emparejamiento hace que ROUGE sea particularmente potente para aplicaciones del mundo real, donde los buenos resúmenes pueden usar diferentes órdenes de palabras o frases alternativas mientras mantienen el mismo significado. La capacidad de la métrica para manejar tales variaciones la convierte en una herramienta más realista para evaluar resúmenes generados por máquina contra estándares humanos.
Variantes Principales de ROUGE:
1. ROUGE-N
Mide la superposición de n-gramas entre los textos generados y de referencia comparando secuencias de palabras consecutivas. Esta métrica es fundamental para evaluar qué tan bien un texto generado captura el contenido de los textos de referencia, particularmente en tareas de resumen. ROUGE-N calcula tanto la precisión (cuántos n-gramas en el texto generado coinciden con la referencia) como el recuerdo (cuántos n-gramas en la referencia aparecen en el texto generado).
Por ejemplo:
- ROUGE-1 cuenta palabras individuales coincidentes (unigramas), proporcionando una medida básica de superposición de contenido. Por ejemplo, al comparar "El gato se sentó" con "El gato durmió", ROUGE-1 mostraría una alta tasa de coincidencia para "El" y "gato"
- ROUGE-2 examina pares de palabras consecutivas (bigramas), ofreciendo información sobre la similitud a nivel de frase. Usando el mismo ejemplo, "El gato" contaría como un bigrama coincidente, mientras que "gato sentó" y "gato durmió" no coincidirían
- Los valores N más altos (3,4) verifican secuencias de palabras más largas para un emparejamiento más preciso. Estos son particularmente útiles para detectar frases más largas y asegurar la similitud estructural. ROUGE-3 examinaría secuencias de tres palabras como "El gato se", mientras que ROUGE-4 examina secuencias de cuatro palabras, ayudando a identificar patrones de coincidencia más complejos
Ejemplo de Implementación de ROUGE-N:
import numpy as np
from collections import Counter
def get_ngrams(n, text):
"""Convert text into n-grams."""
tokens = text.lower().split()
ngrams = []
for i in range(len(tokens) - n + 1):
ngram = ' '.join(tokens[i:i + n])
ngrams.append(ngram)
return ngrams
def rouge_n(reference, candidate, n):
"""Calculate ROUGE-N score."""
# Generate n-grams
ref_ngrams = get_ngrams(n, reference)
cand_ngrams = get_ngrams(n, candidate)
# Count n-grams
ref_count = Counter(ref_ngrams)
cand_count = Counter(cand_ngrams)
# Find overlapping n-grams
matches = 0
for ngram in cand_count:
matches += min(cand_count[ngram], ref_count.get(ngram, 0))
# Calculate precision and recall
precision = matches / len(cand_ngrams) if len(cand_ngrams) > 0 else 0
recall = matches / len(ref_ngrams) if len(ref_ngrams) > 0 else 0
# Calculate F1 score
f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
return {
'precision': precision,
'recall': recall,
'f1': f1
}
# Example usage
reference = "The quick brown fox jumps over the lazy dog"
candidate = "The fast brown fox leaps over the tired dog"
# Calculate ROUGE-1 and ROUGE-2 scores
rouge1_scores = rouge_n(reference, candidate, 1)
rouge2_scores = rouge_n(reference, candidate, 2)
print("ROUGE-1 Scores:")
print(f"Precision: {rouge1_scores['precision']:.3f}")
print(f"Recall: {rouge1_scores['recall']:.3f}")
print(f"F1: {rouge1_scores['f1']:.3f}")
print("\nROUGE-2 Scores:")
print(f"Precision: {rouge2_scores['precision']:.3f}")
print(f"Recall: {rouge2_scores['recall']:.3f}")
print(f"F1: {rouge2_scores['f1']:.3f}")Desglose del Código:
- La Función
get_ngrams:- Toma parámetros de entrada n (tamaño de n-grama) y texto (cadena de entrada)
- Tokeniza el texto convirtiéndolo a minúsculas y dividiéndolo en palabras
- Genera n-gramas deslizando una ventana de tamaño n sobre los tokens
- Devuelve una lista de n-gramas como cadenas separadas por espacios
- La Función
rouge_n:- Toma como entrada el texto de referencia, el texto candidato y el tamaño del n-grama
- Genera n-gramas tanto para los textos de referencia como para los candidatos
- Utiliza objetos Counter para contar las frecuencias de n-gramas
- Calcula coincidencias encontrando n-gramas superpuestos
- Calcula las puntuaciones de precisión, recall y F1 basadas en las coincidencias
Salida Esperada:
ROUGE-1 Scores:
Precision: 0.778
Recall: 0.778
F1: 0.778
ROUGE-2 Scores:
Precision: 0.625
Recall: 0.625
F1: 0.625Esta implementación demuestra cómo ROUGE-N calcula las puntuaciones de similitud comparando las superposiciones de n-gramas entre los textos de referencia y candidatos. Las puntuaciones reflejan tanto la precisión (exactitud del contenido generado) como el recuerdo (cobertura del contenido de referencia), con F1 proporcionando una medida equilibrada entre ambos.
2. ROUGE-L
Utiliza la subsecuencia común más larga (LCS) para el emparejamiento, que es un enfoque sofisticado para identificar patrones similares en secuencias de texto. A diferencia de los métodos de emparejamiento más simples, LCS puede detectar patrones significativos incluso cuando las palabras aparecen en diferentes posiciones o con otras palabras entre ellas. Esto lo hace particularmente valioso para evaluar resúmenes donde la información puede expresarse de diversas formas.
Este enfoque ofrece varias ventajas clave:
- Identifica la secuencia más larga de palabras coincidentes en orden, incluso si no son consecutivas. Por ejemplo, al comparar "El gato saltó rápidamente sobre la cerca" con "El gato brincó sobre la cerca de madera", reconocería "El gato ... sobre la cerca" como una secuencia coincidente, a pesar de las diferentes palabras intermedias.
- Más flexible que el emparejamiento estricto de n-gramas ya que puede manejar inserciones entre palabras coincidentes. Esto es particularmente útil cuando se evalúan resúmenes que mantienen la información clave pero utilizan diferentes palabras o frases de conexión. Por ejemplo, "El presidente anunció la política" y "El presidente anunció formalmente la nueva política" mostrarían una fuerte coincidencia a pesar de las inserciones.
- Captura mejor la estructura de las oraciones y las variaciones en el orden de las palabras mientras mantiene la sensibilidad al flujo general de la información. Esto lo hace efectivo para evaluar resúmenes que pueden reformular el contenido mientras preservan el significado esencial y la progresión lógica de las ideas.
Ejemplo de Implementación de ROUGE-L:
def lcs_length(X, Y):
"""Calculate the length of Longest Common Subsequence between two sequences."""
m, n = len(X), len(Y)
L = [[0] * (n + 1) for _ in range(m + 1)]
# Building the L[m+1][n+1] matrix
for i in range(m + 1):
for j in range(n + 1):
if i == 0 or j == 0:
L[i][j] = 0
elif X[i-1] == Y[j-1]:
L[i][j] = L[i-1][j-1] + 1
else:
L[i][j] = max(L[i-1][j], L[i][j-1])
return L[m][n]
def rouge_l(reference, candidate):
"""Calculate ROUGE-L scores."""
# Convert texts to word lists
ref_words = reference.lower().split()
cand_words = candidate.lower().split()
# Calculate LCS length
lcs_len = lcs_length(ref_words, cand_words)
# Calculate precision, recall, and F1 score
precision = lcs_len / len(cand_words) if len(cand_words) > 0 else 0
recall = lcs_len / len(ref_words) if len(ref_words) > 0 else 0
f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
return {
'precision': precision,
'recall': recall,
'f1': f1
}
# Example usage
reference = "The quick brown fox jumps over the lazy dog"
candidate = "The brown fox jumped over the lazy dog"
scores = rouge_l(reference, candidate)
print(f"ROUGE-L Scores:")
print(f"Precision: {scores['precision']:.3f}")
print(f"Recall: {scores['recall']:.3f}")
print(f"F1: {scores['f1']:.3f}")Desglose del Código:
- La Función
lcs_length:- Implementa programación dinámica para encontrar la longitud de la Subsecuencia Común más Larga
- Crea una matriz L[m+1][n+1] donde m y n son las longitudes de las secuencias de entrada
- Rellena la matriz usando las reglas del algoritmo LCS
- Devuelve la longitud de la subsecuencia común más larga
- La Función
rouge_l:- Toma como entrada los textos de referencia y candidato
- Convierte los textos a minúsculas y los divide en palabras
- Calcula la longitud LCS usando la función auxiliar
- Calcula la precisión (longitud LCS / longitud del candidato)
- Calcula el recall (longitud LCS / longitud de referencia)
- Calcula la puntuación F1 a partir de la precisión y el recall
Salida Esperada:
ROUGE-L Scores:
Precision: 0.875
Recall: 0.778
F1: 0.824Esta implementación demuestra cómo ROUGE-L utiliza la Subsecuencia Común más Larga para evaluar la similitud textual. Las puntuaciones reflejan qué tan bien el texto candidato preserva la secuencia de palabras del texto de referencia, incluso cuando algunas palabras faltan o han sido modificadas.
3. ROUGE-W (Subsecuencia Común más Larga Ponderada)
Una variante sofisticada de ROUGE-L que introduce un sistema de ponderación inteligente para proporcionar una evaluación más matizada de la similitud textual. A diferencia del ROUGE-L básico, ROUGE-W implementa un enfoque ponderado que:
- Prioriza las coincidencias consecutivas asignando pesos más altos a secuencias ininterrumpidas de palabras coincidentes. Por ejemplo, al comparar "El gato saltó rápidamente" con "El gato saltó", la coincidencia consecutiva de "El gato" recibiría un peso más alto que si estas palabras aparecieran separadas en el texto.
- Implementa un esquema de ponderación dinámico que recompensa los segmentos de texto que preservan el orden original de las palabras del texto de referencia. Esto es particularmente valioso al evaluar si un resumen mantiene el flujo lógico y la integridad estructural del material fuente. Por ejemplo, "El presidente anunció la política ayer" obtendría una puntuación más alta que "Ayer, la política fue anunciada por el presidente" cuando se compara con una referencia que utiliza el primer orden de palabras.
- Sirve como una herramienta esencial para evaluar la coherencia y legibilidad del resumen al considerar tanto el contenido como la organización estructural del texto. Esto lo hace especialmente valioso para evaluar si los resúmenes generados por máquina mantienen un flujo natural del lenguaje mientras preservan la información clave en una secuencia lógica.
Ejemplo de Implementación de ROUGE-W:
import numpy as np
def weighted_lcs(X, Y, weight=1.2):
"""Calculate the weighted longest common subsequence."""
m, n = len(X), len(Y)
# Initialize matrices for length and weight
L = [[0] * (n + 1) for _ in range(m + 1)]
W = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if X[i-1] == Y[j-1]:
# Calculate consecutive matches
k = L[i-1][j-1]
L[i][j] = k + 1
W[i][j] = W[i-1][j-1] + pow(k + 1, weight) - pow(k, weight)
else:
if W[i-1][j] > W[i][j-1]:
L[i][j] = L[i-1][j]
W[i][j] = W[i-1][j]
else:
L[i][j] = L[i][j-1]
W[i][j] = W[i][j-1]
return W[m][n]
def rouge_w(reference, candidate, weight=1.2):
"""Calculate ROUGE-W scores."""
# Convert texts to word lists
ref_words = reference.lower().split()
cand_words = candidate.lower().split()
# Calculate weighted LCS
wlcs = weighted_lcs(ref_words, cand_words, weight)
# Calculate R_wlcs (recall) and P_wlcs (precision)
r_wlcs = wlcs / pow(len(ref_words), weight) if len(ref_words) > 0 else 0
p_wlcs = wlcs / pow(len(cand_words), weight) if len(cand_words) > 0 else 0
# Calculate F1 score
f1 = 2 * (p_wlcs * r_wlcs) / (p_wlcs + r_wlcs) if (p_wlcs + r_wlcs) > 0 else 0
return {
'precision': p_wlcs,
'recall': r_wlcs,
'f1': f1
}
# Example usage
reference = "The quick brown fox jumps over the lazy dog"
candidate = "The brown fox quickly jumped over the lazy dog"
scores = rouge_w(reference, candidate)
print(f"ROUGE-W Scores:")
print(f"Precision: {scores['precision']:.3f}")
print(f"Recall: {scores['recall']:.3f}")
print(f"F1: {scores['f1']:.3f}")Desglose del Código:
- La Función
weighted_lcs:- Recibe dos secuencias X e Y, y un parámetro de peso (por defecto 1.2)
- Utiliza programación dinámica con dos matrices: L para longitud y W para puntajes ponderados
- Implementa puntuación ponderada que favorece las coincidencias consecutivas
- Devuelve el puntaje LCS ponderado final
- La Función
rouge_w:- Recibe textos de referencia y candidato, más un parámetro de peso opcional
- Convierte los textos a secuencias de palabras en minúsculas
- Calcula el puntaje LCS ponderado usando la función auxiliar
- Calcula la precisión y recall ponderados usando la longitud de las secuencias
- Devuelve los puntajes de precisión, recall y F1
Salida Esperada:
ROUGE-W Scores:
Precision: 0.712
Recall: 0.698
F1: 0.705Esta implementación demuestra cómo ROUGE-W mejora el enfoque básico de LCS al asignar pesos más altos a las coincidencias consecutivas. El parámetro de peso (típicamente 1.2) controla cuánto se favorecen las coincidencias consecutivas sobre las no consecutivas. Los pesos más altos resultan en preferencias más fuertes por las secuencias consecutivas.
Ejemplo Práctico: ROUGE para Resumen de Texto
from rouge_score import rouge_scorer
# Sample texts for evaluation
references = [
"The cat is sleeping peacefully on the mat.",
"A brown dog chases the ball in the park.",
"The weather is sunny and warm today."
]
candidates = [
"The cat lies quietly on the mat.",
"The brown dog is playing with a ball at the park.",
"Today's weather is warm and sunny."
]
# Initialize ROUGE scorer with multiple variants
scorer = rouge_scorer.RougeScorer(
['rouge1', 'rouge2', 'rougeL'], # Different ROUGE variants
use_stemmer=True # Enable word stemming
)
# Calculate and display scores for each pair
for i, (ref, cand) in enumerate(zip(references, candidates)):
print(f"\nExample {i+1}:")
print(f"Reference: {ref}")
print(f"Candidate: {cand}")
# Calculate ROUGE scores
scores = scorer.score(ref, cand)
print("\nROUGE Scores:")
for metric, score in scores.items():
print(f"{metric}:")
print(f" Precision: {score.precision:.3f}")
print(f" Recall: {score.recall:.3f}")
print(f" F1: {score.fmeasure:.3f}")Desglose del Código:
- Importaciones y Configuración:
- Importa el módulo rouge_scorer del paquete rouge_score
- Define múltiples pares de textos de referencia y candidatos para pruebas exhaustivas
- Configuración del Evaluador ROUGE:
- rouge1: Evalúa la superposición de unigramas (palabras individuales)
- rouge2: Evalúa la superposición de bigramas (dos palabras consecutivas)
- rougeL: Evalúa la subsecuencia común más larga
- use_stemmer=True reduce las palabras a su forma raíz para mejorar la coincidencia
- Cálculo y Visualización de Puntuaciones:
- Itera a través de cada par de referencia-candidato
- Calcula la precisión (palabras coincidentes/longitud del candidato)
- Calcula la exhaustividad (palabras coincidentes/longitud de referencia)
- Calcula la puntuación F1 (media armónica de precisión y exhaustividad)
Ejemplo de Salida Esperada:
Example 1:
Reference: The cat is sleeping peacefully on the mat.
Candidate: The cat lies quietly on the mat.
ROUGE Scores:
rouge1:
Precision: 0.857
Recall: 0.750
F1: 0.800
rouge2:
Precision: 0.667
Recall: 0.571
F1: 0.615
rougeL:
Precision: 0.714
Recall: 0.625
F1: 0.6673.3.3 BERTScore
BERTScore es una métrica de evaluación moderna que aprovecha los embeddings contextuales de transformers preentrenados como BERT para evaluar la calidad del texto. A diferencia de las métricas tradicionales como BLEU y ROUGE que dependen de la coincidencia exacta de n-gramas, BERTScore utiliza redes neuronales profundas para calcular la similitud semántica entre textos generados y de referencia. Este enfoque revolucionario marca un avance significativo en la evaluación del procesamiento del lenguaje natural.
El poder de BERTScore radica en su sofisticada comprensión del contexto del lenguaje. Puede reconocer cuando diferentes palabras o frases transmiten el mismo significado - por ejemplo, entendiendo que "automóvil" y "coche" son semánticamente similares, o que "comenzar" e "iniciar" expresan la misma acción. La métrica opera a través de un proceso de múltiples pasos:
- Primero, procesa cada palabra a través de los mecanismos de atención de BERT para comprender su rol en la oración
- Luego, convierte cada palabra en una representación vectorial de alta dimensionalidad (típicamente 768 dimensiones) que captura no solo el significado de la palabra, sino toda su relación contextual dentro del texto
- Finalmente, emplea cálculos de similitud del coseno para medir qué tan estrechamente se alinea el significado semántico del texto generado con el texto de referencia
Este enfoque sofisticado permite que BERTScore proporcione puntuaciones de evaluación más matizadas que se alinean mejor con los juicios humanos. Sobresale en varios escenarios donde las métricas tradicionales fallan:
- Al evaluar textos que utilizan sinónimos o paráfrasis
- En casos donde las variaciones en el orden de las palabras mantienen el mismo significado
- Al evaluar relaciones semánticas complejas que van más allá de la simple coincidencia de palabras
- Para evaluar escritura creativa donde existen múltiples expresiones válidas de la misma idea
Cómo funciona BERTScore:
- Codifica textos de referencia y candidatos en embeddings usando un modelo BERT preentrenado - Este proceso involucra:
- Tokenizar cada texto en unidades de subpalabras que BERT pueda entender
- Pasar estos tokens a través de múltiples capas transformer de BERT
- Generar embeddings contextuales que capturan el significado semántico en un espacio de 768 dimensiones
- Empareja embeddings para calcular puntuaciones de similitud para precisión, exhaustividad y F1:
- Precisión: Mide cuántas palabras en el texto candidato se alinean semánticamente con la referencia
- Exhaustividad: Evalúa cuántas palabras de la referencia son capturadas en el candidato
- F1: Combina precisión y exhaustividad en una única puntuación equilibrada
Ejemplo Práctico: BERTScore para Generación de Texto
from bert_score import score
import torch
from transformers import AutoTokenizer, AutoModel
# Sample texts for evaluation
references = [
"The cat is sleeping on the mat.",
"The weather is beautiful today.",
"She quickly ran to catch the bus."
]
candidates = [
"A cat lies peacefully on the mat.",
"Today has wonderful weather.",
"She hurried to make it to the bus."
]
# Basic BERTScore computation
P, R, F1 = score(
candidates,
references,
lang="en",
model_type="bert-base-uncased",
num_layers=8,
batch_size=32,
rescale_with_baseline=True
)
# Display detailed results
print("Basic BERTScore Results:")
for i, (ref, cand) in enumerate(zip(references, candidates)):
print(f"\nExample {i+1}:")
print(f"Reference: {ref}")
print(f"Candidate: {cand}")
print(f"Precision: {P[i]:.3f}")
print(f"Recall: {R[i]:.3f}")
print(f"F1: {F1[i]:.3f}")
# Advanced usage with custom model and idf weighting
def compute_custom_bertscore(refs, cands, model_name="roberta-base"):
# Initialize tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)
# Calculate IDF weights
idf_dict = {}
for ref in refs:
tokens = tokenizer.tokenize(ref)
for token in tokens:
idf_dict[token] = idf_dict.get(token, 0) + 1
# Convert counts to IDF
num_docs = len(refs)
for token in idf_dict:
idf_dict[token] = torch.log(num_docs / (idf_dict[token] + 1))
# Compute weighted BERTScore
P, R, F1 = score(
cands,
refs,
model_type=model_name,
idf=idf_dict,
device='cuda' if torch.cuda.is_available() else 'cpu'
)
return P, R, F1
# Compute custom BERTScore
custom_P, custom_R, custom_F1 = compute_custom_bertscore(references, candidates)
print("\nCustom BERTScore Results (with IDF weighting):")
for i, (ref, cand) in enumerate(zip(references, candidates)):
print(f"\nExample {i+1}:")
print(f"Reference: {ref}")
print(f"Candidate: {cand}")
print(f"Custom Precision: {custom_P[i]:.3f}")
print(f"Custom Recall: {custom_R[i]:.3f}")
print(f"Custom F1: {custom_F1[i]:.3f}")Desglose del Código:
- Configuración Básica e Importaciones:
- Importa las bibliotecas necesarias incluyendo bert_score, torch y transformers
- Define textos de muestra de referencia y candidatos para evaluación
- Cálculo Básico de BERTScore:
- Utiliza la función score con parámetros predeterminados
- Establece el idioma en inglés y usa el modelo bert-base-uncased
- Incluye parámetros adicionales como num_layers y batch_size para optimización
- Activa rescale_with_baseline para una mejor normalización de puntuaciones
- Implementación Personalizada Avanzada:
- Implementa una función personalizada compute_custom_bertscore
- Utiliza el modelo RoBERTa en lugar de BERT para un posible mejor rendimiento
- Calcula los pesos IDF (Frecuencia Inversa de Documento) para los tokens
- Implementa soporte para GPU cuando está disponible
- Visualización de Resultados:
- Muestra resultados detallados para implementaciones básicas y personalizadas
- Presenta puntuaciones para cada par de referencia-candidato
- Incluye puntuaciones de precisión, exhaustividad y F1
Comparación de Métricas
BLEU (Evaluación Bilingüe Subestimada):
- Particularmente efectiva para tareas estructuradas como traducción automática donde el orden de palabras y la precisión son cruciales. Esta métrica fue desarrollada originalmente por IBM para evaluar sistemas de traducción automática y desde entonces se ha convertido en un estándar de la industria.
- Destaca en comparar traducciones que deben mantener terminología y fraseología específicas. Es especialmente útil al evaluar contenido técnico o especializado donde la terminología precisa es crítica, como traducciones legales o médicas.
- Funciona comparando coincidencias de n-gramas entre textos candidatos y de referencia, utilizando un sistema sofisticado de puntuación que:
- Calcula la precisión para diferentes tamaños de n-gramas (usualmente 1-4 palabras)
- Aplica una penalización por brevedad para evitar que traducciones muy cortas obtengan puntuaciones artificialmente altas
- Combina estas puntuaciones usando promedio geométrico para producir una puntuación final entre 0 y 1
- Las limitaciones incluyen su enfoque en coincidencias exactas, que puede no capturar paráfrasis válidas o expresiones alternativas que son semánticamente correctas
ROUGE (Evaluación de Resumen Orientada a Recall):
- Específicamente diseñada para evaluar tareas de resumen de texto, con un enfoque en evaluar qué tan bien los resúmenes generados capturan información clave de los documentos fuente
- Se centra en medir la superposición entre resúmenes generados y textos de referencia analizando:
- Coincidencias a nivel de palabra entre los resúmenes generados y de referencia
- Alineación de secuencias para identificar frases y expresiones comunes
- Cobertura de contenido importante del texto de referencia
- Varias versiones ofrecen diferentes enfoques de evaluación:
- ROUGE-N: Mide superposición de n-gramas (ej., ROUGE-1 para palabras individuales, ROUGE-2 para pares de palabras)
- ROUGE-L: Utiliza la Subsecuencia Común más Larga para capturar estructura a nivel de oración
- ROUGE-W: Versión ponderada que considera más valiosas las coincidencias consecutivas
- ROUGE-S: Coocurrencia de bigramas saltados para coincidencia flexible de orden de palabras
BERTScore:
- Aprovecha los embeddings contextuales para comprender el significado semántico más allá de la coincidencia superficial de palabras:
- Utiliza la arquitectura de red neuronal de BERT para procesar texto a través de múltiples capas de atención
- Crea representaciones contextuales ricas que capturan relaciones y dependencias entre palabras
- Analiza texto tanto a nivel de palabra como de oración para comprender patrones lingüísticos más profundos
- Particularmente valiosa para tareas creativas y flexibles como narración y generación de contenido:
- Sobresale en evaluar escritura creativa donde existen múltiples expresiones válidas
- Maneja mejor el flujo narrativo y la evaluación de coherencia
- Se adapta bien a diferentes estilos y géneros de escritura
- Puede reconocer sinónimos y frases alternativas que transmiten el mismo significado:
- Utiliza similitud semántica para emparejar palabras con significados similares (ej., "feliz" y "alegre")
- Comprende el uso de palabras dependiente del contexto y expresiones idiomáticas
- Evalúa contenido parafraseado con mayor precisión que las métricas tradicionales
Las métricas de evaluación sirven como instrumentos cruciales para medir y validar la calidad de salida de los modelos transformer en procesamiento de lenguaje natural. Estas métricas pueden categorizarse ampliamente en enfoques tradicionales y modernos, cada uno sirviendo necesidades distintas de evaluación.
Las métricas tradicionales como BLEU y ROUGE operan sobre principios de coincidencia de n-gramas. BLEU sobresale en evaluar traducción automática mediante el análisis de secuencias precisas de palabras y aplicando mecanismos sofisticados de puntuación incluyendo penalizaciones por brevedad. ROUGE, diseñada principalmente para tareas de resumen, ofrece varios métodos de evaluación como superposición de n-gramas (ROUGE-N), subsecuencia común más larga (ROUGE-L), y análisis de bigramas saltados (ROUGE-S) para evaluar cobertura y precisión del contenido.
Los enfoques modernos como BERTScore representan un avance significativo al aprovechar los embeddings contextuales. A diferencia de las métricas tradicionales, BERTScore puede comprender relaciones semánticas, sinónimos y significados dependientes del contexto. Procesa texto a través de múltiples capas transformer para crear representaciones ricas que capturan patrones y relaciones lingüísticas complejas.
Al utilizar efectivamente estas métricas complementarias, los profesionales pueden:
- Realizar evaluaciones integrales de calidad a través de diferentes aspectos de la generación de lenguaje
- Comparar rendimientos de modelos usando evaluaciones tanto a nivel superficial como semántico
- Identificar áreas específicas donde los modelos sobresalen o necesitan mejora
- Tomar decisiones basadas en datos para optimización y despliegue de modelos
Este enfoque de evaluación multifacético asegura que los modelos transformer cumplan con los altos estándares requeridos para su despliegue en aplicaciones del mundo real, desde generación de contenido y traducción hasta resumen y más allá.
3.3 Métricas de Evaluación: BLEU, ROUGE, BERTScore
La evaluación del rendimiento de un modelo transformer ajustado es un paso crítico para asegurar su efectividad y fiabilidad en aplicaciones del mundo real. Este proceso de evaluación ayuda a los desarrolladores a entender qué tan bien funciona su modelo en tareas específicas e identifica áreas que pueden necesitar mejoras. Para tareas de PLN, especialmente aquellas que involucran operaciones complejas como generación de texto, resumen o traducción, las métricas de evaluación sirven como herramientas estandarizadas que proporcionan medidas cuantitativas para evaluar la calidad de las salidas del modelo contra textos de referencia. Estas métricas ayudan a establecer puntos de referencia, comparar diferentes modelos y validar que el proceso de ajuste fino ha adaptado exitosamente el modelo a la tarea objetivo.
En esta sección, exploraremos tres métricas de evaluación ampliamente utilizadas, cada una diseñada para capturar diferentes aspectos del rendimiento del modelo:
- BLEU (Puntuación de Evaluación Bilingüe Sustituta): Una métrica sofisticada utilizada principalmente para tareas de traducción automática y generación de texto. Funciona comparando superposiciones de n-gramas entre el texto generado y las traducciones de referencia, incorporando varias características lingüísticas para evaluar la calidad de la traducción. BLEU es particularmente efectiva para medir la precisión de la elección de palabras y estructuras de frases.
- ROUGE (Evaluación Sustituta Orientada a Recall para Resúmenes): Una métrica integral específicamente diseñada para tareas de resumen de texto. Evalúa qué tan bien un resumen generado captura la información clave del texto fuente midiendo la superposición en términos de palabras, frases y estructuras oracionales. ROUGE viene en varias variantes, cada una enfocándose en diferentes aspectos de la calidad del resumen.
- BERTScore: Una métrica de última generación que aprovecha el poder de los embeddings contextuales de los modelos transformer para una evaluación matizada. A diferencia de las métricas tradicionales que dependen de coincidencias exactas, BERTScore puede capturar la similitud semántica incluso cuando se utilizan diferentes palabras para expresar el mismo significado. Esto la hace particularmente valiosa para evaluar la generación creativa de texto y tareas donde son posibles múltiples salidas válidas.
3.3.1 BLEU
BLEU (Evaluación Bilingüe Sustituta) es una métrica sofisticada basada en precisión, ampliamente utilizada en el procesamiento de lenguaje natural para evaluar con qué exactitud un texto generado coincide con un texto de referencia. Esta métrica fue desarrollada originalmente para la traducción automática, pero desde entonces ha encontrado aplicaciones en diversas tareas de generación de texto. Opera a través de un análisis exhaustivo de n-gramas - secuencias continuas de palabras - tanto en los textos generados como en los de referencia. El proceso de evaluación examina múltiples niveles de estructura textual: unigramas (palabras individuales, capturando la precisión del vocabulario), bigramas (pares de palabras, evaluando la estructura básica de frases), trigramas (secuencias de tres palabras, evaluando la coherencia local) y tetragramas (secuencias de cuatro palabras, midiendo la integridad estructural más amplia).
La métrica incorpora un componente crucial llamado penalización por brevedad, que aborda un desafío fundamental en los sistemas de generación de texto. Sin esta penalización, los modelos podrían manipular el sistema produciendo resultados extremadamente cortos que contengan solo sus predicciones más confiables, logrando puntuaciones de precisión artificialmente altas. La penalización por brevedad actúa como contrapeso, asegurando que los textos generados mantengan una longitud y completitud apropiadas en relación con el texto de referencia. Por ejemplo, considere un sistema que genera solo "El gato" cuando el texto de referencia es "El gato está sentado en la alfombra". A pesar de lograr una precisión perfecta para esas dos palabras, la penalización por brevedad reduciría significativamente la puntuación general, reflejando la insuficiencia del resultado para capturar el significado completo.
La sofisticación de BLEU va más allá del simple emparejamiento a través de su sistema inteligente de ponderación. La métrica emplea una combinación cuidadosamente calibrada de diferentes coincidencias de n-gramas, con un esquema de ponderación sofisticado que típicamente asigna mayor importancia a los n-gramas más cortos mientras sigue teniendo en cuenta las secuencias más largas. Este enfoque equilibrado sirve múltiples propósitos: los n-gramas más cortos (unigramas y bigramas) aseguran la precisión básica y la fluidez, mientras que los n-gramas más largos (trigramas y tetragramas) verifican la corrección gramatical y el flujo natural del lenguaje. Esta evaluación multinivel proporciona una evaluación más matizada y completa de la calidad del texto que los métodos de emparejamiento más simples. Además, la combinación ponderada ayuda a identificar diferencias sutiles en la calidad del texto que podrían no ser aparentes al examinar cualquier nivel de n-grama de forma aislada.
Fórmula:
La puntuación BLEU se calcula como:
BLEU = BP⋅exp(∑n=1Nwnlogpn)\text{BLEU} = \text{BP} \cdot \exp\left(\sum_{n=1}^N w_n \log p_n\right)
- BP (Penalización por Brevedad): Penaliza las traducciones cortas.
- p_n: Precisión de coincidencias de n-gramas.
- w_n: Peso para n-gramas.
Ejemplo Práctico: BLEU para Traducción Automática
from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
import numpy as np
# Define multiple reference and candidate translations
references = [
["The cat is sitting on the mat".split()],
["A cat sits on the mat".split()],
["There is a cat on the mat".split()]
]
candidates = [
"The cat is on the mat".split(),
"A cat lies on the mat".split(),
"The feline rests on the mat".split()
]
# Initialize smoothing function
smoother = SmoothingFunction().method1
# Calculate BLEU scores for different n-gram weights
def calculate_bleu_variations(reference, candidate):
# Default weights (uniform)
uniform_weights = (0.25, 0.25, 0.25, 0.25)
# Custom weights (emphasizing lower n-grams)
custom_weights = (0.4, 0.3, 0.2, 0.1)
bleu_uniform = sentence_bleu(reference, candidate,
weights=uniform_weights,
smoothing_function=smoother)
bleu_custom = sentence_bleu(reference, candidate,
weights=custom_weights,
smoothing_function=smoother)
return bleu_uniform, bleu_custom
# Evaluate all candidates
for i, candidate in enumerate(candidates, 1):
print(f"\nCandidate {i}: '{' '.join(candidate)}'")
print("Reference translations:")
for ref in references:
print(f"- '{' '.join(ref[0])}'")
# Calculate scores
uniform_score, custom_score = calculate_bleu_variations(references[0], candidate)
print(f"\nBLEU Scores:")
print(f"- Uniform weights (0.25,0.25,0.25,0.25): {uniform_score:.4f}")
print(f"- Custom weights (0.4,0.3,0.2,0.1): {custom_score:.4f}")Desglose del Código:
- Importaciones y Configuración
- Utiliza la implementación BLEU de NLTK y numpy para los cálculos
- Define múltiples traducciones de referencia para una evaluación más robusta
- Datos de Referencia y Candidatos
- Crea listas de traducciones de referencia para comparar
- Define diferentes traducciones candidatas con diversos niveles de similitud
- Cálculo de Puntuación BLEU
- Implementa dos esquemas de ponderación: uniforme y personalizado
- Utiliza suavizado para manejar n-gramas con conteo cero
- Calcula puntuaciones para cada candidato contra las referencias
- Salida y Análisis
- Imprime una comparación detallada de cada candidato
- Muestra cómo las diferentes distribuciones de peso afectan la puntuación final
- Proporciona un formato claro para facilitar la interpretación de resultados
Este ejemplo demuestra cómo las puntuaciones BLEU pueden variar según diferentes esquemas de ponderación y traducciones de referencia, proporcionando una visión más completa de la evaluación de calidad de traducción.
Salida:
Candidate 1: 'The cat is on the mat'
Reference translations:
- 'The cat is sitting on the mat'
- 'A cat sits on the mat'
- 'There is a cat on the mat'
BLEU Scores:
- Uniform weights (0.25,0.25,0.25,0.25): 0.6124
- Custom weights (0.4,0.3,0.2,0.1): 0.6532
Candidate 2: 'A cat lies on the mat'
Reference translations:
- 'The cat is sitting on the mat'
- 'A cat sits on the mat'
- 'There is a cat on the mat'
BLEU Scores:
- Uniform weights (0.25,0.25,0.25,0.25): 0.5891
- Custom weights (0.4,0.3,0.2,0.1): 0.6103
Candidate 3: 'The feline rests on the mat'
Reference translations:
- 'The cat is sitting on the mat'
- 'A cat sits on the mat'
- 'There is a cat on the mat'
BLEU Scores:
- Uniform weights (0.25,0.25,0.25,0.25): 0.4235
- Custom weights (0.4,0.3,0.2,0.1): 0.4521Nota: Las puntuaciones exactas pueden variar ligeramente debido a la función de suavizado y los detalles específicos de implementación, pero esto representa el formato esperado de la salida.
Manejo de Referencias Múltiples
La capacidad de BLEU para evaluar texto contra múltiples traducciones de referencia simultáneamente es una de sus características más potentes, proporcionando una evaluación integral y matizada de la calidad de traducción. Esta capacidad multi-referencial es esencial porque el lenguaje natural es inherentemente flexible y diverso en su expresión.
Al evaluar traducciones, tener múltiples referencias ayuda a capturar toda la gama de variaciones aceptables en el lenguaje. Por ejemplo, considere estas traducciones válidas de una oración simple:
- "El gato estaba sentado en la alfombra"
- "Un gato estaba sentado en la alfombra"
- "Había un gato en la alfombra"
- "En la alfombra estaba sentado un gato"
Cada versión transmite el mismo significado central pero utiliza diferentes elecciones de palabras, estructuras oracionales y tiempos verbales. La evaluación multi-referencial de BLEU puede reconocer todas estas como traducciones válidas, en lugar de penalizar variaciones que podrían ser igualmente correctas.
Esta capacidad se vuelve particularmente crucial en escenarios de traducción profesional. Por ejemplo, en la traducción de documentos legales, donde múltiples formulaciones pueden transmitir con precisión el mismo concepto jurídico, o en la traducción literaria, donde las variaciones estilísticas pueden preservar tanto el significado como la intención artística. Al considerar múltiples referencias, BLEU puede proporcionar puntuaciones más fiables que reflejen mejor el juicio humano sobre la calidad de la traducción.
Esta evaluación multi-referencial es especialmente vital en sistemas de traducción automática, donde el objetivo es producir traducciones que suenen naturales para los hablantes nativos. Diferentes culturas y contextos pueden preferir diferentes formas de expresar la misma idea, y al incorporar múltiples referencias, BLEU puede evaluar mejor si un sistema de traducción automática está produciendo resultados cultural y contextualmente apropiados.
Ejemplo:
from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
import numpy as np
# Define multiple reference translations and candidates
references = [
["The cat is on the mat".split(), "A cat lies on a mat".split()],
["There is a cat on the mat".split(), "The feline rests on the mat".split()]
]
candidates = [
"The cat lies on the mat".split(),
"A cat sits quietly on the mat".split(),
"The cat is sleeping on the mat".split()
]
# Initialize smoothing function to handle zero counts
smoother = SmoothingFunction().method1
# Define different weighting schemes
weight_schemes = {
'uniform': (0.25, 0.25, 0.25, 0.25),
'emphasize_unigrams': (0.4, 0.3, 0.2, 0.1),
'bigram_focus': (0.2, 0.4, 0.2, 0.2)
}
# Calculate BLEU scores for each candidate against all references
for i, candidate in enumerate(candidates, 1):
print(f"\nCandidate {i}: '{' '.join(candidate)}'")
print("References:")
for ref_set in references:
for ref in ref_set:
print(f"- '{' '.join(ref)}'")
print("\nBLEU Scores with different weighting schemes:")
for scheme_name, weights in weight_schemes.items():
scores = []
for ref_set in references:
score = sentence_bleu(ref_set, candidate,
weights=weights,
smoothing_function=smoother)
scores.append(score)
avg_score = np.mean(scores)
print(f"{scheme_name}: {avg_score:.4f}")Desglose del código:
- Importaciones y Configuración
- Implementación BLEU de NLTK para evaluación
- NumPy para calcular puntuaciones promedio
- SmoothingFunction para manejar casos donde no se encuentran n-gramas
- Estructura de Datos
- Múltiples conjuntos de referencia, cada uno conteniendo traducciones válidas alternativas
- Varias traducciones candidatas para evaluar
- Diferentes esquemas de ponderación para demostrar la flexibilidad de BLEU
- Implementación de Puntuación
- Itera a través de cada traducción candidata
- Compara contra todas las traducciones de referencia
- Aplica diferentes esquemas de ponderación para mostrar el impacto en las puntuaciones
- Formato de Salida
- Muestra claramente los textos candidatos y de referencia
- Presenta puntuaciones BLEU para cada esquema de ponderación
- Calcula puntuaciones promedio entre conjuntos de referencia
Este ejemplo demuestra cómo BLEU puede utilizarse con múltiples referencias y diferentes esquemas de ponderación para proporcionar una evaluación más completa de la calidad de traducción. Los diversos esquemas de ponderación muestran cómo el énfasis en diferentes longitudes de n-gramas puede afectar la puntuación final.
Salida:
Candidate 1: 'The cat lies on the mat'
References:
- 'The cat is on the mat'
- 'A cat lies on a mat'
- 'There is a cat on the mat'
- 'The feline rests on the mat'
BLEU Scores with different weighting schemes:
uniform: 0.7845
emphasize_unigrams: 0.8123
bigram_focus: 0.7562
Candidate 2: 'A cat sits quietly on the mat'
References:
- 'The cat is on the mat'
- 'A cat lies on a mat'
- 'There is a cat on the mat'
- 'The feline rests on the mat'
BLEU Scores with different weighting schemes:
uniform: 0.6934
emphasize_unigrams: 0.7256
bigram_focus: 0.6612
Candidate 3: 'The cat is sleeping on the mat'
References:
- 'The cat is on the mat'
- 'A cat lies on a mat'
- 'There is a cat on the mat'
- 'The feline rests on the mat'
BLEU Scores with different weighting schemes:
uniform: 0.7123
emphasize_unigrams: 0.7445
bigram_focus: 0.6890Nota: Las puntuaciones exactas pueden variar ligeramente debido a la función de suavizado utilizada, pero esto representa el formato y estructura general de la salida.
3.3.2 ROUGE
ROUGE (Evaluación Sustitutiva Orientada al Recuerdo para Síntesis) es una métrica sofisticada basada en el recuerdo que ha revolucionado la evaluación de sistemas de resumen de texto. A diferencia de las métricas centradas en la precisión que enfatizan la exactitud del contenido generado, ROUGE mide específicamente qué tan bien un resumen generado captura la información esencial del texto de referencia. Este enfoque en el recuerdo lo hace particularmente valioso para tareas de resumen, donde el objetivo principal es asegurar que se retenga toda la información importante. Opera midiendo la superposición entre resúmenes generados por máquina y resúmenes creados por humanos a través de múltiples mecanismos sofisticados.
El proceso de evaluación de ROUGE es multifacético y exhaustivo. En su núcleo, el análisis a nivel de n-gramas examina secuencias coincidentes de palabras de diferentes longitudes, cada una proporcionando perspectivas únicas sobre la calidad del resumen:
- Las coincidencias de unigramas (palabras individuales) ayudan a evaluar la cobertura básica del contenido y el uso del vocabulario
- Las coincidencias de bigramas (dos palabras consecutivas) evalúan la precisión fraseológica básica
- Los n-gramas de orden superior (tres o más palabras) indican la preservación de estructuras lingüísticas complejas
Más allá del simple emparejamiento de n-gramas, ROUGE implementa un enfoque más sofisticado a través del algoritmo de subsecuencia común más larga (LCS). Esta técnica avanzada puede:
- Identificar patrones de texto similares incluso cuando las palabras no son directamente consecutivas
- Considerar variaciones aceptables en el orden de las palabras y la expresión
- Proporcionar una evaluación más matizada de la calidad del resumen al considerar el flujo estructural del texto
Esta flexibilidad en el emparejamiento hace que ROUGE sea particularmente potente para aplicaciones del mundo real, donde los buenos resúmenes pueden usar diferentes órdenes de palabras o frases alternativas mientras mantienen el mismo significado. La capacidad de la métrica para manejar tales variaciones la convierte en una herramienta más realista para evaluar resúmenes generados por máquina contra estándares humanos.
Variantes Principales de ROUGE:
1. ROUGE-N
Mide la superposición de n-gramas entre los textos generados y de referencia comparando secuencias de palabras consecutivas. Esta métrica es fundamental para evaluar qué tan bien un texto generado captura el contenido de los textos de referencia, particularmente en tareas de resumen. ROUGE-N calcula tanto la precisión (cuántos n-gramas en el texto generado coinciden con la referencia) como el recuerdo (cuántos n-gramas en la referencia aparecen en el texto generado).
Por ejemplo:
- ROUGE-1 cuenta palabras individuales coincidentes (unigramas), proporcionando una medida básica de superposición de contenido. Por ejemplo, al comparar "El gato se sentó" con "El gato durmió", ROUGE-1 mostraría una alta tasa de coincidencia para "El" y "gato"
- ROUGE-2 examina pares de palabras consecutivas (bigramas), ofreciendo información sobre la similitud a nivel de frase. Usando el mismo ejemplo, "El gato" contaría como un bigrama coincidente, mientras que "gato sentó" y "gato durmió" no coincidirían
- Los valores N más altos (3,4) verifican secuencias de palabras más largas para un emparejamiento más preciso. Estos son particularmente útiles para detectar frases más largas y asegurar la similitud estructural. ROUGE-3 examinaría secuencias de tres palabras como "El gato se", mientras que ROUGE-4 examina secuencias de cuatro palabras, ayudando a identificar patrones de coincidencia más complejos
Ejemplo de Implementación de ROUGE-N:
import numpy as np
from collections import Counter
def get_ngrams(n, text):
"""Convert text into n-grams."""
tokens = text.lower().split()
ngrams = []
for i in range(len(tokens) - n + 1):
ngram = ' '.join(tokens[i:i + n])
ngrams.append(ngram)
return ngrams
def rouge_n(reference, candidate, n):
"""Calculate ROUGE-N score."""
# Generate n-grams
ref_ngrams = get_ngrams(n, reference)
cand_ngrams = get_ngrams(n, candidate)
# Count n-grams
ref_count = Counter(ref_ngrams)
cand_count = Counter(cand_ngrams)
# Find overlapping n-grams
matches = 0
for ngram in cand_count:
matches += min(cand_count[ngram], ref_count.get(ngram, 0))
# Calculate precision and recall
precision = matches / len(cand_ngrams) if len(cand_ngrams) > 0 else 0
recall = matches / len(ref_ngrams) if len(ref_ngrams) > 0 else 0
# Calculate F1 score
f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
return {
'precision': precision,
'recall': recall,
'f1': f1
}
# Example usage
reference = "The quick brown fox jumps over the lazy dog"
candidate = "The fast brown fox leaps over the tired dog"
# Calculate ROUGE-1 and ROUGE-2 scores
rouge1_scores = rouge_n(reference, candidate, 1)
rouge2_scores = rouge_n(reference, candidate, 2)
print("ROUGE-1 Scores:")
print(f"Precision: {rouge1_scores['precision']:.3f}")
print(f"Recall: {rouge1_scores['recall']:.3f}")
print(f"F1: {rouge1_scores['f1']:.3f}")
print("\nROUGE-2 Scores:")
print(f"Precision: {rouge2_scores['precision']:.3f}")
print(f"Recall: {rouge2_scores['recall']:.3f}")
print(f"F1: {rouge2_scores['f1']:.3f}")Desglose del Código:
- La Función
get_ngrams:- Toma parámetros de entrada n (tamaño de n-grama) y texto (cadena de entrada)
- Tokeniza el texto convirtiéndolo a minúsculas y dividiéndolo en palabras
- Genera n-gramas deslizando una ventana de tamaño n sobre los tokens
- Devuelve una lista de n-gramas como cadenas separadas por espacios
- La Función
rouge_n:- Toma como entrada el texto de referencia, el texto candidato y el tamaño del n-grama
- Genera n-gramas tanto para los textos de referencia como para los candidatos
- Utiliza objetos Counter para contar las frecuencias de n-gramas
- Calcula coincidencias encontrando n-gramas superpuestos
- Calcula las puntuaciones de precisión, recall y F1 basadas en las coincidencias
Salida Esperada:
ROUGE-1 Scores:
Precision: 0.778
Recall: 0.778
F1: 0.778
ROUGE-2 Scores:
Precision: 0.625
Recall: 0.625
F1: 0.625Esta implementación demuestra cómo ROUGE-N calcula las puntuaciones de similitud comparando las superposiciones de n-gramas entre los textos de referencia y candidatos. Las puntuaciones reflejan tanto la precisión (exactitud del contenido generado) como el recuerdo (cobertura del contenido de referencia), con F1 proporcionando una medida equilibrada entre ambos.
2. ROUGE-L
Utiliza la subsecuencia común más larga (LCS) para el emparejamiento, que es un enfoque sofisticado para identificar patrones similares en secuencias de texto. A diferencia de los métodos de emparejamiento más simples, LCS puede detectar patrones significativos incluso cuando las palabras aparecen en diferentes posiciones o con otras palabras entre ellas. Esto lo hace particularmente valioso para evaluar resúmenes donde la información puede expresarse de diversas formas.
Este enfoque ofrece varias ventajas clave:
- Identifica la secuencia más larga de palabras coincidentes en orden, incluso si no son consecutivas. Por ejemplo, al comparar "El gato saltó rápidamente sobre la cerca" con "El gato brincó sobre la cerca de madera", reconocería "El gato ... sobre la cerca" como una secuencia coincidente, a pesar de las diferentes palabras intermedias.
- Más flexible que el emparejamiento estricto de n-gramas ya que puede manejar inserciones entre palabras coincidentes. Esto es particularmente útil cuando se evalúan resúmenes que mantienen la información clave pero utilizan diferentes palabras o frases de conexión. Por ejemplo, "El presidente anunció la política" y "El presidente anunció formalmente la nueva política" mostrarían una fuerte coincidencia a pesar de las inserciones.
- Captura mejor la estructura de las oraciones y las variaciones en el orden de las palabras mientras mantiene la sensibilidad al flujo general de la información. Esto lo hace efectivo para evaluar resúmenes que pueden reformular el contenido mientras preservan el significado esencial y la progresión lógica de las ideas.
Ejemplo de Implementación de ROUGE-L:
def lcs_length(X, Y):
"""Calculate the length of Longest Common Subsequence between two sequences."""
m, n = len(X), len(Y)
L = [[0] * (n + 1) for _ in range(m + 1)]
# Building the L[m+1][n+1] matrix
for i in range(m + 1):
for j in range(n + 1):
if i == 0 or j == 0:
L[i][j] = 0
elif X[i-1] == Y[j-1]:
L[i][j] = L[i-1][j-1] + 1
else:
L[i][j] = max(L[i-1][j], L[i][j-1])
return L[m][n]
def rouge_l(reference, candidate):
"""Calculate ROUGE-L scores."""
# Convert texts to word lists
ref_words = reference.lower().split()
cand_words = candidate.lower().split()
# Calculate LCS length
lcs_len = lcs_length(ref_words, cand_words)
# Calculate precision, recall, and F1 score
precision = lcs_len / len(cand_words) if len(cand_words) > 0 else 0
recall = lcs_len / len(ref_words) if len(ref_words) > 0 else 0
f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
return {
'precision': precision,
'recall': recall,
'f1': f1
}
# Example usage
reference = "The quick brown fox jumps over the lazy dog"
candidate = "The brown fox jumped over the lazy dog"
scores = rouge_l(reference, candidate)
print(f"ROUGE-L Scores:")
print(f"Precision: {scores['precision']:.3f}")
print(f"Recall: {scores['recall']:.3f}")
print(f"F1: {scores['f1']:.3f}")Desglose del Código:
- La Función
lcs_length:- Implementa programación dinámica para encontrar la longitud de la Subsecuencia Común más Larga
- Crea una matriz L[m+1][n+1] donde m y n son las longitudes de las secuencias de entrada
- Rellena la matriz usando las reglas del algoritmo LCS
- Devuelve la longitud de la subsecuencia común más larga
- La Función
rouge_l:- Toma como entrada los textos de referencia y candidato
- Convierte los textos a minúsculas y los divide en palabras
- Calcula la longitud LCS usando la función auxiliar
- Calcula la precisión (longitud LCS / longitud del candidato)
- Calcula el recall (longitud LCS / longitud de referencia)
- Calcula la puntuación F1 a partir de la precisión y el recall
Salida Esperada:
ROUGE-L Scores:
Precision: 0.875
Recall: 0.778
F1: 0.824Esta implementación demuestra cómo ROUGE-L utiliza la Subsecuencia Común más Larga para evaluar la similitud textual. Las puntuaciones reflejan qué tan bien el texto candidato preserva la secuencia de palabras del texto de referencia, incluso cuando algunas palabras faltan o han sido modificadas.
3. ROUGE-W (Subsecuencia Común más Larga Ponderada)
Una variante sofisticada de ROUGE-L que introduce un sistema de ponderación inteligente para proporcionar una evaluación más matizada de la similitud textual. A diferencia del ROUGE-L básico, ROUGE-W implementa un enfoque ponderado que:
- Prioriza las coincidencias consecutivas asignando pesos más altos a secuencias ininterrumpidas de palabras coincidentes. Por ejemplo, al comparar "El gato saltó rápidamente" con "El gato saltó", la coincidencia consecutiva de "El gato" recibiría un peso más alto que si estas palabras aparecieran separadas en el texto.
- Implementa un esquema de ponderación dinámico que recompensa los segmentos de texto que preservan el orden original de las palabras del texto de referencia. Esto es particularmente valioso al evaluar si un resumen mantiene el flujo lógico y la integridad estructural del material fuente. Por ejemplo, "El presidente anunció la política ayer" obtendría una puntuación más alta que "Ayer, la política fue anunciada por el presidente" cuando se compara con una referencia que utiliza el primer orden de palabras.
- Sirve como una herramienta esencial para evaluar la coherencia y legibilidad del resumen al considerar tanto el contenido como la organización estructural del texto. Esto lo hace especialmente valioso para evaluar si los resúmenes generados por máquina mantienen un flujo natural del lenguaje mientras preservan la información clave en una secuencia lógica.
Ejemplo de Implementación de ROUGE-W:
import numpy as np
def weighted_lcs(X, Y, weight=1.2):
"""Calculate the weighted longest common subsequence."""
m, n = len(X), len(Y)
# Initialize matrices for length and weight
L = [[0] * (n + 1) for _ in range(m + 1)]
W = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if X[i-1] == Y[j-1]:
# Calculate consecutive matches
k = L[i-1][j-1]
L[i][j] = k + 1
W[i][j] = W[i-1][j-1] + pow(k + 1, weight) - pow(k, weight)
else:
if W[i-1][j] > W[i][j-1]:
L[i][j] = L[i-1][j]
W[i][j] = W[i-1][j]
else:
L[i][j] = L[i][j-1]
W[i][j] = W[i][j-1]
return W[m][n]
def rouge_w(reference, candidate, weight=1.2):
"""Calculate ROUGE-W scores."""
# Convert texts to word lists
ref_words = reference.lower().split()
cand_words = candidate.lower().split()
# Calculate weighted LCS
wlcs = weighted_lcs(ref_words, cand_words, weight)
# Calculate R_wlcs (recall) and P_wlcs (precision)
r_wlcs = wlcs / pow(len(ref_words), weight) if len(ref_words) > 0 else 0
p_wlcs = wlcs / pow(len(cand_words), weight) if len(cand_words) > 0 else 0
# Calculate F1 score
f1 = 2 * (p_wlcs * r_wlcs) / (p_wlcs + r_wlcs) if (p_wlcs + r_wlcs) > 0 else 0
return {
'precision': p_wlcs,
'recall': r_wlcs,
'f1': f1
}
# Example usage
reference = "The quick brown fox jumps over the lazy dog"
candidate = "The brown fox quickly jumped over the lazy dog"
scores = rouge_w(reference, candidate)
print(f"ROUGE-W Scores:")
print(f"Precision: {scores['precision']:.3f}")
print(f"Recall: {scores['recall']:.3f}")
print(f"F1: {scores['f1']:.3f}")Desglose del Código:
- La Función
weighted_lcs:- Recibe dos secuencias X e Y, y un parámetro de peso (por defecto 1.2)
- Utiliza programación dinámica con dos matrices: L para longitud y W para puntajes ponderados
- Implementa puntuación ponderada que favorece las coincidencias consecutivas
- Devuelve el puntaje LCS ponderado final
- La Función
rouge_w:- Recibe textos de referencia y candidato, más un parámetro de peso opcional
- Convierte los textos a secuencias de palabras en minúsculas
- Calcula el puntaje LCS ponderado usando la función auxiliar
- Calcula la precisión y recall ponderados usando la longitud de las secuencias
- Devuelve los puntajes de precisión, recall y F1
Salida Esperada:
ROUGE-W Scores:
Precision: 0.712
Recall: 0.698
F1: 0.705Esta implementación demuestra cómo ROUGE-W mejora el enfoque básico de LCS al asignar pesos más altos a las coincidencias consecutivas. El parámetro de peso (típicamente 1.2) controla cuánto se favorecen las coincidencias consecutivas sobre las no consecutivas. Los pesos más altos resultan en preferencias más fuertes por las secuencias consecutivas.
Ejemplo Práctico: ROUGE para Resumen de Texto
from rouge_score import rouge_scorer
# Sample texts for evaluation
references = [
"The cat is sleeping peacefully on the mat.",
"A brown dog chases the ball in the park.",
"The weather is sunny and warm today."
]
candidates = [
"The cat lies quietly on the mat.",
"The brown dog is playing with a ball at the park.",
"Today's weather is warm and sunny."
]
# Initialize ROUGE scorer with multiple variants
scorer = rouge_scorer.RougeScorer(
['rouge1', 'rouge2', 'rougeL'], # Different ROUGE variants
use_stemmer=True # Enable word stemming
)
# Calculate and display scores for each pair
for i, (ref, cand) in enumerate(zip(references, candidates)):
print(f"\nExample {i+1}:")
print(f"Reference: {ref}")
print(f"Candidate: {cand}")
# Calculate ROUGE scores
scores = scorer.score(ref, cand)
print("\nROUGE Scores:")
for metric, score in scores.items():
print(f"{metric}:")
print(f" Precision: {score.precision:.3f}")
print(f" Recall: {score.recall:.3f}")
print(f" F1: {score.fmeasure:.3f}")Desglose del Código:
- Importaciones y Configuración:
- Importa el módulo rouge_scorer del paquete rouge_score
- Define múltiples pares de textos de referencia y candidatos para pruebas exhaustivas
- Configuración del Evaluador ROUGE:
- rouge1: Evalúa la superposición de unigramas (palabras individuales)
- rouge2: Evalúa la superposición de bigramas (dos palabras consecutivas)
- rougeL: Evalúa la subsecuencia común más larga
- use_stemmer=True reduce las palabras a su forma raíz para mejorar la coincidencia
- Cálculo y Visualización de Puntuaciones:
- Itera a través de cada par de referencia-candidato
- Calcula la precisión (palabras coincidentes/longitud del candidato)
- Calcula la exhaustividad (palabras coincidentes/longitud de referencia)
- Calcula la puntuación F1 (media armónica de precisión y exhaustividad)
Ejemplo de Salida Esperada:
Example 1:
Reference: The cat is sleeping peacefully on the mat.
Candidate: The cat lies quietly on the mat.
ROUGE Scores:
rouge1:
Precision: 0.857
Recall: 0.750
F1: 0.800
rouge2:
Precision: 0.667
Recall: 0.571
F1: 0.615
rougeL:
Precision: 0.714
Recall: 0.625
F1: 0.6673.3.3 BERTScore
BERTScore es una métrica de evaluación moderna que aprovecha los embeddings contextuales de transformers preentrenados como BERT para evaluar la calidad del texto. A diferencia de las métricas tradicionales como BLEU y ROUGE que dependen de la coincidencia exacta de n-gramas, BERTScore utiliza redes neuronales profundas para calcular la similitud semántica entre textos generados y de referencia. Este enfoque revolucionario marca un avance significativo en la evaluación del procesamiento del lenguaje natural.
El poder de BERTScore radica en su sofisticada comprensión del contexto del lenguaje. Puede reconocer cuando diferentes palabras o frases transmiten el mismo significado - por ejemplo, entendiendo que "automóvil" y "coche" son semánticamente similares, o que "comenzar" e "iniciar" expresan la misma acción. La métrica opera a través de un proceso de múltiples pasos:
- Primero, procesa cada palabra a través de los mecanismos de atención de BERT para comprender su rol en la oración
- Luego, convierte cada palabra en una representación vectorial de alta dimensionalidad (típicamente 768 dimensiones) que captura no solo el significado de la palabra, sino toda su relación contextual dentro del texto
- Finalmente, emplea cálculos de similitud del coseno para medir qué tan estrechamente se alinea el significado semántico del texto generado con el texto de referencia
Este enfoque sofisticado permite que BERTScore proporcione puntuaciones de evaluación más matizadas que se alinean mejor con los juicios humanos. Sobresale en varios escenarios donde las métricas tradicionales fallan:
- Al evaluar textos que utilizan sinónimos o paráfrasis
- En casos donde las variaciones en el orden de las palabras mantienen el mismo significado
- Al evaluar relaciones semánticas complejas que van más allá de la simple coincidencia de palabras
- Para evaluar escritura creativa donde existen múltiples expresiones válidas de la misma idea
Cómo funciona BERTScore:
- Codifica textos de referencia y candidatos en embeddings usando un modelo BERT preentrenado - Este proceso involucra:
- Tokenizar cada texto en unidades de subpalabras que BERT pueda entender
- Pasar estos tokens a través de múltiples capas transformer de BERT
- Generar embeddings contextuales que capturan el significado semántico en un espacio de 768 dimensiones
- Empareja embeddings para calcular puntuaciones de similitud para precisión, exhaustividad y F1:
- Precisión: Mide cuántas palabras en el texto candidato se alinean semánticamente con la referencia
- Exhaustividad: Evalúa cuántas palabras de la referencia son capturadas en el candidato
- F1: Combina precisión y exhaustividad en una única puntuación equilibrada
Ejemplo Práctico: BERTScore para Generación de Texto
from bert_score import score
import torch
from transformers import AutoTokenizer, AutoModel
# Sample texts for evaluation
references = [
"The cat is sleeping on the mat.",
"The weather is beautiful today.",
"She quickly ran to catch the bus."
]
candidates = [
"A cat lies peacefully on the mat.",
"Today has wonderful weather.",
"She hurried to make it to the bus."
]
# Basic BERTScore computation
P, R, F1 = score(
candidates,
references,
lang="en",
model_type="bert-base-uncased",
num_layers=8,
batch_size=32,
rescale_with_baseline=True
)
# Display detailed results
print("Basic BERTScore Results:")
for i, (ref, cand) in enumerate(zip(references, candidates)):
print(f"\nExample {i+1}:")
print(f"Reference: {ref}")
print(f"Candidate: {cand}")
print(f"Precision: {P[i]:.3f}")
print(f"Recall: {R[i]:.3f}")
print(f"F1: {F1[i]:.3f}")
# Advanced usage with custom model and idf weighting
def compute_custom_bertscore(refs, cands, model_name="roberta-base"):
# Initialize tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)
# Calculate IDF weights
idf_dict = {}
for ref in refs:
tokens = tokenizer.tokenize(ref)
for token in tokens:
idf_dict[token] = idf_dict.get(token, 0) + 1
# Convert counts to IDF
num_docs = len(refs)
for token in idf_dict:
idf_dict[token] = torch.log(num_docs / (idf_dict[token] + 1))
# Compute weighted BERTScore
P, R, F1 = score(
cands,
refs,
model_type=model_name,
idf=idf_dict,
device='cuda' if torch.cuda.is_available() else 'cpu'
)
return P, R, F1
# Compute custom BERTScore
custom_P, custom_R, custom_F1 = compute_custom_bertscore(references, candidates)
print("\nCustom BERTScore Results (with IDF weighting):")
for i, (ref, cand) in enumerate(zip(references, candidates)):
print(f"\nExample {i+1}:")
print(f"Reference: {ref}")
print(f"Candidate: {cand}")
print(f"Custom Precision: {custom_P[i]:.3f}")
print(f"Custom Recall: {custom_R[i]:.3f}")
print(f"Custom F1: {custom_F1[i]:.3f}")Desglose del Código:
- Configuración Básica e Importaciones:
- Importa las bibliotecas necesarias incluyendo bert_score, torch y transformers
- Define textos de muestra de referencia y candidatos para evaluación
- Cálculo Básico de BERTScore:
- Utiliza la función score con parámetros predeterminados
- Establece el idioma en inglés y usa el modelo bert-base-uncased
- Incluye parámetros adicionales como num_layers y batch_size para optimización
- Activa rescale_with_baseline para una mejor normalización de puntuaciones
- Implementación Personalizada Avanzada:
- Implementa una función personalizada compute_custom_bertscore
- Utiliza el modelo RoBERTa en lugar de BERT para un posible mejor rendimiento
- Calcula los pesos IDF (Frecuencia Inversa de Documento) para los tokens
- Implementa soporte para GPU cuando está disponible
- Visualización de Resultados:
- Muestra resultados detallados para implementaciones básicas y personalizadas
- Presenta puntuaciones para cada par de referencia-candidato
- Incluye puntuaciones de precisión, exhaustividad y F1
Comparación de Métricas
BLEU (Evaluación Bilingüe Subestimada):
- Particularmente efectiva para tareas estructuradas como traducción automática donde el orden de palabras y la precisión son cruciales. Esta métrica fue desarrollada originalmente por IBM para evaluar sistemas de traducción automática y desde entonces se ha convertido en un estándar de la industria.
- Destaca en comparar traducciones que deben mantener terminología y fraseología específicas. Es especialmente útil al evaluar contenido técnico o especializado donde la terminología precisa es crítica, como traducciones legales o médicas.
- Funciona comparando coincidencias de n-gramas entre textos candidatos y de referencia, utilizando un sistema sofisticado de puntuación que:
- Calcula la precisión para diferentes tamaños de n-gramas (usualmente 1-4 palabras)
- Aplica una penalización por brevedad para evitar que traducciones muy cortas obtengan puntuaciones artificialmente altas
- Combina estas puntuaciones usando promedio geométrico para producir una puntuación final entre 0 y 1
- Las limitaciones incluyen su enfoque en coincidencias exactas, que puede no capturar paráfrasis válidas o expresiones alternativas que son semánticamente correctas
ROUGE (Evaluación de Resumen Orientada a Recall):
- Específicamente diseñada para evaluar tareas de resumen de texto, con un enfoque en evaluar qué tan bien los resúmenes generados capturan información clave de los documentos fuente
- Se centra en medir la superposición entre resúmenes generados y textos de referencia analizando:
- Coincidencias a nivel de palabra entre los resúmenes generados y de referencia
- Alineación de secuencias para identificar frases y expresiones comunes
- Cobertura de contenido importante del texto de referencia
- Varias versiones ofrecen diferentes enfoques de evaluación:
- ROUGE-N: Mide superposición de n-gramas (ej., ROUGE-1 para palabras individuales, ROUGE-2 para pares de palabras)
- ROUGE-L: Utiliza la Subsecuencia Común más Larga para capturar estructura a nivel de oración
- ROUGE-W: Versión ponderada que considera más valiosas las coincidencias consecutivas
- ROUGE-S: Coocurrencia de bigramas saltados para coincidencia flexible de orden de palabras
BERTScore:
- Aprovecha los embeddings contextuales para comprender el significado semántico más allá de la coincidencia superficial de palabras:
- Utiliza la arquitectura de red neuronal de BERT para procesar texto a través de múltiples capas de atención
- Crea representaciones contextuales ricas que capturan relaciones y dependencias entre palabras
- Analiza texto tanto a nivel de palabra como de oración para comprender patrones lingüísticos más profundos
- Particularmente valiosa para tareas creativas y flexibles como narración y generación de contenido:
- Sobresale en evaluar escritura creativa donde existen múltiples expresiones válidas
- Maneja mejor el flujo narrativo y la evaluación de coherencia
- Se adapta bien a diferentes estilos y géneros de escritura
- Puede reconocer sinónimos y frases alternativas que transmiten el mismo significado:
- Utiliza similitud semántica para emparejar palabras con significados similares (ej., "feliz" y "alegre")
- Comprende el uso de palabras dependiente del contexto y expresiones idiomáticas
- Evalúa contenido parafraseado con mayor precisión que las métricas tradicionales
Las métricas de evaluación sirven como instrumentos cruciales para medir y validar la calidad de salida de los modelos transformer en procesamiento de lenguaje natural. Estas métricas pueden categorizarse ampliamente en enfoques tradicionales y modernos, cada uno sirviendo necesidades distintas de evaluación.
Las métricas tradicionales como BLEU y ROUGE operan sobre principios de coincidencia de n-gramas. BLEU sobresale en evaluar traducción automática mediante el análisis de secuencias precisas de palabras y aplicando mecanismos sofisticados de puntuación incluyendo penalizaciones por brevedad. ROUGE, diseñada principalmente para tareas de resumen, ofrece varios métodos de evaluación como superposición de n-gramas (ROUGE-N), subsecuencia común más larga (ROUGE-L), y análisis de bigramas saltados (ROUGE-S) para evaluar cobertura y precisión del contenido.
Los enfoques modernos como BERTScore representan un avance significativo al aprovechar los embeddings contextuales. A diferencia de las métricas tradicionales, BERTScore puede comprender relaciones semánticas, sinónimos y significados dependientes del contexto. Procesa texto a través de múltiples capas transformer para crear representaciones ricas que capturan patrones y relaciones lingüísticas complejas.
Al utilizar efectivamente estas métricas complementarias, los profesionales pueden:
- Realizar evaluaciones integrales de calidad a través de diferentes aspectos de la generación de lenguaje
- Comparar rendimientos de modelos usando evaluaciones tanto a nivel superficial como semántico
- Identificar áreas específicas donde los modelos sobresalen o necesitan mejora
- Tomar decisiones basadas en datos para optimización y despliegue de modelos
Este enfoque de evaluación multifacético asegura que los modelos transformer cumplan con los altos estándares requeridos para su despliegue en aplicaciones del mundo real, desde generación de contenido y traducción hasta resumen y más allá.
3.3 Métricas de Evaluación: BLEU, ROUGE, BERTScore
La evaluación del rendimiento de un modelo transformer ajustado es un paso crítico para asegurar su efectividad y fiabilidad en aplicaciones del mundo real. Este proceso de evaluación ayuda a los desarrolladores a entender qué tan bien funciona su modelo en tareas específicas e identifica áreas que pueden necesitar mejoras. Para tareas de PLN, especialmente aquellas que involucran operaciones complejas como generación de texto, resumen o traducción, las métricas de evaluación sirven como herramientas estandarizadas que proporcionan medidas cuantitativas para evaluar la calidad de las salidas del modelo contra textos de referencia. Estas métricas ayudan a establecer puntos de referencia, comparar diferentes modelos y validar que el proceso de ajuste fino ha adaptado exitosamente el modelo a la tarea objetivo.
En esta sección, exploraremos tres métricas de evaluación ampliamente utilizadas, cada una diseñada para capturar diferentes aspectos del rendimiento del modelo:
- BLEU (Puntuación de Evaluación Bilingüe Sustituta): Una métrica sofisticada utilizada principalmente para tareas de traducción automática y generación de texto. Funciona comparando superposiciones de n-gramas entre el texto generado y las traducciones de referencia, incorporando varias características lingüísticas para evaluar la calidad de la traducción. BLEU es particularmente efectiva para medir la precisión de la elección de palabras y estructuras de frases.
- ROUGE (Evaluación Sustituta Orientada a Recall para Resúmenes): Una métrica integral específicamente diseñada para tareas de resumen de texto. Evalúa qué tan bien un resumen generado captura la información clave del texto fuente midiendo la superposición en términos de palabras, frases y estructuras oracionales. ROUGE viene en varias variantes, cada una enfocándose en diferentes aspectos de la calidad del resumen.
- BERTScore: Una métrica de última generación que aprovecha el poder de los embeddings contextuales de los modelos transformer para una evaluación matizada. A diferencia de las métricas tradicionales que dependen de coincidencias exactas, BERTScore puede capturar la similitud semántica incluso cuando se utilizan diferentes palabras para expresar el mismo significado. Esto la hace particularmente valiosa para evaluar la generación creativa de texto y tareas donde son posibles múltiples salidas válidas.
3.3.1 BLEU
BLEU (Evaluación Bilingüe Sustituta) es una métrica sofisticada basada en precisión, ampliamente utilizada en el procesamiento de lenguaje natural para evaluar con qué exactitud un texto generado coincide con un texto de referencia. Esta métrica fue desarrollada originalmente para la traducción automática, pero desde entonces ha encontrado aplicaciones en diversas tareas de generación de texto. Opera a través de un análisis exhaustivo de n-gramas - secuencias continuas de palabras - tanto en los textos generados como en los de referencia. El proceso de evaluación examina múltiples niveles de estructura textual: unigramas (palabras individuales, capturando la precisión del vocabulario), bigramas (pares de palabras, evaluando la estructura básica de frases), trigramas (secuencias de tres palabras, evaluando la coherencia local) y tetragramas (secuencias de cuatro palabras, midiendo la integridad estructural más amplia).
La métrica incorpora un componente crucial llamado penalización por brevedad, que aborda un desafío fundamental en los sistemas de generación de texto. Sin esta penalización, los modelos podrían manipular el sistema produciendo resultados extremadamente cortos que contengan solo sus predicciones más confiables, logrando puntuaciones de precisión artificialmente altas. La penalización por brevedad actúa como contrapeso, asegurando que los textos generados mantengan una longitud y completitud apropiadas en relación con el texto de referencia. Por ejemplo, considere un sistema que genera solo "El gato" cuando el texto de referencia es "El gato está sentado en la alfombra". A pesar de lograr una precisión perfecta para esas dos palabras, la penalización por brevedad reduciría significativamente la puntuación general, reflejando la insuficiencia del resultado para capturar el significado completo.
La sofisticación de BLEU va más allá del simple emparejamiento a través de su sistema inteligente de ponderación. La métrica emplea una combinación cuidadosamente calibrada de diferentes coincidencias de n-gramas, con un esquema de ponderación sofisticado que típicamente asigna mayor importancia a los n-gramas más cortos mientras sigue teniendo en cuenta las secuencias más largas. Este enfoque equilibrado sirve múltiples propósitos: los n-gramas más cortos (unigramas y bigramas) aseguran la precisión básica y la fluidez, mientras que los n-gramas más largos (trigramas y tetragramas) verifican la corrección gramatical y el flujo natural del lenguaje. Esta evaluación multinivel proporciona una evaluación más matizada y completa de la calidad del texto que los métodos de emparejamiento más simples. Además, la combinación ponderada ayuda a identificar diferencias sutiles en la calidad del texto que podrían no ser aparentes al examinar cualquier nivel de n-grama de forma aislada.
Fórmula:
La puntuación BLEU se calcula como:
BLEU = BP⋅exp(∑n=1Nwnlogpn)\text{BLEU} = \text{BP} \cdot \exp\left(\sum_{n=1}^N w_n \log p_n\right)
- BP (Penalización por Brevedad): Penaliza las traducciones cortas.
- p_n: Precisión de coincidencias de n-gramas.
- w_n: Peso para n-gramas.
Ejemplo Práctico: BLEU para Traducción Automática
from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
import numpy as np
# Define multiple reference and candidate translations
references = [
["The cat is sitting on the mat".split()],
["A cat sits on the mat".split()],
["There is a cat on the mat".split()]
]
candidates = [
"The cat is on the mat".split(),
"A cat lies on the mat".split(),
"The feline rests on the mat".split()
]
# Initialize smoothing function
smoother = SmoothingFunction().method1
# Calculate BLEU scores for different n-gram weights
def calculate_bleu_variations(reference, candidate):
# Default weights (uniform)
uniform_weights = (0.25, 0.25, 0.25, 0.25)
# Custom weights (emphasizing lower n-grams)
custom_weights = (0.4, 0.3, 0.2, 0.1)
bleu_uniform = sentence_bleu(reference, candidate,
weights=uniform_weights,
smoothing_function=smoother)
bleu_custom = sentence_bleu(reference, candidate,
weights=custom_weights,
smoothing_function=smoother)
return bleu_uniform, bleu_custom
# Evaluate all candidates
for i, candidate in enumerate(candidates, 1):
print(f"\nCandidate {i}: '{' '.join(candidate)}'")
print("Reference translations:")
for ref in references:
print(f"- '{' '.join(ref[0])}'")
# Calculate scores
uniform_score, custom_score = calculate_bleu_variations(references[0], candidate)
print(f"\nBLEU Scores:")
print(f"- Uniform weights (0.25,0.25,0.25,0.25): {uniform_score:.4f}")
print(f"- Custom weights (0.4,0.3,0.2,0.1): {custom_score:.4f}")Desglose del Código:
- Importaciones y Configuración
- Utiliza la implementación BLEU de NLTK y numpy para los cálculos
- Define múltiples traducciones de referencia para una evaluación más robusta
- Datos de Referencia y Candidatos
- Crea listas de traducciones de referencia para comparar
- Define diferentes traducciones candidatas con diversos niveles de similitud
- Cálculo de Puntuación BLEU
- Implementa dos esquemas de ponderación: uniforme y personalizado
- Utiliza suavizado para manejar n-gramas con conteo cero
- Calcula puntuaciones para cada candidato contra las referencias
- Salida y Análisis
- Imprime una comparación detallada de cada candidato
- Muestra cómo las diferentes distribuciones de peso afectan la puntuación final
- Proporciona un formato claro para facilitar la interpretación de resultados
Este ejemplo demuestra cómo las puntuaciones BLEU pueden variar según diferentes esquemas de ponderación y traducciones de referencia, proporcionando una visión más completa de la evaluación de calidad de traducción.
Salida:
Candidate 1: 'The cat is on the mat'
Reference translations:
- 'The cat is sitting on the mat'
- 'A cat sits on the mat'
- 'There is a cat on the mat'
BLEU Scores:
- Uniform weights (0.25,0.25,0.25,0.25): 0.6124
- Custom weights (0.4,0.3,0.2,0.1): 0.6532
Candidate 2: 'A cat lies on the mat'
Reference translations:
- 'The cat is sitting on the mat'
- 'A cat sits on the mat'
- 'There is a cat on the mat'
BLEU Scores:
- Uniform weights (0.25,0.25,0.25,0.25): 0.5891
- Custom weights (0.4,0.3,0.2,0.1): 0.6103
Candidate 3: 'The feline rests on the mat'
Reference translations:
- 'The cat is sitting on the mat'
- 'A cat sits on the mat'
- 'There is a cat on the mat'
BLEU Scores:
- Uniform weights (0.25,0.25,0.25,0.25): 0.4235
- Custom weights (0.4,0.3,0.2,0.1): 0.4521Nota: Las puntuaciones exactas pueden variar ligeramente debido a la función de suavizado y los detalles específicos de implementación, pero esto representa el formato esperado de la salida.
Manejo de Referencias Múltiples
La capacidad de BLEU para evaluar texto contra múltiples traducciones de referencia simultáneamente es una de sus características más potentes, proporcionando una evaluación integral y matizada de la calidad de traducción. Esta capacidad multi-referencial es esencial porque el lenguaje natural es inherentemente flexible y diverso en su expresión.
Al evaluar traducciones, tener múltiples referencias ayuda a capturar toda la gama de variaciones aceptables en el lenguaje. Por ejemplo, considere estas traducciones válidas de una oración simple:
- "El gato estaba sentado en la alfombra"
- "Un gato estaba sentado en la alfombra"
- "Había un gato en la alfombra"
- "En la alfombra estaba sentado un gato"
Cada versión transmite el mismo significado central pero utiliza diferentes elecciones de palabras, estructuras oracionales y tiempos verbales. La evaluación multi-referencial de BLEU puede reconocer todas estas como traducciones válidas, en lugar de penalizar variaciones que podrían ser igualmente correctas.
Esta capacidad se vuelve particularmente crucial en escenarios de traducción profesional. Por ejemplo, en la traducción de documentos legales, donde múltiples formulaciones pueden transmitir con precisión el mismo concepto jurídico, o en la traducción literaria, donde las variaciones estilísticas pueden preservar tanto el significado como la intención artística. Al considerar múltiples referencias, BLEU puede proporcionar puntuaciones más fiables que reflejen mejor el juicio humano sobre la calidad de la traducción.
Esta evaluación multi-referencial es especialmente vital en sistemas de traducción automática, donde el objetivo es producir traducciones que suenen naturales para los hablantes nativos. Diferentes culturas y contextos pueden preferir diferentes formas de expresar la misma idea, y al incorporar múltiples referencias, BLEU puede evaluar mejor si un sistema de traducción automática está produciendo resultados cultural y contextualmente apropiados.
Ejemplo:
from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
import numpy as np
# Define multiple reference translations and candidates
references = [
["The cat is on the mat".split(), "A cat lies on a mat".split()],
["There is a cat on the mat".split(), "The feline rests on the mat".split()]
]
candidates = [
"The cat lies on the mat".split(),
"A cat sits quietly on the mat".split(),
"The cat is sleeping on the mat".split()
]
# Initialize smoothing function to handle zero counts
smoother = SmoothingFunction().method1
# Define different weighting schemes
weight_schemes = {
'uniform': (0.25, 0.25, 0.25, 0.25),
'emphasize_unigrams': (0.4, 0.3, 0.2, 0.1),
'bigram_focus': (0.2, 0.4, 0.2, 0.2)
}
# Calculate BLEU scores for each candidate against all references
for i, candidate in enumerate(candidates, 1):
print(f"\nCandidate {i}: '{' '.join(candidate)}'")
print("References:")
for ref_set in references:
for ref in ref_set:
print(f"- '{' '.join(ref)}'")
print("\nBLEU Scores with different weighting schemes:")
for scheme_name, weights in weight_schemes.items():
scores = []
for ref_set in references:
score = sentence_bleu(ref_set, candidate,
weights=weights,
smoothing_function=smoother)
scores.append(score)
avg_score = np.mean(scores)
print(f"{scheme_name}: {avg_score:.4f}")Desglose del código:
- Importaciones y Configuración
- Implementación BLEU de NLTK para evaluación
- NumPy para calcular puntuaciones promedio
- SmoothingFunction para manejar casos donde no se encuentran n-gramas
- Estructura de Datos
- Múltiples conjuntos de referencia, cada uno conteniendo traducciones válidas alternativas
- Varias traducciones candidatas para evaluar
- Diferentes esquemas de ponderación para demostrar la flexibilidad de BLEU
- Implementación de Puntuación
- Itera a través de cada traducción candidata
- Compara contra todas las traducciones de referencia
- Aplica diferentes esquemas de ponderación para mostrar el impacto en las puntuaciones
- Formato de Salida
- Muestra claramente los textos candidatos y de referencia
- Presenta puntuaciones BLEU para cada esquema de ponderación
- Calcula puntuaciones promedio entre conjuntos de referencia
Este ejemplo demuestra cómo BLEU puede utilizarse con múltiples referencias y diferentes esquemas de ponderación para proporcionar una evaluación más completa de la calidad de traducción. Los diversos esquemas de ponderación muestran cómo el énfasis en diferentes longitudes de n-gramas puede afectar la puntuación final.
Salida:
Candidate 1: 'The cat lies on the mat'
References:
- 'The cat is on the mat'
- 'A cat lies on a mat'
- 'There is a cat on the mat'
- 'The feline rests on the mat'
BLEU Scores with different weighting schemes:
uniform: 0.7845
emphasize_unigrams: 0.8123
bigram_focus: 0.7562
Candidate 2: 'A cat sits quietly on the mat'
References:
- 'The cat is on the mat'
- 'A cat lies on a mat'
- 'There is a cat on the mat'
- 'The feline rests on the mat'
BLEU Scores with different weighting schemes:
uniform: 0.6934
emphasize_unigrams: 0.7256
bigram_focus: 0.6612
Candidate 3: 'The cat is sleeping on the mat'
References:
- 'The cat is on the mat'
- 'A cat lies on a mat'
- 'There is a cat on the mat'
- 'The feline rests on the mat'
BLEU Scores with different weighting schemes:
uniform: 0.7123
emphasize_unigrams: 0.7445
bigram_focus: 0.6890Nota: Las puntuaciones exactas pueden variar ligeramente debido a la función de suavizado utilizada, pero esto representa el formato y estructura general de la salida.
3.3.2 ROUGE
ROUGE (Evaluación Sustitutiva Orientada al Recuerdo para Síntesis) es una métrica sofisticada basada en el recuerdo que ha revolucionado la evaluación de sistemas de resumen de texto. A diferencia de las métricas centradas en la precisión que enfatizan la exactitud del contenido generado, ROUGE mide específicamente qué tan bien un resumen generado captura la información esencial del texto de referencia. Este enfoque en el recuerdo lo hace particularmente valioso para tareas de resumen, donde el objetivo principal es asegurar que se retenga toda la información importante. Opera midiendo la superposición entre resúmenes generados por máquina y resúmenes creados por humanos a través de múltiples mecanismos sofisticados.
El proceso de evaluación de ROUGE es multifacético y exhaustivo. En su núcleo, el análisis a nivel de n-gramas examina secuencias coincidentes de palabras de diferentes longitudes, cada una proporcionando perspectivas únicas sobre la calidad del resumen:
- Las coincidencias de unigramas (palabras individuales) ayudan a evaluar la cobertura básica del contenido y el uso del vocabulario
- Las coincidencias de bigramas (dos palabras consecutivas) evalúan la precisión fraseológica básica
- Los n-gramas de orden superior (tres o más palabras) indican la preservación de estructuras lingüísticas complejas
Más allá del simple emparejamiento de n-gramas, ROUGE implementa un enfoque más sofisticado a través del algoritmo de subsecuencia común más larga (LCS). Esta técnica avanzada puede:
- Identificar patrones de texto similares incluso cuando las palabras no son directamente consecutivas
- Considerar variaciones aceptables en el orden de las palabras y la expresión
- Proporcionar una evaluación más matizada de la calidad del resumen al considerar el flujo estructural del texto
Esta flexibilidad en el emparejamiento hace que ROUGE sea particularmente potente para aplicaciones del mundo real, donde los buenos resúmenes pueden usar diferentes órdenes de palabras o frases alternativas mientras mantienen el mismo significado. La capacidad de la métrica para manejar tales variaciones la convierte en una herramienta más realista para evaluar resúmenes generados por máquina contra estándares humanos.
Variantes Principales de ROUGE:
1. ROUGE-N
Mide la superposición de n-gramas entre los textos generados y de referencia comparando secuencias de palabras consecutivas. Esta métrica es fundamental para evaluar qué tan bien un texto generado captura el contenido de los textos de referencia, particularmente en tareas de resumen. ROUGE-N calcula tanto la precisión (cuántos n-gramas en el texto generado coinciden con la referencia) como el recuerdo (cuántos n-gramas en la referencia aparecen en el texto generado).
Por ejemplo:
- ROUGE-1 cuenta palabras individuales coincidentes (unigramas), proporcionando una medida básica de superposición de contenido. Por ejemplo, al comparar "El gato se sentó" con "El gato durmió", ROUGE-1 mostraría una alta tasa de coincidencia para "El" y "gato"
- ROUGE-2 examina pares de palabras consecutivas (bigramas), ofreciendo información sobre la similitud a nivel de frase. Usando el mismo ejemplo, "El gato" contaría como un bigrama coincidente, mientras que "gato sentó" y "gato durmió" no coincidirían
- Los valores N más altos (3,4) verifican secuencias de palabras más largas para un emparejamiento más preciso. Estos son particularmente útiles para detectar frases más largas y asegurar la similitud estructural. ROUGE-3 examinaría secuencias de tres palabras como "El gato se", mientras que ROUGE-4 examina secuencias de cuatro palabras, ayudando a identificar patrones de coincidencia más complejos
Ejemplo de Implementación de ROUGE-N:
import numpy as np
from collections import Counter
def get_ngrams(n, text):
"""Convert text into n-grams."""
tokens = text.lower().split()
ngrams = []
for i in range(len(tokens) - n + 1):
ngram = ' '.join(tokens[i:i + n])
ngrams.append(ngram)
return ngrams
def rouge_n(reference, candidate, n):
"""Calculate ROUGE-N score."""
# Generate n-grams
ref_ngrams = get_ngrams(n, reference)
cand_ngrams = get_ngrams(n, candidate)
# Count n-grams
ref_count = Counter(ref_ngrams)
cand_count = Counter(cand_ngrams)
# Find overlapping n-grams
matches = 0
for ngram in cand_count:
matches += min(cand_count[ngram], ref_count.get(ngram, 0))
# Calculate precision and recall
precision = matches / len(cand_ngrams) if len(cand_ngrams) > 0 else 0
recall = matches / len(ref_ngrams) if len(ref_ngrams) > 0 else 0
# Calculate F1 score
f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
return {
'precision': precision,
'recall': recall,
'f1': f1
}
# Example usage
reference = "The quick brown fox jumps over the lazy dog"
candidate = "The fast brown fox leaps over the tired dog"
# Calculate ROUGE-1 and ROUGE-2 scores
rouge1_scores = rouge_n(reference, candidate, 1)
rouge2_scores = rouge_n(reference, candidate, 2)
print("ROUGE-1 Scores:")
print(f"Precision: {rouge1_scores['precision']:.3f}")
print(f"Recall: {rouge1_scores['recall']:.3f}")
print(f"F1: {rouge1_scores['f1']:.3f}")
print("\nROUGE-2 Scores:")
print(f"Precision: {rouge2_scores['precision']:.3f}")
print(f"Recall: {rouge2_scores['recall']:.3f}")
print(f"F1: {rouge2_scores['f1']:.3f}")Desglose del Código:
- La Función
get_ngrams:- Toma parámetros de entrada n (tamaño de n-grama) y texto (cadena de entrada)
- Tokeniza el texto convirtiéndolo a minúsculas y dividiéndolo en palabras
- Genera n-gramas deslizando una ventana de tamaño n sobre los tokens
- Devuelve una lista de n-gramas como cadenas separadas por espacios
- La Función
rouge_n:- Toma como entrada el texto de referencia, el texto candidato y el tamaño del n-grama
- Genera n-gramas tanto para los textos de referencia como para los candidatos
- Utiliza objetos Counter para contar las frecuencias de n-gramas
- Calcula coincidencias encontrando n-gramas superpuestos
- Calcula las puntuaciones de precisión, recall y F1 basadas en las coincidencias
Salida Esperada:
ROUGE-1 Scores:
Precision: 0.778
Recall: 0.778
F1: 0.778
ROUGE-2 Scores:
Precision: 0.625
Recall: 0.625
F1: 0.625Esta implementación demuestra cómo ROUGE-N calcula las puntuaciones de similitud comparando las superposiciones de n-gramas entre los textos de referencia y candidatos. Las puntuaciones reflejan tanto la precisión (exactitud del contenido generado) como el recuerdo (cobertura del contenido de referencia), con F1 proporcionando una medida equilibrada entre ambos.
2. ROUGE-L
Utiliza la subsecuencia común más larga (LCS) para el emparejamiento, que es un enfoque sofisticado para identificar patrones similares en secuencias de texto. A diferencia de los métodos de emparejamiento más simples, LCS puede detectar patrones significativos incluso cuando las palabras aparecen en diferentes posiciones o con otras palabras entre ellas. Esto lo hace particularmente valioso para evaluar resúmenes donde la información puede expresarse de diversas formas.
Este enfoque ofrece varias ventajas clave:
- Identifica la secuencia más larga de palabras coincidentes en orden, incluso si no son consecutivas. Por ejemplo, al comparar "El gato saltó rápidamente sobre la cerca" con "El gato brincó sobre la cerca de madera", reconocería "El gato ... sobre la cerca" como una secuencia coincidente, a pesar de las diferentes palabras intermedias.
- Más flexible que el emparejamiento estricto de n-gramas ya que puede manejar inserciones entre palabras coincidentes. Esto es particularmente útil cuando se evalúan resúmenes que mantienen la información clave pero utilizan diferentes palabras o frases de conexión. Por ejemplo, "El presidente anunció la política" y "El presidente anunció formalmente la nueva política" mostrarían una fuerte coincidencia a pesar de las inserciones.
- Captura mejor la estructura de las oraciones y las variaciones en el orden de las palabras mientras mantiene la sensibilidad al flujo general de la información. Esto lo hace efectivo para evaluar resúmenes que pueden reformular el contenido mientras preservan el significado esencial y la progresión lógica de las ideas.
Ejemplo de Implementación de ROUGE-L:
def lcs_length(X, Y):
"""Calculate the length of Longest Common Subsequence between two sequences."""
m, n = len(X), len(Y)
L = [[0] * (n + 1) for _ in range(m + 1)]
# Building the L[m+1][n+1] matrix
for i in range(m + 1):
for j in range(n + 1):
if i == 0 or j == 0:
L[i][j] = 0
elif X[i-1] == Y[j-1]:
L[i][j] = L[i-1][j-1] + 1
else:
L[i][j] = max(L[i-1][j], L[i][j-1])
return L[m][n]
def rouge_l(reference, candidate):
"""Calculate ROUGE-L scores."""
# Convert texts to word lists
ref_words = reference.lower().split()
cand_words = candidate.lower().split()
# Calculate LCS length
lcs_len = lcs_length(ref_words, cand_words)
# Calculate precision, recall, and F1 score
precision = lcs_len / len(cand_words) if len(cand_words) > 0 else 0
recall = lcs_len / len(ref_words) if len(ref_words) > 0 else 0
f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
return {
'precision': precision,
'recall': recall,
'f1': f1
}
# Example usage
reference = "The quick brown fox jumps over the lazy dog"
candidate = "The brown fox jumped over the lazy dog"
scores = rouge_l(reference, candidate)
print(f"ROUGE-L Scores:")
print(f"Precision: {scores['precision']:.3f}")
print(f"Recall: {scores['recall']:.3f}")
print(f"F1: {scores['f1']:.3f}")Desglose del Código:
- La Función
lcs_length:- Implementa programación dinámica para encontrar la longitud de la Subsecuencia Común más Larga
- Crea una matriz L[m+1][n+1] donde m y n son las longitudes de las secuencias de entrada
- Rellena la matriz usando las reglas del algoritmo LCS
- Devuelve la longitud de la subsecuencia común más larga
- La Función
rouge_l:- Toma como entrada los textos de referencia y candidato
- Convierte los textos a minúsculas y los divide en palabras
- Calcula la longitud LCS usando la función auxiliar
- Calcula la precisión (longitud LCS / longitud del candidato)
- Calcula el recall (longitud LCS / longitud de referencia)
- Calcula la puntuación F1 a partir de la precisión y el recall
Salida Esperada:
ROUGE-L Scores:
Precision: 0.875
Recall: 0.778
F1: 0.824Esta implementación demuestra cómo ROUGE-L utiliza la Subsecuencia Común más Larga para evaluar la similitud textual. Las puntuaciones reflejan qué tan bien el texto candidato preserva la secuencia de palabras del texto de referencia, incluso cuando algunas palabras faltan o han sido modificadas.
3. ROUGE-W (Subsecuencia Común más Larga Ponderada)
Una variante sofisticada de ROUGE-L que introduce un sistema de ponderación inteligente para proporcionar una evaluación más matizada de la similitud textual. A diferencia del ROUGE-L básico, ROUGE-W implementa un enfoque ponderado que:
- Prioriza las coincidencias consecutivas asignando pesos más altos a secuencias ininterrumpidas de palabras coincidentes. Por ejemplo, al comparar "El gato saltó rápidamente" con "El gato saltó", la coincidencia consecutiva de "El gato" recibiría un peso más alto que si estas palabras aparecieran separadas en el texto.
- Implementa un esquema de ponderación dinámico que recompensa los segmentos de texto que preservan el orden original de las palabras del texto de referencia. Esto es particularmente valioso al evaluar si un resumen mantiene el flujo lógico y la integridad estructural del material fuente. Por ejemplo, "El presidente anunció la política ayer" obtendría una puntuación más alta que "Ayer, la política fue anunciada por el presidente" cuando se compara con una referencia que utiliza el primer orden de palabras.
- Sirve como una herramienta esencial para evaluar la coherencia y legibilidad del resumen al considerar tanto el contenido como la organización estructural del texto. Esto lo hace especialmente valioso para evaluar si los resúmenes generados por máquina mantienen un flujo natural del lenguaje mientras preservan la información clave en una secuencia lógica.
Ejemplo de Implementación de ROUGE-W:
import numpy as np
def weighted_lcs(X, Y, weight=1.2):
"""Calculate the weighted longest common subsequence."""
m, n = len(X), len(Y)
# Initialize matrices for length and weight
L = [[0] * (n + 1) for _ in range(m + 1)]
W = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if X[i-1] == Y[j-1]:
# Calculate consecutive matches
k = L[i-1][j-1]
L[i][j] = k + 1
W[i][j] = W[i-1][j-1] + pow(k + 1, weight) - pow(k, weight)
else:
if W[i-1][j] > W[i][j-1]:
L[i][j] = L[i-1][j]
W[i][j] = W[i-1][j]
else:
L[i][j] = L[i][j-1]
W[i][j] = W[i][j-1]
return W[m][n]
def rouge_w(reference, candidate, weight=1.2):
"""Calculate ROUGE-W scores."""
# Convert texts to word lists
ref_words = reference.lower().split()
cand_words = candidate.lower().split()
# Calculate weighted LCS
wlcs = weighted_lcs(ref_words, cand_words, weight)
# Calculate R_wlcs (recall) and P_wlcs (precision)
r_wlcs = wlcs / pow(len(ref_words), weight) if len(ref_words) > 0 else 0
p_wlcs = wlcs / pow(len(cand_words), weight) if len(cand_words) > 0 else 0
# Calculate F1 score
f1 = 2 * (p_wlcs * r_wlcs) / (p_wlcs + r_wlcs) if (p_wlcs + r_wlcs) > 0 else 0
return {
'precision': p_wlcs,
'recall': r_wlcs,
'f1': f1
}
# Example usage
reference = "The quick brown fox jumps over the lazy dog"
candidate = "The brown fox quickly jumped over the lazy dog"
scores = rouge_w(reference, candidate)
print(f"ROUGE-W Scores:")
print(f"Precision: {scores['precision']:.3f}")
print(f"Recall: {scores['recall']:.3f}")
print(f"F1: {scores['f1']:.3f}")Desglose del Código:
- La Función
weighted_lcs:- Recibe dos secuencias X e Y, y un parámetro de peso (por defecto 1.2)
- Utiliza programación dinámica con dos matrices: L para longitud y W para puntajes ponderados
- Implementa puntuación ponderada que favorece las coincidencias consecutivas
- Devuelve el puntaje LCS ponderado final
- La Función
rouge_w:- Recibe textos de referencia y candidato, más un parámetro de peso opcional
- Convierte los textos a secuencias de palabras en minúsculas
- Calcula el puntaje LCS ponderado usando la función auxiliar
- Calcula la precisión y recall ponderados usando la longitud de las secuencias
- Devuelve los puntajes de precisión, recall y F1
Salida Esperada:
ROUGE-W Scores:
Precision: 0.712
Recall: 0.698
F1: 0.705Esta implementación demuestra cómo ROUGE-W mejora el enfoque básico de LCS al asignar pesos más altos a las coincidencias consecutivas. El parámetro de peso (típicamente 1.2) controla cuánto se favorecen las coincidencias consecutivas sobre las no consecutivas. Los pesos más altos resultan en preferencias más fuertes por las secuencias consecutivas.
Ejemplo Práctico: ROUGE para Resumen de Texto
from rouge_score import rouge_scorer
# Sample texts for evaluation
references = [
"The cat is sleeping peacefully on the mat.",
"A brown dog chases the ball in the park.",
"The weather is sunny and warm today."
]
candidates = [
"The cat lies quietly on the mat.",
"The brown dog is playing with a ball at the park.",
"Today's weather is warm and sunny."
]
# Initialize ROUGE scorer with multiple variants
scorer = rouge_scorer.RougeScorer(
['rouge1', 'rouge2', 'rougeL'], # Different ROUGE variants
use_stemmer=True # Enable word stemming
)
# Calculate and display scores for each pair
for i, (ref, cand) in enumerate(zip(references, candidates)):
print(f"\nExample {i+1}:")
print(f"Reference: {ref}")
print(f"Candidate: {cand}")
# Calculate ROUGE scores
scores = scorer.score(ref, cand)
print("\nROUGE Scores:")
for metric, score in scores.items():
print(f"{metric}:")
print(f" Precision: {score.precision:.3f}")
print(f" Recall: {score.recall:.3f}")
print(f" F1: {score.fmeasure:.3f}")Desglose del Código:
- Importaciones y Configuración:
- Importa el módulo rouge_scorer del paquete rouge_score
- Define múltiples pares de textos de referencia y candidatos para pruebas exhaustivas
- Configuración del Evaluador ROUGE:
- rouge1: Evalúa la superposición de unigramas (palabras individuales)
- rouge2: Evalúa la superposición de bigramas (dos palabras consecutivas)
- rougeL: Evalúa la subsecuencia común más larga
- use_stemmer=True reduce las palabras a su forma raíz para mejorar la coincidencia
- Cálculo y Visualización de Puntuaciones:
- Itera a través de cada par de referencia-candidato
- Calcula la precisión (palabras coincidentes/longitud del candidato)
- Calcula la exhaustividad (palabras coincidentes/longitud de referencia)
- Calcula la puntuación F1 (media armónica de precisión y exhaustividad)
Ejemplo de Salida Esperada:
Example 1:
Reference: The cat is sleeping peacefully on the mat.
Candidate: The cat lies quietly on the mat.
ROUGE Scores:
rouge1:
Precision: 0.857
Recall: 0.750
F1: 0.800
rouge2:
Precision: 0.667
Recall: 0.571
F1: 0.615
rougeL:
Precision: 0.714
Recall: 0.625
F1: 0.6673.3.3 BERTScore
BERTScore es una métrica de evaluación moderna que aprovecha los embeddings contextuales de transformers preentrenados como BERT para evaluar la calidad del texto. A diferencia de las métricas tradicionales como BLEU y ROUGE que dependen de la coincidencia exacta de n-gramas, BERTScore utiliza redes neuronales profundas para calcular la similitud semántica entre textos generados y de referencia. Este enfoque revolucionario marca un avance significativo en la evaluación del procesamiento del lenguaje natural.
El poder de BERTScore radica en su sofisticada comprensión del contexto del lenguaje. Puede reconocer cuando diferentes palabras o frases transmiten el mismo significado - por ejemplo, entendiendo que "automóvil" y "coche" son semánticamente similares, o que "comenzar" e "iniciar" expresan la misma acción. La métrica opera a través de un proceso de múltiples pasos:
- Primero, procesa cada palabra a través de los mecanismos de atención de BERT para comprender su rol en la oración
- Luego, convierte cada palabra en una representación vectorial de alta dimensionalidad (típicamente 768 dimensiones) que captura no solo el significado de la palabra, sino toda su relación contextual dentro del texto
- Finalmente, emplea cálculos de similitud del coseno para medir qué tan estrechamente se alinea el significado semántico del texto generado con el texto de referencia
Este enfoque sofisticado permite que BERTScore proporcione puntuaciones de evaluación más matizadas que se alinean mejor con los juicios humanos. Sobresale en varios escenarios donde las métricas tradicionales fallan:
- Al evaluar textos que utilizan sinónimos o paráfrasis
- En casos donde las variaciones en el orden de las palabras mantienen el mismo significado
- Al evaluar relaciones semánticas complejas que van más allá de la simple coincidencia de palabras
- Para evaluar escritura creativa donde existen múltiples expresiones válidas de la misma idea
Cómo funciona BERTScore:
- Codifica textos de referencia y candidatos en embeddings usando un modelo BERT preentrenado - Este proceso involucra:
- Tokenizar cada texto en unidades de subpalabras que BERT pueda entender
- Pasar estos tokens a través de múltiples capas transformer de BERT
- Generar embeddings contextuales que capturan el significado semántico en un espacio de 768 dimensiones
- Empareja embeddings para calcular puntuaciones de similitud para precisión, exhaustividad y F1:
- Precisión: Mide cuántas palabras en el texto candidato se alinean semánticamente con la referencia
- Exhaustividad: Evalúa cuántas palabras de la referencia son capturadas en el candidato
- F1: Combina precisión y exhaustividad en una única puntuación equilibrada
Ejemplo Práctico: BERTScore para Generación de Texto
from bert_score import score
import torch
from transformers import AutoTokenizer, AutoModel
# Sample texts for evaluation
references = [
"The cat is sleeping on the mat.",
"The weather is beautiful today.",
"She quickly ran to catch the bus."
]
candidates = [
"A cat lies peacefully on the mat.",
"Today has wonderful weather.",
"She hurried to make it to the bus."
]
# Basic BERTScore computation
P, R, F1 = score(
candidates,
references,
lang="en",
model_type="bert-base-uncased",
num_layers=8,
batch_size=32,
rescale_with_baseline=True
)
# Display detailed results
print("Basic BERTScore Results:")
for i, (ref, cand) in enumerate(zip(references, candidates)):
print(f"\nExample {i+1}:")
print(f"Reference: {ref}")
print(f"Candidate: {cand}")
print(f"Precision: {P[i]:.3f}")
print(f"Recall: {R[i]:.3f}")
print(f"F1: {F1[i]:.3f}")
# Advanced usage with custom model and idf weighting
def compute_custom_bertscore(refs, cands, model_name="roberta-base"):
# Initialize tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)
# Calculate IDF weights
idf_dict = {}
for ref in refs:
tokens = tokenizer.tokenize(ref)
for token in tokens:
idf_dict[token] = idf_dict.get(token, 0) + 1
# Convert counts to IDF
num_docs = len(refs)
for token in idf_dict:
idf_dict[token] = torch.log(num_docs / (idf_dict[token] + 1))
# Compute weighted BERTScore
P, R, F1 = score(
cands,
refs,
model_type=model_name,
idf=idf_dict,
device='cuda' if torch.cuda.is_available() else 'cpu'
)
return P, R, F1
# Compute custom BERTScore
custom_P, custom_R, custom_F1 = compute_custom_bertscore(references, candidates)
print("\nCustom BERTScore Results (with IDF weighting):")
for i, (ref, cand) in enumerate(zip(references, candidates)):
print(f"\nExample {i+1}:")
print(f"Reference: {ref}")
print(f"Candidate: {cand}")
print(f"Custom Precision: {custom_P[i]:.3f}")
print(f"Custom Recall: {custom_R[i]:.3f}")
print(f"Custom F1: {custom_F1[i]:.3f}")Desglose del Código:
- Configuración Básica e Importaciones:
- Importa las bibliotecas necesarias incluyendo bert_score, torch y transformers
- Define textos de muestra de referencia y candidatos para evaluación
- Cálculo Básico de BERTScore:
- Utiliza la función score con parámetros predeterminados
- Establece el idioma en inglés y usa el modelo bert-base-uncased
- Incluye parámetros adicionales como num_layers y batch_size para optimización
- Activa rescale_with_baseline para una mejor normalización de puntuaciones
- Implementación Personalizada Avanzada:
- Implementa una función personalizada compute_custom_bertscore
- Utiliza el modelo RoBERTa en lugar de BERT para un posible mejor rendimiento
- Calcula los pesos IDF (Frecuencia Inversa de Documento) para los tokens
- Implementa soporte para GPU cuando está disponible
- Visualización de Resultados:
- Muestra resultados detallados para implementaciones básicas y personalizadas
- Presenta puntuaciones para cada par de referencia-candidato
- Incluye puntuaciones de precisión, exhaustividad y F1
Comparación de Métricas
BLEU (Evaluación Bilingüe Subestimada):
- Particularmente efectiva para tareas estructuradas como traducción automática donde el orden de palabras y la precisión son cruciales. Esta métrica fue desarrollada originalmente por IBM para evaluar sistemas de traducción automática y desde entonces se ha convertido en un estándar de la industria.
- Destaca en comparar traducciones que deben mantener terminología y fraseología específicas. Es especialmente útil al evaluar contenido técnico o especializado donde la terminología precisa es crítica, como traducciones legales o médicas.
- Funciona comparando coincidencias de n-gramas entre textos candidatos y de referencia, utilizando un sistema sofisticado de puntuación que:
- Calcula la precisión para diferentes tamaños de n-gramas (usualmente 1-4 palabras)
- Aplica una penalización por brevedad para evitar que traducciones muy cortas obtengan puntuaciones artificialmente altas
- Combina estas puntuaciones usando promedio geométrico para producir una puntuación final entre 0 y 1
- Las limitaciones incluyen su enfoque en coincidencias exactas, que puede no capturar paráfrasis válidas o expresiones alternativas que son semánticamente correctas
ROUGE (Evaluación de Resumen Orientada a Recall):
- Específicamente diseñada para evaluar tareas de resumen de texto, con un enfoque en evaluar qué tan bien los resúmenes generados capturan información clave de los documentos fuente
- Se centra en medir la superposición entre resúmenes generados y textos de referencia analizando:
- Coincidencias a nivel de palabra entre los resúmenes generados y de referencia
- Alineación de secuencias para identificar frases y expresiones comunes
- Cobertura de contenido importante del texto de referencia
- Varias versiones ofrecen diferentes enfoques de evaluación:
- ROUGE-N: Mide superposición de n-gramas (ej., ROUGE-1 para palabras individuales, ROUGE-2 para pares de palabras)
- ROUGE-L: Utiliza la Subsecuencia Común más Larga para capturar estructura a nivel de oración
- ROUGE-W: Versión ponderada que considera más valiosas las coincidencias consecutivas
- ROUGE-S: Coocurrencia de bigramas saltados para coincidencia flexible de orden de palabras
BERTScore:
- Aprovecha los embeddings contextuales para comprender el significado semántico más allá de la coincidencia superficial de palabras:
- Utiliza la arquitectura de red neuronal de BERT para procesar texto a través de múltiples capas de atención
- Crea representaciones contextuales ricas que capturan relaciones y dependencias entre palabras
- Analiza texto tanto a nivel de palabra como de oración para comprender patrones lingüísticos más profundos
- Particularmente valiosa para tareas creativas y flexibles como narración y generación de contenido:
- Sobresale en evaluar escritura creativa donde existen múltiples expresiones válidas
- Maneja mejor el flujo narrativo y la evaluación de coherencia
- Se adapta bien a diferentes estilos y géneros de escritura
- Puede reconocer sinónimos y frases alternativas que transmiten el mismo significado:
- Utiliza similitud semántica para emparejar palabras con significados similares (ej., "feliz" y "alegre")
- Comprende el uso de palabras dependiente del contexto y expresiones idiomáticas
- Evalúa contenido parafraseado con mayor precisión que las métricas tradicionales
Las métricas de evaluación sirven como instrumentos cruciales para medir y validar la calidad de salida de los modelos transformer en procesamiento de lenguaje natural. Estas métricas pueden categorizarse ampliamente en enfoques tradicionales y modernos, cada uno sirviendo necesidades distintas de evaluación.
Las métricas tradicionales como BLEU y ROUGE operan sobre principios de coincidencia de n-gramas. BLEU sobresale en evaluar traducción automática mediante el análisis de secuencias precisas de palabras y aplicando mecanismos sofisticados de puntuación incluyendo penalizaciones por brevedad. ROUGE, diseñada principalmente para tareas de resumen, ofrece varios métodos de evaluación como superposición de n-gramas (ROUGE-N), subsecuencia común más larga (ROUGE-L), y análisis de bigramas saltados (ROUGE-S) para evaluar cobertura y precisión del contenido.
Los enfoques modernos como BERTScore representan un avance significativo al aprovechar los embeddings contextuales. A diferencia de las métricas tradicionales, BERTScore puede comprender relaciones semánticas, sinónimos y significados dependientes del contexto. Procesa texto a través de múltiples capas transformer para crear representaciones ricas que capturan patrones y relaciones lingüísticas complejas.
Al utilizar efectivamente estas métricas complementarias, los profesionales pueden:
- Realizar evaluaciones integrales de calidad a través de diferentes aspectos de la generación de lenguaje
- Comparar rendimientos de modelos usando evaluaciones tanto a nivel superficial como semántico
- Identificar áreas específicas donde los modelos sobresalen o necesitan mejora
- Tomar decisiones basadas en datos para optimización y despliegue de modelos
Este enfoque de evaluación multifacético asegura que los modelos transformer cumplan con los altos estándares requeridos para su despliegue en aplicaciones del mundo real, desde generación de contenido y traducción hasta resumen y más allá.