AI Prompt Engineering · Leçon

Ordre et récence des exemples

L’influence de l’ordre des exemples sur la sortie.

Leçon 3 sur 413 étapes

Ordre et récence des exemples est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 3 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.

L’ordre est un hyperparamètre caché

L’ordre des exemples utilisés avec quelques exemples peut faire varier la précision de plusieurs points de pourcentage, transformant parfois une invite presque aléatoire en une invite performante, et inversement. Cette instabilité existe même lorsque l’ensemble d’exemples reste fixe.

Traitez l’ordre comme un hyperparamètre à rechercher à part entière, et non comme un détail secondaire. Présenter des résultats avec quelques exemples sans contrôler l’ordre n’est pas scientifiquement rigoureux.

import itertools

def order_search(demos, eval_set, build, max_perms=24):
    perms = list(itertools.permutations(demos))[:max_perms]
    scored = [(p, evaluate(build(p), eval_set)) for p in perms]
    return max(scored, key=lambda x: x[1])

Explication du biais de récence

Les transformeurs ne comportant qu’un décodeur présentent un biais de récence : les jetons les plus proches du point de génération exercent une influence disproportionnée. La dernière démonstration avant la requête est la plus susceptible de déterminer le format, l’étiquette et le ton.

Ce phénomène est en partie un artefact des schémas d’attention et du codage positionnel. En pratique, ce que vous placez en dernier est ce que le modèle imite le plus facilement.

# Position weight intuition (illustrative, not exact)
# influence(example_i) roughly increases with proximity to the query
# => the FINAL demo disproportionately anchors the next generation
weights = [0.1, 0.15, 0.25, 0.5]  # earlier ... latest

Perdu au milieu

Les études sur les contextes longs révèlent un profil d’attention en forme de U : les modèles prêtent bien attention au début et à la fin du contexte, mais moins au milieu. Les démonstrations essentielles enfouies au milieu de l’invite sont en pratique négligées.

Placez vos exemples les plus importants ou les plus délicats au début ou, compte tenu du biais de récence, près de la fin ; ne les laissez jamais isolés au milieu d’un long bloc de démonstrations.

def place_key_demos(key, filler):
    # U-shape aware: key items at the edges, filler in the middle
    head = key[: len(key)//2]
    tail = key[len(key)//2 :]
    return head + filler + tail

Étiquette majoritaire et dernière position

Les biais de récence et d’étiquette majoritaire se renforcent mutuellement. Si votre dernière démonstration appartient à la classe A, le modèle aura tendance à prédire A. Combiné à un ensemble de démonstrations composé majoritairement d’exemples A, le a priori devient fortement biaisé.

Pour une classification équilibrée, alternez les étiquettes et veillez à ce que le dernier exemple n’appartienne pas toujours à la même classe dans vos variantes d’invite.

def alternate_labels(by_label, k):
    labels = list(by_label)
    out = []
    i = 0
    while len(out) < k:
        lbl = labels[i % len(labels)]
        if by_label[lbl]:
            out.append(by_label[lbl].pop())
        i += 1
    return out  # final element varies by construction

Démonstrations classées par similarité croissante

Une heuristique robuste pour l’apprentissage en contexte augmenté par récupération avec quelques exemples consiste à classer les exemples récupérés par similarité croissante avec la requête, afin que l’exemple le plus pertinent soit placé au plus près de la requête et bénéficie de la récence.

Cette approche associe la sélection dynamique à l’exploitation de la récence : le contexte pertinent est présent et positionné là où le modèle porte le plus fortement son attention.

def order_by_similarity(query_emb, retrieved):
    scored = [(d, cos(query_emb, d.emb)) for d in retrieved]
    scored.sort(key=lambda x: x[1])     # ascending
    return [d for d, _ in scored]        # most similar last (near query)

Ordre curriculum

Pour le raisonnement ou la génération, un ordre de type curriculum (du plus facile au plus difficile) peut aider le modèle à construire le comportement attendu, en terminant par un exemple complexe qui montre toute la profondeur du raisonnement juste avant la requête.

Cela dépend de la tâche : validez cette approche en la comparant à des ordres aléatoires et fondés sur la similarité au lieu de supposer qu’elle sera bénéfique.

def curriculum(demos, difficulty_fn):
    return sorted(demos, key=difficulty_fn)  # easiest first, hardest last

Mesurer la sensibilité à l’ordre

Quantifiez la fragilité de votre invite en échantillonnant de nombreux ordres et en indiquant la variance de l’exactitude. Une variance élevée signale une invite instable, susceptible de régresser de manière imprévisible en production.

Utilisez cette mesure pour comparer les conceptions d’invites : une invite robuste à l’ordre est plus sûre qu’une invite légèrement mieux notée, mais volatile.

import random

def order_sensitivity(demos, eval_set, build, trials=20):
    accs = []
    for _ in range(trials):
        perm = random.sample(demos, len(demos))
        accs.append(evaluate(build(perm), eval_set))
    return mean(accs), stdev(accs)  # report both; low stdev = robust

Sélection de l’ordre sans sondage

Lorsque vous ne disposez pas d’étiquettes pour noter les ordres, vous pouvez utiliser select pour choisir un ordre à partir de l’entropie des prédictions du modèle sur un ensemble de sondage : les ordres qui produisent des prédictions confiantes, à faible entropie et bien réparties ont tendance à mieux se généraliser (Lu et al., 2022).

Vous pouvez ainsi choisir une bonne permutation sans ensemble de validation annoté.

def select_order_by_entropy(perms, probe_inputs, build):
    def score(perm):
        ents = [entropy(model_probs(build(perm), x)) for x in probe_inputs]
        return -mean(ents)        # prefer confident, low-entropy orderings
    return max(perms, key=score)

Stabiliser par étalonnage

La sensibilité à l’ordre et le biais de récence accentuent tous deux certaines étiquettes. L’étalonnage contextuel atténue ce phénomène en estimant la distribution a priori du modèle sur une entrée sans contenu, puis en corrigeant les probabilités prédites, ce qui réduit l’influence d’un ordre particulier.

Un étalonnage associé à un ordre convenable produit un comportement plus stable en production que la recherche de la permutation unique la plus performante.

p_prior = model_probs(build(perm), content_free='N/A')
def calibrate(probs):
    return normalize(probs / p_prior)  # cancels order-induced label skew

Mise en cache et stabilité de l’ordre

Si vous utilisez la mise en cache des invites, le préfixe (y compris le bloc d’exemples) doit rester stable au niveau des octets pour que le cache soit utilisé. Réorganiser fréquemment les exemples à chaque requête empêche leur réutilisation dans le cache et augmente le coût ainsi que la latence.

Solution : fixez un ordre unique et validé pour le bloc statique d’exemples et mettez-le en cache ; réservez le réordonnancement dynamique à la fin récupérée, spécifique à la requête.

# Stable cached prefix + dynamic tail
prefix = render(FIXED_ORDERED_DEMOS)   # cache_control on this block
tail   = render(order_by_similarity(q_emb, retrieved))
prompt = prefix + tail + query

Liste de contrôle d’une stratégie d’ordonnancement

Réglages pratiques par défaut : équilibrez les étiquettes et alternez-les, placez les exemples clés ou difficiles aux extrémités (évitez le milieu), classez les exemples récupérés par similarité croissante afin que le meilleur soit proche de la requête, mesurez la variance selon l’ordre et appliquez un étalonnage pour réduire le biais résiduel.

Figez ensuite l’ordre pour la mise en cache et validez-le de nouveau chaque fois que l’ensemble d’exemples change.

def final_order(demos, q_emb):
    demos = alternate_labels(group(demos), len(demos))
    return order_by_similarity(q_emb, demos)  # validated, then cached

Vérification rapide

Réfléchissez à la position d’un exemple de démonstration essentiel.

Récapitulatif

Points essentiels :

  • L’ordre des exemples est un hyperparamètre qui peut faire varier l’exactitude de plusieurs points de pourcentage ; utilisez search et rendez compte de la variance.
  • Le biais de récence rend le dernier exemple le plus influent ; le phénomène « perdu au milieu » sous-pondère les exemples centraux.
  • Équilibrez et alternez les étiquettes, classez les exemples récupérés par similarité croissante et envisagez un ordre curriculum.
  • Lorsque les étiquettes sont rares, sélectionnez les ordres à l’aide de l’entropie et appliquez un étalonnage contextuel pour réduire le biais.
  • Figez un ordre stable pour la mise en cache des invites ; ne réorganisez que la fin récupérée dynamiquement.
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

Questions Fréquemment Posées

La leçon « Ordre et récence des exemples » est-elle gratuite ?

Oui — le texte complet de « Ordre et récence des exemples » 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 « Ordre et récence des exemples » ?

L’influence de l’ordre des exemples sur la sortie. 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 3 sur 4.

Combien de temps prend la leçon « Ordre et récence des exemples » ?

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

  1. Zéro, un ou quelques exemples
  2. Concevoir des exemples efficaces
  3. Ordre et récence des exemples
  4. Sélection dynamique de quelques exemples
← Retour à AI Prompt Engineering