El Módulo 6 nos dejó con un base model: un modelo que sabe muchísimo del mundo pero solo hace una cosa — continuar texto. Le preguntas la capital de Chile y te responde con otra pregunta, porque aprendió a que el texto siga plausible, no a obedecerte. Este módulo cubre el paso que transformó esa curiosidad de laboratorio en la herramienta que usan millones: cómo un afinado relativamente pequeño convierte un continuador de texto en un asistente que sigue instrucciones. Es, literalmente, el salto de GPT a ChatGPT.

La tesis del módulo

El conocimiento ya estaba; lo que faltaba era el comportamiento. El fine-tuning no le enseña hechos nuevos al modelo: le enseña un formato — “cuando alguien te dé una instrucción, responde a esa instrucción”. Con miles de ejemplos de conversaciones bien hechas, el base model aprende a portarse como asistente. Y hoy eso se puede lograr entrenando apenas una fracción minúscula de sus pesos.

Fine-tuning: seguir entrenando, pero con propósito

El fine-tuning (glosar: “afinamiento”; tomar un modelo ya pre-entrenado y entrenarlo un poco más sobre datos específicos, para especializar su comportamiento sin partir de cero) es el mismo mecanismo del Módulo 6 — predecir el siguiente token y ajustar pesos con cross-entropy — pero sobre datos cuidadosamente elegidos y muchísimos menos.

El sabor que nos importa se llama supervised fine-tuning (SFT, glosar: afinamiento supervisado; entrenar con pares de ejemplo donde alguien preparó tanto la entrada como la respuesta ideal — “supervisado” porque hay respuestas modelo hechas por humanos). El dato ya no es texto crudo de la web: son pares (instrucción, respuesta):

 instrucción:  "Resume esto en una frase: <texto largo>"
 respuesta:    "El texto explica cómo funciona la fotosíntesis."

 instrucción:  "¿Cuál es la capital de Chile?"
 respuesta:    "La capital de Chile es Santiago."

Al entrenar sobre miles de estos pares, el modelo aprende el patrón de comportamiento: tras una instrucción, viene una respuesta que la atiende. Cuando ese SFT usa una colección amplia y variada de instrucciones, se llama instruction tuning (glosar: afinamiento por instrucciones; el SFT específicamente pensado para que el modelo generalice a seguir cualquier instrucción, no solo las del set de entrenamiento). Ese es el ingrediente que convierte al base model en asistente.

 base model                    modelo instruction-tuned
 (completa texto)              (sigue instrucciones)
      │                                 ▲
      │        SFT sobre pares          │
      └──► (instrucción, respuesta) ────┘
              miles de ejemplos

Chat templates: cómo se marca quién habla

Para que el modelo sepa dónde termina la instrucción del usuario y dónde debe empezar su respuesta, la conversación se formatea con marcas especiales. A eso se le llama chat template (glosar: plantilla de chat; el formato con tokens especiales que rodea cada turno para señalar los roles — sistema, usuario, asistente — dentro del texto plano que el modelo procesa).

Por dentro, una conversación se ve más o menos así (el formato exacto varía por modelo):

<|system|>   Eres un asistente útil y conciso.
<|user|>     ¿Cuál es la capital de Chile?
<|assistant|> La capital de Chile es Santiago.

El modelo aprende, durante el SFT, que después de la marca <|assistant|> le toca a él generar. Por eso hoy separamos roles (system, user, assistant): todo eso vive en el texto que el Transformer procesa, guiado por estas marcas. Cuando usas la API de un LLM y pasas messages con roles, la librería arma este template por ti.

Ojo: cada familia de modelos tiene su propio chat template. Aplicar el template equivocado a un modelo es una causa clásica de respuestas raras o degeneradas. En Hugging Face, tokenizer.apply_chat_template(...) usa el correcto automáticamente — úsalo en vez de armar el formato a mano.

Full fine-tuning vs PEFT/LoRA

Aquí viene la decisión más práctica del módulo. Hay dos formas de hacer el afinado:

Full fine-tuning: ajustar todos los pesos del modelo. Máxima flexibilidad, pero necesitas memoria y cómputo casi como para pre-entrenar, y terminas con una copia completa del modelo por cada tarea.
PEFT (glosar: Parameter-Efficient Fine-Tuning; familia de técnicas que afinan el modelo tocando solo una fracción minúscula de sus pesos, dejando el resto congelado). El miembro estrella es LoRA (glosar: Low-Rank Adaptation; en vez de modificar las matrices gigantes del modelo, se les suman unas matrices chiquititas y nuevas, y solo esas se entrenan; el modelo original queda intacto y congelado).

La idea de LoRA es elegante: al lado de cada matriz de pesos grande y congelada, se agregan dos matrices pequeñas cuyo producto se suma a la salida. Solo esas matrices chicas aprenden. Como son diminutas, entrenar cuesta poquísimo y el resultado (el “adaptador LoRA”) pesa unos pocos MB en vez de decenas de GB.

 entrada
    │
    ▼
 ┌──────────────────────┐        ┌──────────────┐
 │ matriz original W    │        │ LoRA: A y B  │
 │ (congelada, no       │        │ (chicas, SÍ  │
 │  se entrena)         │        │  se entrenan)│
 └──────────┬───────────┘        └──────┬───────┘
            │                           │
            └──────────►( + )◄──────────┘
                          │
                          ▼
                       salida

Combinar LoRA con cuantización (cargar el modelo base en 4 bits, técnica del Módulo 4 de GPU) se llama QLoRA, y es lo que permite afinar modelos de 7B–13B en una sola GPU de consumidor. Es la razón de que hoy cualquiera pueda especializar un LLM sin un datacenter.

	Full fine-tuning	LoRA / QLoRA
Qué se entrena	Todos los pesos	Solo matrices chicas añadidas
VRAM necesaria	Enorme (como pre-entrenar)	Baja: un 7B cabe en 1 GPU consumer
Costo / tiempo	Alto	Bajo, horas en vez de semanas
Peso del resultado	Otra copia completa (GB)	Un adaptador de pocos MB
Calidad tope	Máxima	Muy cercana, suficiente casi siempre
Cuándo usarlo	Cambios profundos, presupuesto grande	Casi siempre: rápido, barato, reversible

Un SFT con LoRA, en código

Ejemplo ilustrativo con Hugging Face (transformers + peft + trl). Es la estructura real que usarías; los datos y el modelo son de ejemplo:

from datasets import load_dataset
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig
from trl import SFTTrainer, SFTConfig

nombre = "meta-llama/Llama-3.2-1B"  # un base model chico
tok = AutoTokenizer.from_pretrained(nombre)
modelo = AutoModelForCausalLM.from_pretrained(nombre, device_map="auto")

# dataset de pares (instrucción, respuesta) ya en formato de chat
datos = load_dataset("json", data_files="mis_conversaciones.jsonl")["train"]

# config de LoRA: SOLO se entrenan estas matrices chicas
lora = LoraConfig(
    r=16,                       # "rango": qué tan chicas son las matrices
    lora_alpha=32,              # cuánto pesan al sumarse
    target_modules=["q_proj", "v_proj"],  # dónde se enchufan (capas de atención)
    task_type="CAUSAL_LM",
)

entrenador = SFTTrainer(
    model=modelo,
    train_dataset=datos,
    peft_config=lora,           # aquí se activa LoRA; el resto queda congelado
    args=SFTConfig(
        output_dir="./mi-asistente",
        num_train_epochs=3,
        per_device_train_batch_size=2,
        learning_rate=2e-4,
        assistant_only_loss=True,  # loss solo sobre las respuestas del asistente
    ),
)

entrenador.train()
entrenador.save_model("./mi-asistente")  # guarda el adaptador LoRA (pocos MB)

El SFTTrainer aplica el chat template, calcula la loss de cross-entropy solo sobre la parte de respuesta gracias a assistant_only_loss=True (no queremos que el modelo aprenda a generar la pregunta del usuario; sin esa opción la loss cubre todo el texto) y ajusta únicamente las matrices LoRA. El detalle fino de esta opción y del loss masking está en el Curso de Fine-tuning. Con esto, un base model de 1B se vuelve un asistente acotado en tu propia máquina.

Errores comunes

Creer que el fine-tuning “mete conocimiento nuevo”. Sobre todo con LoRA, lo que ajustas es comportamiento y formato, no una enciclopedia. Para conocimiento fresco, muchas veces conviene más RAG (ver embeddings y RAG) que fine-tuning.
Aplicar el chat template equivocado. Formatear con las marcas de otro modelo produce respuestas degeneradas. Usa apply_chat_template.
Ir a full fine-tuning por defecto. Para la enorme mayoría de casos, LoRA/QLoRA da calidad casi idéntica a una fracción del costo. Empieza por ahí.
Datos de baja calidad. En SFT manda la calidad, no la cantidad: mil ejemplos excelentes superan a cien mil mediocres. El modelo imita lo que le muestras, defectos incluidos.

La frase para llevarse

“El pretraining le dio al modelo qué decir; el fine-tuning le enseñó cuándo callarse y responder. Y hoy ese modal de asistente cabe en un adaptador de pocos megas.”

Qué viene

Módulo 8: RLHF y alineamiento. El SFT hace que el modelo obedezca, pero no garantiza que sea útil, honesto e inofensivo. Veremos cómo se afina el modelo con preferencias humanas — comparaciones entre respuestas, un reward model y PPO — y las alternativas modernas como DPO y el enfoque de Anthropic con Constitutional AI.

Transformers — Módulo 7: fine-tuning e instruction tuning — de GPT a ChatGPT