Wat is self-consistency?
Self-consistency is een prompting-techniek die de betrouwbaarheid van AI-output verhoogt door meerdere onafhankelijke antwoorden te genereren op dezelfde vraag en vervolgens via "majority voting" het meest consistente antwoord te selecteren.
De gedachte is statistisch: als een model dezelfde vraag tien keer beantwoordt en acht keer hetzelfde antwoord geeft, is dat antwoord waarschijnlijk correct. Afwijkende antwoorden zijn outliers die worden weggefilterd.
Self-consistency werd geïntroduceerd in een paper van Google Research uit 2022 (Wang e.a., "Self-Consistency Improves Chain of Thought Reasoning in Language Models") als aanvulling op chain-of-thought prompting. De combinatie van chain-of-thought en self-consistency verbeterde de prestaties op wiskundige en logische benchmarks fors.
Waarom werkt self-consistency?
Taalmodellen zijn stochastisch: bij dezelfde prompt met een hogere temperature geven ze niet altijd hetzelfde antwoord. Dat is een zwakte bij exacte taken, maar precies de motor achter self-consistency.
Doordat het model elke keer een licht andere redeneerroute neemt, vallen fouten in individuele redeneerpaden tegen elkaar weg. Een conclusie die via meerdere verschillende paden wordt bereikt, is betrouwbaarder dan een conclusie die maar via één pad ontstaat.
Wat het oorspronkelijke onderzoek liet zien
In het paper van Wang e.a. (2022) verbeterde self-consistency de wiskundige redenering op de GSM8K-benchmark (schoolwiskunde) met ongeveer 17 procentpunten ten opzichte van standaard chain-of-thought. Dat is een grote sprong zonder enige modelwijziging, puur door slimmer te samplen.
Hoe implementeer je self-consistency?
De basismethode bestaat uit vier stappen:
- Stel je vraag met een chain-of-thought instructie.
- Genereer N antwoorden (N is meestal 5 tot 20, afhankelijk van de benodigde betrouwbaarheid).
- Extraheer het definitieve antwoord uit elk redeneerpad.
- Kies het meest voorkomende antwoord via majority voting.
Een minimale implementatie via een API ziet er zo uit:
antwoorden = []
for i in range(10):
antwoord = model.generate(prompt, temperature=0.7)
antwoorden.append(extraheer_antwoord(antwoord))
meest_voorkomend = max(set(antwoorden), key=antwoorden.count)
Gebruik een temperature van ongeveer 0.5 tot 0.8 voor genoeg variatie in de redeneerpaden. Bij temperature 0 geeft het model telkens hetzelfde antwoord en heeft self-consistency geen effect.
Self-consistency in vijf stappen
- Schrijf een chain-of-thought prompt: vraag het model expliciet "denk stap voor stap na en geef daarna je antwoord".
- Genereer meerdere runs: vijf tot twintig, afhankelijk van hoe kritiek de uitkomst is.
- Extraheer het finale antwoord: gebruik een parser of vraag het model zijn antwoord te structureren.
- Voer majority voting uit: het meest voorkomende antwoord wint.
- Optioneel gewogen voting: geef hogere gewichten aan antwoorden met coherentere redeneerpaden.
Wanneer gebruik je self-consistency?
Self-consistency is sterk bij taken met één duidelijk correct antwoord:
- Wiskundige berekeningen.
- Logische redeneeropgaven.
- Feitelijke vragen met één correct antwoord.
- Verificatie van code-correctheid.
- Beslissingen waarbij fouten kostbaar zijn, bijvoorbeeld in financiële of operationele context.
Minder geschikt is de techniek voor taken zonder objectief juist antwoord:
- Creatieve taken zonder "correct" antwoord.
- Open vragen.
- Subjectieve evaluaties.
Kosten-batenanalyse
Self-consistency kost N keer meer API-aanroepen dan een enkele aanroep. Dat is de belangrijkste beperking en de reden om N bewust te kiezen.
| Runs | Betrouwbaarheidswinst | Kosten (relatief) |
|---|---|---|
| 3 | Matig | 3x |
| 5 | Goed | 5x |
| 10 | Uitstekend | 10x |
| 20 | Maximaal | 20x |
In de praktijk geven vijf runs al een duidelijke betrouwbaarheidswinst. Twintig runs is zelden nodig, tenzij de uitkomst absoluut kritiek is.
Geen oplossing voor systematische bias
Self-consistency filtert willekeurige fouten statistisch weg, maar elimineert ze niet volledig. Als een model systematisch dezelfde fout maakt, kiest majority voting juist die foute optie. De techniek lost dus geen structurele modellimiet of bias op.
Praktijkvoorbeeld: een wiskundeprobleem
Stel dezelfde vraag vijf keer met temperature 0.7:
"Los op en leg stap voor stap uit: een winkel geeft 15% korting op een artikel van 80 euro. Daarna wordt nog 10% extra korting gegeven. Wat is de eindprijs?"
De vijf runs leveren op:
- Run 1: 80 maal 0.85 is 68 euro, daarna 68 maal 0.90 is 61,20 euro. Antwoord: 61,20 euro.
- Run 2: 80 min 12 is 68, daarna 68 min 6,80 is 61,20 euro. Antwoord: 61,20 euro.
- Run 3: 15% plus 10% is 25% korting, dus 80 maal 0.75 is 60 euro. Antwoord: 60 euro.
- Run 4: 80 maal 0.85 is 68, daarna 68 maal 0.90 is 61,20 euro. Antwoord: 61,20 euro.
- Run 5: 80 maal 0.85 is 68 euro, daarna 68 maal 0.90 is 61,20 euro. Antwoord: 61,20 euro.
Majority voting kiest 61,20 euro (vier keer) boven 60 euro (één keer). Het correcte antwoord is inderdaad 61,20 euro, want twee opeenvolgende kortingen tel je niet op tot 25%.
Self-consistency versus zelfcontrole
Een verwante maar zwakkere variant is het model zijn eigen antwoord laten verifiëren, bijvoorbeeld met "klopt het antwoord dat je net gaf? Controleer elke stap."
Dit is zwakker dan echte self-consistency, omdat het model binnen dezelfde run dezelfde bias herhaalt. Echte self-consistency genereert onafhankelijke runs met variatie; zelfcontrole binnen één run vermindert vooral slordige fouten, niet de systematische.
Combineer altijd met chain-of-thought
Self-consistency werkt het best bovenop chain-of-thought. De expliciete redeneerstappen geven variatie tussen runs en maken het eindantwoord makkelijker te extraheren. Vraag het model daarom telkens om eerst te redeneren en daarna het antwoord in een vast formaat te geven, bijvoorbeeld "Mijn antwoord is: X".
Moet ik chain-of-thought altijd combineren met self-consistency?
Vrijwel altijd wel. Chain-of-thought genereert expliciete redeneerstappen die je kunt analyseren en die zorgen voor variatie tussen runs. Bij directe antwoorden zonder redenering is majority voting minder betrouwbaar.
Werkt self-consistency bij reasoning-modellen zoals de o-serie of Gemini Deep Think?
Reasoning-modellen voeren al intern meerdere redeneerstappen uit, dus de meerwaarde is kleiner. Toch kan het nog bijdragen bij zeer kritieke beslissingen, omdat je dan onafhankelijke runs vergelijkt in plaats van één interne redenering te vertrouwen.
Kan ik self-consistency handmatig doen zonder API?
Ja. Stel dezelfde vraag een paar keer en ververs de sessie voor echte onafhankelijkheid, en kijk welk antwoord het vaakst terugkomt. Het is tijdrovend, maar effectief voor een kritieke eenmalige beslissing.
Hoe extraheer ik het eindantwoord automatisch?
Vraag het model zijn definitieve antwoord in een vast formaat te zetten, zoals "Mijn antwoord is: X". Daarna kun je het eenvoudig parsen en tellen.
Welke temperature kies ik?
Een waarde tussen 0.5 en 0.8 geeft genoeg variatie in de redeneerpaden zonder dat de antwoorden willekeurig worden. Bij temperature 0 zijn alle runs identiek en heeft de techniek geen zin.
Hoeveel runs heb ik nodig?
Vijf runs leveren meestal al een duidelijke winst. Verhoog naar tien of meer als de beslissing kritiek is, en weeg dat af tegen de evenredig hogere kosten.
Self-consistency is een elegante statistische oplossing voor de inherente onbetrouwbaarheid van stochastische modellen. Voor toepassingen met een hoog belang, waarbij fouten kostbaar zijn, is het een waardevol onderdeel van je prompt-engineering arsenaal.