Cómo Entrenar Modelos LLM en RunPod: Guía Completa 2026

Fine-tunear un modelo de lenguaje ya no es territorio exclusivo de los grandes laboratorios. En 2026, con $10 USD, un pod en RunPod y las herramientas correctas, puedes entrenar un modelo 7B personalizado, fusionarlo y desplegarlo localmente en Ollama. Esta guía cubre todo el flujo: desde elegir la GPU hasta tener el modelo corriendo en producción.

¿Por qué RunPod y no AWS o GCP?

La diferencia de costos es brutal. Un setup equivalente de 4x A100 tiene un costo a 3 años de:

Para experimentos puntuales la ventaja es aún más clara: con $10 USD puedes entrenar hasta 10 modelos tipo 7B. Pagas exactamente lo que usas, al segundo.

El Stack de 2026: Qué Herramientas Usar

• Python 3.11+ / PyTorch 2.5+ / CUDA 12.x — la base irrenunciable
• Axolotl — orquestador de fine-tuning con config YAML/JSON. Soporta LLaMA, Gemma, Mistral, Qwen y más. Imagen Docker lista: axolotlai/axolotl-cloud:main-latest
• Unsloth — kernels optimizados que reducen VRAM y aumentan throughput significativamente
• Hugging Face ecosystem — transformers, datasets, peft, trl
• Weights & Biases (WandB) — tracking de métricas durante el entrenamiento en tiempo real

Paso 1: Elegir la GPU Correcta

La regla de oro: el modelo debe caber en VRAM o el entrenamiento simplemente no arranca.

El H100 entrega 2-3x más velocidad de entrenamiento y hasta 30x más velocidad de inferencia en modelos transformer respecto al A100. Para experimentación con modelos 7B, el A100 sigue siendo la opción con mejor costo-beneficio.

Paso 2: Crear el Pod en RunPod

1. Entra a console.runpod.io y selecciona Deploy
2. Elige la GPU según tu modelo
3. En Template Image escribe: axolotlai/axolotl-cloud:main-latest
4. Monta un volumen persistente en /workspace antes de iniciar — si el Pod se cae sin volumen, pierdes todo el entrenamiento
5. Agrega variables de entorno: HF_TOKEN y WANDB_API_KEY
6. Deploy — el Pod estará listo en menos de 2 minutos

Paso 3: Preparar el Dataset

El dataset es lo más importante del proceso — el modelo aprenderá exactamente de esos datos.

Formato requerido por Axolotl (ShareGPT / ChatML)

[
  {
    "messages": [
      {"role": "system", "content": "Eres un asistente especializado en..."},
      {"role": "user", "content": "¿Cómo funciona X?"},
      {"role": "assistant", "content": "X funciona de la siguiente manera..."}
    ]
  }
]

Transferir dataset local al Pod

# En tu máquina local
runpodctl send dataset.jsonl
# Copia el código generado (ej: 8338-galileo-collect-fidel)

# En el Pod de RunPod
runpodctl receive 8338-galileo-collect-fidel

Paso 4: Elegir la Técnica de Fine-Tuning

Paso 5: Configurar el Entrenamiento con Axolotl

Configuración funcional y comentada de LoRA para Llama 3.2-1B:

{
  "base_model": "NousResearch/Llama-3.2-1B",
  "load_in_4bit": false,        // true para QLoRA
  "load_in_8bit": false,
  "adapter": "lora",            // "lora" o "qlora"
  "lora_r": 16,                 // rango — empieza aquí, sube a 64 si no aprende
  "lora_alpha": 32,             // siempre 2x lora_r
  "lora_dropout": 0.05,
  "lora_target_modules": [
    "q_proj", "v_proj", "k_proj", "o_proj",
    "gate_proj", "down_proj", "up_proj"
  ],
  "datasets": [{ "path": "teknium/GPT4-LLM-Cleaned", "type": "alpaca" }],
  "val_set_size": 0.1,          // 10% para validación — detecta overfitting
  "sequence_len": 2048,
  "output_dir": "./outputs/lora-out",
  "num_epochs": 3,
  "micro_batch_size": 2,
  "gradient_accumulation_steps": 4,
  "optimizer": "adamw_8bit",
  "lr_scheduler": "cosine",
  "learning_rate": 0.0002,
  "bf16": "auto",               // bfloat16 en A100/H100 — más estable que fp16
  "gradient_checkpointing": true, // SIEMPRE true — reduce VRAM ~30%
  "logging_steps": 10
}

Paso 6: Ejecutar el Entrenamiento

# Single GPU
python -m axolotl.cli.train config.yaml

# Multi-GPU (ej: 2x A100)
ACCELERATE_LOG_LEVEL=info accelerate launch \
  -m axolotl.cli.train config.yaml

Durante el entrenamiento WandB mostrará en tiempo real: training loss, validation loss, learning rate y tokens/segundo. El objetivo: training loss bajando consistentemente sin que la validation loss suba — esa subida es la señal de overfitting.

Paso 7: Fusionar el Adaptador LoRA

python3 -m axolotl.cli.merge_lora \
  --base_model mistralai/Mistral-7B-v0.1 \
  --peft_model /workspace/outputs/mymodel \
  --output_dir /workspace/outputs/mymodel/merged \
  --config /workspace/config.yaml

Desde el modelo fusionado en /merged, tienes tres caminos:

1. Hugging Face Hub: huggingface-cli upload tu-usuario/modelo /workspace/outputs/mymodel/merged
2. GGUF para Ollama local: convertir con llama.cpp convert y cargar en Ollama — sin enviar datos a terceros
3. RunPod Serverless: inferencia bajo demanda con auto-scaling y pago por uso

Fine-Tuning vs RAG vs Prompt Engineering

Nota: Las tres estrategias no son mutuamente excluyentes. Un modelo fine-tuned que también hace RAG frecuentemente supera a cualquiera de las dos técnicas en aislamiento.

Tips Críticos Para No Perder Tiempo ni Dinero

1. Monta volumen persistente ANTES de lanzar el Pod. Sin volumen, si el Pod cae, pierdes todo.
2. Siempre gradient_checkpointing: true. Reduce VRAM ~30% a costa de 20% más tiempo.
3. Empieza con RTX 3090 para experimentos. Migra a A100/H100 solo cuando el experimento esté validado.
4. Pinea versiones de dependencias. Un cambio en transformers o peft puede romper la reproducibilidad.
5. Conecta WandB desde el inicio. Sin métricas en tiempo real estás ciego.
6. Usa bf16: auto, no fp16. En A100/H100, bfloat16 es más estable. fp16 puede generar NaN en runs largos.
7. Evalúa siempre contra el modelo base. Si mejora marginalmente con buen prompting, el fine-tuning no estaba justificado.

Caso Práctico: Flujo Completo para un Modelo de Dominio Específico

1. Arma 500–2000 ejemplos en formato system/user/assistant con casos reales de tu dominio
2. Lanza un Pod con RTX 3090 + imagen Axolotl + volumen persistente en /workspace
3. Configura LoRA con lora_r=16, 3 epochs, learning_rate=2e-4
4. Entrena — tiempo estimado: 1–4 horas. Costo: $3–8 USD
5. Fusiona el adaptador y convierte a GGUF
6. Despliega en Ollama local — sin enviar datos a terceros, sin costo de inferencia recurrente

Conclusión

La combinación de RunPod + Axolotl + LoRA/QLoRA democratizó el fine-tuning de LLMs. Lo que hace un año requería un equipo de ML y servidores propios, hoy lo puede hacer un desarrollador individual en pocas horas por menos de $10.

El stack de 2026 está maduro. Los modelos base open source (Llama 4, Qwen3, Mistral) son suficientemente potentes para que un fine-tune bien ejecutado produzca resultados de producción reales. No hay excusa para no experimentar.