Antisèche ART (Agent Reinforcement Trainer)

Antisèche ART (Agent Reinforcement Trainer)

ART (Agent Reinforcement Trainer) par OpenPipe est un framework open-source pour entraîner les agents basés sur LLM avec l’apprentissage par renforcement, principalement GRPO. Son idée directrice est une architecture partagée : un client léger exécute les rollouts de votre agent dans votre propre code via un point de terminaison compatible OpenAI, tandis qu’un serveur/backend gère l’inférence (vLLM) et l’entraînement (GRPO alimenté par Unsloth), éventuellement sur une machine GPU séparée. Cela la rend bien adaptée aux agents multi-tours utilisant des outils qui ont besoin d’un entraînement “on-the-job” par rapport à une récompense.

L’apprentissage par renforcement peut être instable et gourmand en calcul. Commencez petit, loggez tout, et validez une fonction de récompense sur une poignée de rollouts avant de passer à l’échelle.

Installation

Étape	Commande
Installer	pip install openpipe-art
Avec extras (backend)	pip install "openpipe-art[backend]"
uv	uv add openpipe-art
Prérequis	Un GPU CUDA pour le backend (entraînement/inférence)

Concepts Essentiels

Terme	Signification
Modèle	Un handle de modèle entraînable (art.TrainableModel) enregistré auprès d’un backend
Backend	Où s’exécutent l’inférence + l’entraînement (GPU local ou distant)
Rollout	Un épisode d’agent qui produit une trajectoire et une récompense
Trajectoire	Les messages/appels d’outils/choix qu’ART évalue et apprend
GRPO	Group Relative Policy Optimization — l’algorithme RL par défaut
Récompense	Un scalaire que votre code assigne à une trajectoire (plus haut = mieux)

Définir un Modèle

import art

model = art.TrainableModel(
    name="agent-001",
    project="my-agent",
    base_model="Qwen/Qwen2.5-7B-Instruct",
)

backend = art.LocalBackend()          # or a remote backend
await model.register(backend)

Objet	Objectif
art.TrainableModel(...)	La stratégie que vous entraînez
art.LocalBackend()	Exécuter l’inférence + l’entraînement sur le GPU local
model.register(backend)	Lier un modèle à un backend
model.openai_client()	Client compatible OpenAI pour les rollouts

Écrire un Rollout

import art, weave

@weave.op
async def rollout(model: art.Model, scenario) -> art.Trajectory:
    client = model.openai_client()
    traj = art.Trajectory(messages_and_choices=[], reward=0.0)

    messages = [{"role": "user", "content": scenario.prompt}]
    completion = await client.chat.completions.create(
        model=model.name, messages=messages,
    )
    choice = completion.choices[0]
    traj.messages_and_choices.append(choice)

    traj.reward = score(choice.message.content, scenario)  # your reward fn
    return traj

Boucle d’Entraînement

for step in range(NUM_STEPS):
    groups = await art.gather_trajectory_groups(
        (art.TrajectoryGroup(rollout(model, s) for _ in range(GROUP_SIZE))
         for s in scenarios)
    )
    await model.train(groups, config=art.TrainConfig(learning_rate=1e-5))

Appel	Description
art.TrajectoryGroup(...)	Un groupe de rollouts comparés les uns aux autres (GRPO)
art.gather_trajectory_groups(...)	Exécuter les rollouts de façon concurrente et collecter les groupes
model.train(groups, config=...)	Une mise à jour GRPO à partir des groupes rassemblés
art.TrainConfig(...)	Taux d’apprentissage et hyperparamètres d’entraînement
model.get_step()	Étape d’entraînement actuelle (pour les points de contrôle/reprise)

Conseils sur la Conception des Récompenses

Principe	Pourquoi
Maintenir les récompenses bornées	Stabilise les estimations d’avantage GRPO
Récompenser le résultat, pas la formulation	Évite l’optimisation de récompense sur la formulation
Ajouter un petit façonnage pour le succès des outils	Aide à l’attribution du crédit multi-étapes
Utiliser RULER pour le classement relatif	L’assistant de classe du PRI d’ART pour classer les trajectoires dans un groupe quand il n’y a pas de métrique nette

Observabilité

Outil	Intégration
Weights & Biases	Logging natif des courbes de récompense/perte
Weave	Décorer les rollouts avec @weave.op pour la capture de trace
LangfuseTracing	Supporté pour l’inspection de trajectoire

ART vs Autres Entraîneurs RL

Aspect	ART	OpenRLHF	verl
Focus	Agents multi-étapes	RLHF évolutif	RL haute débit
Architecture	Client/serveur partagée	Ray + vLLM	Ray + vLLM
Backend	vLLM + Unsloth	vLLM	vLLM
Meilleur pour	Agents entraînés dans votre propre code	Pipelines RLHF à grande échelle	Débit de recherche

Ressources

• Dépôt GitHub
• Post de Lancement : ART Trainer
• Package PyPI