Fine-Tuning de LLMs: Guía Completa para Principiantes (Tutorial Paso a Paso 2025)

Meta descripción: Fine-tuning LLMs desde cero. Aprende qué es, cuándo usarlo, LoRA vs QLoRA, tutorial práctico con código, herramientas y casos de uso reales. Guía definitiva para novatos.

Qué es Fine-Tuning y Por Qué Debería Importarte

Si usas ChatGPT, Claude o Llama y piensas “esto es genial, pero me gustaría que respondiera exactamente de ESTA forma” o “si tan solo conociera información de MI empresa”… necesitas fine-tuning.

Fine-tuning es tomar un modelo de lenguaje pre-entrenado (Llama, Mistral, GPT) y entrenarlo específicamente para TU tarea, con TUS datos, siguiendo TUS patrones.

Analogía simple: Tienes un estudiante universitario brillante que sabe de todo un poco (el LLM). Fine-tuning es enviarlo a una especialización – le das material específico (medicina, leyes, código de tu API) y se vuelve experto en ESE tema.

Ejemplo práctico real:

• Sin fine-tuning: “ChatGPT, analiza el sentimiento de este tweet sobre iPhone”
• Con fine-tuning: Modelo pequeño local que procesa 10,000 tweets/segundo identificando sentimiento específico de productos tech con 95% precisión, costando $0.0001 por análisis vs $0.01 usando APIs externas

Por qué importa:

• ✅ Privacidad: Tus datos nunca salen de tu servidor
• ✅ Costo: Modelo pequeño fine-tuneado puede superar a GPT-4 en tareas específicas por 100x menos precio
• ✅ Control: Formato exacto, tono específico, conocimiento privado
• ✅ Velocidad: Modelos locales más rápidos que APIs cloud
• ✅ Consistencia: Siempre responde de la misma forma

Esta guía asume CERO conocimiento previo. Al terminar, sabrás exactamente qué es fine-tuning, cuándo usarlo, cómo hacerlo paso a paso, y cuánto cuesta.

Pre-Training vs Fine-Tuning vs Prompts vs RLHF: Las Diferencias Clave

Estos términos confunden a todos al principio. Aquí la diferencia clara:

1. Pre-Training (Pre-entrenamiento)

Qué es: Entrenar el modelo desde cero con billones de palabras de internet.

Analogía: Los primeros 18 años de educación de una persona – aprende lenguaje, cultura, conocimiento general.

Quién lo hace: Solo grandes empresas (Meta, OpenAI, Google).

Costo: Millones de dólares, semanas/meses en clusters de miles de GPUs.

Resultado: Modelo base que entiende lenguaje pero no está especializado.

2. Fine-Tuning (Ajuste fino)

Qué es: Tomar modelo pre-entrenado y entrenarlo con datos específicos de tu tarea.

Analogía: Hacer maestría o especialización después de la universidad.

Quién lo hace: TÚ, con GPU decente (incluso gratis en Google Colab).

Cuánto dura: Minutos a horas.

Resultado: Modelo especializado en TU tarea específica.

Cuándo usarlo:

• Necesitas formato EXACTO (JSON, XML, estructura específica)
• Tienes 100-1000+ ejemplos de “input → output deseado”
• Conocimiento que NO está en internet (datos privados empresa)
• Reducir costos (modelo pequeño fine-tuneado > GPT-4 con prompts complejos)
• Consistencia absoluta (siempre la misma respuesta)

3. Prompt Engineering

Qué es: Escribir instrucciones cuidadosas para obtener respuestas deseadas.

Analogía: Explicarle a alguien MUY BIEN cómo hacer algo, sin cambiar lo que sabe.

Quién lo hace: Tú, directamente al usar el modelo.

Duración: Segundos (solo escribes el prompt).

Cuándo usarlo:

• Tareas ocasionales o variadas
• Puedes explicar claramente lo que quieres
• No tienes cientos de ejemplos
• Velocidad de iteración > precisión

4. RLHF (Reinforcement Learning from Human Feedback)

Qué es: Entrenar mostrando pares de respuestas y eligiendo cuál prefieres.

Analogía: Dar feedback de estilo: “Esta respuesta es correcta pero cortante, prefiero esta otra más amable”.

Quién lo hace: Empresas con equipos de anotadores humanos.

Cuándo usarlo: Ajustar TONO, ESTILO o COMPORTAMIENTO (más amable, conciso, menos alucinaciones).

Comparativa Rápida

Conclusión para principiantes: Casi siempre quieres fine-tuning (guía de hoy) o prompts (rápido y simple).

Métodos de Fine-Tuning: Full vs LoRA vs QLoRA

Full Fine-Tuning: El Método Tradicional (Olvidalo)

Qué es: Actualizar TODOS los parámetros del modelo durante entrenamiento.

Un modelo 7B tiene 7,000,000,000 de números. Full fine-tuning modifica TODOS.

Requisitos VRAM:

• 7B model: 60GB VRAM (imposible en GPUs consumidor)
• 13B model: 120GB VRAM (varias A100 de $10,000 cada una)
• 70B model: 600GB VRAM (cluster empresarial)

Cuándo usar: Casi nunca para individuos. Solo hardware empresarial nivel OpenAI.

Ventajas: Máximo control, mejor performance posible.

Desventajas: Hardware carísimo, días/semanas, alto overfitting, resultado muy grande (decenas GB).

LoRA: La Solución Inteligente

LoRA significa Low-Rank Adaptation (Adaptación de Bajo Rango).

Qué es: En lugar de modificar 7 mil millones de parámetros, LoRA agrega matrices pequeñas (adaptadores) que representan los cambios.

Analogía perfecta:
Tienes un libro de 1000 páginas (modelo base). En vez de reescribir todo:

• Creas un folleto de 10 páginas con “correcciones y adiciones”
• Al leer el libro, consultas el folleto
• El libro original NO cambia, solo el folleto extra

Cómo funciona técnicamente:

Normal:      Y = W × X
Con LoRA:    Y = W × X + B × A × X

Donde:
- W = pesos originales (CONGELADOS, no se modifican)
- B × A = matrices pequeñas que se entrenan (LoRA adapters)

Requisitos VRAM:

• 7B: 16-20GB (cabe en RTX 3090/4090) ✅
• 13B: 28-32GB (A100 40GB)
• 70B: 160GB (todavía grande)

Ventajas:

• ✅ Reduce VRAM 70% vs full fine-tuning
• ✅ Entrenamiento rápido (horas vs días)
• ✅ Adaptador resultante PEQUEÑO (100-500MB vs 15GB)
• ✅ Menor overfitting
• ✅ Múltiples adaptadores para diferentes tareas

Hyperparámetros clave:

• rank (r): Cuántos parámetros entrenar. Típico: 8-64
• r=8: Pocos parámetros, rápido, menos capacidad
• r=64: Más parámetros, lento, más capacidad
• alpha: Influencia adaptadores. Típico: alpha = 2 × rank
• target_modules: Qué partes modificar. Típico: ["q_proj", "k_proj", "v_proj", "o_proj"]

QLoRA: LoRA con Superpoderes de Ahorro

QLoRA significa Quantized LoRA (LoRA Cuantizado).

Qué es: LoRA + comprimir modelo a 4 bits en vez de 16 bits.

Analogía cuantización:
Guardar colores:

• 16 bits: 65,536 colores diferentes (súper preciso)
• 4 bits: 16 colores diferentes (menos preciso)
• QLoRA: “Para mayoría de tareas, 16 colores suficientes, ahorremos espacio”

Cómo funciona:

• Comprime modelo base 16→4 bits (ahorra 75% memoria)
• Aplica LoRA encima (adaptadores siguen 16 bits para calidad)
• Durante entrenamiento, descomprime temporalmente partes necesarias

Requisitos VRAM:

• 7B: 6-10GB (RTX 3060 12GB funciona) ✅✅
• 13B: 12-20GB (RTX 4090)
• 70B: 48GB (A100 80GB única GPU)

Ventajas:

• ✅ MÍNIMO VRAM (Google Colab GRATIS)
• ✅ Permite fine-tunear modelos grandes en hardware modesto
• ✅ Calidad casi idéntica a LoRA
• ✅ Perfecto para experimentación

Desventajas:

• ❌ 39% más lento que LoRA
• ❌ Puede perder calidad en tareas MUY complejas

Innovaciones técnicas:

• NF4 (4-bit Normal Float): Cuantización que aprovecha distribución normal de pesos
• Double Quantization: Comprime incluso valores de cuantización (extra 0.5 bits ahorrados)
• Paged Optimizers: Gestión inteligente de memoria

Tabla Comparativa Completa

Recomendación para principiantes:

• Empieza con QLoRA en Google Colab (gratis)
• Si tienes RTX 3090/4090, prueba LoRA (más velocidad)
• Olvida Full fine-tuning a menos que trabajes en empresa grande

Herramientas: Tu Arsenal de Fine-Tuning

Unsloth: El Más Rápido (Recomendado para Empezar)

Por qué es especial: Actualmente el framework MÁS RÁPIDO para fine-tuning.

Ventajas:

• ✅ 2x más rápido que métodos tradicionales
• ✅ 80% menos memoria que Transformers estándar
• ✅ Funciona en Google Colab y Kaggle (GRATIS)
• ✅ Compatible con ecosistema Hugging Face
• ✅ Kernels optimizados Triton (GPU bajo nivel)

Instalación Colab/Kaggle:

pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps xformers trl peft accelerate bitsandbytes

Instalación local:

pip install unsloth

Código básico:

from unsloth import FastLanguageModel

# Cargar modelo 4-bit
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name='unsloth/llama-3-8b-bnb-4bit',
    max_seq_length=2048,
    load_in_4bit=True,
)

# Agregar LoRA
model = FastLanguageModel.get_peft_model(
    model,
    r=16,  # LoRA rank
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_alpha=16,
)

Cuándo usar Unsloth:

• ✅ Eres principiante
• ✅ Quieres máxima velocidad
• ✅ Trabajas en Colab/Kaggle recursos limitados
• ✅ Modelos Llama, Mistral, Gemma, Qwen

Hugging Face Transformers + PEFT

Qué es: Ecosistema estándar industria para LLMs.

Componentes:

• transformers: Librería principal modelos
• PEFT: Implementación LoRA, QLoRA, adapters
• TRL: Trainers especializados
• datasets: Gestión datos

Instalación:

pip install transformers peft trl datasets accelerate bitsandbytes

Ventajas:

• ✅ Ecosistema completo maduro
• ✅ Compatible con TODO (miles modelos Hugging Face Hub)
• ✅ Documentación extensa
• ✅ Soporte comunidad enorme

Desventajas:

• ❌ Más lento que Unsloth
• ❌ Más configuración manual
• ❌ Curva aprendizaje pronunciada

Cuándo usar:

• Necesitas máximo control
• Modelos/tareas no soportados Unsloth
• Producción empresarial

LLaMA-Factory: GUI Para No Programadores

Qué es: Interfaz gráfica completa para fine-tuning sin escribir código.

Características:

• ✅ Interface web intuitiva
• ✅ Múltiples métodos (LoRA, QLoRA, full)
• ✅ Soporte 100+ modelos
• ✅ Monitoring tiempo real
• ✅ Export automático

Instalación:

git clone https://github.com/hiyouga/LLaMA-Factory.git
cd LLaMA-Factory
pip install -e .

Lanzar UI:

llamafactory-cli webui

Cuándo usar:

• ✅ No quieres programar
• ✅ Experimentación rápida
• ✅ Aprender conceptos visualmente

Comparativa Herramientas

Recomendación: Empieza con Unsloth (balance perfecto). Luego explora LLaMA-Factory (si quieres GUI) o Transformers+PEFT (si quieres control total).

Preparación de Datos: El 80% del Éxito

Fine-tuning es 80% datos, 20% código. Datos malos = resultados malos, sin importar cuánto optimices.

Formatos de Datasets

1. Instruction Format (más común):

{
  "instruction": "Traduce al español",
  "input": "Hello, how are you?",
  "output": "Hola, ¿cómo estás?"
}

2. Chat Format (conversaciones):

{
  "messages": [
    {"role": "system", "content": "Eres asistente legal"},
    {"role": "user", "content": "¿Qué es un contrato?"},
    {"role": "assistant", "content": "Un contrato es..."}
  ]
}

3. Completion Format (simple):

{
  "prompt": "Escribe función Python que suma dos números:",
  "completion": "def suma(a, b):\n    return a + b"
}

Cuántos Ejemplos Necesitas

PERO: 100 ejemplos EXCELENTES > 10,000 ejemplos mediocres.

Calidad vs Cantidad

Datos de calidad tienen:

• ✅ Diversidad: Cubren diferentes casos, edge cases
• ✅ Precisión: Outputs correctos, sin errores
• ✅ Consistencia: Mismo formato, mismo estilo
• ✅ Representatividad: Reflejan uso real

Ejemplo MALO:

{"input": "hola", "output": "hola"}
{"input": "que tal", "output": "bien"}
{"input": "adios", "output": "chao"}

Ejemplo BUENO:

{
  "instruction": "Analiza sentimiento de tweet sobre producto tech",
  "input": "El iPhone 15 Pro es increíble, cámara brutal pero batería regular",
  "output": "Sentimiento: MIXTO_POSITIVO\nPositivo: cámara (5/5)\nNegativo: batería (2/5)\nScore general: 7/10"
}

Herramientas para Crear Datasets

1. GPT-4/Claude para datos sintéticos:

prompt = """
Genera 10 ejemplos de análisis sentimiento de tweets sobre iPhone.
Formato JSON con: input (tweet), output (análisis).
"""
# Usar API GPT-4 → obtener ejemplos

2. Datos reales + anotación manual:

• Extrae datos reales (tweets, tickets soporte, documentos)
• Anota manualmente outputs correctos (tú o equipo)
• Más trabajo pero mejor calidad

3. Distillation (destilación):

# Usa modelo grande (GPT-4) para generar respuestas
# Fine-tunea modelo pequeño con esas respuestas
# Resultado: modelo pequeño aprende de modelo grande

Validación y Splits

# División estándar
train: 80%      # Entrenar modelo
validation: 10%  # Validar durante entrenamiento
test: 10%       # Evaluar resultado final

# Ejemplo con 1000 ejemplos:
# train: 800, validation: 100, test: 100

Script validación básica:

import json

def validate_dataset(file_path):
    with open(file_path) as f:
        data = [json.loads(line) for line in f]

    # Checks básicos
    assert len(data) > 0, "Dataset vacío"

    required_fields = ["instruction", "input", "output"]
    for i, item in enumerate(data):
        for field in required_fields:
            assert field in item, f"Item {i} falta campo '{field}'"
        assert len(item["output"]) > 0, f"Item {i} output vacío"

    print(f"✅ Dataset válido: {len(data)} ejemplos")
    return data

validate_dataset("train.jsonl")

Hardware y Requisitos de VRAM

VRAM por Método y Modelo

Recomendaciones GPU por Presupuesto

Gratis:

• ✅ Google Colab Free: T4 16GB (QLoRA modelos 7B) ✅
• ✅ Kaggle: P100 16GB o T4 16GB
• ⚠️ Limitación: Sesiones 12h, puede desconectar

Gratis++ ($10-25/mes):

• ✅ Colab Pro: V100 16GB, sesiones 24h
• ✅ Colab Pro+: A100 40GB (LoRA 70B) ✅✅

Cloud pay-per-use:

• Lambda Labs: RTX 4090 $0.60/h, A100 40GB $1.10/h
• RunPod: RTX 3090 $0.34/h, A100 80GB $1.89/h
• Vast.ai: Mercado community, desde $0.20/h

Homelab (comprar GPU):

• RTX 3090 24GB: $950 usado (mejor value)
• RTX 4090 24GB: $1,600 nuevo
• RTX 5090 32GB: $2,000+ (nuevo 2025, LoRA 70B)

Para elegir qué ejecutar en tu GPU homelab, consulta nuestra guía de modelos y herramientas IA para GPUs 24GB+ con benchmarks completos.

Análisis ROI:

RTX 4090 ($1,600) vs Cloud ($0.60/h RTX 4090):
- Uso 3h/día = $18/día × 30 = $540/mes
- Break-even en 3 meses
- Después: $0/mes vs $540/mes → ahorro $6,480/año

Batch Size y Gradient Accumulation

Problema: VRAM limitada = batch size pequeño = entrenamiento lento.

Solución: Gradient Accumulation.

# Sin gradient accumulation:
batch_size = 32  # Requiere 40GB VRAM ❌

# Con gradient accumulation:
micro_batch_size = 4            # Solo requiere 12GB ✅
gradient_accumulation_steps = 8
effective_batch_size = 4 × 8 = 32  # Mismo resultado

Gradient Accumulation: Acumula gradientes de múltiples micro-batches antes de actualizar pesos. Mismo efecto que batch grande pero usando menos VRAM.

Optimización VRAM

Técnicas adicionales:

• CPU Offloading: Mueve partes del modelo a RAM cuando no se usan
• Flash Attention: Reduce uso memoria en attention mechanism
• Mixed Precision (FP16/BF16): Usa 16 bits en vez de 32
• Gradient Checkpointing: Recalcula activations en vez de guardarlas

# Ejemplo config ahorro máximo VRAM
training_args = TrainingArguments(
    per_device_train_batch_size=1,      # Micro batch mínimo
    gradient_accumulation_steps=16,     # Compensar batch pequeño
    gradient_checkpointing=True,        # Ahorra VRAM
    fp16=True,                           # Mixed precision
    optim="paged_adamw_8bit",           # Optimizer 8-bit
)

Tutorial Práctico: Fine-Tunea Llama 3.1-8B con LoRA

Vamos a fine-tunear Llama 3.1-8B para generar respuestas de soporte técnico usando Unsloth + QLoRA en Google Colab gratis.

Paso 1: Setup Inicial

Abre Google Colab, crea notebook, selecciona T4 GPU (Runtime → Change runtime type → T4 GPU).

# Instalar dependencias
!pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
!pip install --no-deps xformers trl peft accelerate bitsandbytes

Paso 2: Cargar Modelo

from unsloth import FastLanguageModel
import torch

# Configuración
max_seq_length = 2048  # Longitud máxima secuencias
dtype = None  # Auto-detecta (Float16 para Tesla T4, Bfloat16 para Ampere+)
load_in_4bit = True  # QLoRA para ahorrar VRAM

# Cargar modelo
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/llama-3-8b-bnb-4bit",  # Llama 3 8B cuantizado 4-bit
    max_seq_length=max_seq_length,
    dtype=dtype,
    load_in_4bit=load_in_4bit,
)

print("✅ Modelo cargado")

Paso 3: Configurar LoRA

# Agregar adaptadores LoRA
model = FastLanguageModel.get_peft_model(
    model,
    r=16,  # LoRA rank (8-64 típico, 16 balance bueno)
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_alpha=16,  # Alpha = r generalmente
    lora_dropout=0,  # 0 optimizado por Unsloth
    bias="none",
    use_gradient_checkpointing="unsloth",  # Ahorra VRAM
    random_state=3407,
)

print("✅ LoRA configurado")

Paso 4: Preparar Dataset

from datasets import load_dataset

# Cargar dataset ejemplo (usa tu propio dataset aquí)
# Formato Alpaca: instruction, input, output
dataset = load_dataset("yahma/alpaca-cleaned", split="train[:1000]")

# Formato para chat template
alpaca_prompt = """A continuación hay una instrucción que describe una tarea, junto con una entrada que proporciona más contexto. Escribe una respuesta que complete adecuadamente la solicitud.

### Instrucción:
{}

### Entrada:
{}

### Respuesta:
{}"""

EOS_TOKEN = tokenizer.eos_token

def formatting_prompts_func(examples):
    instructions = examples["instruction"]
    inputs = examples["input"]
    outputs = examples["output"]
    texts = []

    for instruction, input_text, output in zip(instructions, inputs, outputs):
        text = alpaca_prompt.format(instruction, input_text, output) + EOS_TOKEN
        texts.append(text)

    return {"text": texts}

dataset = dataset.map(
    formatting_prompts_func,
    batched=True,
)

print(f"✅ Dataset preparado: {len(dataset)} ejemplos")

IMPORTANTE: Reemplaza yahma/alpaca-cleaned con TU dataset. Formato requerido:

{
  "instruction": "Tu instrucción",
  "input": "Contexto adicional",
  "output": "Respuesta esperada"
}

Paso 5: Configurar Training

from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=max_seq_length,
    dataset_num_proc=2,
    packing=False,  # Puede hacer entrenamiento 5x más rápido si True
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=5,
        max_steps=60,  # Epochs = max_steps / (len(dataset) / batch_size)
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=1,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=3407,
        output_dir="outputs",
    ),
)

print("✅ Trainer configurado")

Paso 6: Entrenar

# Mostrar stats antes de entrenar
gpu_stats = torch.cuda.get_device_properties(0)
start_gpu_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)
max_memory = round(gpu_stats.total_memory / 1024 / 1024 / 1024, 3)
print(f"GPU: {gpu_stats.name}, VRAM usada: {start_gpu_memory}GB / {max_memory}GB")

# ENTRENAR
trainer_stats = trainer.train()

# Stats después
used_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)
print(f"✅ Entrenamiento completado")
print(f"VRAM pico: {used_memory}GB / {max_memory}GB")
print(f"Tiempo: {trainer_stats.metrics['train_runtime']:.2f}s")

Output esperado:

GPU: Tesla T4, VRAM usada: 7.2GB / 15GB
✅ Entrenamiento completado
VRAM pico: 9.8GB / 15GB
Tiempo: 180.45s

Paso 7: Probar Modelo

# Activar modo inference
FastLanguageModel.for_inference(model)

# Generar respuesta
inputs = tokenizer(
    alpaca_prompt.format(
        "Explica qué es fine-tuning",  # Instrucción
        "",  # Input
        "",  # Output (vacío, modelo lo genera)
    ),
    return_tensors="pt"
).to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=128,
    temperature=0.7,
    top_p=0.9,
)

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

Paso 8: Guardar Modelo

# Guardar adaptadores LoRA (solo ~100-500MB)
model.save_pretrained("lora_model")
tokenizer.save_pretrained("lora_model")

# Guardar merged model (modelo completo con adaptadores fusionados)
model.save_pretrained_merged(
    "model_merged",
    tokenizer,
    save_method="merged_16bit",  # o "merged_4bit" para más compresión
)

print("✅ Modelos guardados")

Paso 9: Cargar y Usar Después

# Cargar adaptadores LoRA
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="lora_model",
    max_seq_length=max_seq_length,
    dtype=dtype,
    load_in_4bit=True,
)
FastLanguageModel.for_inference(model)

# Usar para inferencia
# ... (mismo código generación paso 7)

Troubleshooting Común

Error: CUDA Out of Memory

# Soluciones:
# 1. Reduce batch size
per_device_train_batch_size=1  # En vez de 2

# 2. Aumenta gradient accumulation
gradient_accumulation_steps=8  # En vez de 4

# 3. Reduce max_seq_length
max_seq_length=1024  # En vez de 2048

# 4. Usa gradient checkpointing
use_gradient_checkpointing="unsloth"

Error: Model not found

# Verifica que descargaste modelo correcto
# Llama 3 requiere aceptar términos en Hugging Face
# Usa alternativa sin restricciones:
model_name="unsloth/mistral-7b-bnb-4bit"

Loss no baja:

# 1. Aumenta learning rate
learning_rate=5e-4  # Era 2e-4

# 2. Aumenta max_steps
max_steps=200  # Era 60

# 3. Verifica dataset tiene diversidad
# Necesitas >100 ejemplos variados

Hyperparámetros Explicados

Learning Rate (Tasa de Aprendizaje)

Qué es: Cuánto cambia el modelo en cada paso.

Analogía: Estás escalando montaña en niebla buscando la cima:

• LR muy alto (0.01): Das pasos gigantes, puedes pasarte la cima
• LR muy bajo (0.00001): Das pasos minúsculos, tardas eternidades
• LR óptimo (0.0002): Pasos balanceados, llegas rápido sin pasarte

Valores típicos:

• Full fine-tuning: 1e-5 a 5e-5
• LoRA/QLoRA: 1e-4 a 5e-4

Cómo elegir: Empieza con 2e-4, si loss oscila mucho reduce a 1e-4, si no baja aumenta a 5e-4.

Epochs (Épocas)

Qué es: Cuántas veces el modelo ve el dataset completo.

Valores típicos:

• Dataset grande (>5000): 1-3 epochs
• Dataset pequeño (<1000): 3-10 epochs

Warning: Demasiados epochs = overfitting (memoriza dataset, no generaliza).

Batch Size

Qué es: Cuántos ejemplos procesa simultáneamente.

Batch size grande (32):

• ✅ Entrenamiento más estable
• ✅ Mejor uso GPU
• ❌ Requiere mucha VRAM

Batch size pequeño (2-4):

• ✅ Funciona con poca VRAM
• ❌ Entrenamiento menos estable
• ❌ Más lento

Solución: Gradient accumulation (simula batch grande con micro-batches pequeños).

LoRA Rank y Alpha

Rank (r):

• r=8: ~400K parámetros entrenables, rápido, tareas simples
• r=16: ~800K parámetros, balance óptimo
• r=64: ~3M parámetros, tareas complejas, más lento

Alpha:

• Regla simple: alpha = 2 × rank
• rank=16 → alpha=32

Warmup Steps

Qué es: Pasos iniciales donde learning rate aumenta gradualmente desde 0 hasta valor configurado.

Por qué: Evita cambios bruscos al inicio que desestabilicen modelo.

Valor típico: 5-10% de total steps. Si max_steps=100 → warmup_steps=10.

Weight Decay

Qué es: Penalización para evitar pesos muy grandes (regularización).

Valores típicos: 0.01 a 0.1

Por qué: Previene overfitting.

Optimizer (Optimizador)

Opciones:

• AdamW: Estándar, funciona bien (DEFAULT)
• AdamW 8-bit: Usa menos VRAM, ligeramente más lento
• SGD: Viejo, rara vez mejor que AdamW
• Adafactor: Ahorra memoria, bueno para modelos grandes

Recomendación: adamw_8bit (balance VRAM/velocidad).

Evaluación: ¿Funcionó el Fine-Tuning?

Loss Curves (Curvas de Pérdida)

Training Loss: Debe BAJAR consistentemente.

Epoch 1: loss 2.5
Epoch 2: loss 1.8
Epoch 3: loss 1.2  ✅ Bajando = aprendiendo

Validation Loss: Debe BAJAR también (si sube = overfitting).

Train loss: 0.5, Val loss: 0.6  ✅ Bueno
Train loss: 0.1, Val loss: 1.5  ❌ Overfitting (memorizó train, no generaliza)

Visualizar con TensorBoard:

# Durante training
from torch.utils.tensorboard import SummaryWriter

# Luego ver gráficas
%load_ext tensorboard
%tensorboard --logdir outputs/runs

Perplexity

Qué es: Medida de “sorpresa” del modelo. Menor = mejor.

Cálculo: perplexity = e^(loss)

import math

loss = 1.2
perplexity = math.exp(loss)
print(f"Perplexity: {perplexity:.2f}")  # ~3.32

Interpretación:

• Perplexity < 5: Excelente
• 5-10: Bueno
• 10-20: Aceptable
• >20: Malo

Test Set Evaluation

# Evaluar en test set (datos que modelo NUNCA vio)
test_dataset = load_dataset("tu_dataset", split="test")

# Generar predicciones
predictions = []
for example in test_dataset:
    input_text = format_prompt(example["instruction"], example["input"])
    output = generate(model, input_text)
    predictions.append(output)

# Comparar con ground truth
accuracy = calculate_accuracy(predictions, test_dataset["output"])
print(f"Accuracy: {accuracy}%")

Overfitting: Detectar y Evitar

Señales de overfitting:

• ❌ Train loss muy bajo (0.01) pero val loss alto (2.0)
• ❌ Modelo memoriza ejemplos exactos del train set
• ❌ Performance mala en datos nuevos

Soluciones:

• Más datos: Mejor solución
• Early stopping: Para cuando val loss empieza a subir
• Menos epochs: Reduce de 10 a 3 epochs
• Data augmentation: Crea variaciones de ejemplos existentes
• Regularización: Aumenta weight decay
• LoRA rank menor: r=8 en vez de r=64

Casos de Uso Reales

1. Customer Support Chatbot

Problema: 10,000 tickets soporte/mes, respuestas manuales tardan 10 min/ticket.

Solución Fine-Tuning:

• Dataset: 5,000 tickets históricos + respuestas aprobadas
• Modelo: Llama 3.1-8B con QLoRA
• Training: 3 horas en Colab Pro+ ($10/mes)
• Resultado: 80% tickets resueltos automáticamente, 2 min/ticket

ROI:

• Antes: 10,000 tickets × 10 min = 100,000 min/mes (1,666 horas)
• Después: 2,000 tickets × 10 min = 20,000 min/mes (333 horas)
• Ahorro: 1,333 horas/mes

2. Code Generation (Tu Stack)

Problema: ChatGPT genera código genérico, no conoce tu API/patterns internos.

Solución:

• Dataset: 1,000 funciones de tu codebase + documentación
• Modelo: Mistral 7B Instruct
• Resultado: Genera código siguiendo tus patterns exactos, usa tus libs

Si trabajas con Cursor como editor con IA, puedes configurarlo para usar tu modelo fine-tuneado local en lugar de los modelos remotos.

Ejemplo:

Input: "Crear endpoint GET users con paginación"
Output:
def get_users(request):
    # Tu patrón específico con tu ORM
    page = request.GET.get('page', 1)
    users = User.objects.paginate(page, per_page=20)
    return JsonResponse(serialize_users(users))

3. Análisis Sentimiento Custom

Problema: APIs genéricas no entienden jerga de tu industria (fintech, gaming, crypto).

Solución:

• Dataset: 10,000 comentarios de usuarios etiquetados
• Modelo: DistilBERT fine-tuneado (modelo pequeño, específico NLP)
• Inference: 10,000 comentarios/segundo en single GPU

Performance:

• Modelo genérico: 70% accuracy
• Modelo fine-tuneado: 94% accuracy ✅

4. Traducción Dominio-Específico

Problema: Google Translate falla en términos legales/médicos específicos.

Solución:

• Dataset: 5,000 documentos legales español↔inglés
• Modelo: mBART fine-tuneado
• Resultado: 98% precisión en terminología legal vs 75% Google Translate

5. Summarization Documentos Técnicos

Problema: Resumir papers científicos 20 páginas → 2 párrafos manteniendo info clave.

Solución:

• Dataset: 2,000 papers + resúmenes escritos por expertos
• Modelo: Llama 3.1-70B con LoRA
• Resultado: Resúmenes calidad comparable a humano en 30 segundos vs 30 minutos manual

Costos y ROI

Cloud vs Homelab

Google Colab:

• Free: T4 16GB, sesiones 12h (QLoRA 7B) ✅
• Pro ($10/mes): V100 16GB, sesiones 24h
• Pro+ ($50/mes): A100 40GB, compute units (LoRA 70B)

Cloud Pay-Per-Use:

• Lambda: RTX 4090 $0.60/h, A100 40GB $1.10/h
• RunPod: RTX 3090 $0.34/h, A100 80GB $1.89/h
• Vast.ai: Desde $0.20/h (community)

Homelab RTX 4090 ($1,600):

• Uso 3h/día × $0.60/h = $18/día = $540/mes en cloud
• Break-even en 3 meses
• Ahorro año 1: $6,480 – $1,600 = $4,880
• Años siguientes: $6,480/año ahorro

Tiempo de Entrenamiento

ROI Ejemplo Real

Startup SaaS – Customer Support:

• Antes: 3 agentes × $3,000/mes = $9,000/mes
• Fine-tuning:
• One-time: Colab Pro+ 1 mes ($50) + dataset prep (20h × $30/h = $600) = $650
• Inference: Modal.com GPU $100/mes
• Después: 1 agente supervisa + modelo automatizado = $3,000 + $100 = $3,100/mes
• Ahorro: $9,000 – $3,100 = $5,900/mes ($70,800/año)
• ROI: 650/5,900 = 0.11 meses (3.3 días)

Best Practices y Errores Comunes

Best Practices

1. Start Small, Iterate Fast

❌ Mal: Fine-tunear Llama 70B con 50K ejemplos en primer intento
✅ Bien: Llama 7B con 100 ejemplos → evaluar → iterar

2. Valida Early

# Entrenar 10% del dataset primero
quick_test_dataset = full_dataset[:100]
# Si loss no baja → fix dataset/config ANTES de entrenar completo

3. Version Control

# Git para código
git commit -m "Experiment 3: lr=2e-4, r=16, 1K examples"

# DVC para datos grandes
dvc add train.jsonl
dvc push

4. Experiment Tracking

# Weights & Biases
import wandb

wandb.init(
    project="fine-tuning",
    config={
        "learning_rate": 2e-4,
        "epochs": 3,
        "lora_rank": 16,
    }
)

# Auto-log todo durante training

5. Backup Checkpoints

# Guardar cada N steps
save_steps=50
# Si algo falla, no pierdes todo

Errores Comunes

Error 1: OOM (Out of Memory)

Soluciones:

# 1. Reduce batch size
per_device_train_batch_size=1

# 2. Gradient accumulation
gradient_accumulation_steps=16

# 3. Gradient checkpointing
gradient_checkpointing=True

# 4. Reduce max_seq_length
max_seq_length=512  # Era 2048

# 5. Usa QLoRA en vez de LoRA
load_in_4bit=True

# 6. Mixed precision
fp16=True

Error 2: Learning Rate Muy Alto

Síntomas: Loss oscila salvajemente o aumenta.

Fix: Reduce learning rate 10x.

learning_rate=2e-5  # Era 2e-4

Error 3: Dataset Muy Pequeño

Síntomas: Overfitting inmediato, val loss sube.

Fix:

• Consigue más datos (mínimo 100-200)
• Data augmentation (parafrasear ejemplos existentes)
• Usa modelo más pequeño
• Reduce epochs

Error 4: Formato Datos Incorrecto

Síntomas: Training arranca pero loss no baja.

Fix: Valida formato cuidadosamente.

# Debe ser EXACTAMENTE:
{"instruction": "...", "input": "...", "output": "..."}

# NO:
{"prompt": "...", "response": "..."}  # ❌ Nombre campos mal

Error 5: No Usar Validation Set

Fix: ALWAYS split train/val/test.

dataset = dataset.train_test_split(test_size=0.2)
train_dataset = dataset["train"]
eval_dataset = dataset["test"]

Preguntas Frecuentes

¿Cuánto cuesta realmente fine-tunear un modelo?

Gratis: Google Colab Free con QLoRA puede fine-tunear modelos 7B gratis (limitaciones sesión 12h).

Low-cost: Colab Pro+ ($50/mes) fine-tunea hasta modelos 70B con LoRA.

Homelab: RTX 4090 ($1,600 one-time) break-even en 3 meses vs cloud, luego gratis excepto electricidad (~$20/mes).

¿Necesito ser programador experto?

No. LLaMA-Factory tiene GUI completa – cero código. Unsloth con ejemplos copy-paste funciona si sabes Python básico. Esta guía tiene código completo funcional.

¿Puedo fine-tunear GPT-4 o Claude?

No directamente. OpenAI/Anthropic solo permiten fine-tuning via sus APIs (carísimo, $$$). Solución: Fine-tunea modelos open source (Llama, Mistral, Qwen) que son gratuitos y pueden igualar/superar GPT-4 en tareas específicas.

¿Cuántos datos necesito mínimo?

50-100 ejemplos: Proof of concept, aprender formatos simples.
500-1000: Tareas básicas producción.
5000+: Alta calidad producción.

PERO: 100 ejemplos excelentes > 10,000 mediocres.

¿LoRA o QLoRA para empezar?

QLoRA si:

• ✅ Tienes GPU modesta (<24GB VRAM)
• ✅ Usas Colab Free/Pro
• ✅ Quieres experimentar rápido

LoRA si:

• ✅ Tienes RTX 4090/A100 (24GB+)
• ✅ Necesitas máxima velocidad
• ✅ Producción con SLAs estrictos

¿Fine-tuning o RAG (Retrieval Augmented Generation)?

Fine-tuning: Modelo aprende patterns, estilo, formato. No para añadir hechos/datos dinámicos.

RAG: Busca info en base de datos, pasa al modelo en prompt. Para conocimiento actualizable.

Combinación (mejor): Fine-tunea formato/estilo + RAG para datos actualizados.

Ejemplo:

• Fine-tuning: “Responde en formato JSON siguiendo nuestro schema”
• RAG: “Busca info actualizada producto en DB antes de responder”

¿Puedo fine-tunear con datos en español/otro idioma?

Sí, perfectamente. Modelos multilingües (Llama 3, Qwen, Mistral) funcionan excelente con datasets en cualquier idioma. Solo asegura dataset tenga ejemplos en ese idioma.

¿Cómo evito que modelo olvide conocimiento general?

Problema: Catastrophic forgetting – modelo olvida conocimiento original.

Soluciones:

• Mezcla datos: 80% tu dataset + 20% dataset general
• LoRA/QLoRA: Preservan modelo base, solo agregan adaptadores
• Learning rate bajo: Cambios suaves vs drásticos
• Pocas epochs: No sobreentrenar

¿Puedo fine-tunear modelos en mi Mac M1/M2?

Sí, con MLX (biblioteca Apple para ML en Apple Silicon). Performance decent para modelos pequeños pero GPUs NVIDIA siguen siendo mejores para modelos grandes.

¿Fine-tuning mejora todas las capacidades del modelo?

No. Fine-tuning mejora tareas específicas del dataset. Si fine-tuneas para análisis sentimiento, mejora eso pero no mejorará code generation. Para múltiples tareas, fine-tunea con dataset mixto o usa múltiples adaptadores LoRA.

¿Cuánto dura un modelo fine-tuneado?

Indefinidamente si guardas los weights. Modelo base puede deprecarse (Llama 3 → Llama 4) pero tus adaptadores LoRA siguen funcionando con el base. Para producción seria, guarda modelo merged completo.

¿Necesito limpiar datos antes de fine-tuning?

Absolutamente. Garbage in = garbage out.

Limpieza básica:

• Remove duplicados
• Fix typos críticos
• Consistencia formato
• Remove ejemplos obviamente incorrectos

¿Puedo monetizar un modelo fine-tuneado?

Depende de la licencia del modelo base:

• Llama 3: Uso comercial OK si <700M users
• Mistral: Licencia Apache 2.0 (fully open)
• Qwen: Licencia permisiva comercial
• Gemma: Términos Google (revisar)

SIEMPRE revisa licencia antes de monetizar. Modelos base open source generalmente permiten fine-tuning comercial.

¿Inference después de fine-tuning es caro?

No. Inference cuesta igual que modelo base. Si fine-tuneaste Llama 7B:

• Cloud: ~$0.0002 por 1K tokens (vs $0.01-0.03 GPT-4)
• Local: Gratis excepto electricidad (~$0.0001 por 1K tokens)

Conclusión: Tu Roadmap de Fine-Tuning

Has llegado al final de esta guía. Aquí está tu plan de acción para empezar:

Semana 1: Experimentación (Gratis)

• Abre Google Colab Free
• Copia tutorial Llama 3.1-8B de esta guía
• Usa dataset ejemplo (Alpaca)
• Fine-tunea tu primer modelo (2-3 horas)
• Prueba generación

Semana 2: Tu Primer Modelo Real

• Recolecta 100-200 ejemplos de TU tarea
• Formatea como instruction dataset
• Fine-tunea con Unsloth + QLoRA
• Evalúa en test set
• Itera (ajusta LR, epochs, datos)

Semana 3-4: Producción Básica

• Expande dataset a 1,000+ ejemplos
• Usa Colab Pro+ ($50) o cloud GPU
• Fine-tunea modelo mejor (13B o 70B)
• Deploy inference (Modal, RunPod, local)
• Monitorea performance real

Mes 2+: Scale Up

• Automatiza data collection
• Version control (Git + DVC)
• Experiment tracking (W&B)
• A/B testing modelos
• Considera homelab GPU si uso constante

Recursos adicionales:

• Documentación Unsloth
• PEFT Docs
• Hugging Face Curso NLP

Fine-tuning pasó de ser “solo para empresas grandes” a “cualquiera con Colab Free”. La barrera de entrada es CERO. El único límite es tu creatividad para identificar casos de uso.

Si quieres montar tu propio entorno para fine-tuning local, revisa nuestra guía completa de homelab con GPU 24GB+ donde cubrimos toda la infraestructura necesaria.

Empieza hoy. En 3 horas puedes tener tu primer modelo custom funcionando. 🚀

Herramientas y Recursos para Fine-Tuning

• Ollama vs LM Studio – Elige la mejor herramienta para ejecutar tus modelos fine-tuneados
• Homelab con GPU 24GB+ – Configura tu homelab para fine-tuning con GPU
• RAG desde cero – Complementa tu modelo con RAG
• Whisper con Docker – Ejemplo práctico: Fine-tuning de Whisper