---
title: "Evaluar un LLM antes de cambiar: conjunto de eval y LLM juez"
description: "Cree un pequeño conjunto de evaluación con tráfico real, puntúelo con código y un LLM juez sin sesgos, y compare calidad, costo y latencia antes de migrar."
url: https://broadrouter.com/es/blog/evaluate-llm-before-switching/
lang: es
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traducido del inglés con ayuda de IA. [Lea el original en inglés](https://broadrouter.com/blog/evaluate-llm-before-switching/) (actualizado el 2026-11-14).

# Cómo evaluar un LLM antes de cambiar de proveedor

Por el equipo de BroadNet Inference · 5 min de lectura · Publicado 2026-11-14

Reúna de 50 a 200 prompts reales con resultados correctos conocidos. Puntúe ambos modelos primero con verificaciones de código y con un LLM juez solo donde el código no pueda decidir. Invierta el orden de las respuestas para anular el sesgo de posición, use un juez de una tercera familia de modelos, contrástelo con sus propias etiquetas y fije la regla de aprobación, incluidos costo y latencia, antes de ejecutarla.

## Puntos clave

-   Cree el conjunto de evaluación a partir de registros reales, no de prompts inventados, e incluya los casos difíciles y los que fallan.
-   Prefiera verificaciones deterministas (el JSON se analiza, el campo es igual, la prueba pasa). Use un LLM juez solo para cualidades que el código no puede comprobar.
-   Los LLM jueces muestran sesgos de posición, de verbosidad y de autopreferencia. Juzgue cada par dos veces invirtiendo el orden.
-   Con 100 casos, una puntuación del 80 % tiene un margen al 95 % de unos ±8 puntos. Las diferencias pequeñas son ruido.
-   Decida de antemano la regla de aprobación, incluidos costo, latencia y ninguna regresión en los casos críticos.

**En esta página**

1.  ¿Cómo crear un conjunto de evaluación a partir de tráfico real?
2.  ¿Qué verificaciones deben ser código y cuáles un juez?
3.  ¿Qué falla con un LLM como juez?
4.  ¿Cómo hacer una comparación lado a lado?
5.  ¿Qué diferencia es real?
6.  ¿Cuál debe ser la regla de decisión?
7.  Dónde encaja BroadNet Inference

Para evaluar un LLM antes de cambiar, ejecute ambos modelos con 50 a 200 prompts reales cuyo resultado correcto conozca. Puntúe primero con verificaciones de código y con un LLM juez sin sesgos solo donde el código no pueda decidir, registre costo y latencia, y fije de antemano la regla de aprobación.

El cambio de código en sí es pequeño: con una [API compatible con OpenAI](https://broadrouter.com/es/glossary/openai-compatible-api/) se reduce a una [base URL](https://broadrouter.com/es/glossary/base-url/) y un ID de modelo. La [lista de verificación de migración](https://broadrouter.com/es/blog/openai-compatible-api-migration-checklist/) cubre esa parte, y la [lista de verificación de proveedores](https://broadrouter.com/es/blog/choose-llm-api-provider-checklist/) cubre precio, límites y privacidad. Lo difícil es saber si el modelo nuevo es igual de bueno **para sus tareas**. Las tablas de clasificación públicas no responden a eso; [Artificial Analysis y sus alternativas](https://broadrouter.com/es/blog/artificial-analysis-alternatives/) sirven para armar una lista corta. Lo que sí responde es un pequeño conjunto de [evaluación](https://broadrouter.com/es/glossary/eval/) creado con su propio tráfico, en uno o dos días de trabajo.

## ¿Cómo crear un conjunto de evaluación a partir de tráfico real?

1.  **Extraiga de 300 a 1,000 solicitudes recientes** de sus [registros de uso](https://broadrouter.com/es/blog/llm-api-usage-logging/), tras anonimizarlas.
2.  **Agrúpelas por tipo de tarea**: extracción, clasificación, resumen, respuesta de chat, edición de código, llamada a herramienta.
3.  **Tome una muestra de 10 a 40 por tipo**, más en los tipos de alto volumen o alto riesgo. Incluya prompts largos, entradas que no estén en inglés y los casos de los que se quejaron los usuarios.
4.  **Escriba el resultado esperado** de cada uno: un valor exacto, un esquema, una prueba que debe pasar o una rúbrica breve (“menciona el plazo de reembolso; ninguna política inventada”).
5.  **Etiquete los casos críticos.** Un total de factura erróneo o una instrucción filtrada no es lo mismo que un tono un poco peor.
6.  **Congélelo** en el control de versiones. Añada casos cuando encuentre fallos nuevos y nunca los elimine para que un modelo quede mejor.

## ¿Qué verificaciones deben ser código y cuáles un juez?

Use la verificación fiable más barata para cada caso:

| Tarea | Verificación | ¿Necesita juez? |
| --- | --- | --- |
| Extracción a JSON | Se analiza, valida contra el esquema, los campos son iguales a lo esperado | No |
| Clasificación | La etiqueta es igual a la esperada | No |
| Edición de código | Las pruebas pasan | No |
| Llamada a herramienta | Función correcta, los argumentos validan | No |
| Resumen | Contiene los hechos requeridos; ningún hecho ausente de la fuente | A veces |
| Respuesta de chat, tono, utilidad | Rúbrica | Sí |

Las verificaciones deterministas son gratuitas, repetibles e imposibles de halagar, así que lleve a verificaciones de código tantos casos como pueda.

## ¿Qué falla con un LLM como juez?

Un [LLM como juez](https://broadrouter.com/es/glossary/llm-as-judge/) es un modelo que califica las respuestas de otros modelos según una rúbrica. El estudio de MT-Bench (Zheng et al.) halló que los jueces potentes coincidían con las preferencias humanas más del 80 % de las veces, aproximadamente tanto como los humanos coinciden entre sí. El mismo artículo identificó los sesgos que hay que tener en cuenta al diseñar:

| Sesgo | Qué ocurre | Mitigación |
| --- | --- | --- |
| Posición | Prefiere la primera (o la segunda) respuesta mostrada | Juzgue cada par dos veces con el orden invertido; cuente una victoria solo si ambas coinciden |
| Verbosidad | Prefiere respuestas más largas | Rúbrica que premie la corrección y la brevedad; limite la longitud en el prompt |
| Autopreferencia | Prefiere respuestas con su propio estilo | Juez de una familia de modelos distinta a la de ambos candidatos |
| Razonamiento débil | Pasa por alto errores de matemáticas o de código | Use verificaciones de código para esos casos |

Dos reglas más de la práctica. **Fije el juez**: misma versión del modelo, mismo prompt, temperatura 0, durante toda la comparación. Y **calíbrelo**: etiquete usted mismo de 30 a 50 pares, ejecute el juez sobre ellos y confíe en él solo si coincide con usted la mayoría de las veces. La guía de evaluadores de Arize da el mismo consejo (“Collect 20–100 examples”; Traducción: reúna de 20 a 100 ejemplos) con etiquetas humanas, y recomienda etiquetas categóricas como aprobado/suspenso en lugar de escalas numéricas amplias.

## ¿Cómo hacer una comparación lado a lado?

Ejecute ambos candidatos en cada caso, oculte al juez qué modelo es cuál, invierta el orden y registre costo y tiempo:

```python
import os, random, time, json
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
A, B = "broadnet/deepseek-v4.1-flash", "broadnet/qwen3.8-27b"
JUDGE = "broadnet/glm-5.3"  # a third family, pinned

def run(model, case):
    t0 = time.perf_counter()
    r = client.chat.completions.create(model=model, messages=case["messages"], max_tokens=4000, temperature=0)
    return {"text": r.choices[0].message.content or "", "usage": r.usage.model_dump(),
            "secs": time.perf_counter() - t0}

def judge(case, first, second):
    prompt = (f"Task:\n{case['task']}\n\nRubric:\n{case['rubric']}\n\n"
              f"Answer 1:\n{first}\n\nAnswer 2:\n{second}\n\n"
              'Reply with JSON only: {"winner": 1 or 2 or 0 for tie, "reason": "..."}')
    r = client.chat.completions.create(model=JUDGE, temperature=0, max_tokens=2000,
                                       response_format={"type": "json_object"},
                                       messages=[{"role": "user", "content": prompt}])
    return int(json.loads(r.choices[0].message.content or "{}").get("winner", 0))

def compare(case):
    a, b = run(A, case), run(B, case)
    if case.get("check"):                       # deterministic first
        return {"a_ok": case["check"](a["text"]), "b_ok": case["check"](b["text"]), "a": a, "b": b}
    w1 = judge(case, a["text"], b["text"])      # A shown first
    w2 = judge(case, b["text"], a["text"])      # B shown first
    winner = "A" if (w1, w2) == (1, 2) else "B" if (w1, w2) == (2, 1) else "tie"
    return {"winner": winner, "a": a, "b": b}
```

La regla de inversión significa que un modelo gana solo cuando el juez lo prefiere en ambas posiciones; cualquier desacuerdo cuenta como empate. La proporción de desacuerdos es útil en sí misma: una tasa alta indica que el juez o la rúbrica son demasiado vagos. Fíjese en `max_tokens=4000`: en los modelos de razonamiento, el pensamiento cuenta para el límite, y un tope bajo produce respuestas vacías que parecen fallos. Consulte [por qué los modelos de razonamiento devuelven respuestas vacías](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/).

## ¿Qué diferencia es real?

Las puntuaciones de una evaluación son muestras. Para una tasa de aprobación p sobre n casos, el error estándar es √(p × (1 − p) ÷ n), y un margen al 95 % es aproximadamente el doble.

| Casos | Tasa de aprobación | Margen al 95 % |
| --- | --- | --- |
| 50 | 80 % | unos ±11 puntos |
| 100 | 80 % | unos ±8 puntos |
| 200 | 80 % | unos ±6 puntos |
| 400 | 80 % | unos ±4 puntos |

Así que un modelo que obtiene un 82 % frente a un 79 % en 100 casos no ha demostrado ser mejor. Fíjese en cambio en las **diferencias por caso**: ¿qué casos pasaron de aprobado a suspenso? Eso le dice más que los totales, y en los casos críticos un solo cambio puede decidir la migración.

## ¿Cuál debe ser la regla de decisión?

Escríbala antes de ejecutar la evaluación, para que el resultado no pueda torcerla. Una plantilla práctica:

1.  Ninguna regresión en ningún caso etiquetado como crítico.
2.  Una tasa de aprobación global no inferior a la del modelo actual en más que el margen de error.
3.  Latencia p95 dentro de su presupuesto; consulte [TTFT frente a throughput](https://broadrouter.com/es/blog/llm-latency-ttft-throughput/) para saber cómo medirla.
4.  Costo por caso exitoso más bajo, o más alto solo en una cantidad que se haya acordado que la calidad justifica. Calcule la diferencia mensual con la [calculadora de costos de API de LLM](https://broadrouter.com/tools/llm-api-cost-calculator/).
5.  Un periodo en sombra: envíe una parte del tráfico real al modelo nuevo, registre ambos y compare antes de hacer el cambio definitivo.

El mismo conjunto de evaluación es el punto de partida si está pensando en un modelo personalizado: [antes del fine-tuning](https://broadrouter.com/es/blog/fine-tuning-readiness/) explica cuándo bastan los prompts y la recuperación.

## Dónde encaja BroadNet Inference

BroadNet Inference sirve varias familias de modelos detrás de un único endpoint compatible con OpenAI, entre ellas [DeepSeek V4.1 Flash](https://broadrouter.com/es/models/deepseek-v4.1-flash/), [GLM 5.3](https://broadrouter.com/es/models/glm-5.3/) y [Qwen3.8 27B](https://broadrouter.com/es/models/qwen3.8-27b/), así que los candidatos y un juez de otra familia pueden ejecutarse con el mismo cliente y la misma clave. Cada respuesta incluye el uso de tokens para comparar costos, y las cuentas nuevas empiezan con $5 de crédito; sin recarga, ese crédito solo sirve para [Gemma 4 VL 26B](https://broadrouter.com/es/models/gemma-4-vl-26b/), así que prevea una pequeña recarga para comparar los modelos más grandes. No incluye un entorno de evaluación ni herramientas de juez alojadas; usted ejecuta el código de arriba. Para cargas de trabajo en árabe, [elegir un LLM para árabe](https://broadrouter.com/es/blog/choosing-an-llm-for-arabic/) enumera qué probar. Los precios lado a lado están en la [página de comparación](https://broadrouter.com/compare/).

Herramientas gratuitas sobre este tema (en inglés)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Herramientas gratuitas (en inglés)](https://broadrouter.com/tools/)

## Términos de este artículo

[Evaluación de LLM (eval)](https://broadrouter.com/es/glossary/eval/)

Una eval (abreviatura de evaluation, evaluación) es una prueba repetible de un modelo de lenguaje o de un prompt: un conjunto fijo de entradas, una descripción de cómo es una buena salida y un calificador (código, una persona u otro modelo) que puntúa cada salida para poder comparar versiones.

[LLM como juez (LLM-as-a-judge)](https://broadrouter.com/es/glossary/llm-as-judge/)

LLM como juez (LLM-as-a-judge) es un método de evaluación en el que un modelo de lenguaje califica las salidas de otros modelos, ya sea puntuando una respuesta según una rúbrica o eligiendo la mejor de dos. Se aproxima al juicio humano a un costo mucho menor, pero tiene sesgos conocidos, como favorecer la primera respuesta o la más larga.

[Crédito prepago (prepaid credit)](https://broadrouter.com/es/glossary/prepaid-credit/)

El crédito prepago es dinero que se añade a una cuenta de API antes de usarla. Cada solicitud descuenta su coste del saldo y, cuando el saldo se agota, las solicitudes medidas se detienen hasta que usted recargue. Limita el gasto a lo que ha pagado.

[Fine-tuning (ajuste fino)](https://broadrouter.com/es/glossary/fine-tuning/)

El fine-tuning (ajuste fino) es el proceso de seguir entrenando un modelo de lenguaje preentrenado con un conjunto de datos más pequeño y específico de una tarea, como conversaciones de ejemplo, para que sus pesos cambien y realice esa tarea o estilo con más fiabilidad sin necesitar instrucciones o ejemplos largos en cada prompt.

[Latencia (latency)](https://broadrouter.com/es/glossary/latency/)

La latencia, en una API de modelos de lenguaje, es el tiempo que tarda una solicitud desde que se envía hasta que se recibe el último token de salida. Es la suma del tiempo hasta el primer token y el tiempo de generación, y suele reportarse en percentiles como p50 y p95, no como promedio.

[Llamadas a herramientas (tool calling)](https://broadrouter.com/es/glossary/tool-calling/)

Las llamadas a herramientas (tool calling), también llamadas function calling, son una función de las APIs de LLM en la que el modelo devuelve una solicitud estructurada para ejecutar una función definida por el desarrollador, con argumentos JSON. La aplicación ejecuta la función y devuelve el resultado; el modelo nunca ejecuta código.

[Throughput (rendimiento total)](https://broadrouter.com/es/glossary/throughput/)

El throughput, en el servicio de LLMs, es la cantidad total de trabajo que un sistema completa por unidad de tiempo en todas las solicitudes concurrentes, normalmente medida en tokens de salida por segundo o solicitudes por segundo. Es distinto de la velocidad por stream, que es qué tan rápido recibe sus tokens una sola solicitud.

[Token](https://broadrouter.com/es/glossary/token/)

Un token es la unidad de texto que un modelo de lenguaje lee y escribe: una palabra, parte de una palabra, un signo de puntuación o una secuencia de bytes producida por el tokenizador del modelo. Las APIs de LLM cuentan, limitan y normalmente facturan el uso en tokens.

## Preguntas frecuentes

### ¿Cuántos ejemplos necesito en un conjunto de evaluación de LLM?

Cincuenta bastan para detectar regresiones grandes; 200, para ver diferencias de unos 5 a 10 puntos. La cobertura importa más que el tamaño, así que incluya todos los tipos de tarea y los casos de fallo que ya conoce.

### ¿Es fiable usar un LLM como juez?

En parte. En el estudio de MT-Bench, los jueces potentes coincidieron con las preferencias humanas más del 80 % de las veces, aproximadamente tanto como los humanos coinciden entre sí. También mostraron sesgos de posición, de verbosidad y de autoensalzamiento, así que corrija esos sesgos y revíselos por muestreo.

### ¿El modelo juez debe ser el mismo que el modelo que se prueba?

No. Los jueces tienden a favorecer las respuestas que se parecen a las suyas. Use un juez de otra familia de modelos y manténgalo fijo en una misma versión durante toda la comparación.

### ¿Qué es el sesgo de posición en la evaluación de LLM?

El juez prefiere la respuesta que aparece primero, o segunda, sin importar su calidad. Se corrige juzgando cada par dos veces con el orden invertido y contando una victoria solo cuando ambos órdenes coinciden.

### ¿Debo comparar costo y latencia en la misma evaluación?

Sí. Registre tokens y tiempo en cada llamada de la evaluación. Un modelo que puntúa dos puntos más con el triple de costo o de latencia puede seguir siendo un mal cambio.

## Siga leyendo

-   [Cómo elegir un proveedor de API de LLM: lista de 20 puntos](https://broadrouter.com/es/blog/choose-llm-api-provider-checklist/)
-   [Cambiar a una API compatible con OpenAI: lista de verificación](https://broadrouter.com/es/blog/openai-compatible-api-migration-checklist/)
-   [Cómo elegir una API de LLM para árabe: qué probar](https://broadrouter.com/es/blog/choosing-an-llm-for-arabic/)
-   [Registro de uso de API de LLM: costo por usuario y función, sin PII](https://broadrouter.com/es/blog/llm-api-usage-logging/)
-   [Latencia de LLM: TTFT, tokens por segundo y latencia total](https://broadrouter.com/es/blog/llm-latency-ttft-throughput/)
-   [Antes del fine-tuning: defina el problema que quiere resolver](https://broadrouter.com/es/blog/fine-tuning-readiness/)
-   [El hardware GPU de BroadNet y cómo sirve los modelos, según BroadNet](https://broadrouter.com/es/blog/broadnet-gpu-fleet-and-serving/)
-   [Caché de respuestas de APIs de LLM para reducir costos en Python](https://broadrouter.com/es/blog/cache-llm-responses-cut-cost/)
-   [Guía: Usar el SDK de OpenAI para Python con BroadNet Inference](https://broadrouter.com/es/guides/openai-python-sdk/)
-   [Guía: ¿Por qué un modelo de razonamiento devuelve una respuesta vacía?](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/)

Pruébelo con su carga de trabajo real. Las cuentas nuevas empiezan con USD 5 de crédito para Gemma y transcripción. DeepSeek, GLM y Qwen3.8 requieren una recarga.

[Comenzar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-evaluate-llm-before-switching&utm_content=page-cta) ·

**Fuentes**

-   [Zheng et al., Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena, arXiv 2306.05685 (consultado el 2026-11-14)](https://arxiv.org/abs/2306.05685)
-   [Documentación de Arize, buenas prácticas para evaluadores (consultado el 2026-11-14)](https://arize.com/docs/ax/concepts/evaluators/evaluator-best-practices)
-   [Referencia de la API de BroadNet Inference (consultado el 2026-11-14) (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-evaluate-llm-before-switching&utm_content=sources)
-   [Precios de BroadNet Inference en formato legible por máquina, pricing.json (consultado el 2026-11-14) (en inglés)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-evaluate-llm-before-switching&utm_content=sources)
