Méthode multi-agent REINFORCE

REINFORCE est une classe de méthodes de gradient de politique qui optimise directement la politique en utilisant des retours échantillonnés. Ces méthodes sont largement utilisées pour le réglage fin de LLM en raison de leur simplicité et de leur efficacité. Des exemples incluent GRPO, Dr. GRPO, RLOO, ReMax, TreeRPO, et REINFORCE++. REINFORCE peut être étendu aux environnements multi-agent, où plusieurs agents LLM réagissent à chaque tour et leurs réponses conjointes reçoivent une récompense partagée.

Tous MAREINFORCE trainers un seul cycle d’entraînement. À chaque rollout nœud, chaque agent échantillonne $$ K $$ réponses, le trainer calcule les scores des réponses conjointes alignées par index avec une récompense partagée, et chaque agent pondère ses propres probabilités logarithmiques par les avantages partagés résultants avant une étape d’optimiseur tamponnée.

Flux d'entraînement de MAREINFORCE Chaque échantillon conjoint génère une récompense partagée ; son poids d'avantage attribue un gradient de politique à chaque agent.

MAREINFORCE#

Le surrogate de gradient de politique pour Multi-Agent REINFORCE (MAREINFORCE), avant la normalisation des avantages ou la régularisation de référence, peut être exprimé comme :

J(\theta_i) = \mathbb{E}_{\mathbf{o}_0 \sim \mathcal{D}, \mathbf{h}_t \sim \boldsymbol{\pi}_{\boldsymbol{\theta}}} \Bigg[\sum_{t=0}^{H-1} R_t \cdot \log \pi_{\theta_i}(a_{i,t}\mid h_{i,t})\Bigg],

où

\( R_t \)

est le retour au tour

\( t \)

\( H \)

est l’horizon (c’est-à-dire le nombre de tours de dialogue). L’attente est calculée à partir des observations initiales du jeu de données

\mathcal{D}

et de l’historique des actions conjointes de tous les episodes selon la politique

\boldsymbol{\pi}_{\boldsymbol{\theta}}

Les méthodes REINFORCE n’utilisent pas un modèle critic pour l’estimation de la valeur. Leurs estimations de gradient de politique peuvent avoir une grande variance en raison de l’échantillonnage stochastique et de l’attribution à long terme. Les approches courantes pour réduire cette variance comprennent l’utilisation d’une base indépendante de l’action ou la moyenne sur plus d’échantillons, comme les échantillons $$ K $$ à chaque historique conjoint $\mathbf{h}_t$ .

J(\theta_i) = \mathbb{E}_{\mathbf{o}_0 \sim \mathcal{D}, \mathbf{h}_t \sim \boldsymbol{\pi}_{\boldsymbol{\theta}}} \Bigg[\frac{1}{K}\sum_{k=1}^{K} \sum_{t=0}^{H-1} \left(R^{k}_t - b(\mathbf{h}_t)\right) \cdot \log \pi_{\theta_i}(a^{k}_{i,t}\mid h_{i,t})\Bigg],

où la base

b(\mathbf{h}_t)

est indépendante de l’action.

MAGRPO#

L’optimisation de la politique multi-agent, relative au groupe (Multi-Agent Group-Relative Policy Optimization) (MAGRPO) est une implémentation de MAREINFORCE inspirée de GRPO, où la base moyenne du groupe est la moyenne des retours des échantillons $$ K $$ . Dans le mode conjoint par défaut aligned, sa surrogate avant la normalisation de l’avantage est:

J(\theta_i) = \mathbb{E}_{\mathbf{o}_0 \sim \mathcal{D}, \mathbf{h}_t \sim \boldsymbol{\pi}_{\boldsymbol{\theta}}} \Bigg[\frac{1}{K}\sum_{k=1}^{K}\sum_{t=0}^{H-1} \left(R^{k}_t - \frac{1}{K}\sum_{l=1}^{K}R^{l}_t\right) \cdot \log \pi_{\theta_i}(a^{k}_{i,t}\mid h_{i,t})\Bigg].

La moyenne du groupe échantillonnée inclut l’échantillon mis à jour, il ne s’agit donc pas de la base indépendante de l’action supposée dans l’expression générale ci-dessus. Dans l’entraînement multi-tours, le retour de chaque branche est sa récompense immédiate plus la moyenne des retours de son nœud enfant, sans facteur d’actualisation. Dans le mode cross, chaque agent reçoit la somme des retours sur toutes les combinaisons conjointes contenant cette complétion.

Par défaut, advantage_normalization=True centre et met à l’échelle les avantages au sein de chaque groupe de génération à l’aide de l’écart type de la population, avec un dénominateur minimum de 1e-6. Si la régularisation de référence KL est activée, la pénalité de référence échantillonnée est soustraite des retours avant que la base et la normalisation ne soient appliquées.

La tranche de perte MAGRPOTrainer actuelle omet la complétion finale token, de sorte que son score de séquence mis en œuvre diffère de la probabilité de séquence complète dans le substitut ci-dessus. La configuration canonique est joint_mode="cross" ; l’alias accepté "crossed" génère des combinaisons cartésiennes, mais n’applique pas la même agrégation de retour par complétion.

MAGRPOConfig Paramètres

num_agents : Nombre d’agents configuré, qui doit correspondre à la configuration trainer
num_turns : Nombre de tours par episode
num_train_epochs : Nombre d’époques d’entraînement epochs
agent_learning_rate : Taux d’apprentissage
logging_steps : Intervalle de journalisation en pas
num_generations : Nombre de générations à échantillonner par requête pour chaque agent
max_new_tokens : Nombre maximal de nouvelles tokens à générer
temperature : Température pour l’échantillonnage
top_p : Top-p pour l’échantillonnage
top_k : Top-k pour l’échantillonnage
discount : Champ de configuration conservé ; l’implémentation actuelle MAGRPO calcule des retours non dépréciés et ne l’utilise pas
joint_mode : Composition d’actions conjointes (aligned pour l’alignement sur l’index, cross pour le produit cartésien)
early_termination_threshold : Une branche d’entraînement cesse de s’étendre lorsque la récompense immédiate moyenne du nœud dépasse ce seuil (valeur par défaut -0.2 ; None désactive l’arrêt précoce)
rollout_buffer_size : Nombre d’échantillons de nœuds à mettre en mémoire par agent avant une mise à jour
train_batch_size : Nombre d’échantillons de nœuds par étape de l’optimiseur ; valeur par défaut rollout_buffer_size
advantage_normalization : Que centrer et mettre à l’échelle les avantages au sein de chaque groupe de génération du nœud (valeur par défaut True)
eval_interval : Les évaluations se déroulent aux indices de lots divisibles par N, y compris le premier lot de chaque epoch ; 0 désactive l’évaluation périodique
eval_num_samples : Nombre d’échantillons à évaluer par exécution d’évaluation
eval_batch_size : Taille du lot d’évaluation DataLoader
external_prompt_passthrough : Utiliser directement les invites externes dans l’entraînement multi-tours
advantage_mode : Mode de base (mean, max, rloo, raw)
parallel_training : Mode d’exécution de l’agent (none ou mp)
agent_devices: Placement de l’appareil ; requis explicitement pour parallel_training="mp"
reference_kl_enabled: Activer une pénalité de référence gelée KL (valeur par défaut False)
reference_kl_coef: Poids de la pénalité de référence (valeur par défaut 0.1)
reference_devices: Placement de l’appareil optionnel pour les modèles de référence

MAGRPOTrainer Paramètres

agent_model ou agents: Chaîne d’identifiant de modèle pour les agents homogènes, ou une liste d’identifiants de modèles ou de modèles préchargés ; les modèles préchargés sont fournis via agents
num_agents: Nombre d’agents créés à partir de agent_model (valeur par défaut 2), configuré indépendamment de args. Lorsque seul agents est fourni, sa longueur détermine le nombre d’agents
tokenizer: Partagé tokenizer ou un par agent ; facultatif pour les identifiants de modèles, requis pour les modèles préchargés
reward_func: Fonction qui renvoie une liste de nombres à virgule flottante (requis)
reward_processor: Fonction optionnelle à appliquer aux récompenses (par exemple, mise à l’échelle)
formatters: Fonction unique ou liste de fonctions par agent pour le formatage des invites
args: Instance de MAGRPOConfig (facultatif)
train_dataset: Ensemble de données requis lors de l’appel à train()
eval_dataset: Ensemble de données d’évaluation (facultatif)
model_config: Dictionnaire de configuration du modèle (facultatif)
wandb_config: Configuration de la journalisation pour Weights & Biases (facultatif)
external_transition: Fonction fournissant les transitions entre les tours; requis lors de l’appel à num_turns > 1 (la valeur par défaut est 2)
eval_logger: Callback facultatif pour les métriques de tâche, appelé comme eval_logger(agent_completions_turns=..., batch_items=..., prompts=...); renvoie un dictionnaire de métriques pour chaque élément évalué et est utilisé avec eval_aggregator
eval_aggregator: Callback facultatif, appelé comme eval_aggregator(metrics, num_turns=...); les métriques turn_k/... renvoyées sont enregistrées sous eval/. Les deux callbacks d’évaluation doivent être fournis pour les métriques personnalisées

MAGRPO collecte des échantillons dans un tampon rollout et recalcule leurs probabilités logarithmiques lors des mises à jour, sans importance ni troncage des ratios. Les échantillons peuvent donc prédater les mises à jour antérieures du même tampon ou de l’arbre rollout. Puisque le trainer n’a pas de modèle critic, value_clip_range n’est pas applicable.

Le trainer utilise une formation fixe DataLoader taille de lot de 1 et nécessite au moins num_generations=2, y compris pour la variante de retour brut. Par défaut, train_batch_size=rollout_buffer_size: chaque agent calcule la moyenne des pertes des échantillons de nœuds en mémoire tampon pour une étape d’optimisation. Des mini-lots plus petits produisent plusieurs étapes d’optimisation ; un tampon partiel est vidé à la fin de chaque epoch.

Autres variantes#

CoMLRL fournit également d’autres variantes MAREINFORCE avec différentes bases:

MARLOO: Multi-Agent REINFORCE Leave-One-Out. La base est la moyenne des retours des autres générations dans le même groupe d’échantillons du nœud, et non des autres agents.

J(\theta_i) = \mathbb{E}_{\mathbf{o}_0 \sim \mathcal{D}, \mathbf{h}_t \sim \boldsymbol{\pi}_{\boldsymbol{\theta}}} \Bigg[\frac{1}{K}\sum_{k=1}^{K}\sum_{t=0}^{H-1} \left(R^{k}_t - \frac{1}{K-1}\sum_{l=1, l\neq k}^{K}R^{l}_t\right) \cdot \log \pi_{\theta_i}(a^{k}_{i,t}\mid h_{i,t})\Bigg].

MAReMax: Agent multi-agent REINFORCE avec Max par groupe (MAReMaxConfig et MAReMaxTrainer). La valeur de référence est le retour maximal du groupe échantillonné au nœud ; cette implémentation ne génère pas de réponse de référence égoïste séparée.

J(\theta_i) = \mathbb{E}_{\mathbf{o}_0 \sim \mathcal{D}, \mathbf{h}_t \sim \boldsymbol{\pi}_{\boldsymbol{\theta}}} \Bigg[\frac{1}{K}\sum_{k=1}^{K}\sum_{t=0}^{H-1} \left(R^{k}_t - \mathrm{max}_l\, R^l_t \right) \cdot \log \pi_{\theta_i}(a^{k}_{i,t}\mid h_{i,t})\Bigg].

MAREINFORCETrainer, MARLOOTrainer, et MAReMaxTrainer dérivent de comlrl.trainers.reinforce.MAGRPOTrainer. Leurs classes de configuration correspondantes héritent MAGRPOConfig, avec des valeurs par défaut advantage_mode des raw, rloo, et max, respectivement. Elles partagent la même trainer interface et champs de configuration.

Les quatre trainers diffèrent uniquement par la valeur de référence soustraite. Pour un nœud avec des réponses conjointes $$ K=4 $$ , l’animation ci-dessous compare leurs avantages avant la normalisation : MAREINFORCE conserve le retour brut, comme dans REINFORCE ; MAGRPO soustrait la moyenne du groupe, comme dans GRPO ; MARLOO soustrait la moyenne des autres $$ K-1 $$ , comme dans RLOO, ce qui met à l’échelle les avantages MAGRPO par $$ K/(K-1) $$ ; et MAReMax soustrait le maximum du groupe, de sorte qu’aucune réponse ne reçoive un avantage positif.

Baselines sur les variantes de MAREINFORCE Chaque ligne soustrait une baseline différente de la même récompense partagée ; les barres en nuance indiquent les avantages avant la normalisation.

Les formules variant décrivent les avantages avant la normalisation. Toutes les variantes héritent de advantage_normalization=True, qui recentre même les retours bruts et les avantages basés sur le maximum. À l’exception de la limite de l’écart type et de la précision numérique, les quatre modes produisent ensuite les mêmes avantages normalisés. Les utilisateurs peuvent conserver les différences de référence affichées ci-dessus, y compris l’estimateur de retour brut MAREINFORCE, en définissant advantage_normalization=False.