Stability-Aware Aggregation for Fleets of Predictive Controllers

When a fleet of similar machines (drones, reactors, cooling units) learns a shared dynamics model by federated learning, meaning each machine trains on its own data and sends only model updates to a server that averages them, the result is a model close to the fleet's average plant. That model is then placed inside each machine's model predictive controller. Such a controller plans a few seconds ahead with its internal model, applies the first action, and replans. Averaging assumes that errors in either direction are equally costly. For predictive control they are not. Sensitivity analysis of these controllers shows that a model which overestimates how fast the plant responds shrinks the stable operating window far more than one which underestimates it (A tool to analyze robust stability for model predictive controllers). So an averaged model is "too fast" for every machine slower than average. Those machines are the ones that oscillate or break constraints. The average fleet metric improves while the tail of the fleet fails.

We propose to change what the server optimizes. Each client computes, from its own data, a compact description of which model errors its controller can tolerate and in which direction. This description is an asymmetric margin derived from the sensitivity of its control problem, and it contains no raw data. The server then chooses the shared model that fits the pooled data best while staying inside every client's tolerance region, or as close to it as possible. A small local correction handles what the shared model cannot. The claim is testable: at matched identification accuracy, this aggregation should sharply reduce the fraction of fleet members whose closed loop goes unstable or violates constraints, and it should cost little in average tracking performance.

Core Claim and What Is New

Two papers establish that federation cuts the sample cost of identifying dynamics across a fleet. FedSysID does this for linear plants: error falls as $1/\sqrt{MN}$ plus a floor proportional to the fleet's heterogeneity $\epsilon$, with roughly a 10x error reduction at 100 clients. Federated Nonlinear System Identification extends the result to nonlinear plants whose structure is a known set of basis functions, and it shows the same heterogeneity plateau. Both papers stop at parameter error. Neither puts the learned model in a controller, and both treat the $\epsilon$ floor as symmetric, unavoidable error.

Our observation is that the floor is not a single number from the controller's point of view. Its direction relative to each client's stability window decides whether that client works at all. We therefore replace squared-error consensus with consensus constrained by what each controller tolerates.

A second line of work is related but does something different. Collaborative Value Function Estimation Under Model Mismatch proves that federation removes the single-agent "bias wall" in value estimation. That proof relies on perturbations averaging to zero across the fleet. Real fleets are skewed: most units are nominal and a tail is worn or loaded. This paper constrains our design, because it tells us the zero-mean assumption cannot be relied on, and skewed heterogeneity is the regime where directional aggregation should matter most. Data-driven Economic NMPC using Reinforcement Learning shows that a wrong model can still yield an optimal policy once cost and constraint parameters are tuned. It supplies the tool we reuse, which is differentiating through the controller's optimality conditions. Its tuning, however, is single-plant trial and error, whereas we use the same sensitivities offline to summarize tolerances.

Research Program

Each client $i$ first fits a local estimate $\hat\theta_i$ with uncertainty from its short excitation data. It then computes how its controller's closed loop degrades as the model parameter moves away from its plant. The computation uses parametric sensitivity of the controller's optimality conditions, in the style of the robust-stability tool. The margins are evaluated against a set of plausible plants drawn from the local uncertainty, not a single point estimate. The client summarizes the result as a set of directions $a_{ij}$ and one-sided margins $m_{ij}$, where $j$ indexes directions such as time constant, gain, and delay. The margins are typically much tighter on the "too fast" side.

The server then solves the following problem:

$$\bar\theta = \arg\min_\theta \sum_i w_i F_i(\theta) + \lambda \sum_{i,j} \max\big(0,\ a_{ij}^\top(\theta - \hat\theta_i) - m_{ij}\big)^2 .$$

Here $F_i$ is client $i$'s identification loss, which is optimized through ordinary federated gradient rounds so raw trajectories never leave the client. The weight $w_i$ is proportional to client $i$'s data size. The second term penalizes only violations of a client's tolerated error on the unsafe side, and $\lambda$ controls how strongly.

If no shared model fits inside every region, which happens when heterogeneity is large, the server has two options. It can cluster clients whose regions overlap, or it can mark the residual clients for a stronger local correction. That correction is a low-dimensional per-client offset fitted on local data, and it also sets the client's tube tightening, meaning the extra safety margin added to constraints. The margin summaries are small, a few vectors per client per round. We will report what they reveal about each plant, since they do leak a coarse description of the plant's dynamics.

Baselines

The naive reference point is each client running its predictive controller with the fleet's nominal design model and no learning. This fixes the failure rate that any learning must improve on.

The first learning baseline is standard federated averaging of the identification loss, with the resulting model deployed unchanged in every controller. This is the natural "obvious" combination of FedSysID with MPC.

The strongest identification competitor is FedLin, the gradient-tracking method from the same paper, which removes client drift. It shows whether fixing the optimization is enough without fixing the objective.

The strongest control competitor is federated averaging plus a local $L_1$ adaptive inner loop, as in Performance, Precision, and Payloads. That paper reports over 90% tracking-error reduction versus non-adaptive NMPC under a +90% mass mismatch. For a federated closed-loop version of this setup, no reported result was found on Lacuna.

All methods use the same client data and excitation budget, the same number of communication rounds, and the same controller horizon and weights. Hyperparameters are tuned with equal grid budgets on held-out fleets.

The key ablation keeps our aggregation but uses symmetric margins, penalizing error equally in both directions. This isolates directionality as the active ingredient.

Beating the baselines means two things at the same communication cost and the same mean identification error. First, a statistically clear reduction in the fraction of unstable or constraint-violating clients. Second, worst-decile closed-loop cost no worse than 5% above FedAvg's mean.

Why not just…?

Why not just shift the averaged model toward "slow," for example by taking a conservative quantile of client time constants? This is the most serious threat. For a single-parameter first-order plant it may do as well as our method. It breaks when the unsafe direction differs across parameters, such as gain versus delay versus time constant, and depends on the operating point, because a scalar shift then trades one failure for another. We include a per-parameter quantile baseline. We will report honestly if it matches our method on the multi-parameter benchmarks, in which case the contribution reduces to that simple rule.

Why not just personalize, letting each client fine-tune the shared model locally? With the short, safe excitation budgets that motivate federation in the first place, local fine-tuning has high variance. Variance on the too-fast side is exactly what destabilizes the loop. We test personalized fine-tuning at 5 to 100 rollouts per client and expect it to close the gap only at the high end.

Why not just add a local $L_1$ or disturbance-observer loop on top of FedAvg? The authors of Performance, Precision, and Payloads note two limitations: the planner stays blind to persistent mismatch over its horizon, and large corrections saturate the actuators. We measure saturation time and failure rates for the tail clients, where both effects should appear.

Why not just use robust tube MPC around the averaged model? A tube sized to fleet-wide $\epsilon$ is conservative for well-matched clients and still too small for tail clients. Trans-Tube-MPC shows that adaptive tubes beat fixed ones. We compare against fixed tubes sized to reach the same zero-violation rate and report the resulting loss in tracking performance.

Proposed Experiments

We start from the FedSysID synthetic linear fleet (3 states, 2 inputs, 1 to 100 clients, 5 to 100 rollouts) and close the loop with a constrained linear MPC. Heterogeneity is drawn from symmetric distributions and from skewed ones in which a tail is 20 to 60% slower. We then move to the nonlinear inverted pendulum and the 13-state quadrotor from Federated Nonlinear System Identification. For the quadrotor fleet, we simulate up to 150 heterogeneous vehicles in Flightmare, with payload heterogeneity up to 60% of vehicle mass. The final benchmark is a fleet of evaporation-process plants with perturbed parameters, following Data-driven Economic NMPC using Reinforcement Learning.

The metrics are the fraction of clients with sustained oscillation or constraint violation, worst-decile and mean tracking cost, actuator-saturation time, parameter error, and bytes communicated.

The decisive check is a curve of fleet failure rate against heterogeneity $\epsilon$ for FedAvg-MPC, the quantile baseline, symmetric-margin aggregation, and our method. The proposal succeeds if the directional method holds failures near zero to a clearly larger $\epsilon$ than FedAvg and the symmetric ablation, while staying within the mean-cost budget. It fails if the per-parameter quantile rule matches it on the quadrotor and evaporator fleets.