💡Guide sur l'apprentissage par renforcement (RL)
Apprenez tout sur l'apprentissage par renforcement (RL) et comment entraîner votre propre modèle de raisonnement DeepSeek-R1 avec Unsloth en utilisant GRPO. Un guide complet du débutant à l'avancé.
L'apprentissage par renforcement est une situation où un « agent » apprend à prendre des décisions en interagissant avec un environnement et en recevant retours sous la forme de récompenses ou pénalités.
Action : Ce que le modèle génère (par ex. une phrase).
Récompense : Un signal indiquant si l'action du modèle était bonne ou mauvaise (par ex. la réponse a-t-elle suivi les instructions ? était-elle utile ?).
Environnement : Le scénario ou la tâche sur lequel le modèle travaille (par ex. répondre à la question d'un utilisateur).
🦥Ce que vous apprendrez
Qu'est-ce que le RL ? RLVR ? PPO ? GRPO ? RLHF ? RFT ? Est-ce que « La chance est tout ce dont vous avez besoin ? » pour le RL ?
Qu'est-ce qu'un environnement ? Un agent ? Une action ? Une fonction de récompense ? Des récompenses ?
Cet article couvre tout (du débutant à l'avancé) ce que vous devez savoir sur GRPO, l'apprentissage par renforcement (RL) et les fonctions de récompense, ainsi que des conseils, et les bases de l'utilisation de GRPO avec Unsloth. Si vous recherchez un tutoriel pas à pas pour utiliser GRPO, consultez notre guide ici.
Mise à jour du 15 janv. 2026 : RL à contexte ultra long est arrivé ! Entraînez gpt-oss avec une fenêtre de contexte de 380K.
Mise à jour du 26 nov. 2025 : Nous introduisons la précision FP8 pour le RL et GRPO dans Unsloth ! Lire le blog
❓Qu'est-ce que l'apprentissage par renforcement (RL) ?
L'objectif du RL est de :
Augmenter la probabilité d'observer « bon » résultats.
Diminuer la probabilité d'observer « mauvais » résultats.
C'est tout ! Il existe des subtilités sur ce que signifient « bon » et « mauvais », ou comment nous procédons pour « augmenter » ou « diminuer » cela, ou même ce que signifient « résultats ».
Par exemple, dans le jeu Pacman:
Le l'environnement est le monde du jeu.
Le les actions que vous pouvez effectuer sont HAUT, GAUCHE, DROITE et BAS.
Le récompenses sont bonnes si vous mangez un cookie, ou mauvais si vous heurtez l'un des ennemis ondulés.
En RL, vous ne pouvez pas connaître la « meilleure action » à entreprendre, mais vous pouvez observer des étapes intermédiaires, ou l'état final du jeu (victoire ou défaite)
Un autre exemple : imaginez qu'on vous pose la question : « Quel est 2 + 2 ? » (4) Un modèle de langue non aligné crachera 3, 4, C, D, -10, littéralement n'importe quoi.
Les nombres sont meilleurs que C ou D, n'est-ce pas ?
Obtenir 3 est mieux que, disons, 8, non ?
Obtenir 4 est définitivement correct.
Nous venons de concevoir un fonction de récompense!
🏃De RLHF, PPO à GRPO et RLVR
OpenAI a popularisé le concept de RLHF (Reinforcement Learning from Human Feedback), où nous entraînons un « agent » à produire des sorties à une question (l' état) qui sont jugées plus utiles par des êtres humains.
Le pouce levé et baissé dans ChatGPT, par exemple, peut être utilisé dans le processus RLHF.
Le terme clip(..., 1-e, 1+e) est utilisé pour forcer PPO à ne pas effectuer de changements trop importants. Il y a aussi un terme KL avec beta réglé > 0 pour empêcher le modèle de trop s'écarter.
Afin de réaliser RLHF, PPO (Proximal Policy Optimization) a été développé. L' agent est dans ce cas le modèle de langage. En fait il est composé de 3 systèmes :
Le Politique génératrice (modèle entraîné actuel)
Le Politique de référence (modèle original)
Le Modèle de valeur (estimateur de récompense moyenne)
Nous utilisons le Modèle de récompense pour calculer la récompense pour l'environnement actuel, et notre objectif est de maximiser ceci!
La formule pour PPO semble assez compliquée car elle a été conçue pour être stable. Consultez notre conférence AI Engineer que nous avons donnée en 2025 sur le RL pour des dérivations mathématiques plus approfondies sur PPO.
DeepSeek a développé GRPO (Group Relative Policy Optimization) pour entraîner leurs modèles de raisonnement R1. Les principales différences avec PPO sont :
Le Le modèle de valeur est supprimé, remplacé par des statistiques obtenues en appelant le modèle de récompense plusieurs fois.
Le Le modèle de récompense est supprimé et remplacé par une simple fonction de récompense personnalisée qui RLVR peut être utilisée.
Cela signifie que GRPO est extrêmement efficace. Auparavant PPO nécessitait d'entraîner plusieurs modèles - maintenant, avec la suppression du modèle de récompense et du modèle de valeur, nous pouvons économiser de la mémoire et accélérer tout.
RLVR (Reinforcement Learning with Verifiable Rewards) nous permet de récompenser le modèle sur la base de tâches avec des solutions faciles à vérifier. Par exemple :
Les équations mathématiques peuvent être facilement vérifiées. Par ex. 2+2 = 4.
La sortie de code peut être vérifiée comme ayant été exécutée correctement ou non.
Concevoir des fonctions de récompense vérifiables peut être difficile, et donc la plupart des exemples concernent les mathématiques ou le code.
Les cas d'utilisation de GRPO ne sont pas seulement pour le code ou les mathématiques — son processus de raisonnement peut améliorer des tâches comme l'automatisation des e-mails, la récupération de bases de données, le droit et la médecine, améliorant grandement la précision en fonction de votre jeu de données et de votre fonction de récompense - l'astuce est de définir un rubric - c.-à-d. une liste de petites récompenses vérifiables, et non une récompense finale unique et tout-consommatrice. OpenAI a popularisé cela dans leur offre d'affinage par renforcement (RFT) par exemple.
Pourquoi « Group Relative » ?
GRPO supprime complètement le modèle de valeur, mais nous devons toujours estimer la « récompense moyenne » donnée l'état actuel.
Le l'astuce est d'échantillonner le LLM! Nous calculons ensuite la récompense moyenne via des statistiques du processus d'échantillonnage sur plusieurs questions différentes.
Par exemple pour « Quel est 2+2 ? » nous échantillonnons 4 fois. Nous pourrions obtenir 4, 3, D, C. Nous calculons ensuite la récompense pour chacune de ces réponses, puis calculons la récompense moyenne et écart-type, puis standardiser par Z-score cela !
Ceci crée les avantages A, que nous utiliserons en remplacement du modèle de valeur. Cela permet d'économiser beaucoup de mémoire !
🤞La chance (enfin la patience) est tout ce dont vous avez besoin
L'astuce du RL est que vous n'avez besoin que de 2 choses :
Une question ou une instruction par ex. « Quel est 2+2 ? » « Crée un jeu Flappy Bird en Python »
Une fonction de récompense et un vérificateur pour vérifier si la sortie est bonne ou mauvaise.
Avec seulement ces 2 éléments, nous pouvons essentiellement appeler un modèle de langage un nombre infini de fois jusqu'à obtenir une bonne réponse. Par exemple pour « Quel est 2+2 ? », un mauvais modèle de langue non entraîné produira :
0, chat, -10, 1928, 3, A, B, 122, 17, 182, 172, A, C, BAHS, %$, #, 9, -192, 12.31**** puis soudain 4.
Le signal de récompense était 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0**** puis soudain 1.
Donc par chance et par hasard, le RL a réussi à trouver la bonne réponse à travers plusieurs exécutions. Notre objectif est de voir la bonne réponse 4 plus souvent, et le reste (les mauvaises réponses) beaucoup moins.
Ainsi l'objectif du RL est d'être patient - à la limite, si la probabilité de la bonne réponse est au moins un petit nombre (non nul), ce n'est qu'un jeu d'attente - vous rencontrerez la réponse correcte à 100 % à la limite.
Donc j'aime l'appeler « La chance est tout ce dont vous avez besoin » pour le RL.
Une meilleure formulation est « La patience est tout ce dont vous avez besoin » pour le RL.
Le RL nous fournit essentiellement une astuce - au lieu d'attendre simplement l'infini, nous obtenons des « mauvais signaux » c.-à-d. de mauvaises réponses, et nous pouvons essentiellement « guider » le modèle pour qu'il n'essaie pas déjà de générer de mauvaises solutions. Cela signifie que bien que vous ayez attendu très longtemps qu'une « bonne » réponse apparaisse, le modèle a déjà été modifié pour tenter au mieux de ne pas produire de mauvaises réponses.
Dans l'exemple « Quel est 2+2 ? » - 0, chat, -10, 1928, 3, A, B, 122, 17, 182, 172, A, C, BAHS, %$, #, 9, -192, 12.31**** puis soudain 4.
Puisque nous avons obtenu de mauvaises réponses, le RL influencera le modèle pour qu'il essaie de NE PAS produire de mauvaises réponses. Cela signifie qu'au fil du temps, nous « taillons » ou déplaçons soigneusement la distribution des sorties du modèle loin des mauvaises réponses. Cela signifie que le RL est efficace, puisque nous n'attendons PAS simplement l'infini, mais nous essayons activement de « pousser » le modèle autant que possible vers l'« espace des bonnes réponses ».
Si la probabilité est toujours 0, alors le RL ne fonctionnera jamais. C'est aussi pourquoi les gens aiment faire du RL à partir d'un modèle déjà affiné sur les instructions, qui peut partiellement suivre les instructions de manière raisonnable - cela augmente très probablement la probabilité au-dessus de 0.
🦥Ce que Unsloth offre pour le RL
Avec 15 Go de VRAM, Unsloth vous permet de transformer n'importe quel modèle jusqu'à 17 milliards de paramètres comme Llama 3.1 (8B), Phi-4 (14B), Mistral (7B) ou Qwen2.5 (7B) en un modèle de raisonnement
Unsloth prend désormais en charge le RL pour la vision/multimodalité des modèles !
Exigence minimale : Juste 5 Go de VRAM suffisent pour entraîner votre propre modèle de raisonnement localement (pour tout modèle de 1,5B de paramètres ou moins)
Pour GRPO avancé documentation sur le batching, la génération et les paramètres d'entraînement, lisez notre guide !
Notebooks GRPO :
gpt-oss-20b GSPO - nouveau
(ou mettre à jour Unsloth si local) : - Vision GSPO - nouveau
Gemma 3 (4B) - Vision GSPO - nouveau
NOUVEAU ! Nous prenons maintenant en charge GSPO et la plupart des autres nouvelles techniques GRPO. Vous pouvez jouer avec les arguments suivants dans GRPOConfig pour activer :
Si vous n'obtenez aucun raisonnement, assurez-vous d'avoir suffisamment d'étapes d'entraînement et vérifiez que votre fonction de récompense/vérificateur fonctionne. Nous fournissons des exemples de fonctions de récompense ici.
Des démonstrations précédentes montrent que vous pourriez obtenir votre propre moment « aha » avec Qwen2.5 (3B) - mais cela nécessitait 2 GPU A100 (160GB de VRAM). Maintenant, avec Unsloth, vous pouvez obtenir le même moment « aha » en utilisant juste un seul GPU de 5 Go de VRAM.
Auparavant, GRPO n'était pris en charge que pour l'affinage complet, mais nous l'avons rendu compatible avec QLoRA et LoRA
Sur des longueurs de contexte de 20K par exemple avec 8 générations par invite, Unsloth n'utilise que 54,3 Go de VRAM pour Llama 3.1 (8B), tandis que les implémentations standard (+ Flash Attention 2) prennent 510,8 Go (90 % de moins pour Unsloth).
Veuillez noter que ceci n'est pas l'affinage des modèles distillés R1 de DeepSeek ni l'utilisation de données distillées de R1 pour l'ajustement que Unsloth prenait déjà en charge. Il s'agit de convertir un modèle standard en un modèle de raisonnement complet en utilisant GRPO.
Dans un exemple de test, même si nous n'avons entraîné Phi-4 qu'avec 100 étapes en utilisant GRPO, les résultats sont déjà clairs. Le modèle sans GRPO n'a pas le token de pensée, tandis que celui entraîné avec GRPO l'a et a aussi la bonne réponse.
💻Entraînement avec GRPO
Pour un tutoriel sur la façon de transformer n'importe quel LLM ouvert en modèle de raisonnement en utilisant Unsloth & GRPO, voir ici.
Pour GRPO avancé documentation sur le batching, la génération et les paramètres d'entraînement, lisez notre guide !
Comment GRPO entraîne un modèle
Pour chaque paire question-réponse, le modèle génère plusieurs réponses possibles (par ex., 8 variations).
Chaque réponse est évaluée à l'aide de fonctions de récompense.
Étapes d'entraînement :
Si vous avez 300 lignes de données, cela représente 300 étapes d'entraînement (ou 900 étapes si entraîné pendant 3 époques).
Vous pouvez augmenter le nombre de réponses générées par question (par ex., de 8 à 16).
Le modèle apprend en mettant à jour ses poids à chaque étape.
Si vous rencontrez des problèmes avec votre modèle GRPO qui n'apprend pas, nous vous recommandons vivement d'utiliser nos notebooks GRPO avancés car ils possèdent une bien meilleure fonction de récompense et vous devriez voir des résultats beaucoup plus rapides et fréquents.
Bases/Conseils
Attendez au moins 300 étapes pour que la récompense augmente réellement. Pour obtenir des résultats décents, vous devrez peut-être prévoir un minimum de 12 heures (c'est ainsi que fonctionne GRPO), mais gardez à l'esprit que ce n'est pas obligatoire car vous pouvez arrêter à tout moment.
Pour des résultats optimaux, ayez au moins 500 lignes de données. Vous pouvez essayer avec même 10 lignes de données mais il est préférable d'en avoir plus.
Chaque exécution d'entraînement sera toujours différente selon votre modèle, vos données, votre fonction de récompense/vérificateur, etc., donc même si 300 étapes est ce que nous indiquons comme minimum, parfois cela peut être 1000 étapes ou plus. Cela dépend de divers facteurs.
Si vous utilisez GRPO avec Unsloth localement, veuillez aussi "pip install diffusers" si vous obtenez une erreur. Veuillez également utiliser la dernière version de vLLM.
Il est conseillé d'appliquer GRPO à un modèle d'au moins 1,5B de paramètres pour générer correctement des tokens de pensée car les modèles plus petits peuvent ne pas le faire.
Pour les exigences de GPU VRAM pour QLoRA 4 bits, la règle générale est : les paramètres du modèle = la quantité de VRAM dont vous aurez besoin (vous pouvez utiliser moins de VRAM mais c'est pour être prudent). Plus la longueur de contexte est grande, plus la VRAM nécessaire augmente. LoRA en 16 bits utilisera au minimum 4x plus de VRAM.
L'affinage continu est possible et vous pouvez simplement laisser GRPO tourner en arrière-plan.
Dans les notebooks d'exemple, nous utilisons le jeu de données GSM8K, le choix le plus populaire actuellement pour l'entraînement de type R1.
Si vous utilisez un modèle de base, assurez-vous d'avoir un template de chat.
Plus vous entraînez avec GRPO, mieux c'est. La meilleure partie de GRPO est que vous n'avez pas besoin d'autant de données. Tout ce dont vous avez besoin est une excellente fonction de récompense/vérificateur et plus vous passez de temps à entraîner, meilleur sera votre modèle. Attendez-vous à ce que votre récompense par rapport aux étapes augmente avec le temps comme ceci :
Le suivi de la perte d'entraînement pour GRPO est désormais intégré directement dans Unsloth, éliminant le besoin d'outils externes comme wandb, etc. Il contient des détails de journalisation complets pour toutes les fonctions de récompense, y compris la fonction de récompense agrégée totale elle-même.
📋Fonctions de récompense / Vérificateurs
En apprentissage par renforcement, une Fonction de récompense et un Vérificateur ont des rôles distincts dans l'évaluation de la sortie d'un modèle. En général, vous pouvez les interpréter comme la même chose ; cependant, techniquement ils ne le sont pas, mais cela importe moins car ils sont généralement utilisés conjointement.
Vérificateur:
Détermine si la réponse générée est correcte ou incorrecte.
Il n'attribue pas de score numérique — il vérifie simplement la correction.
Exemple : si un modèle génère « 5 » pour « 2+2 », le vérificateur vérifie et le marque comme « incorrect » (puisque la réponse correcte est 4).
Les vérificateurs peuvent aussi exécuter du code (par ex., en Python) pour valider la logique, la syntaxe et la correction sans nécessiter d'évaluation manuelle.
Fonction de récompense:
Convertit les résultats de vérification (ou d'autres critères) en un score numérique.
Exemple : si une réponse est incorrecte, elle peut attribuer une pénalité (-1, -2, etc.), tandis qu'une réponse correcte pourrait obtenir un score positif (+1, +2).
Elle peut aussi pénaliser selon des critères au-delà de la correction, tels que la longueur excessive ou la mauvaise lisibilité.
Principales différences:
Une Vérificateur vérifie la correction mais ne donne pas de score.
Une Fonction de récompense attribue un score mais ne vérifie pas nécessairement la correction elle-même.
Une fonction de récompense pouvez peut utiliser un Vérificateur, mais techniquement ce ne sont pas la même chose.
Comprendre les fonctions de récompense
L'objectif principal de GRPO est de maximiser la récompense et d'apprendre comment une réponse a été dérivée, plutôt que de simplement mémoriser et reproduire des réponses issues de ses données d'entraînement.
À chaque étape d'entraînement, GRPO ajuste les poids du modèle pour maximiser la récompense. Ce processus affine progressivement le modèle.
L'affinage régulier (sans GRPO) ne maximise que la probabilité de prédiction du prochain mot mais n'optimise pas pour une récompense. GRPO optimise pour une fonction de récompense plutôt que de simplement prédire le mot suivant.
Vous pouvez réutiliser les données sur plusieurs époques.
Les fonctions de récompense par défaut peuvent être prédéfinies pour être utilisées sur un large éventail de cas d'utilisation ou vous pouvez demander à ChatGPT/modèle local de les générer pour vous.
Il n'y a pas une seule manière correcte de concevoir des fonctions de récompense ou des vérificateurs - les possibilités sont infinies. Cependant, elles doivent être bien conçues et significatives, car des récompenses mal conçues peuvent involontairement dégrader les performances du modèle.
🪙Exemples de fonctions de récompense
Vous pouvez vous référer aux exemples ci-dessous. Vous pouvez entrer vos générations dans un LLM comme ChatGPT 4o ou Llama 3.1 (8B) et concevoir une fonction de récompense et un vérificateur pour l'évaluer. Par exemple, alimentez vos générations dans un LLM de votre choix et définissez une règle : « Si la réponse semble trop robotique, déduire 3 points. » Cela aide à affiner les sorties en fonction de critères de qualité.
Exemple #1 : Tâche arithmétique simple
Question :
"2 + 2"Réponse :
"4"Fonction de récompense 1 :
Si un nombre est détecté → +1
Si aucun nombre n'est détecté → -1
Fonction de récompense 2 :
Si le nombre correspond à la bonne réponse → +3
Si incorrect → -3
Récompense totale : Somme de toutes les fonctions de récompense
Exemple #2 : Tâche d'automatisation d'e-mails
Question : E-mail entrant
Réponse : E-mail sortant
Fonctions de récompense :
Si la réponse contient un mot-clé requis → +1
Si la réponse correspond exactement à la réponse idéale → +1
Si la réponse est trop longue → -1
Si le nom du destinataire est inclus → +1
Si un bloc de signature (téléphone, e-mail, adresse) est présent → +1
Fonction de récompense basée sur la proximité d'Unsloth
Si vous avez consulté notre Advanced GRPO Colab Notebook, vous remarquerez que nous avons créé une fonction de récompense personnalisée basée sur la proximité construite entièrement à partir de zéro, conçue pour récompenser les réponses plus proches de la correcte. Cette fonction flexible peut être appliquée à un large éventail de tâches.
Dans nos exemples, nous activons le raisonnement dans Qwen3 (Base) et le guidons vers des tâches spécifiques
Appliquez des stratégies de pré-affinage pour éviter la tendance par défaut de GRPO à n'apprendre que le formatage
Améliorez la précision d'évaluation avec une correspondance basée sur des regex
Créez des templates GRPO personnalisés au-delà des prompts génériques comme
think, par ex.,<start_working_out></end_working_out>Appliquez un score basé sur la proximité — les modèles obtiennent davantage de récompense pour des réponses plus proches (par ex., prédire 9 au lieu de 10 est mieux que 3) tandis que les valeurs aberrantes sont pénalisées
Fonctions de récompense GSM8K
Dans nos autres exemples, nous utilisons les fonctions de récompense GSM8K existantes par @willccbb qui sont populaires et se sont avérées assez efficaces :
correctness_reward_func – Récompense les correspondances exactes d'étiquette.
int_reward_func – Encourage les réponses uniquement entières.
soft_format_reward_func – Vérifie la structure mais autorise de petites divergences de nouvelle ligne.
strict_format_reward_func – Assure que la structure de la réponse correspond à l'invite, y compris les nouvelles lignes.
xmlcount_reward_func – Assure exactement une occurrence de chaque balise XML dans la réponse.
🧮Utilisation de vLLM
Vous pouvez désormais utiliser vLLM directement dans votre pile d'affinage, ce qui permet beaucoup plus de débit et vous permet d'affiner et d'effectuer des inférences sur le modèle en même temps ! Sur 1x A100 40GB, attendez-vous à environ 4000 tokens/s avec la quantification dynamique 4 bits d'Unsloth pour Llama 3.2 3B Instruct. Sur une Tesla T4 16GB (GPU Colab gratuit), vous pouvez obtenir 300 tokens/s. Nous avons également supprimé magiquement l'utilisation double de mémoire lors du chargement de vLLM et Unsloth ensemble, permettant des économies d'environ 5 Go pour Llama 3.1 8B et 3 Go pour Llama 3.2 3B. Unsloth pouvait à l'origine affiner Llama 3.3 70B Instruct sur 1 GPU de 48GB avec les poids de Llama 3.3 70B prenant 40GB de VRAM. Si nous ne supprimions pas l'utilisation double de mémoire, nous aurions besoin d'au moins 80GB de VRAM lors du chargement d'Unsloth et vLLM ensemble. Mais avec Unsloth, vous pouvez toujours affiner et bénéficier d'inférences rapides dans un seul package en dessous de 48GB de VRAM ! Pour utiliser l'inférence rapide, installez d'abord vllm, et instanciez Unsloth avec fast_inference :
✅Lignes directrices des exigences GRPO
Lorsque vous utilisez Unsloth pour faire du GRPO, nous réduisons intelligemment l'utilisation de la VRAM de plus de 90 % par rapport aux implémentations standard avec Flash Attention 2 en utilisant plusieurs astuces ! Sur des longueurs de contexte de 20K par exemple avec 8 générations par invite, Unsloth n'utilise que 54,3 Go de VRAM pour Llama 3.1 8B, tandis que les implémentations standard prennent 510,8 Go (90 % de moins pour Unsloth).
Pour les Exigences GPU VRAM pour QLoRA 4 bits, la règle générale est : les paramètres du modèle = la quantité de VRAM dont vous aurez besoin (vous pouvez utiliser moins de VRAM mais c'est pour être prudent). Plus la longueur de contexte est grande, plus la VRAM nécessaire augmente. LoRA en 16 bits utilisera au minimum 4x plus de VRAM.
Nos nouveaux noyaux linéaires économes en mémoire pour GRPO réduisent l'utilisation de la mémoire par 8x ou plus. Cela économise 68,5 Go de mémoire, tout en étant en fait plus rapide grâce à l'aide de torch.compile !
Nous tirons parti de notre checkpointing de gradient Unsloth algorithme que nous avons publié il y a quelque temps. Il décharge intelligemment les activations intermédiaires vers la RAM système de manière asynchrone tout en n'étant qu'1 % plus lent. Cela économise 52 Go de mémoire.
Unsloth utilise également le même espace mémoire GPU / CUDA que le moteur d'inférence sous-jacent (vLLM), contrairement aux implémentations dans d'autres packages. Cela économise 16 Go de mémoire.
Coût mémoire d'entraînement (GB)
42GB
414GB
Coût mémoire GRPO (GB)
9,8GB
78,3GB
Coût d'inférence (GB)
0GB
16GB
Cache KV d'inférence pour une longueur de contexte de 20K (GB)
2,5GB
2,5GB
Utilisation totale de la mémoire
54,33GB (90 % de moins)
510,8GB
Dans les implémentations GRPO standard typiques, vous devez créer 2 logits de taille (8, 20K) pour calculer la perte GRPO. Cela prend 2 * 2 octets * 8 (nombre de générations) * 20K (longueur de contexte) * 128256 (taille du vocabulaire) = 78,3GB en VRAM.
Unsloth réduit l'utilisation de la mémoire par 8x pour le GRPO à long contexte, donc nous n'avons besoin que d'environ 9,8GB de VRAM supplémentaires pour des longueurs de contexte de 20K !
Nous avons aussi besoin du Cache KV en 16 bits. Llama 3.1 8B a 32 couches, et K et V ont tous deux une taille de 1024. Donc l'utilisation mémoire pour une longueur de contexte de 20K = 2 * 2 octets * 32 couches * 20K longueur de contexte * 1024 = 2,5GB par batch. Nous fixerions la taille de batch pour vLLM à 8, mais nous la laissons à 1 pour nos calculs afin d'économiser de la VRAM. Sinon vous aurez besoin de 20GB pour le cache KV.
🎥 Vidéo atelier Unsloth RL 3 heures
🎓Lectures complémentaires
Le livre de Nathan Lambert sur RLHF est incontournable ! https://rlhfbook.com/c/11-policy-gradients.html
La vidéo YouTube de Yannic Kilcher sur GRPO est également incontournable ! https://www.youtube.com/watch?v=bAWV_yrqx4w
Nous avons fait un atelier de 3 heures à la AI Engineer World's Fair 2025. Les slides et autres matériaux sont disponibles à https://docs.unsloth.ai/ai-engineers-2025
Notebook GRPO avancé via Unsloth. https://docs.unsloth.ai/basics/reinforcement-learning-guide/tutorial-train-your-own-reasoning-model-with-grpo
GRPO depuis un notebook de modèle de base : https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_(4B)-GRPO.ipynb
Tutoriels vidéo
Voici quelques tutoriels vidéo créés par des YouTubers formidables que nous trouvons fantastiques !
Mis à jour
Ce contenu vous a-t-il été utile ?