👾Entraîner des agents IA avec RL

Apprenez à entraîner des agents IA pour des tâches réelles en utilisant l'apprentissage par renforcement (RL).

L'IA « agentique » devient de plus en plus populaire au fil du temps. Dans ce contexte, un « agent » est un LLM auquel on donne un objectif de haut niveau et un ensemble d'outils pour l'atteindre. Les agents sont aussi généralement « multi‑tours » — ils peuvent effectuer une action, voir quel effet elle a eu sur l'environnement, puis effectuer une autre action de façon répétée, jusqu'à ce qu'ils atteignent leur objectif ou échouent en essayant.

Malheureusement, même des LLM très performants peuvent avoir du mal à accomplir de manière fiable des tâches agentiques complexes et multi‑tours. Fait intéressant, nous avons découvert que former des agents en utilisant un algorithme RL appelé GRPO (Group Relative Policy Optimization) peut les rendre bien plus fiables ! Dans ce guide, vous apprendrez comment construire des agents IA fiables en utilisant des outils open‑source.

🎨 Former des agents RL avec ART

ART (Agent Reinforcement Trainer) construit au‑dessus de UnslothLe GRPOTrainer de , est un outil qui rend la formation d'agents multi‑tours possible et facile. Si vous utilisez déjà Unsloth pour GRPO et devez former des agents capables de gérer des interactions complexes et multi‑tours, ART simplifie le processus.

Les modèles d'agents entraînés avec Unsloth+ART sont souvent capables de surpasser les modèles basés sur des prompts sur des flux de travail agentiques.

ART + Unsloth

ART s'appuie sur l'implémentation GRPO de Unsloth, efficace en mémoire et en calcul. De plus, il ajoute les fonctionnalités suivantes :

1. Formation d'agents multi‑tours

ART introduit le concept de « trajectoire », qui se construit au fur et à mesure que votre agent s'exécute. Ces trajectoires peuvent ensuite être notées et utilisées pour GRPO. Les trajectoires peuvent être complexes et inclure même des historiques non linéaires, des appels à des sous‑agents, etc. Elles prennent également en charge les appels d'outils et les réponses.

2. Intégration flexible dans des bases de code existantes

Si vous avez déjà un agent fonctionnant avec un modèle par prompt, ART essaie de minimiser le nombre de modifications nécessaires pour encapsuler votre boucle d'agent existante et l'utiliser pour l'entraînement.

Architecturalement, ART est divisé en un client « frontend » qui vit dans votre base de code et communique via API avec un « backend » où l'entraînement réel a lieu (ceux‑ci peuvent aussi être colocalisés sur une seule machine si vous préférez utiliser le LocalBackend). Cela apporte quelques avantages clés :

• Configuration minimale requise: Le frontend ART a des dépendances minimales et peut être facilement ajouté à des bases de code Python existantes.

• S'entraîner depuis n'importe où: Vous pouvez exécuter le client ART sur votre ordinateur portable et laisser le serveur ART lancer un environnement éphémère avec GPU, ou exécuter sur un GPU local

• API compatible OpenAI: Le backend ART expose votre modèle en cours d'entraînement via une API compatible OpenAI, ce qui est compatible avec la plupart des bases de code existantes.

3. RULER : Récompenses d'agent en zero‑shot

ART fournit également une fonction de récompense générale intégrée appelée RULER (Relative Universal LLM‑Elicited Rewards), qui peut éliminer le besoin de fonctions de récompense conçues à la main. De façon surprenante, les agents entraînés par RL avec la fonction de récompense automatique RULER égalent souvent ou dépassent les performances des agents entraînés avec des fonctions de récompense écrites manuellement. Cela facilite la prise en main du RL.

# Avant : des heures d'ingénierie des récompenses
def complex_reward_function(trajectory):
    # Plus de 50 lignes de logique de notation soigneuse...
    pass

# Après : Une seule ligne avec RULER
judged_group = await ruler_score_group(group, "openai/o3")

Quand choisir ART

ART peut convenir aux projets qui nécessitent :

1. Capacités d'agent en plusieurs étapes: Lorsque votre cas d'utilisation implique des agents qui doivent effectuer plusieurs actions, utiliser des outils ou entretenir des conversations prolongées

2. Prototypage rapide sans ingénierie des récompenses: La notation automatique des récompenses par RULER peut réduire le temps de développement de votre projet de 2 à 3 fois

3. Intégration avec des systèmes existants: Lorsque vous devez ajouter des capacités RL à une base de code agentique existante avec un minimum de modifications

Exemple de code : ART en action

import art
from art.rewards import ruler_score_group

# Initialiser le modèle avec un modèle de base pris en charge par Unsloth
model = art.TrainableModel(
    name="agent-001",
    project="my-agentic-task",
    base_model="Qwen/Qwen2.5-14B-Instruct",  # Tout modèle pris en charge par Unsloth
)

# Définissez votre fonction de rollout
async def rollout(model: art.Model, scenario: Scenario) -> art.Trajectory:
    openai_client = model.openai_client()
    trajectory = art.Trajectory(
        messages_and_choices=[
            {"role": "system", "content": "..."},
            {"role": "user", "content": "..."}
        ]
    )
    # Votre logique d'agent ici...    
    return trajectory

# Entraînez avec RULER pour des récompenses automatiques
groups = await art.gather_trajectory_groups(
    (
        art.TrajectoryGroup(rollout(model, scenario) for _ in range(8))
        for scenario in scenarios
    ),
    after_each=lambda group: ruler_score_group(
        group,
        "openai/o3",
        swallow_exceptions=True
    )
)

await model.train(groups)

Prise en main

Pour ajouter ART à votre projet basé sur Unsloth :

pip install openpipe-art # ou `uv add openpipe-art`

Puis consultez les notebooks d'exemple pour voir ART en action avec des tâches telles que :

• Agents de récupération d'e-mails qui battent o3

• Agents jouant à des jeux (2048, Tic Tac Toe, Codenames)

• Tâches de raisonnement complexes (Temporal Clue)