【Matlab】基于粒子群优化算法优化BP神经网络的时间序列预测（Excel可直接替换数据）

news2024/11/25 3:21:06

【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神经网络的时间序列预测”的原理：

  1. BP神经网络简介：
    BP神经网络是一种前向人工神经网络，由输入层、若干隐藏层和输出层组成。它通过前向传播计算输出，并通过反向传播算法来更新权重和偏置，以最小化预测值与真实值之间的误差。BP神经网络在时间序列预测问题中可以用于拟合非线性函数，并通过梯度下降法进行参数优化。

  2. 粒子群优化算法简介：
    PSO是一种群体智能优化算法，受到鸟群觅食行为的启发。在PSO中，个体被称为“粒子”，它们在搜索空间中移动，并通过学习社会最优和个体最优位置来更新自己的位置和速度。每个粒子维护两个向量：速度向量和位置向量，它们决定了粒子在搜索空间中的移动方向和距离。

  3. 基于粒子群优化的BP神经网络优化：
    在使用PSO优化BP神经网络时，我们将BP神经网络的权重和偏置作为待优化的参数。每个粒子表示一组可能的权重和偏置的取值，称为“粒子的位置”。PSO算法中的每个粒子都有一个适应度函数，用于评估其在时间序列预测问题中的表现。在这里，适应度函数可以是回归预测任务中的损失函数，如均方误差。

  4. PSO算法流程：
    PSO算法的基本流程如下：

    • 初始化粒子群的位置和速度。
    • 计算每个粒子的适应度值（即神经网络在训练数据上的预测误差）。
    • 根据个体最优和全局最优位置更新粒子的速度和位置。
    • 重复上述步骤，直到满足停止条件（如达到最大迭代次数或达到预定的精度）。

  5. 优化过程：
    在优化过程中，每个粒子代表了一组BP神经网络的权重和偏置。它们根据自身的适应度和周围粒子的表现来更新自己的位置和速度，以寻找更优的权重和偏置组合。通过迭代优化，粒子逐渐趋向于全局最优解，从而找到了最优的BP神经网络权重和偏置组合，以提高时间序列预测的性能。

  6. 应用于时间序列预测：
    将PSO算法与BP神经网络结合应用于时间序列预测任务时，首先需要准备训练数据和测试数据。然后，利用PSO算法优化BP神经网络的权重和偏置，使其能够更好地拟合训练数据。最后，使用优化后的BP神经网络对测试数据进行预测，得到时间序列的预测结果。

总结起来，基于粒子群优化算法优化BP神经网络的时间序列预测方法，通过结合PSO算法的全局优化特性，帮助BP神经网络更好地拟合时间序列数据并提高预测精度。这种方法在时间序列预测任务中具有较好的性能，并且在应用于其他优化问题上也具有广泛的应用价值。

2.数学公式

当然可以！在下面，我将详细介绍“基于粒子群优化算法优化BP神经网络的时间序列预测”的原理，并带上公式：

  1. 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）。
  1. 粒子群优化算法部分：

在粒子群优化算法中，每个粒子代表一组可能的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.运行结果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/794853.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【LeetCode 75】第九题(443)压缩字符串

【LeetCode 75】第九题(443)压缩字符串

目录 题目: 示例: 分析: 题目: 示例: 分析: 给一个字符串,如果该字符有连续的相同的字符,则只保留一个字符,并在该字符后加上该字符连续的数量.例如原数组为 [a,a,a],则因为字符a连续了三次,因此可以压缩为[a,3],我们需要注意的是数字也需要是字符,则如果字符连续次数不止有…
阅读更多...
SpringCloud学习路线（13）——分布式搜索ElasticSeach集群

SpringCloud学习路线（13）——分布式搜索ElasticSeach集群

前言 单机ES做数据存储&#xff0c;必然面临两个问题&#xff1a;海量数据的存储&#xff0c;单点故障。 如何解决这两个问题&#xff1f; 海量数据的存储问题&#xff1a; 将索引库从逻辑上拆分为N个分片&#xff08;shard&#xff09;&#xff0c;存储到多个节点。单点故障…
阅读更多...
C++笔记之memset分析

C++笔记之memset分析

C笔记之memset分析 code review! 文章目录 C\笔记之memset分析1.介绍2.误区总结3.代码一&#xff0c;char数组和uint8_t使用memset4.代码三&#xff0c;int数组使用memset 1.介绍 2.误区总结 参考文章&#xff1a;Cmemset踩坑 3.代码一&#xff0c;char数组和uint8_t使用mem…
阅读更多...
2023年河北省研究生数学建模竞赛D题中国钢铁工业低碳转型与高质量发展路径优化研究思路和代码

2023年河北省研究生数学建模竞赛D题中国钢铁工业低碳转型与高质量发展路径优化研究思路和代码

D题中国钢铁工业低碳转型与高质量发展路径优化研究 目前已写出D题初步代码&#xff0c;下载地址&#xff1a;【2023年河北省研究生数学建模竞赛D题初步思路和代码-哔哩哔哩】 https://b23.tv/g2ATbX5 随着我国工业化、城镇化进程的加快和消费结构持续升级&#xff0c;能源需求…
阅读更多...
tty（五）串口的打开过程

tty（五）串口的打开过程

一、字符设备完成注册 我们知道&#xff0c;在serial核心层提供了2个重要接口 uart_register_driver uart_add_one_port 上者通过调用tty核心的接口&#xff0c;完成了tty_driver的动态分配和注册&#xff0c;然而此时并没有看到创建字符设备&#xff0c; 通过对uart_add_one…
阅读更多...
货拉拉基于 Flink 计算引擎的应用与优化实践

货拉拉基于 Flink 计算引擎的应用与优化实践

摘要&#xff1a;本文整理自货拉拉实时研发平台负责人王世涛&#xff0c;在Flink Forward Asia 2022 平台建设专场的分享。本篇内容主要分为六个部分&#xff1a; Flink 在货拉拉的使用现状Flink 平台化性能优化主题数据准确性主题稳定性主题未来展望 点击查看原文视频 & 演…
阅读更多...
【leetcode】链表的中间节点|链表中倒数第k个节点

【leetcode】链表的中间节点|链表中倒数第k个节点

目录 1.链表的中间节点 2.链表中倒数第k个节点 1.链表的中间节点 思路1&#xff1a;遍历链表&#xff0c;统计节点个数count&#xff0c;返回第count/2 1个节点 &#x1f4d6;Note:注意循环条件为--mid&#xff0c;--mid循环执行mid-1次&#xff0c;mid--循环mid次&#xf…
阅读更多...
SpringBoot 8种异步实现方式

SpringBoot 8种异步实现方式

前言&#xff1a;异步执行对于开发者来说并不陌生&#xff0c;在实际的开发过程中&#xff0c;很多场景多会使用到异步&#xff0c;相比同步执行&#xff0c;异步可以大大缩短请求链路耗时时间&#xff0c;比如&#xff1a;「发送短信、邮件、异步更新等」&#xff0c;这些都是…
阅读更多...
采用串级控制和超高精度PID调节器的微张力精密控制技术

采用串级控制和超高精度PID调节器的微张力精密控制技术

摘要&#xff1a;采用当前的各种涂布机很难适用气体扩散层这类脆性材料的涂布工艺&#xff0c;需要控制精度更高的微张力控制系统。为此本文基于串级控制原理&#xff0c;提出了采用双闭环PID控制模式和超高精度PID张力控制器的解决方案&#xff0c;一方面形成浮动摆棍闭环和主…
阅读更多...
python机器学习（五）逻辑回归、决策边界、代价函数、梯度下降法实现线性和非线性逻辑回归

python机器学习（五）逻辑回归、决策边界、代价函数、梯度下降法实现线性和非线性逻辑回归

线性回归所解决的问题是把数据集的特征传入到模型中&#xff0c;预测一个值使得误差最小&#xff0c;预测值无限接近于真实值。比如把房子的其他特征传入到模型中&#xff0c;预测出房价&#xff0c; 房价是一系列连续的数值&#xff0c;线性回归解决的是有监督的学习。有很多场…
阅读更多...
kafka权威指南学习以及kafka生产配置

kafka权威指南学习以及kafka生产配置

0、kafka常用命令 Kafka是一个分布式流处理平台&#xff0c;它具有高度可扩展性和容错性。以下是Kafka最新版本中常用的一些命令&#xff1a; 创建一个主题&#xff08;topic&#xff09;&#xff1a; bin/kafka-topics.sh --create --topic my-topic --partitions 3 --replic…
阅读更多...
【论文阅读22】Label prompt for multi-label text classification

【论文阅读22】Label prompt for multi-label text classification

论文相关 论文标题&#xff1a;Label prompt for multi-label text classification&#xff08;基于提示学习的多标签文本分类&#xff09; 发表时间&#xff1a;2023 领域&#xff1a;多标签文本分类 发表期刊&#xff1a;Applied Intelligence&#xff08;SCI二区&#xff0…
阅读更多...
生态系统景观指数-聚集度指数AI计算

生态系统景观指数-聚集度指数AI计算

景观指数是景观生态学的常见指标&#xff0c;可用于不同生态系统的特征识别。景观指数是反映景观结构与空间格局的定量指标&#xff0c;目前已成为景观生态学领域常用的分析景观格局、度量空间异质性的重要方法。不同水平下的指数结果往往代表不同含义&#xff0c;应在把握指数…
阅读更多...
git冲突“accept theirs”和“accept yours”

git冲突“accept theirs”和“accept yours”

Accept Yours 就是直接选取本地的代码&#xff0c;覆盖掉远程仓库的 Accept Theirs 是直接选取远程仓库的&#xff0c;覆盖掉自己本地的 我们选择Merge,自己手动行进选择、修改。 这里左边部分是你本地仓库的代码&#xff0c;右边部分是远程仓库的代码&#xff0c;中间的res…
阅读更多...
uniapp WIFI上下班打卡

uniapp WIFI上下班打卡

大纲 &#x1f959; uniapp官网&#xff1a;uni-app官网 &#x1f959; WIFI功能模块&#xff1a; 1、下载 wifi 插件 uni-WiFi 2、在 manifest.json 中 App权限配置中 配置权限 1. ACCESS_WIFI_STATE &#xff08;访问权限状态&#xff09; 2. CHANGE_WIFI_STATE&#xff…
阅读更多...
13.Netty源码之Netty中的类与API

13.Netty源码之Netty中的类与API

highlight: arduino-light ServerBootstrap Bootstrap 意思是引导&#xff0c;一个 Netty 应用通常由一个 Bootstrap 开始&#xff0c;主要作用是配置整个 Netty 程序&#xff0c;串联各个组件&#xff0c;Netty 中ServerBootstrap 是服务端启动引导类。 java //泛型 AbstractB…
阅读更多...
VMware上安装Ubuntu64

VMware上安装Ubuntu64

D:\VMware\Virtual Machines\Ubuntu64 D:\VMware\Virtual Machines\Ubuntu64\Ubuntu64.vmdk 继续
阅读更多...
【ESP32】调试UART功能

【ESP32】调试UART功能

1.创建示例项目uart_echo&#xff1a;VSCODE中->“查看”->”命令面板“->输入&#xff1a;Show Examples projects->选择Use current ESP-IDF(C:\Espressif\frameworks\esp-idf-v5.1)->弹出示例ESP-IDF Examples&#xff0c;选择peripherals->uart->uart…
阅读更多...
泰晓科技发布 Linux Lab v1.2 正式版

泰晓科技发布 Linux Lab v1.2 正式版

导读近日消息&#xff0c;Linux Lab 是一套用于 Linux 内核学习、开发和测试的即时实验室&#xff0c;官方称其“可以极速搭建和使用&#xff0c;功能强大&#xff0c;用法简单”。 自去年 12 月份发布 Linux Lab v1.1 后&#xff0c;v1.2 正式版目前已经发布于 GitHub 及 Gite…
阅读更多...
Tensorflow(二)

Tensorflow(二)

一、过拟合 过拟合现象:机器对于数据的学习过于自负(想要将误差减到最小)。 解决方法:利用正规化方法 二、卷积神经网络(CNN) 卷积神经网络是近些年来逐渐兴起的人工神经网络&#xff0c;主要用于图像分类、计算机视觉等。 卷积:例如对图片每一小块像素区域的处理&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023