AmeliorIA

tekio.org

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/gsm8k sont 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.py appelle commun/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.py confie le modèle, les prompts et les fonctions de récompense au GRPOTrainer de TRL, réglé pour DAPO (perte dapo, 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: true ajoute 0,2 quand la réponse se termine par Answer: N, utile sur l'arithmétique). Ce calcul se fait en Python, sans GPU. Avec SET="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.sh documente 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.