SÉANCE 7 / 8SESSION 7 / 8 ⏱ ≈ 90 min

Fine-tuning LoRA / QLoRA sur votre datasetLoRA / QLoRA fine-tuning on your dataset

Objectif du jour : modifier le comportement d'un modèle avec vos propres données — et le faire sur un GPU de 12 Go, pas dans un centre de données. À la fin de cette séance, vous savez construire un jeu de données d'entraînement propre, régler les hyperparamètres qui comptent réellement, reconnaître le sur-apprentissage à temps, et comparer votre modèle affiné à sa version d'origine. Le gain du jour est votre adaptateur LoRA, entraîné sur votre dataset, avec une évaluation avant/après. Today's goal: modify a model's behaviour with your own data — and do it on a 12 GB GPU, not in a data centre. By the end of this session you can build a clean training dataset, set the hyperparameters that actually matter, spot overfitting in time, and compare your fine-tuned model against the original. Today's win is your LoRA adapter, trained on your dataset, with a before/after evaluation.

Ce que LoRA change — et ce qu'il ne change pasWhat LoRA changes — and what it does not

≈ 18 min

Rappelez-vous la séance 1 : un modèle a subi trois entraînements, et l'étape 2 (SFT) est celle qui transforme un compléteur en assistant. C'est exactement l'étape sur laquelle vous allez intervenir. Vous ne réapprenez pas le langage : vous ajustez un comportement. Recall session 1: a model goes through three trainings, and stage 2 (SFT) is the one that turns a completer into an assistant. That is exactly the stage you are about to act on. You are not relearning language: you are adjusting a behaviour.

L'idée de LoRA, en une imageThe LoRA idea, in one image

🧠 Le modèle de base est un livre imprimé : vous n'allez pas le réimprimer. LoRA colle des post-it sur certaines pages. Techniquement : on gèle tous les poids du modèle et on ajoute, à côté de certaines matrices, deux petites matrices de rang faible (A et B) dont le produit approxime la correction à appliquer. Résultat : on entraîne 0,1 à 1 % des paramètres — d'où la mémoire et le temps nécessaires qui s'effondrent. Et comme le livre n'est pas modifié, l'adaptateur est un fichier de quelques dizaines de mégaoctets : versionnable, partageable, superposable. The base model is a printed book: you will not reprint it. LoRA sticks sticky notes on certain pages. Technically: all the model's weights are frozen, and next to certain matrices we add two small low-rank matrices (A and B) whose product approximates the correction to apply. Result: you train 0.1–1 % of the parameters — hence the collapse in memory and time needed. And because the book is untouched, the adapter is a file of a few tens of megabytes: versionable, shareable, stackable.

ApprocheApproach	CoûtCost	Bon pourGood for	Mauvais pourBad for
Prompt engineeringPrompt engineering	MinutesMinutes	Presque tout, en premier essaiAlmost everything, as a first attempt	Format très contraint, volume d'appelsVery constrained format, high call volume
RAG	HeuresHours	Connaissance factuelle, citations, corpus évolutifFactual knowledge, citations, evolving corpus	Imposer une forme, apprendre un styleImposing a shape, learning a style
LoRA / QLoRA	Quelques heures de GPUA few GPU-hours	Comportement : format de sortie strict, jargon maison, ton, tâche répétitive, appel d'outil systématiqueBehaviour: strict output format, in-house jargon, tone, repetitive task, consistent tool calling	Injecter des faits qui changent ; ajouter de la connaissanceInjecting changing facts; adding knowledge
Fine-tuning completFull fine-tuning	Des centaines de GPU-heuresHundreds of GPU-hours	Changer le modèle en profondeur (rarement nécessaire)Deeply changing the model (rarely necessary)

⚠️ L'erreur de débutant la plus coûteuse : essayer d'apprendre des faits par fine-tuning. Vous obtiendrez un modèle qui récite vos faits avec assurance… et qui les oubliera dès que vous changerez un document. C'est du RAG, pas du fine-tuning. Le fine-tuning apprend des régularités de comportement, pas une base de données. The most expensive beginner mistake: trying to teach facts by fine-tuning. You will get a model that recites your facts confidently… and forgets them as soon as you change a document. That is RAG, not fine-tuning. Fine-tuning learns behavioural regularities, not a database.

📚 Sources : Hugging Face PEFT, LoRA — décomposition en deux matrices de rang faible, forte réduction des paramètres entraînés · HF TRL, SFT Trainer — boucle d'entraînement supervisé de référence, avec PEFT intégré. Sources: Hugging Face PEFT, LoRA — decomposition into two low-rank matrices, large reduction in trained parameters · HF TRL, SFT Trainer — the reference supervised fine-tuning loop, with PEFT built in.

QLoRA : pourquoi ça tient dans 12 GoQLoRA: why it fits in 12 GB

≈ 20 min

LoRA réduit les paramètres entraînés, mais le modèle de base doit quand même être en mémoire — et un 8 B en FP16 pèse 16 Go, ce qui ne rentre pas dans une RTX 3060 de 12 Go. QLoRA résout ça : le modèle de base est chargé en 4 bits (format NF4), et seuls les adaptateurs sont entraînés en précision plus élevée. LoRA reduces the trained parameters, but the base model still has to be in memory — and an 8 B in FP16 weighs 16 GB, which does not fit in a 12 GB RTX 3060. QLoRA solves this: the base model is loaded in 4 bits (NF4 format), and only the adapters are trained at higher precision.

Les trois idées du papier QLoRAThe three ideas of the QLoRA paper

TechniqueTechnique	Ce qu'elle faitWhat it does
NF4 4-bit NormalFloat	Un type de 4 bits adapté à la distribution des poids des réseaux de neurones (approximativement gaussienne), meilleur que l'arrondi uniforme.A 4-bit type fitted to the weight distribution of neural networks (approximately Gaussian), better than uniform rounding.
Double quantificationDouble quantization	Les constantes d'échelle sont elles-mêmes quantifiées : ~0,4 bit par paramètre économisé, soit ~3 Go sur un 65 B.The scale constants are themselves quantized: ~0.4 bits per parameter saved, i.e. ~3 GB on a 65 B.
Optimiseurs paginésPaged optimizers	L'état de l'optimiseur peut déborder en RAM système au lieu de faire planter l'entraînement : on évite les pics de mémoire.Optimizer state can spill to system RAM instead of crashing the run: memory spikes are avoided.

Où part la VRAM (le calcul qui décide de votre matériel)Where the VRAM goes (the calculation that decides your hardware)

Modèle 8 B en QLoRA, entraînement :

  poids de base (4 bits)      :  8,0e9 x 0,5 octet   =  ~4,0 Go
  adaptateurs LoRA (r=16)     :  négligeable (~0,05 Go)
  états d'optimiseur (Adam)   :  ~2 x adaptateurs    =  ~0,1 Go
  gradients                   :  ~adaptateurs        =  ~0,05 Go
  activations + cache d'attention : ~2 à 6 Go selon
                                    la LONGUEUR DE SÉQUENCE et la taille de lot
  ---------------------------------------------------------------
  TOTAL approximatif          :  ~8 à 12 Go

  => Tient sur UNE RTX 3060 (12 Go) si l'on reste sur des séquences
     de 1024-2048 tokens et une taille de lot effective modérée.
  => Sur Colab T4 (16 Go) ou Kaggle P100 (16 Go) : confortable.

🎯 La leçon du lab 2 s'applique à l'entraînement : ce qui fait exploser la VRAM d'un fine-tuning, ce n'est pas le nombre de paramètres, c'est la longueur de séquence (les activations croissent avec elle) et la taille de lot. Si vous manquez de mémoire : réduisez max_seq_length avant de réduire le rang LoRA, et augmentez l'accumulation de gradient au lieu de la taille de lot. On obtient la même taille de lot effective pour une fraction de la mémoire. The Lab 2 lesson applies to training: what blows up fine-tuning VRAM is not the parameter count, it is the sequence length (activations grow with it) and the batch size. If you run out of memory: cut max_seq_length before cutting the LoRA rank, and raise gradient accumulation instead of batch size. You get the same effective batch size for a fraction of the memory.

📚 Sources : Dettmers et al., QLoRA: Efficient Finetuning of Quantized LLMs, 2023 (NF4, double quantification, optimiseurs paginés) · HF blog, bitsandbytes, 4-bit quantization and QLoRA, 2023-05-24 · Unsloth, Fine-tuning LLMs Guide. Sources: Dettmers et al., QLoRA: Efficient Finetuning of Quantized LLMs, 2023 (NF4, double quantization, paged optimizers) · HF blog, bitsandbytes, 4-bit quantization and QLoRA, 2023-05-24 · Unsloth, Fine-tuning LLMs Guide.

Le dataset : 80 % du travail, 100 % du résultatThe dataset: 80 % of the work, 100 % of the result

≈ 26 min

C'est la partie que tout le monde bâcle et qui décide de tout. Un modèle entraîné sur 500 exemples excellents battra systématiquement un modèle entraîné sur 50 000 exemples médiocres. La qualité, la cohérence et la couverture des cas difficiles sont les seuls critères qui comptent. This is the part everyone rushes and that decides everything. A model trained on 500 excellent examples will systematically beat one trained on 50,000 mediocre ones. Quality, consistency and coverage of hard cases are the only criteria that matter.

Les formats que vous rencontrerezThe formats you will meet

FormatFormat	StructureStructure	QuandWhen
Alpaca	`{"instruction": "...", "input": "...", "output": "..."}`	Tâche instruction → réponse, avec entrée optionnelle. Le plus simple pour débuter.Instruction → response task, with optional input. The simplest to start with.
ShareGPT	`{"conversations": [{"from":"human",...},{"from":"gpt",...}]}`	Dialogues multi-tours. Nécessaire pour apprendre un comportement conversationnel.Multi-turn dialogues. Needed to learn conversational behaviour.
Gabarit de chatChat template	`<\|im_start\|>user … <\|im_end\|>` selon le modèleper model	Ce que la plupart des outils appliquent automatiquement à partir de la conversation. Voir l'avertissement ci-dessous.What most tools apply automatically from the conversation. See the warning below.

⛔ Le piège du gabarit de chat — la défaillance silencieuse n°1 du fine-tuningThe chat-template trap — the #1 silent failure of fine-tuning Chaque modèle a été entraîné avec un format de conversation précis (Llama utilise <|start_header_id|>, Mistral [INST]…[/INST], Qwen son propre gabarit). Si vous entraînez avec un gabarit différent de celui du modèle, l'entraînement converge quand même — la perte baisse, tout semble aller bien — mais le modèle produit des réponses dégradées parce que vous lui avez appris une convention qu'il n'attendait pas. Règle : laissez l'outil appliquer le gabarit du modèle (tokenizer.apply_chat_template via TRL/Unsloth), et vérifiez visuellement au moins un exemple formaté avant de lancer l'entraînement. Every model was trained with a precise conversation format (Llama uses <|start_header_id|>, Mistral [INST]…[/INST], Qwen its own template). If you train with a template different from the model's, training still converges — loss falls, everything looks fine — but the model produces degraded answers because you taught it a convention it did not expect. Rule: let the tool apply the model's template (tokenizer.apply_chat_template via TRL/Unsloth), and visually check at least one formatted example before launching training.

La recette du datasetThe dataset recipe

✅ À faireDo

100 à 1 000 exemples de haute qualité suffisent pour un comportement.100–1,000 high-quality examples are enough for a behaviour.
Le comportement exact que vous voulez, appliqué sans exception. Une seule incohérence et le modèle apprend l'incohérence.The exact behaviour you want, applied without exception. One inconsistency and the model learns the inconsistency.
Les cas difficiles : entrées ambiguës, champs manquants, refus. C'est là que le modèle se trompe aujourd'hui.The hard cases: ambiguous inputs, missing fields, refusals. That is where the model fails today.
Un jeu de validation retenu (10–20 %) — jamais le jeu qui vous sert à évaluer le résultat final.A held-out validation set (10–20 %) — never the set you use to evaluate the final result.
Dédoublonner, et anonymiser (aucune donnée personnelle réelle).Deduplicate, and anonymise (no real personal data).

⛔ À éviterAvoid

Dumper du brut (scraping, logs non filtrés) : vous apprendrez le bruit.Dumping raw data (scraping, unfiltered logs): you will learn the noise.
Des exemples quasi identiques : le modèle sur-apprend une seule forme.Near-identical examples: the model overfits to one shape.
Des sorties générées par le modèle sans relecture : vous amplifiez ses erreurs.Model-generated outputs without review: you amplify its errors.
Un dataset sans vérification de licence : c'est un risque juridique, pas technique.A dataset without licence checks: that is a legal risk, not a technical one.

🎯 Les données synthétiques, mode d'emploi honnête. Faire rédiger un brouillon par un grand modèle puis le corriger humainement est une méthode légitime et rapide pour atteindre 200–500 exemples. Mais un dataset entièrement synthétique et non relu apprend au petit modèle les erreurs du grand, avec une confiance accrue. Le contrôle qualité humain n'est pas optionnel : c'est ce qui distingue un dataset d'un dump. Synthetic data, the honest way. Having a large model draft examples and then correcting them by hand is a legitimate, fast route to 200–500 examples. But a fully synthetic, unreviewed dataset teaches the small model the large model's mistakes, with increased confidence. Human quality control is not optional: it is what separates a dataset from a dump.

Entraîner : les hyperparamètres qui comptentTraining: the hyperparameters that matter

≈ 20 min

ParamètreParameter	RôleRole	Valeur de départStarting value
`r` (rang LoRA)(LoRA rank)	Capacité de l'adaptateur. Plus grand = plus expressif, plus de mémoire, plus de risque de sur-apprentissage.Adapter capacity. Larger = more expressive, more memory, higher overfitting risk.	16 (8–64 selon la complexité)(8–64 by complexity)
`lora_alpha`	Pondération de la correction. La convention alpha = 2 × r est un bon point de départ.Weighting of the correction. The alpha = 2 × r convention is a good start.	2 × r
`target_modules`	Quelles matrices adapter. Toutes les couches linéaires donne plus de qualité ; seulement `q_proj`/`v_proj` est plus léger.Which matrices to adapt. All linear layers gives more quality; only `q_proj`/`v_proj` is lighter.	toutes les linéaires (via Unsloth)all linear layers (via Unsloth)
`learning_rate`	Bien plus élevé qu'un fine-tuning complet : LoRA entraîne peu de paramètres.Much higher than full fine-tuning: LoRA trains few parameters.	2e-4 (1e-4 à 3e-4)(1e-4 to 3e-4)
`num_train_epochs`	Presque toujours 1 à 3. Au-delà, vous mémorisez votre dataset.Almost always 1 to 3. Beyond that, you memorise your dataset.	2
taille de lot + accumulationbatch size + accumulation	La taille de lot effective = lot × accumulation × GPU. Montez l'accumulation, pas le lot, quand la VRAM manque.The effective batch = batch × accumulation × GPUs. Raise accumulation, not batch, when VRAM is short.	lot 2, accumulation 4 (effectif 8)batch 2, accumulation 4 (effective 8)
`max_seq_length`	Troncature des exemples trop longs. Vérifiez combien de vos exemples sont tronqués — sinon vous entraînez sur des phrases coupées.Truncation of over-long examples. Check how many of your examples get truncated — otherwise you train on severed sentences.	1024–2048, mesuré sur vos données1024–2048, measured on your data
`warmup_ratio`	Montée progressive du taux d'apprentissage : évite de casser le modèle au premier pas.Gradual learning-rate ramp: avoids breaking the model on the first step.	0,03

Sur-apprentissage : les signauxOverfitting: the signals La perte d'entraînement baisse mais la perte de validation remonte — c'est le signal d'arrêt. Autres symptômes : le modèle recopie mot pour mot vos exemples, il refuse toute entrée qui n'y ressemble pas, et il devient moins bon sur les tâches générales. Surveillez la validation, pas l'entraînement. Training loss falls but validation loss rises — that is the stop signal. Other symptoms: the model copies your examples verbatim, refuses any input unlike them, and gets worse on general tasks. Watch validation, not training.

Oubli catastrophiqueCatastrophic forgetting Le modèle devient excellent sur votre tâche et perd des capacités générales (raisonnement, autres langues, code). Parade : un rang LoRA modéré, 1–2 époques, et mélanger 10–20 % de données générales à votre dataset. Un adaptateur est réversible : vous pouvez toujours revenir à la base. The model becomes excellent at your task and loses general abilities (reasoning, other languages, code). Countermeasure: a moderate LoRA rank, 1–2 epochs, and mixing in 10–20 % general data with your dataset. An adapter is reversible: you can always return to the base.

Les outils, et où trouver un GPUThe tools, and where to find a GPU

OutilTool	PourquoiWhy
Unsloth	Le plus rapide et le plus économe en VRAM ; notebooks Colab gratuits fournis. Le meilleur point de départ.Fastest and most VRAM-frugal; free Colab notebooks provided. The best starting point.
TRL + PEFT	La référence Hugging Face : plus de contrôle, mieux documenté, plus lent. Le choix quand vous devez comprendre chaque étape.The Hugging Face reference: more control, better documented, slower. The choice when you need to understand every step.
Axolotl	Piloté par fichier de configuration : reproductible, adapté aux pipelines d'équipe.Config-file driven: reproducible, suited to team pipelines.
GPU gratuitFree GPU	Google Colab : T4 16 Go, gratuit, sans garantie de disponibilité ni de type de GPU. Kaggle : P100 16 Go, quota de 30 h/semaine réinitialisé chaque semaine (variable selon la demande).Google Colab: T4 16 GB, free, no guarantee of availability or GPU type. Kaggle: P100 16 GB, a 30 h/week quota reset weekly (varies with demand).
Votre labYour lab	2× RTX 3060 (24 Go cumulés). Une seule carte suffit pour QLoRA sur un 8 B avec Unsloth ; les deux avec TRL.2× RTX 3060 (24 GB total). One card suffices for QLoRA on an 8 B with Unsloth; both with TRL.

📚 Sources : Unsloth · HF TRL, SFTTrainer · HF PEFT, LoRA · Colab FAQ (accès gratuit aux GPU, sans garantie) · Kaggle, Efficient GPU Usage Tips (P100, quota 30 h/semaine). Sources: Unsloth · HF TRL, SFTTrainer · HF PEFT, LoRA · Colab FAQ (free GPU access, no guarantee) · Kaggle, Efficient GPU Usage Tips (P100, 30 h/week quota).

Lab 7 — Dataset, entraînement, évaluation avant/aprèsLab 7 — Dataset, training, before/after evaluation

≈ 25 min

🔬 Objectif : votre adaptateur, et la preuve qu'il sert à quelque choseGoal: your adapter, and proof that it does something

Étape 1 — Construire et valider le datasetStep 1 — Build and validate the dataset

# Génère un dataset de démonstration (extraction de tickets vers JSON)
# et le VALIDE : format, doublons, longueurs, gabarit, jeu de validation.
python3 labs/dataset/make_dataset.py --out dataset_tickets.jsonl --n 300

# Le script refuse de produire un dataset silencieusement défectueux :
# il vérifie la longueur en tokens (troncature), les doublons exacts,
# et affiche le gabarit formaté pour UN exemple — à relire à l'œil.

Étape 2 — Entraîner (sur le lab ou sur Colab)Step 2 — Train (on the lab or on Colab)

# Sur le lab (2x RTX 3060) ou sur Colab T4 — le script choisit Unsloth
# s'il est disponible, sinon TRL+PEFT (voie de référence).
python3 labs/lab7_finetune_qlora.py --dataset dataset_tickets.jsonl \
        --base-model unsloth/llama-3.1-8b-bnb-4bit \
        --r 16 --alpha 32 --epochs 2 --lr 2e-4 \
        --max-seq-len 1024 --batch 2 --grad-accum 4 \
        --out ./mon-adaptateur --validate-only   # d'abord : vérifier la config

# puis, pour de vrai :
python3 labs/lab7_finetune_qlora.py --dataset dataset_tickets.jsonl \
        --base-model unsloth/llama-3.1-8b-bnb-4bit --out ./mon-adaptateur

Étape 3 — Comparer base et modèle affinéStep 3 — Compare base and fine-tuned model

# Réutilise le harnais de la séance 3 : mêmes cas, même métrique.
# C'est le SEUL moyen honnête d'affirmer que le fine-tuning a servi.
python3 labs/lab3_eval_harness.py --model llama3.1:8b        --prompt hardened --compare
python3 labs/lab3_eval_harness.py --model mon-modele-affine --prompt hardened

🎯 Résultats réels mesurés sur le lab le 2026-09-18 — QLoRA complet, exécuté de bout en bout : Real results measured on the lab on 2026-09-18 — a complete QLoRA run, executed end to end:

Modèle de baseBase model	`Qwen/Qwen2.5-1.5B-Instruct`
DatasetDataset	255 exemples d'entraînementtraining examples + 45 de validationvalidation
RéglagesSettings	r=16, alpha=32, lr=2e-4, 2 époquesepochs, lotbatch 2 × 4, max_length 512
DuréeDuration	2 min 16 s sur une RTX 3060on one RTX 3060
Perte d'entraînement (moyenne)Training loss (mean)	0,8227
Perte de validationValidation loss époque 1 → époque 2epoch 1 → epoch 2	0,3952 → 0,3081 (elle baisse : pas de sur-apprentissage)(it falls: no overfitting)
Précision par token (validation)Per-token accuracy (validation)	91,1 % → 92,3 %
Taille de l'adaptateurAdapter size	8,75 Mo (`adapter_model.safetensors`)
Base vs affinéBase vs tuned 20 cas de validation tenus à l'écart20 held-out validation cases	JSON valide 20/20 → 20/20 champs exactsexact fields 0/20 → 4/20

Huit mégaoctets, et un gain mesuré de +4 cas. C'est tout ce que pèse votre contribution : le modèle de base n'a pas été modifié, l'adaptateur est un fichier que l'on versionne, partage, superpose et retire. Et l'entraînement a pris deux minutes — pas deux jours. C'est la démonstration concrète de la section 1 : LoRA ne réimprime pas le livre, il colle des post-it. Eight megabytes, and a measured gain of +4 cases. That is the entire weight of your contribution: the base model was not modified, the adapter is a file you version, share, stack and remove. And training took two minutes — not two days. This is the concrete demonstration of section 1: LoRA does not reprint the book, it sticks sticky notes.

⚠️ Comment lire honnêtement ce « 4/20 » — et pourquoi c'est la meilleure leçon du cours. Trois points. (1) La métrique est volontairement stricte : les cinq champs doivent tous être exacts, y compris impact, une chaîne de texte libre qui doit correspondre mot pour mot. Un seul champ faux sur cinq annule le cas. (2) Le modèle de base produisait déjà du JSON valide (20/20) — parce que le message système décrivait le schéma — mais il inventait toutes les valeurs (0/20). Le fine-tuning ne lui a pas appris à formater : il lui a appris à extraire. (3) 255 exemples sur un modèle de 1,5 B, ce n'est pas censé donner 95 %. C'est censé donner un gain mesurable — et c'est exactement ce que vous avez. Un cours qui vous promet 95 % vous mentira ; un cours qui vous apprend à mesurer 20 % vous rendra autonome. How to read this "4/20" honestly — and why it is the best lesson in the course. Three points. (1) The metric is deliberately strict: all five fields must be exact, including impact, a free-text string that must match word for word. One wrong field out of five voids the case. (2) The base model already produced valid JSON (20/20) — because the system message described the schema — but it invented every value (0/20). Fine-tuning did not teach it to format: it taught it to extract. (3) 255 examples on a 1.5 B model is not supposed to give 95 %. It is supposed to give a measurable gain — and that is exactly what you have. A course promising 95 % would be lying to you; a course teaching you to measure 20 % makes you self-sufficient.

⚠️ L'erreur que j'ai commise en écrivant ce lab, et qui est exactement la leçon de la séance. Ma première version du script de comparaison envoyait au modèle uniquement le message utilisateur, sans le message système avec lequel il avait été entraîné. Résultat : base et modèle affiné répondaient tous deux 0/20 en prose libre — le modèle ne savait plus quelle tâche on lui demandait. L'inférence doit rejouer la même entrée que l'entraînement, message système inclus. C'est la version « côté inférence » de l'erreur de gabarit de la section 3, et elle est plus sournoise encore : rien ne plante, les deux modèles ont juste l'air également mauvais. The mistake I made writing this lab — and it is exactly this session's lesson. My first version of the comparison script sent the model only the user message, without the system message it had been trained with. Result: base and tuned both answered 0/20 in free prose — the model no longer knew what task it was being asked. Inference must replay the same input as training, system message included. It is the inference-side version of the section 3 template error, and sneakier still: nothing crashes, both models just look equally bad.

⚠️ Un obstacle réel rencontré en exécutant ce lab, et sa leçon. TRL a changé son API entre les versions : max_seq_length est devenu max_length, warmup_ratio est devenu warmup_steps, et SFTTrainer(tokenizer=…) est devenu processing_class=…. Pire : dans TRL 1.x, le paramètre loss_type par défaut (chunked_nll) applique un patch au lm_head qui plante dès que le modèle est enveloppé par PEFT. La parade est exactement la discipline du cours : le script interroge la signature réelle de SFTConfig et filtre les paramètres au lieu de les coder en dur — « ne pas supposer une interface, la vérifier ». C'est aussi pour cela que le mode --validate-only existe : il attrape ce genre de problème en 30 secondes au lieu de 2 heures. A real obstacle hit while running this lab, and its lesson. TRL changed its API between versions: max_seq_length became max_length, warmup_ratio became warmup_steps, and SFTTrainer(tokenizer=…) became processing_class=…. Worse: in TRL 1.x the default loss_type (chunked_nll) applies a patch to the lm_head that crashes as soon as the model is wrapped by PEFT. The fix is exactly the course's discipline: the script inspects SFTConfig's real signature and filters parameters instead of hard-coding them — "do not assume an interface, verify it". That is also why --validate-only exists: it catches this class of problem in 30 seconds instead of 2 hours.

🎯 Ce que vous devez produire : un fichier .jsonl validé (format, pas de doublon, longueurs mesurées, gabarit vérifié à l'œil), un adaptateur LoRA entraîné avec sa courbe de perte de validation, et une comparaison chiffrée base contre affiné sur le harnais de la séance 3 ou sur le jeu de validation tenu à l'écart (labs/lab7_compare.py). Sans cette comparaison, vous ne savez pas si vous avez amélioré le modèle ou seulement dépensé du GPU. What you must produce: a validated .jsonl file (format, no duplicates, measured lengths, visually checked template), a trained LoRA adapter with its validation loss curve, and a quantified base-vs-tuned comparison on the session 3 harness or on the held-out validation set (labs/lab7_compare.py). Without that comparison, you do not know whether you improved the model or just spent GPU time.

Quiz — 5 questionsQuiz — 5 questions

≈ 8 min

1. Que gèle-t-on exactement dans LoRA ?1. What exactly is frozen in LoRA?

Aucun poids d'origine n'est modifié : c'est ce qui rend l'adaptateur petit (quelques dizaines de Mo), versionnable, superposable, et réversible — on retrouve la base en retirant l'adaptateur.No original weight is modified: that is what makes the adapter small (tens of MB), versionable, stackable, and reversible — remove the adapter and you are back to the base.

2. Vous voulez que le modèle connaisse votre nouvelle gamme tarifaire. Quel outil ?2. You want the model to know your new price list. Which tool?

Des faits qui évoluent = RAG (séance 6). Le fine-tuning apprend des régularités de comportement, pas une base de données : il mémoriserait les tarifs d'aujourd'hui et les oublierait à la prochaine mise à jour, sans possibilité de citer la source.Facts that change = RAG (session 6). Fine-tuning learns behavioural regularities, not a database: it would memorise today's prices and forget them at the next update, with no way to cite the source.

3. La perte d'entraînement baisse, la perte de validation remonte. Que faites-vous ?3. Training loss falls, validation loss rises. What do you do?

La perte d'entraînement baisse toujours si on laisse tourner : elle mesure la mémorisation, pas la généralisation. Ce qui compte est la validation. Une divergence entre les deux courbes est la définition du sur-apprentissage — et la raison pour laquelle on retient 10 à 20 % des données.Training loss always falls if you let it run: it measures memorisation, not generalisation. What matters is validation. A divergence between the two curves is the definition of overfitting — and the reason you hold out 10–20 % of the data.

4. Votre entraînement converge mais le modèle est mauvais. Premier suspect ?4. Your training converges but the model is bad. First suspect?

Un gabarit incorrect produit exactement ce symptôme : une perte qui descend normalement et un modèle qui répond mal, parce qu'il a appris une convention de conversation que le modèle de base n'attend pas. Relisez un exemple formaté avant chaque entraînement. C'est une défaillance silencieuse : rien dans les métriques ne l'annonce.A wrong template produces exactly this symptom: loss falling normally and a model answering badly, because it learned a conversation convention the base model does not expect. Re-read one formatted example before every training run. It is a silent failure: nothing in the metrics warns you.

5. Un 8 B en QLoRA ne rentre pas dans votre VRAM. Quoi d'abord ?5. An 8 B in QLoRA does not fit your VRAM. What first?

Les activations dominent la consommation quand la séquence est longue : réduire max_seq_length libère beaucoup de mémoire pour un coût de qualité souvent nul (si vos exemples tiennent dedans). Et l'accumulation de gradient permet de garder la même taille de lot effective sans payer la mémoire du lot. Réduire le rang LoRA ne fait presque rien gagner : les adaptateurs sont minuscules.Activations dominate consumption at long sequences: cutting max_seq_length frees a lot of memory at often-zero quality cost (if your examples fit). And gradient accumulation keeps the same effective batch size without paying for the batch's memory. Cutting the LoRA rank gains almost nothing: adapters are tiny.

Score : 0 / 5Score: 0 / 5

🏁 À retenirKey takeaways

LoRA gèle la base et n'entraîne que deux petites matrices. Adaptateur de quelques Mo : versionnable et réversible.LoRA freezes the base and trains only two small matrices. A few-MB adapter: versionable and reversible.
QLoRA = base en 4 bits (NF4) + adaptateurs en précision plus élevée. Un 8 B tient dans 8–12 Go.QLoRA = 4-bit base (NF4) + higher-precision adapters. An 8 B fits in 8–12 GB.
Le dataset, c'est 80 % du résultat : 100–1 000 exemples excellents, cohérents, avec les cas difficiles.The dataset is 80 % of the result: 100–1,000 excellent, consistent examples, including hard cases.
Vérifiez le gabarit de chat à l'œil : un mauvais gabarit converge quand même et sabote le résultat.Visually check the chat template: a wrong template still converges and sabotages the result.
Surveillez la perte de validation, pas celle d'entraînement. 1 à 3 époques, pas plus.Watch validation loss, not training loss. 1–3 epochs, no more.
Pas de comparaison avant/après = pas de preuve. Réutilisez le harnais de la séance 3.No before/after comparison = no proof. Reuse the session 3 harness.

🏆 Votre gain du jourToday's win
Un adaptateur LoRA entraîné sur votre propre dataset, avec son dataset validé, sa courbe de validation et une évaluation avant/après chiffrée. Vous avez modifié un modèle pour de bon — sans réentraîner le langage, sans cluster, et de façon réversible. A LoRA adapter trained on your own dataset, with its validated dataset, its validation curve and a quantified before/after evaluation. You have genuinely modified a model — without retraining language, without a cluster, and reversibly.

Sources de la séance : Dettmers et al., QLoRA, 2023 — arxiv.org/abs/2305.14314 · HF blog, bitsandbytes, 4-bit quantization and QLoRA, 2023-05-24 · HF PEFT, LoRA — huggingface.co/docs/peft · HF TRL, SFTTrainer — huggingface.co/docs/trl · Unsloth, Fine-tuning LLMs Guide — docs.unsloth.ai · Colab FAQ — research.google.com/colaboratory/faq.html · Kaggle, Efficient GPU Usage Tips — kaggle.com/docs. Consultation : 2026-09-18. Session sources: Dettmers et al., QLoRA, 2023 — arxiv.org/abs/2305.14314 · HF blog, bitsandbytes, 4-bit quantization and QLoRA, 2023-05-24 · HF PEFT, LoRA — huggingface.co/docs/peft · HF TRL, SFTTrainer — huggingface.co/docs/trl · Unsloth, Fine-tuning LLMs Guide — docs.unsloth.ai · Colab FAQ — research.google.com/colaboratory/faq.html · Kaggle, Efficient GPU Usage Tips — kaggle.com/docs. Consulted: 2026-09-18.