BP
%输入和输出数据
tic
data=csvread('1NewTrainTest.csv');
[M,N]=size(data);
input=data(:,1:N-1);
output=data(:,N);
%随机选择1900组作为训练，100组最为测试
TestNum=M-5;
input_train=input(1:TestNum,:)';
output_train=output(1:TestNum,:)';
input_test=input(TestNum+1:M,:)';
output_test=output(TestNum+1:M,:)';
%训练数据的归一化
[inputn,inputps]=mapminmax(input_train);
[outputn,outputps]=mapminmax(output_train);
%构建BP神经网络
net=newff(inputn,outputn,[5 5 5]);
%net=newff(inputn,outputn,[5 5 5]);构将2个隐含层，神经元个数依次是3和4
net.trainParam.epochs=100;
net.trainParam.lr=0.1;
net.trainParam.goal=0.00004;
%训练神经网络
net=train(net,inputn,outputn);
%待预测数据的归一化
inputn_test=mapminmax('apply',input_test,inputps);
%输出预测值，并反归一化
an=sim(net,inputn_test);
BPoutput=mapminmax('reverse',an,outputps);
figure(1);
%预测值和准确值
plot(BPoutput(1,:),'r');
hold on;
plot(output_test(1,:),'b')
b=BPoutput';
d=output_test';
rmse=sqrt(sum((b-d).^2)/length(b));
mape=sum(abs(b-d)./d)/length(b);
mae=sum(abs(b-d))/length(b);
data=load('si.txt');
[M,N]=size(data);
input=data(:,2:N);
output=data(:,1);
a1 = a(ind(1:round(len_dataSet*0.7)),:); % 随机的70%数据作为训练集
a2 = a(ind(round(len_dataSet*0.7)+1:end),:);% 随机的30%数据作为测试集
output_train=a1(:,1)'; % 第一列：分类或回归的期望输出
input_train=a1(:,2:5)';% 第二列到最后一列：不同数据的属性
test_data=load(TestingData_File);% clear train_data;
output_test=a2(:,1)'; % 第一列：分类或回归的期望输出
input_test=a2(:,2:5)';% 第二列到最后一列：不同数据的属性Pn_test=P_test;Tn_test=T_test;
inputn=input_train;
outputn=output_train;
net=newff(inputn,outputn,[5 5 5]);
net.trainParam.epochs=100;
net.trainParam.lr=0.1;
net.trainParam.goal=0.00004;
%训练神经网络
net=train(net,inputn,outputn);
%待预测数据的归一化mapminmax('apply',,inputps)
inputn_test=input_test;
an=sim(net,inputn_test);
BPoutput=an;
POS
tic
global SamIn SamOut HiddenUnitNum InDim OutDim TrainSamNum
%% 导入训练数据
data = xlsread('data.xlsx');
[data_m,data_n] = size(data);%获取数据维度
P = 80; %百分之P的数据用于训练，其余测试
Ind = floor(P * data_m / 100);
train_data = data(1:Ind,1:4)';
train_result = data(1:Ind,6:7)';
test_data = data(Ind+1:end,1:4)';% 利用训练好的网络进行预测
test_result = data(Ind+1:end,6:7)';
%% 初始化参数
[InDim,TrainSamNum] = size(train_data);% 学习样本数量
[OutDim,TrainSamNum] = size(train_result);
HiddenUnitNum = 8; % 隐含层神经元个数
[SamIn,PS_i] = mapminmax(train_data,0,1); % 原始样本对（输入和输出）初始化
[SamOut,PS_o] = mapminmax(train_result,0,1);
W1 = HiddenUnitNum*InDim; % 初始化输入层与隐含层之间的权值
B1 = HiddenUnitNum; % 初始化输入层与隐含层之间的阈值
W2 = OutDim*HiddenUnitNum; % 初始化输出层与隐含层之间的权值
B2 = OutDim; % 初始化输出层与隐含层之间的阈值
L = W1+B1+W2+B2; %粒子维度
%% *********初始化
M=100; %种群规模
%初始化粒子位置
X=rand(M,L);
c1=2; %学习因子
c2=2;
wmax=0.9;%最大最小惯性权重
wmin=0.5;
Tmax=1000;%迭代次数
v=zeros(M,L);%初始化速度
%*******全局最优粒子位置初始化
fmin=inf;
for i=1:M
fx = f(X(i,:));
if fx<fmin
fmin=fx;
gb=X(i,:);
end
end
%********粒子个体历史最优位置初始化
pb=X;
%********算法迭代
for t=1:Tmax
w(t)=wmax-(wmax-wmin)*t/Tmax; %线性下降惯性权重
for i=1:M
%******更新粒子速度
v(i,:)=w(t)*v(i,:)+c1*rand(1)*(pb(i,:)-X(i,:))+c2*rand(1)*(gb-X(i,:));
if sum(abs(v(i,:)))>1e3
v(i,:)=rand(size(v(i,:)));
end
%*******更新粒子位置
X(i,:)=X(i,:)+v(i,:);
end
%更新pbest和gbest
for i=1:M
if f(X(i,:))<f(pb(i,:))
pb(i,:)=X(i,:);
end
if f(X(i,:))<f(gb)
gb=X(i,:);
end
end
%保存最佳适应度
re(t)=f(gb);
fprintf('经%d次训练，误差为%f，用时%fs\n\n',t,f(gb),toc);
%可视化迭代过程
subplot(221)
plot(gb)
title('权阈值更新曲线')
hold on
subplot(222)
mesh(v)
title('粒子速度变化')
pause(0.000000001)
subplot(2,2,[3,4])
plot(re,'r')
title('累计误差迭代曲线')
%74-86会增加程序运行时间，注释掉可加快程序运行
end
x = gb;
W1 = x(1:HiddenUnitNum*InDim);
L1 = length(W1);
W1 = reshape(W1,[HiddenUnitNum, InDim]);
B1 = x(L1+1:L1+HiddenUnitNum)';
L2 = L1 + length(B1);
W2 = x(L2+1:L2+OutDim*HiddenUnitNum);
L3 = L2 + length(W2);
W2 = reshape(W2,[OutDim, HiddenUnitNum]);
B2 = x(L3+1:L3+OutDim)';
HiddenOut = logsig(W1 * SamIn + repmat(B1, 1, TrainSamNum)); % 隐含层网络输出
NetworkOut = W2 * HiddenOut + repmat(B2, 1, TrainSamNum); % 输出层网络输出
Error = SamOut - NetworkOut; % 实际输出与网络输出之差
Forcast_data = mapminmax('reverse',NetworkOut,PS_o);
[OutDim,ForcastSamNum] = size(test_result);
SamIn_test= mapminmax('apply',test_data,PS_i); % 原始样本对（输入和输出）初始化
HiddenOut_test = logsig(W1 * SamIn_test + repmat(B1, 1, ForcastSamNum)); % 隐含层输出预测结果
NetworkOut = W2 * HiddenOut_test + repmat(B2, 1, ForcastSamNum); % 输出层输出预测结果
Forcast_data_test = mapminmax('reverse',NetworkOut,PS_o);
%% 绘制结果
figure
plot(re,'r')
xlabel('迭代次数')
ylabel('适应度')
title('累计误差迭代曲线')
figure
subplot(2,2,1);
plot(train_result(1,:), 'r-*')
hold on
plot(Forcast_data(1,:), 'b-o');
legend('真实值','拟合值')
title('第1个输出训练集拟合效果')
subplot(2,2,2);
plot(test_result(1,:), 'r-*')
hold on
plot(Forcast_data_test(1,:), 'b-o');
legend('真实值','预测值')
title('第1个输出测试集预测效果')
subplot(2,2,3);
stem(train_result(1,:) - Forcast_data(1,:))
title('第1个输出训练集误差')
subplot(2,2,4);
stem(test_result(1,:) - Forcast_data_test(1,:))
title('第1个输出测试集误差')
figure
subplot(2,2,1);
plot(train_result(2,:), 'r-*')
hold on
plot(Forcast_data(2,:), 'b-o');
legend('真实值','拟合值')
title('第2个输出训练集拟合效果')
subplot(2,2,2);
plot(test_result(2,:), 'r-*')
hold on
plot(Forcast_data_test(2,:), 'b-o');
legend('真实值','预测值')
title('第2个输出测试集预测效果')
subplot(2,2,3);
stem(train_result(2,:) - Forcast_data(2,:))
title('第2个输出训练集误差')
subplot(2,2,4);
stem(test_result(2,:) - Forcast_data_test(2,:))
title('第2个输出测试集误差')
toc
POS-BP
% tic
global SamIn SamOut HiddenUnitNum InDim OutDim TrainSamNum
%% 导入训练数据
data=csvread('1NewTrainTest.csv');
[M,N]=size(data);
input=data(:,1:N-1);
output=data(:,N);
%随机选择1900组作为训练，100组最为测试
TestNum=M-5;
train_data=input(1:TestNum,:)';
train_result=output(1:TestNum,:)';
test_data=input(TestNum+1:M,:)';
test_result=output(TestNum+1:M,:)';
%% 初始化参数
[InDim,TrainSamNum] = size(train_data);% 学习样本数量
[OutDim,TrainSamNum] = size(train_result);
HiddenUnitNum = 8; % 隐含层神经元个数
[SamIn,PS_i] = mapminmax(train_data,0,1); % 原始样本对（输入和输出）初始化
[SamOut,PS_o] = mapminmax(train_result,0,1);
W1 = HiddenUnitNum*InDim; % 初始化输入层与隐含层之间的权值
B1 = HiddenUnitNum; % 初始化输入层与隐含层之间的阈值
W2 = OutDim*HiddenUnitNum; % 初始化输出层与隐含层之间的权值
B2 = OutDim; % 初始化输出层与隐含层之间的阈值
L = W1+B1+W2+B2; %粒子维度
%% *********初始化
M=100; %种群规模
%初始化粒子位置
X=rand(M,L);
c1=2; %学习因子
c2=2;
wmax=0.9;%最大最小惯性权重
wmin=0.5;
Tmax=100;%迭代次数
v=zeros(M,L);%初始化速度
%*******全局最优粒子位置初始化
fmin=inf;
for i=1:M
fx = f(X(i,:));
if fx<fmin
fmin=fx;
gb=X(i,:);
end
end
%********粒子个体历史最优位置初始化
pb=X;
%********算法迭代
for t=1:Tmax
w(t)=wmax-(wmax-wmin)*t/Tmax; %线性下降惯性权重
for i=1:M
%******更新粒子速度
v(i,:)=w(t)*v(i,:)+c1*rand(1)*(pb(i,:)-X(i,:))+c2*rand(1)*(gb-X(i,:));
if sum(abs(v(i,:)))>1e3
v(i,:)=rand(size(v(i,:)));
end
%*******更新粒子位置
X(i,:)=X(i,:)+v(i,:);
end
%更新pbest和gbest
for i=1:M
if f(X(i,:))<f(pb(i,:))
pb(i,:)=X(i,:);
end
if f(X(i,:))<f(gb)
gb=X(i,:);
end
end
%保存最佳适应度
re(t)=f(gb);
fprintf('经%d次训练，误差为%f，用时%fs\n\n',t,f(gb),toc);
%可视化迭代过程
% subplot(221)
% plot(gb)
% title('权阈值更新曲线')
% hold on
% subplot(222)
% mesh(v)
% title('粒子速度变化')
% pause(0.000000001)
% subplot(2,2,[3,4])
% plot(re,'r')
% title('累计误差迭代曲线')
%74-86会增加程序运行时间，注释掉可加快程序运行
end
x = gb;
W1 = x(1:HiddenUnitNum*InDim);
L1 = length(W1);
W1 = reshape(W1,[HiddenUnitNum, InDim]);
B1 = x(L1+1:L1+HiddenUnitNum)';
L2 = L1 + length(B1);
W2 = x(L2+1:L2+OutDim*HiddenUnitNum);
L3 = L2 + length(W2);
W2 = reshape(W2,[OutDim, HiddenUnitNum]);
B2 = x(L3+1:L3+OutDim)';
HiddenOut = logsig(W1 * SamIn + repmat(B1, 1, TrainSamNum)); % 隐含层网络输出
NetworkOut = W2 * HiddenOut + repmat(B2, 1, TrainSamNum); % 输出层网络输出
Error = SamOut - NetworkOut; % 实际输出与网络输出之差
Forcast_data = mapminmax('reverse',NetworkOut,PS_o);
[OutDim,ForcastSamNum] = size(test_result);
SamIn_test= mapminmax('apply',test_data,PS_i); % 原始样本对（输入和输出）初始化
HiddenOut_test = logsig(W1 * SamIn_test + repmat(B1, 1, ForcastSamNum)); % 隐含层输出预测结果
NetworkOut = W2 * HiddenOut_test + repmat(B2, 1, ForcastSamNum); % 输出层输出预测结果
Forcast_data_test = mapminmax('reverse',NetworkOut,PS_o);
%% 绘制结果
figure
plot(re,'r')
xlabel('迭代次数')
ylabel('适应度')
title('累计误差迭代曲线')
figure
subplot(2,2,1);
plot(train_result(1,:), 'r-*')
hold on
plot(Forcast_data(1,:), 'b-o');
legend('真实值','拟合值')
title('第1个输出训练集拟合效果')
subplot(2,2,2);
plot(test_result(1,:), 'r-*')
hold on
plot(Forcast_data_test(1,:), 'b-o');
legend('真实值','预测值')
title('第1个输出测试集预测效果')
subplot(2,2,3);
stem(train_result(1,:) - Forcast_data(1,:))
title('第1个输出训练集误差')
subplot(2,2,4);
stem(test_result(1,:) - Forcast_data_test(1,:))
title('第1个输出测试集误差')
rmse=sqrt(sum((b-d).^2)/length(b));
mape=sum(abs(b-d)./d)/length(b);
% mae=sum(abs(b-d))/length(b);
fprintf('经次训练误,差用时%f\n\n',rmse,mape);
% figure
% subplot(2,2,1);
% plot(train_result(2,:), 'r-*')
% hold on
% plot(Forcast_data(2,:), 'b-o');
% legend('真实值','拟合值')
% title('第2个输出训练集拟合效果')
% subplot(2,2,2);
% plot(test_result(2,:), 'r-*')
% hold on
% plot(Forcast_data_test(2,:), 'b-o');
% legend('真实值','预测值')
% title('第2个输出测试集预测效果')
% subplot(2,2,3);
% stem(train_result(2,:) - Forcast_data(2,:))
% title('第2个输出训练集误差')
% subplot(2,2,4);
% stem(test_result(2,:) - Forcast_data_test(2,:))
% title('第2个输出测试集误差')
% toc
灰色
syms a u;
%构成矩阵c=;
% A=sort(rand(1,20)) * 10;%输入数据，可以修改
data=csvread('1NewTrainTest.csv');
[a,u]=size(data);
A=data(:,u)';
%随机选择1900组作为训练，100组最为测试
% TestNum=M-5;
% input_train=input(1:M,1)';
% output_train=output(1:TestNum,:)';
% input_test=input(TestNum+1:M,:)';
% output_test=output(TestNum+1:M,:)';
Ago=cumsum(A);%原始数据一次累加,得到1-AGO序列xi(1)。
n=length(A);%原始数据个数
for k=1:(n-1)
Z(k)=(Ago(k)+Ago(k+1))/2; %Z(i)为xi(1)的紧邻均值生成序列
end
Yn =A;%Yn为常数项向量
Yn(1)=[]; %从第二个数开始，即x(2),x(3)...
Yn=Yn';
E=[-Z;ones(1,n-1)]';%累加生成数据做均值
c=(E'*E)\(E'*Yn);%利用公式求出a，u
%c= c';
a=c(1);%得到a的值
u=c(2);%得到u的值
F=[];
F(1)=A(1);
for k=2:(n)
F(k)=(A(1)-u/a)/exp(a*(k-1))+u/a;%求出GM(1,1)模型公式
end
G=[];
G(1)=A(1);
for k=2:(n)
G(k)=F(k)-F(k-1);%两者做差还原原序列，得到预测数据
end
b=G';
d=A';
rmse=sqrt(sum((b-d).^2)/length(b));
mape=sum(abs(b-d)./d)/length(b);
% fprintf('经次训练误差为用时%f\n\n',rmse);
% t1=1:n;
% t2=1:n;
% plot(t1,A,'bo-');
% hold on;
% plot(t2,G,'r*-');
% title('预测结果');
% legend('真实值','预测值');
%后验差检验
% e=A-G;
% q=e/A;%相对误差
% s1=var(A);
% s2=var(e);
% c=s2/s1;%方差比
% len=length(e);
% p=0; %小误差概率
% for i=1:len
% if(abs(e(i))<0.6745*s1)
% p=p+1;
% end
% end
% p=p/len;
梯度下降法优化BP神经网络
tic;
data=csvread('1NewTrainTest.csv');
[M,N]=size(data);
input=data(:,1:N-1);
output=data(:,N);
%随机选择1900组作为训练，100组最为测试
TestNum=M-5;
train_data=input(1:TestNum,:)';
train_result=output(1:TestNum,:)';
test_data=input(TestNum+1:M,:)';
test_result=output(TestNum+1:M,:)';
%% 初始化参数
[InDim,TrainSamNum] = size(train_data);% 学习样本数量
[OutDim,TrainSamNum] = size(train_result);
HiddenUnitNum = 5; % 隐含层神经元个数
[SamIn,PS_i] = mapminmax(train_data,0,1); % 原始样本对（输入和输出）初始化
[SamOut,PS_o] = mapminmax(train_result,0,1);
MaxEpochs = 100; % 最大训练次数
lr = 2e-3; % 学习率
E0 = 1e-6; % 目标误差
W1 = rand(HiddenUnitNum, InDim); % 初始化输入层与隐含层之间的权值
B1 = rand(HiddenUnitNum, 1); % 初始化输入层与隐含层之间的阈值
W2 = rand(OutDim, HiddenUnitNum); % 初始化输出层与隐含层之间的权值
B2 = rand(OutDim, 1); % 初始化输出层与隐含层之间的阈值
ErrHistory = zeros(MaxEpochs, 1);
m = 1;
%% 开始迭代
for i = 1 : MaxEpochs
HiddenOut = logsig(W1 * SamIn + repmat(B1, 1, TrainSamNum)); % 隐含层网络输出
NetworkOut = W2 * HiddenOut + repmat(B2, 1, TrainSamNum); % 输出层网络输出
Error = SamOut - NetworkOut; % 实际输出与网络输出之差
SSE = sumsqr(Error); % 能量函数（误差平方和）
ErrHistory(i) = SSE;
if SSE < E0
break;
end
% 权值（阈值）依据能量函数负梯度下降原理所作的每一步动态调整量
Delta2 = Error;
Delta1 = W2' * Delta2 .* HiddenOut .* (1 - HiddenOut);
dW2 = Delta2 * HiddenOut';
dB2 = Delta2 * ones(TrainSamNum, 1);
dW1 = Delta1 * SamIn';
dB1 = Delta1 * ones(TrainSamNum, 1);
% 对输出层与隐含层之间的权值和阈值进行修正
W2 = W2 + lr * dW2;
B2 = B2 + lr * dB2;
% 对输入层与隐含层之间的权值和阈值进行修正
W1 = W1 + lr * dW1;
B1 = B1 + lr * dB1;
if mod(i,MaxEpochs/200)==0
mean_Error(m) = abs(mean(mean(Error)));
% fprintf('经%d次训练，误差为%f，用时%fs\n\n',i,SSE,toc);
E_rr(m) = SSE;
m = m + 1;
end
end
%% 计算结果
HiddenOut = logsig(W1 * SamIn + repmat(B1, 1, TrainSamNum)); % 隐含层输出最终结果
NetworkOut = W2 * HiddenOut + repmat(B2, 1, TrainSamNum); % 输出层输出最终结果
Forcast_data = mapminmax('reverse',NetworkOut,PS_o);
[OutDim,ForcastSamNum] = size(test_result);
SamIn_test= mapminmax('apply',test_data,PS_i); %原始样本对（输入和输出）初始化
HiddenOut_test = logsig(W1 * SamIn_test + repmat(B1, 1, ForcastSamNum)); % 隐含层输出预测结果
NetworkOut = W2 * HiddenOut_test + repmat(B2, 1, ForcastSamNum); % 输出层输出预测结果
Forcast_data_test = mapminmax('reverse',NetworkOut,PS_o);
b=Forcast_data_test';
d=test_result';
rmse=sqrt(sum((b-d).^2)/length(b));
mape=sum(abs(b-d)./d)/length(b);
fprintf('经次训练误,差用时%f\n\n',rmse,mape);
%% 绘制结果
% figure
% subplot(2,1,1);
% plot(E_rr,'r')
% title('累计误差迭代曲线')
% subplot(2,1,2);
% plot(mean_Error)
% title('平均误差迭代曲线')
%
% figure
% subplot(2,2,1);
% plot(train_result(1,:), 'r-*')
% hold on
% plot(Forcast_data(1,:), 'b-o');
% legend('真实值','拟合值')
% title('第1个输出训练集拟合效果')
% subplot(2,2,2);
% plot(test_result(1,:), 'r-*')
% hold on
% plot(Forcast_data_test(1,:), 'b-o');
% legend('真实值','预测值')
% title('第1个输出测试集拟合效果')
% subplot(2,2,3);
% stem(train_result(1,:) - Forcast_data(1,:))
% title('第1个输出训练集误差')
% subplot(2,2,4);
% stem(test_result(1,:) - Forcast_data_test(1,:))
% title('第1个输出测试集误差')
%
% figure
% subplot(2,2,1);
% plot(train_result(2,:), 'r-*')
% hold on
% plot(Forcast_data(2,:), 'b-o');
% legend('真实值','拟合值')
% title('第2个输出训练集拟合效果')
% subplot(2,2,2);
% plot(test_result(2,:), 'r-*')
% hold on
% plot(Forcast_data_test(2,:), 'b-o');
% legend('真实值','预测值')
% title('第2个输出测试集拟合效果')
% subplot(2,2,3);
% stem(train_result(2,:) - Forcast_data(2,:))
% title('第2个输出训练集误差')
% subplot(2,2,4);
% stem(test_result(2,:) - Forcast_data_test(2,:))
% title('第2个输出测试集误差')
Elman
Elman
添加链接描述
添加链接描述
添加链接描述
添加链接描述
添加链接描述
扫一扫
831
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
