文章目录
- 1 模型预测控制的基本思想
- 2 简单离散情况下的MPC
- 2.1 状态空间以及连续到离散的转化
- 2.2 算法原理
- 3 约束条件的转化
- 3.1 输入向量变化量的约束
- 3.2 输入向量的约束
- 3.3 输出向量的约束
- 4 约束优化
1 模型预测控制的基本思想
假设拥有一个精度较高的可以描述系统的状态空间方程，显然我可以根据当前的状态的未来的输入预测出未来的状态。由此可以定义包含两项的损失函数
- 一项是预测的未来状态和期望的未来状态的距离
- 另一项是输入变化量的模长
显然，我们希望优化关于未来输入的损失函数，使得这两项最小，即预测状态最贴近期望状态，并且输入不会变化地太剧烈。与PID控制不同，可以明显看出MPC计算输入的过程，本质上是一个优化问题，既然是优化问题，那么就可以加上约束，这是PID做不到的。
2 简单离散情况下的MPC
2.1 状态空间以及连续到离散的转化
一般地，用状态空间方程可以描述系统为：
x
˙
=
f
(
x
,
u
,
t
)
,
y
=
g
(
x
,
u
,
t
)
(2.1.1)
dot x = f(x,u,t), y=g(x,u,t) tag{2.1.1}
x˙=f(x,u,t),y=g(x,u,t)(2.1.1)
其中x是状态向量，y是输出，u是输入。
对于线性时不变系统，则可以简单地描述为：
x
˙
=
A
x
+
B
u
,
y
=
C
x
+
D
u
(2.1.2)
dot x = Ax+Bu, y = Cx+Du tag{2.1.2}
x˙=Ax+Bu,y=Cx+Du(2.1.2)
接下来考虑近似的离散化模型，当采样周期T足够小时，可以认为
d
x
=
x
(
k
+
1
)
−
x
(
k
)
T
dx=frac{x(k+1)-x(k)}{T}
dx=Tx(k+1)−x(k)，代入式(2.1.1)与(2.1.2)中可得到
x
(
k
+
1
)
=
x
(
k
)
+
T
f
(
x
(
k
)
,
u
(
k
)
,
k
T
)
,
y
(
k
)
=
g
(
x
(
k
)
,
u
(
k
)
,
k
T
)
(2.1.3)
x(k+1)=x(k)+Tf(x(k),u(k),kT), y(k)=g(x(k),u(k),kT) tag{2.1.3}
x(k+1)=x(k)+Tf(x(k),u(k),kT), y(k)=g(x(k),u(k),kT)(2.1.3)
x
(
k
+
1
)
=
(
I
+
T
A
)
x
(
k
)
+
T
B
u
(
k
)
,
y
(
k
)
=
C
x
(
k
)
+
D
u
(
k
)
(2.1.4)
x(k+1)=(I+TA)x(k)+TBu(k), y(k)=Cx(k)+Du(k) tag{2.1.4}
x(k+1)=(I+TA)x(k)+TBu(k), y(k)=Cx(k)+Du(k)(2.1.4)
本文接下来讨论的所有情况均使用模型(2.1.4)，但因为以原理为主，对于一般化的非线性系统(2.1.3)仍然可以使用相同地方式具体推导。
2.2 算法原理
考虑系统
x
(
k
+
1
)
=
A
x
(
k
)
+
B
u
(
k
)
y
(
k
)
=
C
x
(
k
)
(2.2.1)
x(k+1)=Ax(k)+Bu(k) \ y(k)=Cx(k) tag{2.2.1}
x(k+1)=Ax(k)+Bu(k)y(k)=Cx(k)(2.2.1)
由于损失函数需要优化输入向量的变化量，所以我们首先做一些变换，将状态方程中的输入向量替换为输入变化量。
令
Δ
x
(
k
+
1
)
=
x
(
k
+
1
)
−
x
(
k
)
Delta x(k+1)=x(k+1)-x(k)
Δx(k+1)=x(k+1)−x(k)，有
Δ
y
(
k
+
1
)
=
C
A
Δ
x
(
k
)
+
C
B
Δ
u
(
k
)
y
(
k
+
1
)
=
y
(
k
)
+
C
A
Δ
x
(
k
)
+
C
B
Δ
u
(
k
)
(2.2.2)
Delta y(k+1)=CADelta x(k)+CBDelta u(k) \ y(k+1)=y(k)+CADelta x(k)+CBDelta u(k) tag{2.2.2}
Δy(k+1)=CAΔx(k)+CBΔu(k)y(k+1)=y(k)+CAΔx(k)+CBΔu(k)(2.2.2)
写成紧凑的形式
[
Δ
x
(
k
+
1
)
y
(
k
+
1
)
]
=
[
A
O
C
A
I
]
[
Δ
x
(
k
)
y
(
k
)
]
+
[
B
C
B
]
Δ
u
(
k
)
(2.2.3)
left [ begin{matrix} Delta x(k+1) \ y(k+1) end{matrix} right] = left [ begin{matrix} A & O \ CA & I end{matrix} right] left [ begin{matrix} Delta x(k) \ y(k) end{matrix} right] + left [ begin{matrix} B \ CB end{matrix} right] Delta u(k) tag{2.2.3}
[Δx(k+1)y(k+1)]=[ACAOI][Δx(k)y(k)]+[BCB]Δu(k)(2.2.3)
y
(
k
)
=
[
O
I
]
[
Δ
x
(
k
)
y
(
k
)
]
(2.2.4)
y(k)=left [ begin{matrix} O& I end{matrix} right] left [ begin{matrix} Delta x(k) \ y(k) end{matrix} right] tag{2.2.4}
y(k)=[OI][Δx(k)y(k)](2.2.4)
显然，已经可以定义一个新的状态空间，其输入向量为原来的输入向量变化量，定义：
x
a
:
=
[
Δ
x
(
k
)
y
(
k
)
]
,
A
a
:
=
[
A
O
C
A
I
]
,
B
a
:
=
[
B
C
B
]
,
C
a
:
=
[
O
I
]
(2.2.5)
x_a:=left [ begin{matrix} Delta x(k) \ y(k) end{matrix} right] , A_a:=left [ begin{matrix} A & O \ CA & I end{matrix} right] , B_a:=left [ begin{matrix} B \ CB end{matrix} right], C_a:=left [ begin{matrix} O& I end{matrix} right] tag{2.2.5}
xa:=[Δx(k)y(k)], Aa:=[ACAOI], Ba:=[BCB], Ca:=[OI](2.2.5)
新的状态空间方程为：
x
a
(
k
+
1
)
=
A
a
x
a
(
k
)
+
B
a
Δ
u
(
k
)
y
(
k
)
=
C
a
x
a
(
k
)
(2.2.6)
x_a(k+1)=A_ax_a(k)+B_aDelta u(k) \ y(k)=C_ax_a(k) tag{2.2.6}
xa(k+1)=Aaxa(k)+BaΔu(k)y(k)=Caxa(k)(2.2.6)
现在考虑位于预测时域上的序列状态，定义
N
p
N_p
Np为预测时域，控制器将会预测一共
N
p
N_p
Np个状态作为依据进行优化。定义符号
x
(
k
+
N
∣
k
)
x(k+N|k)
x(k+N∣k)表示在k时刻预测的k+N时刻的变量x的值。
那么有：
[
y
(
k
+
1
∣
k
)
⋮
y
(
k
+
N
p
−
1
∣
k
)
]
=
[
C
a
A
a
⋮
C
a
A
a
N
p
]
x
a
(
k
)
+
[
C
a
B
a
C
a
A
a
B
a
B
a
⋮
⋱
C
a
A
a
N
p
−
1
B
a
⋯
B
a
]
[
Δ
u
(
k
)
⋮
Δ
u
(
k
+
N
p
−
1
)
]
(2.2.7)
left [ begin{matrix} y(k+1|k)\ vdots \ y(k+N_p-1|k) end{matrix} right]=left [ begin{matrix} C_aA_a\ vdots \ C_aA_a^{N_p} end{matrix} right]x_a(k)+ left [ begin{matrix} C_aB_a\ C_aA_aB_a & B_a \ vdots & & ddots \ C_aA_a^{N_p-1}B_a & cdots & &B_a end{matrix} right] left [ begin{matrix} Delta u(k) \ vdots \ Delta u(k+N_p-1) end{matrix} right] tag{2.2.7}
⎣⎢⎡y(k+1∣k)⋮y(k+Np−1∣k)⎦⎥⎤=⎣⎢⎡CaAa⋮CaAaNp⎦⎥⎤xa(k)+⎣⎢⎢⎢⎡CaBaCaAaBa⋮CaAaNp−1BaBa⋯⋱Ba⎦⎥⎥⎥⎤⎣⎢⎡Δu(k)⋮Δu(k+Np−1)⎦⎥⎤(2.2.7)
将上式简化表示为
Y
=
W
x
a
(
k
)
+
Z
Δ
U
(2.2.8)
Y=Wx_a(k)+ZDelta U tag{2.2.8}
Y=Wxa(k)+ZΔU(2.2.8)
根据1中所提到的算法思想，我们可以轻易构造出损失函数
J
(
Δ
U
)
J(Delta U)
J(ΔU)
J
(
Δ
U
)
=
1
2
(
r
p
−
Y
)
T
Q
(
r
p
−
Y
)
+
1
2
Δ
U
T
R
Δ
U
(2.2.9)
J(Delta U)=frac{1}{2}(r_p-Y)^TQ(r_p-Y)+frac{1}{2}Delta U^TRDelta U tag{2.2.9}
J(ΔU)=21(rp−Y)TQ(rp−Y)+21ΔUTRΔU(2.2.9)
其中Q和R为半正定矩阵，作用是设定两项优化项的权重，当Q显著大的时候，可以让系统追踪期望向量
r
p
r_p
rp更加紧密，当R显著大的时候可以让系统的输入变化更小，式中的1/2是为了求梯度时形式更好看。
在没有任何约束的时候，优化这个损失函数相当容易，直接求导可以得到
∂
J
∂
Δ
U
=
−
(
r
p
−
W
x
a
−
Z
Δ
U
)
T
Q
Z
+
Δ
U
T
R
=
0
(2.2.10)
frac{partial J}{partial{Delta U}}=-(r_p-Wx_a-ZDelta U)^TQZ+Delta U^TR=0 tag{2.2.10}
∂ΔU∂J=−(rp−Wxa−ZΔU)TQZ+ΔUTR=0(2.2.10)
Δ
U
∗
=
(
R
+
Z
T
Q
Z
)
−
1
Z
T
Q
(
r
p
−
W
x
a
)
(2.2.11)
Delta U^*=(R+Z^TQZ)^{-1}Z^TQ(r_p-Wx_a) tag{2.2.11}
ΔU∗=(R+ZTQZ)−1ZTQ(rp−Wxa)(2.2.11)
至此我们可以按照以下流程进行控制
- 采样，更新状态
- 根据当前状态计算最优输入向量
- 将输入向量输入系统，等待下一次采样
3 约束条件的转化
为了体现MPC的优势性，我们考虑控制系统可能存在的约束，事实上实际例子中往往包含约束
- 输入向量变化量存在约束（例如机器处理速度优先，无法达到高频率的输入调整）
- 输入向量存在约束（例如油门和刹车最多只能“踩死”）
- 输出向量存在约束（例如无人机飞行区域因为障碍物而存在空间飞行限制）
这些约束作用于不同的变量，但由于我们优化损失函数的最优结果是关于输入变化向量 Δ U Delta U ΔU的，所以我们希望进行一些条件转化，将约束条件转化为对 Δ U Delta U ΔU的约束。
3.1 输入向量变化量的约束
Δ
u
m
i
n
≤
Δ
u
≤
Δ
u
m
a
x
(3.1.1)
Delta u^{min} le Delta u le Delta u^{max} tag{3.1.1}
Δumin≤Δu≤Δumax(3.1.1)
这个和
Δ
U
Delta U
ΔU直接关联，所以也非常好写，直接代入就能得到：
[
−
I
O
⋯
O
I
O
⋯
O
O
−
I
⋯
O
O
I
⋯
O
⋮
⋮
⋮
O
O
⋯
I
]
Δ
U
≤
[
−
Δ
u
(
k
)
m
i
n
Δ
u
(
k
)
m
a
x
⋮
−
Δ
u
(
k
+
N
p
−
1
)
m
i
n
Δ
u
(
k
+
N
p
−
1
)
m
a
x
]
(3.1.2)
left [ begin{matrix} -I & O & cdots & O \ I & O & cdots & O \ O & -I & cdots & O \ O & I & cdots & O \ vdots & vdots && vdots \ O & O & cdots &I end{matrix} right] Delta U le left [ begin{matrix} -Delta u(k)^{min} \ Delta u(k)^{max} \ vdots \ -Delta u(k+N_p-1)^{min} \ Delta u(k+N_p-1)^{max} \ end{matrix} right] tag{3.1.2}
⎣⎢⎢⎢⎢⎢⎢⎢⎡−IIOO⋮OOO−II⋮O⋯⋯⋯⋯⋯OOOO⋮I⎦⎥⎥⎥⎥⎥⎥⎥⎤ΔU≤⎣⎢⎢⎢⎢⎢⎡−Δu(k)minΔu(k)max⋮−Δu(k+Np−1)minΔu(k+Np−1)max⎦⎥⎥⎥⎥⎥⎤(3.1.2)
3.2 输入向量的约束
u
m
i
n
≤
u
≤
u
m
a
x
(3.2.1)
u^{min} le u le u^{max} tag{3.2.1}
umin≤u≤umax(3.2.1)
将u写为
u
(
k
)
=
u
(
k
−
1
)
+
[
I
O
⋯
O
]
Δ
U
u(k)=u(k-1)+[I O cdots O]Delta U
u(k)=u(k−1)+[I O ⋯ O]ΔU的递推式，写完递推式可以得到
[
u
(
k
)
⋮
u
(
k
+
N
p
−
1
)
]
=
[
I
⋮
I
]
u
(
k
−
1
)
+
[
I
O
⋮
⋱
I
⋯
I
]
[
Δ
u
(
k
)
⋮
Δ
u
(
k
+
N
p
−
1
)
]
(3.2.2)
left [ begin{matrix} u(k) \ vdots \ u(k+N_p-1) end{matrix} right] = left [ begin{matrix} I \ vdots \ I end{matrix} right] u(k-1) + left [ begin{matrix} I & & O\ vdots & ddots & \ I & cdots & I end{matrix} right] left [ begin{matrix} Delta u(k) \ vdots \ Delta u(k+N_p-1) end{matrix} right] tag{3.2.2}
⎣⎢⎡u(k)⋮u(k+Np−1)⎦⎥⎤=⎣⎢⎡I⋮I⎦⎥⎤u(k−1)+⎣⎢⎡I⋮I⋱⋯OI⎦⎥⎤⎣⎢⎡Δu(k)⋮Δu(k+Np−1)⎦⎥⎤(3.2.2)
简写为
U
=
E
u
(
k
−
1
)
+
H
Δ
U
(3.2.3)
U=Eu(k-1)+H Delta Utag{3.2.3}
U=Eu(k−1)+HΔU(3.2.3)
将式(3.2.3)代入到约束方程，可得
[
−
U
U
]
≤
[
−
U
m
i
n
U
m
a
x
]
⇒
[
−
E
u
(
k
−
1
)
−
H
Δ
U
E
u
(
k
−
1
)
+
H
Δ
U
]
≤
[
−
U
m
i
n
U
m
a
x
]
left [ begin{matrix} -U \ U end{matrix} right] le left [ begin{matrix} -U^{min} \ U^{max} end{matrix} right] Rightarrow left [ begin{matrix} -Eu(k-1)-HDelta U \ Eu(k-1)+HDelta U end{matrix} right] le left [ begin{matrix} -U^{min} \ U^{max} end{matrix} right]
[−UU]≤[−UminUmax]⇒[−Eu(k−1)−HΔUEu(k−1)+HΔU]≤[−UminUmax]
[
−
H
H
]
Δ
U
≤
[
−
U
m
i
n
+
E
u
(
k
−
1
)
U
m
a
x
−
E
u
(
k
−
1
)
]
(3.2.4)
left [ begin{matrix} -H \ H end{matrix} right] Delta Ule left [ begin{matrix} -U^{min} + Eu(k-1)\ U^{max} - Eu(k-1) end{matrix} right] tag{3.2.4}
[−HH]ΔU≤[−Umin+Eu(k−1)Umax−Eu(k−1)](3.2.4)
3.3 输出向量的约束
[
−
Y
Y
]
≤
[
−
Y
m
i
n
Y
m
a
x
]
(3.3.1)
left [ begin{matrix} -Y \ Y end{matrix} right] le left [ begin{matrix} -Y^{min} \ Y^{max} end{matrix} right] tag{3.3.1}
[−YY]≤[−YminYmax](3.3.1)
将(2.2.8)代入上式，可以得到
[
−
Z
Z
]
Δ
U
≤
[
−
Y
m
i
n
+
W
x
a
Y
m
a
x
−
W
x
a
]
(3.2.4)
left [ begin{matrix} -Z \ Z end{matrix} right] Delta Ule left [ begin{matrix} -Y^{min} + Wx_a\ Y^{max} - Wx_a end{matrix} right] tag{3.2.4}
[−ZZ]ΔU≤[−Ymin+WxaYmax−Wxa](3.2.4)
4 约束优化
对于含有约束的系统，或者高度非线性化的系统，直接求一阶导找到全局最小点是不可行的方法，需要使用足够高效的优化算法保证每一步都能进行在线优化。优化算法并不是本文的核心内容，下面会给出部分可行的方法供参考。
- KKT乘子法： 可以认为是广义拉格朗日乘子法，能够将有约束优化问题转化成无约束优化问题求解，但是这需要对损失函数进行精确的计算。推导支持向量机的时候就是使用的KKT乘子法。
- 梯度下降法： 梯度下降固然是可行的，但是问题在于容易跳进局部最优点，更重要的是需要设计一个大小适当的学习率，太小的学习率回导致收敛慢，太大的学习率在收敛点附近震荡。可以展开到二阶，通过考虑函数曲率设计自适应的学习率，具体可以参考我的另一篇博文
- 牛顿法： 牛顿法也是二阶的优化算法，通过检查领域内的最小点去下降，会收敛更快，但是问题在于每一次的迭代都需要重新计算一次损失函数的海森矩阵，对于高维数据，这个计算量非常庞大。不过现在已经有了改进方法通过估计一个近似的海森矩阵来减少计算量，具体可以参考我的另一篇博文
- 粒子群算法/鸽群优化算法等启发式算法： 这一类算法的最大好处在于他完全不需要对系统模型有精确的刻画，完全使用启发式算法“试错”寻找，所需要的计算量也不大。启发式算法就注定在数学上没有严谨的证明，但是这其中有不少算法都在实践中取得了很好的效果，仍然会是一种可行的方案。
最后
以上就是眼睛大牛排最近收集整理的关于基本模型预测控制（MPC）原理1 模型预测控制的基本思想2 简单离散情况下的MPC3 约束条件的转化4 约束优化的全部内容，更多相关基本模型预测控制（MPC）原理1内容请搜索靠谱客的其他文章。
发表评论 取消回复