AI Prompt Engineering · Leçon

Analyse des causes profondes des problèmes d’invites

Déterminez si l’échec vient du contexte, de l’instruction, du format ou des capacités du modèle.

Leçon 2 sur 413 étapes

Analyse des causes profondes des problèmes d’invites est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 2 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 l’analyse des causes profondes est importante

Lorsqu’une invite échoue, plusieurs causes sont possibles. Modifier des mots au hasard fait perdre du temps et peut corriger le symptôme sans corriger la cause profonde — ce qui entraîne le même échec avec des entrées légèrement différentes.

L’analyse des causes profondes (RCA) est un processus systématique qui vise à isoler la raison précise pour laquelle une invite échoue, afin que la correction traite le véritable problème.

Les quatre catégories de causes profondes

Tout échec d’une invite remonte à l’une des quatre causes profondes suivantes :

Problème de contexte : le modèle ne dispose pas des informations nécessaires pour répondre correctement
Ambiguïté de l’instruction : l’instruction admet plusieurs interprétations valides et le modèle choisit la mauvaise
Conflit de format : deux parties de l’invite donnent des instructions de mise en forme contradictoires
Limite des capacités du modèle : la tâche nécessite un raisonnement ou des connaissances que ce modèle ne peut pas fournir de manière fiable

Cause profonde 1 : Problème de contexte

Un problème de contexte survient lorsque le modèle répond incorrectement parce que l’invite ne fournit pas les informations nécessaires. Le modèle comble cette lacune avec les données d’entraînement, qui peuvent être obsolètes, incorrectes ou être à l’origine d’une hallucination.

Vérification : fournissez directement les informations manquantes dans l’invite et observez si la réponse s’améliore. Si c’est le cas, la correction consiste à ajouter du contexte, par exemple au moyen de la récupération RAG.

# Failing prompt — no context
prompt_v1 = 'What is the current price of our Pro plan?'

# Context problem test: inject the information
prompt_v2 = '''
Our pricing (as of today):
- Free: $0/month
- Pro: $19/month
- Enterprise: $99/month

Question: What is the current price of our Pro plan?
'''
# If v2 succeeds and v1 fails -> root cause is context problem

Cause profonde 2 : Ambiguïté de l’instruction

Une ambiguïté de l’instruction survient lorsque l’invite peut raisonnablement être interprétée de plusieurs façons et que le modèle choisit la mauvaise interprétation.

Exemple : « Résumez brièvement » — « brièvement » signifie-t-il une phrase, un paragraphe ou trois points de liste ? Le modèle devine. Vérification : remplacez la formulation ambiguë par une spécification précise et vérifiez si l’échec disparaît.

# Ambiguous
prompt_ambiguous = 'Summarize the following article briefly.'

# Precise — ambiguity removed
prompt_precise = (
    'Summarize the following article in exactly 2 sentences. '
    'Do not exceed 50 words. Output only the summary, nothing else.'
)

# Test: if precise version succeeds, root cause was ambiguity
# Fix: replace vague qualifiers with exact specifications

Cause profonde 3 : Conflit de format

Un conflit de format survient lorsque deux parties de l’invite donnent des instructions contradictoires. Le modèle doit en choisir une et ignorer l’autre — il choisit généralement l’instruction la plus récente ou la plus mise en évidence.

Exemple : l’invite système indique « répondez en texte brut », tandis que le message utilisateur indique « utilisez une mise en forme ». Le modèle peut suivre l’une ou l’autre, de manière incohérente.

# Format conflict example
system_prompt = 'You are a helpful assistant. Always respond in plain text without any formatting.'

user_message = 'List the top 5 benefits of exercise. Use markdown bullet points.'

# The model faces a conflict: plain text vs markdown.
# Detection: if output format is inconsistent across runs, look for conflicting instructions.

# Fix: ensure all format instructions agree. Move format to system prompt only.
system_prompt_fixed = (
    'You are a helpful assistant. '
    'Always respond using markdown bullet points for lists.'
)

Cause fondamentale 4 : limite des capacités du modèle

Un échec dû à une limite des capacités se produit lorsque la tâche dépasse réellement ce que le modèle peut faire de manière fiable. Cela diffère des trois autres causes : aucune modification de l’invite ne permettra de le corriger entièrement.

Signes : le taux d’échec reste élevé même avec des instructions claires et un contexte complet. Corrections : utilisez un modèle plus puissant, divisez la tâche en étapes plus simples ou ajoutez une étape de vérification.

# Capability limit test: try the same task on different models
models = ['gpt-4o-mini', 'gpt-4o', 'gpt-4o-2024-11-20']
results = {}

for model in models:
    resp = client.chat.completions.create(
        model=model,
        messages=[{'role': 'user', 'content': complex_reasoning_prompt}]
    )
    results[model] = evaluate(resp.choices[0].message.content)

# If accuracy improves with more capable models -> capability limit
for model, score in results.items():
    print(f'{model}: {score:.0%} accuracy')

La méthode d’isolation

Pour identifier la cause fondamentale active, utilisez une isolation systématique :

Exécutez l’invite qui échoue et classez le type d’échec (réponse incorrecte, format, etc.)
Ajoutez des informations → si le problème est résolu : problème de contexte
Clarifiez les instructions → si le problème est résolu : ambiguïté
Vérifiez les contradictions → si le problème est résolu : conflit de format
Mettez le modèle à niveau → si le problème est résolu : limite des capacités

Une seule correction devrait être nécessaire. Si plusieurs corrections sont nécessaires, plusieurs causes fondamentales étaient présentes.

def rca_test(base_prompt, test_input, expected_output):
    results = {}

    # Test 1: base (failing) prompt
    results['base'] = run_and_evaluate(base_prompt, test_input, expected_output)

    # Test 2: add context
    results['with_context'] = run_and_evaluate(
        base_prompt + '\nContext: ' + get_context(test_input),
        test_input, expected_output
    )

    # Test 3: clarify instructions
    results['clarified'] = run_and_evaluate(
        clarify(base_prompt), test_input, expected_output
    )

    for name, passed in results.items():
        print(f'{name}: {"PASS" if passed else "FAIL"}')

Élimination ou confirmation

RCA suit deux modes :

Élimination : écarter les causes qui sont NOT responsables (tester chaque hypothèse et voir laquelle NOT modifie la sortie)
Confirmation : identifier la cause qui, une fois corrigée, résout systématiquement l’échec sur plusieurs entrées de test

La confirmation nécessite au moins 3 entrées de test. Une correction qui fonctionne sur une entrée mais pas sur les autres n’a pas résolu la cause fondamentale ; elle a peut-être seulement corrigé un symptôme.

def confirm_root_cause(fix_fn, test_cases, threshold=0.9):
    '''fix_fn: a function that takes a prompt and returns a fixed prompt'''
    passed = 0
    for case in test_cases:
        fixed_prompt = fix_fn(case['prompt'])
        result = run_and_evaluate(fixed_prompt, case['input'], case['expected'])
        if result:
            passed += 1

    pass_rate = passed / len(test_cases)
    print(f'Fix pass rate: {pass_rate:.0%}')
    if pass_rate >= threshold:
        print('Root cause CONFIRMED — fix is reliable.')
    else:
        print('Root cause NOT confirmed — failure has multiple causes.')

Documenter la cause fondamentale

Après avoir identifié la cause fondamentale, documentez-la dans le journal des modifications de l’invite. Incluez :

Le type d’échec observé
La catégorie de la cause fondamentale
L’hypothèse testée
Les éléments probants (quel test a réussi après la correction)
La modification précise apportée à l’invite

Cela évite que de futurs ingénieurs réexaminent le même échec et permet de repérer des schémas entre les invites.

rca_record = {
    'prompt_id': 'summarize_v3',
    'failure_type': 'wrong_format',
    'root_cause': 'format_conflict',
    'hypothesis': 'System prompt said plain text, user message asked for markdown',
    'evidence': 'Removing markdown instruction from user message resolved failure on 8/8 test cases',
    'fix_applied': 'Moved all format instructions to system prompt; removed format instructions from user template',
    'fix_date': '2024-11-15'
}

Erreur courante : corriger la mauvaise cause

L’erreur la plus courante dans RCA consiste à corriger le symptôme plutôt que la cause. Exemple :

Symptôme : le modèle renvoie un JSON précédé d’un préfixe de texte explicatif supplémentaire
Mauvaise correction : ajouter un traitement ultérieur pour supprimer le texte explicatif de la sortie
Cause fondamentale réelle : aucune instruction de format dans l’invite + le modèle adopte par défaut un style conversationnel
Correction appropriée : ajouter l’instruction explicite « Renvoyez uniquement un JSON valide. Aucun autre texte. »

Les astuces de traitement ultérieur accumulent une dette technique. Les corrections de la cause fondamentale sont durables.

RCA pour les échecs intermittents

Certains échecs sont intermittents : l’invite fonctionne 80 % du temps, mais échoue 20 % du temps. Ils sont plus difficiles à diagnostiquer, car une seule exécution de l’invite produit un résultat correct.

Approche : exécutez l’invite 10 à 20 fois avec la même entrée. Si le taux d’échec est non nul, l’invite a une cause fondamentale probabiliste — généralement une ambiguïté des instructions ou une température élevée. Correction : rendez l’instruction plus précise ou réduisez la température.

def measure_failure_rate(prompt, test_input, expected, runs=20):
    failures = 0
    for _ in range(runs):
        resp = client.chat.completions.create(
            model='gpt-4o',
            messages=[{'role': 'user', 'content': prompt + '\n' + test_input}],
            temperature=0.7
        )
        if not evaluate(resp.choices[0].message.content, expected):
            failures += 1
    print(f'Failure rate: {failures}/{runs} = {failures/runs:.0%}')

Vérification des connaissances

Une invite demande une réponse JSON, mais renvoie parfois un JSON précédé d’un préfixe conversationnel comme « Bien sûr ! Voici le JSON : ». Après avoir ajouté « Renvoyez uniquement un JSON valide. Aucun autre texte. », l’échec cesse. Quelle était la cause fondamentale ?

Réponds-y dans la leçon interactive

Récapitulatif : analyse des causes fondamentales

Les quatre catégories de causes fondamentales des échecs d’invites :

Problème de contexte : le modèle ne dispose pas des informations nécessaires — correction : ajoutez du contexte via RAG ou une injection directe
Ambiguïté de l’instruction : instruction vague avec plusieurs interprétations — correction : ajoutez de la précision
Conflit de format : instructions de format contradictoires — correction : regroupez-les dans l’invite système
Limite des capacités du modèle : la tâche dépasse les capacités du modèle — correction : mettez le modèle à niveau ou décomposez la tâche

Utilisez une isolation systématique pour tester chaque hypothèse. Confirmez la correction sur plusieurs cas de test. Documentez vos conclusions. Prochaine leçon : débogage systématique par recherche binaire.

Gratuit pour commencer

Apprends AI Prompt Engineering avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 53
Leçons: 199

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Analyse des causes profondes des problèmes d’invites » est-elle gratuite ?

Oui — le texte complet de « Analyse des causes profondes des problèmes d’invites » 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 « Analyse des causes profondes des problèmes d’invites » ?

Déterminez si l’échec vient du contexte, de l’instruction, du format ou des capacités du modèle. 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 2 sur 4.

Combien de temps prend la leçon « Analyse des causes profondes des problèmes d’invites » ?

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

Diagnostiquer les sorties inattendues
Analyse des causes profondes des problèmes d’invites
Approche systématique du débogage
Stratégies de journalisation et de documentation

← Retour à AI Prompt Engineering