Ir al contenido principal
Español— Elegir un idioma
Menú

Evaluar un pipeline RAG

Lección 15 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Objetivos
  2. Los dos ejes de la evaluación
  3. Métricas de generación
  4. Marco de evaluación completo
  5. Panel de métricas
  6. Resumen

Objetivos

  • Evaluar la recuperación y la generación por separado
  • Implementar métricas automatizadas de calidad RAG
  • Construir un marco de evaluación completo

Los dos ejes de la evaluación

Un pipeline RAG falla de dos formas muy distintas, y confundirlas te costará semanas. O bien el paso de recuperación no ha encontrado los documentos correctos —en cuyo caso la respuesta es errónea por motivos ajenos al modelo de generación, y las métricas de la Lección 10 lo diagnosticarán—, o bien los documentos correctos estaban presentes, pero el paso de generación se ha desviado: el modelo ha inventado un detalle o ha respondido a una pregunta distinta de la formulada.

Cuando un usuario informa de que «la respuesta es incorrecta», no te dirá cuál de las dos causas está operando. De ahí la regla: mide ambos componentes de forma independiente con métricas distintas y solo ajusta uno después de haber identificado cuál está rindiendo por debajo de lo esperado.

Métricas de generación

La fidelidad responde a la pregunta más importante en producción: ¿está la respuesta totalmente respaldada por los documentos proporcionados o el modelo ha añadido su propio giro? En lugar de pedir una puntuación global —que los evaluadores tienden a otorgar con demasiada generosidad—, haz que el evaluador desglose la respuesta afirmación por afirmación y clasifique cada una como respaldada, no respaldada o contradicha. Esta última categoría es la más valiosa: una afirmación que contradice la fuente señala un error mucho más grave que una simple omisión.

from openai import OpenAI

client = OpenAI()

def evaluate_faithfulness(
    question: str,
    answer: str,
    contexts: list[str]
) -> dict:
    """Evalúa si la respuesta es fiel a los contextos."""
    full_context = "\n\n---\n\n".join(contexts)

    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"Evalúa la fidelidad de esta respuesta respecto a los "
                f"documentos fuente.\n\n"
                f"Documentos fuente:\n{full_context}\n\n"
                f"Pregunta: {question}\n\n"
                f"Respuesta: {answer}\n\n"
                f"Para cada afirmación de la respuesta, indica:\n"
                f"- RESPALDADA: si los documentos la confirman\n"
                f"- NO RESPALDADA: si no aparece en los documentos\n"
                f"- CONTRADICHA: si contradice los documentos\n\n"
                f"Termina con una puntuación global de 0 a 1."
            )
        }],
        temperature=0
    )
    return {"evaluation": response.choices[0].message.content}

Una respuesta puede ser perfectamente fiel y, aun así, inútil: podría copiar fielmente un pasaje que trata sobre otra cosa. Eso es lo que mide la relevancia de la respuesta, comparando esta vez la respuesta únicamente con la pregunta, sin los documentos. El prompt establece una escala explícita —1,0 para una respuesta completa, 0,7 para una respuesta parcial pero útil, 0,3 para tangencial, 0,0 para fuera de tema— porque un evaluador al que simplemente se le pide «puntuar de 0 a 1» produce puntuaciones inestables de una ejecución a otra.

def evaluate_relevance(question: str, answer: str) -> float:
    """Puntuación de relevancia de la respuesta respecto a la pregunta."""
    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"En una escala de 0 a 1, ¿hasta qué punto esta respuesta "
                f"aborda la pregunta formulada?\n\n"
                f"Pregunta: {question}\n"
                f"Respuesta: {answer}\n\n"
                f"Criterios:\n"
                f"- 1,0: respuesta completa y precisa\n"
                f"- 0,7: respuesta parcial pero útil\n"
                f"- 0,3: relacionada tangencialmente\n"
                f"- 0,0: fuera de tema\n\n"
                f"Devuelve solo la puntuación numérica."
            )
        }],
        temperature=0,
        max_tokens=10
    )
    try:
        return float(response.choices[0].message.content.strip())
    except ValueError:
        return 0.0

Luego está la precisión del contexto, que puentea los dos ejes: de los cinco documentos que inyectaste en el prompt, ¿cuántos se utilizaron realmente? Si la respuesta a una pregunta sobre políticas de permisos se basó solo en uno de los cinco fragmentos, los otros cuatro consumieron presupuesto de contexto y añadieron ruido. Así que preguntas al evaluador sobre cada contexto de forma aislada, con un simple sí o no, y calculas la proporción que resultó útil.

def evaluate_context_precision(
    question: str,
    contexts: list[str],
    answer: str
) -> dict:
    """Evalúa qué contextos fueron útiles para la respuesta."""
    results = []

    for i, ctx in enumerate(contexts):
        response = client.chat.completions.create(
            model="gpt-5.6-terra",
            messages=[{
                "role": "user",
                "content": (
                    f"¿Fue útil este documento para responder "
                    f"a la pregunta?\n\n"
                    f"Pregunta: {question}\n"
                    f"Documento: {ctx[:500]}\n"
                    f"Respuesta generada: {answer}\n\n"
                    f"Responde SÍ o NO."
                )
            }],
            temperature=0,
            max_tokens=5
        )
        useful = "sí" in response.choices[0].message.content.lower()
        results.append({"index": i, "useful": useful})

    num_useful = sum(1 for r in results if r["useful"])
    return {
        "details": results,
        "precision": num_useful / len(contexts) if contexts else 0
    }

Marco de evaluación completo

Estas tres funciones son inútiles mientras permanezcan manuales. El paso decisivo es ejecutarlas sobre un conjunto fijo de preguntas cada vez que modifiques el pipeline: eso es lo que convierte una corazonada —«creo que ha mejorado desde que cambié el fragmentado»— en un número comparable. La clase siguiente ejecuta el pipeline sobre cada elemento del conjunto de datos, recoge las puntuaciones y devuelve sus medias.

Observa el conjunto de datos de ejemplo: dos preguntas de RR. HH., cada una con una respuesta esperada y el identificador de los documentos que deberían recuperarse. De veinte a cincuenta entradas de este tipo, escritas de una vez por todas a partir de preguntas reales de usuarios, bastan para detectar regresiones.

class RAGEvaluator:
    def __init__(self, rag_pipeline):
        self.pipeline = rag_pipeline
        self.client = OpenAI()

    def evaluate_dataset(self, dataset: list[dict]) -> dict:
        """Evalúa el pipeline sobre un conjunto de datos de preguntas y respuestas.

        Cada elemento: {question, expected_answer, relevant_docs}
        """
        results = {
            "faithfulness": [],
            "relevance": [],
            "context_precision": [],
        }

        for item in dataset:
            # Ejecutar el pipeline
            output = self.pipeline.respond(item["question"])
            answer = output["answer"]
            contexts = [s["excerpt"] for s in output["sources"]]

            # Evaluar
            relevance = evaluate_relevance(item["question"], answer)
            results["relevance"].append(relevance)

            ctx_eval = evaluate_context_precision(
                item["question"], contexts, answer
            )
            results["context_precision"].append(ctx_eval["precision"])

        # Medias
        import numpy as np
        return {
            metric: round(float(np.mean(scores)), 4)
            for metric, scores in results.items()
        }

# Uso
dataset = [
    {
        "question": "¿Cuántos días de permiso tengo?",
        "expected_answer": "25 días de permiso retribuido al año",
        "relevant_docs": ["leave-policy"]
    },
    {
        "question": "¿Puedo trabajar en remoto los lunes?",
        "expected_answer": "Sí, el trabajo en remoto está permitido excepto los martes y jueves",
        "relevant_docs": ["remote-work-policy"]
    },
]

evaluator = RAGEvaluator(rag_pipeline)
metrics = evaluator.evaluate_dataset(dataset)
print("Resultados:")
for k, v in metrics.items():
    print(f"  {k}: {v}")

Panel de métricas

Estos son los objetivos a los que debes aspirar en un sistema de producción, junto con lo que significa realmente cada número.

MétricaObjetivoQué mide
Recall@5> 0,90¿Están los documentos correctos en el top 5?
Precision@5> 0,70¿Son relevantes los documentos devueltos?
Faithfulness> 0,85¿Es la respuesta fiel a las fuentes?
Answer Relevance> 0,80¿Aborda la respuesta la pregunta?
Context Precision> 0,60¿Son útiles los contextos proporcionados?

Lee esta tabla de arriba abajo como un árbol de diagnóstico. Un recall inferior a 0,90 hace que cualquier análisis de las líneas siguientes carezca de sentido: arregla primero el fragmentado o el índice. Por el contrario, un recall excelente combinado con una fidelidad deficiente señala el prompt de generación, no la búsqueda.

Resumen

  • Evalúa la recuperación (recall, precisión) y la generación (fidelidad, relevancia) por separado
  • La fidelidad detecta alucinaciones del LLM
  • La relevancia verifica que la respuesta sea útil
  • Construye un conjunto de datos de prueba y mide antes de cada cambio