⚡ electrical engineering

Real-Time Online Learning for Model Predictive Control using a Spatio-Temporal Gaussian Process Approximation

This paper introduces an efficient, constant-complexity spatio-temporal Gaussian Process approximation for online learning within Model Predictive Control, enabling real-time adaptation to time-varying dynamics and improved performance in applications like autonomous racing.

Original authors: Lars Bartels, Amon Lahr, Andrea Carron, Melanie N. Zeilinger

Published 2026-03-19

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Lars Bartels, Amon Lahr, Andrea Carron, Melanie N. Zeilinger

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are teaching a robot to drive a race car around a track. You give the robot a map and a set of rules (the "nominal model") on how the car should behave. But in the real world, things change. Maybe the tires get hot, the wind picks up, or the steering wheel has a slight wobble. The robot's map doesn't know about these changes, so it starts making mistakes, drifting off course or crashing.

This paper is about giving the robot a superpower: the ability to learn from its mistakes while it is driving, in real-time, without getting overwhelmed.

Here is the breakdown of the problem and their clever solution, using some everyday analogies.

The Problem: The "Memory Overload"

The robot uses a smart learning tool called a Gaussian Process (GP). Think of a GP as a super-organized librarian. Every time the car drives, the librarian writes down exactly what happened: "At this speed, on this curve, with this wind, the car drifted left."

The Catch: As the car drives more, the librarian's notebook gets huge.
The Bottleneck: To make a prediction for the next turn, the librarian has to read every single page of the notebook to find patterns.
The Result: If the car is driving fast (like in a race), the librarian gets so busy reading old notes that they can't answer the driver's question in time. The car crashes because the brain is too slow.

Usually, to fix this, engineers tell the librarian to throw away old notes and only keep the last 400 pages. This keeps the brain fast, but it's like trying to learn a new language by only reading the last 400 words you ever spoke. You miss the big picture and forget how things used to be.

The Solution: The "Smart Time-Traveling Map"

The authors (Lars Bartels and his team) built a new kind of librarian that doesn't need to read the whole book. They created a Spatio-Temporal Gaussian Process.

Let's break down that fancy name with an analogy:

Spatio (Space): Imagine the race track is a giant grid. Instead of remembering every single inch of the track, the librarian only remembers a few "Key Checkpoints" (called inducing points) scattered across the track.
Temporal (Time): This is the magic part. The librarian realizes that what happens now is closely related to what happened a second ago. Instead of treating every moment as a brand new, unrelated event, they use a mathematical shortcut (like a state-space model) to predict how the "Key Checkpoints" evolve over time.

The Analogy: The Weather Forecaster

Old Way (Standard GP): To predict the weather tomorrow, you look at every single temperature reading from the last 10 years. It takes forever, and you eventually run out of computer memory.
The New Way (This Paper): You realize that weather moves in patterns. If it's raining now, it's likely to rain in 10 minutes. You don't need to re-read the history books; you just update your current "weather model" based on the last few minutes. You can do this instantly, no matter how long you've been watching the weather.

How It Works in the Race Car

In their experiments, they put a tiny race car on a track and introduced a "glitch": they secretly changed the steering sensitivity while the car was driving.

The Old Robot (No Learning): The car kept trying to drive based on the old map. When the steering glitch happened, the car started swerving wildly and almost crashed.
The "Throwaway" Robot (Standard Online Learning): The robot learned quickly but had to delete old data to stay fast. It did okay, but it struggled when the glitch changed in complex ways because it forgot the earlier patterns.
The New Robot (This Paper's Method):
- Constant Speed: No matter how long the race went or how much data it collected, the robot's brain stayed the same size. It didn't get slower.
- Perfect Memory: It kept every single piece of data without getting overwhelmed.
- Adaptation: As soon as the steering glitch started, the robot updated its "Key Checkpoints" instantly. It realized, "Hey, the steering is acting weird now," and adjusted its driving line perfectly.

The Result

The car using this new method was able to race at high speeds, stay perfectly on the track, and handle the changing conditions without crashing. It was faster and more stable than the other robots.

Why This Matters

This isn't just about race cars. This technology is a breakthrough for any machine that needs to learn while it works:

Self-driving cars dealing with changing road conditions.
Robots in factories that need to adapt to new tools.
Drones flying in windy, unpredictable environments.

In short: The authors figured out how to give a robot a brain that gets smarter the more it learns, without ever getting "slow" or needing to forget the past. They turned a memory-heavy, slow process into a lightweight, real-time superpower.

1. Problem Statement

Context: Model Predictive Control (MPC) is a powerful strategy for complex systems but relies heavily on the accuracy of the underlying dynamic model. In real-world applications, models often suffer from inaccuracies (mismatches) due to unmodeled dynamics or time-varying disturbances.
The Challenge:

Learning-Based MPC (GP-MPC): Gaussian Processes (GPs) are ideal for modeling these residual dynamics because they offer data-efficient adaptation and formal uncertainty quantification.
Computational Bottleneck: Exact GP inference scales cubically ( $O(N^3)$ ) with the number of data points $N$ . In online learning scenarios where data accumulates continuously, this leads to computational latencies that violate real-time constraints (e.g., >30ms for high-speed control).
Limitations of Existing Approximations:
- Subset of Data (SoD): Discards old data to keep $N$ fixed. This fails for time-varying systems where historical data remains relevant, or where the system revisits spatial locations after a long time.
- Inducing Points (Spatial only): Summarize data spatially but often struggle with time-varying dynamics unless the inducing points are re-trained or moved, which adds computational overhead.
- Spatio-Temporal GPs: Existing methods often restrict inputs to discrete time or non-continuous spatial domains, making them unsuitable for dynamic systems with continuous state spaces.

2. Methodology

The authors propose an Approximate Spatio-Temporal Gaussian Process model tailored for real-time GP-MPC. The core innovation is combining spatial inducing points with a Markovian temporal structure to achieve constant computational complexity per time step, regardless of the total amount of data collected.

A. Mathematical Formulation

System Dynamics: The system is modeled as $x(k+1) = f(x, u) + Bg(x, u, t) + w$, where $g$ is the unknown residual dynamics modeled as a GP.
Spatio-Temporal Kernel: The GP kernel is separable: $k((z, t), (z', t')) = k_s(z, z') k_t(t - t')$ $k ((z, t), (z^{'}, t^{'})) = k_{s} (z, z^{'}) k_{t} (t - t^{'})$ .
- Spatial Component ( $k_s$ ): Approximated using a fixed set of $M$ inducing points ( $V$ ) in the spatial input space.
- Temporal Component ( $k_t$ ): Modeled using a state-space representation derived from the Fourier transform of the kernel (specifically half-integer Matérn kernels). This converts the temporal GP into a linear Gaussian state-space model driven by a stochastic differential equation.
Recursive Estimation: By combining the spatial inducing point formulation with the temporal state-space model, the joint distribution of inducing points evolves over time according to a linear Gaussian transition. This allows the use of Kalman Filtering for recursive updates.

B. Algorithmic Implementation

The approach utilizes three main procedures:

Initialization: Computes state-space matrices ( $F, G, H$ ) for the temporal kernel and caches invariant terms (e.g., $K_{VV}$ , transition matrices) to avoid redundant calculations.
Update (Online Learning):
- Prediction: Propagates the mean and covariance of the inducing points to the next time step using the state transition model.
- Correction: Incorporates new measurements using a Kalman update step.
- Numerical Stability: Uses a square-root Kalman filter (Cholesky decomposition) to ensure the covariance matrix remains positive semi-definite, preventing numerical drift.
Evaluation: Computes the predictive mean and variance for new spatial inputs at the current time step using the updated inducing point distribution.

C. Integration with MPC

The GP model is integrated into a Zero-Order SQP (Sequential Quadratic Programming) MPC framework (specifically within the L4acados framework).
Zero-Order Approximation: To further reduce computational load, the algorithm neglects gradients of the covariance propagation and constraint tightenings during optimization. This allows the covariance terms to be pre-computed based on the previous iterate, reducing the optimization variables to just the mean state and control inputs.
Real-Time Iteration (RTI): The solver performs a single SQP step per time step, ensuring the total cycle time remains within the control frequency (30 Hz).

3. Key Contributions

Constant Complexity Online Learning: The proposed method enables learning from an arbitrary number of data points with constant computational cost per update. Unlike SoD methods, it does not discard data, preserving "life-long" learning capabilities.
Continuous Spatio-Temporal Modeling: Unlike previous spatio-temporal GP-MPC works, this method operates over a continuous spatial input space while handling time-varying dynamics via Markovian temporal structures.
Open-Source Implementation: The authors provide a Python implementation compatible with GPyTorch and integrated into the L4acados MPC framework, making the approach accessible for research and deployment.
Numerical Robustness: The use of square-root filtering ensures stability during long-term recursive updates, a common failure point in recursive GP methods.

4. Experimental Results

The method was validated using autonomous miniature racing (CRS platform) under a time-varying steering perturbation (simulated by dynamically altering the neutral steering offset $\delta_0$ ).

Computational Performance:
- Exact GP (SoD): Solved in <30ms only by discarding all but the 400 most recent data points.
- Proposed Spatio-Temporal GP: Maintained a constant solve time (~7-10ms for GP parts) regardless of data accumulation. It successfully ran indefinitely without data truncation.
Predictive Accuracy:
- The proposed model significantly reduced the one-step prediction error for lateral and angular velocities compared to the nominal model.
- It outperformed purely spatial inducing-point GPs, which failed to distinguish between different disturbance states at the same spatial coordinates due to the lack of temporal memory.
Control Performance:
- Nominal MPC: Failed to maintain the racing line once the perturbation started, leading to safety margin violations.
- GP-MPC (Proposed): Successfully adapted to the time-varying disturbance in real-time, maintaining consistent lap times and stable trajectories comparable to the pre-perturbation performance.
- Comparison: The proposed method performed similarly to an exact GP with a 400-point buffer, but with the theoretical advantage of not discarding data, which is crucial for scenarios where data accumulation is slow relative to system changes.

5. Significance and Conclusion

This work bridges the gap between the theoretical benefits of Gaussian Processes (uncertainty quantification, data efficiency) and the practical constraints of real-time control.

Impact: It enables true online learning for MPC, allowing controllers to adapt to slow drifts or long-term changes in system dynamics without the computational penalty of growing data sets.
Future Work: The authors suggest extending the method to online hyperparameter tuning and establishing theoretical closed-loop stability guarantees.

In summary, the paper presents a computationally efficient, numerically stable, and theoretically sound framework for learning-based control, demonstrated effectively in a high-speed, safety-critical autonomous racing application.