Calibrando modelos avaliadores em relação a humanos
Colete um conjunto de dados de referência com julgamentos de preferência humana, meça a concordância entre avaliadores e humanos com o Kappa de Cohen e ajuste o prompt do avaliador para reduzir vieses sistemáticos.
Calibrando modelos avaliadores em relação a humanos é 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.
Por que a calibração é indispensável
Um avaliador LLM não calibrado pode atribuir sistematicamente pontuações mais altas ou mais baixas que as pessoas, preferir um estilo de escrita específico ou falhar em casos extremos que sua rubrica não previu. Se você usar esse avaliador para tomar decisões de implantação, estará confiando em um instrumento enviesado. A calibração valida o avaliador com base em uma referência humana e quantifica quanto você pode confiar em suas pontuações antes de usá-las em produção.
Criando um conjunto de dados de calibração
Crie um conjunto de calibração com 100 a 500 respostas de exemplo que tenham sido pontuadas por pessoas. Busque diversidade: inclua respostas de alta qualidade (pontuação 5), de qualidade média (pontuação 3) e claramente ruins (pontuação 1). Peça a 3 a 5 avaliadores humanos independentes que pontuem cada exemplo para medir a concordância entre avaliadores e calcular uma pontuação de referência consensual usando a média ou a moda.
# Calibration dataset structure:
# [
# {
# 'question': 'What causes inflation?',
# 'response': '...',
# 'human_scores': [4, 4, 3, 5, 4], # 5 raters
# 'human_consensus': 4, # mean or mode
# 'rater_ids': ['r1', 'r2', 'r3', 'r4', 'r5']
# },
# ...
# ]
# Typical calibration set composition:
# 30% excellent responses (score 4-5)
# 40% adequate responses (score 2-4)
# 30% poor responses (score 1-2)
# Include adversarial / edge casesMedindo a concordância entre avaliadores
Antes de confiar nas pontuações humanas como referência, verifique se os avaliadores humanos concordam entre si. O kappa de Cohen mede a concordância entre dois avaliadores além do acaso: acima de 0,6 é aceitável; acima de 0,8 é excelente. Para escalas de 5 pontos, calcule o kappa ponderado (com pesos lineares). Uma baixa concordância entre avaliadores significa que a tarefa está definida de forma ambígua — melhore as diretrizes para os avaliadores antes de usar as pontuações para calibrar um avaliador.
from sklearn.metrics import cohen_kappa_score
import numpy as np
def measure_inter_rater_agreement(rater1_scores: list, rater2_scores: list) -> dict:
kappa = cohen_kappa_score(rater1_scores, rater2_scores, weights='linear')
exact_agreement = sum(a == b for a, b in zip(rater1_scores, rater2_scores)) / len(rater1_scores)
adjacent_agreement = sum(abs(a - b) <= 1 for a, b in zip(rater1_scores, rater2_scores)) / len(rater1_scores)
return {
'weighted_kappa': round(kappa, 3),
'exact_agreement': round(exact_agreement, 3),
'adjacent_agreement': round(adjacent_agreement, 3),
'acceptable': kappa >= 0.6
}Executando o avaliador nos dados de calibração
Execute seu avaliador LLM em cada exemplo do conjunto de calibração usando o mesmo comando que você pretende usar em produção. Colete a pontuação do avaliador para cada exemplo junto com a pontuação consensual humana. Mantenha essas duas listas alinhadas para poder compará-las elemento a elemento. Essa comparação pareada revela vieses sistemáticos e diferenças na faixa de pontuações.
async def run_judge_on_calibration(calibration_set: list) -> list:
pairs = []
for item in calibration_set:
judge_result = await async_judge(item['question'], item['response'])
pairs.append({
'question': item['question'],
'human': item['human_consensus'],
'judge': judge_result.correctness,
'judge_rationale': judge_result.rationale
})
return pairsCalculando a correlação entre avaliador e pessoas
Calcule a correlação de Pearson entre as pontuações do avaliador e as pontuações consensuais humanas. Isso mede a concordância linear: uma correlação de 1,0 significa que o avaliador acompanha perfeitamente as classificações humanas. Calcule também o erro absoluto médio (MAE) para entender a diferença média entre as pontuações. Uma correlação acima de 0,7 e um MAE abaixo de 0,8 ponto em uma escala de 5 pontos normalmente indicam um avaliador confiável o suficiente para uso em produção.
from scipy.stats import pearsonr, spearmanr
import numpy as np
def calibration_metrics(pairs: list) -> dict:
humans = [p['human'] for p in pairs]
judges = [p['judge'] for p in pairs]
pearson_r, p_val = pearsonr(humans, judges)
spearman_r, _ = spearmanr(humans, judges)
mae = np.mean([abs(h - j) for h, j in zip(humans, judges)])
return {
'pearson_r': round(pearson_r, 3),
'spearman_r': round(spearman_r, 3),
'p_value': round(p_val, 5),
'mae': round(mae, 3),
'reliable': pearson_r >= 0.7 and mae <= 0.8
}Identificando vieses sistemáticos
Além da correlação, procure vieses sistemáticos: o avaliador atribui pontuações consistentemente altas ou baixas demais? Trace as pontuações do avaliador em relação às pontuações humanas e procure uma linha de regressão que não passe pela origem. Se o avaliador der 4 quando as pessoas derem 3, em média, ele terá um viés de inflação. Corrija isso ajustando a rubrica ou aplicando uma transformação de calibração linear às pontuações brutas.
import numpy as np
from scipy import stats
def detect_score_bias(pairs: list) -> dict:
humans = np.array([p['human'] for p in pairs])
judges = np.array([p['judge'] for p in pairs])
slope, intercept, r, p, se = stats.linregress(judges, humans)
bias = np.mean(judges - humans) # positive = judge over-scores
return {
'mean_bias': round(bias, 3), # > 0 means judge inflates
'calibration_slope': round(slope, 3),
'calibration_intercept': round(intercept, 3),
# Corrected score = slope * judge_score + intercept
'correction_formula': f'human_score ≈ {slope:.2f} * judge + {intercept:.2f}'
}Aplicando a correção de calibração
Depois de obter a regressão de calibração (inclinação e intercepto), aplique-a para transformar as pontuações brutas do avaliador em pontuações calibradas que correspondam melhor aos julgamentos humanos. Essa correção linear é simples e eficaz. Limite a pontuação corrigida à faixa válida (1 a 5) para impedir valores fora dos limites produzidos pela regressão. Armazene as pontuações brutas e corrigidas para permitir comparações retrospectivas à medida que os dados de calibração aumentarem.
def calibrate_score(raw_judge_score: float, slope: float, intercept: float,
min_score: int = 1, max_score: int = 5) -> float:
corrected = slope * raw_judge_score + intercept
return max(min_score, min(max_score, round(corrected, 1)))
# Example: if judge inflates by 0.5 points on average
# slope=0.85, intercept=0.3
# raw_score=4 -> corrected = 0.85*4 + 0.3 = 3.7Encontrando padrões de erros sistemáticos
Agrupe os erros de calibração por tipo de pergunta, tamanho da resposta e área temática para encontrar falhas recorrentes. O avaliador pode não ser confiável em perguntas técnicas de programação, mas ser preciso em perguntas factuais. Ele pode atribuir pontuações altas demais a respostas muito longas e baixas demais a respostas curtas e concisas. Esses padrões orientam melhorias específicas na rubrica ou comandos específicos por tema para os domínios em que a calibração é mais fraca.
from collections import defaultdict
def error_by_category(pairs: list) -> dict:
by_cat = defaultdict(list)
for p in pairs:
error = abs(p['judge'] - p['human'])
by_cat[p.get('category', 'unknown')].append(error)
return {
cat: {
'mean_error': round(sum(errs)/len(errs), 2),
'max_error': max(errs),
'n': len(errs)
}
for cat, errs in by_cat.items()
}Recalibrando à medida que os dados aumentam
A calibração não é uma tarefa única. À medida que você coleta mais avaliações humanas e as atualizações do modelo alteram o comportamento do avaliador, repita a calibração trimestralmente. Acompanhe as métricas de calibração ao longo do tempo — se a correlação de Pearson cair abaixo de 0,7, investigue se uma atualização do modelo alterou a distribuição das pontuações do avaliador. Automatize o processo de calibração para que repeti-lo seja um único comando que produza um coeficiente de correção atualizado.
def run_calibration_pipeline(calibration_data: list) -> dict:
# 1. Measure human inter-rater agreement
ira = measure_inter_rater_agreement(
[d['rater_1'] for d in calibration_data],
[d['rater_2'] for d in calibration_data]
)
# 2. Run judge on all items
pairs = run_judge_on_calibration(calibration_data)
# 3. Compute correlation metrics
metrics = calibration_metrics(pairs)
# 4. Detect bias
bias = detect_score_bias(pairs)
return {'ira': ira, 'metrics': metrics, 'bias': bias}Documentando a configuração do avaliador
Documente o modelo avaliador, a versão do comando, o tamanho e a data do conjunto de dados de calibração, as métricas de calibração e quaisquer coeficientes de correção em um arquivo de configuração do avaliador incluído no controle de versões. Isso cria um registro de auditoria para que futuros membros da equipe entendam por que as pontuações são como são e para que você possa detectar quando alterações nas métricas se devem à reconfiguração do avaliador, e não a mudanças reais de qualidade.
# judge_config.yaml
# judge_model: gpt-4o-2025-01-01
# judge_prompt_version: v3.2
# calibration_date: 2026-05-15
# calibration_set_size: 312
# calibration_metrics:
# pearson_r: 0.81
# spearman_r: 0.79
# mae: 0.54
# bias_correction:
# slope: 0.88
# intercept: 0.45
# next_recalibration: 2026-08-15Comandos do avaliador específicos por dimensão
Um único comando de avaliador que pontua várias dimensões ao mesmo tempo geralmente produz pontuações correlacionadas — o avaliador atribui alta correção porque atribuiu alta clareza, ancorando-se na primeira impressão. Comandos específicos por dimensão avaliam cada critério de forma independente, em uma chamada de API separada. Isso é mais caro, mas produz pontuações mais confiáveis e genuinamente independentes. Use comandos separados para dimensões cujas pontuações você espera que variem de forma independente.
async def multi_dimension_judge(question: str, answer: str) -> dict:
# Run each dimension as a separate judge call
correctness, helpfulness, clarity = await asyncio.gather(
judge_single_dimension(question, answer, 'correctness'),
judge_single_dimension(question, answer, 'helpfulness'),
judge_single_dimension(question, answer, 'clarity')
)
return {
'correctness': correctness,
'helpfulness': helpfulness,
'clarity': clarity,
'composite': 0.5 * correctness + 0.3 * helpfulness + 0.2 * clarity
}Verificação rápida
Teste sua compreensão sobre a calibração de modelos avaliadores LLM com base em avaliações humanas.
Recapitulação da lição
Nesta lição, você aprendeu que conjuntos de dados de calibração com pontuações consensuais humanas fornecem uma referência para medir a confiabilidade do avaliador; a correlação de Pearson e o MAE quantificam o quanto o avaliador acompanha os julgamentos humanos; e a correção linear de viés ajusta atribuições de pontuação sistematicamente altas ou baixas demais. Em seguida, você aprenderá a criar um processo contínuo de avaliação integrado à CI/CD.
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 “Calibrando modelos avaliadores em relação a humanos” é grátis?
Sim — o texto completo de “Calibrando modelos avaliadores em relação a humanos” é 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 “Calibrando modelos avaliadores em relação a humanos”?
Colete um conjunto de dados de referência com julgamentos de preferência humana, meça a concordância entre avaliadores e humanos com o Kappa de Cohen e ajuste o prompt do avaliador para reduzir viese… 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 “Calibrando modelos avaliadores em relação a humanos”?
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
- O padrão LLM como juiz
- Avaliação ponto a ponto e em pares
- Calibrando modelos avaliadores em relação a humanos
- Criando um pipeline de avaliação contínua