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

1. Problem Statement

Model Predictive Control (MPC) is a powerful control strategy for nonlinear systems, but its performance is heavily dependent on the accuracy of the underlying system dynamics model. While physics-based models are standard, they often fail to capture complex, unmodeled dynamics in real-world applications (e.g., tire friction variations, aerodynamic effects).

• The Gap: Incorporating learning-based models (such as Neural Networks or Gaussian Processes) to correct these residuals improves prediction accuracy. However, integrating these models into real-time MPC solvers is challenging.
• The Bottleneck: State-of-the-art optimal control software (like acados) relies on automatic differentiation (via CasADi) to compute sensitivities (Jacobians and Hessians). Most modern machine learning frameworks (PyTorch, GPyTorch) are not natively compatible with CasADi's computational graph. Existing workarounds involve re-implementing models in CasADi (losing state-of-the-art ML features) or using approximate methods that sacrifice accuracy or computational efficiency.
• Specific Challenge for GP-MPC: Gaussian Process (GP) based MPC requires propagating state uncertainty (covariance) to ensure safety. This creates a complex optimization problem that is often computationally intractable for real-time applications, leading to heuristic approximations that ignore the coupling between control inputs and uncertainty.

2. Methodology

The authors propose L4acados, a general framework that bridges the gap between Python-based learning models and the real-time optimal control software acados.

A. Core Concept: External Sensitivities via SQP

Instead of forcing the learning model into the CasADi graph, L4acados modifies the Sequential Quadratic Programming (SQP) solver workflow:

1. Linearization Strategy: In each SQP iteration, the solver does not need the full symbolic dynamics, only the evaluations of the dynamics and their sensitivities (Jacobian matrices) at the current iterate.
2. Parameterization: The authors reformulate the nonlinear optimal control problem (OCP) as an OCP with affine dynamics where the linearization matrices ($\hat{A}_k, \hat{B}_k, \hat{c}_k$) are treated as model parameters.
3. External Interface: At every SQP iteration, L4acados pauses the solver, calls a user-defined Python module to compute the residual model $g(x,u)$ and its derivatives ($\partial g/\partial x, \partial g/\partial u$), and injects these values back into the solver as parameters.
4. Parallelization: The framework batches these computations across the prediction horizon. This allows for efficient parallel processing (e.g., on GPUs) of the sensitivity evaluations, significantly reducing latency for long horizons.

B. Zero-Order GP-MPC (zoGPMPC)

To address the computational complexity of GP-MPC, the paper implements a Zero-Order Robust Optimization (zoRO) algorithm:

• Decoupling: The algorithm separates the propagation of state covariances from the optimization loop. Covariances are propagated based on the previous SQP iterate (fixed Jacobians of the constraints).
• Feasibility: This reduces the problem to a standard SQP iteration where constraint tightenings are fixed, yielding a suboptimal but feasible solution at drastically reduced computational cost.
• Modular Implementation: The GP model (using GPyTorch) is wrapped as a ResidualModel within L4acados, handling posterior mean, covariance, and Jacobian calculations efficiently.

3. Key Contributions

1. L4acados Framework: A software library enabling the use of arbitrary Python-callable dynamics models (PyTorch, TensorFlow, JAX, black-box simulators) in acados without re-implementing them in CasADi.
2. Efficient Sensitivity Computation: Introduction of batched sensitivity evaluation, enabling massive speed-ups for parallelizable models (like Neural Networks) compared to traditional CasADi integration.
3. Modular GP-MPC Implementation: A complete, open-source implementation of zoGPMPC that supports:
   • Arbitrary GPyTorch GP models.
   • Online learning (updating the GP model with new data in real-time).
   • Efficient covariance propagation using the BLASFEO linear algebra library.
4. Hardware Validation: Successful deployment on two distinct hardware platforms:
   • A 1:24 scale autonomous racing car.
   • A full-scale autonomous vehicle performing ISO lane-change maneuvers.

4. Results

A. Benchmarking (Neural Network MPC)

• Setup: Compared L4acados against L4CasADi (JIT-compiled PyTorch into CasADi) and standard CasADi on a double-integrator system with varying Neural Network (NN) depths and widths.
• Performance:
  • L4acados achieved significant speed-ups (up to 10x or more) for prediction horizons $N \geq 10$ and complex models.
  • It outperformed L4CasADi, particularly when utilizing GPU acceleration and batched processing.
  • For very short horizons ($N < 10$), L4CasADi was slightly faster due to JIT compilation overheads in L4acados, but L4acados scales much better with model complexity.

B. Autonomous Miniature Racing (Simulation & Hardware)

• Scenario: Racing a 1:24 scale car on a track with uncertain tire friction.
• Findings:
  • Nominal Model: Without learning, the car crashed or drove conservatively due to model mismatch.
  • GP-MPC (zoGPMPC): Successfully learned the residual dynamics.
  • Online Learning: The system adapted to new data in real-time.
  • Performance: The GP-MPC controller drove faster (more laps in fixed time) and safer (respecting track boundaries with uncertainty-aware constraints) than the nominal model.
  • Real-Time Feasibility: Computation times remained well within the 33ms sampling interval, even with online model updates.

C. Full-Scale Autonomous Vehicle

• Scenario: ISO lane-change maneuver at 30 km/h.
• Findings:
  • The nominal MPC controller exhibited poor tracking and high actuator stress.
  • The zoGPMPC controller, using L4acados, significantly improved path tracking and comfort.
  • Computation Time: Total solve time was 8.2 ms (mean) on a standard laptop, well within the 20ms control cycle, proving feasibility for full-scale vehicles.

5. Significance

• Bridging the Gap: L4acados solves the critical interoperability issue between modern Machine Learning frameworks and real-time control software, allowing researchers to use state-of-the-art models without sacrificing real-time performance.
• Scalability: By leveraging batched computations and external sensitivity injection, it enables the use of complex, high-dimensional learning models in MPC, which was previously computationally prohibitive.
• Safety & Adaptability: The successful application of zoGPMPC demonstrates that uncertainty-aware control can be implemented efficiently in real-time, enabling safer and more adaptive autonomous systems (from small robots to full-scale cars).
• Open Source: The release of the code and hardware data promotes reproducibility and accelerates research in learning-based control.

In conclusion, this work provides a robust, efficient, and modular pathway for deploying learning-based predictive control in safety-critical, real-time applications.