Vue d'ensemble on CoMLRL

Aide

Mon, 01 Jan 0001 00:00:00 +0000

Aide#

Nous sommes heureux de vous aider en cas de problèmes rencontrés lors de l’utilisation de CoMLRL.

Signaler les problèmes#

Les étapes suivantes peuvent aider les utilisateurs à résoudre ou à signaler un problème :

Les utilisateurs peuvent d’abord consulter la documentation, y compris la fonction de recherche (Ctrl + K).
Une recherche des problèmes existants GitHub peut révéler des rapports du même problème.
Un exemple minimal reproductible aide à diagnostiquer le problème. Quelques lignes de code qui démontrent le problème peuvent conduire à une réponse plus rapide.

Écriture

Mon, 01 Jan 0001 00:00:00 +0000

Entraînement basé sur le ratio de longueur

Mon, 01 Jan 0001 00:00:00 +0000

Ce tutoriel démontre une tâche d’entraînement simple avec deux agents, utilisant une récompense basée sur le ratio de longueur. Les deux agents reçoivent la même requête et génèrent indépendamment ; le second agent ne voit pas la réponse du premier. La récompense encourage la seconde sortie à contenir 2–3× plus de caractères que la première. Elle ne évalue pas la qualité de l’histoire ou la collaboration sémantique.

Les utilisateurs peuvent exécuter l’exemple à partir d’un dépôt installé :

Installation

Mon, 01 Jan 0001 00:00:00 +0000

CoMLRL peut être installé à partir de PyPI, conda-forge, ou source et prend en charge Python 3.10 ou supérieur. Les utilisateurs doivent également installer une version de PyTorch compatible avec leur appareil.

Installation à partir de PyPI#

pip install comlrl
# Install PyTorch compatible with your device.

Installation à partir de conda-forge#

conda install -c conda-forge comlrl
# Install PyTorch compatible with your device.

Installation à partir de source#

Les utilisateurs peuvent également cloner le dépôt et installer CoMLRL en mode éditable pour accéder aux dernières fonctionnalités ou le développer localement:

Méthode multi-agent REINFORCE

Mon, 01 Jan 0001 00:00:00 +0000

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.

Reprendre l'entraînement

Mon, 01 Jan 0001 00:00:00 +0000

Cet exemple entraîne deux petits agents pour deux epochs, puis poursuit la même exécution pour deux autres epochs à partir d’un point de contrôle. Les deux parties sont enregistrées dans une seule exécution W&B.

Configuration#

La tâche demande au deuxième agent d’écrire une réponse de 2 à 3 fois plus longue que la réponse du premier agent.

import math
from pathlib import Path

from datasets import Dataset
from transformers import AutoModelForCausalLM, AutoTokenizer
from comlrl.trainers.reinforce import MAGRPOConfig, MAGRPOTrainer
from comlrl.utils import read_checkpoint_metadata

model_name = "Qwen/Qwen2.5-0.5B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
train_dataset = Dataset.from_dict({
 "prompt": [
 "Describe a city in the clouds:",
 "Invent a new holiday and explain it:",
 "Write a bedtime story for a dragon:",
 "Design a playground on Mars:",
 ]
})


def length_ratio_reward(completions1, completions2):
 rewards = []
 for first, second in zip(completions1, completions2):
 ratio = len(second) / max(len(first), 1)
 distance = 0.0 if 2 <= ratio <= 3 else min(abs(ratio - 2), abs(ratio - 3))
 rewards.append(math.exp(-distance))
 return rewards

La même fonction construit le trainer pour les deux parties de l’exécution, de sorte que les deux trainers correspondent.

Apprentissage multi-agent Actor-Critic

Mon, 01 Jan 0001 00:00:00 +0000

Les méthodes Actor-Critic (AC) sont des méthodes de gradient de politique largement utilisées qui utilisent critics pour soutenir l’entraînement. Les méthodes AC peuvent obtenir une variance plus faible et une meilleure efficacité d’échantillonnage que REINFORCE, mais cela nécessite une conception et un réglage minutieux de critic pour assurer un entraînement stable. Dans l’apprentissage par renforcement multi-agents (MARL), Actor-Critic les méthodes comprennent Multi-Agent Actor-Critic (MAAC) et Indépendant Actor-Critic (IAC).

Les deux agents mettent en œuvre conjointement et évaluent leur réponse conjointe avec la fonction de récompense, mais utilisent critics différemment. MAAC entraîne un critic sur l’historique conjoint, de sorte que chaque agent partage son TD erreur. IAC entraîne un critic par agent sur l’historique de cet agent, de sorte que chaque agent obtient sa propre TD erreur.

Codage

Mon, 01 Jan 0001 00:00:00 +0000

Contribution

Mon, 01 Jan 0001 00:00:00 +0000

Contribution#

Les contributions à CoMLRL sont les bienvenues. Ce guide couvre les modifications de code et la maintenance du code.

Directives de développement#

Les contributeurs peuvent forker le dépôt principal.

Les commandes suivantes clonent le fork et le synchronisent avec le dépôt principal:

 git clone https://github.com/<your-username>/CoMLRL.git
 cd CoMLRL
 git remote add upstream https://github.com/OpenMLRL/CoMLRL.git
 git fetch upstream
 git checkout -b feature/<short-description> upstream/main
 git fetch upstream && git rebase upstream/main

Les contributeurs peuvent implémenter de nouvelles fonctionnalités ou corriger des bugs et mettre à jour la documentation si nécessaire.
Les modifications peuvent être soumises au dépôt principal sous forme de demande de fusion pour examen.

Entités d'entraînement

Mon, 01 Jan 0001 00:00:00 +0000

CoMLRL prend en charge l’entraînement des agents LLM et facilite leur entraînement avec des modèles de récompense basés sur LLM ou critics. Les agents et critics peuvent être des modèles homogènes ou hétérogènes provenant de Hugging Face ou de répertoires locaux. Les utilisateurs peuvent spécifier les identifiants de modèle Hugging Face via agent_model/critic_model pour les configurations homogènes, ou fournir des listes agents/critics pour les configurations hétérogènes. Les entités entraînées peuvent être enregistrées et chargées dans un nouveau trainer pour un entraînement ultérieur.

Retour sur plusieurs tours

Mon, 01 Jan 0001 00:00:00 +0000

Dans cet exemple, deux agents répondent à une tâche, reçoivent des commentaires sur leurs réponses, puis répondent à nouveau.

Configuration#

La tâche demande au deuxième agent d’écrire une réponse de 2 à 3 fois plus longue que la réponse du premier agent.

import math

from datasets import Dataset
from transformers import AutoModelForCausalLM, AutoTokenizer
from comlrl.trainers.reinforce import MAGRPOConfig, MAGRPOTrainer

model_name = "Qwen/Qwen2.5-0.5B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
train_dataset = Dataset.from_dict({
 "prompt": [
 "Describe a city in the clouds:",
 "Invent a new holiday and explain it:",
 "Write a bedtime story for a dragon:",
 "Design a playground on Mars:",
 ]
})


def length_ratio_reward(completions1, completions2):
 rewards = []
 for first, second in zip(completions1, completions2):
 ratio = len(second) / max(len(first), 1)
 distance = 0.0 if 2 <= ratio <= 3 else min(abs(ratio - 2), abs(ratio - 3))
 rewards.append(math.exp(-distance))
 return rewards

Retour entre les tours#

Après la première étape, cette fonction écrit une nouvelle invite pour chaque agent. L’invite indique la longueur des réponses.

Complétion de code

Mon, 01 Jan 0001 00:00:00 +0000

Historique des modifications

Mon, 01 Jan 0001 00:00:00 +0000

Historique des modifications#

Version 1.4.3#

Prise en charge des algorithmes MAPL, y compris MARLHF et MADPO (PR #72).
Prise en charge de l’entraînement d’un système multi-agent centralisé (PR #72).
Améliorer la documentation.

Version 1.4.2#

Prise en charge de davantage de modèles de comparaison (commit e1b3d80).
Correction du problème de génération homogène (commit 11d89a9).

Version 1.4.1#

Prise en charge de l’utilisation du comparateur en tant que coordinateur centralisé (PR #69).
Permettre le déploiement des agents LLM, du modèle de récompense et du comparateur sur différents appareils (commit 7cbb792).
Permettre la copie des modèles actuels en tant que comparateurs sur de nouveaux appareils (commit d8d493a).
Optimiser l’utilisation de la mémoire de GPU en libérant rapidement les modèles inutilisés (commit d0c6376).

Version 1.4.0#

Ajouter des méthodes en ligne pour PbRL (PR #68).
Ajouter un enregistreur de dérive de jeu de données.

Version 1.3.9#

Ajouter des méthodes hors ligne telles que PbRL, MADPO et MARLHF (PR #67).

Version 1.3.8#

Permettre l’utilisation d’un modèle de référence pour tous les algorithmes (PR #65).
Unifier l’enregistreur entre différents trainers (PR #66).

Version 1.3.7#

Supprimer les hyperparamètres d’échantillonnage redondants dans les algorithmes.
Permettre l’entraînement multi-GPU avec MP (voir les résultats dans PR #62).

Version 1.3.6#

Corriger un bug critique lors du chargement de modèles hétérogènes et refactoriser la logique de chargement des modèles (voir les résultats dans PR #60).
Améliorer la documentation.

Version 1.3.5#

Ajouter des tests unitaires pour les contraintes d’hyperparamètres.
Nettoyer les interfaces héritées.

Version 1.3.4#

Corriger le bug lors du chargement de modèles hétérogènes et refactoriser la logique de chargement.
Activer MBGD dans MAGRPO pour correspondre à MAAC et IAC.
Supprimer les hyperparamètres redondants et hérités (par exemple, les paramètres de modèle, les hyperparamètres de patching).
Nettoyer le code hérité multi-appareil, tel que drop_last et num_workers.
Ajouter des tests unitaires pour le chargement du modèle et les séparer de CI comme un badge.
Nettoyer les fonctions courtes.
Réorganiser la documentation et aligner les paramètres.

Version 1.3.3#

Compresser la dérivation de MAREINFORCETrainer et la déplacer vers le nouveau dossier.
Unifier l’interface pour différents trainers.
Supprimer les correctifs et les enveloppes redondants.
Réorganiser les variables dans les fichiers de configuration YAML.

Version 1.3.2#

Corriger le problème de journalisation de wandb dans MAGRPOTrainer.

Version 1.3.1#

Permettre l’entraînement par lots dans MAGRPOTrainer, IACTrainer et MAACTrainer.
Permettre l’entraînement multi-étapes dans IACTrainer et MAACTrainer.
Modifier l’axe des x de data_step à env_step.

Version 1.3.0#

Utiliser TD comme critic cible de mise à jour dans IACTrainer et MAACTrainer.

Version 1.2.9#

Ajouter MAACTrainer (centralisé séparément critic) ; IACTrainer et MAACTrainer prennent désormais en charge l’entraînement en une seule étape.

Version 1.2.8#

La critic dans IACTrainer estime maintenant V plutôt que Q.

Version 1.2.7#

Modifier IPPOTrainer à IACTrainer.

Version 1.2.6#

Inclure MAGRPO, MAREINFORCE, MARLOO, MAREMAX et IPPO trainers pour l’apprentissage par renforcement multi-agents avec LLMs.
Prise en charge de l’entraînement sur plusieurs tours avec des mécanismes de rétroaction externes personnalisés.
Environnements de collaboration LLM pour diverses tâches.
Documentation et exemples complets pour commencer.

Initialisation de l'entraînement

Mon, 01 Jan 0001 00:00:00 +0000

L’entraînement est initialisé à partir d’un ensemble de tâches, une classe de tâches qui partagent un format d’entrée et une récompense. Les formatteurs transforment chaque tâche en invites pour l’agent, et une fonction de récompense évalue les réponses conjointes des agents.

Ensembles de tâches#

Un ensemble de tâches est un Hugging Face Dataset ou IterableDataset dont les lignes sont des éléments de tâche, chacun un dictionnaire. Le formatteur par défaut lit le champ prompt; des champs supplémentaires peuvent contenir des cibles, des étiquettes, des cas de test ou d’autres informations requises par la fonction de récompense. Trainers transmet l’élément de tâche original à la fonction de récompense via batch_items.

Multi-LLM PbRL

Mon, 01 Jan 0001 00:00:00 +0000

Multi-agent PbRL entraîne les agents collaboratifs LLM à partir des préférences entre leurs réponses conjointes. CoMLRL construit les données de préférence à partir des éléments de tâche et les apprend avec l’un des deux algorithmes : MARLHF s’adapte à un modèle de récompense conjoint et entraîne ensuite les politiques avec RL, tandis que MADPO optimise directement les politiques à partir des préférences. MARLHFTrainer, MADPOTrainer et leurs variantes itératives MARLHFIterTrainer et MADPOIterTrainer sont disponibles à partir de comlrl.trainers.preference.

Interaction multi-tours

Mon, 01 Jan 0001 00:00:00 +0000

De nombreux problèmes complexes nécessitent plus d’un tour pour être résolus. Les agents LLM interagissent avec l’environnement pour obtenir des commentaires utiles auprès d’autres modèles ou outils du système.

Interaction multi-tours MAGRPO#

L’interaction multi-tours MAGRPO construit un arbre rollout dont les branches représentent différentes réponses conjointes (TreeRPO).

Arbre conjoint rollout Branche des observations et actions conjointes se divisent en rollouts indépendants.

Chaque episode commence par une tâche échantillonnée à partir de l’ensemble de données, ce qui fournit les observations initiales $\mathbf{o}_0=\{o_{1, 0}, \cdots, o_{n, 0}\}$ et les historiques $\mathbf{h}_0=\{h_{1, 0}, \cdots, h_{n, 0}\}$ pour tous les agents. À chaque tour, les agents génèrent un groupe de réponses conjointes $\mathbf{a}^{\mathcal{G}}_t\gets\boldsymbol{\pi}^{\mathcal{G}}(\cdot|\mathbf{h}_t)$ à partir de leur historique d’observation-action actuel $\mathbf{h}_t$ . Chaque réponse démarre une observation distincte rollout. Les agents reçoivent des récompenses conjointes $r^{(g)}_{t}$ pour chaque réponse, en fonction de l’historique cumulé et de l’action conjointe actuelle $\mathbf{a}^{(g)}_{t} \in \mathbf{a}^{\mathcal{G}}_{t}$ . Chaque rollout évolue ensuite indépendamment, produisant de nouvelles observations conjointes $\mathbf{o}^{\mathcal{G}}_{t+1}$ à mesure que l’environnement change et se ramifie davantage rollouts au prochain tour $$ t+1 $$ . Ce processus continue jusqu’à la fin $$ H $$ .

Voyage

Mon, 01 Jan 0001 00:00:00 +0000

Parallélisation de l'entraînement

Mon, 01 Jan 0001 00:00:00 +0000

CoMLRL peut placer différents modèles sur différents GPUs. Avec parallel_training="mp", chaque agent fonctionne sur son propre appareil à partir de agent_devices, et les agents génèrent simultanément ; critics, les modèles de récompense, les comparateurs et les modèles de référence utilisent leurs propres paramètres d’appareil. L’option par défaut, "none", maintient les agents sur un seul appareil. Les deux modes fonctionnent sur une seule machine et n’exigent aucun planificateur de tâches.

Chaque modèle fonctionne entièrement sur son appareil attribué et n’est pas réparti sur GPUs. Les indices d’appareil font référence aux GPUs visibles via CUDA_VISIBLE_DEVICES. Une configuration pour plusieurs modèles prend soit un appareil par modèle, soit un seul appareil pour tous, afin que les utilisateurs puissent faire correspondre le placement aux GPUs disponibles et à la mémoire de chaque modèle. Le placement et la planification parallèle des appareils peuvent affecter les résultats de l’entraînement numérique.

Utilisation d'outils

Mon, 01 Jan 0001 00:00:00 +0000

Questions-réponses

Mon, 01 Jan 0001 00:00:00 +0000

Quelles sont les différences entre CoMLRL et autres frameworks de formation multi-LLM ?

De nombreux frameworks supportent l’entraînement de systèmes multi-agents basés sur LLM, spécifiques à un rôle (PettingLLMs, Dr. MAS, MARTI). La plupart sont formulés comme des jeux stochastiques partiellement observables (POSGs), dans lesquels chaque agent a sa propre récompense. Les règles de récompense manuelles pour chaque agent ou rôle rendent les signaux d’entraînement plus denses, mais leur conception est fastidieuse.

Coopératif MARL a été étudié depuis longtemps et est normalement formulé comme un Dec-POMDP. Dans un Dec-POMDP, tous les agents partagent une récompense, de sorte que la politique optimale conjointe est, en théorie, globalement optimale pour la collaboration. Cette formulation permet également aux agents de trouver des tâches plus spécifiques à partir de rôles divisés (voir le CoopHumanEval domaine de codage). De plus, contrairement aux approches de partage de paramètres, CoMLRL prend principalement en charge l’optimisation de systèmes de véritables agents distincts LLM agents, ce qui représente mieux les environnements hétérogènes LLMs avec des capacités différentes et reflète directement le contexte multi-agent.