信号与系统仿真：系统辨识与建模_（13）.多输入多输出系统的建模与辨识

多输入多输出系统的建模与辨识

1. 多输入多输出系统的基本概念

多输入多输出（Multiple-Input Multiple-Output, MIMO）系统是指具有多个输入和多个输出的系统。在信号处理和控制系统中，MIMO系统的研究和应用日益广泛，尤其是在无线通信、控制工程、生物医学工程等领域。MIMO系统可以更有效地利用资源，提高系统的性能和稳定性。

1.1 MIMO系统的数学表示

MIMO系统的数学表示通常采用矩阵形式。假设系统有 $m$ 个输入和 $n$ 个输出，系统的输入向量和输出向量可以分别表示为：

u ( t ) = [ u 1 ( t ) u 2 ( t ) ⋮ u m ( t ) ] \mathbf{u}(t) = \begin{bmatrix} u_1(t) \\ u_2(t) \\ \vdots \\ u_m(t) \end{bmatrix} u(t)= ​u1​(t)u2​(t)⋮um​(t)​ ​
y ( t ) = [ y 1 ( t ) y 2 ( t ) ⋮ y n ( t ) ] \mathbf{y}(t) = \begin{bmatrix} y_1(t) \\ y_2(t) \\ \vdots \\ y_n(t) \end{bmatrix} y(t)= ​y1​(t)y2​(t)⋮yn​(t)​ ​

系统的状态方程可以表示为：

$$\dot{\mathbf{x}}(t)=\mathbf{Ax}(t)+\mathbf{Bu}(t)$$
$$\mathbf{y}(t)=\mathbf{Cx}(t)+\mathbf{Du}(t)$$

其中：

• $\mathbf{x}(t)$是状态向量。
• $\mathbf{A}$是系统矩阵。
• $\mathbf{B}$是输入矩阵。
• $\mathbf{C}$是输出矩阵。
• $\mathbf{D}$是直接传递矩阵。

1.2 MIMO系统的特性

MIMO系统的特性主要包括：

• 输入输出关系复杂：由于存在多个输入和输出，系统的输入输出关系更加复杂，需要考虑各个输入对各个输出的影响。
• 资源利用率高：MIMO系统可以同时处理多个输入信号，提高资源利用率和系统性能。
• 抗干扰能力强：通过多路径传输和多天线技术，MIMO系统可以有效抗干扰，提高信号传输的可靠性。

1.3 MIMO系统在实际中的应用

MIMO系统在实际中的应用非常广泛，例如：

• 无线通信：在多天线通信系统中，MIMO技术可以显著提高数据传输速率和可靠性。
• 控制系统：在多变量控制系统中，MIMO系统可以同时控制多个变量，提高系统的稳定性和响应速度。
• 信号处理：在多通道信号处理中，MIMO系统可以有效地处理和分析多个信号源的数据。

2. MIMO系统的建模方法

2.1 状态空间建模

状态空间建模是MIMO系统建模的一种常用方法。通过状态空间方程，可以描述系统的动态行为和输入输出关系。状态空间模型的一般形式为：

$$\dot{\mathbf{x}}(t)=\mathbf{Ax}(t)+\mathbf{Bu}(t)$$
$$\mathbf{y}(t)=\mathbf{Cx}(t)+\mathbf{Du}(t)$$

2.2 传递函数建模

传递函数建模是另一种常用的MIMO系统建模方法。传递函数矩阵 $\mathbf{G}(s)$ 可以描述系统的频率特性。传递函数矩阵的一般形式为：

$$\mathbf{G}(s)=\mathbf{C}(s\mathbf{I}-\mathbf{A}{)}^{-1}\mathbf{B}+\mathbf{D}$$

2.3 数据驱动建模

数据驱动建模方法是通过系统的输入输出数据来建立模型。常用的数据驱动建模方法包括：

• 最小二乘法：通过最小化输入输出数据的误差平方和来估计模型参数。
• 子空间建模：通过子空间方法来估计系统的状态矩阵和输入矩阵。

2.4 建模方法的选择

选择合适的建模方法取决于系统的特性和应用场景。状态空间建模适用于描述系统的动态行为，传递函数建模适用于频率特性分析，数据驱动建模适用于系统参数未知的情况。

3. MIMO系统的辨识方法

3.1 最小二乘法辨识

最小二乘法是一种常用的数据驱动辨识方法。通过最小化输入输出数据的误差平方和来估计系统的参数。假设系统的输入输出数据为 $\mathbf{u}(t)$和 $\mathbf{y}(t)$，系统的状态空间模型为：

$$\dot{\mathbf{x}}(t)=\mathbf{Ax}(t)+\mathbf{Bu}(t)$$
$$\mathbf{y}(t)=\mathbf{Cx}(t)+\mathbf{Du}(t)$$

最小二乘法的基本原理是通过优化问题来估计参数 $\mathbf{A}$、$\mathbf{B}$、$\mathbf{C}$和 $\mathbf{D}$。

3.2 子空间辨识

子空间辨识方法是一种基于子空间的数据驱动辨识方法。通过将数据分解为不同的子空间，可以有效地估计系统的参数。子空间辨识方法的基本步骤包括：

• 数据预处理：对输入输出数据进行预处理，例如去除噪声和趋势。
• 子空间分解：将数据分解为状态子空间和输入子空间。
• 参数估计：通过子空间分解的结果来估计系统的状态矩阵和输入矩阵。

3.3 辨识方法的选择

选择合适的辨识方法取决于系统的特性和数据的可用性。最小二乘法适用于参数估计问题，子空间辨识方法适用于系统参数未知但数据丰富的场景。

4. MIMO系统的仿真与分析

4.1 仿真工具

常用的MIMO系统仿真工具包括：

• MATLAB：提供强大的矩阵运算和控制系统工具箱。
• Simulink：MATLAB的仿真环境，可以方便地搭建和仿真复杂的MIMO系统。
• Python：使用NumPy和SciPy库可以进行矩阵运算和控制系统仿真。

4.2 仿真步骤

MIMO系统的仿真步骤通常包括：

1. 模型建立：根据系统特性选择合适的建模方法，建立系统的状态空间模型或传递函数模型。
2. 输入信号设计：设计输入信号，例如阶跃信号、正弦信号或随机信号。
3. 仿真运行：在仿真工具中运行模型，获取系统的输出信号。
4. 结果分析：对仿真结果进行分析，验证模型的准确性和性能。

4.3 仿真实例

4.3.1 MATLAB仿真

以下是一个使用MATLAB进行MIMO系统仿真的实例。假设系统为一个2输入2输出的线性系统，状态空间模型为：

$$\dot{\mathbf{x}}(t)=\left[\begin{array}{cc}-1& 1\\ 0& -2\end{array}\right]\mathbf{x}(t)+\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right]\mathbf{u}(t)$$
$$\mathbf{y}(t)=\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right]\mathbf{x}(t)+\left[\begin{array}{cc}0& 0\\ 0& 0\end{array}\right]\mathbf{u}(t)$$

% 定义系统矩阵
A = [-1 1; 0 -2];
B = [1 0; 0 1];
C = [1 0; 0 1];
D = [0 0; 0 0];

% 创建系统模型
sys = ss(A, B, C, D);

% 定义输入信号
t = 0:0.01:10; % 时间向量
u1 = sin(t); % 输入1
u2 = cos(t); % 输入2
u = [u1; u2]; % 输入向量

% 进行仿真
[y, t, x] = lsim(sys, u, t);

% 绘制输出信号
figure;
subplot(2, 1, 1);
plot(t, y(1, :));
title('输出1');
xlabel('时间 (s)');
ylabel('y1(t)');

subplot(2, 1, 2);
plot(t, y(2, :));
title('输出2');
xlabel('时间 (s)');
ylabel('y2(t)');

4.3.2 Python仿真

以下是一个使用Python进行MIMO系统仿真的实例。假设系统为一个2输入2输出的线性系统，状态空间模型为：

$$\dot{\mathbf{x}}(t)=\left[\begin{array}{cc}-1& 1\\ 0& -2\end{array}\right]\mathbf{x}(t)+\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right]\mathbf{u}(t)$$
$$\mathbf{y}(t)=\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right]\mathbf{x}(t)+\left[\begin{array}{cc}0& 0\\ 0& 0\end{array}\right]\mathbf{u}(t)$$

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint

# 定义系统矩阵
A = np.array([[-1, 1], [0, -2]])
B = np.array([[1, 0], [0, 1]])
C = np.array([[1, 0], [0, 1]])
D = np.array([[0, 0], [0, 0]])

# 系统状态方程
def state_eq(x, t, u):
    dxdt = np.dot(A, x) + np.dot(B, u(t))
    return dxdt

# 定义输入信号
def u(t):
    return np.array([np.sin(t), np.cos(t)])

# 初始状态
x0 = np.array([0, 0])

# 时间向量
t = np.linspace(0, 10, 1000)

# 进行仿真
x = odeint(state_eq, x0, t, args=(u,))

# 计算输出信号
y = np.dot(C, x.T) + np.dot(D, u(t).T)

# 绘制输出信号
plt.figure()
plt.subplot(2, 1, 1)
plt.plot(t, y[0, :])
plt.title('输出1')
plt.xlabel('时间 (s)')
plt.ylabel('y1(t)')

plt.subplot(2, 1, 2)
plt.plot(t, y[1, :])
plt.title('输出2')
plt.xlabel('时间 (s)')
plt.ylabel('y2(t)')

plt.tight_layout()
plt.show()

4.4 仿真结果分析

仿真结果可以帮助我们验证系统的模型是否准确。通过比较仿真输出和实际输出，可以评估模型的性能。例如，可以计算输出信号的均方误差（MSE）来评估模型的准确性。

% 计算均方误差
actual_y1 = sin(t); % 假设实际输出1为sin(t)
actual_y2 = cos(t); % 假设实际输出2为cos(t)
MSE1 = mean((y(1, :) - actual_y1).^2);
MSE2 = mean((y(2, :) - actual_y2).^2);

disp(['输出1的均方误差: ', num2str(MSE1)]);
disp(['输出2的均方误差: ', num2str(MSE2)]);

# 计算均方误差
actual_y1 = np.sin(t)  # 假设实际输出1为sin(t)
actual_y2 = np.cos(t)  # 假设实际输出2为cos(t)
MSE1 = np.mean((y[0, :] - actual_y1)**2)
MSE2 = np.mean((y[1, :] - actual_y2)**2)

print(f'输出1的均方误差: {MSE1}')
print(f'输出2的均方误差: {MSE2}')

4.5 仿真优化

在仿真过程中，可以通过调整系统参数、输入信号或仿真步长来优化仿真结果。例如，可以通过增加输入信号的频率来测试系统的响应速度。

% 增加输入信号的频率
u1 = sin(2 * t); % 输入1
u2 = cos(2 * t); % 输入2
u = [u1; u2]; % 输入向量

% 重新进行仿真
[y, t, x] = lsim(sys, u, t);

% 绘制新的输出信号
figure;
subplot(2, 1, 1);
plot(t, y(1, :));
title('输出1 (频率增加)');
xlabel('时间 (s)');
ylabel('y1(t)');

subplot(2, 1, 2);
plot(t, y(2, :));
title('输出2 (频率增加)');
xlabel('时间 (s)');
ylabel('y2(t)');

# 增加输入信号的频率
def u(t):
    return np.array([np.sin(2 * t), np.cos(2 * t)])

# 重新进行仿真
x = odeint(state_eq, x0, t, args=(u,))
y = np.dot(C, x.T) + np.dot(D, u(t).T)

# 绘制新的输出信号
plt.figure()
plt.subplot(2, 1, 1)
plt.plot(t, y[0, :])
plt.title('输出1 (频率增加)')
plt.xlabel('时间 (s)')
plt.ylabel('y1(t)')

plt.subplot(2, 1, 2)
plt.plot(t, y[1, :])
plt.title('输出2 (频率增加)')
plt.xlabel('时间 (s)')
plt.ylabel('y2(t)')

plt.tight_layout()
plt.show()

4.6 仿真案例分析

通过仿真案例分析，可以更好地理解MIMO系统的特性和性能。例如，可以通过仿真一个无线通信系统的MIMO信道来分析不同输入信号对输出信号的影响。

% 无线通信系统的MIMO信道模型
A = [0 0; 0 0];
B = [1 0; 0 1];
C = [1 0; 0 1];
D = [0 0; 0 0];

% 创建系统模型
sys = ss(A, B, C, D);

% 定义输入信号
t = 0:0.01:10; % 时间向量
u1 = sin(2 * pi * 1 * t); % 输入1
u2 = cos(2 * pi * 2 * t); % 输入2
u = [u1; u2]; % 输入向量

% 进行仿真
[y, t, x] = lsim(sys, u, t);

% 绘制输出信号
figure;
subplot(2, 1, 1);
plot(t, y(1, :));
title('输出1');
xlabel('时间 (s)');
ylabel('y1(t)');

subplot(2, 1, 2);
plot(t, y(2, :));
title('输出2');
xlabel('时间 (s)');
ylabel('y2(t)');

# 无线通信系统的MIMO信道模型
A = np.array([[0, 0], [0, 0]])
B = np.array([[1, 0], [0, 1]])
C = np.array([[1, 0], [0, 1]])
D = np.array([[0, 0], [0, 0]])

# 系统状态方程
def state_eq(x, t, u):
    dxdt = np.dot(A, x) + np.dot(B, u(t))
    return dxdt

# 定义输入信号
def u(t):
    return np.array([np.sin(2 * np.pi * 1 * t), np.cos(2 * np.pi * 2 * t)])

# 初始状态
x0 = np.array([0, 0])

# 时间向量
t = np.linspace(0, 10, 1000)

# 进行仿真
x = odeint(state_eq, x0, t, args=(u,))
y = np.dot(C, x.T) + np.dot(D, u(t).T)

# 绘制输出信号
plt.figure()
plt.subplot(2, 1, 1)
plt.plot(t, y[0, :])
plt.title('输出1')
plt.xlabel('时间 (s)')
plt.ylabel('y1(t)')

plt.subplot(2, 1, 2)
plt.plot(t, y[1, :])
plt.title('输出2')
plt.xlabel('时间 (s)')
plt.ylabel('y2(t)')

plt.tight_layout()
plt.show()

4.7 仿真工具的比较

不同的仿真工具在功能和性能上有所差异。MATLAB和Simulink提供了强大的矩阵运算和控制系统工具箱，适合复杂的MIMO系统仿真。Python则更加灵活，适合自定义仿真和数据分析。

4.8 仿真中的常见问题

在MIMO系统仿真中，常见的问题包括：

• 数值稳定性：仿真过程中可能会出现数值不稳定的情况，需要选择合适的仿真步长和数值方法。
• 模型误差：模型参数的误差会影响仿真结果，需要通过辨识方法来减少模型误差。
• 噪声影响：输入输出数据中的噪声会影响仿真结果，需要进行数据预处理。

4.9 仿真优化方法

为了提高MIMO系统的仿真性能，可以采用以下优化方法：

• 调整仿真步长：选择合适的仿真步长可以提高仿真精度。
• 使用高效的数值方法：例如，使用龙格-库塔方法来提高数值稳定性。
• 模型参数优化：通过辨识方法来优化模型参数，提高模型的准确性。

5. MIMO系统的辨识与建模实例

5. MIMO系统的辨识与建模实例

在前面的章节中，我们已经介绍了多输入多输出（MIMO）系统的基本概念、数学表示、建模方法和辨识方法。MIMO系统在实际应用中非常广泛，因此通过具体的实例来理解这些概念和方法是非常重要的。本章将通过一个具体的MIMO系统实例，详细介绍如何进行建模和辨识，并分析仿真结果。

5.1 实例背景

假设我们有一个2输入2输出的控制系统，该系统用于控制一个双输入双输出的机械臂。机械臂的动态行为可以用状态空间模型来描述。系统的输入为两个关节的控制信号，输出为两个关节的位置。

5.2 系统模型

系统的状态空间模型为：

$$\dot{\mathbf{x}}(t)=\mathbf{Ax}(t)+\mathbf{Bu}(t)$$
$$\mathbf{y}(t)=\mathbf{Cx}(t)+\mathbf{Du}(t)$$

其中：

• $\mathbf{x}(t)$是状态向量，包含机械臂的关节角度和角速度。
• $\mathbf{A}$是系统矩阵，描述系统的动态行为。
• $\mathbf{B}$是输入矩阵，描述输入信号对系统状态的影响。
• $\mathbf{C}$是输出矩阵，描述系统状态对输出的影响。
• $\mathbf{D}$是直接传递矩阵，假设在本例中为零矩阵。

具体参数如下：

• A = [ 0 1 0 0 − 10 − 2 0 0 0 0 0 1 0 0 − 10 − 2 ] \mathbf{A} = \begin{bmatrix} 0 & 1 & 0 & 0 \\ -10 & -2 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & -10 & -2 \end{bmatrix} A= ​0−1000​1−200​000−10​001−2​ ​
• B = [ 0 0 1 0 0 0 0 1 ] \mathbf{B} = \begin{bmatrix} 0 & 0 \\ 1 & 0 \\ 0 & 0 \\ 0 & 1 \end{bmatrix} B= ​0100​0001​ ​
• $\mathbf{C}=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& 1& 0\end{array}\right]$
• $\mathbf{D}=\left[\begin{array}{cc}0& 0\\ 0& 0\end{array}\right]$

5.3 系统建模

5.3.1 状态空间建模

首先，我们使用状态空间建模方法来描述这个系统。在MATLAB中，可以定义如下：

% 定义系统矩阵
A = [0 1 0 0; -10 -2 0 0; 0 0 0 1; 0 0 -10 -2];
B = [0 0; 1 0; 0 0; 0 1];
C = [1 0 0 0; 0 0 1 0];
D = [0 0; 0 0];

% 创建系统模型
sys = ss(A, B, C, D);

% 定义输入信号
t = 0:0.01:10; % 时间向量
u1 = sin(t); % 输入1
u2 = cos(t); % 输入2
u = [u1; u2]; % 输入向量

% 进行仿真
[y, t, x] = lsim(sys, u, t);

% 绘制输出信号
figure;
subplot(2, 1, 1);
plot(t, y(1, :));
title('输出1 (关节1位置)');
xlabel('时间 (s)');
ylabel('y1(t)');

subplot(2, 1, 2);
plot(t, y(2, :));
title('输出2 (关节2位置)');
xlabel('时间 (s)');
ylabel('y2(t)');

在Python中，可以定义如下：

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint

# 定义系统矩阵
A = np.array([[0, 1, 0, 0], [-10, -2, 0, 0], [0, 0, 0, 1], [0, 0, -10, -2]])
B = np.array([[0, 0], [1, 0], [0, 0], [0, 1]])
C = np.array([[1, 0, 0, 0], [0, 0, 1, 0]])
D = np.array([[0, 0], [0, 0]])

# 系统状态方程
def state_eq(x, t, u):
    dxdt = np.dot(A, x) + np.dot(B, u(t))
    return dxdt

# 定义输入信号
def u(t):
    return np.array([np.sin(t), np.cos(t)])

# 初始状态
x0 = np.array([0, 0, 0, 0])

# 时间向量
t = np.linspace(0, 10, 1000)

# 进行仿真
x = odeint(state_eq, x0, t, args=(u,))

# 计算输出信号
y = np.dot(C, x.T) + np.dot(D, u(t).T)

# 绘制输出信号
plt.figure()
plt.subplot(2, 1, 1)
plt.plot(t, y[0, :])
plt.title('输出1 (关节1位置)')
plt.xlabel('时间 (s)')
plt.ylabel('y1(t)')

plt.subplot(2, 1, 2)
plt.plot(t, y[1, :])
plt.title('输出2 (关节2位置)')
plt.xlabel('时间 (s)')
plt.ylabel('y2(t)')

plt.tight_layout()
plt.show()

5.4 系统辨识

5.4.1 最小二乘法辨识

假设我们有一组输入输出数据，可以通过最小二乘法来辨识系统的参数。以下是MATLAB中的实现：

% 生成输入输出数据
t = 0:0.01:10; % 时间向量
u1 = sin(t); % 输入1
u2 = cos(t); % 输入2
u = [u1; u2]; % 输入向量

% 假设已知系统的实际输出
actual_y1 = sin(t); % 实际输出1
actual_y2 = cos(t); % 实际输出2
actual_y = [actual_y1; actual_y2]; % 实际输出向量

% 初始化参数
A_est = zeros(4, 4);
B_est = zeros(4, 2);
C_est = zeros(2, 4);
D_est = zeros(2, 2);

% 定义状态向量
x = zeros(4, length(t));

% 使用最小二乘法进行参数估计
for i = 2:length(t)
    x(:, i) = x(:, i-1) + (A * x(:, i-1) + B * u(:, i-1)) * (t(i) - t(i-1));
end

% 构建数据矩阵
U = [u(:, 1:end-1) u(:, 1:end-1)];
X = [x(:, 1:end-1) u(:, 1:end-1)];
Y = [actual_y(:, 2:end) actual_y(:, 2:end)];

% 进行最小二乘法估计
theta = (pinv([X; U]) * [Y; Y]);

% 提取估计参数
A_est = theta(1:4, 1:4);
B_est = theta(1:4, 5:6);
C_est = theta(5:6, 1:4);
D_est = theta(5:6, 5:6);

% 创建辨识后的系统模型
sys_est = ss(A_est, B_est, C_est, D_est);

% 进行仿真
[y_est, t, x_est] = lsim(sys_est, u, t);

% 绘制实际输出和辨识输出
figure;
subplot(2, 1, 1);
plot(t, actual_y1, 'b', t, y_est(1, :), 'r--');
title('输出1 (关节1位置)');
xlabel('时间 (s)');
ylabel('y1(t)');
legend('实际输出', '辨识输出');

subplot(2, 1, 2);
plot(t, actual_y2, 'b', t, y_est(2, :), 'r--');
title('输出2 (关节2位置)');
xlabel('时间 (s)');
ylabel('y2(t)');
legend('实际输出', '辨识输出');

在Python中，可以实现如下：

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint
from scipy.linalg import pinv

# 生成输入输出数据
t = np.linspace(0, 10, 1000)
u1 = np.sin(t)  # 输入1
u2 = np.cos(t)  # 输入2
u = np.vstack((u1, u2))  # 输入向量

# 假设已知系统的实际输出
actual_y1 = np.sin(t)  # 实际输出1
actual_y2 = np.cos(t)  # 实际输出2
actual_y = np.vstack((actual_y1, actual_y2))  # 实际输出向量

# 初始化参数
A_est = np.zeros((4, 4))
B_est = np.zeros((4, 2))
C_est = np.zeros((2, 4))
D_est = np.zeros((2, 2))

# 初始状态
x0 = np.array([0, 0, 0, 0])

# 使用最小二乘法进行参数估计
def state_eq(x, t, u):
    dxdt = np.dot(A, x) + np.dot(B, u(t))
    return dxdt

x = odeint(state_eq, x0, t, args=(u,))

# 构建数据矩阵
U = np.hstack((u[:, :-1], u[:, :-1]))
X = np.hstack((x[:, :-1], u[:, :-1]))
Y = np.hstack((actual_y[:, 1:], actual_y[:, 1:]))

# 进行最小二乘法估计
theta = np.dot(pinv(np.vstack((X, U))), np.vstack((Y, Y)))

# 提取估计参数
A_est = theta[:4, :4]
B_est = theta[:4, 4:6]
C_est = theta[4:6, :4]
D_est = theta[4:6, 4:6]

# 创建辨识后的系统模型
def state_eq_est(x, t, u):
    dxdt = np.dot(A_est, x) + np.dot(B_est, u(t))
    return dxdt

x_est = odeint(state_eq_est, x0, t, args=(u,))
y_est = np.dot(C_est, x_est.T) + np.dot(D_est, u(t).T)

# 绘制实际输出和辨识输出
plt.figure()
plt.subplot(2, 1, 1)
plt.plot(t, actual_y1, 'b', t, y_est[0, :], 'r--')
plt.title('输出1 (关节1位置)')
plt.xlabel('时间 (s)')
plt.ylabel('y1(t)')
plt.legend(['实际输出', '辨识输出'])

plt.subplot(2, 1, 2)
plt.plot(t, actual_y2, 'b', t, y_est[1, :], 'r--')
plt.title('输出2 (关节2位置)')
plt.xlabel('时间 (s)')
plt.ylabel('y2(t)')
plt.legend(['实际输出', '辨识输出'])

plt.tight_layout()
plt.show()

5.4.2 子空间辨识

子空间辨识方法通过将数据分解为不同的子空间来估计系统的参数。以下是MATLAB中的实现：

% 生成输入输出数据
t = 0:0.01:10; % 时间向量
u1 = sin(t); % 输入1
u2 = cos(t); % 输入2
u = [u1; u2]; % 输入向量

% 假设已知系统的实际输出
actual_y1 = sin(t); % 实际输出1
actual_y2 = cos(t); % 实际输出2
actual_y = [actual_y1; actual_y2]; % 实际输出向量

% 数据预处理
u = u - mean(u);
actual_y = actual_y - mean(actual_y);

% 子空间分解
n = 2; % 系统阶数
Y1 = actual_y(:, 1:end-n);
Y2 = actual_y(:, n+1:end);
U1 = u(:, 1:end-n);
U2 = u(:, n+1:end);

% 构建Hankel矩阵
H = [Y1; U1] * pinv([Y2; U2]);

% 提取系统矩阵
A_est = H(1:n, 1:n);
B_est = H(1:n, n+1:end);
C_est = H(n+1:end, 1:n);
D_est = H(n+1:end, n+1:end);

% 创建辨识后的系统模型
sys_est = ss(A_est, B_est, C_est, D_est);

% 进行仿真
[y_est, t, x_est] = lsim(sys_est, u, t);

% 绘制实际输出和辨识输出
figure;
subplot(2, 1, 1);
plot(t, actual_y1, 'b', t, y_est(1, :), 'r--');
title('输出1 (关节1位置)');
xlabel('时间 (s)');
ylabel('y1(t)');
legend('实际输出', '辨识输出');

subplot(2, 1, 2);
plot(t, actual_y2, 'b', t, y_est(2, :), 'r--');
title('输出2 (关节2位置)');
xlabel('时间 (s)');
ylabel('y2(t)');
legend('实际输出', '辨识输出');

在Python中，可以实现如下：

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint
from scipy.linalg import pinv

# 生成输入输出数据
t = np.linspace(0, 10, 1000)
u1 = np.sin(t)  # 输入1
u2 = np.cos(t)  # 输入2
u = np.vstack((u1, u2))  # 输入向量

# 假设已知系统的实际输出
actual_y1 = np.sin(t)  # 实际输出1
actual_y2 = np.cos(t)  # 实际输出2
actual_y = np.vstack((actual_y1, actual_y2))  # 实际输出向量

# 数据预处理
u = u - np.mean(u, axis=1, keepdims=True)
actual_y = actual_y - np.mean(actual_y, axis=1, keepdims=True)

# 子空间分解
n = 2  # 系统阶数
Y1 = actual_y[:, :-n]
Y2 = actual_y[:, n:]
U1 = u[:, :-n]
U2 = u[:, n:]

# 构建Hankel矩阵
H = np.dot(np.vstack((Y1, U1)), pinv(np.vstack((Y2, U2))))

# 提取系统矩阵
A_est = H[:n, :n]
B_est = H[:n, n:2*n]
C_est = H[n:2*n, :n]
D_est = H[n:2*n, n:2*n]

# 创建辨识后的系统模型
def state_eq_est(x, t, u):
    dxdt = np.dot(A_est, x) + np.dot(B_est, u(t))
    return dxdt

x0 = np.array([0, 0, 0, 0])
x_est = odeint(state_eq_est, x0, t, args=(u,))
y_est = np.dot(C_est, x_est.T) + np.dot(D_est, u(t).T)

# 绘制实际输出和辨识输出
plt.figure()
plt.subplot(2, 1, 1)
plt.plot(t, actual_y1, 'b', t, y_est[0, :], 'r--')
plt.title('输出1 (关节1位置)')
plt.xlabel('时间 (s)')
plt.ylabel('y1(t)')
plt.legend(['实际输出', '辨识输出'])

plt.subplot(2, 1, 2)
plt.plot(t, actual_y2, 'b', t, y_est[1, :], 'r--')
plt.title('输出2 (关节2位置)')
plt.xlabel('时间 (s)')
plt.ylabel('y2(t)')
plt.legend(['实际输出', '辨识输出'])

plt.tight_layout()
plt.show()

5.5 辨识结果分析

通过比较实际输出和辨识输出，可以评估辨识方法的准确性。可以使用均方误差（MSE）来量化误差。

% 计算均方误差
MSE1 = mean((actual_y1 - y_est(1, :)).^2);
MSE2 = mean((actual_y2 - y_est(2, :)).^2);

disp(['输出1的均方误差: ', num2str(MSE1)]);
disp(['输出2的均方误差: ', num2str(MSE2)]);

# 计算均方误差
MSE1 = np.mean((actual_y1 - y_est[0, :])**2)
MSE2 = np.mean((actual_y2 - y_est[1, :])**2)

print(f'输出1的均方误差: {MSE1}')
print(f'输出2的均方误差: {MSE2}')

5.6 优化与改进

在实际应用中，可以通过以下方法来优化和改进MIMO系统的建模和辨识：

• 增加数据量：更多的数据可以提高辨识的准确性。
• 使用先进的辨识算法：例如，递归最小二乘法（RLS）或卡尔曼滤波器。
• 模型结构选择：选择合适的模型结构可以更好地描述系统的动态行为。
• 噪声处理：通过滤波或去噪技术来减少噪声对辨识结果的影响。

5.7 结论

通过本章的实例，我们详细介绍了如何对一个2输入2输出的控制系统进行建模和辨识，并分析了仿真结果。