Auto-cohérence : plusieurs chemins de raisonnement
In questa pagina
Leçon mise à jour le 3 novembre 2026 selon la documentation OpenAI :
temperatureettop_pne sont acceptés qu’avec un effort de raisonnement denone, tandis que les modèles GPT-5.6 raisonnent par défaut (medium). Les appels définissant ces paramètres doivent donc spécifierreasoning={"effort": "none"}(API Responses) oureasoning_effort="none"(Chat Completions). Sources : Utilisation de GPT-6 · GPT-5.6 Terra.
Auto-cohérence : plusieurs chemins de raisonnement
L’auto-cohérence consiste à générer plusieurs réponses indépendantes à la même requête, puis à sélectionner la plus fréquente ou la plus cohérente. Le principe repose sur le vote : un seul appel t’expose à l’aléa d’un mauvais tirage, tandis que cinq appels te donnent une distribution que tu peux interroger. Cette technique améliore considérablement la fiabilité des réponses, surtout pour le raisonnement logique et les tâches mathématiques.
Le problème résolu
Un LLM peut fournir une réponse différente à chaque appel, même avec une requête strictement identique. Certaines de ces réponses sont correctes, d’autres non, et rien dans la sortie n’indique laquelle tu lis : une réponse fausse est énoncée avec la même assurance qu’une bonne. L’auto-cohérence transforme cette variabilité en avantage. Si le modèle atteint la même conclusion via plusieurs chemins de raisonnement distincts, cette conclusion est probablement correcte ; une erreur, en revanche, se reproduit rarement à l’identique d’un tirage à l’autre, car elle dépend précisément du chemin emprunté.
Implémentation de base
Le mécanisme comporte trois étapes : générer, extraire la réponse finale, voter. Le marqueur >>> ANSWER: imposé dans les instructions n’est pas cosmétique : c’est lui qui rend la sortie analysable sans avoir à interpréter le raisonnement qui la précède. Sans cet ancrage, tu devrais écrire une heuristique fragile pour deviner où s’arrête la réflexion et où commence la conclusion.
from openai import OpenAI
from collections import Counter
client = OpenAI()
def self_consistency(prompt: str, system: str = "",
n: int = 5, model: str = "gpt-5.6-terra") -> dict:
"""Génère n réponses et retourne la plus fréquente."""
responses = []
for _ in range(n):
response = client.responses.create(
model=model,
reasoning={"effort": "none"}, # temperature requires effort none
instructions=system + "\nReason step by step, then give "
"your final answer after '>>> ANSWER:'",
input=prompt,
temperature=0.7 # Temperature > 0 for diversity
)
responses.append(response.output_text)
# Extraire les réponses finales
answers = []
for r in responses:
if ">>> ANSWER:" in r:
answer = r.split(">>> ANSWER:")[-1].strip()
answers.append(answer)
# Vote majoritaire
if answers:
counter = Counter(answers)
best_answer, count = counter.most_common(1)[0]
return {
"answer": best_answer,
"confidence": count / len(answers),
"all_answers": dict(counter),
"total_responses": len(answers)
}
return {"answer": None, "confidence": 0}
Ce que le vote t’apprend
Appliquée à la classification de sentiments, la fonction ne renvoie pas seulement une étiquette, mais une distribution, et cette distribution est souvent plus précieuse que l’étiquette elle-même. Pour l’avis ci-dessous, genuinely ambigu — le produit est correct, mais la livraison a été désastreuse — quatre appels votent « négatif » et trois votent « neutre ». La confiance de 57 % t’indique que ce cas mérite peut-être un traitement spécial : mise en file d’attente pour révision humaine, demande de clarification à l’utilisateur, ou simple exclusion des statistiques agrégées. Un appel unique aurait affiché « négatif » sans nuance, et tu aurais traité ce ticket exactement comme un avis unanimement furieux.
system = """You are a sentiment classifier.
Analyze the text and reason step by step.
Give your final answer after '>>> ANSWER:' choosing from:
positive, negative, neutral"""
text = "The product is fine but the delivery took 3 weeks."
result = self_consistency(text, system, n=7)
print(f"Sentiment: {result['answer']}")
print(f"Confidence: {result['confidence']:.0%}")
print(f"Distribution: {result['all_answers']}")
# Exemple de sortie :
# Sentiment: negative
# Confidence: 57%
# Distribution: {'negative': 4, 'neutral': 3}
Version parallèle avec asyncio
Le coût de cette technique n’est pas seulement financier : cinq appels séquentiels signifient aussi cinq fois la latence, ce qui exclut l’approche dans toute interface où quelqu’un attend devant son écran. Pourtant, les appels sont parfaitement indépendants ; rien ne justifie de les attendre les uns après les autres. asyncio.gather ramène le temps total à celui de l’appel le plus lent, rendant l’auto-cohérence compatible avec un usage en ligne, avec une surcharge qui devient purement monétaire.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
async def self_consistency_async(prompt: str, system: str = "",
n: int = 5) -> dict:
"""Version asynchrone de l'auto-cohérence."""
async def single_call():
response = await async_client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
instructions=system + "\nReason then give your answer "
"after '>>> ANSWER:'",
input=prompt,
temperature=0.7
)
return response.output_text
# Lancer toutes les requêtes en parallèle
tasks = [single_call() for _ in range(n)]
results = await asyncio.gather(*tasks)
# Extraire et voter
answers = []
for r in results:
if ">>> ANSWER:" in r:
answers.append(r.split(">>> ANSWER:")[-1].strip())
counter = Counter(answers)
best, count = counter.most_common(1)[0] if answers else (None, 0)
return {
"answer": best,
"confidence": count / len(answers) if answers else 0,
"distribution": dict(counter)
}
Quand utiliser l’auto-cohérence
Le critère de décision est simple à énoncer : le vote n’a de sens que si la réponse est discrète et comparable. Deux résumés bien rédigés ne peuvent pas être décomptés, car ils ne seront jamais identiques caractère par caractère ; deux étiquettes de catégorie, si.
| Cas d'usage | Utile ? | Pourquoi |
|---|---|---|
| Classification | Oui | Réponse discrète, vote simple |
| Raisonnement mathématique | Oui | Plusieurs chemins vers la bonne réponse |
| Extraction d'entités | Oui | Consensus sur les entités détectées |
| Écriture créative | Non | Aucune réponse « correcte » unique |
| Résumé de texte | Partiel | Utile pour les faits clés, pas pour le style |
Ajuster le ratio coût/fiabilité
Trois appels constituent le nombre minimal viable pour qu’un vote majoritaire ait un sens ; cinq offrent le meilleur compromis pour la plupart des applications ; sept à onze se justifient pour des décisions critiques, où une erreur coûte bien plus cher que quelques appels supplémentaires. Cependant, le vrai gain vient de la façon dont tu utilises le score de confiance plutôt que du nombre d’échantillons. En dessous de 60 %, considère qu’il n’y a pas de consensus et escalade, soit vers un opérateur humain, soit vers un modèle plus puissant avec plus d’échantillons, comme illustré ci-dessous.
result = self_consistency(question, system, n=5)
if result["confidence"] < 0.6:
# Pas de consensus clair, escalade
result = self_consistency(question, system, n=9, model="gpt-5.6-sol")
La question restante est de savoir si le jeu en vaut la chandelle dans ton cas spécifique, et cela doit se mesurer, pas se supposer. Implémente la version asynchrone, exécute-la sur une douzaine de questions de classification de sentiments dont tu connais la réponse attendue, puis compare la précision obtenue avec un appel unique versus cinq appels. Le chiffre que tu obtiendras tranchera la question de la surcharge pour ton cas précis, ce qu’aucune recommandation générale ne peut faire à ta place.
Punti chiave
- L’auto-cohérence génère plusieurs réponses et vote pour la meilleure
- Utilise une température > 0 pour obtenir de la diversité
- Efficace pour les tâches avec une réponse discrète (classification, calcul)
- Inutile pour les tâches créatives sans réponse unique correcte
- Parallélise les appels avec asyncio pour limiter la latence