# 🚗 比较 MPC 与 强化学习：以小车到目标点为例

本例以一个简单的小车控制任务，展示 MPC（Model Predictive Control） 与 强化学习（Reinforcement Learning） 的形式对比与数学关系

我们考虑一维小车的位置控制问题。状态为 $x_t$（当前位置），动作为加速度 $u_t$。目标是从起点 $x_0$ 移动至目标位置 $x_{\text{goal}}$。

# 系统动力学模型（离散时间）

$$x_{t+1} = f(x_t, u_t) = x_t + u_t \cdot \Delta t$$

# 代价函数（Cost Function）

$$c(x_t, u_t) = (x_t - x_{\text{goal}})^2 + \lambda u_t^2$$

控制目标：寻找一系列控制量 $\{u_0, u_1, \dots\}$，使得总代价最小。

对于 MPC 而言，每一时刻都解一个有限时域优化问题：

当前时刻为 $t$，优化未来 $H$ 步控制序列：

$$\min_{u_{t:t+H-1}} \sum_{k=0}^{H-1} \left[(x_{t+k} - x_{\text{goal}})^2 + \lambda u_{t+k}^2\right]$$

受限于：

$$x_{t+k+1} = x_{t+k} + u_{t+k} \cdot \Delta t$$

• 解出控制序列 $\{u_t^*, u_{t+1}^*, \dots\}$
• 仅执行第一个动作 $u_t^*$
• 下一步重新优化

# MPC 示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import minimize

# 动力学模型
def dynamics(x, u, dt=0.1):
    return x + u * dt

# 累计代价
def cost(u_seq, x0, x_goal, H, dt, lam=0.1):
    x = x0
    total_cost = 0
    for i in range(H):
        u = u_seq[i]
        total_cost += (x - x_goal)**2 + lam * u**2
        x = dynamics(x, u, dt)
    return total_cost

# MPC 控制器
def run_mpc(x0=0.0, x_goal=10.0, H=10, T=50, lam=0.1):
    traj = [x0]
    x = x0
    for t in range(T):
        u0 = np.zeros(H)
        res = minimize(cost, u0, args=(x, x_goal, H, 0.1, lam), bounds=[(-1, 1)]*H)
        u_opt = res.x[0]
        x = dynamics(x, u_opt)
        traj.append(x)
        if abs(x - x_goal) < 0.05:
            break
    return traj

mpc_traj = run_mpc()
plt.plot(mpc_traj, label="MPC Trajectory")
plt.axhline(10, color='gray', linestyle='--', label="Goal")
plt.xlabel("Time Step")
plt.ylabel("Position")
plt.legend()
plt.title("MPC Control Result")
plt.show()

# 强化学习（以 Q-Learning 为例）

强化学习目标是最大化累计奖励（即最小化总代价）。

将代价函数转化为负的即时奖励：

$$r(s_t, a_t) = -[(x_t - x_{\text{goal}})^2 + \lambda a_t^2]$$

强化学习的目标是学习一个策略 $\pi(a \mid s)$，使得以下期望累计奖励最大，：

$$\max_\pi \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r(s_t, a_t) \right]$$

等价于最小化 MPC 中的累积代价：

$$\min_\pi \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t c(x_t, u_t) \right]$$

# Q-Learning 原理推导

Q-learning 是一种无模型的强化学习算法，通过学习一个状态 - 动作值函数 $Q(s, a)$，表示在状态 $s$ 选择动作 $a$ 后，未来获得的期望总奖励。

# Bellman 方程定义：

$$Q(s_t, a_t) = r(s_t, a_t) + \gamma \max_{a'} Q(s_{t+1}, a')$$

即：当前的 Q 值应等于当前奖励 + 未来最大奖励的折扣。

# Q-learning 更新公式：

在交互过程中迭代更新：

$$Q(s_t, a_t) \leftarrow Q(s_t, a_t) + \alpha \left[ r(s_t, a_t) + \gamma \max_{a'} Q(s_{t+1}, a') - Q(s_t, a_t) \right]$$

• $\alpha$ 是学习率
• $\gamma$ 是折扣因子
• $r(s_t, a_t)$ 是立即奖励
• $Q(s_{t+1}, a')$ 是未来的最大收益

最终收敛后策略为：

$$\pi(s) = \arg\max_a Q(s, a)$$

# Q-learning Python 的简化实现

#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

import numpy as np import matplotlib.pyplot as plt # 状态和动作离散化 x_goal = 10 states = np.arange(0, 21) actions = np.array([-1.0, 0.0, 1.0]) Q = np.zeros((len(states), len(actions))) def reward(x, u, lam=0.1): return -((x - x_goal)**2 + lam * u**2) alpha = 0.1 gamma = 0.95 eps = 0.2 # Q-learning 训练 for episode in range(500): x = 0 for t in range(50): s = int(round(x)) a_idx = np.random.randint(len(actions)) if np.random.rand() < eps else np.argmax(Q[s]) u = actions[a_idx] x_next = max(0, min(20, x + u * 0.1)) s_next = int(round(x_next)) r = reward(x, u) Q[s, a_idx] += alpha * (r + gamma * np.max(Q[s_next]) - Q[s, a_idx]) x = x_next if abs(x - x_goal) < 0.5: break # 测试策略 x = 0 traj = [x] for t in range(50): s = int(round(x)) a_idx = np.argmax(Q[s]) u = actions[a_idx] x = x + u * 0.1 traj.append(x) if abs(x - x_goal) < 0.05: break plt.plot(traj, label="Q-Learning Trajectory") plt.axhline(10, color='gray', linestyle='--', label="Goal") plt.xlabel("Time Step") plt.ylabel("Position") plt.legend() plt.title("Q-Learning Control Result") plt.show()