Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Self-consistency: meerdere redeneerroutes

Les 6 van 16 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Self-consistency: meerdere redeneerroutes
  2. Het probleem dat het oplost
  3. Basisimplementatie
  4. Wat de stemming u vertelt
  5. Parallelle versie met asyncio
  6. Wanneer self-consistency gebruiken
  7. De verhouding kosten/betrouwbaarheid afstemmen
  8. Belangrijkste punten

Les bijgewerkt op 3 november 2026 op basis van OpenAI-documentatie: temperature en top_p worden alleen geaccepteerd met een redeneerinspanning van none, terwijl GPT-5.6-modellen standaard redeneren (medium). Aanroepen die deze parameters instellen, moeten daarom reasoning={"effort": "none"} (Responses API) of reasoning_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