Série d'entretiens IA n°6 : Les trois méthodologies fondamentales des agents IA : ReAct, Plan-and-Solve et Reflection

Les trois méthodologies fondamentales des agents IA : ReAct, Plan-and-Solve et Reflection

Un agent IA est un agent intelligent capable de percevoir son environnement, de prendre des décisions et d'exécuter des actions de manière autonome. Ses méthodologies fondamentales sont principalement au nombre de trois : ReAct, Plan-and-Solve et Reflection. Elles sont présentées ci-dessous, accompagnées de diagrammes de flux et d'exemples de code.

1. ReAct (Raisonnement + Action)

Idée centrale : Entrelacer le raisonnement et l'action. À chaque étape, l'agent réfléchit d'abord à l'état actuel et au plan suivant (raisonnement), puis exécute une action (comme appeler un outil, rechercher des informations), et continue à raisonner en fonction du résultat.

Diagramme de flux :

[État initial] → [Raisonnement : penser à l'étape suivante] → [Action : exécuter l'action] → [Observer le résultat] → [Raisonnement : mettre à jour le plan] → ... → [Réponse finale]

Exemple de code (pseudo-code) :

def react_agent(question):
    context = []
    while not solved:
        # Raisonnement : générer une étape de réflexion
        thought = llm.generate_thought(question, context)
        # Action : choisir une action en fonction de la réflexion
        action = llm.choose_action(thought)
        # Exécuter l'action, obtenir l'observation
        observation = execute_action(action)
        # Ajouter la réflexion, l'action et l'observation au contexte
        context.append((thought, action, observation))
    return final_answer

Exemple :
- L'utilisateur demande : "Quel temps fait-il à Pékin aujourd'hui ?"
- L'agent raisonne : "Je dois interroger l'API météo, j'ai besoin du nom de la ville et de la date."
- Action : appeler l'API météo (paramètres : Pékin, aujourd'hui)
- Observation : retourne "Ensoleillé, 25°C"
- Raisonnement : "J'ai obtenu l'information, je peux répondre."
- Sortie : "Il fait ensoleillé à Pékin aujourd'hui, 25°C."

2. Plan-and-Solve

Idée centrale : Élaborer d'abord un plan complet (Plan), puis l'exécuter progressivement (Solve). La phase de planification décompose la tâche complexe en sous-étapes, la phase d'exécution les réalise dans l'ordre, avec possibilité d'ajuster le plan en fonction des résultats intermédiaires.

Diagramme de flux :

[Tâche] → [Élaborer le plan : décomposer en sous-étapes] → [Exécuter l'étape 1] → [Exécuter l'étape 2] → ... → [Exécuter l'étape N] → [Réponse finale]

Exemple de code :

def plan_and_solve(task):
    # Phase de planification
    plan = llm.generate_plan(task)  # Par exemple : ["Rechercher des documents", "Organiser les informations", "Rédiger le rapport"]
    context = {}
    for step in plan:
        # Exécuter chaque étape
        result = execute_step(step, context)
        context[step] = result
    # Synthétiser les résultats
    final = llm.synthesize(context)
    return final

Exemple :
- Tâche : "Écrire un article de blog sur les agents IA"
- Plan :
1. Rechercher la définition et les dernières avancées des agents IA
2. Lire et organiser les points clés
3. Rédiger le plan de l'article
4. Remplir le contenu
5. Relire et publier
- Exécution : réaliser chaque étape dans l'ordre, produire finalement l'article de blog.

3. Reflection

Idée centrale : L'agent réfléchit sur son propre comportement pendant ou après l'exécution, évalue les résultats et améliore les actions suivantes. Cela inclut généralement l'autocritique, la correction d'erreurs ou l'optimisation de la stratégie.

Diagramme de flux :

[Action] → [Observer le résultat] → [Réflexion : évaluer le succès] → [Si échec : ajuster la stratégie] → [Agir à nouveau] → ... → [Succès]

Exemple de code :

def reflection_agent(task):
    max_attempts = 3
    for attempt in range(max_attempts):
        action = llm.generate_action(task)
        result = execute(action)
        # Réflexion
        reflection = llm.reflect(task, action, result)
        if reflection['success']:
            return result
        else:
            # Ajuster la description de la tâche ou la stratégie en fonction de la réflexion
            task = reflection['improved_task']
    return None

Exemple :
- Tâche : "Calculer 1234 * 5678"
- Action : calcul direct, obtention du résultat 7006652
- Réflexion : vérifier le processus de calcul, détection d'une erreur de retenue
- Ajustement : recalculer, obtention du résultat correct 7006652 (en réalité correct)
- Si toujours erroné, continuer à réfléchir jusqu'à ce que ce soit correct.

Résumé comparatif

Dans la pratique, ces trois méthodologies sont souvent combinées, par exemple en ajoutant un mécanisme de réflexion à ReAct, ou en réfléchissant après chaque étape dans Plan-and-Solve.