Métricas de geração: fidelidade e relevância da resposta
Use RAGAS para medir se as respostas geradas são fiéis ao contexto recuperado e se realmente respondem à pergunta do usuário sem alucinar.
Métricas de geração: fidelidade e relevância da resposta é uma aula grátis de AI Engineering Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Engineering Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Engineering Academy inclui 4 aulas no total.
Medição da etapa de geração
Mesmo quando seu recuperador encontra os trechos perfeitos, a etapa de geração ainda pode falhar. O LLM pode ignorar o contexto recuperado e responder com base em sua memória paramétrica, interpretar incorretamente o que o contexto afirma ou responder a uma pergunta ligeiramente diferente da que foi feita. As métricas de geração quantificam essas falhas independentemente da recuperação, para que você possa identificar e corrigir cada problema. As duas principais métricas de geração são fidelidade e relevância da resposta.
Fidelidade: definição
Fidelidade mede se cada afirmação da resposta gerada pode ser diretamente relacionada ao contexto recuperado. Uma resposta fiel não introduz nenhuma informação que não esteja presente no contexto. A fidelidade é medida no nível das afirmações: a resposta é decomposta em declarações atômicas individuais, e cada uma é comparada ao contexto para verificar se há sustentação. A pontuação de fidelidade é a fração de afirmações sustentadas.
# 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.67Implementação da fidelidade com LLM como avaliador
A maneira mais prática de medir a fidelidade em escala é usar um LLM poderoso como avaliador. Solicite ao LLM avaliador que decomponha a resposta em afirmações individuais e, em seguida, verifique cada afirmação em relação ao contexto. O avaliador retorna uma lista de afirmações rotuladas como SUPPORTED ou UNSUPPORTED, e você calcula a fração das que são sustentadas. Essa abordagem permite realizar milhares de avaliações por hora a um custo de alguns centavos por avaliação.
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)Relevância da resposta: definição
Relevância da resposta mede se a resposta gerada realmente aborda a pergunta do usuário. Uma resposta altamente fiel ainda pode não atingir o objetivo — por exemplo, se o usuário perguntar "Como redefino minha senha?" e a resposta explicar detalhadamente a política geral de segurança da empresa sem mencionar o procedimento de redefinição de senha. A relevância da resposta é independente da fidelidade: é possível ser fiel (dizer apenas coisas presentes no contexto), mas irrelevante (não abordar o que foi perguntado).
Medindo a relevância da resposta
RAGAS mede a relevância da resposta usando uma técnica inteligente de geração reversa: o LLM avaliador gera várias perguntas hipotéticas que seriam respondidas pela resposta gerada e, em seguida, mede a semelhança entre essas perguntas geradas e a pergunta original usando similaridade do cosseno entre embeddings. Uma alta semelhança entre as perguntas hipotéticas geradas e a pergunta original indica alta relevância da resposta.
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)Revocação do contexto: recuperamos o suficiente?
Revocação do contexto mede se o contexto recuperado contém informações suficientes para responder corretamente à pergunta. Ela verifica a resposta de referência frase por frase: cada frase pode ser atribuída a um dos trechos recuperados? Uma alta revocação do contexto significa que o recuperador encontrou tudo o que era necessário. Uma baixa revocação do contexto significa que informações essenciais estavam ausentes dos trechos recuperados, portanto o LLM não pode responder corretamente, mesmo com uma geração perfeita.
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)Precisão do contexto: os trechos recuperados são relevantes?
Precisão do contexto mede se os trechos recuperados são realmente úteis para responder à pergunta. Uma alta precisão do contexto significa que os trechos recuperados são diretamente relevantes. Uma baixa precisão do contexto significa que muitos trechos recuperados são ruído fora do tema que o LLM precisa ler e descartar, aumentando o risco de confusão. A precisão do contexto é medida verificando quais trechos recuperados foram realmente usados ou referenciados na resposta gerada.
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)Usando RAGAS para todas as métricas de uma só vez
A biblioteca RAGAS implementa as quatro métricas centrais de RAG — precisão do contexto, revocação do contexto, fidelidade e relevância da resposta — em uma única estrutura. Ela gerencia internamente as chamadas ao LLM avaliador. Passe um conjunto de dados com perguntas, respostas geradas, contextos recuperados e respostas de referência e receba um relatório abrangente de pontuações. RAGAS também oferece suporte à avaliação assíncrona, para que seja possível avaliar centenas de exemplos em 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)Diagnosticando com combinações de métricas
A combinação de métricas revela problemas específicos do sistema. Baixa fidelidade + alta precisão do contexto → o LLM está ignorando o contexto e alucinando (corrija o prompt). Baixa revocação do contexto + alta fidelidade → o recuperador não está encontrando trechos essenciais, mas o LLM relata fielmente o que encontrou (corrija a divisão em trechos ou os embeddings). Baixa relevância da resposta + alta fidelidade → os trechos recuperados têm relação apenas tangencial e o LLM os discute fielmente, mas não responde à pergunta (melhore a filtragem da recuperação ou a reescrita da consulta).
# 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'
}
]Avaliação humana para calibração
As métricas de LLM como avaliador estão correlacionadas com o julgamento humano, mas não perfeitamente alinhadas. Calibre suas métricas automatizadas fazendo com que 3 avaliadores humanos atribuam pontuações a uma amostra aleatória de 50 saídas quanto à fidelidade e à relevância da resposta, usando uma escala de 1 a 5. Calcule a concordância entre o LLM avaliador e a pontuação humana média. Se o LLM atribuir sistematicamente pontuações maiores ou menores que as pessoas, aplique um fator de correção. Métricas automatizadas calibradas dão confiança de que as melhorias nas pontuações refletem melhorias reais na qualidade.
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, biasDefinindo metas de métricas para produção
Antes de implantar um sistema RAG em produção, defina limiares mínimos para as métricas que o sistema deve atingir. Metas comuns de produção são: fidelidade > 0,90 (menos de 10% das afirmações da resposta são alucinações), relevância da resposta > 0,80 (mais de 80% das respostas realmente abordam a pergunta), precisão do contexto > 0,60 (a maioria dos trechos recuperados é relevante) e revocação do contexto > 0,75 (a maioria dos fatos essenciais está disponível no contexto recuperado). Sistemas que não atingirem esses limiares não devem ser implantados sem melhorias adicionais.
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 readyVerificação rápida
Teste sua compreensão dos conceitos de Engenharia de IA desta lição.
Recapitulação da lição
Nesta lição, você aprendeu: fidelidade como a métrica no nível das afirmações que verifica se cada declaração da resposta é sustentada pelo contexto recuperado; relevância da resposta como a métrica que mede se a resposta aborda a pergunta real; revocação e precisão do contexto para medir a qualidade da recuperação sob a perspectiva da geração; e a biblioteca RAGAS para avaliação automatizada com várias métricas. Em seguida, reuniremos todas essas métricas em uma estrutura de avaliação automatizada que você poderá executar a cada alteração.
Aprenda Python com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 30
- Aulas
- 120
Perguntas Frequentes
A aula “Métricas de geração: fidelidade e relevância da resposta” é grátis?
Sim — o texto completo de “Métricas de geração: fidelidade e relevância da resposta” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Engineering Academy, atualize para CoddyKit PRO. O curso de AI Engineering Academy inclui 4 aulas no total.
O que vou aprender em “Métricas de geração: fidelidade e relevância da resposta”?
Use RAGAS para medir se as respostas geradas são fiéis ao contexto recuperado e se realmente respondem à pergunta do usuário sem alucinar. Você pratica AI Engineering Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar AI Engineering Academy?
Nenhuma experiência prévia é necessária. AI Engineering Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Métricas de geração: fidelidade e relevância da resposta”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de AI Engineering Academy?
Sim. Cada aula de AI Engineering Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Por que a avaliação é importante em RAG
- Métricas de recuperação: taxa de acerto, MRR e NDCG
- Métricas de geração: fidelidade e relevância da resposta
- Criando uma estrutura automatizada de avaliação