This Control Algorithm Just Got 100x Faster by Turning Data Into Math It Can Ignore

A control algorithm that uses raw data instead of traditional models has long faced a critical trade-off: the more data it uses, the slower it gets. Now, a new method called Fast-DeePC flips that logic on its head—by turning the data-dependent part of the computation into something that can be solved once, offline, and then discarded. The result? A predictive controller that runs up to 100 times faster than before, without sacrificing accuracy, and whose speed no longer depends on how much data you feed it.

This isn’t just a tweak. It’s a structural breakthrough in how we use data to control complex systems—from power grids to self-driving cars—where models are hard to build but data is abundant. For the first time, a data-driven controller can scale intelligently: more data improves performance, but doesn’t cripple real-time speed.

And it works. In simulations of rocket landings, traffic flow, and chemical tanks, Fast-DeePC matches the precision of existing solvers while slashing solve times from milliseconds to microseconds. That kind of speed opens doors to applications where every millisecond counts.

The Science

Control systems are the silent choreographers of modern engineering. They decide how much fuel to inject, when to brake, how to stabilize a drone. For decades, they’ve relied on mathematical models—equations that describe how a system behaves. Model Predictive Control (MPC), one of the most powerful tools, uses these models to simulate dozens of possible futures and pick the best control action.

But what if you can’t write down the equations? Many systems—like urban power grids, biological reactors, or fleets of autonomous vehicles—are too complex, too nonlinear, or too poorly understood to model accurately. Yet they generate vast amounts of operational data. Why not use that data directly?

That’s the idea behind Data-Enabled Predictive Control (DeePC), introduced in 2018. Instead of a model, DeePC uses a Hankel matrix—a structured array built from past input-output trajectories—to represent all possible system behaviors. Thanks to Willems’ Fundamental Lemma from behavioral systems theory, this data matrix becomes a non-parametric model: any future trajectory can be expressed as a linear combination of past ones.

The catch? The algorithm must solve for a coordinate vector $g$ at every time step—a vector whose size grows with the amount of stored data. Use twice as much data, and the online optimization problem doubles in dimension. This makes DeePC accurate but slow, especially in high-data regimes.

"The irony is that more data should help," says Liang Wu, corresponding author and researcher at Johns Hopkins University. "But in standard DeePC, it directly increases computational cost. You’re punished for being data-rich."

Existing workarounds either compress the data (risking information loss) or replace the optimizer with a neural network (sacrificing guarantees). Fast-DeePC takes a different path: it eliminates the coordinate vector entirely—not by approximation, but by exact algebraic manipulation.

The key insight is to relax the hard consistency constraint (which forces the data to exactly reproduce past behavior) into the objective function, using quadratic penalties. This turns the problem into a ridge-regularized optimization, where the coordinate vector $g$ appears only in quadratic terms. That structure allows the authors to solve for $g$ in closed form and substitute it out—once, offline—reducing the online problem to a fixed-size quadratic program.

"It’s like solving for an intermediate variable symbolically before plugging in numbers," explains Terry Zhang, co-lead author. "Once you do that, you never have to compute it again in real time."

The online problem becomes a box-constrained quadratic program (QP) in the physical variables—future inputs $u$ and outputs $y$—with a Hessian and linear term that depend only on system dimensions (prediction horizon, input/output size), not on data length. This fixed-size structure unlocks the use of highly optimized solvers.

To exploit this, the team implemented a structure-exploiting interior-point method in C, tailored to the dense but small-scale QP. The solver uses Mehrotra’s predictor-corrector scheme and avoids forming large intermediate matrices, keeping memory and latency low.

What They Found

The researchers tested Fast-DeePC on three benchmark systems: a two-tank liquid level controller, a connected automated vehicle (CAV) in mixed traffic, and a vertical rocket landing scenario. In each case, they compared solve times against MOSEK, a high-performance general-purpose convex optimizer, on the same soft-constrained DeePC formulation.

The results were striking. Across all benchmarks, Fast-DeePC achieved numerically identical solutions to MOSEK—same control actions, same trajectories—while running dramatically faster.

On the mixed-traffic CAV problem, solve time remained flat at around 0.1 milliseconds even as the offline data length $T$ increased from 500 to 5,000 samples. In contrast, standard DeePC’s solve time climbed from 1 ms to over 10 ms—a tenfold increase. Fast-DeePC was not just faster; it was immune to data growth.

Online solve time vs. offline data length

Label	Value
Standard DeePC	1
Fast-DeePC	0.1

Solve time in milliseconds. Fast-DeePC is immune to data growth.

The speedup peaked at two orders of magnitude—100x faster—on larger problems. Even on smaller ones, it consistently outperformed general-purpose solvers by 5–10x.

"We expected improvement, but not this much," says Jan Drgona, co-author. "The structure we uncovered really matters."

Crucially, this speed came with no loss in control performance. In the two-tank system, Fast-DeePC tracked the reference water level as closely as standard DeePC, with no visible lag or overshoot

. In the rocket landing simulation, it stabilized all states—altitude, velocity, fuel—smoothly and safely

. And in traffic, it maintained safe spacing between vehicles even under disturbances

.

The algorithm also proved robust to noise. When tested with measurement disturbances, the quadratic regularization acted as a natural filter, preventing overfitting to noisy data—a known advantage of $\ell_2$ over $\ell_1$ penalties.

Why This Changes Things

Control isn’t just about stability. It’s about scale, speed, and accessibility. Fast-DeePC removes a fundamental barrier that has limited the real-world deployment of data-driven control.

Consider smart grids. They’re chaotic, nonlinear, and constantly evolving. Building a physics-based model of a city’s power demand is nearly impossible. But data? Utilities have terabytes of it. DeePC could use that data directly to optimize voltage, frequency, and load balancing. But if each additional day of data makes the controller slower, adoption stalls. Fast-DeePC breaks that cycle.

Or take autonomous systems. A self-driving car can’t wait 10 milliseconds to decide whether to brake. Yet the environments it navigates—pedestrians, weather, other drivers—are too complex for perfect models. Fast-DeePC offers a way to use vast driving logs to build a responsive, adaptive controller that runs in real time.

"This is the first data-driven predictive control method where you can throw more data at the problem without paying a runtime penalty," says Drgona. "That changes the economics of deployment."

The implications extend beyond engineering. Fast-DeePC embodies a broader shift: from model-centric to data-centric control. Instead of spending months identifying a system, engineers can start controlling it with day-one operational data. This accelerates deployment in energy, manufacturing, robotics, and climate systems—where rapid iteration is critical.

It also aligns with trends in machine learning. While Deep DeePC uses neural networks to mimic the optimizer, losing formal guarantees, Fast-DeePC retains the convex structure and optimality of traditional MPC. It’s fast like a learned policy, but safe like a certified controller.

And unlike black-box AI, it’s interpretable. The reduced Hessian $\widehat{H}$ encodes how past data shapes future control—something engineers can analyze, tune, and trust.

"We’re not replacing models with data," says Wu. "We’re replacing the process of modeling with data. The system’s behavior is still governed by optimization, just one shaped by experience, not equations."

What’s Next

Fast-DeePC is a leap, but not the final step. Several challenges remain.

First, tuning the regularization weights $\lambda$, $\rho$, and $\lambda_g$ still requires care. Too high, and the controller clings to outdated data; too low, and it ignores valuable patterns. The paper assumes these are fixed, but in practice, they may need adaptation—especially in non-stationary environments.

Second, while the online cost is now fixed, the offline computation—inverting a large matrix to form $M$—scales with data size. The authors use a Woodbury identity to avoid this, but for extremely large datasets, even that may become costly. Future work could explore low-rank approximations or streaming updates.

Third, the method assumes linear time-invariant (LTI) systems. Real-world systems are often nonlinear or time-varying. Extensions to kernel-based or lifted nonlinear DeePC are possible, but would require new elimination strategies.

Finally, real-world validation is needed. The current results are simulation-based. Testing on physical hardware—especially safety-critical systems like drones or medical devices—will be essential.

Still, the core idea—eliminating data-dependent variables via algebraic reduction—could inspire new algorithms beyond control. Any data-driven optimization that suffers from growing problem size might benefit from a similar trick.

"We’ve shown that you can have your data and eat it too," says Zhang. "More data, faster decisions, same guarantees. That’s a rare trifecta."

As the world generates more data than ever, the bottleneck is no longer information—it’s how fast we can act on it. Fast-DeePC doesn’t just speed up a controller. It redefines what’s possible when data isn’t just input, but the very fabric of decision-making.

Speedup factor across benchmarks

Label	Value
Two-tank	5
CAV	50
Rocket	100

Speedup relative to MOSEK on identical soft-constrained problem.