AI Engineering Academy · Lección

El patrón LLM como juez

Comprenda cómo solicitar a un LLM potente que puntúe o compare resultados según criterios como corrección, utilidad y tono, y por qué este método escala mejor que la evaluación humana.

Lección 1 de 413 pasos

El patrón LLM como juez es una lección gratuita de AI Engineering Academy en CoddyKit. Esta es la lección 1 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é es necesaria la evaluación automatizada

Evaluar manualmente las salidas de los LLM es lento y costoso. Un equipo de evaluadores humanos puede analizar unos cientos de salidas por semana, pero un sistema en producción genera miles al día. LLM-as-judge utiliza un modelo de lenguaje potente para evaluar a gran escala la calidad de las salidas de otros LLM, lo que permite realizar pruebas de regresión automatizadas y supervisar continuamente la calidad sin contratar a un gran número de anotadores.

La idea principal: un LLM evalúa a otro

En LLM-as-judge, envía a un modelo juez (normalmente GPT-4o o Claude) un prompt de sistema que define los criterios de evaluación, la pregunta original, la respuesta del modelo y, opcionalmente, una respuesta de referencia. El juez devuelve una puntuación numérica, una etiqueta o una clasificación. Esto funciona porque los modelos de última generación comprenden suficientemente conceptos de calidad como la corrección, la utilidad y la coherencia.

JUDGE_SYSTEM_PROMPT = '''
You are an expert evaluator of AI-generated responses.
Given a question and an AI-generated answer, score the answer on:
- Correctness (0-5): Is the information factually accurate?
- Completeness (0-5): Does it fully address the question?
- Clarity (0-5): Is it easy to understand?
Return a JSON object with scores and a brief rationale.
'''

Redacción de un prompt para el juez

Un buen prompt para el juez especifica rúbricas explícitas con definiciones de las puntuaciones, en lugar de términos imprecisos como «bueno» o «malo». Defina concretamente qué significa una puntuación de 5, 3 o 1 para cada criterio. Proporcione la pregunta, la respuesta que se va a evaluar y, opcionalmente, una respuesta de referencia. Pida el razonamiento antes de la puntuación (chain-of-thought) para reducir las puntuaciones arbitrarias.

def build_judge_prompt(question: str, answer: str, reference: str = None) -> str:
    ref_section = f'Reference answer:\n{reference}\n\n' if reference else ''
    return f'''
Question: {question}

{ref_section}Answer to evaluate:
{answer}

Score this answer on correctness (1-5) where:
5 = Completely accurate, no factual errors
3 = Mostly accurate with minor errors
1 = Contains significant factual errors

First explain your reasoning, then provide the score as JSON:
{{"correctness": <1-5>, "rationale": "..."}}
'''

Llamada al modelo juez

Llame al modelo juez con su prompt de evaluación. Analice la respuesta JSON para extraer las puntuaciones. Utilice siempre salidas estructuradas o el modo JSON para garantizar que el juez devuelva datos analizables. Utilizar el mismo modelo como sistema evaluado y como juez puede introducir sesgos; prefiera un modelo diferente o, al menos, una configuración distinta para el juez.

from pydantic import BaseModel
import instructor
from openai import OpenAI

class JudgeScore(BaseModel):
    correctness: int
    completeness: int
    clarity: int
    rationale: str

judge_client = instructor.from_openai(OpenAI())

def judge(question: str, answer: str) -> JudgeScore:
    return judge_client.chat.completions.create(
        model='gpt-4o',  # Use stronger judge than the model being tested
        response_model=JudgeScore,
        messages=[
            {'role': 'system', 'content': JUDGE_SYSTEM_PROMPT},
            {'role': 'user', 'content': build_judge_prompt(question, answer)}
        ]
    )

Evaluación sin referencia frente a evaluación basada en referencias

Existen dos modos de evaluación mediante LLM. La evaluación sin referencia pide al juez que valore la calidad sin una respuesta verdadera de referencia, lo que resulta útil cuando no existe una respuesta correcta establecida, como en un chat abierto. La evaluación basada en referencias proporciona una respuesta de referencia y pregunta si la respuesta del modelo coincide con ella; es más adecuada para responder preguntas factuales cuya respuesta correcta se conoce. Utilice la evaluación basada en referencias cuando disponga de un conjunto de pruebas etiquetado.

# Reference-free: good for open-ended generation
judge_result = judge(question='What is machine learning?', answer=model_answer)

# Reference-based: better for factual QA
judge_result = judge(
    question='What year was Python created?',
    answer=model_answer,
    reference='Python was created by Guido van Rossum and released in 1991.'
)

Control del sesgo del juez

Los jueces LLM presentan sesgos conocidos: prefieren las respuestas más largas (sesgo de verbosidad), las respuestas que suenan seguras y las respuestas que coinciden con el estilo de sus datos de entrenamiento. Mitigue el sesgo de verbosidad penalizando explícitamente la longitud innecesaria en su rúbrica. Reduzca el sesgo de posición en las comparaciones por pares aleatorizando qué respuesta aparece primero y promediando las puntuaciones de ambos órdenes.

# Anti-verbosity note in rubric:
ANTI_VERBOSITY_CLAUSE = '''
Note: A concise, accurate answer should score higher than a long,
rambling answer that happens to contain the correct information.
Do not reward length for its own sake.
'''

# Position-debiasing for pairwise comparison:
async def debiased_pairwise(q, a, b):
    score_ab = await compare(q, answer_a=a, answer_b=b)
    score_ba = await compare(q, answer_a=b, answer_b=a)
    # A wins if it wins in both orderings
    a_wins = (score_ab == 'A' and score_ba == 'B')
    return 'A' if a_wins else 'B' if (score_ab == 'B' and score_ba == 'A') else 'tie'

Agrupación de evaluaciones para aumentar la velocidad

Ejecute las evaluaciones del juez en paralelo para evaluar rápidamente conjuntos de pruebas grandes. Con asyncio y un semáforo, puede evaluar cientos de salidas por minuto. Mantenga un presupuesto de límite de solicitudes independiente para las llamadas al juez (también consumen tokens) y considere utilizar un modelo juez más pequeño, pero capaz, como GPT-4o-mini para los criterios que no requieren un razonamiento profundo. Reserve GPT-4o para los criterios más importantes.

import asyncio

async def batch_judge(qa_pairs: list, concurrency: int = 20) -> list:
    sem = asyncio.Semaphore(concurrency)

    async def judge_one(item):
        async with sem:
            return await async_judge(item['question'], item['answer'])

    return await asyncio.gather(
        *[judge_one(item) for item in qa_pairs],
        return_exceptions=True
    )

Agregación de las puntuaciones del juez

Después de evaluar un conjunto de pruebas, agregue las puntuaciones en estadísticas resumidas: media, mediana y porcentaje de respuestas que superan un umbral de calidad (por ejemplo, corrección ≥ 4). Compare estos agregados entre versiones del modelo o variaciones del prompt. Una disminución superior al 5 % en la tasa de respuestas por encima del umbral debería activar una revisión antes de implementar la nueva versión.

import statistics

def summarize_judge_results(scores: list) -> dict:
    correctness = [s.correctness for s in scores if isinstance(s, JudgeScore)]
    return {
        'n': len(correctness),
        'mean_correctness': round(statistics.mean(correctness), 2),
        'median_correctness': statistics.median(correctness),
        'pct_above_4': round(100 * sum(1 for s in correctness if s >= 4) / len(correctness), 1)
    }

Comparación de versiones de LLM con un juez

Utilice LLM-as-judge para comparar dos versiones de su sistema, por ejemplo, antes y después de cambiar un prompt. Ejecute ambas versiones con el mismo conjunto de preguntas de prueba, evalúe todas las salidas y calcule la tasa de victorias: el porcentaje de casos en los que la versión B obtiene una puntuación superior a la versión A. Una tasa de victorias superior al 55 % en más de 100 muestras suele ser estadísticamente significativa para justificar la implementación de la nueva versión.

async def ab_compare(test_questions: list, version_a, version_b) -> dict:
    a_wins = b_wins = ties = 0
    for q in test_questions:
        answer_a = await version_a.answer(q)
        answer_b = await version_b.answer(q)
        winner = await debiased_pairwise(q, answer_a, answer_b)
        if winner == 'A': a_wins += 1
        elif winner == 'B': b_wins += 1
        else: ties += 1
    total = len(test_questions)
    return {'a_win_rate': a_wins/total, 'b_win_rate': b_wins/total, 'tie_rate': ties/total}

Calibración de las puntuaciones del juez con evaluaciones humanas

Valide su juez comparando sus puntuaciones con evaluaciones humanas en un conjunto de calibración de 50 a 200 ejemplos. Calcule la correlación de Pearson entre las puntuaciones del juez y las humanas. Una correlación superior a 0.7 indica que el juez es fiable. Si la correlación es baja, revise el prompt del juez para identificar en qué puntos discrepa de los evaluadores humanos y añada ejemplos o aclaraciones a la rúbrica. No implemente nunca un juez sin calibrarlo.

from scipy.stats import pearsonr

def calibrate_judge(human_scores: list, judge_scores: list) -> dict:
    corr, p_value = pearsonr(human_scores, judge_scores)
    mean_abs_error = sum(abs(h - j) for h, j in zip(human_scores, judge_scores)) / len(human_scores)
    return {
        'pearson_r': round(corr, 3),
        'p_value': round(p_value, 4),
        'mean_abs_error': round(mean_abs_error, 2),
        'reliable': corr >= 0.7
    }

Cuándo no utilizar LLM-as-judge

LLM-as-judge no es adecuado para todos los escenarios de evaluación. Evítelo cuando: el criterio requiera conocimientos especializados que el modelo juez no posea (precisión de diagnósticos médicos o cumplimiento legal); necesite una evaluación defendible jurídicamente (se requiere revisión humana); evalúe un modelo más potente que el juez (el juez no puede puntuar de forma fiable una salida que no podría producir); o el presupuesto de evaluación sea demasiado limitado para asumir el costo adicional de la API. En estos casos, utilice evaluación humana o métricas deterministas.

# Appropriate uses of LLM-as-judge:
# YES: General helpfulness, clarity, tone, factual accuracy (general knowledge)
# YES: Code correctness for common languages
# YES: Translation quality comparison
# YES: Content safety classification
#
# NOT appropriate:
# NO: Medical/legal/financial accuracy (needs domain expert)
# NO: Evaluating GPT-4o with GPT-4o (same capability ceiling)
# NO: Formal compliance audits (non-deterministic judge)
# NO: Streaming quality at individual token level

Comprobación rápida

Compruebe su comprensión del patrón de evaluación LLM-as-judge.

Resumen de la lección

En esta lección aprendió que LLM-as-judge utiliza un modelo potente para evaluar la calidad a gran escala mediante rúbricas explícitas; los modos sin referencia y basados en referencias se adaptan a distintos escenarios de evaluación; y la calibración con evaluaciones humanas valida que el juez sea fiable antes de utilizarlo en producción. A continuación, implementaremos estrategias de evaluación individual y por pares.

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 «El patrón LLM como juez» es gratis?

Sí — el texto completo de «El patrón LLM como juez» 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 «El patrón LLM como juez»?

Comprenda cómo solicitar a un LLM potente que puntúe o compare resultados según criterios como corrección, utilidad y tono, y por qué este método escala mejor que la evaluación humana. 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 1 de 4.

¿Cuánto tiempo toma la lección «El patrón LLM como juez»?

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