Evaluación de LLMs: ¿Cómo medir la calidad de las respuestas?

Evaluar un LLM no es opcional si planeas usarlo en producción. Sin evaluación, no sabes si el modelo es preciso, está alucinando, es seguro o si una actualización lo empeoró. La evaluación de LLMs es el proceso de medir sistemáticamente la calidad de las respuestas usando criterios objetivos — exactitud, relevancia, tono, seguridad, formato — para decidir si un modelo es apto para tu caso de uso.

Tip Pro: La evaluación no es un paso que haces una vez. Es un proceso continuo: cada vez que cambias de modelo, actualizas un prompt, o agregas un nuevo feature, debes re-evaluar.

¿Qué es?

Evaluar un LLM significa comparar su output contra un estándar definido por ti. A diferencia del software tradicional —donde una función devuelve true o false— un LLM devuelve lenguaje natural, que es inherentemente subjetivo. Por eso la evaluación tiene múltiples dimensiones:

1. Exactitud factual: ¿La respuesta es correcta según tu fuente de verdad?
2. Relevancia: ¿Responde a lo que preguntaron o se va por las ramas?
3. Fidelidad (groundedness): ¿La respuesta se basa en el contexto que le diste o inventa?
4. Tono y estilo: ¿Suena profesional, amigable, coherente con tu marca?
5. Seguridad: ¿Genera contenido tóxico, sesgado o riesgoso?
6. Formato: ¿Respeta la estructura esperada (JSON, XML, etc.)?

Cada dimensión requiere un método de evaluación distinto. No existe una sola métrica que cubra todo.

Nota: No confundas evaluar un LLM con hacerle un test. No le preguntas al modelo "¿qué tan bueno eres?" — le das un conjunto de ejemplos (test set) con respuestas esperadas y mides qué tan cerca estuvo.

Modelo mental

Piensa en la evaluación como un examen estandarizado para el modelo. Tú eres el profesor que prepara el examen: defines las preguntas (test set), decides qué respuestas son correctas (ground truth), y luego calificas.

            ┌──────────────┐
Test set ──→│    LLM       │──→ Respuestas ──→ Calificación (métrica)
            └──────────────┘
                  ↑
          Prompt / sistema

La diferencia con un examen humano es que la calificación puede ser automatizada: otro LLM más grande o un conjunto de reglas compara la respuesta del modelo contra la esperada y asigna un puntaje.

¿Cómo se usa?

Hay tres enfoques principales, y en producción sueles combinarlos.

1. Benchmarks estandarizados

Son conjuntos de prueba públicos con respuestas esperadas. Te permiten comparar modelos entre sí:

# lm-eval-harness: el estándar de facto para benchmarks
pip install lm-eval
 
# Evaluar un modelo en MMLU
lm_eval --model hf \
    --model_args pretrained=mistralai/Mistral-7B-v0.1 \
    --tasks mmlu \
    --num_fewshot 5

Advertencia: Los benchmarks públicos sufren de contaminación de datos — el modelo pudo haber visto las preguntas durante el entrenamiento. No confíes ciegamente en un benchmark. Complémentalo con tu propio test set.

2. LLM-as-judge

Usas un LLM más potente (GPT-4, Claude 3.5 Opus) para evaluar las respuestas de otro modelo. Es el método más práctico para equipos que no tienen presupuesto para anotadores humanos:

from openai import OpenAI
 
client = OpenAI()
 
SYSTEM_PROMPT = """
Eres un evaluador experto. Dada una pregunta, una respuesta
y un criterio de evaluación, califica la respuesta como:
- CORRECTA: cumple el criterio satisfactoriamente
- INCORRECTA: no lo cumple
- PARCIAL: lo cumple a medias
 
Devuelve solo el JSON con "score" y "reason".
"""
 
def evaluate_response(question, response, criterion):
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": f"""
        Pregunta: {question}
        Respuesta: {response}
        Criterio: {criterion}
        """}
    ]
    result = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        response_format={"type": "json_object"}
    )
    return result.choices[0].message.content
 
# Ejemplo
eval = evaluate_response(
    question="¿Cuál es la capital de Uruguay?",
    response="La capital de Uruguay es Montevideo.",
    criterion="La respuesta debe ser factualmente correcta."
)

El truco está en el prompt del evaluador: cuanto más específico sea el criterio, más consistentes serán las calificaciones.

Tip Pro: El LLM-as-judge tiene sesgos. Tiende a favorecer respuestas más largas, con más formato, o que usan el mismo tono del evaluador. Cámbialo de modelo periódicamente y calibra contra evaluación humana cada cierto número de muestras.

3. Test set propio con ground truth

Nada reemplaza tener un conjunto de ejemplos de tu dominio con respuestas esperadas escritas por humanos:

test_set = [
    {
        "question": "¿Cómo reinicio mi router Huawei HG8145V5?",
        "expected": "Presiona el botón de reset en la parte trasera por 10 segundos.",
        "criteria": ["exactitud_factual", "claridad"]
    },
    {
        "question": "¿Cuál es el horario de atención?",
        "expected": "Lunes a viernes de 9:00 a 18:00.",
        "criteria": ["exactitud_factual"]
    }
]
 
def evaluate_accuracy(response, expected):
    # Comparación semántica, no exacta
    # Puedes usar embeddings + similitud coseno o LLM-as-judge
    embedding = client.embeddings.create(
        model="text-embedding-3-small",
        input=[response, expected]
    )
    sim = cosine_similarity(
        embedding.data[0].embedding,
        embedding.data[1].embedding
    )
    return sim > 0.85  # threshold definido empíricamente

Pipeline de evaluación completo en producción

import json
from openai import OpenAI
 
client = OpenAI()
 
def evaluate_response(question, response, expected, criteria):
    prompt = f"""
    Evalúa la siguiente respuesta y determina si cumple los criterios.
 
    Pregunta: {question}
    Respuesta esperada: {expected}
    Respuesta del modelo: {response}
    Criterios: {json.dumps(criteria)}
 
    Para cada criterio, devuelve "pass" o "fail".
    """
    result = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"}
    )
    return json.loads(result.choices[0].message.content)
 
# Test set de 50 preguntas de tu dominio
results = [evaluate_response(**item) for item in test_set]
pass_rate = sum(r.get("pass", False) for r in results) / len(results)
print(f"Tasa de aprobación: {pass_rate:.2%}")

¿Cuándo usarlo / cuándo no?

Tip Pro: No evalúes todo. Enfócate en las 10-20 preguntas que representan el 80% del uso real. Un test set pequeño pero representativo gana a uno grande pero genérico.

Historia y evolución