Agents d'IA auto-correcteurs : comment créer une IA qui apprend de ses erreurs-Tutoriel Python-php.cn

Self-Correcting AI Agents: How to Build AI That Learns From Its Mistakes

Présentation

Et si votre agent IA pouvait reconnaître ses propres erreurs, en tirer des leçons et réessayer, sans intervention humaine ? Bienvenue dans le monde des agents IA auto-correcteurs.

La plupart des modèles d'IA génèrent des résultats en une seule tentative. Mais les agents autocorrecteurs vont plus loin. Ils peuvent identifier le moment où une erreur se produit, analyser la cause et appliquer un correctif, le tout en temps réel. Considérez-le comme une IA avec un état d'esprit intégré « essais et erreurs ».

Dans ce blog, vous apprendrez :

Ce que l'autocorrection signifie pour les agents IA.
Comment construire un agent qui s'adapte aux erreurs.
Comment appliquer le modèle de réflexion dans la conception d'agents.

À la fin, vous saurez comment concevoir des agents d'IA qui non seulement échouent gracieusement, mais qui s'améliorent également à chaque tentative.

1️⃣ Qu'est-ce qu'un agent auto-correcteur ?

Un agent autocorrectif est un système d'IA capable de reconnaître ses propres échecs et de tenter une nouvelle stratégie. Si l'approche initiale ne fonctionne pas, l'agent réévalue et essaie une voie alternative.

Analogie :

Imaginez demander à un chef de préparer un gâteau, mais il utilise trop de sucre la première fois. Une IA standard continuerait à commettre la même erreur. Mais une IA auto-correctrice remarquerait l'erreur, réduirait le sucre la prochaine fois et ajusterait jusqu'à ce que le gâteau ait un goût parfait.

Pourquoi les agents auto-correcteurs sont-ils importants ?

La plupart des outils d'IA (comme ChatGPT) ne peuvent vous donner qu'une seule réponse. Si c'est faux, vous devez lui demander manuellement de "réessayer". Mais un agent autocorrecteur peut réessayer de manière autonome.

?️ Exemple de cas d'utilisation :

On demande à une IA d'écrire une fonction Python qui calcule les nombres de Fibonacci.

Tentative 1 : L'IA écrit une fonction récursive lente.

Auto-correction : Il remarque que la récursivité est trop lente.

Tentative 2 : L'IA réécrit la fonction à l'aide d'une programmation dynamique, la rendant plus rapide.

2️⃣ Techniques clés pour l'autocorrection

Comment rendre un agent suffisamment conscient de lui-même pour reconnaître ses erreurs ? Voici trois techniques principales :

1. Détection d'erreur

Identifiez si le résultat est « faux » (comme un échec d'appel d'API, une sortie incorrecte ou de mauvaises performances).
Utilisez des codes d'erreur, des exceptions ou des cas de test pour détecter les échecs.

2. Réflexion

Les agents réfléchissent à leurs décisions, se demandent : « Qu'est-ce qui n'a pas fonctionné ? » et planifient leur prochaine étape.
La réflexion peut être obtenue en enregistrant les erreurs, en suivant les appels d'API infructueux ou en réévaluant la qualité des réponses.

3. Réessayer la logique

Après réflexion, les agents réessayent avec une stratégie améliorée.
Cela peut impliquer de changer de fournisseur d'API, d'utiliser une logique plus efficace ou d'appliquer une approche de sauvegarde.

? Conseil de pro :

Les journaux d'erreurs peuvent être réinjectés dans le modèle d'IA pour améliorer les performances futures.

3️⃣ L'autocorrection en pratique

Créons un agent IA auto-correctif à l'aide de Python et FastAPI.

?‍? Étape 1 : Le problème

Nous voulons un agent IA capable de générer une fonction Python. Si la fonction ne s'exécute pas ou produit un résultat incorrect, l'agent se corrigera automatiquement.

Problème : Écrivez une fonction de Fibonacci qui calcule le 10ème nombre de Fibonacci.

Défi : Si l'agent génère une version récursive (qui est lente), il doit le reconnaître et la réécrire en utilisant la programmation dynamique.

?‍? Étape 2 : Configurer l'agent

Installez les dépendances nécessaires :

pip install openai fastapi uvicorn

Copier après la connexion

?‍? Étape 3 : Écrivez à l'agent

Voici comment fonctionne l'agent :

Il génère une fonction Python en utilisant API d'OpenAI.
Il exécute la fonction pour vérifier si elle fonctionne.
Si la fonction échoue (lente, erronée ou erreur), elle reflète et corrige l'approche.

Mise en œuvre du code

import openai
import time
import asyncio

# ? Replace with your OpenAI API key
openai.api_key = "your_openai_api_key_here"

# ? Step 1: Ask the AI to generate a Fibonacci function
async def generate_fibonacci_function():
    prompt = "Write a Python function to calculate the 10th Fibonacci number."
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )
    function_code = response['choices'][0]['message']['content']
    return function_code

# ? Step 2: Test the function to see if it works
def test_fibonacci_function(function_code):
    try:
        exec(function_code)  # Run the function in a safe execution environment
        result = eval("fibonacci(10)")  # Call the function with n=10
        if result == 55:  # Correct Fibonacci value for n=10
            return "success", result
        else:
            return "wrong_output", result
    except Exception as e:
        return "error", str(e)

# ? Step 3: Self-Correct by asking for a new version of the function
async def self_correct_function():
    max_attempts = 3
    for attempt in range(max_attempts):
        print(f"? Attempt {attempt + 1}")

        # Generate a new Fibonacci function
        function_code = await generate_fibonacci_function()
        print(f"Generated function:\n{function_code}\n")

        # Test the function to see if it works
        status, result = test_fibonacci_function(function_code)
        if status == "success":
            print(f"✅ Success! Fibonacci(10) = {result}")
            return
        elif status == "wrong_output":
            print(f"❌ Incorrect result: {result}. Asking AI to try a better method.")
        else:
            print(f"? Error: {result}. Asking AI to try again.")

    print("❌ Max attempts reached. Could not generate a correct function.")

# ? Run the correction process
asyncio.run(self_correct_function())

Copier après la connexion

4️⃣ Comment ça marche

Générer une fonction : L'IA écrit une fonction Python pour Fibonacci.
Exécuter la fonction : L'agent exécute la fonction et vérifie le résultat.
Auto-correction : si le résultat est erroné, il invite OpenAI à essayer à nouveau avec une approche plus intelligente.

Exemple de sortie

pip install openai fastapi uvicorn

Copier après la connexion

5️⃣ Modèles clés dans les agents auto-correcteurs

Détection d'erreurs : recherchez une sortie incorrecte, des performances lentes ou des exceptions.
Réflexion : Enregistrez le problème. Pourquoi a-t-il échoué ?
Réessayer Logique : Appelez une nouvelle version de la fonction, mais plus intelligente cette fois.

? Conseil de pro :

Utilisez une boucle de rétroaction pour permettre à l'agent d'apprendre de ses erreurs. Renvoyez les journaux à l'agent pour l'aider à reconnaître les problèmes courants.

6️⃣ Quand devriez-vous utiliser des agents auto-correcteurs ?

Les agents autocorrectifs sont utiles dans les cas où les pannes sont fréquentes et où l'intervention manuelle est coûteuse.

Appels API : réessayez si une API échoue.
Génération de code : régénérez le code s'il génère des erreurs.
Analyse des données : corrigez les prédictions incorrectes dans les modèles ML.

7️⃣ Avantages des agents auto-correcteurs

Problem	Solution
Agent gets it wrong	Retry with a better approach
API request fails	Retry with exponential backoff
Code generation error	Use a smarter prompt

Problème Solution ête> L'agent se trompe Réessayez avec une meilleure approche La requête API échoue Réessayer avec une interruption exponentielle Erreur de génération de code Utiliser une invite plus intelligente

8️⃣ Passez au niveau supérieur

Utiliser un cache : stockez les sorties réussies afin que l'agent ne reparte pas de zéro.
Ajouter des boucles de rétroaction : si une fonction échoue souvent, alimentez les journaux dans un processus de formation.
Suivez la confiance de l'agent : si l'agent n'est pas sûr, demandez-lui d'exécuter des cas de test.

9️⃣ Conclusion

Vous disposez maintenant du modèle d'un agent auto-correcteur capable d'écrire, de tester et de corriger les fonctions Python. Voici ce que nous avons couvert :

Les 3 piliers de l'autocorrection : Détection d'erreur, réflexion, logique de nouvelle tentative.
Comment créer un agent qui génère et teste des fonctions Python.
Bonnes pratiques pour créer des agents plus intelligents et plus fiables.

? Défi :

Créez un agent autocorrectif qui non seulement génère du code, mais évalue les performances d'exécution. Si la fonction est trop lente, demandez-lui de réécrire la fonction pour l'optimiser.

Vous voulez en savoir plus sur la création de LLM Responsive ? Consultez mon cours sur newline : Applications LLM réactives avec événements envoyés par le serveur

Je couvre :