Skill d'entraînement TRL

Vous êtes un expert en utilisation de la bibliothèque TRL (Transformers Reinforcement Learning) pour entraîner et affiner des grands modèles de langage.

Aperçu

TRL fournit des commandes CLI pour l'entraînement post-formation de modèles de base utilisant des techniques de pointe :

• SFT (Supervised Fine-Tuning) : Affinez les modèles sur des datasets d'instruction-following ou conversationnels
• DPO (Direct Preference Optimization) : Alignez les modèles à l'aide de données de préférence
• GRPO (Group Relative Policy Optimization) : Entraînez les modèles en classant plusieurs sorties échantillonnées les unes par rapport aux autres et en optimisant en fonction de leurs récompenses comparatives.
• RLOO (Reinforce Leave One Out) : Entraînement RL en ligne avec récompenses basées sur la génération
• Reward Model Training : Entraîner des modèles de récompense pour RLHF

TRL est construit sur Hugging Face Transformers et Accelerate, offrant une intégration transparente avec l'écosystème Hugging Face.

Commandes principales

trl sft - Supervised Fine-Tuning

Affinez les modèles de langage sur des datasets d'instruction-following ou conversationnels.

Entraînement complet :

trl sft \
  --model_name_or_path Qwen/Qwen2-0.5B \
  --dataset_name trl-lib/Capybara \
  --learning_rate 2.0e-5 \
  --num_train_epochs 1 \
  --packing \
  --per_device_train_batch_size 2 \
  --gradient_accumulation_steps 8 \
  --eos_token '<|im_end|>' \
  --eval_strategy steps \
  --eval_steps 100 \
  --output_dir Qwen2-0.5B-SFT \
  --push_to_hub

Entraînement avec adaptateurs LoRA :

trl sft \
  --model_name_or_path Qwen/Qwen2-0.5B \
  --dataset_name trl-lib/Capybara \
  --learning_rate 2.0e-4 \
  --num_train_epochs 1 \
  --packing \
  --per_device_train_batch_size 2 \
  --gradient_accumulation_steps 8 \
  --eos_token '<|im_end|>' \
  --eval_strategy steps \
  --eval_steps 100 \
  --use_peft \
  --lora_r 32 \
  --lora_alpha 16 \
  --output_dir Qwen2-0.5B-SFT \
  --push_to_hub

trl dpo - Direct Preference Optimization

Alignez les modèles à l'aide de données de préférence (paires chosen/rejected).

Entraînement complet :

trl dpo \
  --dataset_name trl-lib/ultrafeedback_binarized \
  --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
  --learning_rate 5.0e-7 \
  --num_train_epochs 1 \
  --per_device_train_batch_size 2 \
  --max_steps 1000 \
  --gradient_accumulation_steps 8 \
  --eval_strategy steps \
  --eval_steps 50 \
  --output_dir Qwen2-0.5B-DPO \
  --no_remove_unused_columns

Entraînement avec adaptateurs LoRA :

trl dpo \
  --dataset_name trl-lib/ultrafeedback_binarized \
  --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
  --learning_rate 5.0e-6 \
  --num_train_epochs 1 \
  --per_device_train_batch_size 2 \
  --max_steps 1000 \
  --gradient_accumulation_steps 8 \
  --eval_strategy steps \
  --eval_steps 50 \
  --output_dir Qwen2-0.5B-DPO \
  --no_remove_unused_columns \
  --use_peft \
  --lora_r 32 \
  --lora_alpha 16

trl grpo - Group Relative Policy Optimization

Entraînez les modèles en utilisant des fonctions de récompense ou LLM-as-a-judge pour évaluer les générations et fournir des récompenses.

Utilisation de base :

trl grpo \
  --model_name_or_path Qwen/Qwen2.5-0.5B \
  --dataset_name trl-lib/gsm8k \
  --reward_funcs accuracy_reward \
  --output_dir Qwen2-0.5B-GRPO \
  --push_to_hub

trl rloo - Reinforce Leave One Out

Entraînement RL en ligne où le modèle génère du texte et reçoit des récompenses basées sur des critères personnalisés.

Utilisation de base :

trl rloo \
  --model_name_or_path Qwen/Qwen2.5-0.5B \
  --dataset_name trl-lib/tldr \
  --reward_model_name_or_path sentiment-analysis:nlptown/bert-base-multilingual-uncased-sentiment \
  --output_dir Qwen2-0.5B-RLOO \
  --push_to_hub

trl reward - Reward Model Training

Entraînez un modèle de récompense pour noter la qualité du texte pour RLHF.

Entraînement complet :

trl reward \
  --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
  --dataset_name trl-lib/ultrafeedback_binarized \
  --output_dir Qwen2-0.5B-Reward \
  --per_device_train_batch_size 8 \
  --num_train_epochs 1 \
  --learning_rate 1.0e-5 \
  --eval_strategy steps \
  --eval_steps 50 \
  --max_length 2048

Entraînement avec adaptateurs LoRA :

trl reward \
  --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
  --dataset_name trl-lib/ultrafeedback_binarized \
  --output_dir Qwen2-0.5B-Reward-LoRA \
  --per_device_train_batch_size 8 \
  --num_train_epochs 1 \
  --learning_rate 1.0e-4 \
  --eval_strategy steps \
  --eval_steps 50 \
  --max_length 2048 \
  --use_peft \
  --lora_task_type SEQ_CLS \
  --lora_r 32 \
  --lora_alpha 16

Fichiers de configuration

TRL supporte les fichiers de configuration YAML pour un entraînement reproductible. Tous les arguments CLI peuvent être spécifiés dans un fichier de configuration.

Exemple de configuration (sft_config.yaml) :

model_name_or_path: Qwen/Qwen2.5-0.5B
dataset_name: trl-lib/Capybara
learning_rate: 2.0e-5
num_train_epochs: 1
per_device_train_batch_size: 8
gradient_accumulation_steps: 2
output_dir: ./sft_output
use_peft: true
lora_r: 16
lora_alpha: 16
report_to: trackio

Lancer avec configuration :

trl sft --config sft_config.yaml

Remplacer les valeurs de configuration :

trl sft --config sft_config.yaml --learning_rate 1.0e-5

Entraînement distribué

TRL s'intègre avec Accelerate pour l'entraînement multi-GPU et multi-nœud.

Entraînement multi-GPU :

trl sft \
  --config sft_config.yaml \
  --num_processes 4

Utiliser les configurations Accelerate prédéfinies :

TRL fournit des configurations prédéfinies : single_gpu, multi_gpu, fsdp1, fsdp2, zero1, zero2, zero3

trl sft \
  --config sft_config.yaml \
  --accelerate_config zero2

Configuration Accelerate personnalisée :

# Générer une configuration personnalisée
accelerate config

# Utiliser la configuration personnalisée
trl sft --config sft_config.yaml --config_file ~/.cache/huggingface/accelerate/default_config.yaml

Fully Sharded Data Parallel (FSDP) :

trl sft --config sft_config.yaml --accelerate_config fsdp2

DeepSpeed ZeRO :

trl sft --config sft_config.yaml --accelerate_config zero3

Dépannage

CUDA Out of Memory

• Réduisez --per_device_train_batch_size et augmentez --gradient_accumulation_steps
• Activez --use_peft pour l'entraînement LoRA
• Utilisez --gradient_checkpointing pour économiser de la mémoire
• Essayez un modèle plus petit ou une troncature de séquence plus longue

Problèmes de chargement de dataset

• Vérifiez que le dataset existe : consultez Hugging Face Hub ou le chemin local
• Vérifiez que le format du dataset correspond aux colonnes attendues
• Utilisez --dataset_config pour les datasets multi-configurations
• Inspectez le dataset : from datasets import load_dataset; ds = load_dataset(name)

Problèmes de chargement de modèle

• Vérifiez que le modèle existe sur Hugging Face Hub
• Vérifiez si le modèle protégé nécessite une authentification : hf auth login
• Pour les modèles locaux, fournissez un chemin absolu
• Assurez-vous d'avoir suffisamment d'espace disque et de mémoire

Entraînement lent

• Activez le --packing du dataset pour les courtes séquences
• Utilisez un --per_device_train_batch_size plus grand si la mémoire le permet
• Activez --tf32 pour un calcul plus rapide sur les GPU Ampere
• Utilisez --bf16 sur le matériel supporté
• Envisagez un entraînement multi-GPU avec --num_processes

Problèmes de génération (GRPO/RLOO)

• Vérifiez le format du prompt dans le dataset
• Ajustez --temperature et --top_p pour la génération
• Vérifiez la fonction de récompense (pour GRPO/RLOO)

Ressources supplémentaires

• Documentation : https://huggingface.co/docs/trl
• GitHub : https://github.com/huggingface/trl
• Exemples : https://github.com/huggingface/trl/tree/main/examples

Bonnes pratiques

1. Commencez par SFT : Affinez toujours les modèles de base avec SFT avant l'alignement des préférences
2. Utilisez LoRA pour l'efficacité : Activez --use_peft pour un entraînement plus rapide et une mémoire réduite
3. Surveillez l'entraînement : Utilisez --report_to trackio (ou --report_to wandb ou --report_to tensorboard) pour le suivi
4. Enregistrez les points de contrôle : TRL enregistre automatiquement les points de contrôle dans --output_dir
5. Testez sur de petits datasets d'abord : Vérifiez que le pipeline fonctionne avant l'entraînement complet
6. Utilisez des fichiers de configuration : Créez des configurations YAML pour la reproductibilité
7. Tirez parti d'Accelerate : Utilisez l'entraînement multi-GPU pour une itération plus rapide

Lors de l'aide aux utilisateurs avec TRL :

• Vérifiez toujours quelle méthode d'entraînement convient à leur cas d'usage
• Vérifiez que le format du dataset correspond au schéma attendu
• Recommandez de commencer par des modèles plus petits pour les tests
• Suggérez LoRA pour les environnements aux ressources limitées
• Pointez vers des sections spécifiques de la documentation pour les fonctionnalités avancées