Technische Samenvatting: ASSCG – Just-Right Gating voor Fast–Slow LLM Planning in Autonoom Rijden

1. Probleemstelling

Large Language Models (LLMs) en Vision-Language Models (VLMs) bieden aanzienlijk potentieel voor planning in autonoom rijden door het te bieden van common-sense redeneren en contextbewuste begeleiding. Echter, hun hoge inferentielatentie en computationele kosten verhinderen implementatie per frame in real-time systemen. De gangbare oplossing is het fast–slow (dual-system) paradigma, waarbij een lichtgewicht, real-time "fast" planner elke frame opereert, terwijl een zwaar "slow" LLM-module op een lagere frequentie hoogwaardige begeleiding biedt.

Huidige coördinatiestrategieën voor het triggeren van de slow-module lijden onder twee belangrijke beperkingen:

1. Fixed-interval triggering: Stelt queries aan het slow systeem op een constante snelheid (bijv. elke $K$ frames). Dit negeert temporele variabiliteit, wat leidt tot redundante queries in eenvoudige scenario's (verspilling van rekenkracht) en gemiste kansen in complexe scenario's.
2. Heuristic difficulty-based triggering: Vertrouwt op proxies zoals "scènecomplexiteit" of onzekerheidsschattingen. Deze proxies falen vaak in het afstemmen op de werkelijke marginale bruikbaarheid van het aanroepen van de slow module, wat leidt tot onnodige oscillaties of verkeerd getimede queries.

Cruciaal is dat de paper observeert dat frequentere slow reasoning niet altijd voordelig is. In bepaalde segmenten (getermd Failure Intervals) kan het aanroepen van het slow systeem de prestaties verslechteren door hallucinaties of misinterpretaties. De kernuitdaging is het formuleren van een controlebeleid dat beslist wanneer er gequeryed moet worden, wanneer bestaande begeleiding hergebruikt moet worden, en wanneer de slow module volledig onderdrukt moet worden om de closed-loop prestaties te maximaliseren onder een budget voor rekenkracht.

2. Methodologie: Adaptive Slow-System Control Gate (ASSCG)

De auteurs stellen ASSCG voor, een architectuur-agnostische controle-interface die de interactie tussen een fast planner en een slow LLM-module op frame-niveau beheert.

2.1 Conceptueel Kader

De auteurs definiëren drie operationele intervallen om de waarde van slow guidance te karakteriseren:

• Equivalent Interval (EI): Een venster waarin het opnieuw aanvragen van het slow systeem verwaarloosbare incrementele informatie oplevert. Het systeem moet de bestaande begeleiding Cachen (hergebruiken).
• Effective Interval (EfI): De duur waarin de huidige gecachte begeleiding geldig en nuttig is.
• Failure Interval (FI): Een venster waarin het aanroepen van het slow systeem de downstream prestaties verslechtert ten opzichte van het niet aanroepen ervan. Het systeem moet de begeleiding Droppen (onderdrukken).

2.2 Systeemarchitectuur

ASSCG opereert binnen een ontkoppelde fast–slow architectuur (bijv. AsyncDriver):

• Fast System: Een real-time planner (bijv. gebaseerd op GameFormer) die elke frame draait.
• Slow System: Een LLM-gebaseerde planner (bijv. LLaMA2-13B) die op aanvraag wordt aangeroepen.
• Buffer: Slaat een compacte representatie van de slow guidance op (latente features, waypoints of logits).
• ASSCG Controller: Een lichtgewicht netwerk dat voor elk frame een discrete actie $a_t \in \{0, 1, 2\}$ output:
  • Query (0): Roep het slow systeem aan, ververs de buffer en fuseer nieuwe begeleiding.
  • Cache (1): Hergebruik de gebufferde begeleiding zonder het slow systeem aan te roepen.
  • Drop (2): Negeer de buffer (vervang door een null-vector) om te voorkomen dat verouderde of schadelijke begeleiding de fast planner beïnvloedt.

2.3 Modelontwerp

• Backbone: ASSCG maakt gebruik van een RWKV-7 backbone. Deze keuze is gemotiveerd door de noodzaak voor efficiënte long-horizon temporele modellering met lineaire tijdscomplexiteit en constante geheugen per stap (na state caching), waardoor de kwadratische kosten van Transformers voor lange episodes worden vermeden.
• Inputs: De gate ontvangt:
  • Huidige scène-embedding (van een Vector Map Encoder).
  • Referentiegeheugen (de laatste slow-guidance embedding).
  • Cosine similarity tussen de huidige scène en de referentie.
  • Time feature ($\Delta t$ sinds de laatste slow query).
• Trainingspipeline:
  1. Supervised Fine-Tuning (SFT): De gate wordt geïnitialiseerd met pseudo-labels afgeleid van een grid search van fixed query-schema's. Voor elke scène wordt het schema met de hoogste closed-loop score geselecteerd, en de frame-level Query/Cache/Drop sequentie dient als label.
  2. Compute-Aware Reinforcement Fine-Tuning (RL): De gate wordt verder geoptimaliseerd met een GRPO-achtige (Group Relative Policy Optimization) algoritme. De reward functie is ontworpen om de officiële closed-loop score te maximaliseren terwijl de query-kosten worden bestraft.
     • Reward Shaping: Gebruikt potential-based shaping om dichte intermediaire feedback te geven op basis van veiligheids- en comfortmetrieken (TTC, comfort, naleving snelheidslimiet).
     • Query Cost: Een strafterm ($\lambda_{call}$) wordt toegepast op de "Query" actie om efficiëntie te stimuleren.
     • Doelstelling: Het beleid wordt getraind om de trade-off tussen planningkwaliteit en de frequentie van slow-module aanroepen te optimaliseren.

3. Belangrijkste Bijdragen

1. Analyse van Fast–Slow Samenwerking: De paper introduceert de concepten van Equivalent, Effective en Failure Intervals, en toont empirisch aan dat vaste schema's en heuristische triggers suboptimaal zijn omdat de bruikbaarheid van slow reasoning dynamisch varieert binnen een enkel episode.
2. ASSCG Architectuur: Een frame-level, discrete gating-mechanisme (Query/Cache/Drop) dat architectuur-agnostisch is en in staat is om schadelijke slow guidance opzettelijk te onderdrukken.
3. Trainingsstrategie: Een nieuw twee-fasen trainingsprotocol dat SFT combineert met compute-aware RL fine-tuning (GRPO) om direct closed-loop metrieken te optimaliseren onder expliciete query-kostenrestricties.
4. Empirische Validatie: Evaluatie op twee verschillende fast–slow instantiaties en benchmarks, wat verbeterde prestatie-efficiëntie trade-offs aantoont.

4. Experimentele Resultaten

4.1 nuPlan Hard20 (AsyncDriver-gebaseerd)

• Setup: Geëvalueerd op de nuPlan closed-loop Hard20 split met een AsyncDriver architectuur.
• Prestaties: Integratie van ASSCG verbeterde de algemene score naar 67.28 (een toename van +2.28 over de baseline AsyncDriver).
• Efficiëntie: De gemiddelde end-to-end inferentielatentie werd met ~60% verminderd vergeleken met de always-query baseline. Het gemiddelde effectieve query-interval was 5.26 frames (querying ~19% van de frames), wat overeenkomt met de latentie van een fixed 5-frame stride schema, maar met aanzienlijk hogere scores.
• Metriek-analyse: Verbeteringen werden waargenomen in veiligheidsgerelateerde metrieken (TTC, botsingsvermijding) en regelnaleving (rijbaar gebied, rijrichting), wat suggereert dat ASSCG meer stabiel en veiliger rijgedrag mogelijk maakt.

4.2 NAVSIM (RecogDrive-gebaseerd)

• Setup: Geëvalueerd op de NAVSIM benchmark met een dual system waarbij een lichtgewicht ViT-gebaseerde fast planner concurreert met een VLM-gebaseerde slow planner (InternVL-2B).
• Prestaties: Het door ASSCG aangedreven systeem bereikte een PDMS van 91.4 (een toename van +0.6 over de originele ReCogDrive).
• Efficiëntie: De gemiddelde wall-clock inferentielatentie daalde van 350 ms naar **270 ms** per scène.
• Observatie: Het systeem selecteerde de slow branch succesvol voor slechts ~40% van de scènes, wat aantoont dat het gating-mechanisme effectief identificeert wanneer de fast planner voldoende is.

4.3 Ablatie-studies

• Trainingsstrategie: Het vervangen van GRPO door PPO resulteerde in lagere scores (66.76 vs 67.28) en instabiliteit, wat het voordeel van de specifieke gebruikte RL-formulering benadrukt.
• Backbone: Het vervangen van RWKV door een Transformer met vergelijkbaar aantal parameters leverde vergelijkbare nauwkeurigheid op, maar met aanzienlijk hogere latentie (0.06s vs 0.02s voor het laatste frame in lange episodes), wat de keuze voor RWKV voor real-time toepassingen valideert.
• Drop Actie: Het verwijderen van de "Drop" actie verminderde de score van 67.28 naar 66.71, wat bevestigt dat het vermogen om slow guidance te onderdrukken cruciaal is, niet alleen het vermogen om de query-frequentie te verminderen.

5. Betekenis en Claims

De paper claimt dat ASSCG een "just-right" gating-mechanisme biedt dat de balans houdt tussen planningkwaliteit en rekenkrachtkosten. De primaire betekenis ligt in:

• Verder gaan dan statische triggers: Het aantonen dat adaptieve, frame-level beslissingen beter presteren dan vaste schema's en heuristische complexiteitsschattingen.
• Omgaan met Failure Intervals: Bewijzen dat het systeem kan leren om de slow module te negeren wanneer deze waarschijnlijk schadelijk is, een capaciteit die ontbreekt in eerdere "always-query" of "complexity-triggered" benaderingen.
• Generaliseerbaarheid: Laten zien dat het gating-principe werkt over verschillende onderliggende planner-architecturen (AsyncDriver en RecogDrive) en evaluatieprotocollen (nuPlan closed-loop en NAVSIM one-shot).

De auteurs merken bescheiden op dat hun werk evalueert wanneer een slow branch te gebruiken is gegeven bestaande systemen, in plaats van te bewijzen dat LLM reasoning noodzakelijk is voor elk scenario. Zij identificeren moeilijkere end-to-end long-tail benchmarks als een natuurlijke volgende stap.