RLSF: Fine-tuning LLMs via Symbolic Feedback

Dit paper introduceert RLSF, een nieuwe fijnafstappingsparadigma voor grote taalmodellen dat symbolische hulpmiddelen gebruikt voor gedetailleerde feedback, waardoor kleinere modellen aanzienlijk beter presteren dan grotere gesloten modellen op taken die logische en domeinspecifieke redenering vereisen.

De kern

Stel je voor dat je een zeer slimme, maar soms wat ongeduldige student hebt die alles uit het hoofd kan leren en prachtige zinnen kan vormen. Dit is een Groot Taalmodel (LLM). Hij kan een gedicht schrijven, een verhaal bedenken of zelfs code voor een website genereren. Maar als je hem vraagt om een complexe wiskundige som op te lossen, een chemische formule te bouwen of een programma te schrijven dat echt werkt, kan hij in de war raken. Hij blijft vaak hangen in "het klinkt goed", terwijl het feitelijk fout is.

De auteurs van dit paper, RLSF, hebben een slimme oplossing bedacht om deze student niet alleen te laten "gissen", maar hem te laten leren van een onfeilbare leraar.

Hier is hoe het werkt, vertaald naar alledaagse taal:

1. Het Probleem: De "Gokker" vs. De "Wiskundeleraar"

Normaal gesproken leren deze AI-modellen door menselijke feedback (zoals in het bekende RLHF).

• Hoe het nu gaat: Je vraagt de AI om een antwoord. Een mens kijkt er naar en zegt: "Ja, dat is goed" of "Nee, dat is fout".
• Het nadeel: Dit is als een gokker die probeert een puzzel op te lossen door willekeurig stukjes te verplaatsen en hoopt dat iemand roept "goed zo!". De menselijke feedback is vaak vaag ("dit is een beetje raar") en kost veel tijd.

2. De Oplossing: RLSF (Leren van de "Wiskundeleraar")

De auteurs introduceren RLSF (Reinforcement Learning via Symbolic Feedback).

• De Analogie: In plaats van een menselijke leraar die soms twijfelt, geven ze de AI een onfeilbare wiskundeleraar (een computerprogramma dat perfect is in logica, zoals een bewijstool of een chemisch simulatieprogramma).
• Hoe het werkt:
  1. De AI schrijft een antwoord (bijvoorbeeld een stukje code of een chemische formule).
  2. De "Wiskundeleraar" (het symbolische gereedschap) checkt het direct.
  3. Het magische verschil: De leraar zegt niet alleen "fout". Hij wijst exact aan welke letter, welk woord of welk symbool verkeerd is.
  4. De AI krijgt een gedetailleerde kaart van zijn fouten en leert direct hoe hij het moet verbeteren.

3. Drie Voorbeelden uit het Dagelijkse Leven

De paper toont dit aan met drie verschillende "proefballonnen":

A. De Programmeur (Van idee naar werkende code)

Stel, je vraagt de AI om een computerprogramma te schrijven op basis van een beschrijving in gewoon Nederlands.

• Zonder RLSF: De AI schrijft code die er mooi uitziet, maar als je het compileert, crasht het. De menselijke feedback zegt alleen: "Het werkt niet."
• Met RLSF: De AI schrijft de code. De "compiler" (de leraar) zegt: "Regel 5, het woordje ; ontbreekt, en in regel 12 heb je een variabele gebruikt die niet bestaat." De AI krijgt een puntenkaart voor elke regel: goed = punten, fout = geen punten. Zo leert hij in no-time perfect code te schrijven.
• Het resultaat: Een klein modelletje (2 miljard parameters) schrijft nu betere code dan een gigantisch model (100x groter) dat alleen maar op menselijke feedback leert.

B. De Scheikundige (Het bouwen van moleculen)

Stel, je vraagt de AI om een nieuw medicijnmolecuul te ontwerpen.

• Zonder RLSF: De AI bedenkt een molecuul dat er op papier mooi uitziet, maar in de echte wereld zou het ontploffen of gewoon niet bestaan (omdat atomen niet aan elkaar kunnen plakken zoals de AI denkt).
• Met RLSF: Een chemisch programma (RDKit) checkt de formule. "Hé," zegt het, "Stikstof (N) heeft hier te veel handjes om zich heen. Dat mag niet." De AI krijgt een signaal: "Pas dit specifieke atoom aan."
• Het resultaat: De AI leert de regels van de scheikunde letterlijk te volgen. Een klein model (Galactica) presteert hier beter dan GPT-4 (een model 1000x groter).

C. Het Spel "24" (Wiskundig puzzelen)

Het doel is om met 4 getallen en de basisrekenkundige bewerkingen (+, -, *, /) het getal 24 te krijgen.

• Zonder RLSF: De AI probeert willekeurige combinaties. "Misschien is 12 + 12 goed?" Nee, dat is niet 24.
• Met RLSF: De AI probeert een oplossing. De wiskundige tool checkt direct: "Nee, 12 + 12 is 24, maar je hebt de getallen verkeerd gebruikt." De AI krijgt een stap-voor-stap feedback over waar zijn redenering fout liep.
• Het resultaat: De AI wordt een meester in het spel. Een klein model (Llama2) wint vaker dan een veel groter model (GPT-3.5).

4. Waarom is dit zo speciaal?

De grote kracht van deze methode is dat de AI niet hoeft te leren van menselijke meningen (die vaak subjectief zijn), maar van harde feiten (wiskunde, logica, chemie).

• Vroeger: "Ik denk dat dit antwoord goed is." (Menselijke feedback)
• Nu: "Dit antwoord is wiskundig onmogelijk. Hier is de exacte stap die fout ging." (Symbolische feedback)

Conclusie in één zin

De auteurs hebben een manier bedacht om slimme, maar soms onnauwkeurige AI's te trainen met een onfeilbare, digitale leraar die hen elke fout tot in de kleinste detail corrigeert. Hierdoor kunnen kleine, snelle AI-modellen nu taken uitvoeren die normaal alleen voor de gigantische, dure modellen weggelegd waren.

Het is alsof je een beginnende chef-kok (de kleine AI) niet meer laat gissen naar het recept, maar hem een automatische smaakmeter geeft die precies zegt: "Te zout, voeg nu een snufje peper toe." En plotseling kookt die beginnende chef beter dan de beroemdste sterrenchef ter wereld.

Technische samenvatting

Probleemstelling

Grote Taalmodellen (LLMs) hebben de AI-landschap getransformeerd, maar ze kampen met significante beperkingen bij taken die domeinspecifiek redeneren en logische consistentie vereisen. Traditionele fijne-tuningmethoden (zoals Supervised Fine-Tuning of SFT) en Reinforcement Learning from Human Feedback (RLHF) hebben de volgende tekortkomingen:

• Gebrek aan symbolische kennis: Ze maken geen gebruik van de enorme hoeveelheid symbolische domeinkennis die beschikbaar is via redeneertools (zoals bewijzers, solvers en algebra-systemen).
• Onbetrouwbare beloningssignalen: RLHF vertrouwt vaak op menselijke feedback of zwarte-kast beloningsmodellen die schaars (sparse) en scalair (enkel 0 of 1) zijn. Dit biedt geen gedetailleerde instructies over waar en hoe een fout in de output zit.
• Logische inconsistentie: LLMs kunnen vloeiende tekst genereren die logisch onjuist is of syntactische fouten bevat die niet direct zichtbaar zijn bij inspectie.

Methodologie: Reinforcement Learning via Symbolic Feedback (RLSF)

Het paper introduceert RLSF, een nieuw paradigma voor het fijne-tunen van LLMs dat symbolische redeneertools integreert in het leerproces. In tegenstelling tot RLHF, waarbij een mens of een geschat beloningsmodel feedback geeft, fungeert in RLSF een symbolisch systeem als de omgeving die feedback genereert.

Kerncomponenten van het algoritme:

1. Agent en Omgeving: De LLM is de RL-agent. De omgeving bevat een "SymbolicReasoner" (bijv. een compiler, een chemische toolkit zoals RDKit, of een wiskundige solver zoals SymPy).
2. Generatie en Certificering: De LLM genereert een antwoord (bijv. code, een molecuul, of een wiskundige oplossing). Het symbolische systeem analyseert deze output en genereert een poly-grootte certificaat (bijv. een compiler-foutmelding, een bewijs van ongeldigheid, of een validatie van chemische valentie).
3. Token-level Feedback: In plaats van één scalair getal (succes/mislukken) te geven, wordt het certificaat omgezet in een vector-feedback op token-niveau.
   • Foutieve tokens krijgen een lage beloning (bijv. 0).
   • Correcte tokens krijgen een hoge beloning (bijv. 1 of een waarde gebaseerd op de mate van correctheid).
   • Dit biedt dichte (dense) feedback, waardoor het model precies kan leren welke specifieke delen van de output moeten worden aangepast.
4. Update: Het model wordt bijgewerkt met behulp van Proximal Policy Optimization (PPO) op basis van deze token-level vector.
5. Voordeel: Het vereist geen differentieerbare redeneersystemen, wat het veelzijdiger maakt dan traditionele neuro-symbolische RL-approaches.

Belangrijkste Bijdragen

• Het RLSF-paradigma: Een nieuwe methode die symbolische tools gebruikt om fijne-tuning te sturen via gedetailleerde, logisch onderbouwde feedback.
• Token-level correctie: Het vermogen om fouten op token-niveau te identificeren en te corrigeren, wat leidt tot veel effectiever leren dan schaarse, scalair feedback.
• Brede toepasbaarheid: De methode is getoetst op vijf verschillende taken uit diverse domeinen (programmatie, scheikunde en wiskunde).
• Efficiëntie: Het toont aan dat kleinere, open-source modellen na RLSF-fijne-tuning beter presteren dan veel grotere, gesloten modellen.

Resultaten en Evaluatie

De auteurs hebben RLSF geëvalueerd op vijf specifieke taken. De resultaten tonen aanzienlijke verbeteringen ten opzichte van Zero-shot, SFT, en traditionele RL met Boolean feedback:

1. Programma-synthese (NL Pseudo-code naar C++):

   • Modellen: Google CodeGemma-2b, Stable-Code-3b, DeepSeek-Coder-1.3b.
   • Resultaat: RLSF-tuning van CodeGemma-2b leidde tot een +31,43% verbetering in functionele correctheid vergeleken met SFT.
   • Vergelijking: Het getunte 2B-parameter model presteerde beter dan GPT-3.5 (ongeveer 100x groter) in zowel compilatie- als functionele correctheid.

2. Scheikundige Taken (Molecuulgeneratie, Forward Synthese, Retrosynthese):

   • Modellen: Mistral-7b, Galactica-1.3b (Meta).
   • Resultaat: RLSF op Galactica-1.3b resulteerde in een +33,7% verbetering in exacte match voor retrosynthese en +19,4% voor forward synthese.
   • Vergelijking: Het getunte 1,3B-parameter model presteerde beter dan GPT-4 (ongeveer 1000x groter) op deze taken.

3. Game of 24 (Wiskundig redeneren):

   • Modellen: Gemma-2b-it, Llama2-7b-chat.
   • Resultaat: RLSF-tuning van Llama2-7b-chat leidde tot een +25% succesrate (tegenover traditionele methoden) en een +7% verbetering ten opzichte van GPT-3.5.
   • Vergelijking: Het 7B-parameter model overtrof het 175B-parameter GPT-3.5 model.

Overige bevindingen:

• RLSF presteerde consistent beter dan RL met alleen Boolean feedback (0/1), wat aantoont dat de granulariteit van token-level feedback cruciaal is.
• De overhead van het gebruik van symbolische tools (zoals compilers of RDKit) is beheersbaar door asynchrone parallelisatie (bijv. <1 uur extra per 24-uurs training voor code-synthese).

Betekenis en Conclusie

Het paper demonstreert dat het integreren van symbolische feedback in het fijne-tuningproces van LLMs een krachtige methode is om domeinspecifieke beperkingen op te lossen. De belangrijkste implicaties zijn:

• Kleine modellen kunnen grote modellen verslaan: Door gebruik te maken van correcte, logische feedback kunnen relatief kleine open-source modellen (1B-7B parameters) gespecialiseerde taken beter uitvoeren dan enorme gesloten modellen (100B-1000B parameters).
• Verbinding tussen Symboliek en Statistiek: RLSF overbrugt de kloof tussen de statistische kracht van LLMs en de strikte logica van symbolische systemen zonder dat de symbolische systemen zelf differentieerbaar hoeven te zijn.
• Toekomstperspectief: Hoewel de focus ligt op fijne-tuning, suggereert het paper dat het combineren van RLSF met multi-stap symbolische feedback tijdens inferentie (inference) de prestaties nog verder kan verbeteren.

Samenvattend biedt RLSF een praktische en effectieve route om LLMs robuuster en logischer te maken in complexe domeinen, waarbij het de afhankelijkheid van menselijke feedback en enorme rekenkracht voor prestatieverbetering reduceert.