AI Engineering Academy · Lección

Métricas de generación: fidelidad y relevancia de la respuesta

Usará RAGAS para medir si las respuestas generadas son fieles al contexto recuperado y si realmente responden a la pregunta del usuario sin alucinar.

Lección 3 de 413 pasos

Métricas de generación: fidelidad y relevancia de la respuesta es una lección gratuita de AI Engineering Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Engineering Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Engineering Academy incluye 4 lecciones en total.

Medición de la etapa de generación

Incluso cuando el recuperador encuentra los fragmentos perfectos, la etapa de generación puede fallar. El LLM podría ignorar el contexto recuperado y responder basándose en su memoria paramétrica, interpretar incorrectamente lo que dice el contexto o responder una pregunta ligeramente distinta de la que se formuló. Las métricas de generación cuantifican estos fallos de forma independiente de la recuperación, para que pueda localizar y corregir cada problema. Las dos métricas principales de generación son la fidelidad y la relevancia de la respuesta.

Fidelidad: definición

La fidelidad mide si cada afirmación de la respuesta generada puede rastrearse directamente hasta el contexto recuperado. Una respuesta fiel no introduce información que no esté presente en el contexto. La fidelidad se mide en el nivel de las afirmaciones: la respuesta se descompone en enunciados atómicos individuales y cada uno se comprueba con respecto al contexto para verificar que cuenta con respaldo. La puntuación de fidelidad es la fracción de afirmaciones respaldadas.

# Faithfulness = supported_claims / total_claims

example_answer = (
    'Employees receive 15 vacation days per year. '
    'Remote work is allowed on Wednesdays and Fridays. '
    'The CEO is John Smith.'
)
example_context = (
    '15 vacation days are granted annually. '
    'Remote work is permitted on Wednesdays and Fridays.'
)

# Claim 1: 15 vacation days — SUPPORTED
# Claim 2: Remote work Wed+Fri — SUPPORTED
# Claim 3: CEO is John Smith — NOT IN CONTEXT (hallucinated)
# Faithfulness = 2/3 = 0.67

Implementación de la fidelidad con un LLM como evaluador

La forma más práctica de medir la fidelidad a escala es utilizar un LLM potente como evaluador. Indique al LLM evaluador que descomponga la respuesta en afirmaciones individuales y, después, compruebe cada afirmación con respecto al contexto. El evaluador devuelve una lista de afirmaciones etiquetadas como SUPPORTED o UNSUPPORTED, y usted calcula la fracción de las que cuentan con respaldo. Este enfoque permite escalar hasta miles de evaluaciones por hora, con un coste de unos pocos céntimos por evaluación.

import json

def evaluate_faithfulness(answer, context, llm_client):
    prompt = (
        'Task: Evaluate the faithfulness of an answer against a context.\n\n'
        f'Context:\n{context}\n\n'
        f'Answer:\n{answer}\n\n'
        'Steps:\n'
        '1. Break the answer into individual atomic claims.\n'
        '2. For each claim, check if it is supported by the context.\n'
        '3. Return JSON: {"claims": [{"text": "...", "supported": true/false}], "score": 0.0-1.0}'
    )
    response = llm_client.chat.completions.create(
        model='gpt-4o',
        response_format={'type': 'json_object'},
        messages=[{'role': 'user', 'content': prompt}]
    )
    return json.loads(response.choices[0].message.content)

Relevancia de la respuesta: definición

La relevancia de la respuesta mide si la respuesta generada aborda realmente la pregunta del usuario. Una respuesta muy fiel aún puede no dar en el blanco; por ejemplo, si el usuario pregunta «¿Cómo restablezco mi contraseña?» y la respuesta explica detalladamente la política general de seguridad de la empresa sin mencionar el procedimiento para restablecer la contraseña. La relevancia de la respuesta es independiente de la fidelidad: puede ser fiel (decir únicamente cosas que aparecen en el contexto) pero irrelevante (no abordar lo que se preguntó).

Medición de la relevancia de la respuesta

RAGAS mide la relevancia de la respuesta mediante una ingeniosa técnica de generación inversa: el LLM evaluador genera varias preguntas hipotéticas cuya respuesta sería la respuesta generada y, después, mide cuánto se parecen estas preguntas generadas a la pregunta original mediante la similitud coseno de sus embeddings. Una alta similitud entre las preguntas hipotéticas generadas y la pregunta original indica una alta relevancia de la respuesta.

def evaluate_answer_relevance(question, answer, llm_client, embed_fn):
    # Generate hypothetical questions for this answer
    prompt = (
        f'Given this answer: "{answer}"\n\n'
        'Generate 3 questions that this answer would be a good response to.\n'
        'Return as JSON: {"questions": ["...", "...", "..."]}'
    )
    response = llm_client.chat.completions.create(
        model='gpt-4o-mini',
        response_format={'type': 'json_object'},
        messages=[{'role': 'user', 'content': prompt}]
    )
    hyp_questions = json.loads(response.choices[0].message.content)['questions']

    # Measure similarity to original question
    orig_embedding = embed_fn(question)
    hyp_embeddings = [embed_fn(q) for q in hyp_questions]
    similarities = [cosine_similarity(orig_embedding, e) for e in hyp_embeddings]
    return sum(similarities) / len(similarities)

Recall del contexto: ¿recuperamos suficiente información?

El recall del contexto mide si el contexto recuperado contiene información suficiente para responder correctamente a la pregunta. Comprueba la respuesta de referencia oración por oración: ¿se puede atribuir cada oración a uno de los fragmentos recuperados? Un recall del contexto alto significa que el recuperador encontró todo lo necesario. Un recall del contexto bajo significa que faltaba información clave en los fragmentos recuperados, por lo que el LLM no puede responder correctamente, ni siquiera con una generación perfecta.

def evaluate_context_recall(ground_truth_answer, retrieved_contexts, llm_client):
    prompt = (
        f'Ground truth answer:\n{ground_truth_answer}\n\n'
        f'Retrieved context:\n{",".join(retrieved_contexts)}\n\n'
        'For each sentence in the ground truth answer, determine if it '
        'can be attributed to the retrieved context.\n'
        'Return JSON: {"sentences": [{"text": "...", "in_context": true/false}], "recall": 0.0-1.0}'
    )
    response = llm_client.chat.completions.create(
        model='gpt-4o',
        response_format={'type': 'json_object'},
        messages=[{'role': 'user', 'content': prompt}]
    )
    return json.loads(response.choices[0].message.content)

Precisión del contexto: ¿son relevantes los fragmentos recuperados?

La precisión del contexto mide si los fragmentos recuperados son realmente útiles para responder a la pregunta. Una precisión del contexto alta significa que los fragmentos recuperados son muy relevantes. Una precisión del contexto baja significa que muchos fragmentos recuperados son ruido fuera de tema que el LLM debe leer y descartar, lo que aumenta el riesgo de confusión. La precisión del contexto se mide comprobando qué fragmentos recuperados se utilizaron o se citaron realmente en la respuesta generada.

def evaluate_context_precision(question, answer, retrieved_contexts, llm_client):
    precision_scores = []
    for i, context in enumerate(retrieved_contexts, 1):
        prompt = (
            f'Question: {question}\n\n'
            f'Context chunk {i}: {context}\n\n'
            f'Answer: {answer}\n\n'
            'Was this context chunk useful in generating the answer? '
            'Return JSON: {"useful": true/false, "reason": "..."}'
        )
        response = llm_client.chat.completions.create(
            model='gpt-4o-mini',
            response_format={'type': 'json_object'},
            messages=[{'role': 'user', 'content': prompt}]
        )
        result = json.loads(response.choices[0].message.content)
        precision_scores.append(1.0 if result['useful'] else 0.0)
    return sum(precision_scores) / len(precision_scores)

Uso de RAGAS para todas las métricas a la vez

La biblioteca RAGAS implementa las cuatro métricas principales de RAG —precisión del contexto, recall del contexto, fidelidad y relevancia de la respuesta— en un único framework. Gestiona internamente las llamadas al LLM evaluador. Pase un conjunto de datos con preguntas, respuestas generadas, contextos recuperados y respuestas de referencia, y recibirá un informe completo de puntuaciones. RAGAS también admite la evaluación asíncrona, por lo que puede evaluar cientos de ejemplos en paralelo.

from ragas import evaluate
from ragas.metrics import (
    faithfulness, answer_relevancy,
    context_precision, context_recall
)
from datasets import Dataset

# Build evaluation dataset
eval_samples = [
    {
        'question': item['question'],
        'answer': item['generated_answer'],
        'contexts': item['retrieved_texts'],
        'ground_truth': item['expected_answer']
    }
    for item in test_results
]

eval_dataset = Dataset.from_list(eval_samples)
results = evaluate(eval_dataset,
    metrics=[faithfulness, answer_relevancy, context_precision, context_recall]
)
results.to_pandas().to_csv('eval_results.csv', index=False)

Diagnóstico mediante combinaciones de métricas

La combinación de métricas revela problemas específicos del sistema. Fidelidad baja + precisión del contexto alta → el LLM ignora el contexto y alucina (corrija el prompt). Recall del contexto bajo + fidelidad alta → al recuperador le faltan fragmentos clave, pero el LLM informa fielmente de lo que encontró (corrija la división en fragmentos o los embeddings). Relevancia de la respuesta baja + fidelidad alta → los fragmentos recuperados están relacionados tangencialmente y el LLM habla fielmente de ellos, pero no responde a la pregunta (mejore el filtrado de la recuperación o la reescritura de consultas).

# Diagnostic matrix
diagnostics = [
    {
        'condition': 'Low faithfulness + High context precision',
        'cause': 'LLM ignoring context, answering from parametric memory',
        'fix': 'Strengthen system prompt: "Answer ONLY from the provided context"'
    },
    {
        'condition': 'Low context recall + High faithfulness',
        'cause': 'Retriever missing relevant chunks',
        'fix': 'Improve chunking strategy, embedding model, or increase top-k'
    },
    {
        'condition': 'Low answer relevance + High context recall',
        'cause': 'Retrieved context is off-topic; LLM is answering wrong question',
        'fix': 'Add query rewriting or improve metadata filters'
    }
]

Evaluación humana para la calibración

Las métricas de LLM como evaluador se correlacionan con el criterio humano, pero no coinciden perfectamente. Calibre sus métricas automatizadas haciendo que 3 evaluadores humanos puntúen una muestra aleatoria de 50 respuestas en fidelidad y relevancia de la respuesta, utilizando una escala del 1 al 5. Calcule la concordancia entre el LLM evaluador y la puntuación humana media. Si el LLM asigna sistemáticamente puntuaciones superiores o inferiores a las de los evaluadores humanos, aplique un factor de corrección. Las métricas automatizadas calibradas le dan la confianza de que las mejoras en las puntuaciones reflejan mejoras reales de calidad.

from scipy.stats import spearmanr

def calibrate_judge_vs_humans(samples):
    '''samples: [{"llm_score": 0.9, "human_score": 4.2}, ...]'''
    llm_scores = [s['llm_score'] for s in samples]
    human_scores = [s['human_score'] / 5.0 for s in samples]  # normalize to 0-1

    correlation, pvalue = spearmanr(llm_scores, human_scores)
    print(f'LLM-Human Spearman correlation: {correlation:.3f} (p={pvalue:.4f})')

    mean_llm = sum(llm_scores) / len(llm_scores)
    mean_human = sum(human_scores) / len(human_scores)
    bias = mean_llm - mean_human
    print(f'LLM bias vs humans: {bias:+.3f}')
    return correlation, bias

Definición de objetivos de métricas para producción

Antes de implementar un sistema RAG en producción, defina umbrales mínimos de las métricas que el sistema debe cumplir. Algunos objetivos habituales en producción son: fidelidad > 0.90 (menos del 10 % de las afirmaciones de la respuesta son alucinaciones), relevancia de la respuesta > 0.80 (al menos el 80 % de las respuestas aborda realmente la pregunta), precisión del contexto > 0.60 (la mayoría de los fragmentos recuperados son relevantes) y recall del contexto > 0.75 (la mayoría de los datos clave están disponibles en el contexto recuperado). Los sistemas que no cumplan estos umbrales no deben implementarse sin realizar antes mejoras adicionales.

PRODUCTION_THRESHOLDS = {
    'faithfulness': 0.90,
    'answer_relevancy': 0.80,
    'context_precision': 0.60,
    'context_recall': 0.75
}

def check_production_readiness(metrics):
    ready = True
    print('Production readiness check:')
    for metric, threshold in PRODUCTION_THRESHOLDS.items():
        score = metrics.get(metric, 0)
        status = 'PASS' if score >= threshold else 'FAIL'
        print(f'  {metric}: {score:.2f} (>= {threshold}) -> {status}')
        if status == 'FAIL':
            ready = False
    print(f'Overall: {"READY" if ready else "NOT READY"}')
    return ready

Comprobación rápida

Compruebe su comprensión de los conceptos de Ingeniería de IA de esta lección.

Resumen de la lección

En esta lección ha aprendido: la fidelidad como métrica a nivel de afirmación que comprueba si cada afirmación de la respuesta está respaldada por el contexto recuperado; la relevancia de la respuesta como métrica que mide si la respuesta aborda la pregunta real; el recall y la precisión del contexto para medir la calidad de la recuperación desde la perspectiva de la generación; y la biblioteca RAGAS para la evaluación automatizada de varias métricas. A continuación, reuniremos todas estas métricas en un sistema de evaluación automatizado que podrá ejecutar cada vez que realice un cambio.

Gratis para empezar

Aprende Python con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
30
Lecciones
120

Preguntas frecuentes

¿La lección «Métricas de generación: fidelidad y relevancia de la respuesta» es gratis?

Sí — el texto completo de «Métricas de generación: fidelidad y relevancia de la respuesta» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Engineering Academy, actualiza a CoddyKit PRO. El curso de AI Engineering Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Métricas de generación: fidelidad y relevancia de la respuesta»?

Usará RAGAS para medir si las respuestas generadas son fieles al contexto recuperado y si realmente responden a la pregunta del usuario sin alucinar. Practicas AI Engineering Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar AI Engineering Academy?

No se requiere experiencia previa. AI Engineering Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Métricas de generación: fidelidad y relevancia de la respuesta»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de AI Engineering Academy?

Sí. Cada lección de AI Engineering Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Por qué es importante la evaluación en RAG
  2. Métricas de recuperación: hit rate, MRR y NDCG
  3. Métricas de generación: fidelidad y relevancia de la respuesta
  4. Creación de un sistema automatizado de evaluación
← Volver a AI Engineering Academy