> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/training-ai-agents-with-rl.md).

# Entraîner des agents IA avec RL

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

L’IA « agentique » gagne en popularité avec le temps. Dans ce contexte, un « agent » est un LLM auquel on attribue 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 l’effet qu’elle a eu sur l’environnement, puis effectuer une autre action de manière répétée, jusqu’à atteindre leur objectif ou échouer en essayant.

Malheureusement, même des LLM très performants peuvent avoir du mal à exécuter de manière fiable des tâches agentiques complexes sur plusieurs tours. Fait intéressant, nous avons constaté qu’entraîner des agents à l’aide d’un algorithme RL appelé [GRPO (Group Relative Policy Optimization)](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo.md) peut les rendre beaucoup plus fiables ! Dans ce guide, vous apprendrez à construire des agents IA fiables à l’aide d’outils open source.

## 🎨 Entraîner des agents RL avec ART

[ART (Agent Reinforcement Trainer)](https://github.com/openpipe/art) construit au-dessus du [Unsloth](https://github.com/unslothai/unsloth)GRPOTrainer d’Unsloth, est un outil qui rend l’entraînement d’agents multi-tours possible et facile. Si vous utilisez déjà Unsloth pour GRPO et avez besoin d’entraîner des agents capables de gérer des interactions complexes sur plusieurs tours, ART simplifie le processus.

<div align="left"><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-c97e63a69ecd17685c6e09cb41fd625d43a3545d%2FScreenshot_2025-07-19_at_1.23.18_PM.webp?alt=media" alt="" width="375"><figcaption><p>Les modèles d’agent entraînés avec Unsloth+ART sont souvent capables de surpasser les modèles pilotés par prompt sur les flux de travail agentiques.</p></figcaption></figure></div>

### ART + Unsloth

ART s’appuie sur l’implémentation de GRPO d’Unsloth, économe en mémoire et en calcul. De plus, il ajoute les capacités suivantes :

#### 1. Entraînement 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 les bases de code existantes

Si vous avez déjà un agent qui fonctionne avec un modèle piloté par prompt, ART cherche à minimiser le nombre de modifications que vous devez apporter pour encapsuler votre boucle d’agent existante et l’utiliser pour l’entraînement.

Sur le plan architectural, ART est divisé en un client « frontend » qui réside dans votre base de code et communique via API avec un « backend » où se déroule l’entraînement réel (ils peuvent aussi être co-localisés sur une seule machine si vous préférez utiliser le `LocalBackend`d’ART). Cela apporte plusieurs avantages clés :

* **Configuration minimale requise**: Le frontend d’ART a très peu de dépendances et peut être facilement ajouté aux bases de code Python existantes.
* **Entraînement 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 doté de GPU, ou l’exécuter sur un GPU local
* **API compatible avec OpenAI**: Le backend ART expose votre modèle en cours d’entraînement via une API compatible avec OpenAI, qui est compatible avec la plupart des bases de code existantes.

#### 3. RULER : récompenses zero-shot pour agents

ART fournit également une fonction de récompense générale intégrée appelée [RULER](https://art.openpipe.ai/fundamentals/ruler) (Relative Universal LLM-Elicited Rewards), qui peut éliminer le besoin de fonctions de récompense conçues à la main. Étonnamment, les agents entraînés par RL avec la fonction de récompense automatique RULER égalent souvent ou surpassent les performances des agents entraînés à l’aide de fonctions de récompense écrites manuellement. Cela facilite la prise en main du RL.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-b4168c3c380f6c8258c31083dcb65a5fcd2308b8%2FScreenshot_2025-07-19_at_1.21.08_PM.webp?alt=media" alt="" width="375"><figcaption></figcaption></figure>

```python
# Avant : des heures d’ingénierie de récompense
def complex_reward_function(trajectory):
    # Plus de 50 lignes de logique d’évaluation minutieuse...
    pass

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

### Quand choisir ART

ART peut être un bon choix pour des projets qui ont besoin de :

1. **Capacités d’agent en plusieurs étapes**: Lorsque votre cas d’usage implique des agents qui doivent effectuer plusieurs actions, utiliser des outils ou avoir des conversations prolongées
2. **Prototypage rapide sans ingénierie de récompense**: L’évaluation automatique des récompenses de 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

```python
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éfinir votre fonction de déroulement
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îner 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 :

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

Ensuite, consultez les [notebooks d’exemple](https://art.openpipe.ai/getting-started/notebooks) pour voir ART en action avec des tâches comme :

* Des agents de récupération d’e-mails qui battent o3
* Des agents jouant à des jeux (2048, morpion, Codenames)
* Des tâches de raisonnement complexe (Temporal Clue)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/training-ai-agents-with-rl.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
