— factory / algos ML / adaptation de modèles pré-entraînés

FINE-TUNING ET LORA.

Le fine-tuning réentraîne un modèle déjà pré-entraîné sur vos propres exemples pour le spécialiser. LoRA (Low-Rank Adaptation) rend l'opération abordable : les poids d'origine sont gelés et seules de petites matrices ajoutées apprennent, souvent moins de 1 % des paramètres. L'adaptation obtenue ne pèse que quelques mégaoctets.

LLMApprentissage par transfertClassification de texteAdaptation légèreNiveau : avancé

FICHE D'IDENTITÉ

notes sur 5 · usage entreprise

PerformanceProche d'un fine-tuning complet, pour une fraction du coût

InterprétabilitéLe modèle adapté reste une boîte noire

VitesseHeures plutôt que jours, souvent sur un seul GPU

Facilité de réglageRang, pas d'apprentissage, époques : à tester

Tolérance aux données brutesExige des exemples propres et bien étiquetés

EN 30 SECONDES

Plutôt que de réécrire un manuel de 500 pages, on y colle quelques post-it qui adaptent son usage à votre métier. Le manuel reste intact ; les post-it se retirent ou se remplacent.

1. On part d'un modèle pré-entraîné

Ici CamemBERT, un modèle de la famille BERT entraîné sur du français. Il connaît déjà la langue, mais pas votre tâche.

2. On gèle ses poids et on ajoute des adaptateurs

À côté de certaines matrices du modèle, LoRA ajoute deux petites matrices dont le produit forme une correction. Le rang r fixe leur taille.

3. On n'entraîne que les adaptateurs

Sur vos exemples annotés, seules ces petites matrices et la couche de sortie apprennent. En production, on charge le modèle de base puis l'adaptateur du métier voulu.

LE CAS MÉTIER

avis clients · e-commerce / distribution

EN ENTRÉE

1 200 avis étiquetés pour apprendre

Des avis en français avec leur sentiment : positif, négatif ou neutre. 300 autres avis sont mis de côté pour le test.

EN SORTIE

Un classifieur maison, léger

Le modèle adapté classe chaque nouvel avis. Le code affiche d'abord la part de paramètres réellement entraînés, moins de 1 % du modèle, puis les résultats sur les avis de test.

CE QU'ON MESURE

L'exactitude, et les négatifs manqués

On mesure l'exactitude sur les 300 avis jamais vus, puis on lit la matrice de confusion. Un avis négatif classé neutre, c'est un client mécontent que personne ne rappelle.

QUAND LE SORTIR, QUAND L'ÉVITER

OUI

Tâche répétitive et bien définie : classer, extraire, reformuler dans un format fixe
Quelques centaines à quelques milliers d'exemples annotés de bonne qualité
Style ou vocabulaire maison qu'une consigne seule n'obtient pas
Plusieurs métiers servis par un même modèle de base, avec un adaptateur chacun

NON

Apporter des connaissances qui changent souvent : préférer un RAG
Moins d'une centaine d'exemples : une bonne consigne avec quelques exemples suffit souvent
Pas de jeu de test pour mesurer le gain : impossible de savoir si l'adaptation aide
Aucun GPU disponible : commencer par TF-IDF et une régression logistique

LES 4 RÉGLAGES QUI COMPTENT

Noms donnés pour la bibliothèque peft de Hugging Face.

r (rang)

Taille des matrices ajoutées. 8 ou 16 suffisent le plus souvent. Plus grand, l'adaptateur apprend davantage, coûte plus et risque de surapprendre.

lora_alpha

Facteur d'échelle de la correction, appliqué sous la forme alpha / r. On le fixe souvent au double du rang.

target_modules

Les matrices du modèle qui reçoivent un adaptateur. Les projections de l'attention (query, value) sont le choix classique ; ajouter les couches denses augmente la capacité.

Pas d'apprentissage (lr)

Plus élevé qu'en fine-tuning complet, de l'ordre de 1e-4 à 5e-4, puisque peu de paramètres bougent. À valider sur le jeu de test.

LE CODE MINIMAL

jeu d'exemple : avis_clients.csv ↓

# Classement des avis : fine-tuning avec LoRA en Python
import pandas as pd
import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification
from peft import LoraConfig, get_peft_model

avis = pd.read_csv("avis_clients.csv")
y = torch.tensor(avis["sentiment"].map({"negatif": 0, "neutre": 1, "positif": 2}).values)

nom = "almanach/camembert-base"  # CamemBERT : modèle public pré-entraîné sur du français
tokenizer = AutoTokenizer.from_pretrained(nom)
X = tokenizer(avis["texte"].tolist(), padding=True, truncation=True, max_length=64, return_tensors="pt")
modele = AutoModelForSequenceClassification.from_pretrained(nom, num_labels=3)

# LoRA : poids d'origine gelés, petites matrices ajoutées sur l'attention
config = LoraConfig(task_type="SEQ_CLS", r=8, lora_alpha=16, lora_dropout=0.1, target_modules=["query", "value"])
modele = get_peft_model(modele, config)
modele.print_trainable_parameters()  # moins de 1 % des paramètres

torch.manual_seed(42)
train, test = torch.randperm(len(avis)).split([1200, 300])  # 1 200 avis pour apprendre, 300 pour tester
optimiseur = torch.optim.AdamW(modele.parameters(), lr=5e-4)
modele.train()
for epoque in range(3):
    for lot in train.split(16):
        perte = modele(input_ids=X["input_ids"][lot], attention_mask=X["attention_mask"][lot], labels=y[lot]).loss
        perte.backward(); optimiseur.step(); optimiseur.zero_grad()

modele.eval()
with torch.no_grad():
    pred = modele(input_ids=X["input_ids"][test], attention_mask=X["attention_mask"][test]).logits.argmax(-1)
print("Exactitude sur 300 avis de test :", round((pred == y[test]).float().mean().item(), 3))
print(pd.crosstab(pd.Series(y[test].numpy(), name="réel"), pd.Series(pred.numpy(), name="prédit")))

Le fine-tuning avec LoRA se pratique en Python (transformers, peft) : pas d'équivalent R courant.

QUESTIONS FRÉQUENTES

Qu'est-ce que LoRA en IA ?

Low-Rank Adaptation, une méthode publiée en 2021 par des chercheurs de Microsoft. Elle adapte un grand modèle en gelant ses poids et en n'entraînant que de petites matrices ajoutées. La mémoire nécessaire à l'entraînement baisse fortement, et chaque adaptation se stocke à part.

Combien d'exemples faut-il pour un fine-tuning ?

Pour une classification, quelques centaines d'exemples par classe donnent souvent un bon résultat. La qualité compte plus que le volume, car des étiquettes incohérentes s'apprennent aussi. On commence petit, on mesure, puis on complète les classes où le modèle se trompe.

Quelle différence entre LoRA et QLoRA ?

QLoRA applique LoRA sur un modèle de base chargé en 4 bits. La mémoire nécessaire baisse encore, au point d'affiner un modèle de plusieurs dizaines de milliards de paramètres sur un seul GPU.