【Matlab】基于粒子群优化算法优化BP神经网络的时间序列预测（Excel可直接替换数据）
- 1.模型原理
- 2.数学公式
- 3.文件结构
- 4.Excel数据
- 5.分块代码
- 5.1 fun.m
- 5.2 main.m
- 6.完整代码
- 6.1 fun.m
- 6.2 main.m
- 7.运行结果
1.模型原理
基于粒子群优化算法（Particle Swarm Optimization, PSO）优化BP神经网络的时间序列预测是一种结合了PSO和BP神经网络的方法，用于提高BP神经网络在时间序列预测任务中的性能。时间序列预测是指根据过去的时间序列数据，预测未来的时间序列值。BP神经网络是一种常用的前向人工神经网络，但在复杂的时间序列预测问题上可能陷入局部最优解。PSO是一种全局优化算法，可以帮助寻找更优的神经网络权重和偏置值，从而提高BP神经网络的预测精度。
以下是“基于粒子群优化算法优化BP神经网络的时间序列预测”的原理：
-
BP神经网络简介：
BP神经网络是一种前向人工神经网络，由输入层、若干隐藏层和输出层组成。它通过前向传播计算输出，并通过反向传播算法来更新权重和偏置，以最小化预测值与真实值之间的误差。BP神经网络在时间序列预测问题中可以用于拟合非线性函数，并通过梯度下降法进行参数优化。 -
粒子群优化算法简介：
PSO是一种群体智能优化算法，受到鸟群觅食行为的启发。在PSO中，个体被称为“粒子”，它们在搜索空间中移动，并通过学习社会最优和个体最优位置来更新自己的位置和速度。每个粒子维护两个向量：速度向量和位置向量，它们决定了粒子在搜索空间中的移动方向和距离。 -
基于粒子群优化的BP神经网络优化：
在使用PSO优化BP神经网络时，我们将BP神经网络的权重和偏置作为待优化的参数。每个粒子表示一组可能的权重和偏置的取值，称为“粒子的位置”。PSO算法中的每个粒子都有一个适应度函数，用于评估其在时间序列预测问题中的表现。在这里，适应度函数可以是回归预测任务中的损失函数，如均方误差。 -
PSO算法流程：
PSO算法的基本流程如下：- 初始化粒子群的位置和速度。
- 计算每个粒子的适应度值（即神经网络在训练数据上的预测误差）。
- 根据个体最优和全局最优位置更新粒子的速度和位置。
- 重复上述步骤，直到满足停止条件（如达到最大迭代次数或达到预定的精度）。
-
优化过程：
在优化过程中，每个粒子代表了一组BP神经网络的权重和偏置。它们根据自身的适应度和周围粒子的表现来更新自己的位置和速度，以寻找更优的权重和偏置组合。通过迭代优化，粒子逐渐趋向于全局最优解，从而找到了最优的BP神经网络权重和偏置组合，以提高时间序列预测的性能。 -
应用于时间序列预测：
将PSO算法与BP神经网络结合应用于时间序列预测任务时，首先需要准备训练数据和测试数据。然后，利用PSO算法优化BP神经网络的权重和偏置，使其能够更好地拟合训练数据。最后，使用优化后的BP神经网络对测试数据进行预测，得到时间序列的预测结果。
总结起来，基于粒子群优化算法优化BP神经网络的时间序列预测方法，通过结合PSO算法的全局优化特性，帮助BP神经网络更好地拟合时间序列数据并提高预测精度。这种方法在时间序列预测任务中具有较好的性能，并且在应用于其他优化问题上也具有广泛的应用价值。
2.数学公式
当然可以！在下面，我将详细介绍“基于粒子群优化算法优化BP神经网络的时间序列预测”的原理，并带上公式：
- BP神经网络部分：
假设我们有一个时间序列数据 ( X X X)，其包含 ( T T T) 个时间步的观测值： X = { x 1 , x 2 , . . . , x T } X = \{x_1, x_2, ..., x_T\} X={x1,x2,...,xT}，其中 ( x t x_t xt) 是时间步 ( t t t) 的输入数据。
在BP神经网络中，我们使用前向传播计算隐藏层和输出层的输出，然后使用反向传播算法来更新权重和偏置，以最小化预测值与真实值之间的误差。隐藏层和输出层的计算公式如下：
隐藏层的计算公式：
z
h
=
W
x
h
⋅
x
t
+
W
h
h
⋅
h
t
−
1
+
b
h
z_h = W_{xh} \cdot x_t + W_{hh} \cdot h_{t-1} + b_h
zh=Wxh⋅xt+Whh⋅ht−1+bh
h
t
=
σ
(
z
h
)
h_t = \sigma(z_h)
ht=σ(zh)
输出层的计算公式：
z
o
=
W
h
o
⋅
h
t
+
b
o
z_o = W_{ho} \cdot h_t + b_o
zo=Who⋅ht+bo
y
t
=
σ
(
z
o
)
y_t = \sigma(z_o)
yt=σ(zo)
其中，
- ( h t h_t ht) 是隐藏层在时间步 ( t t t) 的输出（隐藏状态），
- ( W x h W_{xh} Wxh) 是输入到隐藏层的权重矩阵，
- ( W h h W_{hh} Whh) 是隐藏层上一时间步输出到当前时间步的隐藏层的权重矩阵，
- ( b h b_h bh) 是隐藏层的偏置，
- ( σ \sigma σ) 是激活函数（如 sigmoid 或 tanh）。
- 粒子群优化算法部分：
在粒子群优化算法中，每个粒子代表一组可能的BP神经网络的权重和偏置，即一组解。这些粒子在搜索空间中移动，并通过学习社会最优和个体最优位置来更新自己的位置和速度。每个粒子维护两个向量：速度向量和位置向量，它们决定了粒子在搜索空间中的移动方向和距离。
假设第 ( i i i) 个粒子在时间步 ( t t t) 时的位置向量为 ( x i t x_{it} xit)，速度向量为 ( v i t v_{it} vit)，个体最优位置为 ( p i t p_{it} pit)，全局最优位置为 ( p g t p_{gt} pgt)。
粒子更新的公式为：
v
i
t
=
ω
⋅
v
i
t
+
c
1
⋅
r
1
⋅
(
p
i
t
−
x
i
t
)
+
c
2
⋅
r
2
⋅
(
p
g
t
−
x
i
t
)
v_{it} = \omega \cdot v_{it} + c_1 \cdot r_1 \cdot (p_{it} - x_{it}) + c_2 \cdot r_2 \cdot (p_{gt} - x_{it})
vit=ω⋅vit+c1⋅r1⋅(pit−xit)+c2⋅r2⋅(pgt−xit)
x
i
t
+
1
=
x
i
t
+
v
i
t
x_{it+1} = x_{it} + v_{it}
xit+1=xit+vit
其中，
- ( t t t) 是时间步，
- ( ω \omega ω) 是惯性权重，控制粒子的惯性，
- ( c 1 c_1 c1) 和 ( c 2 c_2 c2) 是学习因子，分别控制个体和全局的权重，
- ( r 1 r_1 r1) 和 ( r 2 r_2 r2) 是随机数，用于增加随机性。
在每一次迭代中，通过计算每个粒子的适应度（即BP神经网络在训练数据上的预测误差），找到个体最优位置 ( p i t p_{it} pit) 和全局最优位置 ( p g t p_{gt} pgt)，并更新粒子的速度和位置，直到达到停止条件（如达到最大迭代次数或达到预定的精度）为止。
通过以上的粒子群优化过程，每个粒子逐渐趋向于全局最优解，从而找到了最优的BP神经网络权重和偏置组合，在时间序列预测任务中表现出色。
请注意，上述公式中的权重矩阵和偏置是需要在训练过程中学习的模型参数。
3.文件结构
fun.m % 适应度值计算
main.m % 主函数
数据集.xlsx % 可替换数据集
4.Excel数据
5.分块代码
5.1 fun.m
function error = fun(pop, hiddennum, net, p_train, t_train)
%% 节点个数
inputnum = size(p_train, 1); % 输入层节点数
outputnum = size(t_train, 1); % 输出层节点数
%% 提取权值和阈值
w1 = pop(1 : inputnum * hiddennum);
B1 = pop(inputnum * hiddennum + 1 : inputnum * hiddennum + hiddennum);
w2 = pop(inputnum * hiddennum + hiddennum + 1 : ...
inputnum * hiddennum + hiddennum + hiddennum * outputnum);
B2 = pop(inputnum * hiddennum + hiddennum + hiddennum * outputnum + 1 : ...
inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum);
%% 网络赋值
net.Iw{1, 1} = reshape(w1, hiddennum, inputnum );
net.Lw{2, 1} = reshape(w2, outputnum, hiddennum);
net.b{1} = reshape(B1, hiddennum, 1);
net.b{2} = B2';
%% 网络训练
net = train(net, p_train, t_train);
%% 仿真测试
t_sim1 = sim(net, p_train);
%% 适应度值
error = sqrt(sum((t_sim1 - t_train) .^ 2) ./ length(t_sim1));
5.2 main.m
%% 清空环境变量
warning off % 关闭报警信息
close all % 关闭开启的图窗
clear % 清空变量
clc % 清空命令行
%% 导入数据（时间序列的单列数据）
result = xlsread('数据集.xlsx');
%% 数据分析
num_samples = length(result); % 样本个数
kim = 15; % 延时步长（kim个历史数据作为自变量）
zim = 1; % 跨zim个时间点进行预测
%% 构造数据集
for i = 1: num_samples - kim - zim + 1
res(i, :) = [reshape(result(i: i + kim - 1), 1, kim), result(i + kim + zim - 1)];
end
%% 划分训练集和测试集
temp = 1: 1: 922;
P_train = res(temp(1: 700), 1: 15)';
T_train = res(temp(1: 700), 16)';
M = size(P_train, 2);
P_test = res(temp(701: end), 1: 15)';
T_test = res(temp(701: end), 16)';
N = size(P_test, 2);
%% 数据归一化
[p_train, ps_input] = mapminmax(P_train, 0, 1);
p_test = mapminmax('apply', P_test, ps_input);
[t_train, ps_output] = mapminmax(T_train, 0, 1);
t_test = mapminmax('apply', T_test, ps_output);
%% 节点个数
inputnum = size(p_train, 1); % 输入层节点数
hiddennum = 5; % 隐藏层节点数
outputnum = size(t_train, 1); % 输出层节点数
%% 建立网络
net = newff(p_train, t_train, hiddennum);
%% 设置训练参数
net.trainParam.epochs = 1000; % 训练次数
net.trainParam.goal = 1e-6; % 目标误差
net.trainParam.lr = 0.01; % 学习率
net.trainParam.showWindow = 0; % 关闭窗口
%% 参数初始化
c1 = 4.494; % 学习因子
c2 = 4.494; % 学习因子
maxgen = 30; % 种群更新次数
sizepop = 5; % 种群规模
Vmax = 1.0; % 最大速度
Vmin = -1.0; % 最小速度
popmax = 2.0; % 最大边界
popmin = -2.0; % 最小边界
%% 节点总数
numsum = inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum;
for i = 1 : sizepop
pop(i, :) = rands(1, numsum); % 初始化种群
V(i, :) = rands(1, numsum); % 初始化速度
fitness(i) = fun(pop(i, :), hiddennum, net, p_train, t_train);
end
%% 个体极值和群体极值
[fitnesszbest, bestindex] = min(fitness);
zbest = pop(bestindex, :); % 全局最佳
gbest = pop; % 个体最佳
fitnessgbest = fitness; % 个体最佳适应度值
BestFit = fitnesszbest; % 全局最佳适应度值
%% 迭代寻优
for i = 1 : maxgen
for j = 1 : sizepop
% 速度更新
V(j, :) = V(j, :) + c1 * rand * (gbest(j, :) - pop(j, :)) + c2 * rand * (zbest - pop(j, :));
V(j, (V(j, :) > Vmax)) = Vmax;
V(j, (V(j, :) < Vmin)) = Vmin;
% 种群更新
pop(j, :) = pop(j, :) + 0.2 * V(j, :);
pop(j, (pop(j, :) > popmax)) = popmax;
pop(j, (pop(j, :) < popmin)) = popmin;
% 自适应变异
pos = unidrnd(numsum);
if rand > 0.95
pop(j, pos) = rands(1, 1);
end
% 适应度值
fitness(j) = fun(pop(j, :), hiddennum, net, p_train, t_train);
end
for j = 1 : sizepop
% 个体最优更新
if fitness(j) < fitnessgbest(j)
gbest(j, :) = pop(j, :);
fitnessgbest(j) = fitness(j);
end
% 群体最优更新
if fitness(j) < fitnesszbest
zbest = pop(j, :);
fitnesszbest = fitness(j);
end
end
BestFit = [BestFit, fitnesszbest];
end
%% 提取最优初始权值和阈值
w1 = zbest(1 : inputnum * hiddennum);
B1 = zbest(inputnum * hiddennum + 1 : inputnum * hiddennum + hiddennum);
w2 = zbest(inputnum * hiddennum + hiddennum + 1 : inputnum * hiddennum ...
+ hiddennum + hiddennum * outputnum);
B2 = zbest(inputnum * hiddennum + hiddennum + hiddennum * outputnum + 1 : ...
inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum);
%% 最优值赋值
net.Iw{1, 1} = reshape(w1, hiddennum, inputnum);
net.Lw{2, 1} = reshape(w2, outputnum, hiddennum);
net.b{1} = reshape(B1, hiddennum, 1);
net.b{2} = B2';
%% 打开训练窗口
net.trainParam.showWindow = 1; % 打开窗口
%% 网络训练
net = train(net, p_train, t_train);
%% 仿真预测
t_sim1 = sim(net, p_train);
t_sim2 = sim(net, p_test );
%% 数据反归一化
T_sim1 = mapminmax('reverse', t_sim1, ps_output);
T_sim2 = mapminmax('reverse', t_sim2, ps_output);
%% 均方根误差
error1 = sqrt(sum((T_sim1 - T_train).^2) ./ M);
error2 = sqrt(sum((T_sim2 - T_test ).^2) ./ N);
%% 绘图
figure
plot(1: M, T_train, 'r-', 1: M, T_sim1, 'b-', 'LineWidth', 1)
legend('真实值', '预测值')
xlabel('预测样本')
ylabel('预测结果')
string = {'训练集预测结果对比'; ['RMSE=' num2str(error1)]};
title(string)
xlim([1, M])
grid
figure
plot(1: N, T_test, 'r-', 1: N, T_sim2, 'b-', 'LineWidth', 1)
legend('真实值', '预测值')
xlabel('预测样本')
ylabel('预测结果')
string = {'测试集预测结果对比'; ['RMSE=' num2str(error2)]};
title(string)
xlim([1, N])
grid
%% 误差曲线迭代图
figure
plot(1 : length(BestFit), BestFit, 'LineWidth', 1.5);
xlabel('粒子群迭代次数');
ylabel('适应度值');
xlim([1, length(BestFit)])
string = {'模型迭代误差变化'};
title(string)
grid on
%% 相关指标计算
% R2
R1 = 1 - norm(T_train - T_sim1)^2 / norm(T_train - mean(T_train))^2;
R2 = 1 - norm(T_test - T_sim2)^2 / norm(T_test - mean(T_test ))^2;
disp(['训练集数据的R2为：', num2str(R1)])
disp(['测试集数据的R2为：', num2str(R2)])
% MAE
mae1 = sum(abs(T_sim1 - T_train)) ./ M ;
mae2 = sum(abs(T_sim2 - T_test )) ./ N ;
disp(['训练集数据的MAE为：', num2str(mae1)])
disp(['测试集数据的MAE为：', num2str(mae2)])
% MBE
mbe1 = sum(T_sim1 - T_train) ./ M ;
mbe2 = sum(T_sim2 - T_test ) ./ N ;
disp(['训练集数据的MBE为：', num2str(mbe1)])
disp(['测试集数据的MBE为：', num2str(mbe2)])
6.完整代码
6.1 fun.m
function error = fun(pop, hiddennum, net, p_train, t_train)
%% 节点个数
inputnum = size(p_train, 1); % 输入层节点数
outputnum = size(t_train, 1); % 输出层节点数
%% 提取权值和阈值
w1 = pop(1 : inputnum * hiddennum);
B1 = pop(inputnum * hiddennum + 1 : inputnum * hiddennum + hiddennum);
w2 = pop(inputnum * hiddennum + hiddennum + 1 : ...
inputnum * hiddennum + hiddennum + hiddennum * outputnum);
B2 = pop(inputnum * hiddennum + hiddennum + hiddennum * outputnum + 1 : ...
inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum);
%% 网络赋值
net.Iw{1, 1} = reshape(w1, hiddennum, inputnum );
net.Lw{2, 1} = reshape(w2, outputnum, hiddennum);
net.b{1} = reshape(B1, hiddennum, 1);
net.b{2} = B2';
%% 网络训练
net = train(net, p_train, t_train);
%% 仿真测试
t_sim1 = sim(net, p_train);
%% 适应度值
error = sqrt(sum((t_sim1 - t_train) .^ 2) ./ length(t_sim1));
6.2 main.m
%% 清空环境变量
warning off % 关闭报警信息
close all % 关闭开启的图窗
clear % 清空变量
clc % 清空命令行
%% 导入数据（时间序列的单列数据）
result = xlsread('数据集.xlsx');
%% 数据分析
num_samples = length(result); % 样本个数
kim = 15; % 延时步长（kim个历史数据作为自变量）
zim = 1; % 跨zim个时间点进行预测
%% 构造数据集
for i = 1: num_samples - kim - zim + 1
res(i, :) = [reshape(result(i: i + kim - 1), 1, kim), result(i + kim + zim - 1)];
end
%% 划分训练集和测试集
temp = 1: 1: 922;
P_train = res(temp(1: 700), 1: 15)';
T_train = res(temp(1: 700), 16)';
M = size(P_train, 2);
P_test = res(temp(701: end), 1: 15)';
T_test = res(temp(701: end), 16)';
N = size(P_test, 2);
%% 数据归一化
[p_train, ps_input] = mapminmax(P_train, 0, 1);
p_test = mapminmax('apply', P_test, ps_input);
[t_train, ps_output] = mapminmax(T_train, 0, 1);
t_test = mapminmax('apply', T_test, ps_output);
%% 节点个数
inputnum = size(p_train, 1); % 输入层节点数
hiddennum = 5; % 隐藏层节点数
outputnum = size(t_train, 1); % 输出层节点数
%% 建立网络
net = newff(p_train, t_train, hiddennum);
%% 设置训练参数
net.trainParam.epochs = 1000; % 训练次数
net.trainParam.goal = 1e-6; % 目标误差
net.trainParam.lr = 0.01; % 学习率
net.trainParam.showWindow = 0; % 关闭窗口
%% 参数初始化
c1 = 4.494; % 学习因子
c2 = 4.494; % 学习因子
maxgen = 30; % 种群更新次数
sizepop = 5; % 种群规模
Vmax = 1.0; % 最大速度
Vmin = -1.0; % 最小速度
popmax = 2.0; % 最大边界
popmin = -2.0; % 最小边界
%% 节点总数
numsum = inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum;
for i = 1 : sizepop
pop(i, :) = rands(1, numsum); % 初始化种群
V(i, :) = rands(1, numsum); % 初始化速度
fitness(i) = fun(pop(i, :), hiddennum, net, p_train, t_train);
end
%% 个体极值和群体极值
[fitnesszbest, bestindex] = min(fitness);
zbest = pop(bestindex, :); % 全局最佳
gbest = pop; % 个体最佳
fitnessgbest = fitness; % 个体最佳适应度值
BestFit = fitnesszbest; % 全局最佳适应度值
%% 迭代寻优
for i = 1 : maxgen
for j = 1 : sizepop
% 速度更新
V(j, :) = V(j, :) + c1 * rand * (gbest(j, :) - pop(j, :)) + c2 * rand * (zbest - pop(j, :));
V(j, (V(j, :) > Vmax)) = Vmax;
V(j, (V(j, :) < Vmin)) = Vmin;
% 种群更新
pop(j, :) = pop(j, :) + 0.2 * V(j, :);
pop(j, (pop(j, :) > popmax)) = popmax;
pop(j, (pop(j, :) < popmin)) = popmin;
% 自适应变异
pos = unidrnd(numsum);
if rand > 0.95
pop(j, pos) = rands(1, 1);
end
% 适应度值
fitness(j) = fun(pop(j, :), hiddennum, net, p_train, t_train);
end
for j = 1 : sizepop
% 个体最优更新
if fitness(j) < fitnessgbest(j)
gbest(j, :) = pop(j, :);
fitnessgbest(j) = fitness(j);
end
% 群体最优更新
if fitness(j) < fitnesszbest
zbest = pop(j, :);
fitnesszbest = fitness(j);
end
end
BestFit = [BestFit, fitnesszbest];
end
%% 提取最优初始权值和阈值
w1 = zbest(1 : inputnum * hiddennum);
B1 = zbest(inputnum * hiddennum + 1 : inputnum * hiddennum + hiddennum);
w2 = zbest(inputnum * hiddennum + hiddennum + 1 : inputnum * hiddennum ...
+ hiddennum + hiddennum * outputnum);
B2 = zbest(inputnum * hiddennum + hiddennum + hiddennum * outputnum + 1 : ...
inputnum * hiddennum + hiddennum + hiddennum * outputnum + outputnum);
%% 最优值赋值
net.Iw{1, 1} = reshape(w1, hiddennum, inputnum);
net.Lw{2, 1} = reshape(w2, outputnum, hiddennum);
net.b{1} = reshape(B1, hiddennum, 1);
net.b{2} = B2';
%% 打开训练窗口
net.trainParam.showWindow = 1; % 打开窗口
%% 网络训练
net = train(net, p_train, t_train);
%% 仿真预测
t_sim1 = sim(net, p_train);
t_sim2 = sim(net, p_test );
%% 数据反归一化
T_sim1 = mapminmax('reverse', t_sim1, ps_output);
T_sim2 = mapminmax('reverse', t_sim2, ps_output);
%% 均方根误差
error1 = sqrt(sum((T_sim1 - T_train).^2) ./ M);
error2 = sqrt(sum((T_sim2 - T_test ).^2) ./ N);
%% 绘图
figure
plot(1: M, T_train, 'r-', 1: M, T_sim1, 'b-', 'LineWidth', 1)
legend('真实值', '预测值')
xlabel('预测样本')
ylabel('预测结果')
string = {'训练集预测结果对比'; ['RMSE=' num2str(error1)]};
title(string)
xlim([1, M])
grid
figure
plot(1: N, T_test, 'r-', 1: N, T_sim2, 'b-', 'LineWidth', 1)
legend('真实值', '预测值')
xlabel('预测样本')
ylabel('预测结果')
string = {'测试集预测结果对比'; ['RMSE=' num2str(error2)]};
title(string)
xlim([1, N])
grid
%% 误差曲线迭代图
figure
plot(1 : length(BestFit), BestFit, 'LineWidth', 1.5);
xlabel('粒子群迭代次数');
ylabel('适应度值');
xlim([1, length(BestFit)])
string = {'模型迭代误差变化'};
title(string)
grid on
%% 相关指标计算
% R2
R1 = 1 - norm(T_train - T_sim1)^2 / norm(T_train - mean(T_train))^2;
R2 = 1 - norm(T_test - T_sim2)^2 / norm(T_test - mean(T_test ))^2;
disp(['训练集数据的R2为：', num2str(R1)])
disp(['测试集数据的R2为：', num2str(R2)])
% MAE
mae1 = sum(abs(T_sim1 - T_train)) ./ M ;
mae2 = sum(abs(T_sim2 - T_test )) ./ N ;
disp(['训练集数据的MAE为：', num2str(mae1)])
disp(['测试集数据的MAE为：', num2str(mae2)])
% MBE
mbe1 = sum(T_sim1 - T_train) ./ M ;
mbe2 = sum(T_sim2 - T_test ) ./ N ;
disp(['训练集数据的MBE为：', num2str(mbe1)])
disp(['测试集数据的MBE为：', num2str(mbe2)])
7.运行结果
