🧩Documentation avancée sur l'apprentissage par renforcement

Paramètres de documentation avancés lors de l'utilisation d'Unsloth avec GRPO.

Guides détaillés sur la réalisation de GRPO avec Unsloth pour le batching, la génération et les paramètres d'entraînement :

Paramètres d'entraînement

• beta (float, par défaut 0.0): coefficient KL.

  • 0.0 ⇒ aucun modèle de référence chargé (mémoire moindre, plus rapide).

  • Plus élevé beta contraint la politique à rester plus proche de la politique de référence.

• num_iterations (int, par défaut 1): Époques PPO par lot (μ dans l'algorithme). Rejoue les données à l'intérieur de chaque étape d'accumulation de gradient ; par ex., 2 = deux passes avant par étape d'accumulation.

• epsilon (float, par défaut 0.2): Valeur de clipping pour les rapports de log-prob au niveau du token (plage typique de ratio ≈ [-1.2, 1.2] avec ε par défaut).

• delta (float, optionnel): Active borne de clipping pour GRPO à deux côtés lorsqu'elle est définie. Si None, le clipping GRPO standard est utilisé. Recommandé > 1 + ε lorsqu'activé (selon le rapport INTELLECT-2).

• epsilon_high (float, optionnel): Epsilon borne supérieure ; par défaut epsilon si non défini. DAPO recommande 0.28.

• importance_sampling_level ("token" | "sequence", par défaut "token"):

  • "token": rapports bruts par token (un poids par token).

  • "sequence": moyenne des rapports par token en un seul ratio au niveau de la séquence. GSPO montre que l'échantillonnage au niveau de la séquence donne souvent un entraînement plus stable pour les récompenses au niveau de la séquence.

• reward_weights (list[float], optionnel): Un poids par récompense. Si None, tous les poids = 1.0.

• scale_rewards (str|bool, par défaut "group"):

  • True ou "group": mettre à l'échelle par écart-type au sein de chaque groupe (variance unité dans le groupe).

  • "batch": mettre à l'échelle par écart-type sur l'ensemble du lot (par PPO-Lite).

  • False ou "none": pas de mise à l'échelle. Le Dr. GRPO recommande de ne pas mettre à l'échelle afin d'éviter le biais de difficulté introduit par la mise à l'échelle par écart-type.

• loss_type (str, par défaut "dapo"):

  • "grpo": normalise par la longueur de la séquence (biais de longueur ; non recommandé).

  • "dr_grpo": normalise par une constante globale (introduite dans Dr. GRPO ; supprime le biais de longueur). Constante ≈ max_completion_length.

  • "dapo" (par défaut): normalise par tokens actifs dans le lot accumulé global (introduit dans DAPO ; supprime le biais de longueur).

  • "bnpo": normalise par tokens actifs dans le lot local seulement (les résultats peuvent varier selon la taille du lot local ; équivaut à GRPO lorsque per_device_train_batch_size == 1).

• mask_truncated_completions (bool, par défaut False): Lorsque True, les complétions tronquées sont exclues de la perte (recommandé par DAPO pour la stabilité). Remarque: Il existe quelques problèmes de KL avec ce drapeau, donc nous recommandons de le désactiver.

  # Si mask_truncated_completions est activé, mettre à zéro les complétions tronquées dans completion_mask
  if self.mask_truncated_completions:
      truncated_completions = ~is_eos.any(dim=1)
      completion_mask = completion_mask * (~truncated_completions).unsqueeze(1).int()

  Ceci peut mettre à zéro tous les completion_mask entrées lorsque de nombreuses complétions sont tronquées, rendant n_mask_per_reward = 0 et faisant que le KL devienne NaN. Voir

• vllm_importance_sampling_correction (bool, par défaut True): Applique l'échantillonnage d'importance tronqué (TIS) pour corriger les effets hors-politique lorsque la génération (par ex., vLLM / fast_inference) diffère du backend d'entraînement. Dans Unsloth, ceci est automatiquement défini sur True si vous utilisez vLLM/fast_inference ; sinon False.

• vllm_importance_sampling_cap (float, par défaut 2.0): Paramètre de troncature C pour le TIS ; fixe une borne supérieure sur le ratio d'échantillonnage d'importance pour améliorer la stabilité.

• dtype lors du choix float16 ou bfloat16, voir FP16 vs BF16 pour le RL

RL sur des modèles non pris en charge :

Vous pouvez également exécuter le 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.

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Qwen3.5-4B",
    fast_inference=False,
)

Paramètres de génération

• temperature (float, par défaut 1.0) : Température pour l'échantillonnage. Plus la température est élevée, plus les complétions sont aléatoires. Assurez-vous d'utiliser une température relativement élevée (1.0) pour obtenir de la diversité dans les générations, ce qui aide l'apprentissage.

• top_p (float, optionnel, par défaut 1.0) : Float qui contrôle la probabilité cumulative des meilleurs tokens à considérer. Doit être dans (0, 1]. Mettre à 1.0 pour considérer tous les tokens.

• top_k (int, optionnel) : Nombre des tokens du vocabulaire avec la plus haute probabilité à conserver pour le filtrage top-k. Si None, le filtrage top-k est désactivé et tous les tokens sont considérés.

• min_p (float, optionnel) : Probabilité minimale du token, qui sera mise à l'échelle par la probabilité du token le plus probable. Elle doit être une valeur entre 0.0 et 1.0. Les valeurs typiques sont dans la plage 0.01-0.2.

• repetition_penalty (float, optionnel, par défaut 1.0) : Float qui pénalise les nouveaux tokens en fonction de leur apparition dans le prompt et le texte généré jusqu'à présent. Les valeurs > 1.0 encouragent le modèle à utiliser de nouveaux tokens, tandis que les valeurs < 1.0 encouragent le modèle à répéter des tokens.

• steps_per_generation : (int, optionnel) : Nombre d'étapes par génération. Si None, il est par défaut à gradient_accumulation_steps. Mutuellement exclusif avec generation_batch_size.

C'est un peu déroutant de jouer avec ce paramètre, il est recommandé de modifier per_device_train_batch_size et l'accumulation de gradient pour les tailles de lot

Paramètres de lot et de débit

Paramètres qui contrôlent les lots

• train_batch_size: Nombre d'échantillons par processus par étape. Si cet entier est moins que num_generations, il sera par défaut à num_generations.

• steps_per_generation: Nombre de micro-lots qui contribuent à le calcul de la perte d'une génération (passes avant seulement). Un nouveau lot de données est généré tous les steps_per_generation steps ; le timing de la rétropropagation dépend de gradient_accumulation_steps.

• num_processes: Nombre de processus d'entraînement distribués (par ex., GPUs / workers).

• gradient_accumulation_steps (aussi appelé gradient_accumulation): Nombre de micro-lots à accumuler avant d'appliquer la rétropropagation et la mise à jour de l'optimiseur.

• Taille de lot effective:

  effective_batch_size = steps_per_generation * num_processes * train_batch_size

  Échantillons totaux contribuant aux gradients avant une mise à jour (à travers tous les processus et étapes).

• Pas de l'optimiseur par génération:

  optimizer_steps_per_generation = steps_per_generation / gradient_accumulation_steps

  Exemple : 4 / 2 = 2.

• num_generations: Nombre de générations produites par prompt (appliqué après le calcul de effective_batch_size). Le nombre de prompts uniques dans un cycle de génération est :

  unique_prompts = effective_batch_size / num_generations

  Doit être > 2 pour que GRPO fonctionne.

Exemples de batchs GRPO

Les tableaux ci-dessous illustrent comment les lots circulent à travers les étapes, quand les mises à jour de l'optimiseur ont lieu, et comment de nouveaux lots sont générés.

Exemple 1

num_gpus = 1
per_device_train_batch_size = 3
gradient_accumulation_steps = 2
steps_per_generation = 4

effective_batch_size = 4 * 3 * 1 = 12
num_generations = 3

Cycle de génération A

Étape	Lot	Remarques
0	[0,0,0]
1	[1,1,1]	→ mise à jour de l'optimiseur (accum = 2 atteint)
2	[2,2,2]
3	[3,3,3]	mise à jour de l'optimiseur

Cycle de génération B

Étape	Lot	Remarques
0	[4,4,4]
1	[5,5,5]	→ mise à jour de l'optimiseur (accum = 2 atteint)
2	[6,6,6]
3	[7,7,7]	mise à jour de l'optimiseur

Exemple 2

num_gpus = 1
per_device_train_batch_size = 3
steps_per_generation = gradient_accumulation_steps = 4

effective_batch_size = 4 * 3 * 1 = 12
num_generations = 3

Cycle de génération A

Étape	Lot	Remarques
0	[0,0,0]
1	[1,1,1]
2	[2,2,2]
3	[3,3,3]	mise à jour de l'optimiseur (accum = 4 atteint)

Cycle de génération B

Étape	Lot	Remarques
0	[4,4,4]
1	[5,5,5]
2	[6,6,6]
3	[7,7,7]	mise à jour de l'optimiseur (accum = 4 atteint)

Exemple 3

num_gpus = 1
per_device_train_batch_size = 3
steps_per_generation = gradient_accumulation_steps = 4

effective_batch_size = 4 * 3 * 1 = 12
num_generations = 4
unique_prompts = effective_batch_size / num_generations = 3

Cycle de génération A

Étape	Lot	Remarques
0	[0,0,0]
1	[0,1,1]
2	[1,1,3]
3	[3,3,3]	mise à jour de l'optimiseur (accum = 4 atteint)

Cycle de génération B

Étape	Lot	Remarques
0	[4,4,4]
1	[4,5,5]
2	[5,5,6]
3	[6,6,6]	mise à jour de l'optimiseur (accum = 4 atteint)

Exemple 4

num_gpus = 1
per_device_train_batch_size = 6
steps_per_generation = gradient_accumulation_steps = 2

effective_batch_size = 2 * 6 * 1 = 12
num_generations = 3
unique_prompts = 4

Cycle de génération A

Étape	Lot	Remarques
0	[0,0,0, 1,1,1]
1	[2,2,2, 3,3,3]	mise à jour de l'optimiseur (accum = 2 atteint)

Cycle de génération B

Étape	Lot	Remarques
0	[4,4,4, 5,5,5]
1	[6,6,6, 7,7,7]	mise à jour de l'optimiseur (accum = 2 atteint)

Référence rapide des formules

effective_batch_size = steps_per_generation * num_processes * train_batch_size
optimizer_steps_per_generation = steps_per_generation / gradient_accumulation_steps
unique_prompts = effective_batch_size / num_generations   # doit être > 2