AI Prompt Engineering · Leçon

Boucles de correction et de validation

Corriger une sortie mal formée.

Boucles de correction et de validation est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Prompt Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Prompt Engineering comprend 4 leçons au total.

Pourquoi les boucles de correction existent

Même avec des schémas, la sortie peut échouer : JSON tronqué à cause d’une limite de jetons, champs supplémentaires halluciné, chaîne de caractères à la place d’un nombre attendu ou règle métier non respectée. Une boucle de correction détecte l’échec et le renvoie au modèle pour qu’il le corrige.

C’est le filet de sécurité qui transforme un taux de réussite de 98 % en un taux de 99,9 %.

Le cycle de validation et de correction

La boucle canonique consiste à générer, valider et, en cas d’invalidité, reformuler la demande en indiquant l’erreur précise, jusqu’à un nombre maximal d’essais.

def generate_valid(prompt, schema, max_tries=3):
    msgs = [{'role': 'user', 'content': prompt}]
    for _ in range(max_tries):
        out = call_model(msgs)
        ok, err = validate(out, schema)
        if ok:
            return out
        msgs.append({'role': 'assistant', 'content': out})
        msgs.append({'role': 'user',
                     'content': 'Invalid. Fix this error and resend JSON only: ' + err})
    raise ValueError('repair budget exhausted')

Les erreurs précises sont meilleures que les erreurs génériques

La qualité de la correction dépend de la précision du retour. « JSON non valide » aide peu ; « Le champ rating doit être un entier compris entre 1 et 5, mais la valeur obtenue est 7 » corrige presque toujours le problème en un seul tour.

Renvoyez au modèle le message d’erreur exact de votre validateur (chemin et raison).

def validate(obj, schema):
    v = jsonschema.Draft202012Validator(schema)
    errs = sorted(v.iter_errors(obj), key=lambda e: e.path)
    if not errs:
        return True, None
    msg = '; '.join(f"{list(e.path)}: {e.message}" for e in errs)
    return False, msg

Validation par niveaux

La validation comporte plusieurs niveaux ; commencez par le moins coûteux :

Syntaxique — le contenu peut-il être analysé comme du JSON ?
Structurelle — correspond-il au schéma ?
Sémantique — les valeurs respectent-elles les règles métier et les invariants entre champs ?

Une remise ne peut pas dépasser le sous-total, même si les deux valeurs sont des nombres valides ; il s’agit d’un check sémantique.

def semantic_ok(o):
    return o['discount'] <= o['subtotal'] and o['total'] == o['subtotal'] - o['discount']

Correction déterministe préalable

Avant de consommer un appel au modèle, essayez des corrections déterministes peu coûteuses pour les défauts courants :

strip les clôtures de blocs de code Markdown.
Extrayez l’objet JSON le plus extérieur du texte qui l’entoure.
Supprimez les virgules finales.

Ne passez à une correction par le modèle que si le nettoyage déterministe échoue.

def extract_json(text):
    text = text.strip().removeprefix('json').strip()
    start, end = text.find('{'), text.rfind('}')
    if start != -1 and end != -1:
        return text[start:end + 1]
    return text

Gérer la troncature

Si finish_reason == 'length', le JSON est tronqué ; corriger le fragment est inutile. Augmentez plutôt max_tokens, réduisez la charge utile demandée ou diffusez la sortie et demandez une continuation. Distinguez la troncature d’une sortie mal formée, car ces deux situations exigent des réponses opposées.

if resp.choices[0].finish_reason == 'length':
    # do NOT feed truncated JSON back; regenerate with more room
    return retry_with(max_tokens=resp_max * 2)

Limiter la boucle

Une correction sans limite représente un risque en matière de coûts et de latence, et un modèle bloqué peut boucler indéfiniment. Limitez toujours le nombre d’essais, ajoutez un budget par demande et définissez une solution de repli (dégradation progressive, mise en file pour examen humain ou renvoi d’une valeur par défaut sûre).

try:
    data = generate_valid(prompt, schema, max_tries=3)
except ValueError:
    log_for_review(prompt)
    data = SAFE_DEFAULT

Correction dans les appels d’outils

Pour les appels de fonctions, le canal de correction est le résultat de l’outil. Renvoyez une erreur structurée et le modèle se corrige de lui-même au tour suivant ; aucune boucle distincte n’est nécessaire.

msgs.append({'role': 'tool', 'tool_call_id': call.id,
  'content': json.dumps({'error': 'amount must be positive', 'got': args['amount']})})
# next model turn will re-issue the call with a corrected argument

Idempotence et effets secondaires

Lorsqu’une boucle de correction entoure une action (et pas seulement une génération), assurez-vous que les nouvelles tentatives sont idempotentes. Utilisez des clés d’idempotence afin qu’un appel réémis ne facture pas deux fois et ne duplique pas un enregistrement. Validez avant de déclencher les effets secondaires, jamais après.

Observer les taux de correction

Le taux de correction est un indicateur avancé de qualité. Une hausse peut signaler une régression des instructions, un schéma trop strict ou une dérive du modèle. Log le nombre d’essais par réussite et les principaux chemins d’erreur, puis déclenchez une alerte lorsqu’ils augmentent fortement.

metrics.histogram('llm.repair.attempts', tries)
metrics.increment('llm.repair.error', tags={'path': top_error_path})

Combiner contraintes et correction

La chaîne de traitement la plus robuste superpose plusieurs défenses : décodage contraint ou mode de schéma strict pour réduire les échecs, nettoyage déterministe pour les corrections peu coûteuses et boucle de correction par le modèle, limitée, pour les rares problèmes résiduels. Aucune couche ne suffit à elle seule.

Vérification rapide

L’API renvoie une raison de fin length avec un JSON tronqué. Quelle est la réponse correcte ?

Récapitulatif

Chaînes de traitement de correction robustes :

Validez par niveaux : syntaxique, structurel, sémantique.
Renvoyez au modèle des erreurs précises, au niveau du chemin.
Essayez un nettoyage déterministe avant de payer le coût d’un appel au modèle.
Détectez séparément la troncature et régénérez la sortie.
Limitez les essais, assurez l’idempotence et surveillez les taux de correction.

Vous avez terminé la génération structurée. Cours suivant : garde-fous et validation de la sortie.

Questions Fréquemment Posées

La leçon « Boucles de correction et de validation » est-elle gratuite ?

Oui — le texte complet de « Boucles de correction et de validation » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Prompt Engineering, passe à CoddyKit PRO. Le cours AI Prompt Engineering comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Boucles de correction et de validation » ?

Corriger une sortie mal formée. Tu pratiques AI Prompt Engineering avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Prompt Engineering ?

Aucune expérience préalable n'est requise. AI Prompt Engineering sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Boucles de correction et de validation » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Prompt Engineering ?

Oui. Chaque leçon AI Prompt Engineering inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à AI Prompt Engineering