# Guide de l'apprentissage par renforcement (RL) L’apprentissage par renforcement est le fait qu’un « agent » apprenne à prendre des décisions en interagissant avec un environnement et en recevant **des retours** sous la forme de **récompenses** ou **punitions**. * **Action :** Ce que le modèle génère (par ex. une phrase). * **Récompense :** Un signal indiquant à quel point l’action du modèle était bonne ou mauvaise (par ex. la réponse a-t-elle respecté 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). ### :sloth:Ce que vous allez apprendre 1. Qu’est-ce que RL ? RLVR ? PPO ? GRPO ? RLHF ? Est **« Le hasard est tout ce dont vous avez besoin ? »** pour le RL ? 2. Qu’est-ce qu’un environnement ? Un agent ? Une action ? Une fonction de récompense ? Des récompenses ? Cet article couvre tout ce que vous devez savoir sur GRPO, l’apprentissage par renforcement (RL) et les fonctions de récompense, du niveau débutant au niveau avancé, ainsi que des conseils et les bases de l’utilisation de GRPO avec [Unsloth](https://github.com/unslothai/unsloth). Si vous cherchez un tutoriel étape par étape pour utiliser GRPO, consultez notre guide [ici](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo). {% hint style="success" %} **Mise à jour du 15 janv. 2026 :** [Le RL à contexte ultra long](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/grpo-long-context) est arrivé ! Entraînez gpt-oss avec une fenêtre de contexte de 380K. **Mise à jour du 26 nov. 2025 :** Nous introduisons le RL en précision FP8 et GRPO dans Unsloth ! [Lire le blog](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/fp8-reinforcement-learning) {% endhint %} ## :question:Qu’est-ce que l’apprentissage par renforcement (RL) ? L’objectif du RL est de : 1. **Augmenter la probabilité d’obtenir des ****« bons »**** résultats.** 2. **Diminuer la probabilité d’obtenir des ****« mauvais »**** résultats.** **C’est tout !** Il existe des subtilités sur ce que signifient « bon » et « mauvais », ou sur la manière d’« augmenter » ou de « diminuer » cela, ou même sur ce que signifie « résultats ». {% columns %} {% column width="50%" %} Par exemple, dans le **jeu Pac-Man**: 1. L’ **environnement** est le monde du jeu. 2. L’ **actions** que vous pouvez effectuer sont HAUT, GAUCHE, DROITE et BAS. 3. L’ **récompenses** sont bonnes si vous mangez un cookie, ou mauvaises si vous touchez l’un des ennemis ondulants. 4. En RL, vous ne pouvez pas connaître la « meilleure action » à effectuer, mais vous pouvez observer des étapes intermédiaires, ou l’état final du jeu (victoire ou défaite) {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} {% columns %} {% column width="50%" %}

{% endcolumn %} {% column %} Un autre exemple : imaginez que l’on vous pose la question : **« Combien font 2 + 2 ? »** (4) Un modèle de langage non aligné peut répondre 3, 4, C, D, -10, littéralement n’importe quoi. 1. Les nombres sont meilleurs que C ou D, non ? 2. Obtenir 3 est mieux que, disons, 8, non ? 3. Obtenir 4 est certainement correct. Nous venons de concevoir une **fonction de récompense**! {% endcolumn %} {% endcolumns %} ### :person\_running:De RLHF, PPO à GRPO et RLVR {% columns %} {% column %}

{% endcolumn %} {% column %} OpenAI a popularisé le concept de [RLHF](https://en.wikipedia.org/wiki/Reinforcement_learning_from_human_feedback) (Reinforcement Learning from Human Feedback, apprentissage par renforcement à partir de retours humains), où nous entraînons un **« agent »** à produire des réponses à une question (l’ **état**) jugées plus utiles par les humains. Les pouces levés et baissés dans ChatGPT, par exemple, peuvent être utilisés dans le processus RLHF. {% endcolumn %} {% endcolumns %} {% columns %} {% column %}

Le terme clip(..., 1-e, 1+e) est utilisé pour forcer PPO à ne pas prendre des changements trop importants. Il y a aussi un terme KL avec beta réglé sur > 0 pour forcer le modèle à ne pas trop s’éloigner. {% endcolumn %} {% column %} Afin de faire du RLHF, [**PPO**](https://en.wikipedia.org/wiki/Proximal_policy_optimization) (optimisation de politique proximale) a été développé. L’ **agent** est le modèle de langage dans ce cas. En fait, il est composé de 3 systèmes : 1. L’ **Politique génératrice (modèle actuel entraîné)** 2. L’ **Politique de référence (modèle original)** 3. L’ **Modèle de valeur (estimateur de récompense moyenne)** Nous utilisons le **Modèle de récompense** pour calculer la récompense de l’environnement actuel, et notre objectif est de **maximiser celle-ci**! La formule de PPO semble assez compliquée parce qu’elle a été conçue pour être stable. Consultez notre [conférence d’ingénierie IA](https://docs.unsloth.ai/ai-engineers-2025) que nous avons donnée en 2025 sur le RL pour des dérivations mathématiques plus approfondies sur PPO. {% endcolumn %} {% endcolumns %} {% columns %} {% column %}

{% endcolumn %} {% column %} DeepSeek a développé [**GRPO**](https://unsloth.ai/blog/grpo) (Group Relative Policy Optimization, optimisation de politique relative par groupe) pour entraîner ses modèles de raisonnement R1. Les principales différences par rapport à PPO sont : 1. L’ **Le modèle de valeur est supprimé,** remplacé par des statistiques issues de multiples appels au modèle de récompense. 2. L’ **Le modèle de récompense est supprimé** et remplacé par une simple fonction de récompense personnalisée qui **RLVR** peut être utilisé. {% endcolumn %} {% endcolumns %} Cela signifie que GRPO est extrêmement efficace. Auparavant, PPO devait entraîner plusieurs modèles — maintenant, avec le modèle de récompense et le modèle de valeur supprimés, nous pouvons économiser de la mémoire et tout accélérer. **RLVR (apprentissage par renforcement avec récompenses vérifiables)** nous permet de récompenser le modèle en fonction de tâches dont les solutions sont faciles à vérifier. Par exemple : 1. Les équations mathématiques peuvent être facilement vérifiées. Par ex. 2+2 = 4. 2. La sortie de code peut être vérifiée pour savoir si elle s’est exécutée correctement ou non. 3. Concevoir des fonctions de récompense vérifiables peut être difficile, donc la plupart des exemples concernent les maths ou le code. 4. 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 recherche en base de données, le droit et la médecine, en améliorant grandement la précision selon votre ensemble de données et votre fonction de récompense — l’astuce consiste à définir une **grille d’évaluation — c’est-à-dire une liste de petites récompenses vérifiables, et non une récompense finale unique qui englobe tout.** OpenAI a लोकप्रियisé cela dans son offre de [fine-tuning par apprentissage par renforcement (RFT)](https://platform.openai.com/docs/guides/reinforcement-fine-tuning) par exemple. {% columns %} {% column %} **Pourquoi « Relative par groupe » ?** GRPO supprime complètement le modèle de valeur, mais nous devons tout de même estimer la **« récompense moyenne »** étant donné l’état actuel. L’ **l’astuce consiste à échantillonner le LLM**! Nous calculons ensuite la récompense moyenne à partir des statistiques du processus d’échantillonnage sur plusieurs questions différentes. {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} {% columns %} {% column %} Par exemple, pour « Combien font 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 l’ **écart-type**, puis nous **standardisons en score Z** cela ! Cela crée les **avantages A**, que nous utiliserons à la place du modèle de valeur. Cela économise beaucoup de mémoire ! {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} ### :fingers\_crossed:Le hasard (ou plutôt la patience) est tout ce dont vous avez besoin L’astuce du RL est qu’il ne faut que 2 choses : 1. Une question ou une instruction, par ex. « Combien font 2+2 ? » « Crée un jeu Flappy Bird en Python » 2. 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 **faire appel à un modèle de langage un nombre infini de fois** jusqu’à obtenir une bonne réponse. Par exemple, pour « Combien font 2+2 ? », un mauvais modèle de langage non entraîné renverra : ***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.*** Ainsi, par chance et par hasard, RL a réussi à trouver la bonne réponse à travers plusieurs **déploiements**. 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), c’est juste une question d’attente — vous finirez 100 % du temps par rencontrer la bonne réponse à la limite.** **J’aime donc appeler cela « Le hasard est tout ce dont vous avez besoin » pour le RL.** **Eh bien, une meilleure formule est « La patience est tout ce dont vous avez besoin » pour le RL.**

Le RL nous offre essentiellement une astuce : au lieu d’attendre simplement l’infini, nous recevons bien des « signaux négatifs », c’est-à-dire de mauvaises réponses, et nous pouvons en quelque sorte « 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 faire de son mieux afin de ne pas produire de mauvaises réponses. Dans l’exemple « Combien font 2+2 ? » — ***0, chat, -10, 1928, 3, A, B, 122, 17, 182, 172, A, C, BAHS, %$, #, 9, -192, 12.31\*\*\*\*\*\*\*\* ****puis soudain 4****.*** Comme nous avons obtenu de mauvaises réponses, RL influencera le modèle pour essayer de NE PAS produire de mauvaises réponses. Cela signifie qu’avec le temps, nous « élaguons » soigneusement, ou éloignons, la distribution de sortie du modèle des mauvaises réponses. Cela signifie que RL est **efficace**, car nous ne faisons PAS qu’attendre l’infini, nous poussons activement le modèle à aller autant que possible vers l’« espace de la bonne réponse ». {% hint style="danger" %} **Si la probabilité est toujours de 0, alors RL ne fonctionnera jamais**. C’est aussi pourquoi les gens aiment faire du RL à partir d’un modèle déjà affiné pour suivre les instructions, qui peut les suivre raisonnablement bien — cela augmente la probabilité au-dessus de 0 dans la plupart des cas. {% endhint %} ## :sloth:Ce qu’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 modèle de raisonnement * **Unsloth prend désormais en charge** [**le RL pour les modèles de vision/multimodaux**](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl) **!** * **Exigence minimale :** Seulement 5 Go de VRAM suffisent pour entraîner votre propre modèle de raisonnement localement (pour tout modèle de 1,5 milliard de paramètres ou moins) {% columns %} {% column %} {% content-ref url="reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo" %} [tutorial-train-your-own-reasoning-model-with-grpo](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo) {% endcontent-ref %} {% endcolumn %} {% column %} {% content-ref url="reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl" %} [vision-reinforcement-learning-vlm-rl](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl) {% endcontent-ref %} {% endcolumn %} {% endcolumns %} {% hint style="info" %} Pour la **GRPO avancé** documentation sur le batching, la génération et les paramètres d’entraînement, [lisez notre guide !](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/advanced-rl-documentation) {% endhint %} ### Notebooks GRPO : | [**Gemma 4 E2B**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_$E2B$_Reinforcement_Learning_Sudoku_Game.ipynb) - **nouveau** | [Qwen3-VL-8B](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_VL_$8B$-Vision-GRPO.ipynb) - Vision GSPO | [Gemma 3 (4B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3_$4B$-Vision-GRPO.ipynb) - Vision GSPO | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | | [**Qwen3.5 (4B)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_5_$4B$_Vision_GRPO.ipynb) **- Vision - *****nouveau*** | [gpt-oss-20b](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/gpt-oss-$20B$-GRPO.ipynb) GSPO | [Llama 3.2 (3B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Advanced_Llama3_2_$3B$_GRPO_LoRA.ipynb) - Avancé | | [Qwen3 (4B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_$4B$-GRPO.ipynb) - Avancé | [Phi-4 (14B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Phi_4_$14B$-GRPO.ipynb) | [DeepSeek-R1-0528-Qwen3-8B](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/DeepSeek_R1_0528_Qwen3_$8B$_GRPO.ipynb) | | [Mistral v0.3 (7B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Mistral_v0.3_$7B$-GRPO.ipynb) | [Llama 3.1 (8B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3.1_$8B$-GRPO.ipynb) | [Qwen3-8B - **FP8**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_8B_FP8_GRPO.ipynb) (L4) | {% hint style="success" %} Nous prenons en charge [**GSPO**](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/advanced-rl-documentation/gspo-reinforcement-learning) et la plupart des autres nouvelles techniques GRPO. Vous pouvez jouer avec les arguments suivants dans GRPOConfig pour activer : ```python epsilon=0.2, epsilon_high=0.28, # unilatéral delta=1.5 # bilatéral loss_type='gspo', # ou : loss_type='grpo', # ou : loss_type='dr_grpo', mask_truncated_completions=True, ``` {% endhint %} * 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](#reward-functions-verifier) fonctionne. Nous fournissons des exemples de fonctions de récompense [ici](#reward-function-examples). * Les démonstrations précédentes montrent que vous pouviez obtenir votre propre moment « aha » avec Qwen2.5 (3B), mais cela nécessitait 2 GPU A100 (160 Go de VRAM). Maintenant, avec Unsloth, vous pouvez obtenir le même moment « aha » en utilisant seulement un seul GPU de 5 Go 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**](#grpo-requirement-guidelines) par exemple avec 8 générations par prompt, Unsloth n’utilise que 54,3 Go de VRAM pour Llama 3.1 (8B), alors que les implémentations standard (+ Flash Attention 2) utilisent **510,8 Go (90 % de moins pour Unsloth)**. * Veuillez noter qu’il ne s’agit pas ici d’un fine-tuning des modèles distillés R1 de DeepSeek ni de l’utilisation des données distillées de R1 pour l’ajustement, ce qu’Unsloth prenait déjà en charge. Il s’agit de convertir un modèle standard en un véritable modèle de raisonnement à l’aide de GRPO. Dans un exemple de test, même si nous n’avons entraîné Phi-4 que pendant 100 étapes avec GRPO, les résultats sont déjà clairs. Le modèle sans GRPO n’a pas le jeton de pensée, tandis que celui entraîné avec GRPO l’a et possède aussi la bonne réponse.

## :computer:Entraînement avec GRPO Pour un tutoriel sur la façon de transformer n’importe quel LLM ouvert en modèle de raisonnement à l’aide d’Unsloth et de GRPO, [voir ici](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo). {% hint style="success" %} Pour la **GRPO avancé** documentation sur le batching, la génération et les paramètres d’entraînement, [lisez notre guide !](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/advanced-rl-documentation) {% endhint %} ### **Comment GRPO entraîne un modèle** 1. Pour chaque paire question-réponse, le modèle génère plusieurs réponses possibles (par ex., 8 variantes). 2. Chaque réponse est évaluée à l’aide de fonctions de récompense. 3. Étapes d’entraînement : * Si vous avez 300 lignes de données, cela fait 300 étapes d’entraînement (ou 900 étapes si l’entraînement se fait sur 3 époques). * Vous pouvez augmenter le nombre de réponses générées par question (par ex., de 8 à 16). 4. Le modèle apprend en mettant à jour ses poids à chaque étape. {% hint style="warning" %} Si vous rencontrez des problèmes parce que votre modèle GRPO n’apprend pas, nous vous recommandons vivement d’utiliser nos [notebooks GRPO avancés](https://unsloth.ai/docs/fr/unsloth-notebooks#grpo-reasoning-notebooks) car ils ont une bien meilleure fonction de récompense et vous devriez voir des résultats beaucoup plus rapidement et plus fréquemment. {% endhint %} ### Bases/Conseils * Attendez au moins **300 étapes** pour que la récompense augmente réellement. Afin d’obtenir des résultats décents, vous devrez peut-être y consacrer 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 seulement 10 lignes de données, mais il est préférable d’en avoir davantage. * Chaque entraînement sera toujours différent 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 avons indiqué comme minimum, parfois il peut s’agir de 1000 étapes ou plus. Cela dépend donc de divers facteurs. * Si vous utilisez GRPO avec Unsloth localement, veuillez aussi faire un « 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,5 milliard de paramètres** pour générer correctement des jetons de pensée, car les plus petits modèles peuvent ne pas y parvenir. * Pour les [**exigences de VRAM GPU**](#grpo-requirement-guidelines) **de QLoRA 4 bits**, 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 par prudence). Plus la longueur de contexte est élevée, plus la VRAM nécessaire augmente. LoRA en 16 bits utilisera au minimum 4 fois 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**](#gsm8k-reward-functions), 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 modèle de conversation (chat template). * Plus vous entraînez avec GRPO, mieux c’est. Le meilleur atout 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/un excellent vérificateur, et plus le temps d’entraînement est long, meilleur sera votre modèle. Attendez-vous à ce que votre récompense par étape augmente avec le temps comme ceci :

* Le suivi de la loss d’entraînement pour GRPO est désormais intégré directement dans Unsloth, éliminant le besoin d’outils externes comme wandb, etc. Il contient maintenant tous les détails de journalisation pour toutes les fonctions de récompense, y compris la fonction de 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 non pris en charge par vLLM, comme [Qwen3.5](https://unsloth.ai/docs/fr/modeles/qwen3.5/fine-tune). Réglez simplement `fast_inference=False` lors du chargement du modèle. ```python from unsloth import FastLanguageModel model, tokenizer = FastLanguageModel.from_pretrained( model_name="unsloth/Qwen3.5-4B", fast_inference=False, ) ``` ## :clipboard:Fonctions de récompense / Vérificateurs En apprentissage par renforcement, une **fonction de récompense** et un **vérificateur** jouent des rôles distincts dans l’évaluation de la sortie d’un modèle. En général, on peut les interpréter comme la même chose, toutefois, techniquement ce n’est pas le cas, 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. * Elle n’attribue pas de score numérique — elle vérifie simplement la correction. * Exemple : si un modèle génère « 5 » pour « 2+2 », le vérificateur le contrôle et le classe comme « faux » (puisque la bonne réponse 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 é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 peut recevoir un score positif (+1, +2). * Elle peut aussi pénaliser sur la base de critères autres que la correction, comme 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 lui-même la correction. * Une fonction de récompense *peut* utiliser un vérificateur, mais ils ne sont techniquement 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 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 progressive. * **Le fine-tuning classique** (sans GRPO) **maximise uniquement la probabilité de prédiction du mot suivant** mais n’optimise pas pour une récompense. GRPO **optimise 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 dans un large éventail de cas d’utilisation, ou vous pouvez demander à ChatGPT / un modèle local de les générer pour vous. * Il n’existe pas une seule bonne façon de concevoir des fonctions de récompense ou des vérificateurs — les possibilités sont infinies. Cependant, ils doivent être bien conçus et pertinents, car des récompenses mal conçues peuvent involontairement dégrader les performances du modèle. ### :coin:Exemples de fonctions de récompense Vous pouvez vous référer aux exemples ci-dessous. Vous pouvez envoyer vos générations à un LLM comme ChatGPT 4o ou Llama 3.1 (8B) et concevoir une fonction de récompense et un vérificateur pour les évaluer. Par exemple, envoyez vos générations à un LLM de votre choix et définissez une règle : « Si la réponse semble trop robotique, retirez 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 bonne réponse → **+3** * Si incorrect → **-3** * **Récompense totale :** *Somme de toutes les fonctions de récompense* #### **Exemple n°2 : tâche d’automatisation des 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 de proximité Unsloth Si vous avez consulté notre [**Notebook Colab GRPO avancé**](#grpo-notebooks), vous remarquerez que nous avons créé une **fonction de récompense personnalisée basée sur la proximité** construite entièrement 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 à apprendre uniquement le format * Améliorez la précision de l’é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 `think`, par ex. `` * Appliquez un score 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 de [@willccbb](https://x.com/willccbb) qui sont populaires et se sont révélées assez efficaces : * **correctness\_reward\_func** – Récompense les correspondances exactes avec l’étiquette. * **int\_reward\_func** – Encourage les réponses composées uniquement d’entiers. * **soft\_format\_reward\_func** – Vérifie la structure mais permet de légers écarts de sauts 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. ## :abacus:Utilisation de vLLM Vous pouvez désormais utiliser [vLLM](https://github.com/vllm-project/vllm/) directement dans votre pile de fine-tuning, ce qui permet un débit bien plus élevé et vous permet de fine-tuner et de faire de l’inférence sur le modèle en même temps ! Sur 1x A100 40 Go, attendez-vous à environ 4000 jetons/s avec la quantification dynamique 4 bits d’Unsloth pour Llama 3.2 3B Instruct. Sur une Tesla T4 16 Go (GPU Colab gratuit), vous pouvez obtenir 300 jetons/s.\ \ Nous avons aussi supprimé magiquement la double consommation mémoire lors du chargement simultané de vLLM et d’Unsloth, ce qui permet d’économiser environ 5 Go pour Llama 3.1 8B et 3 Go pour Llama 3.2 3B. À l’origine, Unsloth pouvait fine-tuner Llama 3.3 70B Instruct sur un GPU de 48 Go, les poids de Llama 3.3 70B occupant 40 Go de VRAM. Si nous ne supprimons pas la double consommation mémoire, alors nous aurons besoin de >= 80 Go de VRAM lors du chargement conjoint d’Unsloth et de vLLM.\ \ Mais avec Unsloth, vous pouvez toujours fine-tuner et bénéficier d’une inférence rapide dans un seul outil avec moins de 48 Go de VRAM ! Pour utiliser l’inférence rapide, installez d’abord vllm, puis instanciez Unsloth avec fast\_inference : ```python # pip install unsloth vllm from unsloth import FastLanguageModel model, tokenizer = FastLanguageModel.from_pretrained( model_name = "unsloth/Llama-3.2-3B-Instruct", fast_inference = True, ) ``` ## :white\_check\_mark:Directives relatives aux 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 grâce à plusieurs astuces ! Sur des longueurs de contexte de 20K par exemple avec 8 générations par prompt, Unsloth n’utilise que **54,3 Go de VRAM pour Llama 3.1 8B**alors que les implémentations standard utilisent **510,8 Go (90 % de moins pour Unsloth)**. 1. Pour les **Exigences de VRAM GPU pour QLoRA 4 bits**, 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 par prudence). Plus la longueur de contexte est élevée, plus la VRAM nécessaire augmente. LoRA en 16 bits utilisera au minimum 4 fois plus de VRAM. 2. Nos nouveaux noyaux linéaires économes en mémoire pour GRPO réduisent l’utilisation de la mémoire d’un facteur 8 ou plus. Cela économise 68,5 Go de mémoire, tout en étant en réalité plus rapide grâce à torch.compile ! 3. Nous exploitons notre [gradient checkpointing Unsloth](https://unsloth.ai/blog/long-context) 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 que 1 % plus lent. Cela économise 52 Go de mémoire. 4. 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 16 Go de mémoire. | Métriques | Unsloth | Standard + FA2 | | -------------------------------------------------------------- | ------------------------ | -------------- | | Coût mémoire d’entraînement (Go) | 42 Go | 414 Go | | Coût mémoire GRPO (Go) | 9,8 Go | 78,3 Go | | Coût d’inférence (Go) | 0 Go | 16 Go | | Cache KV d’inférence pour une longueur de contexte de 20K (Go) | 2,5 Go | 2,5 Go | | Utilisation totale de la mémoire | 54,33 Go (90 % de moins) | 510,8 Go | Dans les implémentations GRPO standard typiques, vous devez créer 2 logits de taille (8, 20K) pour calculer la loss GRPO. Cela représente 2 \* 2 octets \* 8 (nombre de générations) \* 20K (longueur de contexte) \* 128256 (taille du vocabulaire) = 78,3 Go de VRAM. Unsloth réduit l’utilisation de la mémoire d’un facteur 8 pour le GRPO à long contexte, nous n’avons donc besoin que de 9,8 Go de VRAM supplémentaires pour des longueurs de contexte de 20K ! Nous devons aussi utiliser le 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 de mémoire pour une longueur de contexte de 20K = 2 \* 2 octets \* 32 couches \* 20K longueur de contexte \* 1024 = 2,5 Go par lot. Nous fixerions la taille du lot de vLLM à 8, mais nous la laisserons à 1 pour nos calculs afin d’économiser de la VRAM. Sinon, vous aurez besoin de 20 Go pour le cache KV. ## 🎥 Vidéo de l’atelier RL Unsloth de 3 heures {% embed url="" %} ## :mortar\_board:Lectures complémentaires 1. Le livre RLHF de Nathan Lambert est indispensable ! 2. La vidéo YouTube de Yannic Kilcher sur GRPO est aussi indispensable ! 3. Nous avons animé un atelier de 3 heures à l’AI Engineer World’s Fair 2025. Les diapositives et autres ressources sont disponibles à 4. Notebook GRPO avancé via Unsloth. 5. Notebook GRPO à partir d’un modèle de base : ## Tutoriels vidéo Voici quelques tutoriels vidéo créés par des YouTubeurs formidables que nous trouvons fantastiques ! {% embed url="" %} {% columns %} {% column width="50%" %} {% embed url="" %} Idéal pour apprendre à préparer votre ensemble de données et comprendre les bases de l’apprentissage par renforcement + GRPO {% endembed %} {% embed url="" %} {% endcolumn %} {% column width="50%" %} {% embed url="" %} {% embed url="" %} GRPO local sur votre propre appareil {% endembed %} {% endcolumn %} {% endcolumns %} --- # Agent Instructions: 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: ``` GET https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide.md?ask= ``` The question should be specific, self-contained, and written in natural language. 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.