inferwire
/
AI·4 min read

GPU Method Adds Formal Error Bounds to Real-Time Robot Control

Georgia Tech researchers compute tight, differentiable linearization error bounds on the GPU, so a robust controller keeps formal guarantees at up to 67 Hz on systems with 168 states.

TL;DR

  • Georgia Tech researchers compute tight, differentiable bounds on linearization error on the GPU and solve robust control problems with them at up to 67 Hz [^1].
  • Real-time solvers often skip this error and lose their guarantees; on a learned model, trajectories planned that way left their safety tubes [^1].

Background

Robots, drones and spacecraft need controllers that respect constraints even under worst-case disturbances [^1]. Robust planners usually approximate nonlinear dynamics with a linear time-varying (LTV) model along the planned trajectory, because exact reachability through nonlinear dynamics is generally intractable in real time [^1]. The guarantee then holds only if the controller bounds how far the real dynamics can deviate from that approximation, the linearization error. Many real-time solvers skip that bound [^1].

What happened

Jeffrey Fang, Keyi Shen, Anutam Srinivasan and Glen Chou of the Georgia Institute of Technology present a family of linearization error bounds that are tight, differentiable and computed in parallel on the GPU [^1]. For dynamics given by analytic equations, they introduce path-based Hessian bounds, which in their tests were tighter than standard interval methods and ran in under 1 ms [^1]. For dynamics learned by a neural network, they derive certified bounds from affine relaxations produced by a neural network verifier, plus local Jacobian corrections [^1]. The bounds are implemented in JAX, which makes them differentiable, so the optimizer can steer the planned trajectory toward regions with less error [^1].

The bounds feed a solver the authors call GPUSLS-LEO. It builds on GPUSLS, an earlier GPU solver for system-level synthesis by Fang and Chou, and extends it to right-invertible disturbance matrices and to disturbance sets that are not centered on zero [^1]. Its output includes reachable tubes, regions around the planned path that, by the paper's theorem, contain everything the closed-loop system can reach [^1]. On systems with up to 168 state dimensions, the solver computed robust control policies at up to 67 Hz, with solve times as low as 15 ms [^1]. Runtime tests used an Nvidia RTX 4090, while the multi-quadrotor and long-horizon experiments needed an Nvidia H200 [^1].

On a 7-dimensional satellite attitude task, the tubes were on average 20 percent smaller than those of NL-SLS, which relies on a global Hessian bound, and only 4 percent wider than GPUSLS without any linearization error [^1]. On a 6-dimensional planar quadrotor in an obstacle field, the tube area was 91 percent smaller than with control contraction metrics, which allowed a more direct path [^1]. In a system of 14 coupled 3D quadrotors with 168 states, all rollouts stayed inside the tubes [^1]. The clearest case for the bounds is a T-pusher whose dynamics come from a trained neural network. There, the tubes were on average 99 percent larger than those of GPUSLS, but they contained every rollout, while trajectories from GPUSLS fell out of their tubes [^1].

Why it matters

The paper targets a trade-off the authors say practitioners often make: omitting linearization error to stay fast, which yields reachable tubes that are heuristic rather than guaranteed [^1]. The T-pusher result shows both sides. Ignoring the error gives smaller tubes that the system doesn't actually stay in; accounting for it makes the tubes larger but keeps the guarantee [^1]. Because the bounds are computed locally around one trajectory instead of over the whole state space, they avoid much of the conservatism of global methods, which in the satellite and quadrotor tests showed up as wider tubes and a longer route [^1].

The guarantee has limits. For the learned model, the authors write that they don't formally account for learning error, the gap between the neural network and the real system [^1]. The bound covers the learned model, not reality. The pusher's closed-loop test ran on simulated contact dynamics, and the path-based Hessian bounds slow down in higher dimensions because Hessian computations get more expensive [^1]. Next, the authors want to extend the bounds to contact-rich planning and to output-feedback control [^1].

Practical example

Say you build a drone that carries packages through a courtyard full of obstacles, and its motion model is a neural network trained on flight data. A planner that ignores linearization error can draw a neat safety margin around the route that the drone may still leave, as the GPUSLS trajectories did on the neural T-pusher [^1]. With bounds like these, the margin widens to cover the error, and the error penalty nudges the planner toward a route where the approximation holds better [^1]. You would still need to test how well the network matches the real drone, because the paper's guarantee does not cover that learning error [^1].

Sources

  1. [1]arXiv — GPU-Parallel Linearization Error Bounds for Real-Time Robust Optimal Control of Nonlinear and Neural Network Dynamics