Has estado usando GPT-4o y Claude a través de sus APIs. El costo por token es predecible. La latencia es aceptable. Pero sigues chocando contra la misma pared: el modelo no entiende tu dominio lo suficientemente bien y no puedes permitirte usar ingeniería de prompts para solucionarlo.
El fine-tuning lo resuelve. No por arte de magia. Mostrando a un modelo 100-1,000 ejemplos de exactamente lo que quieres que haga, y luego reentrenando sus pesos para que coincidan con tus especificaciones. Construí el clasificador de señales de trading de AlgoVesta sobre Llama 3 8B afinado, y reduce nuestro costo de inferencia en un 70% comparado con GPT-4, al mismo tiempo que iguala la precisión en nuestro dominio.
Esto es lo que realmente importa: la calidad de los datos supera a la cantidad, necesitas una línea base antes de afinar, y el despliegue es donde la mayoría falla.
Cuándo tiene sentido el Fine-Tuning
El fine-tuning no es la respuesta a «mi prompt no funciona». Arregla el prompt primero. Cadena de pensamiento (chain-of-thought), recuperación (retrieval) o un mensaje de sistema suelen resolver el problema por 1/100 del costo.
Haz fine-tuning cuando:
- Tienes 100+ ejemplos etiquetados de tu tarea específica (menos no ayuda mucho)
- El comportamiento base del modelo está cerca pero no es del todo correcto — estás ajustando, no sobrescribiendo
- Necesitas un formato de salida consistente o terminología específica del dominio con la que los modelos genéricos tienen dificultades
- El costo de inferencia o la latencia son una restricción importante (modelos más pequeños y afinados superan a los genéricos más grandes en tu tarea)
NO deberías hacer fine-tuning si estás intentando añadir conocimiento fáctico que el modelo no tiene. Usa RAG en su lugar. Si intentas hacer que el modelo sea más «útil» o «amigable», reescribe tu prompt. El fine-tuning no es un trasplante de personalidad.
Preparación de Datos: El 80/20 del Proceso
Pasa la mayor parte de tu tiempo aquí. Datos malos arruinan todo lo que sigue.
Tu conjunto de entrenamiento necesita: entrada, salida esperada y, idealmente, una etiqueta de confianza (algunos ejemplos son más representativos que otros). Para clasificación, esto es sencillo. Para generación (resumen de texto, redacción de correos), es más complicado — una entrada puede tener múltiples salidas correctas.
El formato depende del modelo y del framework. La API de fine-tuning de OpenAI quiere JSONL:
{"messages": [{"role": "user", "content": "Clasifica esta señal de trading: MSFT cerró 3% por encima de MA50"}, {"role": "assistant", "content": "bullish_breakout"}]}
{"messages": [{"role": "user", "content": "Clasifica esta señal de trading: TSLA abrió a la baja con alto volumen"}, {"role": "assistant", "content": "bearish_reversal"}]}Si usas Hugging Face con un modelo abierto, el formato depende de tu framework (generalmente la misma estructura, pero diferente serialización).
Antes de finalizar tu dataset:
- Audita 50 ejemplos aleatorios manualmente. Comprueba errores de etiquetado, entradas poco claras o fugas de datos (datos de prueba accidentalmente en entrenamiento). Encontramos que el 12% de nuestro primer dataset estaba mal etiquetado. No lo captamos hasta que la inferencia falló en casos límite conocidos.
- Divide 80/10/10: entrenamiento/validación/prueba. No dejes que los datos de validación toquen los de entrenamiento. Los datos de prueba deben mantenerse completamente separados y solo usarse al final.
- Balancea las clases si estás haciendo clasificación. Si el 90% de tus ejemplos son «sin acción» y el 10% son «comprar», el modelo aprende a predecir siempre «sin acción». Sobremuestrea la clase minoritaria o usa pesos de clase durante el entrenamiento.
Eligiendo tu Modelo Base
Empieza con lo que conoces. Si has estado probando con Claude, la API de fine-tuning de OpenAI es el camino de menor resistencia. Anthropic aún no ofrece fine-tuning. Si el costo es crítico, usa un modelo abierto: Llama 3 8B o Mistral 7B funcionan en hardware de consumidor y se afinan en horas en lugar de días.
La elección del modelo tiene compromisos:
- OpenAI GPT-3.5 Turbo: ~$1.50 por 1M de tokens de entrenamiento. Más rápido para poner en producción. Funciona en su infraestructura. Mejor para cuando quieres fine-tuning sin gestionar cómputo.
- Llama 3 8B o Mistral 7B: Modelo gratuito, pero pagas por cómputo de GPU. $0.24–$0.50 por hora en la mayoría de los proveedores de nube. Mejor si tienes 500+ ejemplos y quieres iterar. El costo de inferencia se reduce a casi cero una vez desplegado.
- Claude o GPT-4: Ambos modelos base más capaces pero más caros de afinar (si OpenAI lo soporta) o no disponibles (Anthropic). No empieces aquí.
Recomiendo empezar con GPT-3.5 Turbo si tienes <300 ejemplos. Usa Llama 3 8B si tienes >500 y puedes tolerar un modelo base ligeramente menos capaz que seguirá siendo excelente en tu dominio después del afinamiento.
El Proceso Real de Fine-Tuning
Esto varía según la plataforma, pero el patrón es idéntico.
Si usas la API de OpenAI:
import openai
openai.api_key = "your-key"
# Sube el archivo de entrenamiento
response = openai.File.create(
file=open("training_data.jsonl", "rb"),
purpose="fine-tune"
)
file_id = response["id"]
# Inicia el trabajo de fine-tuning
job = openai.FineTuningJob.create(
training_file=file_id,
model="gpt-3.5-turbo",
hyperparameters={"n_epochs": 3} # 3 pasadas por tus datos
)
print(f"Job ID: {job['id']}")
# Comprueba el estado
job_status = openai.FineTuningJob.retrieve(job["id"])
print(job_status["status"])Para Llama 3 en Hugging Face, usarías la librería transformers con LoRA (Low-Rank Adaptation) para afinar solo un pequeño conjunto de parámetros en lugar del modelo completo — dramáticamente más rápido:
from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b")
lora_config = LoraConfig(
r=8, # Dimensión de bajo rango
lora_alpha=32,
target_modules=["q_proj", "v_proj"],
lora_dropout=0.05
)
model = get_peft_model(model, lora_config)
# Pásalo a tu bucle de entrenamiento (HuggingFace Trainer o custom)Los hiperparámetros importan: n_epochs (3 es estándar), tasa de aprendizaje (generalmente 2e-5 a 5e-4), y tamaño de lote (depende de la memoria de tu GPU). Empieza con los valores por defecto. No persigas ajustes de rendimiento hasta que tengas una línea base.
Evaluando Antes de Desplegar
La pérdida de entrenamiento disminuirá. Eso no significa nada. Lo que importa: ¿el modelo afinado se desempeña mejor en datos que no ha visto?
Ejecuta tu conjunto de prueba reservado a través del modelo base y tu versión afinada. Compara precisión, puntuación F1 (para clasificación) o tasa de coincidencia exacta (para salidas estructuradas). Si la mejora es <5%, el fine-tuning no ayudó — probablemente tenías un problema de prompt o de datos en su lugar.
Prueba manualmente en casos límite. Alimenta al modelo con ejemplos que sean fronterizos, intencionalmente ambiguos, o específicos del dominio de maneras que tus datos de entrenamiento podrían no haber cubierto. Una puntuación de precisión del 90% significa que una de cada diez predicciones son incorrectas. Conoce cuáles.
Despliegue: Donde Realmente se Rompe
Una vez afinado, tu modelo reside en un endpoint de API o en tu hardware. Los errores críticos ocurren aquí:
No versions tus fine-tunes. Despliegas una nueva versión en producción y la inferencia falla. Nómbralas: trading-signals-v1-20250115 incluye la fecha y la versión. Mantén el endpoint antiguo activo durante 2 semanas en paralelo.
No pruebas el endpoint de producción con datos frescos. Tu conjunto de prueba era del mes pasado. La inferencia real hoy está encontrando distribuciones diferentes. Monitoriza la entropía de salida, la latencia y las tasas de error en producción. Si la precisión cae, tus datos cambiaron.
Olvidas el costo de propiedad. Un modelo 8B afinado ejecutándose 24/7 en un A100 cuesta ~$700/mes. Un endpoint GPT-3.5 Turbo en caché para el mismo volumen cuesta ~$90. Haz los cálculos antes de desplegar.
Si despliegas en tu infraestructura, usa vLLM o TensorRT para optimización de inferencia. Reducirás la latencia en un 50% y la memoria de GPU en un 30% comparado con un despliegue de transformers puro.
Tu Próximo Paso
Recopila 150-200 ejemplos de tu tarea. Dedica una semana a limpiarlos y etiquetarlos. Luego ejecuta un fine-tune barato en GPT-3.5 Turbo de OpenAI (cuesta ~$5). Compara las salidas lado a lado con el modelo base. Ese experimento te dice si el fine-tuning vale la pena para tu caso de uso. La mayoría de las veces, un mejor prompt o RAG resuelve el problema. Pero cuando no lo hace, lo sabrás.
