Überblick on CoMLRL

Hilfe

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

Hilfe#

Wir helfen Ihnen gerne bei Problemen, die beim Verwenden von CoMLRL auftreten.

Probleme melden#

Die folgenden Schritte können Benutzern helfen, ein Problem zu lösen oder zu melden:

Benutzer können zunächst die Dokumentation konsultieren, einschließlich der Suchfunktion (Strg + K).
Eine Suche nach bestehenden GitHub-Problemen kann Berichte über dasselbe Problem aufzeigen.
Ein minimales, reproduzierbares Beispiel hilft bei der Diagnose des Problems. Einige Codezeilen, die das Problem demonstrieren, können zu einer schnelleren Reaktion führen.

Installation

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

CoMLRL kann von PyPI, conda-forge oder der Quelle installiert werden und unterstützt Python 3.10 oder höher. Benutzer sollten außerdem eine PyTorch-Build installieren, die mit ihrem Gerät kompatibel ist.

Installation von PyPI#

pip install comlrl
# Install PyTorch compatible with your device.

Installation von conda-forge#

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

Installation von der Quelle#

Benutzer können auch das Repository klonen und CoMLRL im editierbaren Modus installieren, um die neuesten Funktionen zu nutzen oder es lokal zu entwickeln:

Multi-Agent REINFORCE

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

REINFORCE ist eine Klasse von Policy-Gradient-Methoden, die die Policy direkt mithilfe von gesampelten Belohnungen optimieren. Diese Methoden werden häufig für LLM-Feinabstimmung verwendet, da sie einfach und effizient sind. Beispiele sind GRPO, Dr. GRPO, RLOO, ReMax, TreeRPO, und REINFORCE++. REINFORCE kann auf Multi-Agent-Einstellungen erweitert werden, in denen mehrere LLM-Agenten in jeder Runde antworten und ihre gemeinsamen Antworten eine gemeinsame Belohnung erhalten.

Alle MAREINFORCE trainers ein gemeinsames Trainingsschritt. Bei jedem rollout Agent sammelt $$ K $$ Antworten, bewertet der trainer Index-ausgerichtete gemeinsame Antworten mit einer gemeinsamen Belohnung, und jeder Agent gewichtet seine eigenen Log-Wahrscheinlichkeiten mit dem resultierenden gemeinsamen Vorteil, bevor ein gepufferter Optimierungsschritt durchgeführt wird.

Schreiben

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

Training anhand des Längenverhältnisses

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

Dieses Tutorial demonstriert eine einfache zweier-Agenten-Trainingsaufgabe mit einer Längenverhältnis-Belohnung. Beide Agenten erhalten denselben Prompt und generieren unabhängig voneinander; der zweite Agent sieht nicht die Antwort des ersten Agenten. Die Belohnung fördert, dass die zweite Ausgabe 2–3× so viele Zeichen enthält wie die erste. Sie bewertet keine Storyqualität oder semantische Zusammenarbeit.

Benutzer können das Beispiel aus einem installierten Quellcode-Checkout ausführen:

python examples/story-len-ratio.py

Speicheranforderungen hängen vom Modell, der Anzahl der Agenten, der Batch-Größe und der Antwortlänge ab. W&B-Protokollierung ist standardmäßig deaktiviert. Das --wandb-Flag aktiviert sie; --wandb-project und --wandb-entity sind optional.

Training fortsetzen

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

Dieses Beispiel trainiert zwei kleine Agenten für zwei epochs, setzt dann die gleiche Ausführung für zwei weitere epochs von einem Checkpoint fort. Beide Teile werden in einem W&B-Run protokolliert.

Einrichtung#

Die Aufgabe verlangt, dass der zweite Agent eine Antwort verfasst, die 2 bis 3 Mal so lang ist wie die Antwort des ersten Agenten.

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

Die gleiche Funktion erstellt trainer für beide Teile des Runs, sodass die beiden trainers übereinstimmen.

Beitragen

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

Beitragen#

Beiträge zu CoMLRL sind willkommen. Dieser Leitfaden behandelt Codeänderungen und die Instandhaltung des Codes.

Entwicklungsgrundsätze#

Mitwirkende können das Upstream-Repository klonen.

Die folgenden Befehle klonen das Fork und synchronisieren es mit dem Upstream:

 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

Mitwirkende können neue Funktionen implementieren oder Fehler beheben und die Dokumentation bei Bedarf aktualisieren.
Änderungen können als Pull Request im Upstream-Repository zur Überprüfung eingereicht werden.

Mehrstufiges Feedback

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

In diesem Beispiel beantworten zwei Agenten eine Aufgabe, erhalten Feedback auf ihre Antworten und beantworten dann erneut.

Einrichtung#

Die Aufgabe verlangt, dass der zweite Agent eine Antwort verfasst, die 2 bis 3 Mal so lang ist wie die Antwort des ersten Agenten.

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

Feedback zwischen den Schritten#

Nach dem ersten Schritt schreibt diese Funktion einen neuen Prompt für jeden Agenten. Der Prompt gibt die Länge der Antworten an.

Multi-Agent Actor-Critic

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

Actor-Critic (AC) Methoden sind weit verbreitete Policy-Gradient-Methoden, die critics zur Unterstützung des Trainings verwenden. AC-Methoden können eine geringere Varianz und eine bessere Stichprobeneffizienz als REINFORCE erreichen, erfordert dies aber eine sorgfältige Gestaltung und Abstimmung von critic, um ein stabiles Training zu gewährleisten. Im Multi-Agent Reinforcement Learning (MARL) umfassen Actor-Critic-Methoden Multi-Agent Actor-Critic (MAAC) und Independent Actor-Critic (IAC).

Beide führen die Agenten gemeinsam aus und bewerten ihre gemeinsame Antwort mit der Belohnungsfunktion, aber sie verwenden critics unterschiedlich. MAAC trainiert einen critic auf der gemeinsamen Historie, sodass jeder Agent seinen TD-Fehler teilt. IAC trainiert einen critic pro Agent auf der Historie dieses Agenten, sodass jeder Agent seinen eigenen TD-Fehler erhält.

Programmierung

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

Trainings-Entitäten

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

CoMLRL unterstützt das Training von LLM-Agenten und ermöglicht deren Training mit LLM-basierten critics oder Belohnungsmodellen. Agenten und critics können homogene oder heterogene Modelle von Hugging Face oder lokalen Verzeichnissen sein. Benutzer können angeben Hugging Face Modell-IDs über agent_model/critic_model für homogene Konfigurationen, oder angeben agents/critics Listen für heterogene Konfigurationen. Trainierte Entitäten können gespeichert und in eine neue trainer zum weiteren Training.

LLM-Agenten#

Homogene Agenten#

Homogene Agenten werden initialisiert, indem agent_model auf eine einzelne Modell-ID gesetzt und agents=None leer gelassen wird. Für trainers mit einem separaten num_agents-Konstruktorargument kann dieses Argument zusammen mit dem entsprechenden Konfigurationswert gesetzt werden; die Konfiguration allein überschreibt es nicht.

Änderungen

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

Änderungen#

Version 1.4.3#

Unterstützung für MAPL-Algorithmen, einschließlich MARLHF und MADPO (PR #72).
Unterstützung für zentralisiertes Training von Multi-Agent-Systemen (PR #72).
Dokumentation verbessern.

Version 1.4.2#

Unterstützung für mehr Vergleicher-Modelle (Commit e1b3d80).
Behebung des Problems mit der homogenen Generierung (Commit 11d89a9).

Version 1.4.1#

Unterstützung für die Verwendung des Vergleichers als zentralen Koordinator (PR #69).
Ermöglichen des Deployments von LLM-Agenten, dem Belohnungsmodell und dem Vergleicher auf verschiedenen Geräten (Commit 7cbb792).
Ermöglichen Sie das Kopieren aktueller Modelle als Vergleicher auf neuen Geräten (Commit d8d493a).
Optimieren Sie den Speicherverbrauch von GPU, indem Sie nicht benötigte Modelle umgehend freigeben (Commit d0c6376).

Version 1.4.0#

Fügen Sie Online-Methoden für PbRL hinzu (PR #68).
Fügen Sie einen Datensatz-Drift-Logger hinzu.

Version 1.3.9#

Fügen Sie Offline-Methoden für PbRL hinzu, wie MADPO und MARLHF (PR #67).

Version 1.3.8#

Ermöglichen Sie die Verwendung eines Referenzmodells für alle Algorithmen (PR #65).
Vereinheitlichen Sie den Logger zwischen verschiedenen trainers (PR #66).

Version 1.3.7#

Entfernen Sie redundante Sampling-Hyperparameter in Algorithmen.
Ermöglichen Sie das Training mit mehreren GPU zusammen mit MP (siehe Ergebnisse in PR #62).

Version 1.3.6#

Beheben Sie einen kritischen Fehler beim Laden heterogener Modelle und refaktorieren Sie die Logik zum Laden von Modellen (siehe Ergebnisse in PR #60).
Verbessern Sie die Dokumentation.

Version 1.3.5#

Fügen Sie Unit-Tests für Hyperparameter-Beschränkungen hinzu.
Bereinigen Sie veraltete Schnittstellen.

Version 1.3.4#

Beheben Sie den Fehler beim Laden heterogener Modelle und refaktorieren Sie die Ladelogik.
Aktivieren Sie MBGD in MAGRPO, um mit MAAC und IAC kompatibel zu sein.
Entfernen Sie redundante und veraltete Hyperparameter (z. B. Modell-Parameter, Patching-Hyperparameter).
Bereinigen Sie veralteten Code für mehrere Geräte, z. B. drop_last und num_workers.
Fügen Sie Unit-Tests für das Modell laden hinzu und trennen Sie diese von CI als Badge.
Bereinigen Sie kurze Funktionen.
Organisieren Sie die Dokumentation und passen Sie die Parameter an.

Version 1.3.3#

Komprimieren Sie die MAREINFORCETrainer-Ableitung und verschieben Sie sie in das neue Verzeichnis.
Vereinheitlichen Sie die Schnittstelle für verschiedene trainers.
Entfernen Sie redundante Patches und Wrapper.
Organisieren Sie die Variablen in den Config YAML-Dateien.

Version 1.3.2#

Beheben Sie das wandb-Protokollierungsproblem in MAGRPOTrainer.

Version 1.3.1#

Ermöglichen Sie das Batch-Training in MAGRPOTrainer, IACTrainer und MAACTrainer.
Ermöglichen Sie mehrstufiges Training in IACTrainer und MAACTrainer.
Ändern Sie die x-Achse von data_step zu env_step.

Version 1.3.0#

Verwenden TD Fehler als den critic Aktualisierungsziel in IACTrainer und MAACTrainer.

Version 1.2.9#

Fügen Sie MAACTrainer (zentralisiertes critic) hinzu; sowohl IACTrainer als auch MAACTrainer unterstützen jetzt das Training mit einer einzigen Runde.

Version 1.2.8#

Der critic in IACTrainer schätzt jetzt V anstelle von Q.

Version 1.2.7#

Ändern Sie IPPOTrainer zu IACTrainer.

Version 1.2.6#

Inkludieren Sie MAGRPO, MAREINFORCE, MARLOO, MAREMAX und IPPO trainers für das mehragenten-Reinforcement Learning mit LLMs.
Unterstützung für das Training über mehrere Schritte mit benutzerdefinierten externen Feedbackmechanismen.
LLM-Zusammenarbeitsumgebungen für verschiedene Aufgaben.
Umfassende Dokumentation und Beispiele für den Einstieg.

Code-Vervollständigung

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

Initialisierung des Trainings

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

Das Training wird von einem Aufgaben-Set initialisiert, einer Klasse von Aufgaben, die ein einheitliches Eingabeformat und eine Belohnung teilen. Formatierer wandeln jede Aufgabe in Agent-Prompts um, und eine Belohnungsfunktion bewertet die gemeinsamen Antworten der Agenten.

Aufgaben-Sets#

Ein Aufgaben-Set ist ein Hugging Face Dataset oder IterableDataset, dessen Zeilen Aufgaben sind, wobei jede Aufgabe ein Dictionary ist. Der Standard-Formatierer liest das Feld prompt; zusätzliche Felder können Ziele, Labels, Testfälle oder andere Informationen enthalten, die von der Belohnungsfunktion benötigt werden. Trainers übergibt das ursprüngliche Aufgaben-Item über batch_items an die Belohnungsfunktion.

Multi-LLM PbRL

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

Multi-Agent PbRL trainiert kollaborierende LLM Agenten aus Präferenzen zwischen ihren gemeinsamen Antworten. CoMLRL erstellt die Präferenzdaten aus Aufgaben-Items und lernt daraus mit einem von zwei Algorithmen: MARLHF passt ein gemeinsames Belohnungsmodell an und trainiert dann die Richtlinien mit RL, während MADPO die Richtlinien direkt aus den Präferenzen optimiert. MARLHFTrainer, MADPOTrainer und ihre iterativen Varianten MARLHFIterTrainer und MADPOIterTrainer sind von comlrl.trainers.preference erhältlich.

Alle vier trainers benötigen derzeit num_turns=1 und eine abgestimmte gemeinsame Antwort (joint_mode="aligned"). Eine Iteration des iterativen trainers ist eine Runde der Datenerfassung und des Trainings, nicht ein Dialogschritt.

Mehrstufige Interaktion

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

Viele komplexe Probleme erfordern mehr als eine Runde, um sie zu lösen. LLM-Agenten interagieren mit der Umgebung, um nützliches Feedback von anderen Modellen oder Werkzeugen im System zu erhalten.

Mehrstufige MAGRPO#

Mehrstufige MAGRPO erstellt einen rollout-Baum, dessen Zweige unterschiedliche gemeinsame Antworten (TreeRPO) darstellen.

Gemeinsames rollout-Baum Gemeinsame Beobachtungen und Aktionen verzweigen sich in unabhängige rollouts.

Jeder episode beginnt mit einer Aufgabe, die aus dem Datensatz entnommen wird, und liefert die anfänglichen Beobachtungen $\mathbf{o}_0=\{o_{1, 0}, \cdots, o_{n, 0}\}$ und die Vorgeschichte $\mathbf{h}_0=\{h_{1, 0}, \cdots, h_{n, 0}\}$ für alle Agenten. In jeder Stufe generieren die Agenten eine Gruppe von gemeinsamen Antworten $\mathbf{a}^{\mathcal{G}}_t\gets\boldsymbol{\pi}^{\mathcal{G}}(\cdot|\mathbf{h}_t)$ basierend auf ihrer aktuellen Beobachtungs-Aktions-Vorgeschichte $\mathbf{h}_t$ . Jede Antwort leitet eine distincte rollout ein. Die Agenten erhalten gemeinsame Belohnungen $r^{(g)}_{t}$ für jede Antwort, basierend auf der akkumulierten Vorgeschichte und der aktuellen gemeinsamen Aktion $\mathbf{a}^{(g)}_{t} \in \mathbf{a}^{\mathcal{G}}_{t}$ . Jede rollout entwickelt sich unabhängig, wodurch neue gemeinsame Beobachtungen $\mathbf{o}^{\mathcal{G}}_{t+1}$ entstehen, wenn sich die Umgebung ändert, und weitere rollouts-Verzweigungen entstehen in der nächsten Stufe $$ t+1 $$ . Dieser Prozess setzt sich fort, bis die Endstufen $$ H $$ erreicht sind.

Reisen

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

Parallelisierung des Trainings

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

CoMLRL kann verschiedene Modelle auf verschiedenen GPUs platzieren. Mit parallel_training="mp" läuft jeder Agent auf seinem eigenen Gerät von agent_devices, und die Agenten generieren gleichzeitig; critics, Belohnungsmodelle, Vergleicher und Referenzmodelle haben ihre eigenen Geräteeinstellungen. Der Standard, "none", hält die Agenten auf einem Gerät. Beide Modi laufen auf einer einzigen Maschine und erfordern keinen Job-Scheduler.

Jedes Modell läuft vollständig auf seinem zugewiesenen Gerät und wird nicht über GPUs aufgeteilt. Geräteindizes beziehen sich auf die GPUs, die über CUDA_VISIBLE_DEVICES sichtbar sind. Eine Einstellung für mehrere Modelle verwendet entweder ein Gerät pro Modell oder ein Gerät für alle, sodass Benutzer die Platzierung an die verfügbaren GPUs und den Speicher jedes Modells anpassen können. Die Platzierung und die parallele Planung von Geräten können die numerischen Trainingsergebnisse beeinflussen.

Werkzeugnutzung

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

Fragen und Antworten

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

Was sind die Unterschiede zwischen CoMLRL und anderen Multi-LLM-Trainingsframeworks?

Viele Frameworks unterstützen das Training von rollenspezifischen, Multi-Agent-Systemen, die auf LLM basieren (PettingLLMs, Dr. MAS, MARTI). Die meisten davon werden als teilweise beobachtbare stochastische Spiele (POSGs) formuliert, wobei jeder Agent seinen eigenen Reward hat. Handgefertigte Reward-Regeln für jeden Agenten oder jede Rolle machen die Trainingssignale dichter, aber sie sind schwierig zu entwerfen.

Kooperatives MARL wurde lange Zeit untersucht und wird normalerweise als Dec-POMDP formuliert. In einem Dec-POMDP teilen alle Agenten einen Reward, so dass die optimale gemeinsame Policy, theoretisch, global optimal für die Zusammenarbeit ist. Diese Formulierung ermöglicht es auch Agenten, spezifischere Aufgaben aus lose definierten Rollen zu finden (siehe den CoopHumanEval-Codierungsbereich). Darüber hinaus unterstützt CoMLRL hauptsächlich die Optimierung von Systemen von wirklich unterschiedlichen LLM-Agenten, was besser heterogene LLMs mit unterschiedlichen Fähigkeiten darstellt und direkt die Multi-Agent-Umgebung widerspiegelt.