Trainings-Entitäten

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.

Das folgende Beispiel lädt drei Qwen/Qwen2.5-1.5B Agenten:

trainer = MAGRPOTrainer(
    agent_model="Qwen/Qwen2.5-1.5B",
    agents=None,
    num_agents=3,
    reward_func=reward_func,
    train_dataset=train_dataset,
    args=MAGRPOConfig(num_agents=3, num_turns=1, temperature=0.7, top_p=0.9, top_k=None),
)

Heterogene Agenten#

Obwohl homogene Agenten dazu verwendet werden können, unterschiedliche Rollen zu übernehmen und an verschiedenen Teilen einer Aufgabe parallel zu arbeiten, können heterogene Agenten die spezialisierten Fähigkeiten verschiedener Modelle einsetzen.

Benutzer können heterogene Agenten initialisieren, indem sie Modell-IDs oder geladene Modellobjekte in agents bereitstellen, wobei kompatible tokenizers über tokenizer bereitgestellt werden. Mit agents bereitgestellt, kann agent_model None bleiben. Wenn beide bereitgestellt werden, müssen ihre Modellnamen übereinstimmen und ihre Listenlängen mit der Anzahl der Agenten übereinstimmen; andernfalls wird ein Fehler beim Training angezeigt.

Das folgende Beispiel lädt die Agenten Qwen/Qwen2.5-Coder-3B und Qwen/Qwen2.5-Coder-7B:

trainer = MAGRPOTrainer(
    agent_model=None,
    agents=["Qwen/Qwen2.5-Coder-3B", "Qwen/Qwen2.5-Coder-7B"],
    reward_func=reward_func,
    train_dataset=train_dataset,
    args=MAGRPOConfig(num_agents=2, num_turns=1, temperature=0.7, top_p=0.9, top_k=None),
)

LLM Critics#

Algorithmen wie unabhängiger Actor-Critic (IAC) und Multi-Agent Actor-Critic (MAAC) verwenden LLM critics. Wie diese critics geladen werden, hängt vom Algorithmus und der use_separate_critic-Einstellung ab. MARLHF trainers mit rl_algorithm="maac" oder "iac" akzeptieren die gleichen critic_model und critics-Argumente, oder critic_model_name in ihrer Konfiguration; andernfalls verwenden sie die Model-ID des ersten actor.

Zentralisiertes Critic#

Eine separate, zentralisierte critic kann über critic_model oder eine Liste mit einem Element critics geladen werden. Sie muss ein unterstütztes kausales Sprachmodell sein: trainer fügt value head hinzu und kodiert die gemeinsame Eingabe mit der actor des ersten tokenizer, sodass tokenizer auch mit critic kompatibel sein muss.

Das folgende Beispiel lädt die Paare Qwen/Qwen2.5-Coder-3B und Qwen/Qwen2.5-Coder-1.5B actors mit einem zentralisierten Qwen/Qwen2.5-Coder-7B critic:

trainer = MAACTrainer(
    agent_model=None,
    agents=["Qwen/Qwen2.5-Coder-3B", "Qwen/Qwen2.5-Coder-1.5B"],
    tokenizer=[
        AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-3B"),
        AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-1.5B"),
    ],
    critic_model="Qwen/Qwen2.5-Coder-7B",
    critics=None,
    reward_func=reward_func,
    train_dataset=train_dataset,
    args=MAACConfig(num_agents=2, num_turns=1, temperature=0.7, top_p=0.9, top_k=None),
)

Unabhängig Critics#

Mit unabhängigem critics kann jeder Agent seine eigene critic haben. Mit use_separate_critic=True können Benutzer einen critic_model-Identifier angeben, um eine separate Kopie pro Agent zu laden, oder eine Liste critics mit der Länge num_agents. Jede separate critic erhält token IDs von ihrem actor tokenizer und muss mit diesem kompatibel sein. Mit use_separate_critic=False teilen sich jede actor und critic einen LLM backbone und werden zusammen geladen. In diesem Fall bleiben critic_model und critics leer (null oder None). Wie bei Agenten erfordert die Angabe von critic_model und critics übereinstimmende Modelnamen und -längen; andernfalls löst das Training einen Fehler aus.

Das folgende Beispiel lädt die Qwen/Qwen2.5-Coder-3B und Qwen/Qwen2.5-Coder-7B actors mit separaten critics basierend auf denselben Modellen:

trainer = IACTrainer(
    agent_model=None,
    agents=["Qwen/Qwen2.5-Coder-3B", "Qwen/Qwen2.5-Coder-7B"],
    tokenizer=[
        AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-3B"),
        AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-7B"),
    ],
    critic_model=None,
    critics=["Qwen/Qwen2.5-Coder-3B", "Qwen/Qwen2.5-Coder-7B"],
    reward_func=reward_func,
    train_dataset=train_dataset,
    args=IACConfig(
        num_agents=2,
        num_turns=1,
        use_separate_critic=True,
        temperature=0.7,
        top_p=0.9,
        top_k=None,
    ),
)

Alternativ kann jedes actor das gleiche Modell mit seinem critic teilen:

trainer = IACTrainer(
    agent_model=None,
    agents=["Qwen/Qwen2.5-Coder-3B", "Qwen/Qwen2.5-Coder-7B"],
    tokenizer=[
        AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-3B"),
        AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-7B"),
    ],
    critic_model=None,
    critics=None,
    reward_func=reward_func,
    train_dataset=train_dataset,
    args=IACConfig(
        num_agents=2,
        num_turns=1,
        use_separate_critic=False,
        temperature=0.7,
        top_p=0.9,
        top_k=None,
    ),
)

Trainers verwendet agents/critics intern. Die agent_model und critic_model Parameter sind Abkürzungen für homogene Setups und müssen mit allen entsprechenden Listen übereinstimmen.

MAGRPO lädt tokenizers automatisch für Modell-Identifikatoren. MAAC/IAC laden tokenizer automatisch für agent_model, erfordern aber eine explizite tokenizer, wenn agents bereitgestellt wird, auch wenn es Strings enthält. Geladene Modellobjekte benötigen ein kompatibles gemeinsames tokenizer oder eine Liste tokenizer, die actors entspricht. Heterogene actors können unterschiedliche Vokabularien haben, wenn jedes sein eigenes kompatibles tokenizer verwendet; separate critics müssen auch ihre actor’s token IDs akzeptieren (das actor’s IDs für MAAC).

LLM Belohnungsmodelle#

In PbRL, MARLHF lernt ein gemeinsames Belohnungsmodell aus Präferenzpaaren und speichert es als Belohnung für das Policy-Lernen. Sein backbone wird über reward_model_name in MARLHFConfig aus einer Hugging Face-Modell-ID oder einem lokalen Verzeichnis eines kausalen Sprachmodells geladen. Es verwendet standardmäßig die Modell-ID des ersten actor und ist erforderlich, wenn die actors Modellobjekte ohne eine sind. trainer lädt backbone mit seinem eigenen tokenizer, fügt einen Skalar-Head auf dem letzten Nicht-Padding-token hinzu und platziert das Modell auf reward_model_device (Standard: "cuda:0"; None verwendet das trainer-Gerät). reward_freeze_backbone=True trainiert nur den Head.

Das folgende Beispiel lädt ein Qwen/Qwen2.5-Coder-7B Belohnungsmodell für zwei Qwen/Qwen2.5-Coder-3B Agenten:

from comlrl.trainers.preference import MARLHFConfig, MARLHFTrainer

trainer = MARLHFTrainer(
    agent_model="Qwen/Qwen2.5-Coder-3B",
    num_agents=2,
    reward_func=reward_func,
    train_dataset=train_dataset,
    args=MARLHFConfig(
        num_agents=2,
        num_turns=1,
        reward_model_name="Qwen/Qwen2.5-Coder-7B",
        reward_model_device="cuda:1",
    ),
)

MARLHFIterTrainer lädt das Belohnungsmodell bei jeder Iteration aus dieser Quelle neu, bevor das Präferenzlernen stattfindet. Die Aufgabe-Belohnung von reward_func kennzeichnet weiterhin die Präferenzpaare; Trainingsinitialisierung beschreibt, wie regelbasierte oder LLM-basierte Aufgabenbelohnungen übergeben werden.

Speichern und Fortsetzen des Trainings#

Modelle speichern#

Benutzer können save_model(output_dir) nach dem Training aufrufen, um die actors’ Hugging Face-Modellkonfigurationen, Gewichte und tokenizers explizit in lokale Verzeichnisse zu speichern:

trainer.train()
trainer.save_model("./saved-models/run-1")

Training aus gespeicherten Modellen#

Das Training kann von einem gespeicherten Zwei-actor MAGRPO-Setup fortgesetzt werden, indem die Verzeichnisse von actors im ursprünglichen Rollen-Reihenfolge angegeben werden. Das übergeordnete run-1-Verzeichnis enthält actors; jedes agent_i-Verzeichnis ist ein ladbares Modell.

from comlrl.trainers.reinforce import MAGRPOConfig, MAGRPOTrainer

continued_trainer = MAGRPOTrainer(
    agents=[
        "./saved-models/run-1/agent_0",
        "./saved-models/run-1/agent_1",
    ],
    num_agents=2,
    reward_func=reward_func,
    train_dataset=train_dataset,
    args=MAGRPOConfig(
        num_agents=2,
        num_turns=1,
        num_train_epochs=3,
        agent_learning_rate=5e-6,
        temperature=0.7,
        top_p=0.9,
        top_k=None,
    ),
)
continued_trainer.train()
continued_trainer.save_model("./saved-models/run-2")

MAGRPO lädt tokenizers automatisch aus den actor-Verzeichnissen. Hier bedeutet num_train_epochs=3, dass drei epochs in der neuen Trainingslauf durchgeführt werden. Das Dataset, die Belohnungsfunktion, die Trainingskonfiguration und alle benutzerdefinierten Formatierer, der Belohnungsprozessor oder externe Übergänge müssen erneut bereitgestellt werden; save_model speichert diese nicht.

Andere trainers unterstützen den gleichen Ansatz mit lokalen Verzeichnissen, unter der Voraussetzung, dass die tokenizer- und actor-Anzahl-Anforderungen erfüllt sind. Die Präferenz-trainers startet die Präferenzsammlung und das Präferenzlernen gemäß der Konfiguration des neuen Laufs.

IAC und MAAC speichern value heads separat als value_head.pt. Das Laden eines critic oder eines gemeinsamen actor-Verzeichnisses über den Konstruktor stellt das Sprachmodell backbone wieder her und erstellt ein neues value head. Benutzer können die gelernten Werte durch das explizite Wiederherstellen des gespeicherten Kopfes vor dem Aufrufen von train() beibehalten. Trainings-Checkpoints, im Gegensatz zu save_model-Exports, stellen value heads automatisch wieder her.

Für ein gespeichertes Zwei-actor MAAC-Setup mit der Standard-linearen value head:

from pathlib import Path
import torch
from transformers import AutoTokenizer
from comlrl.trainers.actor_critic import MAACConfig, MAACTrainer

saved_dir = Path("./saved-models/maac-run-1")
actor_dirs = [str(saved_dir / f"agent_{i}") for i in range(2)]

continued_maac = MAACTrainer(
    agents=actor_dirs,
    tokenizer=[AutoTokenizer.from_pretrained(path) for path in actor_dirs],
    critic_model=str(saved_dir / "critic"),
    reward_func=reward_func,
    train_dataset=train_dataset,
    args=MAACConfig(num_agents=2, num_turns=1, num_train_epochs=3),
)
continued_maac.critics[0].value_head.load_state_dict(
    torch.load(
        saved_dir / "critic" / "value_head.pt",
        map_location="cpu",
        weights_only=True,
    )
)
continued_maac.train()
continued_maac.save_model("./saved-models/maac-run-2")

Für IAC, dasselbe load_state_dict Schritt gilt für continued_iac.agents[i].value_head wenn use_separate_critic=False, oder für continued_iac.critics[i].value_head wenn es ist True. Getrennt critic backbones erfordert auch das Laden über critic_model oder critics.

Die value-head-Architektur muss mit dem gespeicherten Lauf übereinstimmen. IAC benötigt IACConfig.value_head_hidden_dim für gemeinsame Köpfe und IACConfig.critic_value_head_hidden_dim für separate Köpfe. Ein benutzerdefinierter MAAC-Kopf benötigt model_config={"critic_value_head_hidden_dim": ...} im trainer-Konstruktor. Das Fortsetzen der gleichen Wertlern-Konfiguration erfordert auch critic_type ("v" oder "q").

Trainingszustand#

Benutzer können Trainings-Checkpoints über train(checkpoint_dir=...) aktivieren und einen kompatiblen trainer mit resume_from_checkpoint fortsetzen:

# Save a checkpoint at each completed training boundary.
trainer.train(checkpoint_dir="./checkpoints", checkpoint_interval=1)

# Recreate the trainer with the same models, tokenizers, data, and callbacks.
resumed_trainer.train(
    resume_from_checkpoint="./checkpoints/checkpoint-1",
    checkpoint_dir="./checkpoints",
    checkpoint_interval=1,
)

Checkpoints speichern Modell- und Optimierungszustände, Trainingsfortschritt, Zufallszustände und, falls zutreffend, PbRL-Daten und -Historie.

Checkpoints werden bei abgeschlossenen epochs, Iterationen oder PbRL-Phasen gespeichert, wobei eine abschließende Speicherung erfolgt. checkpoint_interval steuert periodische Speichervorgänge. Das Fortsetzen wiederholt alle seit dem letzten Checkpoint durchgeführten Arbeiten.

num_train_epochs und num_iterations zählen die Gesamtlaufzeit, einschließlich abgeschlossener Arbeiten, und können erhöht werden, wenn fortgesetzt wird. Modelle, tokenizers, Daten und Trainings-Einstellungen müssen kompatibel sein. Stateful Datensätze und Callbacks können state_dict() und load_state_dict() bereitstellen; der externe Dienstzustand wird nicht wiederhergestellt. Wenn ein PbRL-Ausgabeverzeichnis bereits Dateien enthält, gehen die fortgesetzten Ausgaben in ein resume-*-Unterverzeichnis.

Für W&B kann die gespeicherte Lauf-ID vor der Konstruktion von trainer in die bestehende wandb_config-Instanz gemergt werden. Dies bewahrt Protokollierungs- und Ausgabeeinstellungen und vermeidet die Erstellung eines leeren Laufs während der Konstruktion:

from comlrl.utils import read_checkpoint_metadata

checkpoint = "./checkpoints/checkpoint-1"
identity = read_checkpoint_metadata(checkpoint)["wandb"]
if identity and "id" not in wandb_config and "resume" not in wandb_config:
    wandb_config = {**wandb_config, **identity, "resume": "allow"}

# Pass wandb_config to the trainer constructor before resuming.

Explizite Einstellungen für id oder resume haben Vorrang. Wenn der Checkpoint keine W&B-Identität enthält, gibt der Helper None für wandb zurück und die bestehende Konfiguration bleibt erhalten.

Checkpointing ist standardmäßig deaktiviert: train() ohne Checkpoint-Optionen speichert keine Trainings-Checkpoints. save_model() exportiert nur Modelle; es speichert nicht den vollständigen Zustand, der für das erneute Training erforderlich ist.