amortized-nonlinear-mpc

## Context From arXiv:2606.05840 (June 2026) - "Amortized Nonlinear Model Predictive Control" by Francesco Pillitteri, Alberto Bemporad. Addresses computational bottleneck of real-time Nonlinear MPC by approximating optimal control moves with state-dependent QPs. Uses residual-corrector network architecture trained offline with hybrid loss combining imitation and KKT-residual penalties. ## Core Methodology ### 1. Problem Formulation **Standard NMPC bottleneck**: - Solve constrained nonlinear program (NLP) at each sampling instant - Computational cost limits deployment on resource-constrained hardware - High sampling rate applications infeasible **Key insight**: For input-affine nonlinear systems, optimal control can be approximated by state-dependent QP whose parameters depend on current state and reference. ### 2. Architecture Design **Single-network residual-corrector**: 1. **State-dependent analytic baseline**: Provides initial QP parameters (cost matrix H, gradient h, constraint bounds) 2. **Neural network correction**: Learns only the residual corrections needed to match full NLP solution 3. **Differentiable interior-point layer**: Solves resulting QP, guaranteeing constraint satisfaction **Why residual learning**: - Baseline captures problem structure - Network focuses on refinement - Faster training, better generalization - Smaller network capacity needed ### 3. Training Procedure **Offline data generation**: - Run full NLP solver over representative state-reference scenarios - Record optimal control inputs and QP parameters - Build training dataset **Hybrid loss function**: ```python Loss = L_imitation + λ * L_KKT L_imitation = ||u_network - u_NLP||² # Supervised imitation L_KKT = ||KKT_residual||² # KKT optimality condition penalty ``` **Training steps**: 1. Collect NLP solutions across state space 2. Compute analytic baseline QP parameters 3. Train network to predict corrections 4. Enforce KKT conditions via loss penalty 5. Validate on held-out scenarios ### 4. Input-Affine System Structure **System model**: x_dot = f(x) + g(x) * u **State-dependent QP approximation**: ``` minimize: 0.5 * u^T H(x, r) u + h(x, r)^T u subject to: A(x) u ≤ b(x) u_min ≤ u ≤ u_max ``` Parameters H(x,r), h(x,r) depend on current state x and reference r. ### 5. Implementation Architecture ```python class AmortizedNMPC: def __init__(self, baseline_policy, correction_network): self.baseline = baseline_policy # Analytic QP parameter generator self.network = correction_network # Residual correction network self.qp_solver = DifferentiableInteriorPointLayer() def compute_control(self, x, r): """ Real-time control computation Steps: 1. Analytic baseline → H0, h0, A0, b0 2. Network correction → ΔH, Δh, ΔA, Δb 3. QP parameters → H = H0 + ΔH, etc. 4. Solve QP → optimal u """ # Baseline (no computation, analytic) H0, h0, A0, b0 = self.baseline(x, r) # Network correction (single forward pass) delta_params = self.network(x, r) # Final QP parameters H = H0 + delta_params['H'] h = h0 + delta_params['h'] A = A0 + delta_params['A'] b = b0 + delta_params['b'] # Solve QP (differentiable interior-point) u_opt = self.qp_solver.solve(H, h, A, b) return u_opt ``` ### 6. Differentiable Interior-Point Layer **Key requirement**: QP solver must be differentiable for gradient flow through training **Interior-point method characteristics**: - Handles inequality constraints - Iterative optimization with barrier function - Backpropagation through iterations possible **Implementation**: - Use custom autograd function - Fixed iteration count for consistent computation time - Warm start from previous solution ## Pitfalls 1. **Baseline inadequacy**: If analytic baseline is too far from NLP solution, network correction may be insufficient. Ensure baseline captures essential problem structure. 2. **Constraint violation**: Differentiable QP layer must guarantee feasibility. Interior-point methods handle this better than projected gradient. 3. **Training distribution mismatch**: Dataset must cover operational state-reference space. Missing regions lead to poor extrapolation. 4. **Non-input-affine systems**: Method assumes input-affine structure. General nonlinear systems require different approach. 5. **KKT condition weighting**: λ parameter for KKT loss must balance imitation vs optimality. Too high → ignores data; too low → violates constraints. 6. **Real-time constraint**: Must guarantee fixed computation time. Interior-point iterations must be bounded. 7. **Reference prediction horizon**: QP approximation assumes first control action. Long horizons require recursive approach. ## Verification 1. **Speedup validation**: Compare wall-clock time vs NLP solver. Expected orders-of-magnitude improvement. 2. **Tracking performance**: Compare closed-loop tracking error vs full NMPC. 3. **Constraint satisfaction**: Verify that QP solution respects constraints for ALL tested scenarios. 4. **Training convergence**: Monitor imitation loss and KKT residual during training. 5. **Generalization test**: Evaluate on held-out state-reference combinations. 6. **Hardware deployment**: Test on target platform (embedded system, robot controller). ## Key Applications 1. **Robotic manipulation**: High-frequency end-effector tracking (validated on 3-link planar arm) 2. **Autonomous vehicles**: Real-time path planning and control 3. **Process control**: Chemical process regulation with nonlinear dynamics 4. **Power systems**: Grid voltage/frequency regulation 5. **Aerospace**: Flight control with aerodynamic nonlinearities ## Algorithm Comparison | Method | Computation | Constraints | Accuracy | |--------|-------------|-------------|----------| | Full NMPC | Slow (NLP solve) | Exact | Optimal | | Linear MPC | Fast (QP) | Approximate | Approximate | | Amortized NMPC | Fast (QP + net) | Exact (QP layer) | Near-optimal | ## Key Innovation **Residual-corrector architecture**: Instead of learning full QP parameters from scratch, network only learns corrections to analytic baseline. This: - Reduces network size - Improves generalization - Preserves problem structure - Enables faster training **Differentiable optimization layer**: Guarantees constraint satisfaction by solving actual QP, not predicting solution. Differentiability enables end-to-end training with backprop through solver. ## Mathematical Details **Input-affine system**: dx/dt = f(x) + g(x)u **NMPC problem** (horizon N): ``` minimize Σ_{k=0}^{N-1} [l(x_k, u_k) + l_f(x_N)] subject to: x_{k+1} = f(x_k) + g(x_k)u_k x_k ∈ X, u_k ∈ U x_0 = current state ``` **QP approximation** (first step only): ``` minimize 0.5*u^T H(x,r) u + h(x,r)^T u subject to: A(x) u ≤ b(x) u_min ≤ u ≤ u_max ``` **Network correction**: ΔH, Δh, ΔA, Δb = NN(x,r) **Training loss**: L = ||u_NN - u_NLP||² + λ||KKT(u_NN)||² ## Experimental Validation (Paper) **Test case**: 3-link planar robotic arm, Cartesian end-effector tracking **Results**: - Orders-of-magnitude speedup over NLP - Comparable tracking performance - Constraint satisfaction verified - Robust to parameter variations **Computation time**: ~1ms vs ~100ms for full NLP (100x speedup) ## Connection to Prior Work - **Linear MPC**: Fast but inaccurate for nonlinear systems - **Real-time iteration scheme**: Sequential QP approximations (slower convergence) - **Explicit MPC**: Offline solution enumeration (limited complexity) - **Learning-based MPC**: Direct policy learning (constraint violations) - **This paper**: Differentiable optimization + residual learning (fast + feasible) ## Practical Deployment 1. **Offline training phase**: Generate data, train network (hours) 2. **Online inference**: QP solve + network forward pass (milliseconds) 3. **Hardware**: Embedded processors, FPGA, GPU inference 4. **Safety**: Constraint satisfaction guaranteed by QP layer **Activation**: amortized MPC, real-time nonlinear control, QP approximation, differentiable optimization, interior-point solver, robotics control, constraint satisfaction, MPC acceleration, learning-based control