PostTraining - Techniques de post-training des Language Models (SOTA 2024-2025)

← Documentation GenAI | ↑ .. | → SemanticKernel

Place dans GenAI : cette série est le pendant théorique et SOTA 2024-2025 de la série FineTuning. FineTuning couvre la boîte à outils pratique (LoRA, QLoRA, SFT, DPO, model merging) ; PostTraining remonte la chaîne conceptuelle complète SFT → RLHF → DPO → GRPO → RLVR → GAE et reproduit les techniques récentes (Deepseek-R1) sur petits modèles, complétée par un notebook d’évaluation comparative, un détecteur de reward hacking, et un notebook d’implémentation from-scratch de la famille “no critic” (GRPO/RLOO/GAE) sur toy env CPU, par un notebook multi-step à crédit différé causal (PT-12 : les cinq estimateurs re-mesurés, GAE-λ devient discriminant, verdict BEATS 5/5 seeds — le “1-step collapse” était une propriété du banc), et de trois notebooks appliqués Qwen + GRPO + reward vérifiable + rewardspy en ligne (PT-11a Z3 CSP arithmétique sur Qwen3.5-0.8B + PT-11b SymPy arithmétique + Z3 N-queens, plus leur validation multi-seed, plus PT-11c sur le cran au-dessus Qwen3-1.7B/2B qui qualifie l’étage GPU moyen 16 Go et oppose 0.8B vs 1.7B/2B à budget steps égal) qui font sortir la série du toy env vers un vrai LLM, et PT-13 sur les corrections 2025 de la loss GRPO (Dr. GRPO : retrait de ÷|o_i| et ÷std ; clip-higher de DAPO : ε_high=0.28 > ε_low=0.2), dont le biais de longueur est mesuré au niveau gradient, et PT-14 sur les lois thermodynamiques de l’entraînement (R08 : T ∼ η, équipartition ℓf = C·η, schedule 1/t optimal avec discontinuité η/2, force entropique — la physique des learning-rate schedules utilisés en PT-11), et PT-15 sur le contrôle par interprétabilité (R14 §3.2 / R11 §1.1 : refusal direction d’Arditi — extraction diffmoy, ablation par projection toutes-couches, steering additif ; machine unlearning et son évaluation white-box ; finetuning shallow « ~10 exemples rouvrent un modèle aligné » de Gade/Lermen ; evaluation awareness Claude 4.6/Apollo, et PT-16 sur le vericoding (Bursuc et al. 2025 : la preuve formelle comme récompense — pipeline spec → LLM local 7B → Dafny verify/lean réels → boucle de réparation 5 tentatives, avec le cas d’école LC0033 « liste vide prouvée conforme à une spec incomplète »), et PT-17 sur les règles de score propres comme récompense (laya, Nandakishor M., Apache-2.0) — récompense qui note une probabilité plutôt qu’une réponse ; étude étagée d’un modèle de décision non autorégressif (encodeur bidirectionnel + tête transformer, primitives choice/score/noul). Étage 1 (CPU from-scratch) : la famille des récompenses (binaire, linéaire, log, Brier, sphérique) sur tâche jouet où p(y|x) est connue — les propres calibrent 7,6× mieux que les impropres (ECE 0,011 vs 0,088) à exactitude comparable. Estimateur perturbation (GRPO-like G=8) vs gradient direct (MLE) : direct gagne en calibration. Question tranchée : la sur-confiance vient de toute récompense qui ne note que l’argmax, pas de la cross-entropie. Étage 2 (GPU 24 Go, ≥ 4 graines, bras CE / RL / RL+CE) reporté en PR séparée. Les deux se complèment : commencer par FineTuning pour la pratique, PostTraining pour la profondeur méthodologique.

Série pédagogique dédiée aux techniques de post-training des LMs ouverts : SFT, DPO, GRPO, RLVR. L’objectif est de comprendre pourquoi 2024-2025 marque une rupture pédagogique dans la façon dont les modèles de langue passent du pre-training brut à un assistant utile, et comment cette chaîne s’est simplifiée depuis la cascade RLHF historique jusqu’aux méthodes “direct” récentes.

Pourquoi cette série

Le post-training est le maillon qui transforme un modèle pré-entraîné — au mieux un excellent statisticien du langage — en assistant aligné sur des préférences humaines ou des objectifs vérifiables. Pendant longtemps, la chaîne canonique était RLHF : Supervised Fine-Tuning, puis Reward Model, puis PPO. Trois étapes, trois bugs potentiels, beaucoup d’instabilité. Les techniques récentes (DPO en 2023, GRPO en 2024, RLVR en 2024-2025) ont réduit cette chaîne en s’attaquant aux deux maillons faibles : la dépendance au Reward Model appris (DPO le supprime) et la lourdeur mémoire de PPO (GRPO la divise).

En janvier 2025, Deepseek-R1 a publiquement validé cette progression en montrant qu’un modèle moyen entraîné avec GRPO sur des tâches à récompense vérifiable (math, code) peut atteindre un niveau de raisonnement compétitif avec des modèles bien plus gros entraînés de façon classique. Cette série didactise cette chaîne de techniques avec des reproductions concrètes sur petits modèles (Qwen3.5-0.8B en QLoRA 4-bit ; Qwen2.5-0.5B/1.5B historiquement) déployables sur GPU 8 Go (RTX 3070), conformément à l’esprit “po-2024 pionnier parcimonieux” de l’Epic #1454.

L’angle pédagogique est d’expliquer la math du loss avant le code pour chaque technique. Trop de tutoriels existants montrent une cellule trainer.train() qui converge sans donner l’intuition de pourquoi DPO marche, pourquoi GRPO économise la mémoire, ou pourquoi RLVR contourne le besoin d’un Reward Model. Cette série inverse l’ordre : d’abord la formule, puis l’intuition, puis l’implémentation TRL/HuggingFace, puis les outputs réels d’entraînement.

À qui s’adresse cette série : ingénieurs ML curieux de comprendre la chaîne post-training au-delà des annonces de presse, étudiants en NLP voulant reproduire les techniques Deepseek-R1 sans cluster H100, et formateurs ayant besoin de notebooks pédagogiques sur des modèles que leurs étudiants peuvent réellement faire tourner. Prérequis : Python intermediate, PyTorch élémentaire, familiarité avec transformers, intuition de la backprop et de la cross-entropy. Le notebook PT-01 établit le contexte théorique sans code exécuté ; PT-02 reprend les bases SFT ; les notebooks PT-03 à PT-06 ajoutent une technique par étape.

Notebooks

#	Notebook	Sujet	Technique	Modèle cible	PR
PT-01	`PT_01_intro_post_training.ipynb`	Vue d’ensemble historique : SFT → RLHF → DPO → GRPO → RLVR	Théorique (markdown + figures)	N/A	—
PT-02	`PT_02_sft_baseline.ipynb`	Supervised Fine-Tuning baseline	`trl.SFTTrainer` + QLoRA 4-bit	Qwen3.5-0.8B	See #10289
PT-03	`PT_03_dpo_direct_preference.ipynb`	Direct Preference Optimization (Rafailov 2023)	`trl.DPOTrainer`	Qwen3.5-0.8B (QLoRA 4-bit)	#5078
PT-04	`PT_04_grpo_deepseek_r1.ipynb`	Group Relative Policy Optimization (livrable clé) — correctness reward (normalisation $/milliers/unités, crédit partiel) + harness d’éval 4 métriques	`trl.GRPOTrainer` + QLoRA 4-bit	Qwen3.5-0.8B	See #10289, #12438
PT-05	`PT_05_rlvr_verifiable_rewards.ipynb`	RL with Verifiable Rewards (math/code) — vérifieur robuste (tolérance abs/rel, crédit partiel) + harness accuracy/format_rate/think_length/backtrack_rate	`trl.GRPOTrainer` + verifier SymPy	Qwen3.5-0.8B (QLoRA 4-bit)	#10487, #10504, #12438 (orig. #1771)
PT-06	`PT_06_eval_comparative.ipynb`	Évaluation comparative SFT vs DPO vs GRPO vs RLVR	Tableaux, chart, framework décision	tous	#1772, #10819
PT-07	`PT_07_rewardspy_reward_hacking.ipynb`	Détecter le reward hacking (Goodhart) — observabilité reward	`rewardspy.watch`/`audit` (offline, sans GPU)	N/A (offline)	#4538
PT-08	`PT_08_grpo_from_scratch_toy_env.ipynb`	GRPO from scratch (toy env CPU) — mécanique du group-relative advantage, écart PPO↔︎GRPO, comparaison « avec vs sans critic »	`torch` from-scratch (no `trl`)	MLP jouet (CPU, ~1.5k params)	See #1454
PT-09	`PT_09_rloo_from_scratch_toy_env.ipynb`	RLOO from scratch (toy env CPU) — leave-one-out baseline, biais-variance vs GRPO, sibling de PT-08	`torch` from-scratch (no `trl`)	MLP jouet (CPU, ~1.5k params)	See #1454
PT-10	`PT_10_gae_from_scratch_toy_env.ipynb`	GAE from scratch (toy env CPU) — mini-critic + λ-bias/variance, 1-step collapse diagnostique empirique, justifie le choix no-critic de DeepSeek R1	`torch` from-scratch (no `trl`)	MLP jouet + value head (CPU, ~5.7k params)	See #1454
PT-11a	`PT_11a_grpo_qwen35_rlvr.ipynb`	GRPO + RLVR sur vrai LLM (Qwen3.5-0.8B QLoRA 4-bit) — reward vérifiable Z3 (CSP arithmétique), rewardspy en ligne, sortie du toy env	`trl.GRPOTrainer` + Z3 + `rewardspy.watch_trl`	Qwen3.5-0.8B (QLoRA 4-bit, GPU 8 Go)	See #10289 (#10302)
PT-11b	`PT_11b_grpo_qwen_rlvr_on_verifiers.ipynb`	GRPO + RLVR + rewardspy en ligne — la pile complète sur petit modèle Qwen3.5-0.8B QLoRA, Tier 1 SymPy (arithmétique) + Tier 2 Z3 (N-queens), détecteur Goodhart live, 100 steps réels — variante à verifiers complémentaires (sibling de PT-11a)	`trl.GRPOTrainer` + `rewardspy.watch_trl` (integration trl 1.9.2)	Qwen3.5-0.8B (QLoRA 4-bit)	See #10289
PT-11d multi-seed	`PT_11d_multiseed_qwen35_4x100.ipynb`	RLVR multi-seed 4 seeds × 100 steps — reproductibilité du run PT-11a (Qwen3.5-0.8B QLoRA 4-bit), opposition au run mono-seed, métrique informative de groupe (`num_generations`, #10603), verdict MECANISME_REPRO	`trl.GRPOTrainer` + verifiers SymPy/Z3	Qwen3.5-0.8B (QLoRA 4-bit)	See #10289
PT-11c	`PT_11c_grpo_qwen17_rlvr.ipynb`	RLVR sur cran au-dessus (Qwen3-1.7B ou Qwen3-2B QLoRA 4-bit) — extension directe de PT-11b au cran supérieur, 4 seeds × 100 steps, verdict mémoire (pic VRAM RTX 3080 Ti 16GB) + comparaison honnête 0.8B vs 1.7B/2B à budget steps égal. Architecture compatible `trl.GRPOTrainer`, peft 0.20.0 (vs 0.13.2 de PT-11b). Reward SymPy Tier-1 + Z3 N-queens Tier-2 + informative-group métrique #10603. Verdict mesuré (4 seeds × 100 steps chacun, RTX 3070 8 Go) : MECANISME_REPRO sur les DEUX crans — 1.7B mean 0.1148 ± 0.0059 (edge 19.33σ), 2B mean 0.1653 ± 0.0051 (edge 32.44σ), VRAM peak 3.67/4.98 Go, _31/43 min/seed ; le decideur intra-seed reste non-exécutable à 20 pts/seed (fix : `logging_steps=4`). Note env : `rewardspy` (GitHub-only, absent de PyPI) peut être non installé — wrapper no-op gracieux	`trl.GRPOTrainer` + verifiers SymPy/Z3 + `rewardspy.watch_trl` (optionnel)	Qwen3-1.7B ou Qwen3-2B (QLoRA 4-bit, GPU 16 Go cible)	See #12653
PT-12	`PT_12_multistep_delayed_credit.ipynb`	GAE-λ sur env multi-step à crédit différé causal (`count_ones`, terminal dépendant de toute la séquence) — re-mesure des 5 estimateurs REINFORCE/GRPO/RLOO/GAE-λ=0/GAE-λ=0.95, 5 seeds, vérificateur terminal Z3	`torch` from-scratch (no `trl`) + Z3 (RLVR)	MLP jouet acteur-critique (CPU, ~5.5k params)	See #1454
PT-13	`PT_13_dapo_drgrpo_corrections.ipynb`	Corrections de la loss GRPO — `Dr. GRPO` (retire `÷\\|o_i\\|` et `÷std`) et `clip-higher` de `DAPO` (ε_high=0.28 > ε_low=0.2) — biais de longueur mesuré au niveau gradient (norme par bucket : vanille dilue long-faux à ~0.32× vs dr ~0.81×, 5 seeds), amplification `÷std` (jusqu’à ×3.0), taux de climb sous clip (ε=0.2→21.5 pas, 0.28→15.8, 0.40→11.6), verdict comportemental honnête (aucun coût, banc non discriminant), Z3 vérificateur RLVR	`torch` from-scratch (no `trl`) + Z3 (RLVR)	MLP jouet (CPU, ~1.5k params)	See #1454
PT-14	`PT_14_neural_thermodynamic_laws.ipynb`	Lois thermodynamiques de l’entraînement (R08 Liu et al. 2025) — perte = énergie, η = température, bruit minibatch = bain thermique : largeur stationnaire σ(a) SGD/SignGD (edge of stability, plancher √(2π)/4·η), équipartition ℓf = (σg²η/4)/(1−aη/2) indépendant de la sharpness, T ∼ η, confrontation mini-GPT 106k au plateau (bruit d’étiquette q=0.15 : terme thermique BORNÉ C < 0.1, sous résolution du banc toy — verdict honnête, le GPT-2 rapporté 3.145+110·η_min le résout à son échelle ; écart SGD/Adam(0,0) qui s’inverse entre progrès et plateau), schedule 1/t optimal (discontinuité η/2, diagramme de phase (b, t_h) à optimum théorique exact 6.03e-06 vs 6.10e-06), loi de Fourier (relaxation de taux 2aη_B après switch de lr, 4 répliques), force entropique (piégeage vers les zones plates E.1, seuil de blocage η* = 4c/(ασg²) E.2)	`numpy` + `torch` from-scratch (toy + mini-GPT CPU)	toy river-valley + mini-GPT (CPU)	See #16741
PT-15	`PT_15_controle_interpretabilite.ipynb`	Contrôle par interprétabilité (R14 §3.2 / R11 §1.1) — refusal direction d’Arditi (diffmoy sur residual stream au dernier token, validation split-half, ablation par projection toutes-couches toutes-positions, taux de refus mesuré avant/après + side effects bénins), activation steering (courbe refus/α), machine unlearning (édition par activation : réversible par construction, non compétitive vs poids — Farrell 2024, verdict honnête), finetuning shallow (Gade/Lermen « ~10 exemples rouvrent un modèle aligné », proxy comportemental), evaluation awareness (Claude 4.6/Apollo : « les évals ne prouvent plus l’alignement », worst case = lower bound)	hooks `transformers` natifs (no `transformer_lens`), compatible transformers v5 (sortie decoder layer = tenseur direct)	Qwen2.5-0.5B-Instruct (fp16, GPU 8 Go)	See #16758, #16741
PT-16	`PT_16_vericoding_formal_verification.ipynb`	Vericoding (Bursuc et al. 2025, R15) — la preuve formelle comme récompense : pipeline spec → LLM local (Ollama Qwen2.5-7B) → `Dafny verify` / `lean` réels → boucle de réparation 5 tentatives (protocole papier), échantillon stratifié du benchmark public (30 Dafny + 12 Lean sans Mathlib), garde anti-contournement (`assume`/`sorry`/`native_decide`, parallèle du gate `proof-integrity`), cas d’école LC0033 : liste vide prouvée conforme à une spec incomplète, rejetée par la spec réparée — taux mesurés honnêtes d’un 7B local vs 82,2 %/26,8 % (cités) des modèles de frontière	Ollama local + `Dafny verify` + `lean` (toolchain elan)	Qwen2.5-7B-Instruct (local, GPU 8 Go)	See #16751
PT-17	`PT_17_laya_proper_rewards_toy.ipynb`	laya : règle de score propre comme récompense (Nandakishor M., Apache-2.0) — étude étagée d’un modèle de décision non autorégressif. Étage 1 CPU from-scratch : la famille des récompenses (binaire, linéaire, log, Brier, sphérique) entraînées sur une tâche jouet binaire où p(y	x) est connue — verdict mesuré : les récompenses propres calibrent 7,6× mieux que les impropres (ECE 0,011 vs 0,088) à exactitude comparable ; estimateur perturbation (GRPO-like G=8) vs gradient direct : direct gagne en calibration (ECE 0,011 vs 0,050) ; cas ordinal 4-classes (RPS, sphérique). Étage 2 (GPU 24 Go, ≥ 4 graines, bras CE / RL / RL+CE) reporté en PR séparée. Question tranchée : la cross-entropie n’est pas la source de la sur-confiance — c’est toute récompense qui ne note que l’argmax.	CPU toy env, `torch`+`numpy` (kernel `coursia-ml-training`)	— (CPU jouet)
PT-18	`PT_18_laya_ablation_distillation.ipynb`	laya étage 2 : l’ablation à trois bras — entraîne le vrai checkpoint `convaiinnovations/laya-multilingual` sur `LocalLLaMA/typed-decisions` et décompose la recette publiée : bras `ce` / `rl` / `rl_ce` (la recette `loss_rl + 1.0 * loss_ce`), quatre graines, calibration sur slice tenu à part, verdict §C par conjonction écart 2σ cross-seed et Diebold-Mariano apparié par décision (perte MSE des distributions rapportées). Réponse mesurée à la question ouverte de PT-17 : aucune part mesurable — NLL 0,876–0,878 pour les trois bras (σ inter-graines 0,002–0,005), NO BEATS sur `rl_ce` vs `ce` et `rl` vs `ce`, INCONCLUSIVE sur `rl_ce` vs `rl` (jambe DM seule, p_median 0,036) : l’exactitude de la recette publiée revient à sa jambe de cross-entropie.	grille CLI `_measurements/` (`laya` + `torch` CUDA, checkpoints 614 Mo hors dépôt) ; carnet d’analyse kernel `python3` sur agrégats committés	GPU 8 Go (grille 3×4 runs)	See #17878

Migration vers Qwen3.5 (complète sur les notebooks GPU). Qwen2.5 est superseded par Qwen3.5 (modèle vision-langage unifié, multimodal). PT-03 est migré vers Qwen3.5-0.8B (#5078) : l’évaluation DPO est désormais une vraie forward pass (accuracy mesurée 40 % sur 10 préférences held-out, vs 50 % aléatoire — le DPO n’a pas convergé sur 50 exemples, verdict honnête documenté dans le notebook) qui remplace l’ancienne accuracy hardcodée à 72 %. PT-02 est migré vers Qwen3.5-0.8B (#10289, #10813) : le SFT s’exécute sur le vrai petit modèle SOTA (architecture hybride 18×linear_attn + 6×self_attn, LoRA ciblant les deux types + MLP) — verdict honnête documenté : sur 50 exemples (3 steps), le loss oscille (1.92→2.17→1.76) et la génération se dégrade (SFT sous-alimenté sur modèle déjà instruct-tuned, pas un bug). PT-04 est migré vers Qwen3.5-0.8B (#10817, re-exec #11442) : le GRPO s’exécute sur le vrai petit modèle SOTA (vrai GRPO GPU, QLoRA 4-bit, récompense basée sur le score). PT-06 est migré vers Qwen3.5-0.8B (#10819) : l’évaluation comparative porte désormais sur le modèle migré. PT-05 est migré vers Qwen3.5-0.8B (#10487 : re-ciblage + run GPU réel commité — delta honnête documenté 12.5 % → 0.0 %, et #10504 : reward branché sur le ground truth). Architecture Qwen3.5 multimodale (Qwen3_5ForConditionalGeneration) chargée via AutoModelForImageTextToText (et non AutoModelForCausalLM). PT-15 reste sur Qwen2.5-0.5B-Instruct par choix délibéré : la refusal direction a été caractérisée par la littérature (Arditi et al. 2024) sur cette famille — le 0.5B suffit à rendre l’effet visible et mesurable, et l’exécution tient sur tout GPU 8 Go.

Progression pédagogique

Les notebooks s’enchaînent dans l’ordre. Sauter PT-02 (SFT) avant PT-03 (DPO) est techniquement possible mais perd l’intuition clé de DPO : pourquoi la formule contient un terme implicite de reward model est évident après avoir vu un SFT classique converger. De même, GRPO (PT-04) s’éclaire après avoir compris la limite mémoire de PPO. RLVR (PT-05) réutilise l’infrastructure GRPO mais remplace le reward appris par un vérificateur exact (sympy pour les expressions, sandbox pour le code). PT-16 (vericoding) est le cran au-dessus de PT-05 : le vérificateur n’est plus un oracle partiel mais une preuve formelle complète — il se lit en connaissance de la notion de récompense vérifiable.

PT-01 (intro) peut être lu en parallèle des autres notebooks ; c’est un compagnon théorique.

Comprendre les techniques en profondeur

Cette section développe le fond de chaque technique au-delà du simple nom dans le tableau. Les détails mathématiques précis vivent dans les notebooks ; ce qui suit est la carte mentale que la série cherche à installer chez l’apprenant.

SFT — Supervised Fine-Tuning

La technique la plus simple du post-training : un dataset de paires (prompt, réponse_souhaitée), un loss de cross-entropy classique, un optimiseur Adam. Du point de vue formel, c’est un MLE sur une distribution conditionnelle. Toute la subtilité réside dans la qualité du dataset : un SFT sur des réponses moyennes produit un assistant moyen. Les datasets de référence (OpenAssistant, Dolly, Tulu, Open-Hermes) sont devenus des assets à part entière de la communauté. Le piège majeur pour l’apprenant est de penser que SFT “aligne” le modèle : il l’imite seulement. L’alignement vient des étapes suivantes ou de la composition du dataset (curation, refus, ton).

DPO — Direct Preference Optimization (Rafailov 2023)

Le bond conceptuel clé de 2023. Plutôt que d’apprendre un Reward Model (RM) puis de l’utiliser dans PPO, DPO dérive une formule de loss qui consomme directement les paires de préférences (réponse_préférée, réponse_rejetée) et entraîne la policy directement. La dérivation passe par la solution analytique de l’optimum de PPO régularisé par KL : on montre que r(x, y) = β log(π_θ(y|x) / π_ref(y|x)) + Z(x), ce qui permet d’éliminer r du loss au profit d’une expression ne dépendant que de π_θ et π_ref. Bénéfice : un seul modèle à entraîner au lieu de deux, pas de critic, training stable. Inconvénients : suppose un BTL (Bradley-Terry-Luce) sous-jacent valide, sensible à la qualité des préférences (bruit dans le dataset = perturbation directe du gradient).

GRPO — Group Relative Policy Optimization (Deepseek 2024)

La rupture mémoire de 2024. PPO classique nécessite (1) la policy, (2) une copie référence de la policy pour le KL penalty, (3) un value head (critic) entraîné en parallèle. Sur un modèle 7B, c’est ~30 Go de VRAM pour les seuls poids. GRPO supprime le critic en estimant l’avantage par comparaison intra-groupe : pour chaque prompt, générer N completions (typiquement 8-16), évaluer chacune via la reward, calculer l’avantage relatif normalisé dans le groupe. Le baseline implicite du groupe remplace le critic. Bénéfice : ~40% de VRAM gagnée, même performance qu’PPO sur les benchmarks math/code. Inconvénients : sensibilité à N (trop petit = baseline bruitée, trop grand = coûteux), couplage fort à une reward de qualité.

RLVR — RL with Verifiable Rewards (Deepseek-R1 2025)

L’innovation méthodologique de 2025. Au lieu d’apprendre un Reward Model sur des préférences (cycle long, biaisé par les annotateurs), on utilise des tâches dont la réponse est vérifiable algorithmiquement : équations math (sympy.simplify(answer - target) == 0), code (exec(code); assert tests), traduction (bleu_score(translation, reference) > seuil). Le RM devient un vérificateur exact, ce qui élimine toute la complexité RLHF en aval. C’est ce qui a rendu possible Deepseek-R1 : combiné avec GRPO, on entraîne sur des prompts math/code sans aucune annotation humaine, et le modèle développe spontanément des chains-of-thought longs. Limite : applicable uniquement aux tâches vérifiables (math, code, logique formelle), pas aux tâches subjectives (écriture créative, conseil).

Corpus de vérificateurs RLVR (issue #10289)

Notre corpus RLVR séquence les vérificateurs mécaniques par coût de rollout. Chaque vérificateur est un module Python testable sur CPU, consommable par trl.GRPOTrainer via un adapteur de signature reward(prompts, completions, **kwargs) -> list[float].

Tier	Vérificateur	Coût / rollout	Livrable	PR
1	SymPy (arithmétique)	µs-ms	`PT_05` (inline)	#10487
1	Z3 / CSP (arithmétique, N-queens)	µs-ms	`PT_11a`/`PT_11b` (inline)	#10317
2	Lean : élaboration `lake env lean` + oracle d’axiomes `#print axioms`	~s	`verifiers/lean_rlvr_verifier.py`	#10539

Le vérificateur Lean (Tier 2, verifiers/lean_rlvr_verifier.py) est le composant distinctif du corpus : un modèle qui apprend à émettre by sorry pour toucher la récompense est le cas d’école de Goodhart, et nos règles Lean (lean-axiom.yml) énumèrent déjà les exploits (sorry, sorryAx transitif, native_decide/Lean.ofReduceBool, axiomes hors whitelist). Le vérificateur les détecte (oracle de reward hacking) plutôt que les récompenser — récompense binaire 1.0 ssi la preuve compile sans sorry ni axiome interdit. Il réutilise le mécanisme LeanVerifier.check_axioms de agent_tests/lean_server.py (#8680), aucune logique de détection réécrite. Prérequis : elan (règle F, vrai moteur). Tests : pytest verifiers/test_lean_rlvr_verifier.py (10 contrôles positifs/négatifs/oracle sur le vrai Lean 4).

GAE — Generalized Advantage Estimation (Schulman 2015, retour pédagogique)

Le 3ᵉ pilier du post-training moderne, et souvent le seul utilisé en pratique dans PPO : Generalized Advantage Estimation (Schulman et al., 2015) interpole entre TD(0) (λ=0, bas biais, haute variance) et Monte-Carlo (λ=1, haut biais, basse variance) via une moyenne géométrique des n-step TD-errors pondérée par λ. La formule canonique : $A_t^{GAE} = \sum_{l=0}^{T-t} (\gamma\lambda)^l \delta_{t+l}$ avec $\delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)$. Le mini-critic (1 value head) est entraîné via MSE sur les returns bootstrappés. La série PT-08/09/10 montre empiriquement que sur un env 1-step sparse-reward (cas typique du LLM génération courte), GAE collapse en TD(0) et n’apporte aucun bénéfice mesurable par rapport à REINFORCE+baseline, justifiant a posteriori la décision de Deepseek-R1 de remplacer le critic par une baseline intra-groupe. Sur du multi-step (chain-of-thought long), GAE retrouve son intérêt car λ-bootstrapping réduit la variance du gradient. PT-10 (CPU toy env) illustre la symétrie : no-critic GRPO/RLOO dominent en 1-step, GAE redevient discriminant en multi-step. PT-12 confirme empiriquement cette dernière phrase : sur un env multi-step à crédit différé causal (count_ones), GAE-λ=0.95 bat GAE-λ=0 sur 5/5 seeds (moyenne ≈ 0.92 vs ≈ 0.20), et REINFORCE/GRPO/RLOO résolvent la tâche sans critic — le “1-step collapse” était une propriété du banc, pas des méthodes.

Architecture conceptuelle

                  ┌──────────────────────┐
                  │  Base LM (pretrained)│
                  │  Qwen3.5-0.8B-Base   │
                  └──────────┬───────────┘
                             │
                  ┌──────────▼───────────┐
                  │  SFT (PT-02)         │
                  │  trl.SFTTrainer      │
                  │  → Qwen-0.5B-SFT     │
                  └──────────┬───────────┘
                             │
              ┌──────────────┼──────────────┐
              │              │              │
       ┌──────▼──────┐ ┌─────▼──────┐ ┌────▼─────────┐
       │ DPO (PT-03) │ │GRPO (PT-04)│ │ RLVR (PT-05) │
       │ pair-based  │ │ group-based│ │ exact reward │
       │ no RM       │ │ no critic  │ │ no RM appris │
       └─────────────┘ └────────────┘ └──────────────┘
              │              │              │
              └──────────────┼──────────────┘
                             │
                  ┌──────────▼───────────┐
                  │  Eval (PT-06)        │
                  │  GSM8K, IFEval       │
                  │  comparaison métriques│
                  └──────────────────────┘

Contraintes RTX 3070 8 Go (parcimonie po-2024)

Modèles ≤ 1.5B params, modèle de référence Qwen3.5-0.8B en QLoRA 4-bit (pic VRAM mesuré ~2,5 Go, PT-05)
Quantization 4-bit (bitsandbytes) obligatoire pour modèles > 0.5B
LoRA rank ≤ 16, alpha ≤ 32, adapters sur attention + MLP
Batch size ≤ 4, gradient accumulation jusqu’à 16 pour batch effectif 64
Training time cible : < 60 min par notebook
Datasets HF publics : HuggingFaceH4/ultrafeedback_binarized subset, openai/gsm8k, HuggingFaceH4/MATH-500

Quick Start

# 1. Activer l'environnement
conda activate coursia-ml-training

# 2. Installer dependances post-training (a faire une fois)
pip install --upgrade transformers trl peft accelerate datasets bitsandbytes

# 3. Verifier la VRAM
python -c "import torch; print(f'CUDA: {torch.cuda.is_available()}, {torch.cuda.get_device_name(0)}, {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB')"

# 4. Lancer le premier notebook
jupyter notebook PT_01_intro_post_training.ipynb

Pièges pédagogiques courants

Les notebooks anticipent et adressent explicitement plusieurs erreurs d’interprétation que les apprenants développent typiquement face à ces techniques :

“DPO est juste un SFT sur les préférences” — faux. DPO contient un terme de divergence par rapport au modèle de référence (π_ref) qui empêche le drift catastrophique. Un SFT sur paires préférées seules effondrerait la diversité. PT-03 isole expérimentalement ce terme via un ablation (β = 0 vs β = 0.1) pour rendre visible son effet.
“Plus de seeds GRPO = mieux” — faux jusqu’à un seuil. Au-delà de N ≈ 16, le baseline intra-groupe devient stable mais le coût VRAM explose. PT-04 exécute G = 4 et renvoie le dimensionnement en N à l’exercice estimer_memoire_grpo (coût VRAM par taille de groupe) — l’arbitrage rendement/coût est posé, pas pré-calculé.
“RLVR remplace toutes les autres méthodes” — faux. RLVR est restreint aux tâches vérifiables. Pour écriture créative, conversation ouverte, assistance, DPO reste l’approche dominante. PT-05 expose cette limite via un contre-exemple : appliquer RLVR à une tâche subjective produit un modèle dégénéré qui exploite la fonction de reward exacte.
“LoRA = moins de qualité que full fine-tuning” — vrai marginalement, faux pratiquement. Sur un budget GPU 8 Go, LoRA atteint 95-98% de la qualité d’un full FT à 5% du coût mémoire. PT-02 documente ce trade-off explicitement.
“Le post-training résout les hallucinations” — faux. Les hallucinations viennent du pre-training (sous-représentation factuelle) ; le post-training les masque parfois en augmentant la confiance des refus, mais ne les supprime pas. PT-06 illustre via TruthfulQA : SFT/DPO/GRPO améliorent surface, pas substance.

Ces points sont signalés en encarts > **Piège :** au fil des notebooks, avec exercices de vérification.

Méthodologie d’évaluation

Comparer SFT vs DPO vs GRPO vs RLVR de façon honnête requiert une discipline expérimentale stricte. La série applique les règles suivantes, alignées sur la règle CoursIA Multi-seed ≥ 4 :

Seeds fixées : {0, 1, 7, 42} (au minimum). Résultats single-seed = signal bruit, jamais une “victoire”.
Held-out separation : datasets HF splittés via seed=42 réservé évaluation. Aucune training data ne fuit dans l’eval.
Benchmarks distincts : aucune métrique unique ne suffit. La série évalue sur :
- GSM8K (math reasoning, 1.3k test) — cible RLVR
- MMLU subset (knowledge, 5k test) — non-cible, contrôle de régression
- IFEval (instruction following, 541 test) — cible DPO/SFT
- HumanEval (code, 164 test) — cible RLVR
Verdict honnête : BEATS / NO BEATS / INCONCLUSIVE selon écart ≥ 2σ cross-seed. Pas de “promising”, pas de “trending positive”.
Budget compute fixe : chaque technique reçoit le même budget GPU-hour pour la comparaison finale (typiquement 30 min RTX 3070).
Coût cache : on rapporte VRAM peak, training time, et nombre de tokens vus pour rendre les trade-offs visibles. “DPO bat GRPO de 2%” est inutile si DPO consomme 3x plus de VRAM.

PT-06 documente le pipeline d’évaluation complet et produit un tableau comparatif final reproductible.

Qualité pédagogique

Aspect	Application
Exercices	Stubs sans erreur (`pass`, `print(...)`, `return None`) : le notebook s’exécute de bout en bout même exercices non complétés
Outputs	Tous les notebooks committés avec outputs réels d’exécution
Environnement	`coursia-ml-training` requis (TRL + bitsandbytes + datasets)
Méthodologie	Toute claim comparative (“GRPO > DPO”) vérifiée sur >= 4 seeds avec écart >= 2 sigma

Ponts avec les autres séries

Série	Connection	Details
RL	RL classique fondamentaux + sous-série `rlpt_*`	Les notebooks RL (rl_5 MDP/Q-Learning et rl_6c PPO from scratch) établissent l’intuition policy/value que PPO/GRPO réutilisent. Recommandés comme prérequis pour PT-04.
RL — rlpt_2 GRPO	GRPO naked (sans `trl`)	La mécanique de GRPO (group rollouts, avantage intra-groupe, no critic) écrite à la main sur Qwen3.5-0.8B. Bon prérequis conceptuel pour PT-11a/PT-11b.
RL — rlpt_3 reward hacking	Cas clinique d’inoculation	Mini-cas : 3 voies pour déclencher le hack sur récompense vérifiable, inoculation comme variable. PT-07 est l’outil (catalogue de détecteurs), rlpt_3 le cas d’usage.
RL — rlpt_4 DPO vs PPO	Comparaison offline vs online	DPO/ORPO offline vs GRPO online à budget 40 steps — prérequis empirique pour PT-06 (évaluation comparative).
RL — rl_9 offline	DPO = preference learning offline	Le Behavior Cloning y est l’analogue tabulaire du SFT, et la contrainte de support de BCQ celle de la pénalité KL de DPO (PT-03). Le meilleur prérequis conceptuel pour DPO.
RL — rl_10 reward shaping	Reward model = shaping appris	Le reward shaping (Ng 1999) et son biais (shaping naïf → reward hacking) préfigurent le reward model appris et le Goodhart traité en PT-07.
GenAI/FineTuning	Boîte à outils fine-tuning	Série sœur dans GenAI : LoRA/QLoRA/SFT/DPO en pratique. PostTraining = profondeur méthodologique (voir `COURSE_CATALOG.generated.md` pour le décompte canonique), FineTuning = recettes exécutables.

Frontière avec RL/rlpt_* — où ouvre `PT_`, où ouvre `rlpt_`

Les sous-séries RL/rlpt_* et cette série PostTraining couvrent le même terrain (post-training d’un LM) à des niveaux de pile différents. La frontière est posée explicitement pour qu’un lecteur sache quel notebook ouvrir pour quelle question.

Une phrase à retenir : PT_* = la chaîne réelle, à l’échelle (trl.GRPOTrainer + trl.DPOTrainer + Qwen3.5-0.8B QLoRA 4-bit + vérificateur Z3/SymPy + détecteurs Goodhart en ligne + multi-seed) ; rlpt_* = la mécanique, en petit, sans framework (boucle d’entraînement écrite à la main, on voit chaque rollout et chaque gradient).

Question pédagogique	Ouvrir	Pourquoi
« Comment SFT/DPO/GRPO sont-ils câblés dans `trl` ? Comment lire une loss ? »	PT-02, PT-03, PT-04	`trl.SFTTrainer`/`DPOTrainer`/`GRPOTrainer` sur vrai LLM Qwen3.5-0.8B QLoRA, vraies losses, vrais gradients via la pile HuggingFace.
« Comment GRPO fonctionne intérieurement — group rollouts, avantage intra-groupe, no critic ? »	PT-08 (toy env) ou RL/rlpt_2 (vrai LM sans `trl`)	La mécanique écrite à la main — on voit chaque rollout, chaque reward, chaque log-prob ratio.
« GRPO + RLVR sur vrai LLM, avec détecteur Goodhart en ligne, multi-seed ? »	PT-11a, PT-11b	La pile SOTA 2025 : `trl.GRPOTrainer` + Z3/SymPy + `rewardspy.watch_trl` (Goodhart live), 4 seeds dans PT-11b-multi-seed.
« Quels sont les détecteurs statistiques du reward hacking ? »	PT-07	Catalogue `rewardspy.detectors` (6 classes : Component Dominance, Length Drift, etc.) — l’outil.
« Le reward hacking est-il un attracteur spontané sur petit modèle ? Cas clinique. »	RL/rlpt_3	Mini-cas : 3 voies pour déclencher le hack, inoculation comme variable — le cas d’usage de `rewardspy`.
« InoculationRL complet, panel persona × reward hackable, capstone ? »	#5105 ICT-25	Capstone final — distinct de `rlpt_3` (qui en est la version compacte).

Le constat d’éventuelle duplication rlpt_2 ↔︎ PT-11a et rlpt_3 ↔︎ PT-07 est traité en #11460 : les deux séries se complètent par l’angle du regard (mécanique vs déploiement outillé), pas par duplication.

Contexte industriel et historique 2017-2025

La chaîne SFT → RLHF → DPO → GRPO → RLVR n’est pas une succession linéaire d’améliorations techniques : c’est une succession d’adaptations à des contraintes économiques et infrastructurelles changeantes. Comprendre ces contraintes aide à anticiper la prochaine étape.

2017-2020 : l’ère du Reward Model — Christiano et al. (NeurIPS 2017) introduisent le concept de “deep RL from human preferences” sur des tâches Atari. Stiennon et al. (NeurIPS 2020) l’appliquent au résumé de texte. À cette époque, le calcul est abondant et le bottleneck est la qualité des annotations. L’industrie investit massivement dans des équipes d’annotateurs (OpenAI/Surge, Anthropic/Surge, Scale AI, Mechanical Turk rénové). PPO domine.

2022 : InstructGPT canonise RLHF — Ouyang et al. (NeurIPS 2022) publient la “recipe” complète (SFT + RM + PPO) qui devient le standard de facto chez OpenAI, Anthropic, Meta. Cette recipe est chère : ~6 mois d’annotation, 3 modèles à entraîner en parallèle, infrastructure RL maison.

2023 : DPO redistribue les cartes — Rafailov et al. (NeurIPS 2023) montrent que la moitié de la stack peut être supprimée. Stanford, Allen AI, et la communauté open source (Tulu 2) démontrent rapidement que DPO atteint des performances proches de PPO pour 10x moins de complexité. Résultat : les labos avec budget moyen peuvent enfin entraîner des assistants compétitifs (Mistral, Yi, Qwen).

2024 : Deepseek change la perspective mémoire — Shao et al. publient le papier GRPO. La motivation est explicitement industrielle : entraîner des modèles math/code sans louer des clusters H100 à $10/h. La méthode permet de faire tenir l’entraînement RL d’un 7B sur 8x A100, ou d’un 1.5B sur 1x A100. C’est le moment où le RL post-training redevient accessible aux laboratoires académiques.

2025 : Deepseek-R1 et la disparition de l’annotateur — Deepseek-AI (janvier 2025) publie R1 et R1-Zero. R1-Zero est entraîné sans aucun SFT humain, uniquement GRPO + RLVR sur des prompts math/code. Le modèle développe spontanément des chains-of-thought longs, des comportements de re-vérification, des phases de “wait, let me reconsider”. C’est le moment où la communauté réalise que pour les domaines vérifiables, le post-training peut se passer d’annotation humaine. L’industrie commence à explorer le RLVR pour les agents (le succès étant vérifiable par exécution du plan), pour la traduction (BLEU/chrF comme reward), pour la génération SQL (test sur DB de validation).

Vers 2026 et au-delà — les directions actives à la date de cette série : (1) synthetic preferences (modèles juges au lieu d’annotateurs), (2) on-policy distillation (GRPO + distillation simultanée), (3) process reward models (PRM : récompenser les étapes intermédiaires, pas seulement le résultat final), (4) multi-turn RL (entraîner la cohérence sur plusieurs tours, pas tour par tour). La série ne couvre pas ces directions mais les notebooks de tête les référencent en “Pour aller plus loin”.

Compatibilité matérielle et choix d’implémentation

Le choix initial Qwen2.5-0.5B / 1.5B / Math-1.5B n’était pas anodin, et l’arbitrage vaut toujours pour le modèle de référence actuel (Qwen3.5-0.8B, migration #10289). Il résulte d’un arbitrage explicite entre :

Petite taille pour itération rapide : un GRPO sur 0.5B converge en ~30 min sur RTX 3070, ce qui rend les exercices réalisables en TP. Un même exercice sur 7B prendrait 6-8h et nécessiterait du gradient checkpointing agressif.
Qualité suffisante pour observer les effets : un modèle trop petit (< 0.5B) montre des effets de régularisation rendant l’observation des techniques bruitée. 0.5B-1.5B est la zone Goldilocks pour observer clairement les effets de SFT/DPO/GRPO.
Licence permissive Qwen : Apache 2.0, utilisable en cours sans friction.
Famille cohérente : même tokenizer, même architecture, ce qui permet de comparer techniques sans confondre effets de modèle et effets de méthode.
Variante Math-1.5B pour RLVR : Qwen propose une variante pré-entraînée sur math, ce qui évite de devoir partir de zéro pour observer un comportement RLVR concret.

Alternatives écartées et raisons : Llama-3.2-1B (gated, friction d’inscription HF), Phi-3-mini (architecture custom mal supportée par TRL au moment de la série), Gemma-2-2B (licence restrictive sur usage commercial, compliqué pour les apprenants en formation pro).

Pour les apprenants disposant de plus de VRAM (RTX 4090 24Go, A100 40Go), la série indique en encart les hyperparamètres à modifier pour scaler à Qwen2.5-7B sans changer la structure pédagogique.

Références académiques

Les références sont cliquables (arXiv / publisher). Les chiffres que la série cite d’articles externes sont toujours préfixés « rapporte par » ou « selon [source] » — jamais confondus avec nos mesures locales.

Référence	Lien	Couverture
Christiano et al., “Deep reinforcement learning from human preferences” (NeurIPS 2017)	arXiv:1706.03741	Origine RLHF
Stiennon et al., “Learning to summarize with human feedback” (NeurIPS 2020)	arXiv:2009.01325	RLHF appliquée aux LMs
Ouyang et al., “Training language models to follow instructions” (InstructGPT, NeurIPS 2022)	arXiv:2203.02155	SFT + RM + PPO canonique
Rafailov et al., “Direct Preference Optimization” (NeurIPS 2023)	arXiv:2305.18290	DPO origin
Shao et al., “DeepSeekMath: Pushing the Limits of Mathematical Reasoning” (2024)	arXiv:2402.03300	GRPO origin
Deepseek-AI, “Deepseek-R1: Incentivizing Reasoning Capability via RL” (2025)	rapport technique	RLVR + GRPO at scale
Lambert et al., “Tulu 3” (2024)	arXiv:2411.15124	Survey post-training methods
Hoffmann et al., “Chinchilla” (NeurIPS 2022)	arXiv:2203.15556	Scaling laws compute-optimal (référencé dans la narration coût/token)
Penedo et al., “FineWeb-Edu” (2024)	arXiv:2406.17557	Dataset de pré-entraînement éducatif (barème coût/token)
Liu / Su et al., “Moonlight / Muon” (2025)	arXiv:2502.16982	Optimizer Muon (vérifié firsthand) — note prospective architecture from-scratch
Liu et al., “Neural Thermodynamic Laws for Large Language Model Training” (2025) — R08	arXiv:2505.10559	Thermodynamique de l’entraînement : T ∼ η, équipartition, 1/t, force entropique (source de PT-14)
Zhai, “XSA: X-only Sparse Attention” (2026)	arXiv:2603.09078	Architecture XSA remplaçant DiffAttn (vérifié firsthand) — note prospective
Ye et al., “Differential Attention” (Microsoft, 2024)	arXiv:2410.05258	Attention différentielle (citée par la série Substack)
Ainslie et al., “GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints” (Google, 2023)	arXiv:2305.13245	Grouped-Query Attention (citée par la série Substack)

Éclairage externe — série Substack “modern-llm” (JohnEnev)

Première citation Substack du dépôt. La série de 4 posts (juillet→août 2026) + 1 bonus documente en open un from-scratch 350–672M paramètres avec post-training. Les chiffres externes sont toujours cités “selon JohnEnev Part N” — pas confondus avec nos mesures locales.

Post	Date	Lien	Couverture / leçon mobilisée
Part 1 — Building a 350M transformer from scratch	2026-07-03	johne.substack.com/p/modern-llm-part-1	V1 = 353M, 10B tok FineWeb-Edu, $101 — barème coût/token (29 tok/param, sous Chinchilla 20 ⇒ pré-entraînement sous-optimal assumé pour aller vite). Base model “qui parle anglais couramment mais ne suit pas les instructions” — doctrine SFT obligatoire (PT_02).
Part 2 — Modernizing the architecture	2026-07-08	johne.substack.com/p/modern-llm-part-2	V2 = 315M, GQA 4:1 + DiffAttn + QK-Norm + Muon retenu + EMA. mHC rejetée sur mesure throughput (−41% à 2 streams, −49% à 4, ~$93→$155→$175 sans gain de loss) — parallèle direct avec le trade-off critic/no-critic de PT_08 (coût ×4.0).
Part 3 — Post-training: SFT and GRPO	2026-07-21	johne.substack.com/p/modern-llm-part-3	Cœur du sujet. SFT OK, GRPO dégradant. V2 ppl 46.81 → 71.06 post-GRPO ; −4/6 accuracy. Modes d’échec : group no-signal (std=0 → avantage=0), easy stage unlearnable, KL 0.01–0.03 peu informatif. Verbatim canonique : “RL ne peut amplifier que ce que le modèle fait déjà parfois, pas créer ce qu’il ne fait jamais” — fonde notre narration GRPO fragile (PT_08, PT_11, PT_11b, rlpt_2, rlpt_4, ICT-25).
Part 4 — V3: Inference and serving models	2026-08-13	johne.substack.com/p/modern-llm-part-4	V3 = 672M, 30B tok, 2×B200 DDP, $315, 26.7h. ppl wikitext base 22.30 → SFT 32.11 → GRPO 33.65 (GRPO dégrade même SFT) ; GSM8K ~0. XSA remplace DiffAttn (<1% throughput vs 28%). FastAPI + SSE streaming. Convergence triple (V2 + V3 + notre PT_11b) sur “GRPO ne crée pas le signal qu’il prétend créer”.
Bonus — Distilling reasoning into a 14B model (NYT Connections)	2026-02-XX	johne.substack.com — voir bonus “NYT Connections” dans la série modern-llm	SFT-distillation de traces GPT-4o fait passer Qwen2.5-14B de 9.3% → 30.0% sur NYT Connections, vs GPT-4o 22.7% — sans RL. Coût rapporté ~$10 total / ~20 min/modèle sur A100 80GB. Mise en regard directe avec notre POC GRPO Qwen3.5-0.8B INCONCLUSIVE (PT_11) : le pattern “SFT > RL” traverse les échelles (0.8B ↔︎ 14B).

Citations académiques principales de la série Substack (vérifiées firsthand) :

XSA — Zhai 2026, arXiv:2603.09078 (vérifié 2026-08-20)
Muon / Moonlight — Liu / Su et al. 2025, arXiv:2502.16982 (vérifié 2026-08-20)
Differential Attention — Ye et al. 2024, arXiv:2410.05258
GQA — Ainslie et al. 2023, arXiv:2305.13245

Ces 4 entrées sont incluses dans le tableau principal ci-dessus avec liens cliquables.

Ressources en ligne

HuggingFace TRL documentation — librairie principale (SFT, DPO, GRPO trainers)
HuggingFace PEFT documentation — LoRA et adapters
Unsloth — optimisations mémoire pour RTX 3070 (optionnel)

Statut

Série complète : tous les notebooks sont exécutés avec outputs réels.

Suivi : Issue #1742.

FAQ

OOM CUDA pendant GRPO ou DPO

Les notebooks PT-03 à PT-05 sont conçus pour RTX 3070 (8 Go) avec Qwen3.5-0.8B QLoRA 4-bit (pic mesuré ~2,5 Go), mais OOM reste possible si l’environnement n’est pas optimal. Stratégies :

Vérifier que bitsandbytes est installé et que la quantization 4-bit est activée (load_in_4bit=True).
Réduire per_device_train_batch_size à 1 et augmenter gradient_accumulation_steps pour garder un batch effectif correct.
Le paramètre N (nombre de completions par prompt) dans GRPO est le principal consommateur VRAM : utiliser N=4 ou N=8 plutôt que N=16 sur GPU limité.
Fermer tous les autres processus GPU avant l’entraînement (nvidia-smi pour vérifier).

Si votre GPU à 4 Go ou moins, passer LOAD_MODEL_AND_TRAIN=False dans les notebooks pour exécuter en mode démo (chargement des outputs pré-calculés sans entraînement réel).

Quelle série faire en premier : FineTuning ou PostTraining ?

Les deux séries sont complémentaires :

FineTuning d’abord si vous voulez rapidement fine-tuner un modèle pour votre cas d’usage (LoRA, SFT pratique, DPO pratique). Approche “boîte à outils”.
PostTraining d’abord si vous voulez comprendre la théorie derrière les techniques avant de les appliquer. Approche “fondamentaux”.

Le parcours optimal est FineTuning (pratique) puis PostTraining (profondeur), mais l’inverse fonctionne aussi pour les profils théoriciens.

DPO vs GRPO : quand utiliser quoi ?

Critère	DPO	GRPO
Données requises	Paires de préférences (choisi/rejeté)	Prompts + fonction de reward
Reward Model	Non (implicitement éliminé)	Non (baseline intra-groupe)
Critic	Non	Non
VRAM	Plus faible (1 modèle)	Plus élevée (N completions en mémoire)
Tâches cibles	Préférences subjectives, style, ton	Math, code, tâches vérifiables
Stabilité	Bonne (BTL assumption)	Variable (sensible à N et à la reward)
Data annotation	Nécessaire (préférences humaines)	Optionnelle (reward vérifiable)

En pratique : DPO pour l’alignement conversationnel, GRPO+RLVR pour le raisonnement mathématique et code.

Les métriques d’évaluation ne s’améliorent pas après training

Si SFT, DPO ou GRPO ne produisent pas d’amélioration mesurable sur GSM8K ou MMLU :

Vérifier que le dataset d’évaluation est bien séparé du dataset d’entraînement (seed=42 pour le split, pas de fuite).
S’assurer que le nombre de steps d’entraînement est suffisant (minimum 100 steps pour observer un signal sur 0.5B).
Un seul seed ne suffit pas : les résultats sont bruités. Utiliser au minimum 4 seeds ({0, 1, 7, 42}) et vérifier que l’écart est >= 2 sigma (cf règle multi-seed CoursIA).
Le notebook PT-06 (PT_06_eval_comparative.ipynb) automatise cette comparaison avec verdict BEATS/NO BEATS/INCONCLUSIVE.

ImportError avec trl, peft ou bitsandbytes

L’environnement coursia-ml-training doit contenir les dépendances post-training :

conda activate coursia-ml-training
pip install --upgrade transformers trl peft accelerate datasets bitsandbytes

# Verifier
python -c "import trl; print(f'TRL {trl.__version__}')"
python -c "import bitsandbytes; print('bitsandbytes OK')"

Sur Windows, bitsandbytes peut nécessiter CUDA 12.x. Si erreur DLL not found, vérifier que CUDA_HOME pointe vers le bon toolkit et que bitsandbytes est à jour (>= 0.45).

Peut-on reproduire Deepseek-R1 avec cette serie ?

Non directement, mais les briques conceptuelles sont les mêmes. Deepseek-R1 utilise GRPO + RLVR sur des modèles 671B (architecture MoE) avec une infrastructure distribuée massive. Les notebooks GPU de la série (PT-04, PT-05) reproduisent ces mêmes techniques sur Qwen3.5-0.8B (QLoRA 4-bit) pour rendre les concepts accessibles sur GPU 8 Go. Les formules de loss, les mécanismes de reward, et les stratégies d’évaluation sont identiques — seule l’échelle change. PT-04 (GRPO) et PT-05 (RLVR) reproduisent fidèlement le pipeline Deepseek-R1 en miniature.

Licence

Voir la licence du dépôt principal.

Retour au sommet