Fine-tuning ligero con LoRA: personaliza un modelo en tu propia GPU

La promesa: un modelo que escribe como tú, conoce tu dominio o responde como tu asistente. La realidad (honesta): es más fácil de lo que crees y menos mágico de lo que sueñas. Vamos a ello.

Cuándo SÍ y cuándo NO hacer fine-tuning

NO lo hagas si:

Solo quieres que sepa de tus documentos → eso es RAG (receta en el blog)
Quieres comportamiento distinto → casi siempre basta un buen system prompt
Esperas que “aprenda” hechos nuevos → los LLM finetuned alucinan igual

SÍ hazlo si:

Quieres un ESTILO consistente (escribir como tu marca, formato fijo)
Tareas específicas donde los generalistas fallan (tu formato de actas, tu tono de email)
Has probado todo lo anterior y no basta

LoRA en 30 segundos

En vez de reentrenar los miles de millones de pesos (imposible en casa), LoRA entrena unas “capas complementarias” diminutas (decenas de MB) que se enchufan al modelo base. QLoRA además cuantiza el base durante el entrenamiento: un 7-8B se afina en una GPU de 12-16GB, o en CPU+64GB RAM con paciencia.

Paso 1: Los datos (el 90% del éxito)

Formato JSONL de instrucciones:

{"instruction": "Resume esta reunión en acta con secciones Acuerdos y Tareas", "input": "<transcripción real>", "output": "<TU acta real, como la escribes tú>"}

Consejos que importan:

500-2000 ejemplos de verdad es suficiente para estilo/formato
CALIDAD > cantidad: 300 ejemplos perfectos > 5000 mediocres
Usa tus ejemplos REALES (tus actas, tus emails). Lo sintético se nota.
Consistencia brutal: si tu formato de acta tiene 4 secciones, TODOS los ejemplos tienen esas 4 secciones.

Paso 2: Entrenar con Unsloth (lo más eficiente en casa)

from unsloth import FastLanguageModel
from unsloth.chat_templates import get_chat_template

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Qwen2.5-7B-Instruct",
    max_seq_length=2048,
    load_in_4bit=True,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,                       # rango LoRA: 8-32 razonable
    lora_alpha=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
)

# ... carga tus datos en formato chat y entrena
from trl import SFTTrainer
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=tus_datos,
    max_seq_length=2048,
    args={"per_device_train_batch_size": 2, "gradient_accumulation_steps": 4,
          "num_train_epochs": 3, "learning_rate": 2e-4, "logging_steps": 10},
)
trainer.train()
model.save_pretrained("mi-lora")

En una GPU de 16GB: ~30-60 min para 1000 ejemplos. En las Spark (CPU+GPU unificada): también funciona, más despacio.

Paso 3: Usarlo con Ollama

Exporta a GGUF: model.save_pretrained_gguf("mi-modelo", tokenizer, quantization_method="q4_k_m")
Crea el Modelfile:

FROM ./mi-modelo.gguf
SYSTEM "Eres el asistente del Laboratorio. Escribes actas en el formato estándar del equipo."

ollama create mi-asistente -f Modelfile y a chatear.

Los errores que nos costaron noches

Overfitting con pocos datos: 3 epochs con 200 ejemplos y el modelo solo sabía repetir literal. Solución: 2-3 epochs max, learning rate 2e-4 o menos, y dataset variado.
Mezclar formatos: ejemplos con estructura distinta confunden al modelo. Normaliza TODO antes.
No guardar el checkpoint intermedio: entrena, guarda, PRUEBA en cada época. A veces la época 2 es mejor que la 3.
Evaluar con el ojo: usa tu mini-benchmark casero ANTES y DESPUÉS. Que los números digan si mejoró.

El resultado honesto

Un LoRA bien hecho en una tarea concreta y con buenos datos puede convertir un 7B genérico en tu especialista personal, y corrige ese “casi pero no exactamente lo que quiero” que los prompts no logran. No crea inteligencia nueva: afina la que hay hacia TU caso. Y eso, en la práctica, vale oro.