🤖 AI

2.5-D Decomposition for LLM-Based Spatial Construction

Dit artikel introduceert een neuro-symbooltische pijplijn die gebruikmaakt van 2,5D-decompositie om de nauwkeurigheid van ruimtelijke constructie op basis van LLM's aanzienlijk te verbeteren door het model te beperken tot 2D-planning terwijl een deterministische uitvoerder verticale plaatsingen afhandelt, waardoor prestaties dicht bij het plafond worden bereikt op benchmarks en een succesvolle overdracht wordt aangetoond naar randhardware en diverse collaboratieve taken.

Oorspronkelijke auteurs: Paul Whitten, Li-Jen Chen, Sharath Baddam

Gepubliceerd 2026-05-11

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Paul Whitten, Li-Jen Chen, Sharath Baddam

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je probeert een zeer slimme, maar lichtjes onhandige robot te leren hoe hij een toren moet bouwen van kleurrijke blokken, gebaseerd op een gesproken instructie zoals: "Bouw een T-vorm en voeg een paarse blok toe aan de bovenkant."

Het probleem is dat, terwijl het brein van de robot (een Large Language Model, of LLM) uitstekend is in het begrijpen van het idee van de vorm, het vreselijk slecht is in het rekenen voor waar de blokken in de 3D-ruimte moeten worden geplaatst. Het vergeet vaak dat de zwaartekracht bestaat, en stapelt blokken in de lucht of telt verkeerd hoe hoog een stapel zou moeten zijn.

Dit artikel presenteert een slimme oplossing genaamd 2.5-D Decompositie. Hier is hoe het werkt, met behulp van eenvoudige analogieën:

Het Probleem: De "Onhandige Architect"

Denk aan de LLM als een briljante architect die een perfect 2D-ontwerp op een stuk papier kan tekenen. Hij weet precies waar de muren moeten komen op de plattegrond. Als je deze architect echter vraagt om ook de exacte hoogte van elke enkele baksteen in een 3D-toren te berekenen, begint hij fouten te maken. Hij zou kunnen zeggen: "Leg hier een baksteen", zonder te beseffen dat er al een baksteen onder ligt, of hij zou ze te hoog stapelen.

De Oplossing: De "Zwaartekrachtbestendige Voorman"

De auteurs realiseerden zich dat bij veel bouwtaken de hoogte van een blok geen vrije keuze is; deze wordt bepaald door de natuurkunde. Als je op een vlakke vloer bouwt met zwaartekracht, moet een nieuw blok zitten bovenop het hoogste blok dat er al staat. De hoogte is automatisch.

Dus hebben ze de taak opgesplitst in twee delen:

De Architect (De LLM): Dit deel mag alleen het 2D-ontwerp tekenen. Hij zegt: "Leg een rode blok op positie X, en een blauwe blok op positie Z." Het is hem verboden om over hoogte (Y) te praten. Hij plant alleen het "voetafdruk" van het gebouw.
De Voorman (De Deterministische Code): Dit is een simpel, niet-denkend computerprogramma. Zijn enige taak is om naar het ontwerp te kijken en te zeggen: "Oké, je wilt een blok op X en Z? Nou, de zwaartekracht zegt dat het bovenop moet gaan wat er al staat." Hij berekent de hoogte automatisch.

Door de "hoogte"-beslissing weg te halen bij de onhandige architect en deze te geven aan de niet-denkende voorman, hebben ze een enorme categorie fouten geëlimineerd.

De "Peephole"-Truc

Het artikel noemt ook een "Peephole Prompt Optimalisatie". Stel je voor dat de architect vatbaar is voor specifieke, voorspelbare dagdromen. Als je bijvoorbeeld zegt "verbreed het einde", zou de architect per ongeluk een toren kunnen bouwen in plaats van de vloer te verbreden.

De onderzoekers creëerden een "spot-check"-systeem. Voordat de architect het ontwerp tekent, kijkt een snelle scanner naar de instructies. Als hij een zin ziet die bekend staat om problemen te veroorzaken (zoals "elk einde"), schuift hij een klein, specifiek briefje in het oor van de architect: "Hé, wanneer je 'elk einde' ziet, denk eraan om zijwaarts te verbreden, niet omhoog." Dit fungeert als een vangnet voor de bekende zwakke plekken van de architect.

De Resultaten

Toen ze dit systeem testten:

De Oude Manier: Het gebruik van alleen de LLM om alles te doen (3D-planning) resulteerde in ongeveer 76% tot 90% nauwkeurigheid.
De Nieuwe Manier: Het gebruik van de 2.5-D-splitsing (Architect + Voorman) duwde de nauwkeurigheid omhoog naar 94,6%.
De Verrassing: Een kleiner, goedkoper AI-model (GPT-4o-mini) dat deze nieuwe methode gebruikte, sloeg eigenlijk een veel groter, duurder model (GPT-4o) dat de methode niet gebruikte.

Wereldwijde Toepasbaarheid

Het artikel toonde ook aan dat deze truc niet alleen voor één specifieke computer geldt. Ze draaiden hetzelfde systeem op een kleine, krachtige computerchip (een NVIDIA Jetson Thor) die op het hoofd van een robot kon zitten, en het werkte net zo goed als de gigantische cloudcomputers.

De Conclusie

De belangrijkste boodschap is simpel: Vraag een taalmodel niet om wiskunde te doen waar het slecht in is. Als een deel van een taak vaststaat door de natuurwetten (zoals de zwaartekracht die de hoogte bepaalt), laat dan een simpel computerprogramma dat deel afhandelen. Laat de AI zich alleen richten op de creatieve, flexibele delen van het plan. Dit maakt het hele systeem veel betrouwbaarder, zelfs als de AI zelf niet perfect is.

Opmerking: Het artikel vermeldt dat ongeveer 5% van de resterende fouten kwam van een andere "Architect Agent" die verduidelijkende vragen beantwoordt, wat een aparte beperking is die ze met deze specifieke methode niet konden oplossen.

Technische Samenvatting: 2.5-D Decompositie voor LLM-gebaseerde Ruimtelijke Constructie

Probleemstelling

Autonome systemen die fysieke structuren moeten bouwen op basis van instructies in natuurlijke taal, staan voor een kritiek betrouwbaarheidsprobleem: terwijl Large Language Models (LLM's) uitblinken in het begrijpen van hoog niveau intenties, falen ze systematisch in precieze ruimtelijke redenering, met name wat betreft het genereren van driedimensionale coördinaten. Eerdere benchmarks geven aan dat LLM's frequent fouten maken in verticale plaatsing, stapelen met een afwijking van één eenheid, en het dupliceren van posities. Deze falingen vloeien voort uit een gebrek aan interne wereldmodellen om fysieke beperkingen af te dwingen, zoals zwaartekracht, die bepalen dat de verticale positie van een blok strikt wordt bepaald door de bezetting van de kolom eronder.

Methodologie

Het artikel stelt een neuro-symboolle pipeline voor op basis van 2.5-D decompositie om deze coördinaatfouten aan te pakken. Het kerninzicht is dat in bouwgebieden met zwaartekrachtsbeperkingen de verticale as ( $y$ ) geen vrije variabele is, maar een deterministische functie van de horizontale positie ( $x, z$ ) en de huidige staat van het rooster.

De 2.5-D Decompositie Pipeline

Het systeem splitst de plannings- en uitvoeringstaken op in aparte modules:

LLM Planner (2D): De LLM is beperkt tot het genereren van een plan in het tweedimensionale horizontale vlak. Het specificeert uitsluitend $(x, z)$ -coördinaten, blokkleuren, actietypen en aantallen. Het wordt expliciet voorkomen dat het verticale ( $y$ )-coördinaten uitvoert.
Deterministische Executor (3D): Een symbolische engine berekent de verticale plaatsing voor elk blok op basis van kolombezetting. De verticale coördinaat $y^*$ voor een nieuw blok op $(x, z)$ wordt berekend als de minimale hoogte waarbij de cel leeg is, zodat zwaartekrachtsbeperkingen strikt worden nageleefd:
$y^*(x, z, G) = \min\{y \in \{0, \dots, 4\} \mid (x, y, z) \notin \text{dom}(G)\}$
Dit elimineert een hele klasse van coördinaatfouten door de $y$ -dimensie uit de uitvoerruimte van de LLM te verwijderen.

Ondersteunende Componenten

De pipeline omvat vier extra mechanismen om ambiguïteit en systematische faalmodi aan te pakken:

Structuuranalysator: Detecteert geometrische primitieven (bijv. T-vormen, L-vormen) in het bestaande rooster om de planner te informeren.
Onderspecificatie-detecteur: Gebruikt een besluitvormings-theoretisch kader om te bepalen wanneer verduidelijkende vragen gesteld moeten worden. Het berekent de verwachte waarde van gokken versus vragen, waarbij bij ambiguïteit prioriteit wordt gegeven aan vragen over kleur boven vragen over aantallen.
Peephole Prompt-optimizer: scant instructies op specifieke triggerzinnen (bijv. "elk uiteinde", "voor") die bekend staan om systematische LLM-fouten te veroorzaken. Bij detectie injecteert het gerichte, patroongematchte correcties en uitgewerkte voorbeelden in de prompt voordat de LLM-aanroep plaatsvindt.
Planverificator: Een op regels gebaseerde module die het gegenereerde plan valideert tegen de instructie en de roosterstaat, en correcties uitvoert voor consistentie in richting en plausibiliteit van stapelen.

Belangrijkste Bijdragen

2.5-D Decompositie: Een nieuw architecturaal patroon dat LLM-planning beperkt tot een 2D-horizontaal vlak, terwijl het verticale plaatsen wordt gedelegeerd aan een deterministische executor, waardoor verticale coördinaatfouten effectief worden geëlimineerd.
Peephole Prompt-optimalisatie: Een methodologie voor het identificeren van systematische LLM-faalmodes die worden getriggerd door specifieke invoerpatronen en het corrigeren daarvan via dynamische prompt-injectie, analoog aan compiler-optimalisatie.
Empirische Validatie: Aantonen dat deze pipeline een kleiner, kosteneffectief model (GPT-4o-mini) in staat stelt om een groter, duurder model (GPT-4o) te overtreffen in structurele nauwkeurigheid.
Besluitvormings-theoretisch Kader: Een formele aanpak voor het afhandelen van onderspecificeerde instructies (ontbrekende kleuren of aantallen) door de waarschijnlijkheid van een correcte gok af te wegen tegen de straf voor het stellen van een verduidelijkende vraag.

Experimentele Resultaten

Het systeem is geëvalueerd op de Build What I Mean (BWIM)-benchmark, bestaande uit 160 rondes van blokconstructietaken.

Nauwkeurigheid: De volledige pipeline met GPT-4o-mini bereikte een gemiddelde structurele nauwkeurigheid van 94,6% over 12 onafhankelijke runs.
Vergelijking: Dit resultaat presteert beter dan het beste concurrerende systeem (met GPT-4o zonder decompositie) op 76,3% en de directe GPT-4o-baseline op 90,3%.
Ablatiestudie: Het verwijderen van de 2.5-D-decompositie veroorzaakte de grootste prestatiedaling, met een vermindering van de nauwkeurigheid met 50,7 procentpunten (naar 43,8%), wat bevestigt dat het de dominante bijdrage aan succes is. Behandeling van onderspecificatie en peephole-optimalisatie droegen ook significant bij (respectievelijk 17,9 pp en 11,3 pp).
Edge-implementatie: De pipeline werd succesvol overgebracht naar lokale edge-hardware. Nemotron-3 120B, lokaal draaiend op een NVIDIA Jetson Thor AGX, bereikte 94,5% nauwkeurigheid zonder prompt-aanpassingen, wat overeenkomt met de cloud-gebaseerde GPT-4o-mini-resultaten.
Generalisatie: Een transferexperiment op 500 taken uit de IGLU-samenwerkingsbouwdataset toonde aan dat de 2.5-D-decompositie alleen de F1-scores op blokniveau verbeterde van 0,723 naar 0,798, wat de toepasbaarheid van de aanpak buiten de primaire benchmark bevestigt.

Betekenis en Beweringen

Het artikel betoogt dat de primaire beperking in LLM-gebaseerde ruimtelijke constructie niet een gebrek aan redeneervermogen is, maar de opname van deterministische dimensies in de uitvoerruimte van het model. Door dimensies te identificeren die berekenbaar zijn vanuit fysieke beperkingen (zoals zwaartekracht) en deze uit de verantwoordelijkheid van de LLM te halen, bereikt het systeem een betrouwbaarheid die vergelijkbaar is met het theoretische plafond dat wordt opgelegd door de kwaliteit van de verduidelijkingsagent (de "architect").

De auteurs beweren dat deze 2.5-D-structuur een generaliseerbaar principe is voor elk autonoom systeem waarbij fysieke wetten de assemblage of plaatsing beperken. Citerende voorbeelden zijn padplanning voor UAV's die het terrein volgen (waarbij hoogte een functie is van horizontale positie en terreingegevens) en automatisch onderhoud van apparatuur (waarbij paden voor het invoegen van onderdelen worden beperkt door machinegeometrie). Het werk suggereert dat betrouwbare, door LLM's geleide operaties in fysiek beperkte omgevingen haalbaar zijn, niet door het trainen van grotere modellen, maar door systemen te architecten die deterministisch redeneren uitbesteden aan symbolische code.

De auteurs merken een harde bovengrens op voor de bereikbare nauwkeurigheid: ongeveer 97,6%, begrensd door fouten in de architect-agent (een LLM die verduidelijkende vragen beantwoordt). De huidige nauwkeurigheid van het systeem van 94,6% laat slechts een marge van 3,0 procentpunten over voor verbeteringen aan de bouwerskant, wat aangeeft dat de voorgestelde pipeline het potentieel van de bouwercomponent bijna heeft gemaximaliseerd.