Section 7.5: Model predictive control (MPC) as receding-horizon optimization

A Careful Control Loop

This section develops the technical contract for Model predictive control (MPC) as receding-horizon optimization into a usable mental model. First we define the object of study, then we connect it to the agent loop, then we test it with a compact implementation.

The key question in Model predictive control (MPC) as receding-horizon optimization is practical: what must the agent know, what can it observe, what action is available, and what evidence shows that the action worked under the stated conditions?

Theory

For Model predictive control (MPC) as receding-horizon optimization, the practical design rule is to make the interface inspectable before optimization begins: inputs, outputs, units, latency, bounds, and failure labels should all be visible in the saved artifact.

MPC solves a short planning problem at every control tick, executes only the first command, then replans after the next observation. This receding horizon is valuable when constraints matter: actuator limits, collision margins, contact forces, battery limits, joint limits, and comfort bounds can be written directly into the optimization. The cost encourages progress, while the constraints define what the robot is not allowed to buy with that progress.

Worked Example

MPC solves a finite-horizon optimization at every tick, executes only the first command, then replans. Code Fragment 7.5.1 implements this on a 1D double integrator (state \([\text{pos},\text{vel}]\), control = acceleration). Each tick minimizes \(\sum_{k=0}^{N}\lVert x_k - x_d\rVert_Q^2 + \lVert u_k\rVert_R^2\) subject to the discrete dynamics and a hard acceleration limit \(\lvert u\rvert \le 1.5\). The previous solution is shifted forward as a warm start, which is what keeps the per-tick solve fast enough to meet a control deadline.

import numpy as np
from scipy.optimize import minimize

# 1D double integrator: state [pos, vel], control = acceleration. Drive to x_d.
dt, N = 0.1, 15                          # horizon length
A = np.array([[1, dt], [0, 1.0]])
B = np.array([0.5 * dt * dt, dt])
x_d = np.array([1.0, 0.0])
Qx, Qv, Ru = 10.0, 1.0, 0.1
u_lim = 1.5                              # acceleration constraint

def rollout(u_seq, x0):
    x, xs = x0.copy(), [x0.copy()]
    for u in u_seq:
        x = A @ x + B * u; xs.append(x)
    return np.array(xs)

def cost(u_seq, x0):
    e = rollout(u_seq, x0) - x_d
    return Qx * np.sum(e[:, 0] ** 2) + Qv * np.sum(e[:, 1] ** 2) + Ru * np.sum(u_seq ** 2)

def mpc_step(x0, warm):
    res = minimize(cost, warm, args=(x0,), method="SLSQP",
                   bounds=[(-u_lim, u_lim)] * N, options={"maxiter": 50, "ftol": 1e-6})
    return res.x, res.success

x, warm, solves_ok = np.array([0.0, 0.0]), np.zeros(N), 0
for t in range(40):                                  # closed-loop receding horizon
    u_seq, ok = mpc_step(x, warm)
    solves_ok += int(ok)
    u0 = float(np.clip(u_seq[0], -u_lim, u_lim))     # execute only the first command
    x = A @ x + B * u0
    warm = np.r_[u_seq[1:], 0.0]                     # shift solution for the warm start
print(f"feasible solves: {solves_ok}/40")
print(f"final state pos={x[0]:.3f} vel={x[1]:+.3f} (target pos=1.000 vel=0.000)")

Practical Recipe

1. Write the observation, action, and success metric before choosing a model.
2. Build a baseline that is simple enough to debug by inspection.
3. Add the library implementation only after the baseline behavior is understood.
4. Record failures as structured cases: perception error, state error, planning error, control error, or evaluation error.
5. Run at least one perturbation test before trusting the result.

Production Pattern

Model predictive control (MPC) as receding-horizon optimization sits inside the Part II robotics contract: geometry defines where things are, kinematics defines what motion is possible, dynamics defines what motion costs, control defines how errors are corrected, and sensing defines what the agent can know on time.

For MPC, log horizon, constraints, solver status, warm start, and missed-deadline behavior. This makes the section useful to students, builders, and researchers at the same time: the idea has an intuitive role, a formal interface, a runnable check, and a failure mode that can be reproduced.

Use this recipe when turning Model predictive control (MPC) as receding-horizon optimization into code, a simulator experiment, or a robot diagnostic. The point is not to use every library. The point is to keep the hand-built baseline and the maintained-tool path comparable.

1. Write the control objective, measured state, actuator command, update rate, and saturation policy.
2. Run a step-response test before adding learning, with overshoot, settling time, and steady-state error logged.
3. Compare the hand controller with python-control, CasADi, Drake, do-mpc, or ROS 2 control on the same plant model.
4. Record latency, missed deadlines, saturation events, constraint violations, and recovery actions.
5. Only compare controllers and policies when they share sensors, action limits, disturbance tests, and safety checks.

A learned policy can hide an MPC timing failure until the disturbance changes. Check horizon length, model mismatch, constraint scaling, solver status, missed deadlines, warm start, and fallback behavior before scaling training. For this section, first reproduce one tiny receding-horizon case by hand, then rerun it through CasADi, do-mpc, or Drake. If the two disagree, inspect dynamics discretization, constraint units, terminal cost, and the command actually executed after replanning.