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.
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 levelComprobació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.
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
- El patrón LLM como juez
- Evaluación puntual y por pares
- Calibración de modelos juez frente a evaluadores humanos
- Creación de un pipeline de evaluación continua