Synthesizing Interpretable Control Policies through Large Language Model Guided Search

Dit artikel presenteert een methode die Large Language Models en evolutionaire algoritmen combineert om interpreteerbare besturingspoliieken in standaard programmeertalen te synthetiseren voor dynamische systemen, zoals de pendel en de bal in de beker, waardoor transparantie en menselijke aanpasbaarheid worden vergroot ten opzichte van traditionele black-box benaderingen.

De kern

Stel je voor dat je een robot wilt leren om een pendulum (een slinger) omhoog te zwaaien of een bal in een kopje te vangen. Normaal gesproken laten we dit doen door een "zwart doosje" van kunstmatige intelligentie (AI) te trainen. Dit doosje is een enorm complex neuraal netwerk dat na duizenden pogingen weet wat het moet doen, maar niemand weet waarom het die beslissingen neemt. Het is als een genie dat een taak perfect uitvoert, maar als je vraagt hoe het dat deed, zegt het alleen: "Ik heb het gewoon gevoeld."

In deze paper stellen Carlo Bosio en Mark Mueller een nieuwe manier voor. Ze willen geen onbegrijpelijke zwarte doosjes, maar heldere, leesbare instructies die een mens kan begrijpen, lezen en zelfs zelf aanpassen.

Hier is hoe hun methode werkt, vertaald naar alledaagse taal:

1. De Idee: Schrijf een recept, niet een magieformule

In plaats van een neuraal netwerk te laten "groeien", laten ze de AI Python-code schrijven. Python is een programmeertaal die mensen lezen en begrijpen.

• De Analogie: Stel je voor dat je een kok wilt leren koken.
  • De oude manier: Je laat de kok duizenden keren koken en hij onthoudt de smaak, maar je ziet nooit het recept. Als het eten verbrandt, weet je niet of het de temperatuur was of de tijd.
  • De nieuwe manier: Je laat de AI een recept schrijven. "Als de pan heet is, doe dan boter erbij." Dit recept is een programma. Iedereen kan het lezen, begrijpen en zeggen: "Oh, misschien moeten we de boter iets later toevoegen."

2. De Werkwijze: De AI als een creatieve chef-kok met een proefkeuken

De auteurs gebruiken een Large Language Model (LLM), zoals een super-intelligente tekstgenerator, maar dan gespecialiseerd in code. Het proces lijkt op een spelletje "verbeteren en proberen":

1. De Opdracht: Je geeft de AI een startrecept (een stukje basiscode) en een proefkeuken (een simulatie).
2. Het Proefnemen: De AI schrijft een nieuw recept (een programma). Dit programma wordt in de simulatie getest.
   • Voorbeeld: Laat de AI een programma schrijven dat de slinger omhoog zwaait.
3. De Score: Als het programma faalt (de slinger valt), krijgt het een slechte score. Als het werkt, krijgt het een goede score.
4. De Evolutie: De AI kijkt naar de beste recepten die tot nu toe zijn gemaakt. Het zegt: "Oké, dit recept werkte goed, maar dat andere stukje was ook slim. Laten we die twee combineren en proberen het nog beter te maken."
5. Herhaling: Dit proces herhaalt zich duizenden keren. De AI "evolueert" steeds betere programma's, net zoals biologische evolutie, maar dan met code in plaats van DNA.

3. Het Resultaat: Een transparante machine

Het mooie resultaat is dat je aan het einde geen onbegrijpelijke wiskundige matrices krijgt, maar een eenvoudig Python-script.

• Voorbeeld uit de paper: Voor de slinger (pendulum) schreef de AI een programma dat in mensentaal vertaald ongeveer zo klinkt:

  "Als de slinger bijna rechtop staat, gebruik dan een zachte, lineaire beweging. Maar als hij nog ver weg is, duw hem dan hard op en af (zoals een 'bang-bang' schakeling) om energie op te bouwen."

Dit is iets wat een menselijke ingenieur direct kan lezen, begrijpen en zelfs verbeteren. Misschien wil je de "zachte beweging" iets anders instellen? Dan pas je gewoon twee regels code aan. Je hoeft geen PhD in deep learning te hebben.

4. Waarom is dit belangrijk?

• Veiligheid: In kritieke systemen (zoals een auto of een robot in een fabriek) wil je weten waarom een beslissing wordt genomen. Een zwarte doos is riskant; een leesbaar recept is veilig.
• Samenwerking: Mensen kunnen samenwerken met de AI. De AI zoekt de basis, en de mens kan de laatste hand leggen op basis van intuïtie.
  • Voorbeeld uit de paper: Bij het "bal in kopje"-spel zag de AI een oplossing, maar een mens keek ernaar en dacht: "Wacht, als de bal te hoog is, moet het kopje iets zakken." De mens voegde die ene regel code toe, en het resultaat werd veel beter.

Samenvattend

De auteurs zeggen eigenlijk: "Laten we AI niet gebruiken om een onbegrijpelijke magie te creëren, maar als een krachtige assistent om heldere instructies te schrijven."

Ze gebruiken de kracht van de AI om te zoeken in een oneindig universum van mogelijke programma's, maar het eindresultaat is iets dat voor elke mens begrijpelijk is. Het is alsof je een genie hebt dat duizenden recepten bedenkt, maar het beste recept op een kaartje schrijft dat je zelf kunt lezen en aanpassen.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "Synthesizing Interpretable Control Policies through Large Language Model Guided Search" in het Nederlands.

Probleemstelling

De integratie van kunstmatige intelligentie (AI) en besturingstechniek (control theory) staat voor een fundamenteel dilemma. Hoewel machine learning (ML) en versterkend leren (RL) uitstekende prestaties leveren in complexe dynamische systemen, zijn de resulterende besturingspolitieken vaak "black-box" modellen (zoals neurale netwerken). Deze modellen ontberen transparantie en verifieerbaarheid, wat essentieel is voor veiligheidskritische toepassingen. Besturingsingenieurs kunnen de logica achter een beslissing van een neurale netwerk niet direct inspecteren, begrijpen of aanpassen zonder de complexe gewichtsstructuren te decoderen. Het doel van dit onderzoek is het creëren van besturingspolitieken die niet alleen hoog presteren, maar ook volledig interpreteerbaar en door mensen aanpasbaar zijn.

Methodologie

De auteurs stellen een nieuwe methode voor die Large Language Models (LLMs) combineert met evolutionaire zoekalgoritmen en simulatie-evaluatie om besturingspolitieken te synthetiseren die als standaard computercode (bijvoorbeeld Python) worden weergegeven.

Het proces verloopt als volgt:

1. Representatie: In plaats van parameters in een neurale netwerk te optimaliseren, wordt de besturingspolitiek $u_t = \text{policy}(x_t)$ direct gedefinieerd als een programma in Python. Dit garandeert inherent interpreteerbaarheid.
2. Architectuur: Het systeem bestaat uit een iteratieve cyclus met vier hoofdblokken (zoals getoond in Figuur 1 van het paper):
   • Specificatie: Een invoerbestand bevat de taakbeschrijving, startercode en een evaluatiefunctie.
   • Programma-Generatie: Een voorgeïnstalleerd LLM (StarCoder2-Instruct) ontvangt een prompt met de huidige beste programma's en instructies om deze te verbeteren. Het LLM genereert nieuwe kandidaat-programma's. Dit fungeert als een "crossover" in evolutionaire algoritmen.
   • Programma-Evaluatie: De gegenereerde code wordt in een gesimuleerde omgeving (MuJoCo via DeepMind Control Suite) uitgevoerd in een gesloten kring. De prestaties worden gekwantificeerd via een beloningsfunctie (cumulatieve beloning).
   • Database & Selectie: Programma's die syntactisch correct zijn en goed presteren, worden opgeslagen in een database. Slecht presterende programma's worden verworpen.
3. Evolutionaire Strategie: Om lokale optima te vermijden, wordt een "island"-benadering gebruikt. Er worden 10 onafhankelijke populaties (eilanden) parallel geëvolueerd. Periodiek worden de slechtste populaties herinitialiseerd met de beste programma's van andere eilanden.
4. Interactie: De mens kan de gegenereerde code direct lezen, begrijpen en handmatig aanpassen (fine-tunen) op basis van expertise, waarna het proces kan worden hervat.

Belangrijkste Bijdragen

• Code als Politiek-Representatie: Het introduceren van standaard programmeertalen als representatie voor besturingspolitieken, waardoor de "black-box" van runtime-execute wordt verplaatst naar de ontwerpfase.
• LLM-Gestuurde Zoekruimte: Het toepassen van een LLM niet voor directe besturing, maar als generator van kandidaat-programma's binnen een evolutionair raamwerk, waarbij het model wordt gebruikt om de discrete zoekruimte van tokens te navigeren zonder gradients.
• Interpreteerbaarheid en Aanpasbaarheid: Het bewijzen dat complexe besturingsstrategieën kunnen worden gegenereerd die voor een mens leesbaar zijn en eenvoudig kunnen worden gemodificeerd zonder de onderliggende ML-modellen opnieuw te hoeven trainen.
• Open Source Implementatie: Het beschikbaar stellen van de code en de framework voor herhaalbaarheid.

Resultaten

De methode werd getest op twee uitdagende dynamische systemen uit de DeepMind Control Suite:

1. Pendulum Swing-up:

   • Taak: Een pendulum van een hangende positie naar een staande positie zwaaien met beperkt koppel.
   • Resultaat: Het systeem synthetiseerde een compacte Python-functie die een hybride strategie implementeert: eerst een "bang-bang" controle (maximaal koppel in de richting van de beweging) om energie op te bouwen, gevolgd door een lineaire feedbackregeling wanneer de pendulum dicht bij de verticale positie is.
   • Interpretatie: De gegenereerde code (zie Figuur 4) is wiskundig afleidbaar en stabielheidsanalyse (Lyapunov) is direct mogelijk.

2. Ball in Cup:

   • Taak: Een beker (cup) besturen om een bal te vangen die eraan hangt.
   • Resultaat: Het systeem vond een complexer, 8-dimensionaal beleid.
   • Menselijke Verbetering: De auteurs toonden aan dat een mens de gegenereerde code kon analyseren, onnodige logica kon verwijderen en een intuïtieve verbetering kon toevoegen (een voorwaarde om de beker iets te verlagen als de bal te hoog is). Deze handmatige aanpassing leidde tot een aanzienlijke verbetering in de vangkans (minder episodes die de tijdslimiet van 15 seconden bereikten zonder succes).

Betekenis en Toekomstperspectief

Dit werk markeert een verschuiving in de manier waarop AI wordt ingezet voor besturingstechniek:

• Vertrouwen en Veiligheid: Door de politiek als leesbare code te presenteren, wordt de kloof tussen data-gedreven leren en veilige, verifieerbare industriële toepassingen verkleind.
• Samenwerking Mens-AI: Het stelt een nieuwe vorm van samenwerking mogelijk waarbij de AI de zoekruimte verkent en de mens de richting stuurt op basis van intuïtie en domeinkennis.
• Uitdagingen: De huidige methode is rekentechnisch intensief (ongeveer 10 uur op een enkele GPU voor de getoonde resultaten) omdat er geen gradiënten beschikbaar zijn om de zoektocht te sturen. Toekomstig werk richt zich op het combineren van LLM-generatie met gradiëntgebaseerde optimalisatie voor de numerieke parameters en het schalen naar hogere dimensies.

Concluderend biedt deze aanpak een robuust alternatief voor neurale netwerken in besturingssystemen, waarbij de kracht van grote AI-modellen wordt benut voor het ontwerp, terwijl de uitvoering volledig transparant en controleerbaar blijft.