Large Language Models are Contrastive Reasoners

Dit artikel introduceert contrastive prompting, een methode waarbij grote taalmodellen worden gevraagd om zowel een correct als een fout antwoord te genereren, wat hun redeneervermogen aanzienlijk verbetert en prestaties op diverse taken overtreft zonder handmatige voorbeelden.

De kern

Grote Taalmodellen zijn als een slimme, maar soms slordige student: Laat ze hun fouten zien!

Stel je voor dat je een zeer slimme, maar soms wat slordige student hebt die alles weet over wiskunde, alledaagse zaken en logica. Deze student is een Groot Taalmodel (LLM). Als je hem een vraag stelt, geeft hij vaak direct het juiste antwoord. Maar soms... maakt hij een domme fout. Hij rekent verkeerd, hij mist een detail, of hij raakt in de war.

In het verleden dachten onderzoekers: "Oké, laten we de student gewoon vertellen: 'Denk stap voor stap na'." Dat hielp een beetje, maar de student bleef soms nog steeds fouten maken, vooral als hij haast had of als de vraag lastig was.

De auteurs van dit paper (Liang Yao van de Sun Yat-sen Universiteit) hebben een slimme nieuwe truc bedacht. Ze noemen het Contrastive Prompting (of 'Gegeneerde Prompting').

De Truc: Laat de student zijn eigen fouten maken

In plaats van alleen te vragen: "Wat is het antwoord?", zeggen ze tegen de computer: "Geef me eerst een goed antwoord, en daarna een fout antwoord."

Het klinkt misschien gek. Waarom zou je een computer vragen om iets verkeerd te doen?

De Analogie: De Twee Spiegels
Stel je voor dat je een schilderij bekijkt. Als je alleen naar het echte schilderij kijkt, zie je de details. Maar als je ook naar een versie kijkt waar de kleuren verkeerd zijn gemengd of de lijnen scheef staan, dan zie je plotseling veel scherper wat er echt goed aan is.

Door de computer te dwingen om een fout antwoord te bedenken, gebeurt er magie:

1. De computer moet nadenken over hoe het niet moet.
2. Hierdoor wordt hij zich bewust van valkuilen en fouten die hij normaal gesproken zou maken.
3. Wanneer hij daarna het goede antwoord geeft, is hij veel zekerder en accurater, omdat hij de 'valstrikken' al heeft gezien en vermeden.

Hoe werkt het in de praktijk?

Stel, je vraagt de computer: "Tim heeft 5 bomen. Elk jaar plukt hij 6 citroenen van elke boom. Hoeveel citroenen heeft hij in een decennium (10 jaar)?"

• De oude manier (Standaard): De computer zegt direct: "3000!" (Fout! Hij heeft vermenigvuldigd met 100 in plaats van 10, of een andere domme fout gemaakt).
• De nieuwe manier (Contrastive Prompting):
  • De computer denkt: "Oké, ik moet een goed en een fout antwoord geven."
  • Fout antwoord: "In één jaar heeft hij 30 citroenen. Een decennium is 20 jaar, dus 30 x 20 = 600." (De computer ziet hier zelf: Oh, een decennium is 10 jaar, niet 20! Ik heb net een fout gemaakt door de definitie te verwarren.)
  • Goed antwoord: "In één jaar heeft hij 30 citroenen. Een decennium is 10 jaar, dus 30 x 10 = 300."

Door het proces van het bedenken van de fout, heeft de computer zichzelf 'gecorrigeerd' voordat hij het definitieve antwoord gaf.

Wat zijn de resultaten?

De onderzoekers hebben dit getest op heel veel moeilijke vragen, van wiskundepuzzels tot vragen over alledaagse logica (zoals: "Zakt een peer in water?").

• Grote sprong voorwaarts: Bij de beroemde wiskundetoets GSM8K steeg het succes van 35,9% naar 88,8% met de krachtigste computer (GPT-4). Dat is een enorme verbetering!
• Geen menselijke hulp nodig: Het mooie is dat je geen menselijke docenten nodig hebt om voorbeelden te geven. De computer leert dit van zichzelf door de opdracht "Geef een goed en een fout antwoord" te krijgen.
• Werkt overal: Het werkt niet alleen voor rekenen, maar ook voor vragen over gevoelens, logica en symbolen.

Waarom werkt dit?

De auteurs geven vier goede redenen:

1. Oefening: Computers zijn getraind op enorme hoeveelheden tekst van internet. Daar staan vaak vragen én de antwoorden (soms goed, soms fout) in. Ze kennen het patroon van een fout antwoord.
2. Zelfreflectie: Door expliciet om een fout te vragen, dwing je de computer om zijn eigen "brein" te checken.
3. Vertrouwen: Als de computer het fout antwoord ziet, wordt hij overtuigd dat het andere antwoord (het goede) de juiste is. Het is alsof hij zegt: "Nee, dat was dom, dit is slim."
4. Eén keer doen: In plaats van dat de computer 10 keer hetzelfde antwoord moet geven om het beste eruit te kiezen, doet hij het in één keer door het contrast.

Conclusie

Dit paper laat zien dat we slimme computers niet hoeven te dwingen om altijd perfect te zijn. Als we ze juist laten zien hoe ze fout kunnen zijn, worden ze plotseling veel slimmer in het vinden van het juiste antwoord.

Het is alsof je een kind leert fietsen niet door te zeggen "Val niet", maar door te zeggen "Kijk eens hoe je zou vallen als je niet oplet, en nu fiets je maar eens zonder te vallen." Door de fout te visualiseren, wordt het juiste pad helderder.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het artikel "Large Language Models are Contrastive Reasoners" in het Nederlands.

Titel: Large Language Models are Contrastive Reasoners

Auteur: Liang Yao (Sun Yat-sen University)

---

1. Het Probleem

Hoewel Large Language Models (LLM's) indrukwekkende prestaties leveren, ondervinden ze uitdagingen bij complexe redeneertaken. De huidige standaardmethode, Chain-of-Thought (CoT) prompting, kent twee belangrijke beperkingen:

• Zero-shot CoT: Gebruikt instructies zoals "Think step by step", maar genereert vaak onjuiste redeneerstappen, vooral bij taaksoorten als common-sense vragen en rekenwiskunde.
• Few-shot CoT: Vereist handmatig gelabelde voorbeelden van redeneerstappen per taak, wat duur en tijdrovend is om te produceren.

De kernvraag is: Is het mogelijk om een nauwkeuriger redeneerproces te genereren zonder afhankelijk te zijn van menselijke labeling of vooraf gedefinieerde voorbeelden?

2. Methodologie: Contrastive Prompting (CP)

De auteurs introduceren Contrastive Prompting (CP), een nieuwe aanpak die LLM's aanzet tot het genereren van zowel een correct als een onjuist antwoord binnen dezelfde context. De methode is gebaseerd op het idee dat mensen leren door fouten te identificeren en te analyseren.

Het proces bestaat uit twee fasen:

1. Redeneringsextractie (Reasoning Extraction):
   • De gebruiker voegt een specifieke triggerzin toe aan de prompt, bijvoorbeeld: "Let's give a correct and a wrong answer."
   • Het LLM genereert vervolgens een tekst waarin het een correcte oplossing en een expliciet onjuiste oplossing (met een foutieve redenering) produceert.
   • Het model moet hierbij bewust fouten maken (bijv. een verkeerde rekentijd gebruiken of een detail negeren) om het contrast te creëren.
2. Antwoordextractie (Answer Extraction):
   • Een tweede prompt wordt gebruikt om het definitieve, correcte antwoord te extraheren uit de gegenereerde tekst. Omdat het model het onjuiste antwoord al heeft gegenereerd en geïdentificeerd als fout, is de kans groter dat het correcte antwoord nauwkeurig is.

Integratie:
Deze methode is modulair en kan worden gecombineerd met bestaande technieken (aangeduid als X-CP), zoals Zero-shot CoT, Few-shot CoT, of andere "X-of-thought" methoden.

3. Belangrijkste Bijdragen

• Nieuwe Prompting-strategie: Het introduceren van een simpele, handmatige trigger ("geef een correct en een fout antwoord") die de redeneercapaciteit van LLM's aanzienlijk verbetert zonder extra training of few-shot voorbeelden.
• Zelfreflectie zonder menselijke input: In tegenstelling tot eerdere methoden die menselijke annotaties nodig hebben om fouten te genereren (zoals Contrastive CoT), laat CP het model zelf fouten bedenken die consistent zijn met zijn eigen kennispatronen.
• Universele toepasbaarheid: De methode werkt effectief op een breed scala aan taken, waaronder wiskundig redeneren, common-sense vragen, symbolisch redeneren en logische puzzels.
• Openbare code: De implementatie is beschikbaar via een GitHub-repository.

4. Resultaten

De auteurs hebben de methode getest op 12 datasets (waaronder GSM8K, AQUA-RAT, SVAMP, StrategyQA) met verschillende modellen (GPT-3.5, GPT-4, LLaMA3, ChatGLM, Qwen).

Kernresultaten:

• Significante verbetering: Zero-shot CP overtreft standaard Zero-shot en Zero-shot CoT in de meeste taken.
  • Op GSM8K (wiskunde) steeg de nauwkeurigheid van 35,9% naar 88,8% met GPT-4.
  • Op AQUA-RAT steeg de score van 41,3% naar 62,2%.
• Vergelijking met State-of-the-Art: CP presteert beter dan of vergelijkbaar met geavanceerde methoden zoals Few-shot CoT, Tree of Thoughts (ToT), en Self-Consistency, vaak zonder de noodzaak van dure few-shot voorbeelden.
• Robuustheid: De methode werkt goed op zowel gesloten (GPT) als open-source modellen (LLaMA3-8B/70B, Qwen).
• Kwalitatieve analyse: Het genereren van een "fout" antwoord helpt het model om valkuilen te vermijden. In veel gevallen identificeert het model de fout in het onjuiste antwoord expliciet (bijv. "Dit is fout omdat een decennium 10 jaar is, niet 20"), wat de kans op een correct eindantwoord vergroot.

5. Betekenis en Conclusie

De studie toont aan dat LLM's intrinsiek "contrastieve redenaars" zijn. Door het model te dwingen om bewust een alternatief, foutief pad te verkennen, wordt de waarschijnlijkheid dat het model de juiste oplossing kiest, verhoogd. Dit komt doordat het model tijdens het genereren van het foutieve antwoord zijn eigen kennispatronen activeert en de verschillen tussen waar en onwaar kan benadrukken.

Belangrijkste conclusies:

• Het genereren van foutieve antwoorden is een krachtige techniek om de redeneerprestaties van LLM's te verbeteren zonder menselijke tussenkomst.
• De methode is eenvoudig te implementeren, kosteneffectief (geen extra labeling) en kan naadloos worden geïntegreerd in bestaande prompting-workflows.
• Dit opent nieuwe wegen voor het verbeteren van LLM's in complexe redeneertaken door gebruik te maken van hun eigen vermogen om fouten te simuleren en te corrigeren.