🧩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 regroupement, les paramètres de génération et d'entraînement :

Paramètres d'entraînement

• bêta (float, défaut 0.0): coefficient KL.

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

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

• num_iterations (int, 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 exemple, 2 = deux passes avant par étape d'accumulation.

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

• delta (float, optionnel): Active borne de clipping pour GRPO bilatéral lorsqu'il est défini. Si Aucun, le clipping GRPO standard est utilisé. Recommandé > 1 + ε lorsqu'activé (selon le rapport INTELLECT-2).

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

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

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

  • "sequence": moyenne des rapports par token en un seul rapport 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 des récompenses au niveau de la séquence.

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

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

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

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

  • False ou "none": aucune mise à l'échelle. Le Dr. GRPO recommande de ne pas mettre à l'échelle pour éviter un biais de difficulté provenant de la mise à l'échelle par l'écart-type.

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

  • "grpo": normalise selon 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 quand per_device_train_batch_size == 1).

• mask_truncated_completions (bool, 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, nous recommandons donc de le désactiver.

  # Si mask_truncated_completions est activé, mettez à 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()

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

• vllm_importance_sampling_correction (bool, défaut True): Applique Truncated Importance Sampling (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 réglé automatiquement sur True si vous utilisez vLLM/fast_inference ; sinon False.

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

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

Paramètres de génération

• temperature (float, défauts à 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 avoir de la diversité dans les générations, ce qui aide l'apprentissage.

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

• top_k (int, optionnel) : Nombre des tokens du vocabulaire ayant la plus grande 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 de 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 se situent dans la plage 0.01-0.2.

• repetition_penalty (float, optionnel, défauts à 1.0) : Float qui pénalise les nouveaux tokens en fonction de leur apparition dans l'invite 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 vaut 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 inférieur à num_generations, il passera 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 uniquement). 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., GPU / workers).

• gradient_accumulation_steps (également appelé gradient_accumulation): Nombre de micro-lots à accumuler avant 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

  Nombre total d'échantillons contribuant aux gradients avant une mise à jour (à travers tous les processus et étapes).

• Pas d'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 invite (appliqué après au calcul de effective_batch_size). Le nombre de invites 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 lots 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	Terminal Bench 2
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	Terminal Bench 2
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	Terminal Bench 2
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	Terminal Bench 2
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	Terminal Bench 2
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	Terminal Bench 2
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	Terminal Bench 2
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	Terminal Bench 2
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