> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/entrainement/trl.md). # TRL (entraînement RLHF/DPO) **TRL** (Transformer Reinforcement Learning) est la bibliothèque officielle de Hugging Face pour entraîner des modèles de langage avec des techniques d'apprentissage par renforcement. Avec plus de 10 000 étoiles sur GitHub, elle fournit des implémentations de pointe de RLHF, DPO, PPO, GRPO et d'autres algorithmes d'alignement pour les LLM. {% hint style="success" %} Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace). {% endhint %} *** ## Qu'est-ce que TRL ? TRL est la bibliothèque derrière de nombreux modèles de langage parmi les mieux alignés d'aujourd'hui. Elle fournit : * **SFT (ajustement fin supervisé)** — ajustement standard des instructions avec le format ChatML * **RLHF/PPO** — optimisation classique par politique proximale avec un modèle de récompense * **DPO** — optimisation directe des préférences (aucun modèle de récompense nécessaire !) * **GRPO** — optimisation de politique relative en groupe (méthode de DeepSeek-R1) * **KTO** — optimisation de Kahneman-Tversky (fonctionne avec des préférences non appariées) * **Modélisation de récompense** — entraîner un modèle de récompense à partir de données de préférences humaines * **IterativeSFT** — apprentissage par renforcement en ligne avec une configuration plus simple * **ORPO** — optimisation des préférences par rapport de cotes TRL s'intègre nativement à l'écosystème Hugging Face : `transformers`, `peft`, `datasets`, `accelerate`, et `bitsandbytes`. {% hint style="info" %} **Quel algorithme devriez-vous utiliser ?** * **DPO** — le plus simple, le plus stable. À utiliser lorsque vous disposez de données de préférences appariées (choisi/rejeté). * **PPO** — le plus puissant mais complexe. À utiliser lorsque vous disposez d'un modèle de récompense ou d'une fonction de score. * **GRPO** — excellent pour les tâches de raisonnement/de mathématiques. Méthode d'entraînement de DeepSeek-R1. * **SFT** — commencez toujours ici avant d'appliquer toute méthode d'apprentissage par renforcement. {% endhint %} *** ## Exigences du serveur | Composant | Minimum | Recommandé | | ---------------------- | ------------------------- | --------------------------- | | GPU | RTX 3090 (24 Go) | A100 80 Go / H100 | | VRAM | 16 Go (SFT/DPO 7B + LoRA) | 80 Go (affinage complet 7B) | | RAM | 32 Go | 64 Go+ | | CPU | 8 cœurs | 16 cœurs et plus | | Stockage | 100 Go | 300 Go+ | | Système d'exploitation | Ubuntu 20.04+ | Ubuntu 22.04 | | Python | 3.9+ | 3.11 | | CUDA | 12.8+ | 12.8+ | ### VRAM par tâche | Tâche | Modèle | Méthode | VRAM | | ----- | ----------- | ------------ | ---------------- | | SFT | Llama 3 8B | QLoRA 4 bits | \~8 GB | | DPO | Llama 3 8B | LoRA | \~20 Go | | PPO | Llama 3 8B | Complet | \~80 Go (2×A100) | | GRPO | Qwen 7B | LoRA | \~24 Go | | SFT | Llama 3 70B | QLoRA 4 bits | \~48 Go | | DPO | Llama 3 70B | LoRA | \~80 Go | *** ## Ports | Port | Service | Remarques | | ---- | ------- | ------------------------------------------------------ | | 22 | SSH | Accès au terminal, transfert de fichiers, surveillance | TRL est une bibliothèque d'entraînement — elle s'exécute comme un script CLI/Python, aucun serveur web requis. *** ## Installation sur Clore.ai ### Étape 1 — Louer un serveur 1. Accédez à [Marketplace Clore.ai](https://clore.ai/marketplace) 2. Filtrer pour **VRAM ≥ 24 Go** (RTX 3090, A100 ou H100) 3. Choisissez un **PyTorch** ou **CUDA 12.8** image de base 4. Sélectionnez **Stockage ≥ 200 Go** pour les modèles et les ensembles de données 5. Ouvrez le port **22** pour l'accès SSH ### Étape 2 — Se connecter via SSH ```bash ssh root@ -p ``` ### Étape 3 — Installer TRL ```bash # Créer un environnement virtuel Python python3 -m venv /opt/trl source /opt/trl/bin/activate # Installer TRL avec toutes les dépendances pip install trl # Installer des dépendances supplémentaires pour les workflows complets pip install \\ transformers \\ datasets \\ peft \\ accelerate \\ bitsandbytes \\ wandb \\ scipy \\ sentencepiece \\ protobuf # Vérifier la prise en charge du GPU python3 -c "import torch; print(f'CUDA: {torch.cuda.is_available()}, GPU: {torch.cuda.get_device_name(0)}')" ``` ### Étape 4 — Authentification Hugging Face ```bash # Se connecter pour accéder aux modèles protégés (Llama, Gemma) huggingface-cli login # Entrez votre jeton HF depuis https://huggingface.co/settings/tokens # Ou définissez une variable d'environnement export HF_TOKEN=hf_your-token-here ``` ### Étape 5 — Facultatif : suivi Weights & Biases ```bash # Mettre en place le suivi des expériences (fortement recommandé) pip install wandb wandb login # Entrez votre clé API W&B depuis https://wandb.ai/settings # Ou désactiver W&B export WANDB_DISABLED=true ``` *** ## Fine-tuning supervisé (SFT) Le SFT est toujours la première étape avant toute technique de RL. ### Préparez votre ensemble de données ```python # Format : bibliothèque datasets avec une colonne 'messages' ou 'text' # Format ChatML (recommandé) from datasets import Dataset data = [ { "messages": [ {"role": "system", "content": "Vous êtes un assistant cloud GPU utile."}, {"role": "user", "content": "Comment puis-je louer un GPU sur Clore.ai ?"}, {"role": "assistant", "content": "Visitez clore.ai/marketplace, filtrez par spécifications GPU, sélectionnez un serveur et cliquez sur Louer. L'accès SSH est fourni immédiatement après le paiement."} ] }, # ... plus d'exemples ] dataset = Dataset.from_list(data) dataset.save_to_disk("data/sft_dataset") dataset.push_to_hub("your-username/my-sft-dataset") # facultatif ``` ### Script d'entraînement SFT ```python # sft_train.py from trl import SFTTrainer, SFTConfig from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig from peft import LoraConfig, get_peft_model from datasets import load_dataset import torch # Configuration du modèle model_name = "meta-llama/Llama-3.2-8B-Instruct" # QLoRA : configuration de quantification 4 bits bnb_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.bfloat16, bnb_4bit_use_double_quant=True, ) # Charger le modèle model = AutoModelForCausalLM.from_pretrained( model_name, quantization_config=bnb_config, device_map="auto", trust_remote_code=True, ) # Charger le tokenizer tokenizer = AutoTokenizer.from_pretrained(model_name) tokenizer.pad_token = tokenizer.eos_token tokenizer.padding_side = "right" # Configuration LoRA lora_config = LoraConfig( r=16, lora_alpha=32, target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"], lora_dropout=0.05, bias="none", task_type="CAUSAL_LM", ) # Charger l'ensemble de données dataset = load_dataset("trl-lib/ultrachat_200k", split="train_sft[:10%]") # Configuration de l'entraînement training_config = SFTConfig( output_dir="./sft_output", num_train_epochs=3, per_device_train_batch_size=2, gradient_accumulation_steps=4, learning_rate=2e-4, warmup_ratio=0.05, lr_scheduler_type="cosine", fp16=False, bf16=True, max_seq_length=2048, dataset_text_field="messages", logging_steps=10, save_steps=100, save_total_limit=3, push_to_hub=False, report_to="wandb", # ou "none" ) # Initialiser le formateur trainer = SFTTrainer( model=model, args=training_config, train_dataset=dataset, peft_config=lora_config, tokenizer=tokenizer, ) # Entraîner trainer.train() trainer.save_model("./sft_final") ``` ```bash # Lancer l'entraînement python3 sft_train.py ``` *** ## DPO (optimisation directe des préférences) DPO est la méthode d'alignement la plus populaire — aucun modèle de récompense n'est nécessaire, seulement des paires de préférences. ### Préparer l'ensemble de données DPO ```python # Format : chaque exemple a 'prompt', 'chosen', 'rejected' from datasets import Dataset data = [ { "prompt": "Expliquez comment optimiser l'utilisation du GPU", "chosen": "Pour optimiser l'utilisation du GPU : 1) utilisez des tailles de lot plus grandes pour maximiser l'occupation, 2) activez la précision mixte (bf16/fp16), 3) profilez avec nvidia-smi pour identifier les goulets d'étranglement, 4) utilisez des flux CUDA pour les opérations parallèles.", "rejected": "Utilisez simplement plus de GPU." }, # ... plus de paires de préférences ] dataset = Dataset.from_list(data) ``` ### Script d'entraînement DPO ```python # dpo_train.py from trl import DPOTrainer, DPOConfig from transformers import AutoTokenizer, AutoModelForCausalLM from datasets import load_dataset import torch model_name = "./sft_final" # Commencez à partir de votre modèle SFT ! # Charger le modèle SFT (la politique à aligner) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.bfloat16, device_map="auto", ) # Modèle de référence (copie figée du modèle SFT) ref_model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.bfloat16, device_map="auto", ) tokenizer = AutoTokenizer.from_pretrained(model_name) tokenizer.pad_token = tokenizer.eos_token # Charger l'ensemble de données de préférences dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train[:5%]") # Configuration DPO dpo_config = DPOConfig( output_dir="./dpo_output", num_train_epochs=1, per_device_train_batch_size=2, gradient_accumulation_steps=4, learning_rate=5e-7, # Beaucoup plus faible que SFT beta=0.1, # Coefficient de pénalité KL loss_type="sigmoid", # Perte DPO standard max_length=2048, max_prompt_length=512, bf16=True, logging_steps=10, save_steps=50, report_to="wandb", ) trainer = DPOTrainer( model=model, ref_model=ref_model, args=dpo_config, train_dataset=dataset, tokenizer=tokenizer, ) trainer.train() trainer.save_model("./dpo_final") ``` *** ## PPO (optimisation par politique proximale) PPO est l'approche RLHF classique — à utiliser lorsque vous disposez d'un signal de récompense : ```python # ppo_train.py from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead from transformers import AutoTokenizer, pipeline from datasets import load_dataset import torch model_name = "./sft_final" # Modèle de politique (avec tête de valeur pour PPO) model = AutoModelForCausalLMWithValueHead.from_pretrained( model_name, torch_dtype=torch.bfloat16, ) tokenizer = AutoTokenizer.from_pretrained(model_name) tokenizer.pad_token = tokenizer.eos_token # Modèle de récompense (peut être n'importe quelle fonction de score) sentiment_pipe = pipeline( "sentiment-analysis", model="distilbert/distilbert-base-uncased-finetuned-sst-2-english", device=0, ) def reward_fn(texts): """Noter chaque réponse. Retourner une liste de tenseurs de récompense.""" results = sentiment_pipe(texts) rewards = [] for result in results: score = result["score"] if result["label"] == "POSITIVE" else -result["score"] rewards.append(torch.tensor(score)) return rewards ppo_config = PPOConfig( output_dir="./ppo_output", learning_rate=1.41e-5, mini_batch_size=1, batch_size=4, gradient_accumulation_steps=4, kl_penalty="kl", target_kl=6.0, cliprange=0.2, vf_coef=0.1, ) trainer = PPOTrainer( config=ppo_config, model=model, ref_model=None, # Copie automatiquement le modèle initial comme référence tokenizer=tokenizer, ) # Boucle d'entraînement dataset = load_dataset("imdb", split="train[:1000]") for epoch in range(3): for batch in trainer.dataloader: queries = batch["input_ids"] # Générer des réponses responses = trainer.generate(queries, max_new_tokens=100) # Noter les réponses texts = tokenizer.batch_decode(responses, skip_special_tokens=True) rewards = reward_fn(texts) # Mise à jour PPO stats = trainer.step(queries, responses, rewards) trainer.log_stats(stats, batch, rewards) ``` *** ## GRPO (optimisation de politique relative en groupe) GRPO est utilisé dans DeepSeek-R1 pour l'entraînement au raisonnement : ```python # grpo_train.py from trl import GRPOTrainer, GRPOConfig from transformers import AutoTokenizer, AutoModelForCausalLM from datasets import Dataset import re, torch model_name = "Qwen/Qwen2.5-7B-Instruct" model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.bfloat16, device_map="auto", ) tokenizer = AutoTokenizer.from_pretrained(model_name) # Ensemble de données de mathématiques def make_math_dataset(): examples = [ {"prompt": "Combien font 2+2 ?", "answer": "4"}, {"prompt": "Combien font 15 * 7 ?", "answer": "105"}, # ... plus de problèmes de mathématiques ] return Dataset.from_list(examples) dataset = make_math_dataset() def correctness_reward(completions, answer, **kwargs): """Récompenser 1.0 si la réponse est correcte, 0.0 sinon.""" rewards = [] for completion in completions: # Extraire le dernier nombre de la complétion numbers = re.findall(r'\d+', completion[-1]["content"]) if numbers and numbers[-1] == answer: rewards.append(1.0) else: rewards.append(0.0) return rewards grpo_config = GRPOConfig( output_dir="./grpo_output", num_train_epochs=3, per_device_train_batch_size=4, num_generations=8, # GRPO génère G réponses par invite learning_rate=5e-7, bf16=True, logging_steps=10, ) trainer = GRPOTrainer( model=model, args=grpo_config, train_dataset=dataset, reward_funcs=correctness_reward, tokenizer=tokenizer, ) trainer.train() ``` *** ## Entraînement multi-GPU Utilisez `accelerate` pour l'entraînement distribué : ```bash # Configurer accelerate pour le multi-GPU accelerate config # Exemple de configuration pour 4 GPU : # - compute_environment: LOCAL_MACHINE # - distributed_type: MULTI_GPU # - num_processes: 4 # - mixed_precision: bf16 # Lancer l'entraînement sur tous les GPU accelerate launch sft_train.py accelerate launch dpo_train.py # Ou spécifiez explicitement les GPU CUDA_VISIBLE_DEVICES=0,1,2,3 accelerate launch \\ --num_processes 4 \\ --mixed_precision bf16 \\ sft_train.py ``` *** ## Utilisation de l'interface CLI TRL TRL fournit des commandes CLI pratiques : ```bash # SFT via CLI trl sft \ --model_name_or_path meta-llama/Llama-3.2-8B-Instruct \ --dataset_name trl-lib/ultrachat_200k \ --dataset_text_field messages \ --output_dir ./cli_sft_output \ --num_train_epochs 3 \ --per_device_train_batch_size 2 \ --gradient_accumulation_steps 4 \ --learning_rate 2e-4 \ --bf16 \ --use_peft \ --lora_r 16 \ --lora_alpha 32 # DPO via CLI trl dpo \ --model_name_or_path ./cli_sft_output \ --dataset_name trl-lib/ultrafeedback_binarized \ --output_dir ./cli_dpo_output \ --num_train_epochs 1 \ --beta 0.1 \ --bf16 ``` *** ## Surveillance de l'entraînement ```bash # Surveillez l'utilisation du GPU watch -n 1 nvidia-smi # Surveillez la perte d'entraînement (si vous utilisez W&B) # Ouvrez https://wandb.ai/your-username dans le navigateur # Vérifiez le répertoire de sortie pour les checkpoints ls -lh sft_output/checkpoint-*/ # Reprendre à partir d'un checkpoint python3 sft_train.py --resume_from_checkpoint sft_output/checkpoint-500/ ``` *** ## Recommandations GPU Clore.ai {% hint style="warning" %} **Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai.** Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez [bare metal](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement. {% endhint %} L'entraînement TRL est l'une des charges de travail les plus gourmandes en VRAM. Choisissez votre GPU en fonction de la taille du modèle et de la méthode : | Tâche | GPU | Remarques | | --------------------------------------------------------- | ------------------ | ----------------------------------------------------------------------------------------------------------------- | | SFT / DPO sur 7–8B (QLoRA) | **RTX 3090** 24 Go | \~8 Go pour QLoRA 4 bits ; tient confortablement ; 0,07–0,21 $/h sur Clore.ai | | SFT / DPO sur 7–8B (LoRA bf16) | **RTX 4090** 24 Go | Même VRAM que la 3090, mais calcul 30 % plus rapide ; excellent pour la vitesse d'itération | | SFT complet sur 7B ou DPO sur 13B | **A100 40 Go** | 40 Go suffisent pour un entraînement en précision complète sur 7B ; la mémoire ECC évite les erreurs silencieuses | | PPO / fine-tuning complet 7B, ou n'importe quel QLoRA 70B | **A100 80 Go** | PPO nécessite 2× modèle policy+ref en VRAM ; 80 Go exécutent les deux sans OOM | **Conseil pratique :** Commencez sur une RTX 3090 avec QLoRA pour expérimenter — entraînez Llama 3 8B en \~2 h sur 10 000 exemples. Une fois le pipeline validé, passez à une A100 80 Go pour des exécutions en précision complète ou des modèles 70B. **Nombres de vitesse (Llama 3 8B SFT, QLoRA, batch=4, seq=2048) :** * RTX 3090 : \~1 100 tokens/s de débit d'entraînement * RTX 4090 : \~1 450 tokens/s * A100 80 Go : \~2 800 tokens/s (bf16 complet, sans quantification) *** ## Dépannage ### Mémoire CUDA insuffisante ```bash # Réduire la taille du batch per_device_train_batch_size=1 gradient_accumulation_steps=16 # Conservez la même taille de batch effective # Utiliser la quantification 4 bits (QLoRA) # Ajoutez BitsAndBytesConfig avec load_in_4bit=True # Activer le gradient checkpointing gradient_checkpointing=True # Réduire la longueur de séquence max_seq_length=1024 # au lieu de 2048+ # Vérifier la mémoire du GPU nvidia-smi --query-gpu=memory.used,memory.total --format=csv ``` ### La perte est NaN ```bash # Cause fréquente : taux d'apprentissage trop élevé learning_rate=1e-5 # Essayez plus bas # Cause fréquente : mauvaises données (chaînes vides, valeurs None) # Validez le jeu de données : python3 -c " from datasets import load_from_disk ds = load_from_disk('data/sft_dataset') print(ds[0]) print(f'Length: {len(ds)}') # Vérifier les None none_count = sum(1 for x in ds if x.get('messages') is None) print(f'None count: {none_count}') " # Activer bf16 à la place de fp16 (plus stable) bf16=True fp16=False ``` ### DPO: `chosen_rewards > rejected_rewards` is False ```bash # Cela signifie que le modèle préfère les réponses rejetées — surapprentissage ou mauvaises données # Solutions : # 1. Vérifiez la qualité de votre jeu de données # 2. Réduisez beta (moins de pénalité KL) # 3. Réduisez le taux d'apprentissage # 4. Ajoutez davantage d'entraînement SFT avant DPO beta=0.05 # Essayez des valeurs plus petites ``` ### L'entraînement est très lent ```bash # Activer Flash Attention 2 pip install flash-attn --no-build-isolation # Dans votre code : model = AutoModelForCausalLM.from_pretrained( model_name, attn_implementation="flash_attention_2", torch_dtype=torch.bfloat16, ) # Utilisez bf16 à la place de fp16 sur les GPU Ampere+ (A100, RTX 3000+) bf16=True # Augmenter le nombre de workers du DataLoader dataloader_num_workers=4 # Vérifiez si le GPU est réellement utilisé nvidia-smi # Devrait afficher une utilisation élevée du GPU ``` ### `tokenizer.pad_token` avertissement ```bash # Correction standard pour les tokenizers Llama/Mistral tokenizer.pad_token = tokenizer.eos_token tokenizer.padding_side = "right" # Important pour la stabilité de l'entraînement ``` ### Autorisation refusée / HuggingFace 401 ```bash # Se reconnecter huggingface-cli login # Définir le jeton dans l'environnement export HF_TOKEN=hf_your-token # Pour les modèles/jeux de données privés, assurez-vous d'avoir accès : # Rendez-vous sur https://huggingface.co/meta-llama/Llama-3.2-8B-Instruct # Cliquez sur « Request access » et acceptez la licence ``` *** ## Enregistrer et partager votre modèle ```bash # Fusionner les poids LoRA dans le modèle de base python3 << 'EOF' from peft import PeftModel from transformers import AutoModelForCausalLM, AutoTokenizer import torch base_model = AutoModelForCausalLM.from_pretrained( "meta-llama/Llama-3.2-8B-Instruct", torch_dtype=torch.bfloat16, device_map="auto" ) model = PeftModel.from_pretrained(base_model, "./sft_final") merged = model.merge_and_unload() merged.save_pretrained("./merged_model") tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-8B-Instruct") tokenizer.save_pretrained("./merged_model") print("Merged model saved!") EOF # Publier sur HuggingFace huggingface-cli upload your-username/my-trl-model ./merged_model ``` *** ## Liens utiles * **GitHub**: ⭐ 10K+ * **Documentation**: * **Article DPO**: * **GRPO / DeepSeek-R1**: * **Article PPO (RLHF)**: * **HuggingFace PEFT**: * **Weights & Biases**: * **Flash Attention**: * **Marketplace Clore.ai**: --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-fr/entrainement/trl.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.