Multimodal Behavior Tree Generation: A Small Vision-Language Model for Robot Task Planning

Dit paper introduceert een methode om een compact, open-source vision-language model te fine-tunen voor het genereren van uitvoerbare behavior trees voor robottaken, waarbij een groot model als leraar fungeert om een dataset te creëren en een 4B-parameter model een succesratio van 87% bereikt met een fractie van de rekenkracht van gesloten systemen.

De kern

Stel je voor dat je een robot wilt leren om huishoudelijke klusjes te doen, zoals het opruimen van de woonkamer of het maken van een sandwich. Je wilt niet dat je de robot elke beweging handmatig moet programmeren (zoals "ga 10 cm naar links, pak de kom vast"). Nee, je wilt gewoon zeggen: "Maak een boterham" en de robot moet het zelf uitzoeken.

Dit artikel beschrijft een slimme manier om dat te doen, maar dan met een kleine, efficiënte robot-geest in plaats van een enorme, dure supercomputer.

Hier is de uitleg, vertaald naar alledaags taal:

1. Het Probleem: De Robot is "Blind" voor de Wereld

Vroeger konden robots alleen werken als je ze tekst gaf. Ze wisten niet wat er om hen heen gebeurde.

• Vergelijking: Het is alsof je een kok vraagt een taart te bakken, maar je geeft hem alleen een recept op papier. Hij kan niet zien of er al eieren in de kom zitten of of de oven warm is. Hij moet blindelings vertrouwen op wat je zegt.

De auteurs van dit paper wilden een robot maken die kijkt (via een camera) én luistert (naar jouw instructie), en dan zelf een plan maakt.

2. De Oplossing: Een "Gedragsbomen" Generator

Robots werken vaak met zogenaamde Gedragsbomen (Behavior Trees).

• De Metafoor: Denk aan een stamboom, maar dan voor acties.
  • Tak 1: "Is de deur open?" -> Nee? -> "Draai aan de kruk."
  • Tak 2: "Is de deur open?" -> Ja? -> "Loop erdoorheen."
  • Tak 3: "Val je?" -> "Blijf staan."

Het doel van dit onderzoek was een robot-geest te bouwen die, als hij naar een foto van de keuken kijkt en hoort "Maak koffie", direct zo'n gedragstboom schrijft die de robot kan uitvoeren.

3. Het Grote Probleem: Er was geen "Leerboek"

Om een robot-geest slim te maken, moet je hem duizenden voorbeelden geven van: "Hier is een foto, hier is de opdracht, en hier is het perfecte plan."

• Het Dilemma: Zo'n boek bestond niet. Er waren wel foto's van robots, en er waren wel plannen, maar niemand had ze aan elkaar gekoppeld.

De Oplossing van de auteurs: Ze bouwden een Leraar.
Ze gebruikten een gigantische, zeer slimme AI (de "Leraar") om voorbeelden te maken.

1. De Leraar keek naar oude video's van robots.
2. Hij bedacht: "Als de robot deze foto zag en dit moest doen, dan zou hij dit plan moeten volgen."
3. Hij schreef het plan op in het speciale XML-formaat (de "taal" van de robot).

Zo creëerden ze een eigen leerboek, puur door de Leraar te laten nadenken.

4. De Ster van het Verhaal: De "Compacte" Robot-Geest

Meestal gebruiken mensen enorme AI-modellen (zoals GPT-4) om dit te doen. Die zijn echter te zwaar om op een echte robot te zetten (die heeft vaak maar een kleine batterij en een simpele computer).

De auteurs wilden een kleine, lichte versie (een "Compact Model") trainen.

• De Analogie: Stel je voor dat je een universitair professor (de grote AI) vraagt om een leerling (de kleine robot) te trainen. De professor doet het zware denkwerk om de voorbeelden te maken, en de leerling (de kleine robot) leert daarvan.
• Ze gebruikten een techniek genaamd QLoRA. Dit is alsof je de leerling niet het hele universum laat studeren, maar alleen de belangrijkste hoofdstukken in een heel compact notitieboekje. Hierdoor wordt de robot slim, maar blijft hij lichtgewicht.

5. De Resultaten: Klein maar Krachtig

Ze testten hun kleine robot-geest in een virtuele wereld (een videospelletje-achtige simulatie) met echte huishoudelijke taken, zoals:

• "Zet de afvalbak buiten."
• "Pak de boodschappen uit de auto."
• "Zet de kerstversiering op."

Wat bleek?

• De grote, dure modellen deden het goed (zoals verwacht).
• De kleine, open-source modellen (met ongeveer 4 miljard "hersencellen") deden het bijna even goed als de grote modellen!
• Ze haalden een succespercentage van 87%. Dat betekent dat ze in 87 van de 100 pogingen het juiste plan maakten, terwijl ze veel minder rekenkracht nodig hadden.

6. Waar struikelen ze nog?

Natuurlijk is het niet perfect. Soms maakt de kleine robot-geest fouten:

• Fout 1: Hij probeert de koelkast open te maken terwijl hij al een blikje in zijn hand vasthoudt (fysiek onmogelijk).
• Fout 2: Hij hallucineert objecten die er niet zijn (hij denkt dat er een appel op tafel ligt, terwijl er niets ligt).

Maar de boodschap is helder: Je hebt geen supercomputer meer nodig om een slimme robot te maken. Met de juiste trainingsmethode en een slimme "Leraar" in de achtergrond, kunnen kleine, betaalbare robots zelfstandig plannen maken voor complexe taken.

Kort samengevat:
De auteurs hebben een manier gevonden om een kleine, goedkope robot-geest te trainen om naar een foto en een zin te kijken, en daar een perfect stappenplan uit te halen. Ze deden dit door eerst een slimme "Leraar" te laten voorbeelden maken, zodat de kleine robot niet blindelings hoeft te raden. Het resultaat? Robots die binnenkort misschien wel écht je huis kunnen opruimen, zonder dat je een datacenter nodig hebt.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "Multimodal Behavior Tree Generation: A Small Vision-Language Model for Robot Task Planning" in het Nederlands.

Probleemstelling

Robotica vereist flexibele taakplanning, vooral in ongestructureerde omgevingen zoals huishoudens. Behavior Trees (BT's) zijn een populaire formalisme voor robotplanning vanwege hun modulariteit en reactieve uitvoering (ondersteund door de ROS2-ecosysteem bibliotheek BehaviorTree.CPP).

Bestaande benaderingen voor het automatisch genereren van BT's hebben echter twee belangrijke beperkingen:

1. Tekst-only modellen: Grote Taalmodellen (LLM's) kunnen BT's genereren op basis van tekstuele instructies, maar missen visuele waarneming. Ze kunnen zich niet aanpassen aan de daadwerkelijke staat van de omgeving (bijv. objecten die verplaatst zijn).
2. Visueel-Taalmodellen (VLM's): Bestaande multimodale benaderingen vertrouwen vaak op zeer grote, gesloten bronmodellen (zoals GPT-4o) die niet lokaal uitvoerbaar zijn op robots. Bovendien ontbreekt er een bestaand dataset dat visuele observaties en instructies koppelt aan uitvoerbare BT's.

Het doel van dit werk is om een compact, open-source multimodaal model te ontwikkelen dat direct uitvoerbare BT's genereert op basis van een RGB-afbeelding en een natuurlijke taal-instructie, zonder afhankelijk te zijn van enorme, gesloten API's.

Methodologie

De auteurs presenteren een pipeline die bestaat uit drie hoofdfasen: datasetconstructie, fine-tuning en evaluatie.

1. Dataset Constructie (Teacher-Student Pipeline)

Omdat er geen dataset bestaat die beelden en instructies koppelt aan BT's, creëren de auteurs er een uit het Open X-Embodiment-dataset (meer dan 1 miljoen robot-episodes).

• Selectie: Er worden 1.622 episodes geselecteerd. Per episode worden 9 visueel verschillende frames samengevoegd tot een 3x3 "frame sheet" (tijdsgebonden samenvatting).
• Teacher-model (GPT-5-mini): Een groot model fungeert als leraar. Het analyseert de frame sheet en de instructie om twee dingen te genereren:
  • Scene Analysis (SA): Een gestructureerde YAML-blok met doelobjecten, bestemmingen en een verwachte actievolgorde.
  • Behavior Tree (BT): Een lineaire XML-structuur compatibel met BehaviorTree.CPP.
• Validatie: Een programmatieke validator controleert of de gegenereerde XML syntactisch correct is en alleen toegestane primitieve acties bevat. Indien nodig wordt de generatie opnieuw uitgevoerd.
• Augmentatie: Het dataset wordt uitgebreid via structurele augmentatie (toevoegen van decoratoren zoals RetryUntilSuccessful) en lexische augmentatie (synoniemen voor acties), wat resulteert in een einddataset van 2.433 episodes.

2. Fine-tuning van Compacte VLM's

Drie open-source VLM's met verschillende grootte worden gefine-tuned met de gegenereerde dataset:

• SmolVLM2 (500M parameters)
• Qwen2.5-VL (3B parameters)
• Gemma 3 Vision (4B parameters)

De modellen worden getraind met QLoRA (Quantized Low-Rank Adaptation), wat de geheugenconsumptie verlaagt door de basisgewichten te quantiseren naar 4-bit, terwijl alleen lage-rang adapters worden getraind. Het model leert de mapping van (Afbeelding, Instructie, Toegestane Actielijst) naar (Scene Analyse + XML-BT).

3. Evaluatieomgeving

De gegenereerde BT's worden geëvalueerd in de OmniGibson-simulator (onderdeel van de BEHAVIOR-1K benchmark).

• De robot (R1) voert de taken uit in een fysiek realistische omgeving.
• Succes wordt gemeten aan de hand van het voldoen aan BDDL-doelpredicaten (bijv. "binnenin(gereedschapskist, boor)").
• Er wordt getest op 15 taken variërend van makkelijk tot moeilijk, met twee prompt-strategieën: Zero-Shot (alleen instructie) en Chain-of-Thought (CoT, inclusief een stap-voor-stap workflow).

Belangrijkste Bijdragen

1. Eerste Multimodale BT-dataset: Een dataset die RGB-observaties en instructies koppelt aan uitvoerbare Behavior Trees, gegenereerd via een teacher-pipeline.
2. Compacte, Fine-tuned VLM's: De eerste toepassing van compacte (500M-4B), open-source VLM's voor het genereren van robotplanningen, geschikt voor implementatie op echte hardware.
3. Uitgebreide Evaluatie: Een combinatie van offline metingen (syntaxis, structuur) en online simulatie-executie op realistische huishoudelijke taken.
4. Open Source: De auteurs publiceren de modelgewichten, code en dataset.

Resultaten

De resultaten tonen een duidelijk verschil in prestaties gebaseerd op modelgrootte:

• Syntactische Validiteit:
  • De gefine-tuned modellen Gemma-3 (4B) en Qwen2.5-VL (3B) bereiken 100% validiteit in het genereren van correcte XML en BT-CPP-structuur.
  • Het kleinste model (SmolVLM2, 500M) faalt vaak in het genereren van geldige XML (slechts 7% validiteit in simulatie met CoT), wat aangeeft dat er een drempel van ongeveer 3B parameters is voor het leren van gestructureerde output.
• Simulatie Succes (BEHAVIOR-1K):
  • Gemma-3 4B bereikt een 87% succes率 (SR) met Chain-of-Thought prompting, wat zeer dicht in de buurt komt van de gesloten bron GPT-5 (100%), maar met een fractie van de rekenkracht.
  • Zonder fine-tuning presteren alle basismodellen 0% succes.
  • Foutanalyse: Fouten verschuiven van syntactische fouten bij kleine modellen naar semantische fouten bij grotere modellen (bijv. verkeerde volgorde van acties, zoals een deur openen terwijl de grijper bezet is, of objecten hallucineren).
• Efficiëntie: De fine-tuned modellen genereren output aanzienlijk sneller dan hun basismodellen en zijn veel lichter dan gesloten API-modellen.

Betekenis en Conclusie

Dit werk bewijst dat compacte, open-source Vision-Language Modellen (VLM's) betrouwbaar kunnen worden gebruikt voor on-device robotplanning. Het overbrugt de kloof tussen visuele waarneming en uitvoerbare planning zonder afhankelijk te zijn van enorme, gesloten modellen.

De studie benadrukt echter dat modelgrootte cruciaal is: modellen onder de 3B parameters hebben moeite om complexe, gestructureerde plannen te genereren die fysieke precondities respecteren. Toekomstig werk richt zich op het sluiten van de regelkring tijdens de uitvoering (runtime refiner) om dynamische aanpassingen mogelijk te maken en het trainingsdataset te verrijken met langere, complexere demonstraties om de prestaties op moeilijke taken te verbeteren.