"Don't Do That!": Guiding Embodied Systems through Large Language Model-based Constraint Generation

Dit artikel introduceert STPR, een framework dat grote taalmodellen gebruikt om complexe natuurlijke taalbeperkingen voor robotnavigatie ("wat je niet moet doen") om te zetten in uitvoerbare Python-functies, waardoor robuuste planning in gesimuleerde omgevingen mogelijk wordt zonder complexe redenering of hallucinaties.

De kern

"Niet doen!" – Een slimme robot die luistert naar jouw waarschuwingen

Stel je voor dat je een robot hebt die je huis moet schoonmaken. Je wilt dat hij de vloer poets, maar je hebt ook een paar specifieke regels: "Ga niet te dicht bij de open haard, die is heet!" of "Ga de keuken niet in als er een hond is."

Vroeger was dit voor een robot een droom. Als je dit in gewone taal tegen een robot zei, kon hij het vaak niet begrijpen, of hij deed het verkeerd. Hij zou misschien denken: "Oh, een haard? Dat is mooi, ik ga er even op zitten," en dan verbranden. Of hij zou de keuken binnenstappen terwijl de hond er is, en de hond zou hem bijten.

De onderzoekers van dit paper hebben een slimme oplossing bedacht, genaamd STPR. Laten we uitleggen hoe dit werkt met een paar simpele vergelijkingen.

Het probleem: De robot die te veel fantaseert

Grote taalmodellen (zoals de slimme AI's die we vandaag kennen) zijn geweldig in het schrijven van verhalen of het beantwoorden van vragen. Maar als je ze direct vraagt om een route te plannen, zijn ze als een dromerige architect.
Ze kunnen een prachtig plan schetsen op papier, maar ze vergeten vaak de fysieke realiteit. Ze kunnen "hallucineren": ze bedenken een route die er logisch uitziet, maar die dwars door een muur gaat of direct in de haard leidt. Ze zijn te creatief en niet streng genoeg.

De oplossing: De robot als vertaler, niet als planner

In plaats van de AI te laten beslissen waar de robot moet gaan, laten we de AI alleen doen wat hij het beste kan: vertalen.

STPR werkt als een talenvertaler die direct een bouwtekening maakt:

1. De Vertaler (De AI): Jij zegt tegen de AI: "Vermijd de haard, die is heet." De AI denkt niet na over de route zelf. In plaats daarvan schrijft hij een klein computerprogrammaatje (een Python-functie). Dit programmaatje is als een slimme meetlat. Het zegt: "Als de robot op punt X staat, en die punt is te dicht bij de haard, dan is dat 'verboden terrein'."
2. De Bouwmeester (De Traditionele Algorithmes): Nu geven we die meetlat aan een heel oude, zeer strenge en logische robot-planner (zoals A* of RRT*). Deze planner is niet creatief, maar hij is onfeilbaar in logica. Hij neemt de meetlat en gebruikt die om het huis te "scannen".
   • Waar de meetlat "verboden" zegt, plaatst de planner onzichtbare, ondoordringbare muren in zijn hoofd.
   • Hij zoekt dan de kortste weg van A naar B, maar hij mag nooit door die onzichtbare muren.

Waarom is dit zo slim?

• Geen dromen, maar feiten: De AI hoeft niet te fantaseren over de route. Hij hoeft alleen maar de regels in code te zetten. De strenge planner zorgt ervoor dat de regels worden nageleefd.
• Het is als een onzichtbaar hek: Stel je voor dat de AI een hek om de haard bouwt. De robot ziet het hek niet met zijn camera's, maar in zijn "hersenen" (de software) is het er wel. Hij kan er gewoon niet overheen.
• Zelfs kleine robots kunnen het: Het paper toont aan dat je geen super-dure, enorme AI nodig hebt. Zelfs kleinere, snellere modellen kunnen die "meetlat" (de code) perfect schrijven.

Wat hebben ze getest?

Ze hebben dit in een virtueel huis getest met vier moeilijke situaties:

1. De beveiligingscamera: De robot mocht niet in het zicht van een camera komen. De AI schreef code die precies berekende waar het zichtveld was.
2. Het gat in de vloer: Er was een onzichtbaar gat (zoals een kussen dat een put bedekt). De AI maakte een code die zei: "Pas op, hier is een gat!"
3. Het dier in de keuken: Als er een dier is, mag de keuken dicht. De AI begreep deze voorwaarde en bouwde een hek om de keuken.
4. De hete haard: De robot mocht niet te dichtbij komen, zelfs als de haard niet aanraakt, maar alleen warmte uitstraalt. De AI schreef een formule voor warmteverspreiding en maakte een veiligheidszone.

Het resultaat

In al deze tests lukte het de oude planners (zonder AI) niet: ze liepen dwars door de muren of in de haard. De "dromerige" AI's (die direct een route probeerden te bedenken) faalden ook vaak door hallucinaties.

Maar STPR (de combinatie van vertaler + strenge planner) slaagde 100% van de tijd. De robot vond altijd een weg, of hij gaf eerlijk toe: "Het is onmogelijk om daar te komen zonder de regels te breken."

Conclusie

Dit paper laat zien dat we AI niet hoeven te dwingen om alles zelf te bedenken. Als we AI gebruiken als een slimme vertaler die regels omzet in duidelijke instructies, en die instructies geven aan een strenge, logische planner, krijgen we robots die veilig, betrouwbaar en precies doen wat we van hen verwachten.

Het is alsof je een dromerige schrijver vraagt om de regels van een spel op te schrijven, en dan een strikte scheidsrechter die de regels exact naleeft. Zo krijg je een spel dat zowel creatief als eerlijk is.

Technische samenvatting

Probleemstelling

Robotnavigatie in de echte wereld vereist niet alleen het bereiken van een doel, maar ook het naleven van complexe, vaak informele constraints die door menselijke operators worden opgelegd (bijv. "niet te dicht bij de open haard komen" of "de keuken vermijden als er een dier is").

• Uitdaging: Deze constraints zijn vaak vaag, impliciet of niet-gestandaardiseerd en moeilijk om direct uit sensorgegevens te halen.
• Beperkingen van bestaande methoden:
  • Pure LLM-planning: Het laten genereren van een volledig actieplan door een Large Language Model (LLM) leidt vaak tot hallucinaties (plannen die fysiek onmogelijk zijn), gebrek aan interpretatie en onbetrouwbare naleving van constraints. Zelfs geavanceerde redenerende modellen bieden geen theoretische garanties en zijn computatief duur.
  • Traditionele planners: Algoritmen zoals A* of RRT* zijn robuust en efficiënt, maar kunnen geen natuurlijke taal begrijpen en negeren semantische beperkingen.

Methodologie: STPR (Safe Trajectory Planning with Restrictions)

De auteurs stellen STPR voor, een neuro-symbolisch raamwerk dat de kracht van LLMs combineert met traditionele zoekalgoritmen. In plaats van dat de LLM het pad plant, vertaalt deze de constraints naar uitvoerbare code.

De kern van de methode:

1. LLM als Constraint Generator:

   • De LLM ontvangt een prompt met de omgeving (tekstuele beschrijving of point cloud data) en de natuurlijke taal-instructie (bijv. "Vermijd de hitte van de open haard").
   • De LLM genereert een Python-boolean functie (f: X → {True, False}). Deze functie fungeert als een indicator: als de functie True retourneert voor een coördinaat, is dat punt verboden (een "forbidden region").
   • Door de LLM te dwingen gestructureerde code te genereren in plaats van vrije tekst, worden hallucinaties geminimaliseerd en wordt de output interpreteerbaar.

2. Point-Cloud Sampling (Rejection Sampling):

   • De gegenereerde Python-functies worden gebruikt om een point-cloud representatie van de omgeving aan te vullen met "virtuele obstakels".
   • Het systeem samplet punten in de 3D-ruimte. Punten die door de LLM-functie als verboden worden gemarkeerd, worden verwijderd (rejected) of gemarkeerd als obstakel.
   • Om inefficiëntie te voorkomen, vraagt de LLM soms ook om een omhullende box (bounding box) voor de constraint, waarna binnen die box wordt gesampled.

3. Gecombineerde Padplanning:

   • Een klassiek zoekalgoritme (in dit paper A* voor rasteromgevingen en RRT* voor continue ruimtes) plant het pad binnen de gefilterde state space (de point cloud zonder de verboden punten).
   • Dit zorgt ervoor dat het eindresultaat wiskundig gegarandeerd voldoet aan de constraints, zolang de zoekalgoritmen compleet en sound zijn.

Kernbijdragen

• Neuro-symbolische Integratie: STPR splitst de taken op: de LLM doet de semantische vertaling (taal naar code), en de klassieke planner doet de beslissingen (planning). Dit combineert flexibiliteit met theoretische garanties.
• Code-gebaseerde Constraints: Het gebruik van Python-functies als tussenlaag maakt complexe wiskundige constraints (zoals hitteverspreiding of zichtlijnen) uitvoerbaar zonder dat de planner zelf complexe redenering moet doen.
• Onafhankelijkheid van Sensorinvoer: Het systeem kan werken met constraints die door de gebruiker worden opgegeven, zelfs als de robot geen specifieke sensoren heeft om die constraints waar te nemen (bijv. een robot zonder temperatuursensoren die toch veilig blijft bij een open haard).
• Compatibiliteit met kleinere modellen: Het systeem werkt effectief met kleinere "code-specialized" LLMs, wat de inferentiekosten verlaagt.

Resultaten

De auteurs hebben STPR geëvalueerd in een gesimuleerde Gazebo-omgeving (ROS) met vier uitdagende scenario's:

1. S1 (Veiligheidscamera): Vermijden van het gezichtsveld (FOV) van een camera.
2. S2 (Gat): Vermijden van een onzichtbaar gat in de vloer.
3. S3 (Dier in keuken): Een conditionele constraint: de keuken vermijden als er een dier is.
4. S4 (Open haard): Vermijden van hittezones op basis van fysieke modellen.

Belangrijkste bevindingen:

• 100% Succesratio: STPR (zowel met A* als RRT*) behaalde een 100% succesratio in alle scenario's, inclusief het correct melden dat een pad niet bestaat wanneer een constraint het pad blokkeert (bijv. S1 en S3).
• Vergelijking met Baselines:
  • Traditionele planners (A/RRT* zonder STPR):* 0% succes; ze negeerden alle constraints.
  • Naïeve VLM-planning (GPT-4o/o3-mini): Zeer lage succesratio (0-10%), vaak met hallucinaties of het negeren van statische objecten.
• Kwaliteit en Runtime: STPR levert paden van hoge kwaliteit (optimaal of asymptotisch optimaal). De totale runtime (prompting + sampling + planning) ligt tussen de 12 en 18 seconden, wat acceptabel is voor veel toepassingen.
• Modelvariatie: Zelfs kleinere code-LLMs (zoals Granite-34B-Code) presteerden betrouwbaar, terwijl zeer grote redenerende modellen (zoals o1-pro) aanzienlijk trager waren zonder significant betere resultaten.

Betekenis en Conclusie

Dit paper toont aan dat LLMs betrouwbaar kunnen worden geïntegreerd in robotnavigatie, mits hun rol beperkt wordt tot het vertalen van natuurlijke taal naar formele, uitvoerbare constraints. Door de complexe redenering en besluitvorming over te dragen aan bewezen zoekalgoritmen, worden de valkuilen van LLMs (hallucinaties, inconsistentie) omzeild.

STPR biedt een praktische, kosteneffectieve oplossing voor het veilig navigeren van robots in dynamische omgevingen met complexe menselijke instructies, zonder de noodzaak van zware training of extensieve hyperparameter-tuning. Het benadrukt de kracht van een hybride aanpak waarbij de "intelligentie" van taalmodellen wordt gekoppeld aan de "strenge logica" van klassieke planning.