💡Guide de 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 le cadre où un « agent » apprend à prendre des décisions en interagissant avec un environnement et en recevant des 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 laquelle 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 niveau débutant au niveau 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 y a des subtilités sur ce que signifient « bon » et « mauvais », sur la manière dont nous procédons pour « augmenter » ou « diminuer » cela, ou même sur ce que « résultats » signifie.
Par exemple, dans le jeu Pacman:
Le l'environnement est le monde du jeu.
Le actions que vous pouvez effectuer sont HAUT, GAUCHE, DROITE et BAS.
Le récompenses sont bonnes si vous mangez un cookie, ou mauvaises si vous heurtez un des ennemis en zigzag.
En RL, vous ne pouvez pas connaître la « meilleure action » à prendre, 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 langage non aligné lâchera 3, 4, C, D, -10, littéralement n'importe quoi.
Les nombres sont mieux 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 une fonction de récompense!
🏃Du RLHF, PPO au GRPO et RLVR
OpenAI a popularisé le concept de RLHF (Reinforcement Learning from Human Feedback), où nous entraînons un « agent » à produire des réponses à 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 existe également un terme KL avec beta réglé > 0 pour empêcher le modèle de trop dévier.
Pour faire du 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 cela!
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 par rapport à 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 aux solutions faciles à vérifier. Par exemple :
Les équations mathématiques peuvent être facilement vérifiées. Ex. 2+2 = 4.
La sortie de code peut être vérifiée comme ayant exécuté correctement ou non.
Concevoir des fonctions de récompense vérifiables peut être difficile, et donc la plupart des exemples sont des mathématiques ou du code.
Les cas d'utilisation de GRPO ne se limitent pas au code ou aux maths—son processus de raisonnement peut améliorer des tâches comme l'automatisation des e-mails, la récupération de base de données, le droit et la médecine, en améliorant considérablement la précision selon votre jeu de données et votre fonction de récompense - l'astuce est de définir une rubrique - c.-à-d. une liste de petites récompenses vérifiables, et non une récompense finale et toute-puissante. OpenAI a popularisé cela dans leur offre de fine-tuning par apprentissage 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 » étant donné l'état actuel.
Le l'astuce est d'échantillonner le LLM! Nous calculons ensuite la récompense moyenne à travers des statistiques du processus d'échantillonnage sur plusieurs questions différentes.
Par exemple, pour « Quel est 2+2 ? » nous échantillonnons 4 fois. Nous pouvons 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 score Z cela !
Ceci crée les avantages A, que nous utiliserons en remplacement du modèle de valeur. Cela économise beaucoup de mémoire !
🤞La chance (ou plutôt 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 ex. « Quel est 2+2 ? » « Créez 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 interroger 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 langage non entraîné produira :
0, chat, -10, 1928, 3, A, B, 122, 17, 182, 172, A, C, BAHS, %$, #, 9, -192, 12.31**** puis soudainement 4.
Le signal de récompense était 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0**** puis soudainement 1.
Ainsi, par chance et 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 les autres (les mauvaises réponses) beaucoup moins.
Donc 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), c'est juste un jeu d'attente - vous rencontrerez à coup sûr la bonne réponse à la limite.
Donc j'aime l'appeler « La chance est tout ce dont vous avez besoin » pour le RL.
Une meilleure formule serait « 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. des mauvaises réponses, et nous pouvons essentiellement « guider » le modèle pour qu'il essaie déjà de ne pas générer de mauvaises solutions. Cela signifie que même si vous avez attendu très longtemps qu'une « bonne » réponse apparaisse, le modèle a déjà été modifié pour tenter 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 soudainement 4.
Puisque nous avons obtenu de mauvaises réponses, le RL influencera le modèle pour qu'il n'essaie PAS de produire ces mauvaises réponses. Cela signifie qu'au fil du temps, nous « élaguons » ou déplaçons soigneusement la distribution de sortie 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 la raison pour laquelle les gens aiment faire du RL à partir d'un modèle déjà affiné pour les instructions, qui peut partiellement suivre les instructions de manière raisonnable - cela augmente probablement la probabilité au-dessus de 0.
🦥Ce que propose Unsloth pour le RL
Avec 15GB 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 5GB de VRAM suffisent pour entraîner votre propre modèle de raisonnement localement (pour tout modèle de 1.5B 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 !
Cahiers GRPO :
Nous prenons 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.
Les démonstrations précédentes montrent que vous pourriez atteindre 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 5GB de VRAM.
Auparavant, GRPO n'était pris en charge que pour le fine-tuning complet, mais nous l'avons fait fonctionner 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,3GB de VRAM pour Llama 3.1 (8B), tandis que les implémentations standard (+ Flash Attention 2) prennent 510,8GB (90% de moins pour Unsloth).
Veuillez noter que cela n'est pas le fine-tuning des modèles distillés R1 de DeepSeek ni l'utilisation de données distillées de R1 pour le réglage que Unsloth prenait déjà en charge. Il s'agit de convertir un modèle standard en un véritable modèle de raisonnement en utilisant GRPO.
Dans un exemple de test, bien que nous ayons seulement entraîné Phi-4 pendant 100 étapes en utilisant GRPO, les résultats sont déjà clairs. Le modèle sans GRPO n'a pas le jeton de réflexion, tandis que celui entraîné avec GRPO l'a et possède également 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 variantes).
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 correspond à 300 étapes d'entraînement (ou 900 étapes si entraîné sur 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 carnets GRPO avancés car ils ont une fonction de récompense bien meilleure et vous devriez voir les résultats beaucoup plus rapidement et fréquemment.
Bases/Conseils
Attendez au moins 300 étapes pour que la récompense augmente réellement. Pour obtenir des résultats décents, vous pouvez avoir besoin d'un minimum de 12 heures (c'est ainsi que GRPO fonctionne), mais gardez à l'esprit que ce n'est pas obligatoire et que vous pouvez arrêter à tout moment.
Pour des résultats optimaux, ayez au moins 500 lignes de données. Vous pouvez essayer même avec 10 lignes de données mais il est préférable d'en avoir davantage.
Chaque entraînement sera toujours différent en fonction de votre modèle, de vos données, de votre fonction de récompense/vérificateur, etc., donc bien que 300 étapes soit ce que nous indiquons comme minimum, parfois cela peut être 1000 étapes ou plus. Donc, cela dépend de plusieurs 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 jetons de réflexion car les modèles plus petits peuvent ne pas le faire.
Pour les exigences en VRAM GPU pour QLoRA 4-bit, la règle générale est que 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 en sécurité). Plus vous augmentez la longueur de contexte, plus la VRAM nécessaire. LoRA en 16-bit utilisera au minimum 4x plus de VRAM.
Le fine-tuning 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 style R1.
Si vous utilisez un modèle de base, assurez-vous d'avoir un modèle de chat (chat template).
Plus vous entraînez avec GRPO, mieux c'est. La meilleure partie de GRPO est que vous n'avez même pas besoin d'autant de données. Tout ce dont vous avez besoin est une excellente fonction de récompense/vérificateur et plus le temps d'entraînement est long, meilleur sera votre modèle. Attendez-vous à ce que votre récompense en fonction des étapes augmente au fil du temps comme ceci :
Le suivi de la perte d'entraînement pour GRPO est maintenant intégré directement dans Unsloth, éliminant le besoin d'outils externes comme wandb, etc. Il contient des journaux complets pour toutes les fonctions de récompense y compris la récompense agrégée totale elle-même.
RL sur des modèles non pris en charge :
Vous pouvez également exécuter du RL avec Unsloth sur des modèles qui ne sont pas pris en charge par vLLM, tels que Qwen3.5. Il suffit de définir fast_inference=False lors du chargement du modèle.
📋Fonctions de récompense / Vérificateurs
En apprentissage par renforcement, une fonction de récompense et un vérificateur ont des rôles distincts pour évaluer la sortie d'un modèle. En général, vous pouvez les interpréter comme la même chose mais techniquement ils ne le sont pas, bien que cela ait moins d'importance 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 l'étiquette comme « faux » (puisque la réponse correcte est 4).
Les vérificateurs peuvent également 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 fausse, elle peut attribuer une pénalité (-1, -2, etc.), tandis qu'une réponse correcte pourrait recevoir un score positif (+1, +2).
Elle peut aussi pénaliser sur des critères au-delà de la correction, tels qu'une longueur excessive ou une mauvaise lisibilité.
Différences clés:
Un vérificateur vérifie la correction mais n'attribue pas de score.
Un fonction de récompense attribue un score mais ne vérifie pas nécessairement la correction lui-même.
Une fonction de récompense 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 le modèle de manière incrémentale.
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 une large gamme 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 saisir 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 sonne trop robotique, déduire 3 points. » Cela aide à affiner les sorties selon des critères de qualité
Exemple n°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 réponse correcte → +3
Si incorrect → -3
Récompense totale : Somme de toutes les fonctions de récompense
Exemple n°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é Unsloth
Si vous avez consulté notre notebook Colab GRPO avancé, 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 qui sont plus proches de la bonne. 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 modèles GRPO personnalisés au-delà des invites génériques comme
penser, par ex.,<start_working_out></end_working_out>Appliquez un scorage basé sur la proximité — les modèles obtiennent plus 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 est populaire et s'est avéré assez efficace :
correctness_reward_func – Récompense les correspondances d'étiquettes exactes.
int_reward_func – Encourage les réponses entières uniquement.
soft_format_reward_func – Vérifie la structure mais autorise de petites différences de saut de ligne.
strict_format_reward_func – Garantit que la structure de la réponse correspond à l'invite, y compris les sauts de ligne.
xmlcount_reward_func – Garantit exactement une occurrence de chaque balise XML dans la réponse.
🧮Utilisation de vLLM
Vous pouvez maintenant utiliser Cette configuration fonctionne avec des fournisseurs hébergés, des points de terminaison auto-hébergés, directement dans votre chaîne de fine-tuning, 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-bit 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 5GB pour Llama 3.1 8B et 3GB pour Llama 3.2 3B. Unsloth pouvait à l'origine affiner Llama 3.3 70B Instruct sur 1x GPU 48GB avec les poids de Llama 3.3 70B occupant 40GB de VRAM. Si nous ne supprimons pas l'utilisation double de mémoire, alors 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'une inférence rapide en 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% comparé 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,3GB de VRAM pour Llama 3.1 8B, tandis que les implémentations standard prennent 510,8GB (90% de moins pour Unsloth).
Pour les Exigences de VRAM GPU pour QLoRA 4-bit, la règle générale est que 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 en sécurité). Plus vous augmentez la longueur de contexte, plus la VRAM nécessaire. LoRA en 16-bit 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 supprime 68,5GB de mémoire, tout en étant en réalité plus rapide grâce à l'aide de torch.compile !
Nous tirons parti de notre astucieux checkpointing de gradient Unsloth algorithme que nous avons publié il y a quelque temps. Il déplace intelligemment les activations intermédiaires vers la RAM système de manière asynchrone tout en n'étant qu'1% plus lent. Cela économise 52GB 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 d'autres packages. Cela économise 16GB 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 longueur de contexte 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 GRPO à contexte long, donc nous n'avons besoin que d'environ 9.8GB supplémentaires de VRAM pour des longueurs de contexte de 20K !
Nous devons également convertir le Cache KV en 16bit. 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 du batch pour vLLM à 8, mais nous la laisserons à 1 pour nos calculs afin d'économiser de la VRAM. Sinon vous aurez besoin de 20GB pour le cache KV.
🎥 Atelier vidéo Unsloth RL de 3 heures
🎓Lectures complémentaires
Le livre de Nathan Lambert sur le RLHF est un 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 foire AI Engineer World 2025. Les diapositives et autres documents 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 à partir d'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 ?