Explorar guías rápidas · Ingeniería de IA para datos

Tecnología: Ingeniería de IA para datosCategoría: Selección de modelosNivel: PrincipianteActualizado

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
  1. Problema
  2. Respuesta rápida
  3. Primero: ¿necesitas un modelo?
  4. Criterios de comparación
  5. Árbol de decisión
  6. Código / comandos
  7. 1. Construir primero un conjunto de evaluación
  8. 2. Puntuar a los candidatos con los mismos casos
  9. 3. Comparar por costo por tarea completada
  10. 4. Exigir salida estructurada y validarla
  11. 5. Cascada: primero el modelo pequeño, escalar si falla
  12. 6. Añadir recuperación o herramientas para datos privados y actuales
  13. 7. Entrada multimodal
  14. 8. Revisar el rendimiento y los límites
  15. 9. El tamaño de la ventana de contexto no garantiza calidad
  16. 10. Fijar versiones y reevaluar ante cambios
  17. Qué significa el resultado
  18. Qué revisar
  19. Errores comunes
  20. 1. Usar un LLM para trabajo determinista
  21. 2. Elegir solo por rankings públicos
  22. 3. Usar por defecto el modelo más grande
  23. 4. Usar por defecto el modelo más barato
  24. 5. Esperar que el modelo conozca datos privados
  25. 6. Confiar en la salida sin validarla
  26. 7. Evaluar una sola vez
  27. Notas de producción
  28. Lista de comprobación
  29. Siguiente paso
  30. 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.

Siguiente paso

  • Necesitas estimar el costo del modelo elegido → Costo de LLM y presupuesto de tokens.
  • El modelo necesita mejores instrucciones para tareas de datos → Patrones de prompts para ingeniería de datos.
  • El modelo necesita una mejor entrada, no un modelo más grande → Ingeniería de contexto para LLM.

← Todas las guías rápidas