Meta-prompting : faire écrire des prompts au LLM

Meta-prompting : optimiser les prompts avec l'IA

Le meta-prompting consiste à utiliser un LLM pour générer, évaluer et améliorer des prompts. C'est une approche itérative qui produit souvent des prompts supérieurs à ceux écrits manuellement.

Pourquoi le meta-prompting ?

• Les humains ont des biais dans la rédaction de prompts
• Le LLM connaît ses propres "préférences" d'interprétation
• Permet d'explorer rapidement de nombreuses variantes
• Automatise l'optimisation sur un dataset d'évaluation

Technique 1 : Prompt Generation

Je veux créer un prompt pour la tâche suivante :
{description_tâche}

Contraintes :
- Le prompt sera utilisé avec {modèle}
- Input typique : {exemple_input}
- Output attendu : {exemple_output}
- Le prompt doit être robuste face aux cas limites

Génère 3 variantes de prompt, du plus simple au plus élaboré.
Pour chaque variante, explique ses forces et faiblesses.

Technique 2 : Prompt Critique et Amélioration

Voici mon prompt actuel :
---
{prompt_actuel}
---

Voici un cas où il échoue :
Input: {input_problématique}
Sortie obtenue: {sortie_incorrecte}
Sortie attendue: {sortie_correcte}

Analyse pourquoi le prompt échoue sur ce cas.
Propose une version améliorée qui résout ce problème
sans dégrader les cas qui fonctionnent déjà.

Technique 3 : APE (Automatic Prompt Engineer)

L'approche APE de Zhou et al. (2022) automatise la recherche de prompts optimaux :

def automatic_prompt_engineering(task_examples, n_candidates=10):
    # 1. Générer des candidats
    candidates = []
    for _ in range(n_candidates):
        prompt = llm.generate(f"""
            Voici des exemples input/output d'une tâche :
            {task_examples}
            Génère une instruction qui produirait ces outputs
            à partir de ces inputs.
        """)
        candidates.append(prompt)

    # 2. Évaluer chaque candidat
    scores = []
    for candidate in candidates:
        score = evaluate_prompt(candidate, eval_dataset)
        scores.append(score)

    # 3. Sélectionner et raffiner le meilleur
    best = candidates[argmax(scores)]
    refined = llm.generate(f"Améliore ce prompt : {best}")
    return refined

Technique 4 : Prompt Chaining pour l'optimisation

def iterative_optimization(initial_prompt, eval_set, n_iterations=5):
    current_prompt = initial_prompt

    for i in range(n_iterations):
        # Évaluer
        results = evaluate(current_prompt, eval_set)
        failures = get_failures(results)

        if not failures:
            break

        # Améliorer
        current_prompt = llm.generate(f"""
            Prompt actuel : {current_prompt}
            Score : {results['score']}
            Cas d'échec : {failures[:3]}
            Améliore le prompt pour corriger ces échecs.
        """)

    return current_prompt

Technique 5 : A/B Testing de prompts

def ab_test_prompts(prompt_a, prompt_b, test_cases, judge_llm):
    results = {"a_wins": 0, "b_wins": 0, "ties": 0}

    for case in test_cases:
        output_a = llm.generate(prompt_a.format(**case))
        output_b = llm.generate(prompt_b.format(**case))

        # LLM-as-judge pour comparer
        winner = judge_llm.compare(output_a, output_b, case["criteria"])
        results[winner] += 1

    return results

Bonnes pratiques

• Toujours évaluer sur un dataset, jamais sur un seul exemple
• Garder un historique des versions et de leurs scores
• Vérifier que l'optimisation ne sur-ajuste pas aux cas de test
• Tester le prompt optimisé sur des cas hors-distribution
• Combiner meta-prompting avec validation humaine