Ontwikkelaarshandleiding voor Chain of Thought-prompting

Home » Python » Ontwikkelaarshandleiding voor Chain of Thought-prompting

Chain of Thought prompting (CoT) is geëvolueerd van een onderzoekscuriositeit tot een van de meest praktische hulpmiddelen die ontwikkelaars tot hun beschikking hebben om grote taalmodellen daadwerkelijk te laten redeneren, in plaats van alleen maar het meest waarschijnlijke volgende woord te raden. Door het model expliciet te vragen de tussenstappen uit te leggen, behaalt u aanzienlijk betere resultaten bij wiskundige, logische en besluitvormingstaken, terwijl u tegelijkertijd een transparant proces krijgt dat u kunt debuggen en controleren.

Als u LLM-gestuurde applicaties ontwikkelt, agenten Of je nu copiloten hebt of niet, en je stuurt nog steeds alleen maar prompts in één stap, dan laat je veel kwaliteit liggen. In deze handleiding, speciaal voor ontwikkelaars, leggen we uit wat Chain of Thought is, waarom het werkt, de belangrijkste varianten (zero-shot, few-shot, Auto-CoT, self-consistency, Tree-of-Thoughts, least-to-most, multimodal), hoe het zich verhoudt tot prompt chaining en hoe je het kunt integreren en monitoren in echte systemen met behulp van moderne tools.

Van direct antwoorden naar expliciete redenering

De meeste vragen die mensen aan een LLM stellen zijn "eenmalig": je stelt een vraag, het model geeft een antwoord, zonder dat er vragen worden gesteld of redeneringen worden getoond. Voor een vraag als "Welke kleur heeft de lucht?" is dat prima: het model geeft gewoon "De lucht is blauw" terug. Er is geen zichtbare structuur, geen tussenliggende logica, alleen een uiteindelijke zin die goed klinkt.

De Chain of Thought-aanpak draait dit patroon om door het model te vragen de redeneringsstappen die het volgt daadwerkelijk te beschrijven. Stel de vraag: "Waarom ziet de lucht er blauw uit? Denk stap voor stap na." Het model zou dan het concept "blauw" kunnen ontleden, uitleggen hoe zonlicht interactie heeft met de atmosfeer, Rayleigh-verstrooiing noemen en pas daarna stellen dat kortere blauwe golflengten in alle richtingen worden verstrooid, waardoor de lucht voor ons blauw lijkt.

Technisch gezien verander je niet de gewichten van het model en geef je het geen nieuwe kennis; je verandert alleen de vorm van de berekening die je het model laat uitvoeren. In plaats van het analyseren, redeneren, berekenen en beantwoorden samen te vatten in één enkele stap, laat je het een reeks tussenliggende gedachten doorlopen die samen tot een conclusie leiden.

In de praktijk kan dit zo simpel zijn als het toevoegen van een instructie zoals "laat je redenering stap voor stap zien" of "laten we dit systematisch oplossen" aan het einde van je opdracht. Die kleine toevoeging stimuleert het model om de reeks tussenliggende toestanden te onthullen die tot het eindresultaat leiden, in plaats van direct naar een antwoord te springen dat slechts plausibel klinkt.

CoT maakt observeerbaarheid ook aanzienlijk eenvoudiger. Als het model fout is, kun je vaak precies de stap aanwijzen waar de logica de mist in ging, in plaats van te staren naar een mysterieus fout getal of een onjuiste beslissing zonder enige verklaring.

De kloof tussen patroonherkenning en daadwerkelijk redeneren.

LLM's zijn ongelooflijk goed in het herkennen van patronen, omdat ze in wezen gigantische kansberekeningsmachines zijn die getraind zijn op enorme hoeveelheden tekst. Stel de vraag: "Wat is zwaarder, een pond veren of een pond lood?" en een modern model heeft die strikvraag al honderden of duizenden keren voorbij zien komen; het antwoordt vol zelfvertrouwen dat ze evenveel wegen.

Maar wanneer je een vraag stelt die meerdere gekoppelde bewerkingen vereist, kan de prestatie snel achteruitgaan. Een klassiek voorbeeld: "Als 5 machines 5 minuten nodig hebben om 5 widgets te maken, hoe lang zouden 100 machines er dan over doen om 100 widgets te maken?" Veel modellen zullen, tenzij ze zorgvuldig worden begeleid, een intuïtief maar onjuist antwoord geven.

Het kernprobleem is meestal niet een gebrek aan kennis, maar een gebrek aan structuur. Redeneren in meerdere stappen vereist impliciet dat het model meerdere bewerkingen achter elkaar uitvoert: de tekst begrijpen, vaststellen wat er gevraagd wordt, relevante relaties of formules koppelen, berekeningen uitvoeren en een antwoord formuleren. Als je een onmiddellijk antwoord eist, vraag je het model in feite om dat hele proces in één keer af te ronden.

Door middel van de 'Chain of Thought'-aanwijzing krijgt het model 'ruimte om na te denken', doordat de impliciete opeenvolging wordt omgezet in expliciete tekst. Onderzoek van Google en anderen heeft aangetoond dat wanneer je modellen vraagt ​​om "hun berekeningen te laten zien", de nauwkeurigheid bij rekenkundige taken, logisch redeneren en symbolische manipulatie aanzienlijk verbetert in vergelijking met directe antwoorden.

Een bijzonder opvallend experiment: toen onderzoekers GPT-3 wiskundevragen op basisschoolniveau stelden, gaf het apparaat met eenvoudige aanwijzingen minder dan 20% van de vragen correct. Toen ze de vraagstelling simpelweg veranderden in een vraag naar een meer diepgaande redenering, schoot de nauwkeurigheid omhoog naar boven de 50%, en door daar zelfconsistentie aan toe te voegen, steeg deze naar de midden-70%. Dezelfde gewichten, hetzelfde model – alleen een slimmere manier om de vraag te stellen.

Kerntypen van gedachteketen-aanzet

Ontwikkelaars hebben een aantal varianten van CoT ontwikkeld om een ​​balans te vinden tussen nauwkeurigheid, kosten en implementatiecomplexiteit. Je zult varianten tegenkomen zoals zero-shot CoT, few-shot CoT, Automatic CoT (Auto-CoT), self-consistency, Tree-of-Thoughts en least-to-most prompting, elk geschikt voor iets andere scenario's.

Nulschots gedachtegang

Zero-shot CoT is de meest lichtgewicht optie: je hoeft geen voorbeelden in te voeren, je hoeft alleen maar een redeneerinstructie toe te voegen. Zinnen zoals "Laten we stap voor stap nadenken", "Los dit zorgvuldig op, één stap tegelijk" of "Leg je redenering uit voordat je antwoordt" zijn bekende triggers die het aangeleerde redeneergedrag van het model activeren.

Uit ervaring blijkt dat deze simpele aanpassing een enorm verschil kan maken. Uit eerder onderzoek naar rekenkundige benchmarks bleek dat de nauwkeurigheid steeg van ongeveer 10% tot meer dan 40% door simpelweg een stapsgewijze instructie toe te voegen. Je krijgt dus een enorme verbetering in de kwaliteit van het redeneren zonder een voorbeeldbibliotheek te hoeven bouwen of onderhouden.

Zero-shot CoT blinkt uit wanneer je snel resultaat wilt boeken bij algemene redeneertaken en latentie en kosten voor jou van belang zijn. De prompts blijven kort, waardoor je betaalt voor minder tokens en minder contextopbouw, terwijl je toch aanzienlijke interpreteerbaarheid en nauwkeurigheid wint.

Het nadeel is dat het model een eigen redeneerstijl moet ontwikkelen, die omslachtig, inconsistent tussen verschillende domeinen of soms zelfs onlogisch kan zijn, ook al lijkt het eindresultaat correct. Voor specialistische domeinen – financiën, geneeskunde, recht, veiligheidskritische beslissingen – is dit meestal niet voldoende.

Een keten van gedachten met weinig schoten

Few-shot CoT hanteert een meer uitgesproken mening: je laat het model voorbeeldvragen en -antwoorden zien waarbij de antwoorden expliciete redeneringsstappen bevatten. Na een paar van zulke demonstraties voeg je je eigen vraag toe en laat je het model het patroon nabootsen.

Deze aanpak is buitengewoon krachtig wanneer de structuur van een geldige redenering er echt toe doet. Voor een tool voor financiële analyse kunt u voorbeelden opnemen die de berekening van kasstromen, disconteringspercentages en risicoaanpassingen toelichten. Voor een medische triagebot kunt u klinische beslissingsbomen integreren: symptomen, anamnese, alarmsignalen, differentiële diagnoses en vervolgens aanbevelingen.

Het nadeel is dat een CoT met weinig schoten serieuze en snelle technische inspanningen vereist. Je moet duidelijke, diverse voorbeelden ontwerpen, ervoor zorgen dat de logica correct en representatief is, en ze bijwerken naarmate de beperkingen van je product of domein veranderen. Langere prompts betekenen ook meer tokens, hogere kosten en een hogere latentie per aanroep.

Toch presteert few-shot CoT bij gevoelige of complexe domeinen doorgaans beter dan zero-shot en is het vaak de standaard die je in een productieomgeving wilt hanteren. Je krijgt meer controle over de stijl en diepgang van je redenering, en je kunt het model wegleiden van zwakke of irrelevante denkpatronen.

Automatische gedachtegang (Auto-CoT)

Het handmatig maken van goede voorbeelden van gedachteketens is niet goed schaalbaar, dus hebben onderzoekers Automatic Chain of Thought (Auto-CoT) voorgesteld om het grootste deel van dat werk door het model zelf te laten uitvoeren. Het idee is om automatisch diverse redeneerketens te genereren die je als demonstraties kunt hergebruiken.

Auto-CoT verloopt doorgaans in twee fasen:

• Vraagclustering: Je neemt een dataset met problemen, je verwerkt ze (bijvoorbeeld met behulp van een zinstransformator) en je clustert ze zodat vergelijkbare vragen bij elkaar komen te staan.
• Demonstratiemonsters: Uit elk cluster kies je een representatieve vraag en vraag je de LLM om een ​​redeneerketen te genereren met zero-shot CoT, meestal met behulp van eenvoudige heuristieken zoals "korte vragen met ongeveer 5 redeneerstappen".

Het resultaat is een bibliotheek met automatisch gegenereerde, redelijk diverse CoT-voorbeelden zonder handmatige toevoeging. Wanneer er een nieuwe vraag binnenkomt, kunt u relevante demonstraties uit deze bibliotheek ophalen of selecteren en deze als korte CoT-voorbeelden in de prompt invoegen.

Hoewel sommige automatisch gegenereerde ketens kleine foutjes kunnen bevatten, zorgen diversiteit en de mogelijkheid om gegevens terug te vinden ervoor dat de impact van een enkel foutief voorbeeld wordt beperkt. In de praktijk presteert Auto-CoT vaak beter dan zowel de pure zero-shot als de naïeve few-shot CoT op het gebied van redeneerprestaties, terwijl het tegelijkertijd veel menselijke tijd bespaart.

Zelfconsistentie over meerdere redeneerpaden

Zelfconsistentie is een geavanceerde uitbreiding die rekenkracht inruilt voor betrouwbaarheid. In plaats van het model te vragen om één redeneerketen en antwoord, bemonster je verschillende onafhankelijke ketens (door de temperatuur aan te passen of parameters te bemonsteren), waarna je de uiteindelijke antwoorden samenvoegt door middel van meerderheidsstemming.

De intuïtie is dat er veel geldige redeneerpaden zijn die naar hetzelfde juiste antwoord leiden, maar dat foutieve paden vaak afwijken. Bijvoorbeeld, “15 − 3 + 8” kan worden berekend als “12 + 8”, of “15 + 8 = 23, trek er vervolgens 3 vanaf”, of “reken van links naar rechts”. Al deze methoden leveren 20 op, maar een onderbroken keten kan eindigen op 21. Als je meerdere voorbeelden uitvoert, wordt het onjuiste antwoord meestal overstemd.

Bij benchmarks zoals GSM8K heeft het toevoegen van zelfconsistentie aan CoT geleid tot nauwkeurigheidsverbeteringen van meer dan tien procent. Het voor de hand liggende nadeel is dat je nu meerdere LLM-aanroepen per gebruikersquery uitvoert, waardoor zowel de latentie als het tokenverbruik vermenigvuldigd worden met het aantal samples.

Daardoor is zelfconsistentie het meest geschikt voor werkzaamheden met een hoge inzet: financiële berekeningen, juridische redeneringen, klinische besluitvormingsondersteuning en veiligheidscontroles. Voor een simpele chatbot zijn de extra rekenkracht en rekenkracht zelden de moeite waard, maar voor een bedrijfskritische agent kan de verhoogde betrouwbaarheid elke milliseconde waard zijn.

Gedachtenboom: vertakkingen in plaats van lineair redeneren

Tree-of-Thoughts (ToT) breidt Chain of Thought uit van een enkele keten naar een vertakkende zoekboom met mogelijke gedachten. In plaats van één enkel redeneerpad van begin tot eind te volgen, onderzoekt het systeem bij elke stap verschillende opties, snoeit het zwakke takken weg en gaat het verder via de sterkste.

Dit komt meer overeen met hoe je combinatorische of strategische problemen in je eigen hoofd zou aanpakken. Je brainstormt over een aantal mogelijke stappen, onderzoekt ze gedeeltelijk, laat de doodlopende wegen varen en blijft veelbelovende richtingen verder uitwerken totdat je een solide oplossing hebt gevonden.

Qua implementatie coördineert ToT doorgaans veel LLM-gesprekken. Op elk niveau van de boom stelt het model vervolgstappen voor; een controller evalueert gedeeltelijke toestanden, mogelijk met behulp van een ander LLM of heuristische scoreberekening, en kiest welke takken moeten worden uitgebreid. Onderzoeksdemonstraties hebben ToT gebruikt om puzzelspellen, planningstaken en creatieve ideeëngeneratie aan te pakken met aanzienlijk betere resultaten dan met gewone CoT.

De keerzijde is de kosten: mogelijk heb je tientallen telefoontjes nodig voor één enkel probleem. Daarom is ToT het meest geschikt voor niches waar grondig onderzoek belangrijker is dan snelheid – denk aan complexe ontwerpen, game-agents of brainstormsessies waarbij diepgang en diversiteit de doelen zijn.

Minst tot meest stimulerend

De 'least-to-most'-promptingstrategie is een andere geavanceerde methode waarbij een complex probleem wordt opgedeeld in eenvoudigere deelproblemen die in volgorde worden aangepakt. Eerst vraag je het model om de minimale deeltaak te identificeren die het kan oplossen; vervolgens geef je die oplossing terug en vraag je om het volgende, meest complexe onderdeel; en zo verder totdat het volledige probleem is opgelost.

Dit patroon werkt bijzonder goed voor compositioneel redeneren. Denk aan geneste datastructuurquery's, meerstapsalgebra of codegeneratie voor complexe functionaliteiten waarbij elk onderdeel afhankelijk is van eerdere resultaten. Door een duidelijke decompositie af te dwingen, verlaag je de cognitieve belasting van het model bij elke stap en maak je het algehele redeneertrace gemakkelijker te inspecteren.

Gedachtenketen in agentische en gereedschapgebruikende systemen

CoT wordt nog waardevoller zodra je begint met het bouwen van agents die acties uitvoeren, tools aanroepen en plannen maken in meerdere stappen. In plaats van één enkele vraag te beantwoorden en vervolgens te stoppen, doorlopen deze systemen cycli van denken, handelen en observeren, waarbij ze hun plannen aanpassen met elk nieuw stukje informatie.

Stel je voor dat een medewerker van de klantenservice het volgende te horen krijgt: "Ik heb afgelopen dinsdag een rode trui besteld, maar ik heb een blauwe ontvangen. Kan ik deze retourneren?" Een redelijke workflow zou er als volgt uit kunnen zien: het probleem begrijpen, de bestelling vinden, het retourbeleid controleren, de retourtermijn controleren, de geschiktheid bepalen en ten slotte de retourzending initiëren.

Met een simpele aanwijzing zou de medewerker, op basis van een snelle patroonherkenning, direct kunnen reageren met "Zeker, hier is een label" of "Nee, dat kunnen we niet doen", waardoor cruciale controles worden overgeslagen. Met Chain of Thought laat je het systeem iets zeggen als: "Ik zoek eerst je bestelling van afgelopen dinsdag op, controleer vervolgens of het artikel en de kleur niet overeenkomen, kijk of je nog binnen de 30 dagen retourtermijn valt en start dan de retourprocedure als je daarvoor in aanmerking komt."

Dit komt dicht in de buurt van het ReAct-patroon (Reason + Act): de agent wisselt af tussen interne redenering ("Ik moet de orders-API raadplegen") en externe acties (het uitvoeren van de API-aanroep), en integreert vervolgens de waarnemingen in de volgende redeneerstap. Elk stukje "gedachte" wordt onderdeel van het spoor dat je kunt vastleggen, debuggen en analyseren.

Voor agentsystemen is CoT niet zomaar een leuke extra; het is vaak de belangrijkste factor voor betrouwbaarheid, transparantie en veiligheid. Als er iets misgaat – verkeerd hulpmiddel, verkeerde parameter, verkeerde interpretatie – kun je precies zien waar de agent de mist in is gegaan en de prompt, de hulpmiddelen of het beleid corrigeren in plaats van in het duister te tasten.

Snelle keten versus gedachtegang

Zowel prompt chaining als de gedachteketen zijn nuttig bij complexe taken, maar ze werken op verschillende niveaus. Bij prompt chaining verdeel je een grote workflow over meerdere afzonderlijke prompts, waarbij de output van de ene prompt wordt doorgegeven aan de volgende. Met CoT integreer je het volledige redeneerproces in één enkele prompt-response-uitwisseling.

Voorbeeld van prompt chaining: Een boek analyseren in drie stappen: eerst een samenvatting van de plot, vervolgens een thema-analyse op basis van die samenvatting, en tot slot een eindbespreking met behulp van beide. Elke stap is een aparte LLM-sessie met eigen instructies.

Voorbeeld van een gedachtegang voor een vergelijkbare taak: Binnen één prompt zeg je: "Vat eerst de plot samen, identificeer vervolgens de belangrijkste thema's en sluit af met een kort kritisch perspectief. Denk stap voor stap na over elke fase." Het model genereert vervolgens in één keer een eigen mini-proces van gedachten en het uiteindelijke antwoord.

In de praktijk combineren echte systemen vaak beide: ze gebruiken CoT binnen elke stap in de keten om het redeneren te verbeteren, en ze koppelen meerdere met CoT verrijkte prompts aan elkaar om lange workflows te coördineren. Het belangrijkste verschil is dat prompt chaining de macroworkflow over meerdere gesprekken structureert, terwijl Chain of Thought de micro-redenering binnen elk gesprek structureert.

Multimodale gedachtegang

Naarmate multimodale modellen zich verder ontwikkelen, is Chain of Thought niet langer beperkt tot pure tekst. Multimodale CoT maakt het mogelijk dat een systeem gezamenlijk redeneert over tekst, afbeeldingen en mogelijk andere input zoals audio of tabellen, terwijl het tegelijkertijd de interne stappen beschrijft.

Neem een ​​foto van een druk strand en stel de vraag: "Lijkt deze plek op dit moment populair bij toeristen?" Een multimodaal CoT-model zou expliciet rekening kunnen houden met het aantal paraplu's, de mensendichtheid, de drukke parkeerplaats en aanwijzingen van het tijdstip of schaduwen, en vervolgens beargumenteren dat al die visuele signalen wijzen op een hoge actuele populariteit.

Door de visuele redenering expliciet te maken, bereik je niet alleen een betere nauwkeurigheid, maar ook veel beter interpreteerbare beslissingen. Gebruikers kunnen zien op welke elementen van de afbeelding het model zich heeft gericht, en u kunt fouten opsporen zoals overmatige focus op irrelevante details.

Het optimaliseren van gedachtegangen op grote schaal

Zodra je van een paar demo's overstapt naar echt verkeer, word je geconfronteerd met de harde realiteit: de effectiviteit van CoT hangt sterk af van de taak, de Handleiding voor modelupdates en migratiede formulering en de specifieke voorbeelden die je eraan geeft. Goed onderbouwde redeneringen kunnen nog steeds tot foute antwoorden leiden, en langdradige denkprocessen kunnen tokens verspillen zonder veel waarde toe te voegen.

Om CoT in een productieomgeving te laten werken, heb je een feedbacklus nodig die meerdere dimensies tegelijk bijhoudt:

• Eindnauwkeurigheid: Komt het antwoord van het model overeen met de verwachte werkelijkheid of met menselijk oordeel?
• Redeneerkwaliteit: Zijn de tussenstappen geldig, logisch consistent en in lijn met de beperkingen van het domein?
• Consistentie: Leveren vergelijkbare vragen vergelijkbare redeneringen en antwoorden op bij verschillende uitvoeringen en in de loop van de tijd?
• Token efficiëntie: Hoeveel tokens gebruik je per zoekopdracht, en krijg je daarvoor voldoende kwaliteit terug?

Handmatige steekproefsgewijze controle op een handvol voorbeelden is niet voldoende wanneer je tientallen promptvarianten en honderden testgevallen hebt. Je hebt infrastructuur nodig die prompts kan versioneren, gestructureerde evaluaties kan uitvoeren en redeneerprocessen op grote schaal kan visualiseren.

Speciaal voor LLM's ontwikkelde observatietools helpen hierbij door voor elk verzoek de volledige trace vast te leggen: prompt, model, CoT-redenering, toolaanroepen en uiteindelijke output. Platformen zoals Opik laten je bijvoorbeeld CoT-ketens gedetailleerd vastleggen en inspecteren, verschillende promptversies vergelijken en zelfs LLM-als-rechter-instellingen gebruiken om zowel de eindantwoorden als de kwaliteit van de redenering automatisch te beoordelen.

Met die gegevens in handen kunt u uw CoT-instellingen stapsgewijs verfijnen: de formulering aanpassen, nul-shot vervangen door een paar-shot, voorbeelden afstemmen of opnieuw genereren met Auto-CoT, of zelfconsistentie alleen introduceren waar dat een verschil maakt. Sommige frameworks integreren zelfs met optimalisatiebibliotheken zoals DSPy of evolutionair zoeken om iteratief betere prompts te ontwikkelen op basis van evaluatiemetrieken.

Houd er rekening mee dat een gedachtegang vrijwel altijd duurder is dan een direct antwoord: alleen al de redeneringstekst kan het tokengebruik met een factor 2 tot 4 verhogen, zelfconsistentie vermenigvuldigt dat met het aantal voorbeelden, en een gedachteboom kan nog eens tien keer zo duur zijn. Daarom is duidelijke monitoring belangrijk, zodat je precies weet waar dat extra budget zijn vruchten afwerpt.

Voor veel teams is de pragmatische strategie gelaagd: standaard kiezen voor een lichte nul-shot of korte, beperkte CoT, en pas overgaan op zelfconsistentie of ToT voor vragen die als waardevol, zeer onduidelijk of zeer risicovol worden aangemerkt. Observeerbaarheid en evaluatie maken dit soort dynamische strategieën haalbaar.

Wanneer je experimenteert met CoT in je eigen toepassingen – of het nu gaat om snelle nul-shot prompts, zorgvuldig samengestelde few-shot voorbeelden, geautomatiseerde Auto-CoT-bibliotheken of zelfconsistentie met meerdere voorbeelden – is het essentieel om de redenering van het model te behandelen als een eersteklas productoppervlak. Maak het expliciet, registreer het, beoordeel het en herhaal het proces, en je zult veel betrouwbaarder, interpreteerbaarder en krachtiger gedrag uit dezelfde onderliggende modellen halen dan je ooit zou kunnen bereiken met simpele, eenmalige antwoorden.