Explorar guías rápidas · Ingeniería de IA para datos
Elegir el modelo de IA adecuado
Un método práctico para elegir un modelo de IA para aplicaciones de datos: cuándo no usar un LLM, qué criterios importan, un árbol de decisión y cómo evaluar candidatos por calidad, latencia y costo por tarea completada.
En esta página
- Problema
- Respuesta rápida
- Primero: ¿necesitas un modelo?
- Criterios de comparación
- Árbol de decisión
- Código / comandos
- 1. Construir primero un conjunto de evaluación
- 2. Puntuar a los candidatos con los mismos casos
- 3. Comparar por costo por tarea completada
- 4. Exigir salida estructurada y validarla
- 5. Cascada: primero el modelo pequeño, escalar si falla
- 6. Añadir recuperación o herramientas para datos privados y actuales
- 7. Entrada multimodal
- 8. Revisar el rendimiento y los límites
- 9. El tamaño de la ventana de contexto no garantiza calidad
- 10. Fijar versiones y reevaluar ante cambios
- Qué significa el resultado
- Qué revisar
- Errores comunes
- 1. Usar un LLM para trabajo determinista
- 2. Elegir solo por rankings públicos
- 3. Usar por defecto el modelo más grande
- 4. Usar por defecto el modelo más barato
- 5. Esperar que el modelo conozca datos privados
- 6. Confiar en la salida sin validarla
- 7. Evaluar una sola vez
- Notas de producción
- Lista de comprobación
- Siguiente paso
- Para profundizar
Problema
Necesitas un modelo para una tarea de datos: extraer campos de documentos, clasificar tickets, generar SQL, resumir incidentes, responder preguntas sobre datos internos.
Hay muchas opciones: modelos pequeños y grandes, modelos de razonamiento, multimodales, de embedding, alojados o autoalojados. Cada uno equilibra calidad, latencia, costo, rendimiento y esfuerzo operativo.
Ningún modelo es la mejor opción para todas las tareas. La opción correcta es la más barata y rápida que alcanza tu nivel de calidad con tus propios datos, y a veces esa opción no es un LLM.
Respuesta rápida
¿La tarea es determinista (parsear, formatear, calcular, buscar)?
→ código normal, SQL, reglas o un parser. Sin LLM.
¿Extracción o clasificación simple, gran volumen?
→ modelo más pequeño y barato + salida estructurada + validación.
¿Razonamiento complejo, entrada ambigua, análisis en varios pasos?
→ modelo más grande o de razonamiento; mide la latencia y el costo.
¿Necesita datos actuales, privados o del dominio?
→ modelo + recuperación (RAG) o herramientas. El modelo no «conoce» tus datos.
¿Necesita una salida exacta y legible por máquina?
→ salida estructurada + validación de esquema + reintento o escalado.
¿La entrada incluye imágenes, escaneos o gráficos?
→ modelo multimodal, o primero OCR/parsing y después un modelo de texto.
Después, confírmalo con un conjunto de evaluación: precisión, latencia p95 y costo por tarea completada.
Primero: ¿necesitas un modelo?
| Tarea | Normalmente mejor sin LLM |
|---|---|
| Parsear fechas, correos, ID, formatos conocidos | Parser, regex, biblioteca |
| Agregaciones, totales, filtros | SQL |
| Búsquedas en datos de referencia | Join / diccionario |
| Reglas de negocio fijas | Reglas en código |
| Aritmética exacta | Código |
| Conversión de formatos (CSV → Parquet, JSON → tabla) | Código |
Un LLM encaja cuando la entrada es no estructurada o ambigua, cuando las reglas son difíciles de escribir o cuando la salida es lenguaje natural.
Un diseño robusto y habitual: código para todo lo determinista, el modelo solo para la parte ambigua.
Criterios de comparación
| Criterio | Qué significa | Cómo evaluarlo |
|---|---|---|
| Capacidad / tamaño | Calidad general en tareas complejas | Tu conjunto de evaluación, no solo rankings públicos |
| Profundidad de razonamiento | Lógica en varios pasos, planificación, análisis | Casos difíciles de tu dominio |
| Latencia | Tiempo hasta el primer token y hasta la respuesta completa | p50 y p95 con tus tamaños de prompt reales |
| Costo | Precio por token de entrada/salida, tokens consumidos | Costo por tarea completada |
| Ventana de contexto | Cuánta entrada cabe en una solicitud | Tu solicitud real más grande más la salida |
| Salida estructurada | Devuelve JSON / esquema válido de forma fiable | Tasa de validación correcta |
| Uso de herramientas | Llama correctamente a funciones y API | Tasa de herramienta y argumentos correctos |
| Soporte multimodal | Imágenes, documentos, audio | Tus archivos reales, incluidos los escaneos malos |
| Rendimiento (throughput) | Solicitudes y tokens por minuto disponibles | Límites del proveedor frente a tu pico |
| Fiabilidad | Consistencia, disponibilidad, estabilidad de versiones | Varianza entre ejecuciones; SLA; versiones fijadas |
| Tratamiento de datos | Dónde se procesan y conservan los datos | Tus requisitos de seguridad y cumplimiento |
Árbol de decisión
1. ¿Pueden resolverlo de forma fiable código, SQL, reglas o un parser?
sí → hazlo así. Fin.
2. ¿La entrada es privada, reciente o específica del dominio?
sí → planifica primero recuperación o herramientas (cualquier modelo las necesitará).
3. ¿Es extracción, clasificación o una transformación corta?
sí → empieza con un modelo más pequeño + salida estructurada.
4. ¿Necesita razonamiento en varios pasos o criterio sobre una entrada ambigua?
sí → prueba un modelo más grande o de razonamiento; compara latencia y costo.
5. ¿Es de gran volumen?
sí → prioriza el modelo más barato que pase; considera el procesamiento batch.
6. ¿Es interactivo?
sí → revisa la latencia p95; considera streaming y modelos más pequeños.
7. ¿La salida debe ser exacta?
sí → validación de esquema, comprobaciones deterministas, escalado ante fallos.
Código / comandos
1. Construir primero un conjunto de evaluación
- 50–200 casos reales y representativos para empezar, incluidos casos difíciles y límite
- la salida esperada de cada caso, o una regla de puntuación
- sin secretos; enmascara o sintetiza los valores sensibles
{"id": "case-017", "input": "Factura INV-2291 pagada dos veces el 2026-09-03", "expected": {"label": "billing_issue"}}
Sin esto, la elección del modelo es una opinión.
2. Puntuar a los candidatos con los mismos casos
import statistics
import time
def evaluate(call_model, model: str, cases: list[dict], is_correct) -> dict:
"""Ejecuta un modelo candidato sobre un conjunto de evaluación etiquetado."""
latencies, correct, cost = [], 0, 0.0
for case in cases:
started = time.monotonic()
result = call_model(model, case["input"]) # tu wrapper: devuelve {"output": ..., "cost": ...}
latencies.append(time.monotonic() - started)
cost += result["cost"]
correct += bool(is_correct(result["output"], case["expected"]))
return {
"model": model,
"accuracy": correct / len(cases),
"p50_s": statistics.median(latencies),
"p95_s": statistics.quantiles(latencies, n=20)[18],
"cost_per_correct": cost / correct if correct else float("inf"),
}
Ejecuta cada candidato más de una vez: las salidas pueden variar entre ejecuciones.
3. Comparar por costo por tarea completada
cost_per_successful_task = costo total (incluidos reintentos y escalados)
/ tareas que pasan la validación
Un modelo más barato con una tasa de acierto baja puede costar más por tarea completada que uno más caro.
| Modelo | Precisión | Latencia p95 | Costo por respuesta correcta |
|---|---|---|---|
| Pequeño | medida | medida | medido |
| Intermedio | medida | medida | medido |
| Grande / razonamiento | medida | medida | medido |
Elige la fila más barata que cumpla los objetivos de calidad y latencia.
4. Exigir salida estructurada y validarla
import json
LABELS = {"billing_issue", "access_issue", "data_issue", "other"}
def parse_label(raw: str) -> str | None:
"""Devuelve una etiqueta válida, o None para que quien llama reintente o escale."""
try:
data = json.loads(raw)
except json.JSONDecodeError:
return None
label = data.get("label") if isinstance(data, dict) else None
return label if label in LABELS else None
Usa la función de salida estructurada o de esquema JSON del proveedor cuando exista. Valida igualmente.
5. Cascada: primero el modelo pequeño, escalar si falla
def classify(text: str, call_model) -> str:
for model in ("small-model", "large-model"):
label = parse_label(call_model(model, text)["output"])
if label is not None:
return label
return "needs_review" # cola de revisión humana, no una suposición
Mide la tasa de escalado. Si la mayoría de los casos escalan, empieza por el modelo más grande.
6. Añadir recuperación o herramientas para datos privados y actuales
- El entrenamiento del modelo no incluye tus tablas, la ejecución del pipeline de ayer ni tus definiciones internas.
- Recupera documentos, ejecuta una consulta aprobada o llama a una API, y pasa el resultado como contexto.
- Elige el modelo por lo bien que usa el contexto proporcionado, no por lo que podría recordar.
La recuperación puede mejorar el anclaje en los datos, pero no garantiza la exactitud: documentos malos o ausentes siguen produciendo malas respuestas.
7. Entrada multimodal
- PDF escaneados, capturas de pantalla, gráficos: prueba un modelo multimodal con tus archivos reales, incluidos los de mala calidad.
- Alternativa: primero OCR o un parser de documentos y después un modelo de texto. Suele ser más barato y más fácil de depurar.
- Los modelos de embedding sirven para búsqueda y similitud, no para generar respuestas.
8. Revisar el rendimiento y los límites
peak_tokens_per_minute = peak_requests_per_minute × average_tokens_per_request
Compáralo con los límites de solicitudes y de tokens de cada candidato. Un modelo que cabe en el presupuesto pero no en el rendimiento también falla en producción.
9. El tamaño de la ventana de contexto no garantiza calidad
- Una ventana más grande permite enviar más, no necesariamente mejor.
- Las entradas largas cuestan más y son más lentas.
- Los modelos pueden aprovechar de forma desigual la información en entradas muy largas. Prueba con tus tamaños de documento reales.
10. Fijar versiones y reevaluar ante cambios
- Usa versiones explícitas del modelo cuando el proveedor las ofrezca.
- Vuelve a ejecutar el conjunto de evaluación antes de cambiar de versión o de proveedor.
- Guarda el conjunto de evaluación en control de versiones, junto a los prompts.
Qué significa el resultado
| Resultado de la evaluación | Decisión |
|---|---|
| El modelo pequeño cumple calidad y latencia | Úsalo; añade escalado para los fallos |
| El modelo pequeño falla solo en los casos difíciles | Cascada: primero el pequeño, después escalar |
| Todos los modelos fallan en los mismos casos | Corrige primero la entrada, el contexto o la definición de la tarea |
| El modelo grande cumple pero es demasiado lento | Modelo más pequeño + mejor contexto, streaming o procesamiento asíncrono |
| La calidad varía entre ejecuciones | Parámetros menos aleatorios, esquema de salida más estricto, validación |
| El código o el SQL resuelven la mayoría de los casos | Usa código; envía solo el resto a un modelo |
Qué revisar
- La precisión en los casos difíciles, no solo la global.
- La latencia p95 con tamaños de prompt reales.
- La tasa de validación de la salida estructurada.
- Las tasas de escalado y de reintentos.
- El costo por tarea completada.
- Las condiciones de residencia y retención de datos.
- El comportamiento tras una actualización de versión del modelo.
Errores comunes
1. Usar un LLM para trabajo determinista
Parsear una fecha o sumar una columna con un modelo es más lento, más caro y menos fiable que el código.
2. Elegir solo por rankings públicos
Los benchmarks generales no miden tus esquemas, tus documentos ni tus casos límite.
3. Usar por defecto el modelo más grande
Puede ser innecesario para tareas simples y suele ser más lento y más caro.
4. Usar por defecto el modelo más barato
Los reintentos, los escalados y las respuestas incorrectas pueden convertirlo en la opción más cara.
5. Esperar que el modelo conozca datos privados
Usa recuperación o herramientas; no confíes en lo que el modelo pueda recordar.
6. Confiar en la salida sin validarla
Incluso los modelos potentes devuelven a veces salidas no válidas o plausibles pero incorrectas.
7. Evaluar una sola vez
Las salidas varían entre ejecuciones y entre versiones del modelo.
Notas de producción
- Guarda el nombre y la versión del modelo en la configuración, no dispersos por el código.
- Registra la versión del modelo con cada solicitud.
- Encapsula las llamadas al proveedor en una única interfaz para poder cambiar de modelo y comparar.
- Guarda el conjunto de evaluación y el código de puntuación en control de versiones.
- Ten una alternativa (otro modelo, una cola de revisión humana o un error claro) ante caídas del proveedor.
- Revisa las condiciones de procesamiento y retención de datos antes de enviar datos de negocio a un modelo alojado.
Lista de comprobación
- Las partes deterministas se resuelven con código, SQL o reglas.
- Existe un conjunto de evaluación con casos difíciles.
- Los candidatos se comparan por precisión, latencia p95 y costo por tarea completada.
- La salida estructurada se valida.
- Los fallos se escalan o van a revisión, no a una suposición.
- Los datos privados llegan al modelo mediante recuperación o herramientas.
- El rendimiento cabe en los límites del proveedor en el pico.
- Las versiones del modelo están fijadas y se reevalúan ante cambios.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.