实现了离散系统参数辨识（一阶和二阶模型）和广义预测控制（GPC），采用偏最小二乘（PLS）和递归最小二乘（RLS）方法进行参数估计。
matlab
%% 离散系统参数辨识与广义预测控制
% 描述: 实现一阶/二阶离散系统的参数辨识(PLS/RLS)和广义预测控制(GPC)
%% 主程序入口
function discreteSystemIdentificationAndControl()
% 清空环境
clear; close all; clc;
% 参数设置
params = struct();
params.modelOrder = 2; % 模型阶次: 1(一阶), 2(二阶)
params.method = 'RLS'; % 辨识方法: 'RLS', 'PLS'
params.forgettingFactor = 0.99; % 遗忘因子(RLS)
params.nu = 0.95; % 收缩参数(PLS)
params.lambda = 0.1; % 正则化参数(PLS)
params.predictionHorizon = 10; % 预测时域(GPC)
params.controlHorizon = 3; % 控制时域(GPC)
params.weightingFactor = 0.5; % 控制增量权重(GPC)
params.simulationTime = 100; % 仿真时间
params.noiseLevel = 0.05; % 噪声水平
params.showPlots = true; % 显示图形
params.saveResults = true; % 保存结果
% 系统参数(真实值)
params.trueTheta = [0.8; -0.3; 0.5; 0.2]; % [a1, a2, b1, b2]'
% 生成仿真数据
[u, y, t] = generateSystemData(params);
% 参数辨识
[thetaEst, errors] = identifySystem(u, y, params);
% 广义预测控制
[uCtrl, yCtrl] = generalizedPredictiveControl(thetaEst, params);
% 可视化结果
visualizeResults(u, y, t, thetaEst, errors, uCtrl, yCtrl, params);
% 保存结果
if params.saveResults
saveResults(u, y, t, thetaEst, errors, uCtrl, yCtrl, params);
end
end
%% 生成系统数据
function [u, y, t] = generateSystemData(params)
% 时间向量
t = 0:params.simulationTime-1;
N = length(t);
% 输入信号(伪随机二进制序列)
u = idinput(N, 'prbs', [0 0.5], [-1 1]);
% 初始条件
y = zeros(1, N);
y(1:params.modelOrder) = 0; % 初始输出设为0
% 系统参数
if params.modelOrder == 1
a1 = params.trueTheta(1);
b1 = params.trueTheta(2);
for k = 3:N
y(k) = -a1*y(k-1) + b1*u(k-1) + params.noiseLevel*randn;
end
else % 二阶系统
a1 = params.trueTheta(1);
a2 = params.trueTheta(2);
b1 = params.trueTheta(3);
b2 = params.trueTheta(4);
for k = 3:N
y(k) = -a1*y(k-1) - a2*y(k-2) + b1*u(k-1) + b2*u(k-2) + params.noiseLevel*randn;
end
end
end
%% 系统辨识
function [thetaEst, errors] = identifySystem(u, y, params)
N = length(y);
modelOrder = params.modelOrder;
% 初始化参数向量
if modelOrder == 1
thetaEst = zeros(2, 1); % [a1; b1]
else
thetaEst = zeros(4, 1); % [a1; a2; b1; b2]
end
% 初始化误差记录
errors = zeros(N, 1);
% 选择辨识方法
switch lower(params.method)
case 'rls'
[thetaEst, errors] = recursiveLeastSquares(u, y, thetaEst, params);
case 'pls'
[thetaEst, errors] = partialLeastSquares(u, y, thetaEst, params);
otherwise
error('未知辨识方法: %s', params.method);
end
end
%% 递归最小二乘(RLS)算法
function [thetaEst, errors] = recursiveLeastSquares(u, y, theta0, params)
N = length(y);
modelOrder = params.modelOrder;
% 初始化
thetaEst = theta0;
P = 1000 * eye(length(theta0)); % 协方差矩阵
lambda = params.forgettingFactor;
% 初始化回归向量
if modelOrder == 1
phi = zeros(2, 1); % [y(k-1); u(k-1)]
else
phi = zeros(4, 1); % [y(k-1); y(k-2); u(k-1); u(k-2)]
end
% 存储误差
errors = zeros(N, 1);
% RLS算法
for k = modelOrder+1:N
% 构造回归向量
if modelOrder == 1
phi = [-y(k-1); u(k-1)];
else
phi = [-y(k-1); -y(k-2); u(k-1); u(k-2)];
end
% 预测输出
yPred = phi' * thetaEst;
% 计算误差
errors(k) = y(k) - yPred;
% 更新增益
K = P * phi / (lambda + phi' * P * phi);
% 更新参数估计
thetaEst = thetaEst + K * errors(k);
% 更新协方差矩阵
P = (eye(length(theta0)) - K * phi') * P / lambda;
end
end
%% 偏最小二乘(PLS)算法
function [thetaEst, errors] = partialLeastSquares(u, y, theta0, params)
N = length(y);
modelOrder = params.modelOrder;
nu = params.nu; % 收缩参数
lambda = params.lambda; % 正则化参数
% 构造数据矩阵
X = [];
Y = y(modelOrder+1:end);
for k = modelOrder+1:N
if modelOrder == 1
row = [-y(k-1); u(k-1)];
else
row = [-y(k-1); -y(k-2); u(k-1); u(k-2)];
end
X = [X; row'];
end
% 添加常数项
X = [ones(size(X,1),1), X];
% PLS算法
[nSamples, nFeatures] = size(X);
thetaEst = zeros(nFeatures, 1);
% 初始化权重
w = ones(nFeatures, 1);
for iter = 1:100 % 最大迭代次数
% 计算梯度
residuals = Y - X * thetaEst;
gradient = -X' * residuals / nSamples;
% 更新权重
w = w - nu * gradient;
% 应用正则化
w = sign(w) .* max(0, abs(w) - lambda);
% 更新参数估计
thetaEst = w;
% 检查收敛
if norm(gradient) < 1e-6
break;
end
end
% 计算预测误差
YPred = X * thetaEst;
errors = [zeros(modelOrder,1); Y - YPred];
end
%% 广义预测控制(GPC)
function [uCtrl, yCtrl] = generalizedPredictiveControl(theta, params)
% 重新生成系统数据(使用辨识参数)
[u, y, t] = generateSystemData(struct('modelOrder', params.modelOrder, ...
'trueTheta', theta, 'simulationTime', params.simulationTime, ...
'noiseLevel', 0)); % 无噪声用于控制
N = length(t);
modelOrder = params.modelOrder;
% 初始化控制输入和输出
uCtrl = zeros(1, N);
yCtrl = zeros(1, N);
yCtrl(1:modelOrder) = y(1:modelOrder); % 初始条件
% GPC参数
Np = params.predictionHorizon; % 预测时域
Nu = params.controlHorizon; % 控制时域
lambda = params.weightingFactor; % 控制增量权重
% 构造回归矩阵
if modelOrder == 1
A = [1, -theta(1)]; % 分母系数
B = [0, theta(2)]; % 分子系数
else
A = [1, -theta(1), -theta(2)]; % 分母系数
B = [0, 0, theta(3), theta(4)]; % 分子系数
end
% GPC控制循环
for k = modelOrder+1:N-1
% 构造预测矩阵
Phi = zeros(Np, Nu);
for j = 1:Np
for i = 1:min(j, Nu)
if (j-i) < modelOrder
% 处理初始时刻
if (k+j-1) <= modelOrder
y_prev = 0;
else
y_prev = yCtrl(k+j-1-i);
end
else
y_prev = yCtrl(k+j-1-i);
end
if (j-i) == 0
u_prev = 0;
else
if (k+j-1-i) <= 0
u_prev = 0;
else
u_prev = uCtrl(k+j-1-i);
end
end
% 计算预测输出
if modelOrder == 1
Phi(j,i) = -A(2)*y_prev + B(3)*u_prev;
else
Phi(j,i) = -A(2)*y_prev - A(3)*yCtrl(max(1,k+j-1-(i+1))) + ...
B(3)*u_prev + B(4)*uCtrl(max(1,k+j-1-(i+1)));
end
end
end
% 构造目标函数
Q = eye(Np); % 输出权重矩阵
R = lambda * eye(Nu); % 控制增量权重矩阵
% 求解Diophantine方程(简化版)
U = inv(Phi'*Q*Phi + R) * Phi'*Q;
% 计算控制增量
du = U * (yCtrl(k) - yCtrl(k-1)*ones(Np,1)); % 简化目标
% 应用第一个控制增量
uCtrl(k) = uCtrl(k-1) + du(1);
% 应用输入约束(可选)
uCtrl(k) = max(-1, min(1, uCtrl(k))); % 限制在[-1,1]
% 更新系统输出
if modelOrder == 1
yCtrl(k+1) = -theta(1)*yCtrl(k) + theta(2)*uCtrl(k);
else
yCtrl(k+1) = -theta(1)*yCtrl(k) - theta(2)*yCtrl(k-1) + ...
theta(3)*uCtrl(k) + theta(4)*uCtrl(k-1);
end
end
end
%% 可视化结果
function visualizeResults(u, y, t, thetaEst, errors, uCtrl, yCtrl, params)
modelOrder = params.modelOrder;
trueTheta = params.trueTheta;
% 创建图形窗口
fig = figure('Name', '离散系统辨识与控制', 'NumberTitle', 'off', ...
'Position', [50, 50, 1400, 900]);
% 1. 系统响应与辨识结果
subplot(3, 2, 1);
plot(t, y, 'b-', 'LineWidth', 1.5);
hold on;
if modelOrder == 1
yEst = filter([thetaEst(2), 0], [1, thetaEst(1)], u);
else
yEst = filter([thetaEst(3), thetaEst(4), 0], [1, thetaEst(1), thetaEst(2)], u);
end
plot(t, yEst, 'r--', 'LineWidth', 1.5);
title('系统输出与辨识模型');
xlabel('时间步');
ylabel('输出');
legend('实际输出', '辨识模型输出', 'Location', 'best');
grid on;
% 2. 参数估计误差
subplot(3, 2, 2);
if modelOrder == 1
bar([trueTheta(1:2), thetaEst(1:2)]);
set(gca, 'XTickLabel', {'a1(真值)', 'b1(真值)', 'a1(估计)', 'b1(估计)'});
else
bar([trueTheta(1:4), thetaEst(1:4)]);
set(gca, 'XTickLabel', {'a1(真值)', 'a2(真值)', 'b1(真值)', 'b2(真值)', ...
'a1(估计)', 'a2(估计)', 'b1(估计)', 'b2(估计)'});
end
title('参数估计结果');
ylabel('参数值');
grid on;
% 3. 预测误差
subplot(3, 2, 3);
plot(t, errors, 'g-', 'LineWidth', 1.5);
title('预测误差');
xlabel('时间步');
ylabel('误差');
grid on;
% 4. 控制输入
subplot(3, 2, 4);
plot(t, u, 'b-', 'LineWidth', 1.5);
hold on;
plot(t, uCtrl, 'r--', 'LineWidth', 1.5);
title('控制输入');
xlabel('时间步');
ylabel('输入');
legend('开环输入', 'GPC控制输入', 'Location', 'best');
grid on;
% 5. 闭环系统响应
subplot(3, 2, 5);
plot(t, y, 'b-', 'LineWidth', 1.5);
hold on;
plot(t, yCtrl, 'r--', 'LineWidth', 1.5);
title('闭环系统响应');
xlabel('时间步');
ylabel('输出');
legend('开环响应', '闭环响应', 'Location', 'best');
grid on;
% 6. 控制性能分析
subplot(3, 2, 6);
if modelOrder == 1
perfMetric = sum((y - yCtrl).^2) / sum(y.^2);
else
perfMetric = sum((y - yCtrl).^2) / sum(y.^2);
end
text(0.1, 0.5, sprintf('控制性能指标: %.4f', perfMetric), 'FontSize', 12);
title('控制性能分析');
axis off);
% 添加整体标题
sgtitle(sprintf('离散系统辨识与控制 (%s模型, %s方法)', ...
modelOrder==1?'一阶':'二阶', upper(params.method)), 'FontSize', 16);
% 显示参数估计值
if modelOrder == 1
fprintf('\n===== 参数估计结果 =====\n');
fprintf('真实参数: a1 = %.4f, b1 = %.4f\n', trueTheta(1), trueTheta(2));
fprintf('估计参数: a1 = %.4f, b1 = %.4f\n', thetaEst(1), thetaEst(2));
fprintf('估计误差: |a1| = %.4f, |b1| = %.4f\n', ...
abs(trueTheta(1)-thetaEst(1)), abs(trueTheta(2)-thetaEst(2)));
else
fprintf('\n===== 参数估计结果 =====\n');
fprintf('真实参数: a1 = %.4f, a2 = %.4f, b1 = %.4f, b2 = %.4f\n', ...
trueTheta(1), trueTheta(2), trueTheta(3), trueTheta(4));
fprintf('估计参数: a1 = %.4f, a2 = %.4f, b1 = %.4f, b2 = %.4f\n', ...
thetaEst(1), thetaEst(2), thetaEst(3), thetaEst(4));
fprintf('估计误差: |a1| = %.4f, |a2| = %.4f, |b1| = %.4f, |b2| = %.4f\n', ...
abs(trueTheta(1)-thetaEst(1)), abs(trueTheta(2)-thetaEst(2)), ...
abs(trueTheta(3)-thetaEst(3)), abs(trueTheta(4)-thetaEst(4)));
end
end
%% 保存结果
function saveResults(u, y, t, thetaEst, errors, uCtrl, yCtrl, params)
% 创建结果结构体
results = struct();
results.params = params;
results.time = t;
results.input = u;
results.output = y;
results.thetaEst = thetaEst;
results.errors = errors;
results.uCtrl = uCtrl;
results.yCtrl = yCtrl;
% 保存为MAT文件
save('discrete_system_identification_results.mat', 'results');
% 导出CSV文件
data = [t', u', y', uCtrl', yCtrl', errors'];
header = {'Time', 'Input', 'Output', 'CtrlInput', 'CtrlOutput', 'Error'};
fid = fopen('discrete_system_data.csv', 'w');
fprintf(fid, '%s,', header{1:end-1});
fprintf(fid, '%s\n', header{end});
fclose(fid);
dlmwrite('discrete_system_data.csv', data, 'delimiter', ',', 'precision', 6, '-append');
fprintf('结果已保存:\n');
fprintf(' - discrete_system_identification_results.mat (MAT文件)\n');
fprintf(' - discrete_system_data.csv (CSV数据)\n');
end
%% 一阶系统演示
function firstOrderSystemDemo()
params = struct();
params.modelOrder = 1;
params.method = 'RLS';
params.forgettingFactor = 0.98;
params.predictionHorizon = 8;
params.controlHorizon = 2;
params.simulationTime = 80;
params.noiseLevel = 0.03;
params.showPlots = true;
% 系统参数
params.trueTheta = [-0.7; 0.4]; % [a1; b1]
% 运行主程序
[u, y, t] = generateSystemData(params);
[thetaEst, errors] = identifySystem(u, y, params);
[uCtrl, yCtrl] = generalizedPredictiveControl(thetaEst, params);
visualizeResults(u, y, t, thetaEst, errors, uCtrl, yCtrl, params);
end
%% 二阶系统演示
function secondOrderSystemDemo()
params = struct();
params.modelOrder = 2;
params.method = 'PLS';
params.nu = 0.9;
params.lambda = 0.05;
params.predictionHorizon = 12;
params.controlHorizon = 4;
params.simulationTime = 120;
params.noiseLevel = 0.08;
params.showPlots = true;
% 系统参数
params.trueTheta = [0.5; -0.2; 0.3; 0.1]; % [a1; a2; b1; b2]
% 运行主程序
[u, y, t] = generateSystemData(params);
[thetaEst, errors] = identifySystem(u, y, params);
[uCtrl, yCtrl] = generalizedPredictiveControl(thetaEst, params);
visualizeResults(u, y, t, thetaEst, errors, uCtrl, yCtrl, params);
end
%% 不同噪声水平下的鲁棒性测试
function robustnessTest()
noiseLevels = [0, 0.01, 0.05, 0.1, 0.2];
modelOrder = 2;
method = 'RLS';
results = struct();
for i = 1:length(noiseLevels)
params = struct();
params.modelOrder = modelOrder;
params.method = method;
params.forgettingFactor = 0.99;
params.predictionHorizon = 10;
params.controlHorizon = 3;
params.simulationTime = 100;
params.noiseLevel = noiseLevels(i);
params.trueTheta = [0.6; -0.3; 0.4; 0.2];
[u, y, t] = generateSystemData(params);
[thetaEst, errors] = identifySystem(u, y, params);
% 计算性能指标
mse = mean(errors.^2);
results(i).noiseLevel = noiseLevels(i);
results(i).mse = mse;
results(i).thetaError = norm(params.trueTheta - thetaEst);
end
% 可视化结果
figure;
subplot(1,2,1);
plot([results.noiseLevel], [results.mse], 'bo-', 'LineWidth', 2);
xlabel('噪声水平');
ylabel('均方误差(MSE)');
title('噪声对辨识精度的影响');
grid on;
subplot(1,2,2);
plot([results.noiseLevel], [results.thetaError], 'rs-', 'LineWidth', 2);
xlabel('噪声水平');
ylabel('参数估计误差范数');
title('噪声对参数估计的影响');
grid on;
end
%% 不同遗忘因子的RLS性能比较
function forgettingFactorComparison()
lambdaValues = [0.95, 0.97, 0.99, 0.995, 1.0];
modelOrder = 1;
results = struct();
for i = 1:length(lambdaValues)
params = struct();
params.modelOrder = modelOrder;
params.method = 'RLS';
params.forgettingFactor = lambdaValues(i);
params.predictionHorizon = 8;
params.controlHorizon = 2;
params.simulationTime = 100;
params.noiseLevel = 0.05;
params.trueTheta = [-0.6; 0.3];
[u, y, t] = generateSystemData(params);
[thetaEst, errors] = identifySystem(u, y, params);
% 计算性能指标
mse = mean(errors.^2);
results(i).lambda = lambdaValues(i);
results(i).mse = mse;
results(i).convergenceTime = find(errors < 0.1*max(errors), 1);
end
% 可视化结果
figure;
subplot(1,2,1);
plot([results.lambda], [results.mse], 'bo-', 'LineWidth', 2);
xlabel('遗忘因子(\lambda)');
ylabel('均方误差(MSE)');
title('遗忘因子对辨识精度的影响');
grid on;
subplot(1,2,2);
plot([results.lambda], [results.convergenceTime], 'rs-', 'LineWidth', 2);
xlabel('遗忘因子(\lambda)');
ylabel('收敛时间(步)');
title('遗忘因子对收敛速度的影响');
grid on;
end程序功能说明
1. 系统模型
-
一阶模型 ：
-
二阶模型 ：
2. 参数辨识方法
- 递归最小二乘(RLS) ：
- 使用遗忘因子处理时变系统
- 递推更新参数估计
- 协方差矩阵更新
- 偏最小二乘(PLS) ：
- 使用收缩参数和正则化
- 迭代优化参数估计
- 适用于共线性和噪声情况
3. 广义预测控制(GPC)
- 多步预测控制策略
- 控制时域和预测时域可调
- 控制增量加权
- 输入约束处理
4. 性能分析
- 参数估计误差计算
- 预测误差分析
- 控制性能指标评估
- 鲁棒性测试
参考代码 离散系统参数辨识 www.youwenfan.com/contentcst/96684.html
关键技术实现
1. 递归最小二乘(RLS)算法
matlab
function [thetaEst, errors] = recursiveLeastSquares(u, y, theta0, params)
% 初始化
thetaEst = theta0;
P = 1000 * eye(length(theta0));
lambda = params.forgettingFactor;
for k = modelOrder+1:N
% 构造回归向量
if modelOrder == 1
phi = [-y(k-1); u(k-1)];
else
phi = [-y(k-1); -y(k-2); u(k-1); u(k-2)];
end
% 预测输出
yPred = phi' * thetaEst;
% 计算误差
errors(k) = y(k) - yPred;
% 更新增益
K = P * phi / (lambda + phi' * P * phi);
% 更新参数估计
thetaEst = thetaEst + K * errors(k);
% 更新协方差矩阵
P = (eye(length(theta0)) - K * phi') * P / lambda;
end
end2. 偏最小二乘(PLS)算法
matlab
function [thetaEst, errors] = partialLeastSquares(u, y, theta0, params)
% 构造数据矩阵
X = [];
Y = y(modelOrder+1:end);
for k = modelOrder+1:N
if modelOrder == 1
row = [-y(k-1); u(k-1)];
else
row = [-y(k-1); -y(k-2); u(k-1); u(k-2)];
end
X = [X; row'];
end
% PLS算法
for iter = 1:100
% 计算梯度
residuals = Y - X * thetaEst;
gradient = -X' * residuals / nSamples;
% 更新权重
w = w - nu * gradient;
% 应用正则化
w = sign(w) .* max(0, abs(w) - lambda);
% 更新参数估计
thetaEst = w;
end
end3. 广义预测控制(GPC)
matlab
function [uCtrl, yCtrl] = generalizedPredictiveControl(theta, params)
% 构造预测矩阵
for j = 1:Np
for i = 1:min(j, Nu)
% 计算预测输出
if modelOrder == 1
Phi(j,i) = -A(2)*y_prev + B(3)*u_prev;
else
Phi(j,i) = -A(2)*y_prev - A(3)*y_prev2 + B(3)*u_prev + B(4)*u_prev2;
end
end
end
% 求解控制律
U = inv(Phi'*Q*Phi + R) * Phi'*Q;
du = U * (yCtrl(k) - yCtrl(k-1)*ones(Np,1));
% 应用控制增量
uCtrl(k) = uCtrl(k-1) + du(1);
% 更新系统输出
yCtrl(k+1) = -a1*yCtrl(k) - a2*yCtrl(k-1) + b1*uCtrl(k) + b2*uCtrl(k-1);
end算法原理与数学基础
1. 系统辨识模型
离散时间系统ARX模型：
其中：
2. 递归最小二乘(RLS)算法
参数更新方程：
增益矩阵：
协方差更新：
3. 偏最小二乘(PLS)算法
目标函数：
迭代更新：
其中J(θ)=∥Y−Xθ∥2+λ∥θ∥2J(θ)=∥Y−Xθ∥^2+λ∥θ∥^2J(θ)=∥Y−Xθ∥2+λ∥θ∥2
4. 广义预测控制(GPC)
预测方程：
Y=ΓU+ΦθY=ΓU+ΦθY=ΓU+Φθ
其中YYY是预测输出，UUU是控制序列
目标函数：
最优控制律：
使用说明
1. 基本使用
matlab
% 设置参数
params = struct();
params.modelOrder = 2; % 二阶系统
params.method = 'RLS'; % 使用RLS方法
params.forgettingFactor = 0.99; % 遗忘因子
params.simulationTime = 100; % 仿真时间
% 运行主程序
discreteSystemIdentificationAndControl();2. 参数调整指南
- 模型阶次：1(一阶)或2(二阶)
- 辨识方法：'RLS'或'PLS'
- RLS参数 ：
forgettingFactor：0.95~0.999(接近1表示长期记忆)
- PLS参数 ：
nu：收缩参数(0.8~0.99)lambda：正则化参数(0.01~0.1)
- GPC参数 ：
predictionHorizon：预测时域(5~20)controlHorizon：控制时域(2~5)weightingFactor：控制增量权重(0.1~1.0)
3. 运行演示程序
matlab
% 一阶系统演示
firstOrderSystemDemo();
% 二阶系统演示
secondOrderSystemDemo();
% 鲁棒性测试
robustnessTest();
% 遗忘因子比较
forgettingFactorComparison();扩展功能与应用
1. 多变量系统辨识
matlab
function [ThetaEst, Errors] = multivariableIdentification(U, Y, params)
% U: 输入矩阵(m×N)
% Y: 输出矩阵(p×N)
% ThetaEst: 参数矩阵(p×(m+n))
% 构造增广矩阵
X = [Y(:, 1:end-1); U(:, 1:end-1)];
% 使用PLS进行多变量辨识
ThetaEst = pls(X, Y(:, 2:end), params);
end2. 自适应GPC控制
matlab
function adaptiveGPC(u, y, thetaInit, params)
% 在线参数辨识
[thetaEst, ~] = identifySystem(u, y, params);
% 更新控制律
[uCtrl, yCtrl] = generalizedPredictiveControl(thetaEst, params);
% 自适应调整参数
if mean(abs(errors)) > threshold
params.forgettingFactor = max(0.95, params.forgettingFactor*0.99);
end
end3. 非线性系统扩展
matlab
function [thetaEst, errors] = nonlinearIdentification(u, y, params)
% 构造非线性特征
X = [u, u.^2, u.*y, y.^2, lagmatrix(y,1:2), lagmatrix(u,1:2)];
% 使用PLS进行非线性辨识
thetaEst = pls(X, y(params.modelOrder+1:end), params);
end4. 模型验证与残差分析
matlab
function validateModel(u, y, thetaEst, params)
% 计算预测输出
yPred = predictOutput(u, thetaEst, params);
% 残差分析
residuals = y - yPred;
% 自相关检验
autocorr(residuals(10:end)); % 忽略初始瞬态
% 互相关检验
crosscorr(residuals(10:end), u(10:end));
% 正态性检验
normplot(residuals);
end常见问题
- 参数发散 ：
- 减小遗忘因子
- 增加正则化强度
- 检查输入信号激励性
- 辨识精度低 ：
- 增加仿真时间
- 提高输入信号幅度
- 尝试不同辨识方法
- 控制性能差 ：
- 调整预测时域和控制时域
- 增加控制增量权重
- 检查模型准确性
- 数值不稳定 ：
- 添加微小扰动防止除零
- 使用双精度浮点数
- 定期重置协方差矩阵
应用建议
- 工业过程控制 ：
- 温度控制系统
- 压力调节系统
- 流量控制系统
- 机器人控制 ：
- 关节位置控制
- 轨迹跟踪控制
- 柔顺控制
- 电力系统 ：
- 发电机励磁控制
- 电网频率调节
- 无功补偿控制
- 航空航天 ：
- 飞行器姿态控制
- 发动机推力控制
- 导航系统校正
总结
本程序实现了离散系统参数辨识（一阶和二阶模型）和广义预测控制（GPC），具有以下特点：
- 双辨识方法：支持递归最小二乘（RLS）和偏最小二乘（PLS）两种算法
- 完整控制回路：包含系统生成、参数辨识、控制器设计和性能评估
- 灵活的参数配置：可调整模型阶次、辨识方法和控制参数
- 全面的性能分析：提供参数误差、预测误差和控制性能指标
- 丰富的演示案例：包含一阶/二阶系统演示和鲁棒性测试