Exemple de code : RL en ligne
Ce que le dossier 05-rl-en-ligne/ fournit pour cette méthode. Principe et références : RL en ligne.
Ce que fait l'exemple
Le besoin : faire mieux raisonner un modèle sur des problèmes dont on sait vérifier la réponse (calcul, code testable, extraction contrôlable), sans solutions rédigées : seul le résultat attendu est connu.
Résultats (Qwen2.5-0.5B-Instruct, RTX 5070 Ti Laptop ; 1 319 problèmes de test de GSM8K, 200 problèmes de non-régression ; 100 pas, 1 h d'entraînement) :
| GSM8K | Non-régression (arithmétique) | |
|---|---|---|
| Avant | 0,411 [0,385 ; 0,438] | 0,955 [0,917 ; 0,976] |
| Après RL (DAPO) | 0,465 [0,438 ; 0,492] | 0,955 [0,917 ; 0,976] |
Écart apparié sur les mêmes problèmes : +0,054 [+0,026 ; +0,082], p de McNemar = 0,0002. Non-régression : 0,000 [−0,030 ; +0,030]. Récompense moyenne pendant l'entraînement : 0,37 au début, 0,54 à la fin.
Ce qu'on en retient.
- Le RL avec une récompense vérifiable fait progresser le modèle de 5 points, sans aucune solution rédigée et sans rien perdre ailleurs.
- Il fait mieux que les deux autres façons d'apprendre de la même tâche mesurées dans ce dépôt, sur le même modèle et les mêmes problèmes de test : la distillation d'un modèle 6 fois plus gros (SIGN06 : 0,451) et l'entraînement sur ses propres solutions justes (SIGN07 : 0,387). Le RL apprend aussi de ses échecs, que le rejection sampling écarte.
- Il reste modeste à ce budget : 800 problèmes vus une fois. Les papiers (DeepSeekMath, DAPO) entraînent des milliers de pas, avec vLLM pour la génération.
Variantes
Variante modèle de récompense : apprendre à noter les réponses
Le besoin : quand la qualité d'une réponse ne se vérifie pas par un programme (utilité, ton, respect d'une consigne), le RL a besoin d'un modèle qui la note. C'est la première étape du RLHF : on l'entraîne sur des paires « réponse préférée / réponse rejetée ».
variantes/modele-recompense ajoute une tête scalaire à Qwen2.5-0.5B-Instruct et l'entraîne avec la perte de Bradley-Terry : la note de la réponse préférée doit dépasser celle de la rejetée. Les 4 000 paires d'entraînement sont des problèmes d'arithmétique où la réponse préférée est juste et la rejetée fausse, une époque. La mesure porte sur 200 paires jamais vues : part des paires où le modèle note mieux la bonne réponse.
| Paires bien classées (200) | |
|---|---|
| Tête aléatoire | 0,485 [0,417 ; 0,554] |
| Après entraînement (87 s) | 0,98 [0,950 ; 0,992] |
Le modèle obtenu se branche comme récompense de l'exemple principal (--set recompense.source=modele --set recompense.modele=…, voir « Utilisation »), sert au best-of-N (EXEC20) ou classe des paires on-policy (DPO itératif). donnees.source=hf l'entraîne sur un jeu de préférences humaines (UltraFeedback, Skywork-Reward-Preference).
Réserve : distinguer une réponse juste d'une fausse est une tâche facile. Sur des préférences humaines, l'exactitude attendue est plus proche de 0,7 à 0,8, et un modèle de récompense se fait exploiter par la politique (réponses longues, flatterie) : il faut le surveiller pendant le RL.
Composants de l'exemple
flowchart TD
classDef externe fill:#fed7aa,stroke:#ea580c,color:#7c2d12
classDef code fill:#ffffff,stroke:#6b7280,color:#1f2937
classDef gpu fill:#fecaca,stroke:#dc2626,color:#7f1d1d
classDef disque fill:#dcfce7,stroke:#16a34a,color:#14532d
Hub["Hugging Face Hub<br/>Qwen2.5-0.5B-Instruct, GSM8K"]
Cache[("cache disque<br/>~/.cache/huggingface")]
subgraph Py["Processus Python"]
Run["run.py<br/>charge les questions<br/>et le modèle"]
TRL["TRL GRPOTrainer<br/>algorithme DAPO"]
Rec["recompenses.py<br/>exactitude, format"]
end
API["juge en option<br/>serveur d'API"]
GPU["GPU CUDA, 12 Go"]
Out[("sorties/05-rl-en-ligne/")]
Hub -- "① HTTPS GET, 1re fois<br/>poids (1 Go), GSM8K" --> Cache
Cache -- "② lecture des poids" --> Run
Run -- "③ copie des poids<br/>④ ⑤ ⑩ ⑪ mesures" --> GPU
Run -- "⑥ appel Python<br/>trainer.train()" --> TRL
TRL -- "⑧ appel Python<br/>notation" --> Rec
Rec -. "⑧ HTTP POST<br/>/v1/chat/completions" .-> API
TRL -- "⑦ ⑨ noyaux CUDA<br/>génération, entraînement" --> GPU
Run -- "⑫ ⑬ écriture" --> Out
class Hub,API externe
class Run,TRL,Rec code
class GPU gpu
class Cache,Out disque
make run EX=SIGN05 vérifie les prérequis (modules, GPU), puis lance run.py dans l'environnement .venv. Le script lit config.yaml (modèle, algorithme dapo, source de récompense regles, génération, données, réglages) et charge GSM8K : 800 problèmes de mathématiques rédigés pour l'entraînement, et les 1 319 problèmes de test. Seul le résultat attendu sert pendant le RL : le modèle n'est jamais entraîné sur une solution écrite.
- ① Téléchargement. Au premier lancement, les poids de Qwen2.5-0.5B-Instruct (environ 1 Go) et le jeu
openai/gsm8ksont téléchargés depuis le Hugging Face Hub, par HTTPS. - ② Lecture. Tout est rangé dans le cache
~/.cache/huggingface; les lancements suivants le relisent sur le disque, sans réseau. - ③ Copie sur le GPU. Les poids sont copiés en fp32 dans la mémoire du GPU (
dtype: float32), où ils restent jusqu'à la fin. - ④ Mesure avant.
run.pyappellecommun/evaluation.py, qui pose les 1 319 problèmes de test, puis 200 problèmes d'arithmétique de non-régression, par lots de 32. - ⑤ Génération sur le GPU. Pour chaque lot, le modèle raisonne token par token, jusqu'à 512 tokens, en décodage glouton. L'évaluation extrait ensuite le nombre final de chaque réponse et le compare au résultat attendu : c'est l'exactitude de départ.
- ⑥ Entraînement.
run.pyconfie le modèle, les prompts et les fonctions de récompense au GRPOTrainer de TRL, réglé pour DAPO (pertedapo,epsilon_high= 0,28,beta= 0, réponses tronquées ignorées). Rien n'est gelé : tous les poids du modèle sont entraînés. - ⑦ Génération sur le GPU. À chaque pas, le modèle lui-même produit 8 réponses par problème, par échantillonnage à température 1,0, jusqu'à 512 tokens chacune (environ 300 en moyenne).
- ⑧ Notation. TRL passe les réponses à
recompenses.py: 1 si le nombre final est juste, 0 sinon (bonus_format: trueajoute 0,2 quand la réponse se termine parAnswer: N, utile sur l'arithmétique). Ce calcul se fait en Python, sans GPU. AvecSET="recompense.source=juge recompense.api_base=http://localhost:11434/v1", la note vient d'un LLM juge interrogé par HTTP sur une API compatible OpenAI (flèche pointillée). - ⑨ Forward et backward sur le GPU. Chaque réponse reçoit un avantage : l'écart de sa récompense à la moyenne de son groupe de 8, divisé par l'écart type du groupe. Chaque pas traite 64 réponses, soit 8 problèmes (lots de 2, 32 accumulations) : passe avant pour les log-probabilités des tokens générés, perte DAPO, passe arrière, mise à jour de tous les poids par AdamW 8 bits. 100 pas, taux d'apprentissage 1e-6, gradient checkpointing actif.
- ⑩ Mesure après. Les mêmes problèmes sont posés au modèle entraîné.
- ⑪ Génération sur le GPU, avec le même décodage qu'en ⑤.
- ⑫ Écriture du modèle complet dans
sorties/05-rl-en-ligne/modele-dapo/. - ⑬ Écriture du rapport dans
sorties/05-rl-en-ligne/resultats.json, avec le même tableau affiché dans le terminal.
Ce que fait le GPU. Le processus Python ne calcule presque rien lui-même : PyTorch envoie au GPU des « noyaux CUDA », de petits programmes qui font les multiplications de matrices et l'attention sur les poids et les activations déjà présents dans sa mémoire. En génération (⑤, ⑦, ⑪), il y a une passe avant par token produit, accélérée par un cache des clés et des valeurs déjà calculées ; pendant l'entraînement, cette génération occupe l'essentiel du temps. En entraînement (⑨), chaque pas fait une passe avant, une passe arrière qui calcule les gradients de tous les poids, puis leur mise à jour par l'optimiseur AdamW 8 bits, dont l'état tient en 1 Go au lieu de 4. Avec beta = 0, aucun modèle de référence n'est chargé, et la récompense par règles ne demande aucun modèle : un seul modèle occupe la mémoire GPU. Les log-probabilités des réponses de 512 tokens sur un vocabulaire de 152 000 tokens imposent des lots de 2 réponses pour tenir en 12 Go.
Ce qui est écrit.
| Fichier | Contenu |
|---|---|
modele-dapo/model.safetensors |
Tous les poids du modèle entraîné (2,0 Go, en fp32) |
modele-dapo/config.json, generation_config.json |
Architecture et réglages de génération, pour recharger le modèle avec AutoModelForCausalLM.from_pretrained |
modele-dapo/tokenizer.json, tokenizer_config.json, chat_template.jinja |
Le tokenizer et le format de conversation, copiés pour que le dossier se suffise à lui-même |
modele-dapo/training_args.bin |
Les réglages d'entraînement utilisés |
resultats.json |
Exactitude avant et après sur GSM8K et sur la non-régression, avec intervalle à 95 % et réponse de chaque question ; comparaisons appariées ; récompense moyenne en début et en fin d'entraînement ; algorithme et source de récompense |
config_effective.yaml |
La configuration réellement utilisée, surcharges SET comprises |
Le dossier de sortie prend le nom de l'algorithme : avec SET="algo=grpo", il s'appelle modele-grpo/.
Essayer dans le dépôt
| Exemple | Statut | Résultat mesuré | Durée | Commande |
|---|---|---|---|---|
| exemple principal | démontré | GSM8K (n = 1 319) : 0,411 → 0,465 (p = 0,0002) ; non-régression 0,955 → 0,955 | test : 21 s complet : 1 h 05 |
make test EX=SIGN05 |
variante modele-recompense |
démontré | exactitude de préférence 0,485 → 0,98 | test : 13 s complet : 87 s |
make test EX=SIGN05 VAR=modele-recompense |
| non testé version grosse infra | jamais exécutée | 05-rl-en-ligne/infra/ |
Résultats et durées mesurés sur RTX 5070 Ti Laptop (12 Go, 11,5 Gio utilisables), 30 Go de RAM ; résultats de la configuration complète. make test lance un test rapide sur un petit modèle ; make run lance l'exemple complet ; make verifier contrôle d'abord les prérequis. Installation : Installer et lancer.
make install EXTRAS=1
make test EX=SIGN05
make run EX=SIGN05
Utilisation
python run.py --quick
python run.py # DAPO + récompense vérifiable, Qwen2.5-0.5B, GSM8K, ~1 h
python run.py --set algo=gspo
python run.py --set algo=rloo
python variantes/modele-recompense/run.py # 1) entraîner un modèle de récompense
python run.py --set recompense.source=modele \
--set recompense.modele=sorties/05-rl-en-ligne--variantes--modele-recompense/modele # 2) RLHF avec ce modèle
python run.py --set recompense.source=juge --set recompense.juge=Qwen/Qwen2.5-1.5B-Instruct # RLAIF, juge local
python run.py --set recompense.source=juge --set recompense.api_base=http://localhost:11434/v1 --set recompense.juge=qwen3:8b # juge servi par Ollama
python run.py --set peft.activer=true --set entrainement.lr=1e-5 --set modele.nom=Qwen/Qwen2.5-1.5B-Instruct
Paramètres principaux
| Clé | Rôle |
|---|---|
algo, beta |
Variante et pénalité KL (0 = pas de modèle de référence en mémoire) |
recompense.* |
Source de la récompense |
generation.num_generations |
Taille du groupe (4 à 16 en local, 16 à 64 à grande échelle) |
generation.max_completion_length |
Longueur de raisonnement autorisée |
generation.vllm |
Génération rapide (indispensable au-delà de quelques centaines de pas) |
recompense.bonus_format |
Bonus de format Answer: N (tâche d'arithmétique) |
entrainement.batch, accumulation |
Lot × accumulation multiple de num_generations |
evaluation.non_regression |
Tâche hors sujet mesurée avant et après |
Grosse infra
- En local : faisable jusqu'à ~1,5B, mais la génération avec transformers est lente. C'est vLLM qui rend le RL praticable.
infra/config.yaml: DAPO sur Qwen2.5-7B, 16 réponses par prompt jusqu'à 4k tokens, vLLM colocalisé, ZeRO-3, 1 nœud 8×H100.infra/lancer.shdocumente trois montages :- A : TRL + vLLM colocalisé ;
- B : TRL + serveur vLLM dédié (
trl vllm-serve) pour les modèles de 32B et plus ; - C : verl ou OpenRLHF (Ray, multi-nœuds, PPO avec critique, 70B+). Exemple de commande verl fourni.
- Ordres de grandeur : RLVR 7B sur maths, ~1 000 pas en 1 à 3 jours sur 8×H100. DeepSeek-R1 et Qwen3 : des milliers de GPU.