Échantillonnage par auto-cohérence
Voter entre plusieurs chemins de raisonnement.
Échantillonnage par auto-cohérence 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.
Une seule chaîne est fragile
Une seule chaîne de raisonnement peut prendre un mauvais tournant très tôt et ne jamais se rétablir. L’auto-cohérence (Wang et al., 2022) remédie à cela en échantillonnant de nombreux chemins de raisonnement indépendants et en regroupant leurs réponses finales, généralement par vote majoritaire.
L’idée est la suivante : un raisonnement correct converge vers la même réponse par des chemins différents, tandis que les erreurs se dispersent. L’agrégation amplifie le signal cohérent.
def self_consistency(prompt, n=20, temperature=0.7):
answers = []
for _ in range(n):
chain = llm(prompt, temperature=temperature)
answers.append(extract_answer(chain))
return majority_vote(answers)Pourquoi la marginalisation sur les chemins fonctionne
L’auto-cohérence approxime la marginalisation sur les chemins de raisonnement : au lieu de faire confiance à une seule dérivation latente, vous estimez la réponse finale la plus probable en l’intégrant sur de nombreuses dérivations.
Il s’agit d’une estimation de Monte-Carlo de la distribution des réponses. Le mode de cette distribution est généralement plus fiable que n’importe quel chemin échantillonné isolément, en particulier lorsque l’espace des réponses est petit et discret.
from collections import Counter
def majority_vote(answers):
norm = [normalize_answer(a) for a in answers]
counts = Counter(norm)
answer, votes = counts.most_common(1)[0]
confidence = votes / len(norm)
return answer, confidenceLa diversité grâce à la température
L’auto-cohérence a besoin de chemins diversifiés. Une stratégie gloutonne ou une température presque nulle produit des chaînes presque identiques, ce qui rend la méthode inefficace. Utilisez une température modérée, souvent comprise entre 0,5 et 0,8, et éventuellement un échantillonnage par noyau pour diversifier les chemins.
Une température trop élevée dégrade chaque chaîne prise individuellement ; ajustez la température pour maximiser la précision de l’ensemble, et non la qualité d’une seule chaîne.
def tune_temperature(prompt, val_set, temps=(0.4, 0.6, 0.8, 1.0)):
best = max(
temps,
key=lambda t: ensemble_accuracy(prompt, val_set, temp=t, n=20)
)
return bestLa normalisation des réponses est essentielle
Les votes ne comptent que si les réponses équivalentes sont reconnues comme égales. Normalisez avant de compter : supprimez les unités, canonisez les nombres, mettez le texte en minuscules, analysez les fractions et les pourcentages et appliquez l’équivalence propre à la tâche.
Une mauvaise normalisation répartit la véritable majorité entre différentes variantes de forme et permet à une réponse minoritaire de remporter le vote.
def normalize_answer(a):
a = a.strip().lower().rstrip('.')
a = a.replace(',', '').replace('$', '').replace('%', '')
try:
return str(round(float(a), 6)) # numeric canonical form
except ValueError:
return aCombien d’échantillons ?
La précision augmente avec le nombre d’échantillons n, mais avec des rendements décroissants, et se stabilise souvent entre 10 et 40 selon la difficulté de la tâche. Chaque échantillon multiplie linéairement le coût et la latence.
Faites varier n sur un ensemble de validation et choisissez le coude de la courbe, là où les échantillons supplémentaires ne justifient plus leur coût.
def sweep_n(prompt, val, ns=(1,3,5,10,20,40)):
return {n: ensemble_accuracy(prompt, val, n=n) for n in ns}
# Choose n at the accuracy/cost knee, not the maximumArrêt anticipé adaptatif
Économisez du calcul grâce à l’échantillonnage adaptatif : cessez de générer des chemins dès que le vote est décisif. Si, après 5 échantillons, une réponse dispose d’une avance nette, il est peu probable que les échantillons suivants changent le résultat.
Vous concentrez ainsi le calcul sur les éléments réellement difficiles et disputés, tout en traitant les éléments faciles à moindre coût.
def adaptive_sc(prompt, max_n=40, margin=0.6, min_n=5):
answers = []
for i in range(max_n):
answers.append(extract_answer(llm(prompt, temperature=0.7)))
if i + 1 >= min_n:
ans, conf = majority_vote(answers)
if conf >= margin:
return ans, conf, i + 1
return majority_vote(answers)Vote pondéré et assisté par un vérificateur
Un vote majoritaire simple traite tous les chemins de la même manière. Vous pouvez pondérer les votes selon la vraisemblance attribuée au chemin par le modèle, le score d’un vérificateur entraîné ou l’auto-évaluation de la validité de chaque chaîne.
L’auto-cohérence pondérée par un vérificateur surpasse souvent le vote non pondéré, car elle rétrograde les modes d’échec fréquents mais incorrects avec assurance.
def weighted_vote(chains):
scores = {}
for c in chains:
a = normalize_answer(extract_answer(c))
scores[a] = scores.get(a, 0.0) + verifier_score(c)
return max(scores, key=scores.get)La confiance grâce à l’accord
La marge de vote constitue un signal de confiance utile. Une réponse unanime est bien plus digne de confiance qu’un partage 6 contre 5. Transmettez cette information à la logique en aval : orientez les éléments où l’accord est faible vers une escalade, une vérification humaine ou un modèle plus puissant.
L’auto-cohérence devient ainsi à la fois un moyen d’améliorer la précision et un mécanisme d’étalonnage.
def route(prompt):
ans, conf = adaptive_sc(prompt)[:2]
if conf < 0.5:
return escalate_to_stronger_model(prompt)
return ansLimites : tâches continues et ouvertes
Le vote majoritaire suppose un espace de réponses discret et comparable. Il ne s’applique pas directement à la génération libre, aux textes longs ou aux sorties continues, lorsque deux échantillons ne sont jamais identiques.
Pour ces tâches, agrégez autrement : regroupez les sorties sémantiquement similaires, votez sur des champs structurés extraits ou utilisez un modèle arbitre pour sélectionner le meilleur échantillon au lieu de compter les correspondances exactes.
def semantic_consistency(samples):
clusters = cluster_by_embedding(samples)
biggest = max(clusters, key=len) # largest agreement cluster
return representative(biggest) # medoid of the clusterDéploiement tenant compte des coûts
L’auto-cohérence est l’une des techniques de formulation d’instructions les plus coûteuses : le coût augmente avec n. Réservez-la aux éléments importants ou difficiles, combinez-la avec un arrêt adaptatif et envisagez une politique à plusieurs niveaux où une seule chaîne traite les requêtes faciles.
Comparez toujours son rapport précision/coût à celui d’un appel unique à un modèle plus puissant, qui peut être moins cher pour un gain équivalent.
def tiered(prompt, q):
if easy(q):
return extract_answer(llm(prompt, temperature=0))
return adaptive_sc(prompt, max_n=20)[0] # SC only when neededAuto-cohérence de bout en bout
Une chaîne de traitement complète : ajustez la température et n, échantillonnez des chaînes diversifiées, normalisez rigoureusement les réponses, procédez au vote (éventuellement pondéré par un vérificateur), utilisez la marge comme signal de confiance, arrêtez-vous tôt lorsque le résultat est décisif et faites remonter les éléments où l’accord est faible.
Vous obtenez un système de raisonnement plus précis et auto-étalonné qu’une chaîne unique.
def solve(prompt):
chains = sample_until_decisive(prompt, max_n=20, temp=0.7)
ans, conf = weighted_majority(chains)
if conf < THRESH:
return escalate(prompt)
return {'answer': ans, 'confidence': conf, 'paths': len(chains)}Vérification rapide
Diagnostiquez une configuration d’auto-cohérence dont les performances sont insuffisantes.
Récapitulatif
Points clés à retenir :
- L’auto-cohérence échantillonne de nombreuses chaînes diversifiées et procède à un vote, ce qui approxime la marginalisation sur les chemins de raisonnement.
- La diversité, obtenue avec une température modérée, et une normalisation rigoureuse des réponses sont indispensables à son bon fonctionnement.
- La précision augmente avec
n, puis plafonne ; utilisez un arrêt anticipé adaptatif pour maîtriser les coûts. - Pondérez les votes avec un vérificateur et utilisez la marge de vote comme signal de confiance étalonné.
- Cette méthode nécessite un espace de réponses discret ; pour les tâches ouvertes, regroupez les sorties sémantiquement ou utilisez un arbitre.
Questions Fréquemment Posées
La leçon « Échantillonnage par auto-cohérence » est-elle gratuite ?
Oui — le texte complet de « Échantillonnage par auto-cohérence » 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 « Échantillonnage par auto-cohérence » ?
Voter entre plusieurs chemins de raisonnement. 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 « Échantillonnage par auto-cohérence » ?
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
- Prompts avec raisonnement explicite
- Échantillonnage par auto-cohérence
- Explorer les arbres de pensée
- Quand les prompts de raisonnement sont utiles