20 · Fine-tuning pràctic i PEFT

La pregunta que has de fer-te primer: realment necessito fer fine-tuning? En la gran majoria de casos de 2026, la resposta és no — i saber-ho t'estalvia setmanes.

1. L'arbre de decisió#🧭 sense fórmules

El model actual falla en la teva tasca?
├─ No → no facis res
└─ Sí → per què falla?
   ├─ Li falta informació        → RAG / context / eines
   ├─ No entén què vols          → millors prompts, exemples, sortides estructurades
   ├─ Format o to incorrectes    → prompt + few-shot (i si persisteix: SFT lleuger)
   ├─ Massa lent o massa car     → model més petit + fine-tuning (destil·lació)
   ├─ Domini molt especialitzat  → fine-tuning (o RAG, mesura'ls tots dos)
   └─ Necessites comportament    → fine-tuning amb dades de preferència
      molt específic i consistent

Casos on el fine-tuning guanya clarament: reduir cost i latència (model petit que iguala un de gran en una tasca), formats de sortida molt estrictes, dominis amb vocabulari i convencions pròpies, estil de marca consistent, tasques d'alt volum i baixa variabilitat.

Casos on perd: coneixement que canvia sovint (usa RAG), tasques poques i variades (usa prompting), quan no tens un conjunt d'avaluació sòlid (llavors no sabràs ni si ha millorat).

2. LoRA: la tècnica que ho va canviar tot#🧭 sense fórmules

En lloc d'actualitzar $\mathbf{W}\in\mathbb{R}^{d\times k}$, aprèn una actualització de rang baix:

$\mathbf{W}_0$ es congela. $\mathbf{A}$ s'inicialitza aleatòriament i $\mathbf{B}$ a zero, de manera que al començament $\Delta\mathbf{W}=0$ i el model és idèntic a l'original.

Per què és tan bo:

• Entrenes el 0,1-2% dels paràmetres → estats d'optimitzador i gradients minúsculs.
• Els adaptadors pesen de desenes a uns pocs centenars de MB (uns 168 MB amb la recepta de la secció 7 sobre un 8B): pots tenir-ne centenars per a un mateix model base i servir-los simultàniament amb batching (multi-LoRA serving).
• Es poden fusionar amb els pesos base ($\mathbf{W}_0 + \frac{\alpha}{r}\mathbf{BA}$) per no tenir latència afegida en inferència.
• Se sol dir que és menys propens a l'oblit catastròfic que el fine-tuning complet. No sempre: a l'escala petita del mini-GPT d'aquest tema, LoRA oblida més, i el widget d'entrenament ho mesura.

Hiperparàmetres:

Variants: QLoRA (base quantitzat a NF4 de 4 bits + adaptadors en bf16, amb paged optimizers i double quantization) porta el fine-tuning d'un model de 70B a tocar d'una sola GPU de 48 GB: amb els valors per defecte del calculador de VRAM en surten 48,2, i cal retallar el context o el lot perquè hi càpiga. DoRA separa magnitud i direcció i sol millorar LoRA amb rangs baixos. LoRA+ usa LRs diferents per a $\mathbf{A}$ i $\mathbf{B}$. rsLoRA corregeix l'escalat per a rangs alts.

Altres PEFT: adapters clàssics, prefix/prompt tuning (aprendre tokens virtuals), (IA)³, BitFit. LoRA i les seves variants han guanyat àmpliament.

3. Dades: la part que realment decideix#🧭 sense fórmules

El 90% de l'èxit d'un fine-tuning és el dataset.

• Quantitat: 500-5.000 exemples excel·lents per a una tasca concreta sol ser suficient. Per a canvis de comportament amplis, desenes de milers.
• Qualitat: revisa'ls a mà. Llegeix-ne 100 a l'atzar. Sempre hi trobaràs sorpreses desagradables.
• Consistència: si el 20% dels exemples segueixen un format diferent, el model aprendrà a barrejar-los.
• Diversitat: cobreix la distribució real d'entrades, incloent-hi casos límit i entrades que s'han de rebutjar.
• Generació sintètica: genera candidats amb un model fort, filtra'ls amb verificació o amb un jutge, i revisa una mostra. El rejection sampling (generar $k$, quedar-se amb els que passen un test) és la recepta més fiable.
• Divisió: train/val/test des del principi, i un conjunt de "regressions" per comprovar que no trenques el que ja funcionava.

4. Costos reals de VRAM (referència ràpida)#🧭 sense fórmules

Xifres aproximades per a longituds de seqüència moderades; el context llarg augmenta molt la memòria d'activacions. Redueix-la amb gradient checkpointing, batch petit + acumulació, i packing.

5. Destil·lació#🧭 sense fórmules

Transferir capacitat d'un model gran (professor) a un de petit (estudiant):

• De resposta (black-box): entrena l'estudiant amb les sortides del professor. És el que fa tothom, i és el que fa que els models petits hagin millorat tant. Compte amb les condicions d'ús del professor.
• De logits (white-box): minimitza $D_{KL}(p_{prof}\|p_{est})$ amb temperatura. Molt més eficient en dades, però requereix accés als logits i el mateix tokenitzador.
• De traces de raonament: vegeu 19 — actualment la forma més rendible de destil·lació.

Model merging: combinar diversos models fine-tunejats sobre la mateixa base (mitjana de pesos, task arithmetic, TIES, DARE, SLERP). Sona dubtós i funciona sorprenentment bé. És barat: no requereix cap entrenament.

6. Avaluació del teu fine-tuning#🧭 sense fórmules

1. Eval específica de la tasca amb barres d'error i comparació aparellada contra el baseline (03).
2. Eval de regressió: capacitats generals que no vols perdre (un subconjunt de benchmarks estàndard, més els teus casos antics).
3. Comprovació d'oblit catastròfic: el model segueix sabent el que sabia?
4. Inspecció manual de 30-50 sortides. No hi ha substitut.
5. Mesura del cost: latència i preu per consulta abans i després.

7. Receptes ràpides#🧭 sense fórmules

SFT lleuger amb LoRA (HF TRL):

from trl import SFTTrainer, SFTConfig
from peft import LoraConfig

peft_cfg = LoraConfig(r=32, lora_alpha=64, lora_dropout=0.05, task_type="CAUSAL_LM",
                      target_modules=["q_proj","k_proj","v_proj","o_proj",
                                      "gate_proj","up_proj","down_proj"])
cfg = SFTConfig(learning_rate=2e-4, num_train_epochs=2, per_device_train_batch_size=4,
                gradient_accumulation_steps=8, bf16=True, packing=True,
                gradient_checkpointing=True, logging_steps=10, eval_strategy="steps")
SFTTrainer(model="...", train_dataset=ds, peft_config=peft_cfg, args=cfg).train()

peft_cfg = LoraConfig(
    r=32, lora_alpha=64, lora_dropout=0.05,
    task_type="CAUSAL_LM",
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
)
cfg = SFTConfig(
    learning_rate=2e-4, num_train_epochs=2,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=8,
    bf16=True, packing=True, max_seq_length=2048,
    gradient_checkpointing=True, logging_steps=10,
)

Alineament de preferències: DPOTrainer amb parelles (chosen, rejected), $\beta\approx0.1$, LR $\sim5\text{e-}6$ (o $1\text{e-}4$ amb LoRA), 1 època.

Eines de l'ecosistema: Hugging Face TRL/PEFT (flexible), Axolotl i LLaMA-Factory (configuració declarativa YAML), Unsloth (molt més ràpid i eficient en memòria per a una sola GPU), torchtune.

8. Comprova que ho has entès#

9. Recursos#