A robust and adaptive MPC formulation for Gaussian process models

This paper presents a robust and adaptive model predictive control framework that utilizes Gaussian Processes with contraction metrics to learn uncertain nonlinear dynamics online, thereby guaranteeing recursive feasibility, robust constraint satisfaction, and convergence for systems affected by bounded disturbances and unmodeled nonlinearities.

The Gist

Imagine you are trying to teach a robot drone to fly through a complex, hilly landscape. You want it to be fast, efficient, and, most importantly, safe. It must never crash into the ground or fly too close to obstacles.

The problem is, you don't have a perfect map of the wind, the terrain, or how the drone's motors react. You have a "best guess" model, but it's incomplete. If you rely only on your guess, the drone might get scared and fly very slowly to stay safe (too conservative). If you fly too fast based on your guess, it might crash (too risky).

This paper presents a clever solution called Robust Adaptive Model Predictive Control (RAMPC) using a machine learning tool called Gaussian Processes (GP). Here is how it works, broken down into simple concepts:

1. The "Smart Guess" (Gaussian Processes)

Think of the drone's unknown behavior (like how wind pushes it or how the ground affects its lift) as a mystery function.

• The Old Way: Engineers usually try to guess the shape of this mystery with a simple formula (like a straight line). If the real world is curvy, the formula fails.
• The New Way (GP): Instead of a rigid formula, the paper uses a Gaussian Process. Imagine this as a "living, breathing map." It doesn't just guess the value; it draws a cloud of uncertainty around the guess.
  • Where the drone has flown before, the cloud is thin (high confidence).
  • Where the drone hasn't been, the cloud is thick (low confidence).
  • As the drone flies, it collects new data, and the cloud shrinks, making the map more accurate in real-time.

2. The "Safety Bubble" (Robust Prediction)

Even with a smart map, the drone can't be 100% sure where it will be in 5 seconds. So, how do we guarantee safety?

• The Analogy: Imagine the drone is walking through a dark forest. You can't see the trees perfectly, but you know they are somewhere within a certain distance.
• The Solution: Instead of planning a path for a single point (the drone), the controller plans a path for a tube (a safety bubble) around the drone.
• The Magic Trick (Contraction Metrics): Usually, as you look further into the future, your uncertainty grows like a balloon inflating until it's huge and useless. This paper uses a mathematical tool called a Contraction Metric. Think of this as a "deflator" or a "squeeze." It mathematically proves that even if the drone wobbles, the "tube" of possible future positions won't explode in size. It stays tight and manageable.

3. The "Adaptive Learner" (Online Updates)

This is the "Adaptive" part of the title.

• The Problem: If you update your map while the drone is flying, the rules of the game change. The "safety bubble" you calculated 1 second ago might not fit the new map, causing the computer to panic and say, "I can't find a safe path!" (This is called losing recursive feasibility).
• The Solution: The authors created a system that keeps a collection of maps (old and new).
  • When the drone learns something new, it doesn't just throw away the old map. It keeps the old one as a "safety net."
  • The controller then finds a path that works for all the maps in the collection simultaneously.
  • The Result: The drone can safely update its brain while flying, getting faster and more efficient as it learns, without ever breaking the safety rules.

4. The Real-World Test (The Quadrotor)

The authors tested this on a planar quadrotor (a 2D drone).

• The Challenge: The drone had to fly near a "hill" where the ground creates weird air currents (ground effects) that are very hard to model.
• The Outcome:
  • Old Method: The drone was so scared of the unknown air that it flew very slowly and took a long, winding path.
  • New Method (RAMPC): The drone started cautiously but, as it learned the wind patterns, it confidently sped up and took a direct route.
  • The Win: It reached its destination 6% faster and used 9% less energy (tracking cost) than the non-adaptive version, all while staying strictly within safety limits.

Summary

Think of this paper as giving a self-driving car a superpower:

1. It learns on the fly: It builds a better map of the road as it drives.
2. It plans with a safety net: It doesn't just plan for one future; it plans for a "bubble" of all possible futures.
3. It never panics: Even when the map changes, it has a mathematical guarantee that a safe path always exists.

This allows robots to be bold (fast and efficient) without being reckless (unsafe), making them ready for the messy, unpredictable real world.

Technical Summary

1. Problem Statement

The paper addresses the control of uncertain nonlinear continuous-time systems subject to:

• Bounded disturbances ($d(t)$).
• Unmodeled nonlinearities ($g(x)$), which are unknown functions lying in a Reproducing Kernel Hilbert Space (RKHS).
• Safety-critical constraints on states and inputs that must be satisfied with high probability ($1-p$).

The Core Challenge:
While Model Predictive Control (MPC) is powerful for constrained nonlinear systems, it typically requires an accurate model. In practice, models are imperfect. Existing Robust MPC (RMPC) approaches often rely on linearly parametrized uncertainties or simple disturbance bounds. When using Gaussian Processes (GPs) to learn complex, non-parametric dynamics online, previous methods face three major limitations:

1. Over-conservatism: Sequential propagation of uncertainty (e.g., using Lipschitz bounds or interval arithmetic) often leads to exponentially growing reachable sets, making the controller infeasible quickly.
2. Lack of Recursive Feasibility: Updating the GP model online changes the uncertainty bounds and the nominal mean prediction. This often breaks the "nestedness" required for recursive feasibility in standard tube-based MPC.
3. Computational Complexity: Some approaches require optimizing high-dimensional matrices for reachable sets, which is computationally expensive.

2. Methodology

The authors propose a Robust Adaptive MPC (GP-RAMPC) framework that integrates GP learning with contraction metrics to ensure safety and performance.

A. System Modeling & GP Learning

• The system dynamics are modeled as $\dot{x} = f(x) + B(x)u + Gg(x) + E(x)d$.
• The unknown function $g(x)$ is learned using GPs.
• Uncertainty Bounds: The framework utilizes high-probability bounds derived from GP theory (Lemma 1), ensuring that the true function lies within a tube defined by the posterior mean $\mu_N$ and a scaled standard deviation $\sigma_N$ with probability $1-p$.

B. Robust Prediction via Contraction Metrics

Instead of propagating complex reachable sets (like ellipsoids or boxes) which accumulate error, the authors use contraction metrics:

• Offline Design: A contraction metric $M(x)$ and a stabilizing feedback law $\kappa(x, z, v)$ are computed offline using Linear Matrix Inequalities (LMIs). These guarantee exponential incremental stability.
• Tube Construction: A "tube" is defined around a nominal trajectory $z(t)$ using a Riemannian distance $V_\delta(x, z)$. The tube size is scaled by a scalar variable $\delta(t)$.
• Scalar Dynamics: The evolution of the tube size $\delta(t)$ is governed by a simple scalar differential equation:
  $$\dot{\delta} = -(\rho - L_G)\delta + G_M w(z) + E_M$$
  where $w(z)$ is the GP uncertainty bound, and $\rho, G_M, E_M, L_G$ are constants derived from the contraction metric and system bounds.
• Benefit: This reduces the online optimization from high-dimensional matrix variables to a single scalar $\delta$, significantly reducing computational load and avoiding exponential growth of the tube.

C. Adaptive Mechanism (Online Learning)

To handle online model updates without losing feasibility:

• GP Collection: Instead of replacing the model, the algorithm maintains a collection of GP models ($\mathcal{M}_k$) trained on successive datasets.
• Set Intersection: The uncertainty bound is constructed by taking the intersection of confidence intervals from all models in the collection. This ensures the bound is non-increasing (monotonic) as more data is collected.
• Nominal Prediction: The nominal prediction $\bar{g}$ is a linear combination of the posterior means of the selected GP models. The weights ($\lambda$) are optimized online.
• Feasibility Guarantee: By optimizing over the linear combination of models and using the set-intersection bound, the method ensures that the new model update does not invalidate the previous feasible solution, thus guaranteeing recursive feasibility.

3. Key Contributions

1. Robust GP-MPC with Contraction Metrics: A novel formulation that uses contraction metrics to derive scalar dynamics for the uncertainty tube, avoiding the exponential conservatism of sequential propagation methods (e.g., Taylor expansion or Lipschitz bounds).
2. Recursive Feasibility with Online Updates: A theoretical framework that allows for continuous online model updates (GP-RAMPC) while guaranteeing recursive feasibility. This is achieved by optimizing over a collection of GP models and using set-intersection arguments to maintain monotonic uncertainty bounds.
3. Theoretical Guarantees: The paper provides rigorous proofs (with user-specified probability $1-p$) for:
   • Recursive Feasibility: The MPC problem remains solvable at every time step.
   • Constraint Satisfaction: State and input constraints are satisfied for all time.
   • Convergence: The system converges to a neighborhood of the reference state.
4. Computational Efficiency: The approach optimizes a scalar tube size rather than complex matrices, making it suitable for real-time implementation on nonlinear systems.

4. Numerical Results

The framework was tested on a planar quadrotor subject to difficult-to-model ground effects (an unknown vertical force dependent on altitude) and wind disturbances.

• Comparison with Existing Methods:
  • Compared to a state-of-the-art GP-RMPC using sequential ellipsoidal propagation [18], the proposed method's tube size remained bounded.
  • The existing method suffered from accumulating linearization errors, causing the tube to grow exponentially and leading to numerical divergence after ~1 second.
• Performance of GP-RAMPC:
  • Speed: The adaptive scheme reached the terminal set 6% faster than the non-adaptive GP-RMPC.
  • Cost: It reduced the closed-loop tracking cost by 9%.
  • Computation: The average computation time per iteration was ~89ms (including GP evaluation), demonstrating real-time feasibility.
  • Data Efficiency: The online learning effectively reduced uncertainty, allowing the controller to tighten constraints and improve performance as the quadrotor flew.

5. Significance

This paper bridges a critical gap between data-driven learning (GPs) and rigorous safety guarantees (Robust MPC).

• Safety-Critical Applications: It enables the use of machine learning for control in safety-critical domains (like robotics and aviation) where unmodeled dynamics are common, without sacrificing theoretical safety guarantees.
• Scalability: By decoupling the uncertainty propagation into a scalar differential equation via contraction metrics, the method overcomes the "curse of dimensionality" often associated with robust control of nonlinear systems.
• Adaptivity: It solves the long-standing problem of maintaining recursive feasibility when the underlying model is updated online, a major hurdle in adaptive control literature.

In summary, the authors present a computationally efficient, theoretically sound framework that allows nonlinear systems to learn their own dynamics online while strictly adhering to safety constraints.