Exemple de code : Optimisation des préférences
Pas encore démontré. Aucun des 2 exemples de code de cette méthode ne démontre encore son gain : ils s'exécutent, mais leur résultat ne le prouve pas. La version grosse infra n'a jamais été exécutée. La raison figure dans le tableau « Essayer dans le dépôt » ; les pistes pour y arriver : Travail en cours.
Ce que le dossier 04-optimisation-preferences/ fournit pour cette méthode. Principe et références : Optimisation des préférences.
Ce que fait l'exemple
Le besoin : rendre les réponses d'un assistant plus utiles sur des demandes variées, à partir de jugements « cette réponse est meilleure que celle-ci », sans réécrire les réponses soi-même.
Résultats (Qwen2.5-0.5B-Instruct, RTX 5070 Ti Laptop ; 500 demandes de test ; graine 42 sauf mention). Le juge est un modèle de récompense externe, qui n'a vu ni le modèle entraîné ni ses réponses :
| Victoires contre le départ | Note moyenne du juge | Mots par réponse | Non-régression (arithmétique) | Entraînement | |
|---|---|---|---|---|---|
| Qwen2.5-0.5B-Instruct, départ | −0,07 | 193 | 0,955 | ||
| DPO, 16 000 paires | 0,552 [0,508 ; 0,595] | +0,33 | 203 | 0,975 | 65 min, 6,2 Gio |
| Témoin SFT sur les réponses préférées | 0,380 [0,339 ; 0,423] | −1,08 | 178 | 0,860 | 34 min, 3,0 Gio |
| DPO, 4 000 paires, taux 2e-5 | 0,506 [0,462 ; 0,550] | +0,12 | 203 | 0,955 | 16 min |
| DPO, 16 000 paires, graines 42, 43, 44 | 0,533 ± 0,032 (0,552 ; 0,496 ; 0,550) | +0,27 ± 0,16 | 205 | 0,963 |
- Le DPO gagne, de peu et pas à chaque fois. Sur la graine 42, le juge préfère sa réponse à celle du modèle de départ dans 55 % des cas ; la note moyenne monte de +0,40 (p = 0,005, permutation appariée). Sur trois graines, le gain est net deux fois (0,552 et 0,550) et nul une fois (0,496 [0,452 ; 0,540]). Les réponses ne s'allongent que de 5 % : le gain ne vient pas d'abord de la longueur, à laquelle les juges sont sensibles.
- Imiter les réponses préférées dégrade le modèle, alors qu'apprendre la préférence l'améliore : le DPO bat le témoin SFT dans 67 % des cas. Les réponses d'UltraFeedback viennent de modèles plus forts ; un modèle de 0,5B les imite mal et perd une partie de ce qu'il savait (non-régression 0,955 → 0,860).
- Il faut assez de paires. Avec 4 000 paires et un taux plus faible, pas de gain mesurable.
- Non démontré. Le gain dépend de la graine. Qwen2.5-Instruct a déjà été aligné sur des préférences par ses auteurs : la marge restante est faible. Le juge peut partager des biais avec les annotations d'UltraFeedback.
Variantes
Variante DPO itératif : le modèle fabrique ses propres paires
variantes/dpo-iteratif part du même modèle et des mêmes demandes de test, mais n'utilise aucune réponse d'UltraFeedback. À chaque tour :
- le modèle répond 4 fois (température 0,8) à 500 demandes neuves du split d'entraînement ;
- un petit modèle de récompense, Skywork-Reward-V2-Qwen3-0.6B, note les 4 réponses : la mieux notée devient la réponse préférée, la moins bien notée la réponse rejetée ;
- un tour de DPO LoRA (2 époques) est fusionné dans le modèle, qui devient le point de départ et la référence du tour suivant.
La mesure reste celle de l'exemple principal : le juge Skywork-Reward-V2-Qwen3-1.7B, qui n'a pas servi à fabriquer les paires, compare les réponses gloutonnes aux 500 demandes de test.
| Victoires contre le départ | Note moyenne du juge | Mots par réponse | Non-régression (arithmétique) | |
|---|---|---|---|---|
| Départ | −0,07 | 193 | 0,955 | |
| Tour 1 (489 paires) | 0,532 [0,488 ; 0,575] | +0,54 | 176 | 0,965 |
| Tour 2 (494 paires) | 0,602 [0,558 ; 0,644] | +1,03 | 177 | 0,970 |
| Tour 3 (494 paires) | 0,616 [0,573 ; 0,658] | +0,92 | 184 | 0,935 |
Chaque tour dure environ 30 minutes, dont 3 min 30 d'entraînement (6,2 Gio de mémoire). L'écart de note avec le départ est de +0,98 après 3 tours (p < 0,001, permutation appariée).
- Moins de 1 500 paires produites par le modèle valent mieux que 16 000 paires figées : 0,616 contre 0,552. Les paires restent dans la distribution du modèle, et chaque tour repart du modèle amélioré.
- Le gain ne vient pas de la longueur : les réponses raccourcissent un peu (193 → 184 mots).
- Réserves. Une graine pour l'instant. Les deux modèles de récompense sont de la même famille et peuvent partager des biais : le gain mesuré est en partie un gain aux yeux de ce juge. Le tour 3 n'améliore plus la note moyenne : deux ou trois tours suffisent ici.
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, UltraFeedback<br/>Skywork-Reward-V2 (juge)"]
Cache[("cache disque<br/>~/.cache/huggingface")]
subgraph Py["Processus Python"]
Run["run.py<br/>phases avant, DPO,<br/>témoin, notation"]
Pref["preferences.py<br/>génération, juge"]
TRL["TRL DPOTrainer<br/>LoRA r = 16"]
end
GPU["GPU CUDA, 12 Go"]
Out[("sorties/04-optimi-<br/>sation-preferences/")]
Hub -- "① HTTPS GET, 1re fois<br/>poids et paires" --> Cache
Cache -- "② lecture" --> Run
Run -- "③ copie des poids<br/>en mémoire GPU" --> GPU
Run -- "④ ⑦ ⑨ appel Python<br/>réponses aux 500 demandes" --> Pref
Pref -- "⑤ ⑧ ⑩ ⑪ noyaux CUDA<br/>génération, notation" --> GPU
Run -- "⑥ appel Python<br/>trainer.train()" --> TRL
TRL -- "⑥ noyaux CUDA<br/>forward, backward" --> GPU
Run -- "⑫ écriture<br/>adaptateur, réponses,<br/>resultats.json" --> Out
GPU ~~~ Out
class Hub externe
class Run,Pref,TRL code
class GPU gpu
class Cache,Out disque
make run EX=SIGN04 vérifie les prérequis (modules, GPU), puis lance run.py dans l'environnement .venv. Le script lit config.yaml (modèle, algorithme dpo, beta, LoRA, données, juge, témoin). Les paires viennent d'UltraFeedback binarisé (trl-lib/ultrafeedback_binarized) : des demandes variées (rédaction, code, conseils, raisonnement), chacune avec la réponse la mieux notée et une moins bien notée parmi celles de 17 modèles. 16 000 paires du split train servent à l'entraînement ; le split test fournit 300 paires pour mesurer les préférences et 500 demandes (de 2 000 caractères au plus) pour mesurer les réponses.
- ① Téléchargement. Au premier lancement : les poids de Qwen2.5-0.5B-Instruct (environ 1 Go), UltraFeedback (environ 250 Mo) et le juge Skywork-Reward-V2-Qwen3-1.7B (3,4 Go), depuis le Hugging Face Hub, par HTTPS.
- ② Lecture. Tout est rangé dans le cache
~/.cache/huggingface; les lancements suivants le relisent sans réseau. - ③ Copie sur le GPU. Les poids du modèle sont copiés en fp32 dans la mémoire du GPU.
- ④ Phase « avant ».
run.pymesure, sur le modèle de départ : la part des 300 paires de test où il donne une log-probabilité moyenne plus haute à la réponse préférée ; l'exactitude sur 200 problèmes d'arithmétique (non-régression : une tâche qu'il réussit et qui ne doit pas se dégrader) ; ses réponses aux 500 demandes de test. - ⑤ Génération sur le GPU. Décodage glouton, jusqu'à 512 tokens par réponse, par lots de 32 : la même demande donne toujours la même réponse.
- ⑥ Entraînement DPO.
preferences.pyconstruit le DPOTrainer de TRL (pertesigmoid,beta= 0,1) avec LoRA de rang 16 sur toutes les couches linéaires. Chaque pas traite 16 paires (lots de 1, accumulation sur 16), tronquées à 1 024 tokens : passe avant sur la réponse préférée et la rejetée avec l'adaptateur, puis sans lui (le modèle de référence), perte DPO, passe arrière, mise à jour des seules matrices LoRA. Une époque, 1 000 pas, taux d'apprentissage 5e-5. - ⑦ Phase « après ». Mêmes mesures qu'en ④ sur le modèle entraîné, puis écriture de l'adaptateur.
- ⑧ Génération sur le GPU, comme en ⑤.
- ⑨ Témoin SFT. Le modèle de départ est rechargé et entraîné en SFT, avec la même LoRA, sur la seule réponse préférée de chacune des mêmes paires (taux d'apprentissage 1e-4, celui d'un SFT LoRA). Il sépare deux effets : apprendre ce qui rend une réponse meilleure qu'une autre, ou imiter des réponses écrites par des modèles plus forts.
- ⑩ Génération sur le GPU, comme en ⑤, puis mêmes mesures qu'en ④.
- ⑪ Notation par le juge. Le modèle entraîné quitte le GPU ; le juge Skywork-Reward-V2 (modèle de récompense de 1,7 milliard de paramètres, en bf16) note chaque couple (demande, réponse) des trois jeux de réponses. Le taux de victoire est la part des demandes où la réponse du modèle entraîné a une meilleure note que celle du modèle de départ : 0,5 veut dire aussi bien.
- ⑫ Écriture des 500 demandes avec les trois réponses et leurs notes dans
reponses.json, et du rapport dansresultats.json, avec le même tableau 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. DPO a besoin des log-probabilités d'un modèle de référence figé : avec LoRA, c'est le même modèle, adaptateur désactivé, donc aucune seconde copie des poids n'occupe la mémoire. Pic mesuré pendant le DPO : 6,2 Gio ; pendant le témoin SFT : 3,0 Gio. Chaque phase terminée est gardée dans reprise/ : un calcul interrompu et relancé repart de la phase suivante, et l'entraînement en cours reprend de son dernier point de contrôle (commun/reprise.py).
Ce qui est écrit.
| Fichier | Contenu |
|---|---|
modele-dpo/adapter_model.safetensors, adapter_config.json |
Les matrices LoRA entraînées (35 Mo, en fp32) et leur configuration, pour recharger l'adaptateur avec PeftModel.from_pretrained sur le modèle de base du Hub |
modele-dpo/tokenizer.json, tokenizer_config.json, chat_template.jinja |
Le tokenizer et le format de conversation |
temoin-sft/ |
Dossier de travail du Trainer pour le témoin, sans point de contrôle |
reponses.json |
Les 500 demandes de test, avec la réponse et la note de chaque modèle : de quoi relire ce que le juge préfère |
resultats.json |
Pour avant, après et le témoin : préférences, non-régression, note moyenne, mots par réponse, durée et mémoire d'entraînement ; taux de victoire avec intervalle à 95 % ; écart de note apparié |
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=kto", il s'appelle modele-kto/. Avec SET="peft.activer=false", il contient le modèle complet au lieu de l'adaptateur.
Essayer dans le dépôt
| Exemple | Statut | Résultat mesuré | Durée | Commande |
|---|---|---|---|---|
| exemple principal | non prouvé | victoires contre le départ 0,533 ± 0,032 sur 3 graines (0,552 ; 0,496 ; 0,550) ; témoin SFT 0,380 ; non-régression 0,955 → 0,963 — gain net sur 2 graines sur 3 ; faible sur un modèle déjà aligné par ses auteurs | test : 1 min complet : 2 h |
make test EX=SIGN04 |
variante dpo-iteratif |
non prouvé | victoires contre le départ 0,532 → 0,602 → 0,616 [0,573 ; 0,658] au fil des tours ; non-régression 0,955 → 0,935 (n.s.) — une graine ; juges de la même famille | test : — complet : 1 h 40 |
make test EX=SIGN04 VAR=dpo-iteratif |
| non testé version grosse infra | jamais exécutée | 04-optimisation-preferences/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=SIGN04
make run EX=SIGN04
Utilisation
python run.py --quick
python run.py # DPO LoRA Qwen2.5-0.5B-Instruct sur 16 000 paires UltraFeedback, ~2 h avec le témoin
python run.py --set temoin_sft.activer=false # sans le témoin SFT, ~1 h 20
python run.py --set algo=ipo --set beta=0.01
python run.py --set algo=simpo --set beta=2.0
python run.py --set algo=kto
python run.py --set donnees.source=arith --set evaluation.n_paires=100 # paires arithmétiques générées (calcul juste contre erreur)
for a in dpo ipo rdpo slic apo_zero nca bco sppo orpo simpo cpo kto; do python run.py --quick --set algo=$a; done
python variantes/dpo-iteratif/run.py --quick
python variantes/dpo-iteratif/run.py # 3 tours on-policy sur des demandes UltraFeedback, ~1 h 40
Paramètres principaux
| Clé | Rôle |
|---|---|
algo |
Voir le tableau |
beta |
Écart autorisé par rapport à la référence. Plus petit = le modèle s'éloigne davantage |
entrainement.lr |
LoRA : 5e-6 à 5e-5. Très faible en complet (5e-7) : un lr de SFT détruit le modèle |
juge.nom |
Modèle de récompense externe qui note les réponses aux demandes de test |
temoin_sft |
SFT sur les seules réponses préférées des mêmes paires, pour comparaison |
peft.activer |
LoRA : la référence est la base sans adaptateur, ce qui évite de charger une deuxième copie |
Grosse infra
infra/config.yaml: recette Tülu 3 (DPO normalisé en longueur, β=5, mélange de 272k préférences) sur Llama-3.1-8B-SFT, DeepSpeed ZeRO-3 sur 8×H100. Pour 70B : 2 à 4 nœuds via Slurm.precompute_ref_log_probs: true(dansentrainement.autres) : les log-probs de la référence sont calculées une fois, puis la référence est déchargée.- Frameworks : open-instruct, OpenRLHF, LLaMA-Factory.
- Préférences on-policy à grande échelle : générer avec vLLM (n=8 à 16 par prompt), noter avec un modèle de récompense (Skywork-Reward) ou un LLM juge, puis DPO.