AI Engineering Academy · Lección

Calibración de modelos juez frente a evaluadores humanos

Recopile un conjunto de datos de referencia con evaluaciones de preferencias humanas, mida la concordancia entre el evaluador y las personas mediante la kappa de Cohen y ajuste el prompt del evaluador para reducir sesgos sistemáticos.

Lección 3 de 413 pasos

Calibración de modelos juez frente a evaluadores humanos 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.

Por qué la calibración es imprescindible

Un evaluador LLM sin calibrar puede asignar sistemáticamente puntuaciones más altas o más bajas que las personas, preferir un estilo de redacción concreto o fallar en casos límite que su rúbrica no había previsto. Si utiliza un evaluador así para tomar decisiones de despliegue, está confiando en un instrumento sesgado. La calibración valida el evaluador frente a la referencia objetiva humana y cuantifica cuánto puede confiar en sus puntuaciones antes de utilizarlas en producción.

Creación de un conjunto de datos de calibración

Cree un conjunto de calibración de entre 100 y 500 respuestas de ejemplo que hayan sido evaluadas por personas. Procure que sea diverso: incluya respuestas de alta calidad (puntuación 5), de calidad media (puntuación 3) y claramente deficientes (puntuación 1). Haga que entre 3 y 5 evaluadores humanos independientes puntúen cada ejemplo para medir la concordancia entre evaluadores y calcule una puntuación de referencia consensuada mediante el promedio o la 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 cases

Medición de la concordancia entre evaluadores

Antes de confiar en las puntuaciones humanas como referencia objetiva, compruebe que los evaluadores humanos coinciden entre sí. La kappa de Cohen mide la concordancia entre dos evaluadores más allá de la esperada por azar: un valor superior a 0,6 es aceptable y uno superior a 0,8 es excelente. Para escalas de 5 puntos, calcule la kappa ponderada (con ponderaciones lineales). Una concordancia baja entre evaluadores significa que la tarea está definida de forma ambigua; mejore las directrices para los evaluadores antes de utilizar las puntuaciones para calibrar un evaluador.

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
    }

Ejecución del evaluador con datos de calibración

Ejecute el evaluador LLM en cada ejemplo del conjunto de calibración utilizando el mismo prompt que planea usar en producción. Recopile la puntuación del evaluador para cada ejemplo junto con la puntuación consensuada por las personas. Mantenga ambas listas alineadas para poder compararlas elemento por elemento. Esta comparación por pares es la que revela los sesgos sistemáticos y las diferencias en el intervalo de puntuaciones.

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 pairs

Cálculo de la correlación entre el evaluador y las personas

Calcule la correlación de Pearson entre las puntuaciones del evaluador y las puntuaciones consensuadas por las personas. Esto mide la concordancia lineal: una correlación de 1,0 significa que el evaluador sigue perfectamente las clasificaciones humanas. Calcule también el error absoluto medio (MAE) para conocer la diferencia media entre puntuaciones. Una correlación superior a 0,7 y un MAE inferior a 0,8 puntos en una escala de 5 puntos suelen indicar que el evaluador es suficientemente fiable para producción.

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
    }

Identificación de sesgos sistemáticos

Además de la correlación, busque sesgos sistemáticos: ¿el evaluador asigna puntuaciones demasiado altas o demasiado bajas de forma constante? Represente las puntuaciones del evaluador frente a las puntuaciones humanas y busque una línea de regresión que no pase por el origen. Si el evaluador asigna 4 cuando las personas asignan 3 de media, presenta un sesgo de inflación. Corríjalo ajustando la rúbrica o aplicando una transformación lineal de calibración a las puntuaciones sin procesar.

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}'
    }

Aplicación de la corrección de calibración

Una vez que tenga la regresión de calibración (pendiente e intercepto), aplíquela para transformar las puntuaciones sin procesar del evaluador en puntuaciones calibradas que se ajusten mejor a las valoraciones humanas. Esta corrección lineal es sencilla y eficaz. Limite la puntuación corregida al intervalo válido (1-5) para evitar valores fuera de rango producidos por la regresión. Guarde tanto las puntuaciones sin procesar como las corregidas para permitir comparaciones retrospectivas a medida que aumenten los datos de calibración.

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.7

Detección de patrones de error sistemáticos

Agrupe los errores de calibración por tipo de pregunta, longitud de la respuesta y área temática para encontrar fallos recurrentes. El evaluador puede no ser fiable en preguntas técnicas de programación, pero sí ser preciso en preguntas factuales. Puede asignar puntuaciones demasiado altas a respuestas muy largas y demasiado bajas a respuestas breves y concisas. Estos patrones orientan mejoras específicas de la rúbrica o prompts del evaluador adaptados a cada tema en los ámbitos donde la calibración es más débil.

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()
    }

Recalibración a medida que crecen los datos

La calibración no es una tarea que se realice una sola vez. A medida que recopile más valoraciones humanas y las actualizaciones del modelo modifiquen el comportamiento del evaluador, vuelva a ejecutar la calibración cada trimestre. Realice un seguimiento de las métricas de calibración a lo largo del tiempo; si la correlación de Pearson cae por debajo de 0,7, investigue si una actualización del modelo modificó la distribución de puntuaciones del evaluador. Automatice el flujo de calibración para que volver a ejecutarlo sea un único comando que genere un coeficiente de corrección actualizado.

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}

Documentación de la configuración del evaluador

Documente el modelo evaluador, la versión del prompt, el tamaño y la fecha del conjunto de datos de calibración, las métricas de calibración y cualquier coeficiente de corrección en un archivo de configuración del evaluador incluido en el control de versiones. Esto crea un registro de auditoría para que los futuros miembros del equipo entiendan por qué las puntuaciones son como son y para que pueda detectar cuándo los cambios en las métricas se deben a una reconfiguración del evaluador y no a cambios reales de calidad.

# 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-15

Prompts del evaluador específicos para cada dimensión

Un único prompt de evaluación que puntúa varias dimensiones a la vez suele producir puntuaciones correlacionadas: el evaluador asigna una corrección alta porque también ha asignado una claridad alta, anclándose en su primera impresión. Los prompts específicos para cada dimensión evalúan cada criterio de forma independiente en una llamada de API separada. Es más costoso, pero produce puntuaciones más fiables que son realmente mediciones independientes. Utilice prompts separados para las dimensiones en las que espere que las puntuaciones varíen de forma independiente.

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
    }

Comprobación rápida

Compruebe su comprensión de la calibración de modelos evaluadores LLM frente a valoraciones humanas.

Resumen de la lección

En esta lección ha aprendido que los conjuntos de datos de calibración con puntuaciones consensuadas por personas proporcionan una referencia objetiva para medir la fiabilidad del evaluador; la correlación de Pearson y el MAE cuantifican hasta qué punto el evaluador sigue las valoraciones humanas; y la corrección lineal del sesgo ajusta las puntuaciones sistemáticamente demasiado altas o demasiado bajas. A continuación creará un flujo de evaluación continua integrado con CI/CD.

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 «Calibración de modelos juez frente a evaluadores humanos» es gratis?

Sí — el texto completo de «Calibración de modelos juez frente a evaluadores humanos» 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 «Calibración de modelos juez frente a evaluadores humanos»?

Recopile un conjunto de datos de referencia con evaluaciones de preferencias humanas, mida la concordancia entre el evaluador y las personas mediante la kappa de Cohen y ajuste el prompt del evaluado… 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 «Calibración de modelos juez frente a evaluadores humanos»?

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. El patrón LLM como juez
  2. Evaluación puntual y por pares
  3. Calibración de modelos juez frente a evaluadores humanos
  4. Creación de un pipeline de evaluación continua
← Volver a AI Engineering Academy