Chapitre 18 · 12 min

Fine-tuning avec LoRA

Spécialise ton modèle entraîné à bas coût avec LoRA, la voie pratique pour adapter un comportement sans payer un réentraînement complet.

Tu as un modèle. Il fonctionne, plus ou moins. Tu veux le spécialiser : meilleur en code, dans un dialecte précis, ou pour produire du JSON. L’approche naïve consiste à continuer l’entraînement sur les nouvelles données en mettant à jour tous les paramètres.

Ça marche, mais c’est cher. Fine-tuner un modèle d’un milliard de paramètres pour une petite tâche coûte beaucoup de GPU et produit un checkpoint énorme par tâche. La plupart des poids changent à peine.

LoRA rend le fine-tuning bon marché. Au lieu de modifier W, on le fige. On ajoute une petite correction basse-rang A · B et on n’entraîne que cette correction :

y = x \cdot W + \alpha \cdot x \cdot (A \cdot B)

W est [d × d], A est [d × r], B est [r × d], avec r ≪ d. Les entraînables passent de d² à 2 · d · r — un ratio d’économie de d / (2r). Le gain s’amplifie spectaculairement quand les modèles grossissent :

Ton modèle du ch.12 (n_embd = 128, r = 8) : chaque nn.Linear carré passe de 16 384 → 2 048 — soit 8× moins.
GPT-2 small (d = 1024, r = 8) : 1 048 576 → 16 384 — soit 64× moins.
Échelle GPT-3 (d = 4 096, r = 8) : 16 777 216 → 65 536 — soit 256× moins.

LoRA prend tout son sens quand les modèles sont gros. Sur ton modèle local de 14M paramètres, envelopper chaque nn.Linear ramène quand même le compte entraînable à environ 65k — soit ~200× moins de entraînables que le modèle complet. Le gain relatif ne fait que croître quand tu montes en taille.

1. La passe avant LoRA

Écris la formule. La cellule reçoit une matrice W figée, des matrices basses-rang A et B, et un facteur alpha.

Code · JavaScript

const x = [0.2701511529340699,-0.2080734182735712,-0.4949962483002227,-0.32682181043180597,0.14183109273161312,0.48008514332518304,0.3769511271716523,-0.07275001690430677];
const W = [[0.42073549240394825,0.4946791233116909,0.3251439200785584,-0.004425654645201938,-0.33181694210648377,-0.4958894267215579,-0.41588737131429915,-0.13118742685196438],[0.4953036778474352,0.41832781926802803,0.13545289415393452,-0.2140913347480755,-0.4582607739578169,-0.4768763263797359,-0.2607755010434559,0.08367785015140346],[0.4781879642022515,0.2645413430600119,-0.0793113344023545,-0.3841273306618334,-0.4998775866793099,-0.36959034832461146,-0.05739240689159361,0.28305381844909017],[0.3725565802396744,0.061786561372612,-0.27939452442580814,-0.48305888500419647,-0.44896384034464565,-0.19389081770471522,0.15661439121654258,0.4300347029062266],[0.19796257509091708,-0.15240531055110834,-0.42775998948766114,-0.4925731302341237,-0.3149439971372269,0.01769915136683034,0.3416308573680605,0.4974133956792032],[-0.013275577011983397,-0.3383859784436538,-0.4969443269616876,-0.41090891831541126,-0.12262599273382717,0.22601289358917528,0.4634092527088925,0.47271766701238516],[-0.2220563343537542,-0.4617292235020299,-0.4741410706349736,-0.2531828205548794,0.09239087228033373,0.39249019434065524,0.49940761236178977,0.3605188552508658],[-0.38973303480790233,-0.49960341709317685,-0.3635712500404263,-0.04859095294660451,0.29030559210615714,0.486315033621204,0.4429624082299742,0.1815856826866295]];
const A = [[0.45464871341284085,0.2060592426208783],[0.3251439200785584,-0.004425654645201938],[0.13545289415393452,-0.2140913347480755],[-0.0793113344023545,-0.3841273306618334],[-0.27939452442580814,-0.48305888500419647],[-0.42775998948766114,-0.4925731302341237],[-0.4969443269616876,-0.41090891831541126],[-0.4741410706349736,-0.2531828205548794]];
const B = [[0.0705600040299336,-0.2720105554446849,-0.4806987459397784,-0.4527891810033119,-0.2020188226615325,0.14818428935469266,0.4254517622670592,0.49331379602024267],[-0.14395165833253265,-0.4231102020875853,-0.4940158120464309,-0.32176906667849975,0.008850962552706789,0.33511458792168736,0.49643632404226856,0.4134143397450517]];
const alpha = 4;

const D = W.length;
const R = A[0].length;
const out = new Array(D).fill(0);
for (let j = 0; j < D; j++) {
  let s = 0;
  for (let i = 0; i < D; i++) {
    let delta = 0;
    for (let k = 0; k < R; k++) delta += A[i][k] * B[k][j];
    s += x[i] * (W[i][j] + alpha * delta);
  }
  out[j] = s;
}
return out;

La sortie LoRA peut imiter un full fine-tune si la mise à jour complète est approximativement basse-rang. Le papier LoRA montre que, pour beaucoup de tâches d’adaptation, cette hypothèse tient très bien.

2. Pourquoi ça marche

Ce qu’on adapte est souvent un déplacement étroit : parler dans un autre registre, suivre une instruction, citer une source, respecter un format. Ça ne demande pas forcément des millions de dimensions nouvelles. Quelques dimensions de “delta” suffisent.

Vois W comme la compétence de base du modèle, et α · A · B comme un overlay par tâche. Quand tu changes de tâche, tu changes d’overlay ; le modèle de base reste intact.

3. La version Python

Le pattern PyTorch consiste à envelopper les nn.Linear existants dans une version LoraLinear. Sauvegarde llm/lora.py :

"""llm/lora.py — LoRA adapter wrapper for nn.Linear."""
import math
import torch
import torch.nn as nn
 
class LoraLinear(nn.Module):
    """Wraps an existing nn.Linear with frozen weights + a trainable low-rank update."""
    def __init__(self, base: nn.Linear, r: int = 8, alpha: float = 16.0):
        super().__init__()
        self.base = base
        for p in self.base.parameters():
            p.requires_grad = False  # freeze
        self.r = r
        self.alpha = alpha
        d_in = base.in_features
        d_out = base.out_features
        self.A = nn.Parameter(torch.zeros(d_in, r))
        nn.init.kaiming_uniform_(self.A, a=math.sqrt(5))
        self.B = nn.Parameter(torch.zeros(r, d_out))  # zero init: model starts at base behavior
 
    def forward(self, x):
        return self.base(x) + self.alpha * (x @ self.A @ self.B)
 
def apply_lora(model, r=8, alpha=16):
    """Replace every nn.Linear inside the model with a LoraLinear wrapper."""
    for name, module in model.named_children():
        if isinstance(module, nn.Linear):
            setattr(model, name, LoraLinear(module, r=r, alpha=alpha))
        else:
            apply_lora(module, r=r, alpha=alpha)
    return model

Lis ce wrapper comme “comportement de base + petite correction apprise” :

self.base = base garde la couche originale.
requires_grad = False fige ses poids.
A projette vers le rang r.
B reprojette vers la sortie.
x @ self.A @ self.B est le delta basse-rang.
apply_lora parcourt le modèle et remplace les nn.Linear.

Deux détails :

B initialisé à zéro : au départ, le modèle produit exactement la sortie du modèle de base.
A initialisé avec Kaiming : petite init aléatoire prête pour les gradients.

Pour utiliser LoRA sur ton modèle du chapitre 13, modifie le setup d’entraînement :

from llm.model import GPT, GPTConfig
from llm.lora import apply_lora
 
# [1]
model = GPT(GPTConfig())
# [2]
model.load_state_dict(torch.load("checkpoints/model.pt"))
# [3]
model = apply_lora(model, r=8, alpha=16)
 
# only A and B are trainable now
# [4]
trainable = [p for p in model.parameters() if p.requires_grad]
print(f"trainable params: {sum(p.numel() for p in trainable):,}")
# ... rest of the training loop, using `trainable` for the optimizer

[1] recrée l’architecture.
[2] charge le checkpoint de base.
[3] ajoute les adaptateurs.
[4] donne à l’optimiseur seulement les paramètres entraînables.

4. Régime checkpoint

Un LoRA d’un modèle 1B avec r = 8 produit un checkpoint de quelques dizaines de Mo au lieu de plusieurs Go. Tu peux servir un modèle de base + des dizaines d’adaptateurs.

C’est pourquoi LoRA domine le fine-tuning open-source : on partage les deltas, pas tout le modèle.

Recap

LoRA fige W et ajoute α · A · B. - r est le rang de l’update, souvent 4-32. - B à zéro garantit que le modèle démarre identique à la base. - Les gains disque sont énormes. - La qualité approche souvent un full fine-tune pour beaucoup de tâches. - Ton projet local a maintenant llm/lora.py.

Pour aller plus loin

Prochaine étape : quantification — LoRA réduit le coût d’adaptation ; la quantification réduit le coût d’inférence.