Aller au contenu
For the complete documentation index, see llms.txt. This page is also available as Markdown.

🌀Apprentissage par renforcement GRPO avec un contexte 7x plus long

Découvrez comment Unsloth permet un fine-tuning RL avec des contextes ultra-longs.

Le plus grand défi de l'apprentissage par renforcement (RL) est de prendre en charge de longues traces de raisonnement. Nous introduisons de nouveaux algorithmes de batching pour permettre ~un contexte 7x plus long (peut dépasser 12x) Entraînement RL sans dégradation de la précision ni de la vitesse par rapport à d'autres configurations optimisées utilisant FA3, des kernels et des pertes chunkées.

  • Unsloth entraîne désormais gpt-oss en QLoRA avec 380K de contexte sur un seul GPU NVIDIA B200 de 192 Go

  • Qwen3-8B GRPO atteint 110K de contexte sur un H100 doté de 80 Go de VRAM via vLLM et QLoRA, et 65K pour gpt-oss avec LoRA BF16.

  • Avec 24 Go de VRAM, gpt-oss atteint un contexte de 20K et 32K pour Qwen3-VL-8B QLoRA

  • Les exécutions RL GRPO d'Unsloth avec Llama, Gemma et tous les modèles prennent automatiquement en charge des contextes plus longs

Nos nouveaux kernels et algorithmes de déplacement des données et de batching débloquent davantage de contexte grâce à :

Vous pouvez combiner toutes les fonctionnalités d'Unsloth ensemble :

  1. d'Unsloth partage de poids fonctionnalité avec vLLM et notre fonctionnalité de veille dans RL économe en mémoire

  2. d'Unsloth Flex Attention pour gpt-oss à long contexte et notre 500K Context Training

  3. entraînement Float8 dans FP8 RL et le checkpointing asynchrone des gradients et bien plus encore

🎉Premiers pas

Pour commencer, vous pouvez utiliser n'importe quel Notebooks GRPO (ou mettre à jour Unsloth s'il est installé localement) :

Adopter Unsloth pour vos tâches RL fournit un cadre robuste pour gérer efficacement des modèles à grande échelle. Pour utiliser efficacement les améliorations d'Unsloth :

  • Recommandations matérielles: Utilisez un NVIDIA H100 ou l'équivalent pour une utilisation optimale de la VRAM.

  • Conseils de configuration: Assurez-vous que batch_size et gradient_accumulation_steps les paramètres soient adaptés à vos ressources de calcul pour des performances optimales.

Nos benchmarks mettent en évidence les économies de mémoire obtenues par rapport aux versions antérieures pour GPT OSS et Qwen3-8B. Les deux graphiques ci-dessous (sans veille) ont été exécutés avec batch_size = 4 et gradient_accumulation_steps=2 , car la veille utilise par conception toute la VRAM.

Pour nos benchmarks, nous comparons BF16 GRPO à Hugging Face avec toutes les optimisations activées (tous les kernels de la bibliothèque kernels, Flash Attention 3, kernels de perte chunkée, etc.) :

🔢Découpage aplati de la longueur de séquence

Auparavant, Unsloth réduisait l'utilisation de la mémoire en RL en évitant la matérialisation complète du tenseur de logits grâce à un découpage sur la dimension du batch. Une estimation approximative de la VRAM nécessaire pour matérialiser les logits pendant la passe avant est présentée dans l'équation (1).

Equation 1: Logit Memory (GB)=batch size×context length×vocab dim10243\text{Equation 1: } \text{Logit Memory (GB)} = \frac{\text{batch size} \times\text{context length} \times \text{vocab dim}}{1024^3}

En utilisant cette formulation, une configuration avec batch_size = 4, context_length = 8192et vocab_dim = 128,000 nécessiterait environ 3,3 Go de VRAM pour stocker le tenseur de logits.

Par Long Context gpt-oss l'an dernier, nous avons ensuite introduit une approche de perte fusionnée pour GRPO. Cette approche garantit qu'un seul échantillon du batch est traité à la fois, réduisant considérablement l'utilisation maximale de la mémoire. Dans la même configuration, l'utilisation de la VRAM tombe à environ 0,83 Go, comme le montre l'équation (2).

Equation 2: Logit Memory (GB)=context length×vocab dim10243\text{Equation 2: }\text{Logit Memory (GB)} = \frac{\text{context length} \times \text{vocab dim}}{1024^3}
Figure 1 : gpt-oss BF16 GRPO LoRA (Unsloth vs HF avec toutes les optimisations activées)
Figure 2 : Qwen3-8B QLoRA GRPO LoRA (Unsloth vs HF avec toutes les optimisations activées)

Dans cette mise à jour, nous prolongeons encore la même idée en introduisant un découpage sur la dimension de séquence également. Au lieu de matérialiser les logits pour l'ensemble de l' (batch_size × context_length) espace d'un seul coup, nous aplatissons ces dimensions et les traitons en plus petits morceaux à l'aide d'un multiplicateur configurable. Cela permet à Unsloth de prendre en charge des contextes nettement plus longs sans augmenter l'utilisation maximale de la mémoire.

Dans la figure 5 ci-dessous, nous utilisons un multiplicateur de max(4, context_length // 4096), bien que n'importe quel multiplicateur puisse être spécifié selon le compromis mémoire–performance souhaité. Avec ce paramètre, la même configuration d'exemple (batch_size = 4, context_length = 8192, vocab_dim = 128,000) ne nécessite désormais que 0,207 Go de VRAM pour la matérialisation des logits.

Equation 3: Logit Memory (GB)=context lengthmultiplier×vocab dim10243\text{Equation 3: }\text{Logit Memory (GB)} = \frac{\frac{\text{context length}}{\text{multiplier}} \times \text{vocab dim}}{1024^3}
Figure 3 : gpt-oss-20b (H100) nouvelle version d'Unsloth vs ancienne
Figure 4 : Qwen3-8B (H100) nouvelle version d'Unsloth vs ancienne
Figure 5 : gpt-oss-20b (H100)
Figure 6 : Qwen3-8B (B200)

Cette mise à jour se reflète dans le chunked_hidden_states_selective_log_softmax ci-dessous, qui prend désormais en charge le découpage à la fois sur les dimensions du batch et de la séquence. Pour préserver le tenseur de logits ([batch_size, context_length, vocab_dim]), il est toujours découpé selon la dimension du batch. Le découpage supplémentaire de la séquence est contrôlé via unsloth_logit_chunk_multiplier dans la configuration GRPO ; s'il n'est pas défini, il prend par défaut max(4, context_length // 4096). input_ids_chunk[0] correspond à la taille des mini-batchs des hidden states dans l'optimisation 2.

  1. Nous utilisons torch.compile avec des options de compilation personnalisées pour réduire la VRAM et augmenter la vitesse.

  2. Tous les logits découpés sont convertis en float32 pour préserver la précision.

  3. Nous prenons en charge le softcapping des logits, le réglage de la température et toutes les autres fonctionnalités.

👻Découpage des états cachés

Nous avons également observé qu'à des longueurs de contexte plus élevées, les états cachés peuvent contribuer de manière significative à l'utilisation de la mémoire. À titre de démonstration, nous supposerons hidden_states_dim=4096. L'utilisation de mémoire correspondante suit une formulation similaire au cas des logits, présentée ci-dessous.

Hidden States Memory (GB)=batch size×context length×hidden states dim10243\text{Hidden States Memory (GB)} = \frac{\text{batch size} \times\text{context length} \times \text{hidden states dim}}{1024^3}

Avec un batch_size = 8 et context_length = 64000, cela entraînerait une utilisation de la VRAM d'environ 2 Go. Dans cette version, nous introduisons un découpage optionnel sur la dimension du batch pour le tenseur des états cachés lors du calcul des log-probabilités. Cela diviserait l'utilisation de la VRAM par la taille du batch ou, dans ce cas, la ferait passer à 0,244 Go.Cela réduit la VRAM de pointe nécessaire pour matérialiser les états cachés, comme le montre l'équation mise à jour ci-dessous :

Hidden States Memory (GB)=context length×hidden states dim10243\text{Hidden States Memory (GB)} = \frac{\text{context length} \times \text{hidden states dim}}{1024^3}

Comme pour notre perte d'entropie croisée dans notre 500K Context Training version, la nouvelle implémentation ajuste automatiquement le batching des états cachés. Les utilisateurs peuvent également contrôler ce comportement via unsloth_grpo_mini_batch. Cependant, augmenter unsloth_grpo_mini_batch au-delà de la valeur optimale peut entraîner une légère augmentation des performances ou un ralentissement (généralement plus rapide) par rapport à la fonction de perte précédente.

Cependant, lors d'une exécution GPT-OSS (context_length = 8192, batch_size = 4, gradient_accumulation_steps = 2), définir unsloth_grpo_mini_batch = 1 et unsloth_logit_chunk_multiplier = 4 se traduit par peu ou pas de dégradation de la vitesse tout en réduisant l'utilisation de la VRAM d'environ 5 Go par rapport aux anciennes versions d'Unsloth.

🌵Déchargement des activations pour le log softmax

Au cours du développement de cette version, nous avons découvert que lors du pavage sur la dimension du batch pour les états cachés, les activations n'étaient pas déchargées après le calcul fusionné des logits et des logprobs. Comme les logits sont calculés un batch à la fois à l'aide de hidden_states[i] @ lm_head, la logique existante de déchargement des activations et de gradient checkpointing, conçue pour fonctionner dans la passe avant du modèle, ne s'appliquait pas dans ce cas.

Pour y remédier, nous avons ajouté une logique explicite pour décharger ces activations en dehors de la passe avant du modèle, comme le montre le pseudo-code Python ci-dessous :

✨Configuration des paramètres :

Si vous ne configurez pas unsloth_grpo_mini_batch et unsloth_logit_chunk_multiplier, nous allons ajuster automatiquement ces deux paramètres pour vous en fonction de votre VRAM disponible et selon la taille de votre longueur de contexte. Voici toutefois comment vous pouvez modifier ces variables dans votre exécution GRPO :

Une visualisation des optimisations et unsloth_grpo_mini_batch et unsloth_logit_chunk_multiplier peut être vue dans le schéma ci-dessous.

Les 3 matrices représentent le batch global plus grand ou unsloth_grpo_mini_batch (représenté par le nombre d'accolades noires) et les lignes de chacune des matrices représentent la longueur de contexte que le unsloth_logit_chunk_multiplier découpe la longueur de séquence en (représenté par le nombre d'accolades rouges).

📼vLLM pour le RL

Pour les workflows RL, la phase d'inférence/génération est le principal goulot d'étranglement. Pour y remédier, nous utilisons vLLM, ce qui a accéléré la génération jusqu'à 11x par rapport à la génération normale. Depuis que GRPO s'est popularisé l'an dernier, vLLM est un composant essentiel de la plupart des frameworks RL, y compris Unsloth. Nous tenons à exprimer notre gratitude à l'équipe vLLM et à tous ses contributeurs pour leur travail, car ils jouent un rôle central dans l'amélioration du RL d'Unsloth !

Pour essayer le RL à contexte plus long, vous pouvez utiliser n'importe quel Notebooks GRPO (ou mettre à jour Unsloth s'il est installé localement) :

Remerciements : un immense merci à l'équipe et aux bibliothèques Hugging Face pour alimenter Unsloth et rendre cela possible.

Mis à jour

Ce contenu vous a-t-il été utile ?