L4acados: Learning-based models for acados, applied to Gaussian process-based predictive control

Dit paper introduceert L4acados, een framework dat het integreren van leer-gebaseerde modellen, zoals Gaussian processes en neurale netwerken, in de real-time optimal control software acados mogelijk maakt, wat leidt tot aanzienlijke snelheidswinst en succesvolle toepassing op autonome voertuigen.

De kern

De Kern: Een Slimme Vertaler voor Robot-hersenen

Stel je voor dat je een zeer slimme, maar soms onvoorspelbare robot wilt leren om een raceauto te besturen. Je hebt twee soorten "hersenen" nodig:

1. De Fysica-hersenen: Deze weten hoe een auto werkt volgens de natuurwetten (zwaartekracht, wrijving, snelheid). Dit is de basis, het "oude boek" over auto's.
2. De Leer-hersenen: Deze zijn getraind met data (zoals een neural network of een "Gaussian Process"). Ze leren de foutjes van de fysica-hersenen. Bijvoorbeeld: "Oh, deze specifieke auto heeft een lekke band of de weg is glad, dus hij glijdt meer dan de theorie zegt."

Het probleem is dat deze twee hersenen niet goed met elkaar kunnen praten. De software die de auto bestuurt (genaamd acados) spreekt een strenge, wiskundige taal. De "Leer-hersenen" (vaak gemaakt in Python met tools zoals PyTorch) spreken een andere, flexibele taal. Zeer vaak moet je de "Leer-hersenen" volledig herschrijven in de strenge taal van de besturingssoftware, wat veel tijd kost en foutgevoelig is.

L4acados is de oplossing. Het is een tolk of een brug. Het stelt de "Leer-hersenen" in staat om direct met de besturingssoftware te praten, zonder dat je ze hoeft te herschrijven.

---

Hoe werkt het? De Analogie van de Chef-kok

Stel je voor dat acados een super-snelle chef-kok is die elke seconde een nieuw menu (een route) moet bedenken voor een raceauto.

• De chef gebruikt een receptboek (het fysieke model).
• Maar soms is het weer veranderd of is de auto anders, dus het receptboek klopt niet helemaal.
• De chef vraagt een assistent (het leer-model) om tips: "Hoeveel moet ik het gaspedaal iets minder indrukken omdat het regent?"

Het oude probleem:
De assistent was een "zwarte doos". De chef kon de assistent niet direct vragen om de exacte hoeveelheid gas die nodig is, noch hoe die hoeveelheid verandert als je iets harder remt. De chef moest de assistent eerst vertalen naar een eigen taal, wat veel tijd kostte. Soms was de assistent te traag, waardoor de chef te laat was met het menu en de auto een bocht miste.

De oplossing met L4acados:
L4acados is een snelle, gespecialiseerde tolk.

1. De chef (acados) vraagt de assistent (het leer-model) om zijn berekeningen.
2. De tolk pakt deze berekeningen, doet ze in een pakketje (in het Engels: batching), en stuurt ze allemaal tegelijk naar de assistent.
3. De assistent doet dit in één keer, heel snel (vaak op een krachtige computerchip, een GPU), en stuurt het antwoord terug.
4. De chef kan nu direct zijn menu aanpassen.

Dit betekent dat de chef veel sneller kan beslissen, zelfs als de assistent heel complex is.

---

Wat is er nieuw en waarom is het belangrijk?

De auteurs van dit artikel hebben twee grote dingen gedaan:

1. De Tolk bouwen (L4acados)
Ze hebben een software-tool gemaakt die het mogelijk maakt om elke moderne "Leer-model" (geschreven in Python) te koppelen aan de besturingssoftware.

• Voorbeeld: Je kunt een model gebruiken dat is getraind om de grip van banden op een nat wegdek te voorspellen, en dit direct gebruiken om de auto te besturen, zonder dat je de code van het model hoeft te veranderen.

2. Het testen met "Gaussian Processes" (De Voorspeller)
Ze hebben een specifiek type leer-model gebruikt genaamd een Gaussian Process.

• Analogie: Stel je voor dat je een voorspelling doet over de weersomstandigheden. Een normaal model zegt: "Het gaat regenen." Een Gaussian Process zegt: "Het gaat regenen, en ik ben 95% zeker, maar er is een kleine kans dat het juist zonnig is."
• In de auto-besturing is die "onzekerheid" cruciaal. Als het model zegt: "Ik ben niet zeker of de weg glad is," dan zal de auto voorzichtig rijden. Als het model zegt: "Ik weet zeker dat de weg droog is," dan kan de auto agressiever racen.

De Resultaten: Van Simulatie tot Echtheid

De auteurs hebben dit getest in twee scenario's:

1. Miniatureracing (De speelgoedauto):
   Ze lieten een klein modelautootje racen.

   • Zonder het leer-model: De auto rijdt voorzichtig en langzaam, omdat hij bang is om uit te glijden (hij vertrouwt alleen het oude receptboek).
   • Met L4acados en het leer-model: De auto "leert" dat hij op dit specifieke circuit meer grip heeft dan verwacht. Hij durft sneller te rijden, neemt scherper de bochten en wordt sneller, terwijl hij veilig blijft.
   • Resultaat: De auto werd sneller en rijdt slimmer.

2. Echte Auto (De grote auto):
   Ze testten het op een volledige, echte auto voor een "ISO-baanwissel" (een test waarbij je snel van baan wisselt, zoals op een snelweg).

   • De standaard controller (alleen fysica) gaf een oncomfortabele, schokkerige rit.
   • De controller met L4acados en het leer-model gaf een soepele, veilige rit en hield de auto precies op het juiste spoor, zelfs als de weg niet perfect was.

Samenvatting in één zin

L4acados is een slimme software-brug die het mogelijk maakt om moderne, leermogelijke kunstmatige intelligentie (zoals neurale netwerken) direct en supersnel te gebruiken om robots en auto's te besturen, zodat ze sneller, veiliger en slimmer kunnen reageren op de echte wereld dan ooit tevoren.

Technische samenvatting

Probleemstelling

Het integreren van leermodellen (zoals kunstmatige neurale netwerken of Gaussische processen) in Model Predictive Control (MPC) strategieën kan de prestaties en aanpassingsvermogen voor real-world toepassingen aanzienlijk verbeteren. Echter, het implementeren van deze modellen in real-time optimalisatie-software is complex.

• De uitdaging: Bestaande frameworks vereisen vaak dat leermodellen handmatig worden herschreven in CasADi (een tool voor symbolische differentiatie) of dat er lokale benaderingen worden gebruikt. Dit beperkt de beschikbaarheid van geavanceerde methoden, vermindert de rekenefficiëntie en maakt parallelisatie moeilijk.
• Specifiek voor Gaussische Processen (GP): Het oplossen van GP-MPC problemen is computationally zwaar vanwege de propagatie van onzekerheid (covariantie) binnen het optimalisatieprobleem. Bestaande open-source oplossingen zijn vaak te specifiek voor één use-case en schalen niet goed.

Methodologie

De auteurs introduceren L4acados, een algemeen framework dat externe sensitiviteiten (afgeleiden) van Python-gebaseerde dynamische modellen integreert in de real-time optimalisatie-software acados.

1. Externe Sensitiviteiten via SQP:

   • In plaats van het volledige dynamische model in de solver te coderen, wordt het niet-lineaire optimalisatieprobleem (OCP) herschreven als een lineair probleem met parameters.
   • De sensitiviteiten (Jacobianen) van het leermodel worden extern berekend in Python en vervolgens als parameters aan de SQP (Sequential Quadratic Programming) solver van acados doorgegeven in elke iteratie.
   • Dit maakt het mogelijk om willekeurige Python-modellen (PyTorch, TensorFlow, JAX) of black-box simulatoren te gebruiken zonder ze in CasADi te vertalen.

2. Parallelisatie en Batch-verwerking:

   • L4acados maakt gebruik van batch-verwerking: sensitiviteiten voor de hele voorspellingshorizon worden in één keer berekend in plaats van stap-voor-stap.
   • Dit maximaliseert de efficiëntie op GPU's en CPU's, wat essentieel is voor complexe modellen en lange horizons.

3. Real-Time Iteration (RTI):

   • Het framework ondersteunt de RTI-strategie, waarbij de voorbereidingsfase (sensitiviteitsberekening) en de feedbackfase (QP oplossen) gescheiden zijn. Dit minimaliseert de latentie voor real-time besturing.

4. Zero-Order GP-MPC (zoGPMPC):

   • Voor Gaussische Processen wordt een efficiënt algoritme geïmplementeerd dat de "Zero-Order Robust Optimization" (zoRO) methode gebruikt.
   • In plaats van de covariantie-afgeleiden in elke SQP-iteratie te berekenen (wat zeer duur is), worden de covarianties en de daaruit voortvloeiende veiligheidsmarges (constraint tightenings) vastgehouden op basis van de vorige iteratie. Dit levert een suboptimale maar haalbare oplossing op met drastisch lagere rekentijd.

Belangrijkste Bijdragen

1. L4acados Framework: Een open-source module die Python-callable residual dynamics modellen integreert in acados, ondersteunend voor parallelle sensitiviteitsberekening en diverse machine learning frameworks.
2. Efficiënte GP-MPC Implementatie: Een modulaire implementatie van een real-time GP-MPC controller die willekeurige GPyTorch-modellen ondersteunt, inclusief online leermogelijkheden en efficiënte covariantie-propagatie.
3. Benchmarking: Een uitgebreide vergelijking met bestaande methoden (L4CasADi en CasADi), die aantoont dat L4acados superieure schaalbaarheid en snelheid biedt, vooral bij langere voorspellingshorizons en complexere modellen.
4. Hardware Validatie: Succesvolle toepassing op twee verschillende autonome voertuigplatforms:
   • Een 1:24 schaal raceauto (CRS platform).
   • Een volledig groot autonoom voertuig voor een ISO-baanwisselmanoeuvre.

Resultaten

• Benchmarks (Neurale Netwerken):
  • L4acados toont aanzienlijke snelheidswinsten (speed-ups) ten opzichte van L4CasADi en CasADi, vooral bij langere horizons ($N \ge 10$) en grotere modelcomplexiteit.
  • Door batch-verwerking en GPU-gebruik kunnen de rekentijden worden gereduceerd, zelfs bij complexe netwerken.
• Miniature Racing (Hardware):
  • De GP-MPC controller (zoGPMPC) met online leren en onzekerheidsbewuste voorspellingen slaagt erin om agressiever en sneller te racen dan een controller op basis van een puur nominaal model, zonder de baanlimieten te overtreden.
  • De controller is real-time haalbaar (rekentijd < 33ms voor de meeste iteraties) op een standaard laptop.
• Full-Scale Autonomous Driving:
  • Toegepast op een testvoertuig voor een ISO-baanwissel bij 30 km/h.
  • De GP-MPC controller leverde aanzienlijk betere prestaties op dan de nominale MPC: minder actuatorenbelasting, comfortabeler rijden en stabielere baanvolging.
  • De totale rekentijd bleef consistent onder de 20ms (controlecyclus), wat de real-time haalbaarheid voor zware voertuigen bewijst.

Betekenis en Conclusie

Dit werk overbrugt de kloof tussen geavanceerde machine learning frameworks en real-time optimalisatie-software. Door L4acados te introduceren, maken de auteurs het mogelijk om complexe, leerbare dynamische modellen (zoals GP's en neurale netwerken) efficiënt en veilig in MPC-controllers te integreren zonder de prestaties van de solver te offeren.

De succesvolle toepassing op zowel miniature als full-scale autonome voertuigen demonstreert dat leer-gestuurde besturing niet langer beperkt is tot simulatie, maar operationeel veilig en real-time haalbaar is in de echte wereld. Dit opent de deur voor robuustere en adaptieve besturingssystemen in complexe omgevingen zoals autonoom rijden en robotica.