Zéro, un ou quelques exemples
Choisir le nombre d’exemples.
Zéro, un ou quelques exemples est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 1 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.
Le spectre des exemples
Les exemples désignent le nombre de démonstrations annotées placées dans l'instruction avant la requête à traiter. Le mode sans exemple repose entièrement sur les a priori préentraînés du modèle ; le mode à quelques exemples conditionne le modèle sur une petite distribution propre à la tâche au moment de l'inférence, sans aucune mise à jour des poids.
Il s'agit de l'apprentissage en contexte (ICL) : le transformeur traite les exemples comme une partie de la séquence et effectue implicitement une forme de régression issue d'un méta-apprentissage. Le choix de k, c'est-à-dire le nombre d'exemples, est un hyperparamètre que vous réglez empiriquement, et non une pratique optimale fixe.
from dataclasses import dataclass
@dataclass
class ICLConfig:
k: int # number of demonstrations
selection: str # 'static' | 'dynamic'
order: str # 'random' | 'similarity' | 'curriculum'
# Zero-shot is simply k=0
cfg = ICLConfig(k=0, selection='static', order='random')Quand le sans-exemple l’emporte
Préférez le sans-exemple lorsque la tâche est bien représentée dans le préentraînement (résumé, traduction, classification courante) et lorsque des exemples risqueraient de biaiser le format de sortie. Pour les modèles réglés sur des instructions, une directive concise accompagnée d’un schéma de sortie l’emporte souvent sur des exemples qui imposent subtilement un style.
Le sans-exemple réduit également le coût en jetons et la latence, et évite le biais de l’étiquette majoritaire, lorsque le modèle prédit trop souvent la classe dominante dans vos démonstrations.
# Zero-shot with explicit schema beats vague few-shot
PROMPT = (
'Classify sentiment as POSITIVE, NEGATIVE, or NEUTRAL.\n'
'Respond with only the label.\n\n'
'Text: ' + user_text + '\nLabel:'
)Un exemple comme ancrage de format
L’approche à un exemple est particulièrement efficace lorsque la tâche est conceptuellement claire, mais que le format de sortie est inhabituel ou strict. Une seule démonstration enseigne la structure exacte (clés JSON, délimiteurs, casse) bien plus efficacement qu’une description en prose.
Utilisez un exemple lorsque vous souhaitez contraindre la structure sans dépenser de jetons supplémentaires ni risquer le déséquilibre de la distribution des étiquettes introduit par plusieurs exemples.
ONE_SHOT = (
'Extract entities as JSON.\n\n'
'Input: Apple released the iPhone in Cupertino.\n'
'Output: {"org": ["Apple"], "product": ["iPhone"], "loc": ["Cupertino"]}\n\n'
'Input: ' + query + '\nOutput:'
)L’approche à quelques exemples et la courbe de k
Les performances en fonction de k sont rarement monotones. Elles augmentent généralement, atteignent un plateau, puis se dégradent lorsque les exemples encombrent le contexte, dispersent l’attention et éloignent la requête en cours du point de focalisation lié à la récence du modèle.
Faites varier empiriquement k parmi {1, 2, 4, 8, 16} sur un ensemble mis de côté. La valeur optimale de k dépend de la complexité de la tâche, de la longueur des exemples et de l’utilisation effective du contexte par le modèle, généralement bien inférieure à la fenêtre annoncée.
def sweep_k(eval_set, candidates, ks=(1,2,4,8,16)):
results = {}
for k in ks:
acc = evaluate(build_prompt(candidates[:k]), eval_set)
results[k] = acc
return max(results, key=results.get)Pourquoi ICL fonctionne : inférence implicite
Les travaux de recherche présentent ICL comme une inférence bayésienne implicite effectuée par le modèle : les démonstrations l’aident à localiser le concept latent de la tâche que le modèle a déjà appris pendant le préentraînement. Les exemples servent de preuves qui restreignent la distribution a posteriori sur les tâches, et non de nouvelles connaissances.
Cela explique un résultat contre-intuitif : même des étiquettes incorrectes dans les démonstrations peuvent préserver une grande partie de la précision, car le signal dominant est le format et l’espace des étiquettes, et non la correspondance entre l’entrée et l’étiquette.
# Min, Lyu et al. (2022): label correctness matters less than
# - the input distribution
# - the label space (which classes exist)
# - the format / structure
# Implication: invest in representative inputs + valid label setCompromis entre budget de jetons et coût
Chaque exemple consomme du contexte et de l’argent. Avec de longues démonstrations, quatre exemples peuvent éclipser la requête. Calculez une mesure du coût par point de précision : si k=8 apporte 0,5 % de plus que k=4 pour deux fois plus de jetons, k=4 l’emporte en production.
Pour les chaînes de traitement à haut débit, préférez la mise en cache de l’invite contenant le bloc d’exemples statique, afin que les démonstrations répétées ne soient facturées et traitées qu’une seule fois.
def cost_efficiency(acc_by_k, tokens_by_k, price_per_1k):
return {
k: acc_by_k[k] / (tokens_by_k[k] / 1000 * price_per_1k)
for k in acc_by_k
}
# Pick the k maximizing accuracy per dollar, not raw accuracyBiais de l’étiquette majoritaire et de la position
Les invites à quelques exemples présentent des biais cachés. Le biais de l’étiquette majoritaire pousse le modèle à privilégier la classe la plus fréquente dans les démonstrations. Le biais de récence accorde trop de poids au dernier exemple. Le biais des jetons fréquents favorise les jetons qui apparaissent souvent.
Des techniques d’étalonnage telles que l’étalonnage contextuel estiment le a priori du modèle sur une entrée dépourvue de contenu (par exemple, le jeton N/A), puis neutralisent cet effet, ce qui stabilise considérablement les classifieurs utilisant quelques exemples.
# Contextual calibration (Zhao et al. 2021)
p_cf = model_probs(prompt_with_input('N/A')) # content-free prior
W = 1.0 / p_cf # diagonal correction
def calibrated(probs):
return normalize(W * probs)Équilibrer l’ensemble de démonstrations
Pour contrer le biais de l’étiquette majoritaire, équilibrez les classes dans les démonstrations et faites varier leur ordre. Pour k=4 en classification binaire, utilisez 2 exemples positifs et 2 exemples négatifs, mélangés, plutôt qu’une répartition de 3 à 1.
Pour les tâches de génération, équilibrez les dimensions importantes (longueur, ton, difficulté) afin que le modèle ne se réduise pas à un seul mode, celui qu’il a vu le plus souvent.
import random
def balanced_demos(pool, k, label_fn):
by_label = {}
for ex in pool:
by_label.setdefault(label_fn(ex), []).append(ex)
per = k // len(by_label)
picks = [e for lst in by_label.values() for e in random.sample(lst, per)]
random.shuffle(picks)
return picksQuelques exemples ou réglage fin
L’approche à quelques exemples est l’outil adapté lorsque la tâche change souvent, que les données sont rares ou que vous ne pouvez pas héberger un modèle réglé. Le réglage fin l’emporte lorsque vous disposez de milliers d’exemples, que vous avez besoin de la latence la plus faible par appel ou que vous souhaitez intégrer le format afin que les invites restent courtes.
Une démarche courante en production consiste à commencer par quelques exemples, à collecter les traces concluantes, puis à les distiller dans un réglage fin afin de supprimer entièrement les jetons des exemples.
# Decision heuristic
if num_labeled < 500 or task_volatility == 'high':
strategy = 'few-shot ICL'
elif latency_budget_ms < 200 or prompt_token_cost_dominant:
strategy = 'fine-tune + zero-shot'
else:
strategy = 'few-shot now, distill later'Les tâches de raisonnement nécessitent plus que des exemples
Pour le raisonnement en plusieurs étapes, de simples paires question-réponse avec quelques exemples peuvent nuire aux performances : le modèle apprend à passer directement à une réponse qu’il ne peut pas justifier. Associez l’approche à quelques exemples à des démonstrations de chaîne de raisonnement qui montrent la trace du raisonnement, et pas seulement l’étiquette finale.
Le nombre d’exemples interagit avec la profondeur du raisonnement ; souvent, k=2 exemples CoT de haute qualité surpassent k=8 exemples ne contenant que les réponses dans les évaluations de calcul arithmétique et de logique.
COT_SHOT = (
'Q: A shop had 23 apples, used 20, bought 6 more. How many now?\n'
'A: Start 23, minus 20 leaves 3, plus 6 is 9. Answer: 9\n\n'
'Q: ' + question + '\nA:'
)Un harness d’évaluation pour k
Traitez la sélection du nombre d’exemples comme une recherche empirique appuyée par un harness. Gardez un ensemble de validation de côté, contrôlez l’ordre des exemples à l’aide de plusieurs initialisations aléatoires et indiquez la moyenne ainsi que la variance, car la précision avec quelques exemples peut varier de plusieurs points uniquement à cause de l’ordre.
Consignez le nombre de jetons et la latence pour chaque valeur de k afin que le choix final optimise l’objectif complet, et pas seulement la précision.
def harness(pool, val, ks, seeds=5):
report = {}
for k in ks:
accs = []
for s in range(seeds):
demos = balanced_demos(pool, k, label_fn)
accs.append(evaluate(build_prompt(demos), val))
report[k] = (mean(accs), stdev(accs))
return reportVérification rapide
Vérifiez votre compréhension de la sélection du nombre d’exemples et des biais d’ICL.
Récapitulatif
Points clés :
kest un hyperparamètre réglable ; faites varier sa valeur et observez la courbe de hausse, de plateau puis de dégradation.- Le sans-exemple convient aux tâches connues ; un exemple ancre les formats stricts ; quelques exemples conditionnent le modèle sur une distribution de tâches.
- ICL fonctionne en localisant une tâche apprise lors du préentraînement : le format et l’espace des étiquettes dominent donc la justesse des étiquettes.
- Contrez les biais liés à l’étiquette majoritaire, à la récence et aux jetons fréquents par l’équilibrage, le mélange et l’étalonnage contextuel.
- Optimisez la précision par dollar, associez les tâches de raisonnement à des exemples CoT et distillez les invites stables à quelques exemples dans des réglages fins.
Questions Fréquemment Posées
La leçon « Zéro, un ou quelques exemples » est-elle gratuite ?
Oui — le texte complet de « Zéro, un ou quelques 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 « Zéro, un ou quelques exemples » ?
Choisir le nombre d’exemples. 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 1 sur 4.
Combien de temps prend la leçon « Zéro, un ou quelques 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
- Zéro, un ou quelques exemples
- Concevoir des exemples efficaces
- Ordre et récence des exemples
- Sélection dynamique de quelques exemples