Technische Samenvatting: Zoeken, Falen, Herstellen: Een Trainingsframework voor Correctie-bewust Redeneren

Probleemstelling

Standaard Chain-of-Thought (CoT) supervisie traint modellen doorgaans op gepolijste, succesvolle redeneerpaden, waardoor het proces van exploratie, falen en herstel effectief wordt verborgen. Veel complexe redeneertaken zijn van nature niet lineair; een oplosser moet vaak een plausibele tak volgen, een vertraagde fout ontdekken en terugkeren naar een eerder beslissingspunt om een alternatief te proberen. Huidige trainingsparadigma's slagen er niet in modellen te leren wanneer ze onproductieve takken moeten verlaten of hoe ze moeten herstellen van fouten, aangezien het trainingssignaal zelden mislukte pogingen bevat. Dit artikel adresseert de kloof tussen de theoretische "Diligent Learner"-formulering — die stelt dat validatie gemakkelijker is dan generatie en dat terugkeren (backtracking) een leerbare gedragscapaciteit is — en de praktische implementatie van dergelijke training voor hedendaagse, relatief kleine Large Language Models (LLM's).

Methodologie: Het Pyligent Framework

De auteurs introduceren Pyligent, een trainings- en inferentieframework dat redeneren representeert als een gevalideerde zoektocht over gedeeltelijke oplossingsketens. Het framework operationaliseert de Diligent Learner-theorie door zowel succesvolle voortzettingen als mislukte takken om te zetten in gesuperviseerde trainingsvoorbeelden.

Kerncomponenten

1. Solver: Een trainbaar taalmodel dat acties één voor één genereert met behulp van een beperkte markup-vocabulaire:
   • <node>: Voegt een tussenstap toe.
   • <done>: Stelt een definitief antwoord voor.
   • <backtrack>: Geeft de controle terug aan een eerdere node met een reden.
2. Explorer: Selecteert prefixes waaruit de solver voortzettingen samplet. Het framework hanteert twee strategieën:
   • Lineair: Breidt een beperkt aantal parallelle ketens uit voor voorspelbare kosten.
   • Dendritisch: Begint breed en concentreert het budget op diepere voortzettingen.
3. Validator: Een taakspecifieke checker die voorgestelde acties valideert tegen de huidige staat. Het labelt voortzettingen als geldig of ongeldig en identificeert fouttoestanden (bijv. doodlopende wegen, schendingen van restricties).
4. ChainTree: Slaat de zoekboom op, wijst backtrack-doelen toe aan mislukte takken en zet de boomstructuur om in prefix-naar-actie trainingsvoorbeelden.

Trainingspipeline

Het trainingsproces bestaat uit drie fasen:

1. SFT-A (Teacher Dataset): De solver wordt gefinetuned op gouden oplossingsketens om de actieformat te leren en een niet-nul kans te verkrijgen om geldige volgende stappen voor te stellen.
2. Validator-gestuurde Exploratie: De solver verkent de taakruimte vanuit geselecteerde prefixes. De validator registreert zowel geldige voortzettingen als mislukte takken.
3. SFT-B (Exploratie Dataset): Het model wordt gefinetuned op de geconstrueerde ChainTree-data, die het volgende bevat:
   • Succes-paren: Training om geldige takken uit te breiden.
   • Falen-paren: Training om een <backtrack> actie te genereren wanneer restricties worden geschonden. Het doel is een specifieke eerdere node-ID met een door de validator afgeleide reden.
   • Getraceerd Herstel (Optioneel):* Om te voorkomen dat het model dezelfde fout herhaalt na afbreking, wordt een synthetische <trace> geïnjecteerd na een backtrack. Deze trace vat de verlaten tak en de reden van de validator samen, wat het model leert hoe het effectief kan hervatten.

Het framework maakt gebruik van een reverse curriculum, beginnend met exploratie nabij het einde van gouden ketens (korte herstel) en bewegend naar de wortel (langer herstel) om de moeilijkheidsgraad geleidelijk te verhogen.

Belangrijkste Bijdragen

• Implementatie van de Diligent Learner Theorie: Het artikel biedt een concrete trainingspipeline die de gedragscondities van de Diligent Learner (generatie van geldige stappen + leren terugkeren naar de maximale herstelbare prefix) vertaalt naar een gesuperviseerde leeropstelling voor kleine LLM's.
• Expliciete Supervisie op Mislukte Takken: In tegen tegenover standaard CoT, traint Pyligent expliciet op mislukte takken, door deze om te zetten in gesuperviseerde doelen voor de <backtrack> actie.
• Traced Recovery Mechanisme: De introductie van <trace> tokens stelt het model in staat om compacte foutinformatie te behouden na een backtrack, wat een betere voortzetting na herstel faciliteert.
• Gecontroleerde Benchmarking: De auteurs introduceren een Hidden Directed Graph taak die specifiek is ontworpen om vertraagde fout-herstel te isoleren, waarbij het model de taak niet kan oplossen door statische beschrijvingen te kopiëren, maar moet vertrouwen op zoek en herstel.

Experimentele Resultaten

Het framework werd geëvalueerd op vier domeinen: Hidden Directed Graphs, 4×4 Sudoku, 4×4 Sudoku met Reasoning Traces en Blocksworld.

1. Hidden Directed Graph

Deze taak isoleert het vermogen om te herstellen van vertraagde fouten.

• Prestaties: Pyligent bereikte een oplossingspercentage van 76,5%, een enorme verbetering ten opzichte van Gold-only SFT (3,8%) en het basismodel (0,0%).
• Gedrag: Pyligent-modellen maken actief gebruik van backtracking (gemiddeld 2,14 backtracks per run) waarbij 47,7% van de backtracks als "perfect" werd geclassificeerd (terugkeren naar het directe beslissingspunt dat verantwoordelijk was voor de fout). In contrast hiermee voerden Gold-only SFT zelden backtracks uit en herhaalden ze vaak fouten.

2. 4×4 Sudoku

• Gemengde Moeilijkheid: Pyligent (Linear explorer) bereikte een oplossingspercentage van 82% versus 65% voor Gold-only SFT.
• Expert Moeilijkheid: Pyligent bereikte 66% versus 48% voor Gold-only SFT.
• Ablaties: Het gebruik van reasoning traces verbeterde de prestaties aanzienlijk. Echter, het verhogen van het aantal trainingsepochs voor mislukte paden verbeterde de kwaliteit van de backtrack-syntax, maar correleerde niet altijd met hogere uiteindelijke oplossingspercentages, wat wijst op een afweging tussen het leren van herstelmechanismen en de uiteindelijke voortzetting.

3. Sudoku met Reasoning Traces (w/ RT)

In deze variant genereren modellen natuurlijke taalverantwoordingen naast de grid-toestanden. Hoewel de algemene scores lager waren dan bij standaard Sudoku, presteerden Pyligent-modellen nog steeds beter dan Gold-only SFT (bijv. 34% versus 20% op expert-taken), wat de toepasbaarheid van het framework op taken die natuurlijke taalredenering vereisen demonstreert.

4. Blocksworld

Een klassiek planningsdomein waarbij lokale validiteit geen globale progressie garandeert.

• Prestaties: Pyligent bereikte een oplossingspercentage van 50,35%, wat aanzienlijk beter is dan Gold-only SFT (29,37%) en het basismodel (0,0%).
• Herstel: Het model leerde effectieve backtracks uit te voeren, met 14,4% van de backtracks geclassificeerd als "perfect". Het framework stelde het model in staat om taken op te lossen die uniek oplosbaar waren met de herstelmechanisme.

Betekenis en Claims

Het artikel positioneert Pyligent als een empirische implementatiestudie van de Diligent Learner hypothese. De auteurs beweren dat:

1. Herstel is Leerbaar: Expliciete supervisie op mislukte takken leert modellen nuttige herstelgedragingen die niet aanwezig zijn in modellen die uitsluitend getraind zijn op gepolijste oplossingsketens.
2. Signaal voorbij het Antwoord: De structuur van mislukte pogingen en het juiste punt van terugkeer vormen een cruciaal leersignaal, dat verschilt van het uiteindelijke antwoord of het succesvolle pad.
3. Gedrag versus Token-niveau: Het framework demonstreert dat redeneercapaciteiten kunnen worden verbeterd door te focussen op gedragscondities (zoeken en validatie) in plaats van alleen op token-niveau voorspelling op succesvolle trajecten.

De auteurs blijven bescheiden over de beperkingen en merken op dat het framework momenteel afhankelijk is van exacte validators en kleine, synthetische taken. Ze erkennen dat de nauwkeurigheid-kosten afweging van exploratie en de gevoeligheid van training voor trace-formaten en de weging van fout-data verdere systematische studie vereisen. Ze beweren niet dat de methode open eindige natuurlijke taalredenering zonder verificatie oplost, maar suggereren dat het een concreet engineeringpad biedt voor het aanleren van correctie-bewust redeneren in domeinen met verifieerbare restricties.