一、迭代学习定义和分类

1、直观理解

• 迭代学习一般应用于重复性的场景。比如控制一个单自由度的小车以特定的速度曲线移动到指定位置，整个时间是10s，控制频率是0.01，那么整个控制序列就会有1000个点。这1000个点在10s内依次发出，完成依次控制，目的就是让小车的速度或者位置跟踪上特定的曲线。我们有一个优势在于跟踪曲线不变，那么我们可以不断进行尝试，只要获得一组良好的控制序列，那么就可以完成控制。

2、更新率

• 如果我们可以设置一个更新率，根据每一个点面临的误差对控制量进行修改，那么就可以在若干次更新后获得完美的控制序列。
  $$新控制量=旧控制量+更新率$$

• 根据更新率与什么参数有关，可以分为开环、闭环、开闭环。如果跟上一次的误差有关就是开环，如果跟此刻的误差有关就是闭环，如果都有关就是开闭环。根据更新率的结构还可以分为D型、PD型等。

• 需要注意一下有D型和PD型，没有P型，我在仿真中试了半天P型都不收敛。

二、实现例子

• 网上关于迭代学习的代码实现比较少，很多还是用simulink搭的，不方便复现。这里给一个D型闭环迭代学习例子，被控对象是一个钟摆小车，全部代码用python实现，直接运行即可。
  

1、动力学模型

# 动力学模型函数
def dynamics(state, u):x, theta, dx, dtheta = statedd_x = (u + m2*l*dtheta*dtheta + m2*g*np.sin(theta)*np.cos(theta)) / (m1 + m2*np.sin(theta)*np.sin(theta))dd_theta = (-dd_x*np.cos(theta) + dx*np.sin(theta)*dtheta - np.sin(theta)*(dx*dtheta + g)) / lreturn np.array([dx, dtheta, dd_x, dtheta])

2、四阶龙格库塔积分器和控制器更新率

# 四阶龙格库塔法函数
def RK4(t_start, t_end, fun, Npoints, init_state, u_list, pos_des, spd_des):t = np.linspace(t_start, t_end, Npoints)dt = t[1] - t[0]state = np.zeros((Npoints, len(init_state)))state[0, :] = init_statee = np.zeros((Npoints, 2))for i in range(Npoints-1):u_list[i] = u_list[i] + 1 * (spd_des[i] - state[i, 2])  # 闭环D型更新率u = u_list[i]e[i, 0] = pos_des[i] - state[i, 0]e[i, 1] = spd_des[i] - state[i, 2]k1 = fun(state[i, :], u)k2 = fun(state[i, :] + 0.5 * dt * k1, u)k3 = fun(state[i, :] + 0.5 * dt * k2, u)k4 = fun(state[i, :] + dt * k3, u)state[i + 1, :] = state[i, :] + (1/6) * dt * (k1 + 2 * k2 + 2 * k3 + k4)return state, u_list, e

3、进行迭代

for i in range(10):# 运行RK4state, u_list, e_buff = RK4(t_start, t_end, dynamics, Npoints, [0, 0, 0, 0], u_list, pos_des, spd_des)

4、完整代码和效果展示

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd# 动力学模型函数
def dynamics(state, u):x, theta, dx, dtheta = statedd_x = (u + m2*l*dtheta*dtheta + m2*g*np.sin(theta)*np.cos(theta)) / (m1 + m2*np.sin(theta)*np.sin(theta))dd_theta = (-dd_x*np.cos(theta) + dx*np.sin(theta)*dtheta - np.sin(theta)*(dx*dtheta + g)) / lreturn np.array([dx, dtheta, dd_x, dtheta])# 四阶龙格库塔法函数
def RK4(t_start, t_end, fun, Npoints, init_state, u_list, pos_des, spd_des):t = np.linspace(t_start, t_end, Npoints)dt = t[1] - t[0]state = np.zeros((Npoints, len(init_state)))state[0, :] = init_statee = np.zeros((Npoints, 2))for i in range(Npoints-1):u_list[i] = u_list[i] + 1 * (spd_des[i] - state[i, 2])  # 闭环D型更新率u = u_list[i]e[i, 0] = pos_des[i] - state[i, 0]e[i, 1] = spd_des[i] - state[i, 2]k1 = fun(state[i, :], u)k2 = fun(state[i, :] + 0.5 * dt * k1, u)k3 = fun(state[i, :] + 0.5 * dt * k2, u)k4 = fun(state[i, :] + dt * k3, u)state[i + 1, :] = state[i, :] + (1/6) * dt * (k1 + 2 * k2 + 2 * k3 + k4)return state, u_list, e# 参数设置
m1 = 5
m2 = 1
l = 1
g = 9.8t_start = 0
t_end = 10
Npoints = 10000
t = np.linspace(t_start, t_end, Npoints)# 期望位置和速度
pos_des = np.sin(t) + t
spd_des = np.cos(t) + 1pos_des = t * t + 2 * t
spd_des = 2 * t + 2# 初始状态和控制输入
u_list = [0] * 10000# 创建图形对象
plt.figure(figsize=(12, 12))for i in range(20):# 运行RK4state, u_list, e_buff = RK4(t_start, t_end, dynamics, Npoints, [0, 0, 0, 0], u_list, pos_des, spd_des)# 清除当前图像plt.clf()# 绘制实际位置和期望位置的对比图plt.subplot(3, 1, 1)plt.plot(t, state[:, 0], label='Actual x (position)')plt.plot(t, pos_des, label='Desired x (position)', linestyle='--')plt.xlabel('Time (s)')plt.ylabel('Position')plt.legend()plt.title(f'Iteration {i+1}')# 绘制实际速度和期望速度的对比图plt.subplot(3, 1, 2)plt.plot(t, state[:, 2], label='Actual dx (velocity)')plt.plot(t, spd_des, label='Desired dx (velocity)', linestyle='--')plt.xlabel('Time (s)')plt.ylabel('Velocity')plt.legend()# 绘制控制输入（力）曲线plt.subplot(3, 1, 3)plt.plot(t, u_list, label='Control input (force)')plt.xlabel('Time (s)')plt.ylabel('Force')plt.legend()# 显示图像plt.pause(0.01)# 最后显示图像
plt.show()# 将误差和力存储到CSV文件
data = np.hstack((e_buff, np.array(u_list).reshape(-1, 1)))
df = pd.DataFrame(data, columns=['Position Error', 'Velocity Error', 'Control Input'])
df.to_csv('error_and_force_data.csv', index=False)

5、实物效果

• 这个曲线不是上面仿真小车钟摆的实物测试，而是一个有一定质量的物体yaw轴回转的控制效果，展示的是位置曲线。这个物体受到不小的摩擦力，所以在开始迭代时开始和后来都会有停止不动的情况出现。同时，摩擦力也导致这个物体受到很大的干扰，就像小车钟摆的重物一样。

• 值得一提的是整个实物的算法测试过程非常顺利，在代码完成后，一次测试就成功了。使用的还是闭环D型迭代学习，经过三四次迭代就收敛到期望曲线附近了。这说明迭代学习还是一种很实用的算法。