Self-consistency: meerdere redeneerroutes
Op deze pagina
Les bijgewerkt op 3 november 2026 op basis van OpenAI-documentatie:
temperatureentop_pworden alleen geaccepteerd met een redeneerinspanning vannone, terwijl GPT-5.6-modellen standaard redeneren (medium). Aanroepen die deze parameters instellen, moeten daaromreasoning={"effort": "none"}(Responses API) ofreasoning_effort="none"(Chat Completions) specificeren. Bronnen: Using GPT-6 · GPT-5.6 Terra.
Self-consistency: meerdere redeneerroutes
Self-consistency houdt in dat u meerdere onafhankelijke reacties op dezelfde prompt genereert en vervolgens de meest frequente of coherente selecteert. Het principe is stemmen: een enkele aanroep stelt u bloot aan de willekeur van een slechte trekking, terwijl vijf aanroepen u een verdeling geven die u kunt bevragen. Deze techniek verbetert de betrouwbaarheid van antwoorden aanzienlijk, vooral bij logisch redeneren en wiskundige taken.
Het probleem dat het oplost
Een LLM kan bij elke aanroep een ander antwoord geven, zelfs met een strikt identieke prompt. Sommige van deze antwoorden zijn correct, andere niet, en niets in de uitvoer geeft aan welke u leest: een foutief antwoord wordt met evenveel overtuiging gepresenteerd als een juist antwoord. Self-consistency zet deze variabiliteit in uw voordeel om. Als het model via verschillende redeneerroutes tot dezelfde conclusie komt, is die conclusie waarschijnlijk correct; een fout daarentegen reproduceert zich zelden identiek van de ene trekking tot de andere, omdat deze precies afhangt van de gevolgde route.
Basisimplementatie
Het mechanisme heeft drie stappen: genereren, het eindantwoord extraheren, stemmen. De marker >>> ANSWER: die in de instructies wordt afgedwongen, is niet cosmetisch; dit is wat de uitvoer parseerbaar maakt zonder dat u de voorafgaande redenering hoeft te interpreteren. Zonder dit anker zou u een fragiele heuristiek moeten schrijven om te raden waar de reflectie eindigt en de conclusie begint.
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:
"""Genereert n antwoorden en retourneert het meest frequente."""
responses = []
for _ in range(n):
response = client.responses.create(
model=model,
reasoning={"effort": "none"}, # temperature vereist effort none
instructions=system + "\nRedeneer stap voor stap en geef vervolgens "
"uw eindantwoord na '>>> ANSWER:'",
input=prompt,
temperature=0.7 # Temperature > 0 voor diversiteit
)
responses.append(response.output_text)
# Eindantwoorden extraheren
answers = []
for r in responses:
if ">>> ANSWER:" in r:
answer = r.split(">>> ANSWER:")[-1].strip()
answers.append(answer)
// Meerderheidsstemming
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}
Wat de stemming u vertelt
Toegepast op sentimentclassificatie retourneert de functie niet alleen een label, maar ook een verdeling, en die verdeling is vaak waardevoller dan het label zelf. Voor de onderstaande recensie, die echt ambigu is (het product is prima, maar de levering was een ramp), stemmen vier aanroepen op “negatief” en drie op “neutraal”. Het betrouwbaarheidsniveau van 57% geeft aan dat deze zaak speciale behandeling verdient: in de wachtrij plaatsen voor menselijke beoordeling, de gebruiker om verduidelijking vragen, of het simpelweg uitsluiten van geaggregeerde statistieken. Een enkele aanroep zou “negatief” hebben weergegeven zonder nuance, en u zou dit ticket exact hetzelfde hebben behandeld als een unaniem woedende recensie.
system = """U bent een sentimentclassificator.
Analyseer de tekst en redeneer stap voor stap.
Geef uw eindantwoord na '>>> ANSWER:' door te kiezen uit:
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"Betrouwbaarheid: {result['confidence']:.0%}")
print(f"Verdeling: {result['all_answers']}")
# Voorbeelduitvoer:
# Sentiment: negative
# Betrouwbaarheid: 57%
# Verdeling: {'negative': 4, 'neutral': 3}
Parallelle versie met asyncio
De kosten van deze techniek zijn niet alleen financieel: vijf sequentiële aanroepen betekenen ook vijf keer de latentie, wat de aanpak uitsluit in elke interface waar iemand wacht achter zijn scherm. Toch zijn de aanroepen perfect onafhankelijk; er is geen rechtvaardiging om ze één voor één af te wachten. asyncio.gather brengt de totale tijd terug tot die van de langzaamste aanroep, waardoor self-consistency compatibel wordt met online gebruik, met een overhead die puur monetair wordt.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
async def self_consistency_async(prompt: str, system: str = "",
n: int = 5) -> dict:
"""Asynchrone versie van self-consistency."""
async def single_call():
response = await async_client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature vereist effort none
instructions=system + "\nRedeneer en geef vervolgens uw antwoord "
"na '>>> ANSWER:'",
input=prompt,
temperature=0.7
)
return response.output_text
// Start alle verzoeken parallel
tasks = [single_call() for _ in range(n)]
results = await asyncio.gather(*tasks)
// Extraheren en stemmen
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)
}
Wanneer self-consistency gebruiken
Het beslissingscriterium is eenvoudig te formuleren: stemmen heeft alleen zin als het antwoord discreet en vergelijkbaar is. Twee goed geschreven samenvattingen kunnen niet worden geteld, omdat ze nooit karakter voor karakter identiek zullen zijn; twee categorielabels wel.
| Use Case | Nuttig? | Waarom |
|---|---|---|
| Classificatie | Ja | Discreet antwoord, eenvoudige stemming |
| Wiskundig redeneren | Ja | Meerdere routes naar het juiste antwoord |
| Entiteitsextractie | Ja | Consensus over gedetecteerde entiteiten |
| Creatief schrijven | Nee | Geen enkel "juist" antwoord |
| Tekstsamenvatting | Gedeeltelijk | Nuttig voor kernfeiten, niet voor stijl |
De verhouding kosten/betrouwbaarheid afstemmen
Drie aanroepen zijn het minimaal haalbare aantal wil een meerderheidsstemming iets betekenen; vijf biedt voor de meeste toepassingen het beste compromis; zeven tot elf zijn gerechtvaardigd voor kritieke beslissingen, waarbij een fout veel meer kost dan een paar extra aanroepen. De echte winst komt echter van hoe u de betrouwbaarheidsscore gebruikt, niet van het aantal samples. Onder de 60% kunt u ervan uitgaan dat er geen consensus is en moet u escaleren, hetzij naar een menselijke operator, hetzij naar een krachtiger model met meer samples, zoals hieronder wordt getoond.
result = self_consistency(question, system, n=5)
if result["confidence"] < 0.6:
// Geen duidelijke consensus, escaleren
result = self_consistency(question, system, n=9, model="gpt-5.6-sol")
De resterende vraag is of de moeite de moeite waard is in uw specifieke geval, en dat moet worden gemeten, niet aangenomen. Implementeer de asynchrone versie, voer deze uit op een twaalftal vragen voor sentimentclassificatie waarvan u het verwachte antwoord kent, en vergelijk vervolgens de nauwkeurigheid die wordt verkregen met één aanroep versus vijf aanroepen. Het cijfer dat u verkrijgt, zal de vraag naar overhead voor uw specifieke geval beantwoorden; iets wat geen algemene aanbeveling voor u kan doen.
Belangrijkste punten
- Self-consistency genereert meerdere reacties en stemt voor de beste
- Gebruik een temperature > 0 om diversiteit te bereiken
- Effectief voor taken met een discreet antwoord (classificatie, berekening)
- Nutteloos voor creatieve taken zonder één juist antwoord
- Parallelleer aanroepen met asyncio om latentie te beperken