小波神经网络预测的代码1
- 格式:docx
- 大小:16.46 KB
- 文档页数:3
基于小波神经网络的Shibor预测摘要:上海银行间同业拆放利率(Shibor)的推出是中国利率市场化重要的一步。
通过分别建立小波神经网络和回归时间序列组合模型预测2周品种Shibor并作对比分析,结果表明小波神经网络的拟合和预测精度较高,具有一定的科学性和实用性。
关键词:Shibor;小波神经网络;回归时间序列组合;预测一、引言基准利率的形成是利率市场化的重要前提。
以货币市场利率为中介,由市场供求决定金融机构存贷款利率的市场利率体系机制已成为趋势[1],如英国的Libor、美国的联邦基金有效利率和香港的Hibor等。
各国、地区的中央银行通过对基准利率的调控来协调资金供求,实现货币政策目标。
资金在不同金融市场之间流动,影响其流向的一个重要因素是资金成本,而衡量资金成本则需要一个反映市场供求的基准利率[2]。
2007年1月4日上海银行间同业拆放利率(Shanghai Interbank Offered Rate,简称Shibor)的推出正是央行为打造中国金融市场的基准利率而采取的一个重要举措。
目前,国内许多学者展开了对Shibor理论的探讨和研究,大多数从Shibor 的利率市场化及作用进行分析,如姚秦(2007)、刘喜波(2008)、苏昌蕾(2011)等[3-5]。
对于Shibor的预测文献比较少,而且假设的条件、采取的方法以及考虑的变量也不同。
周颖颖等(2009)利用带跳Vasicek单因子利率模型预测3个月的Shibor报价,但其样本量有限,未考虑多因子模型描述Shibor的适用性[6]。
田敏等(2009)应用ARMA模型对1周的Shibor价格进行分析,预测结果与真实值误差偏大[7]。
杨宝臣和苏云鹏(2010)使用Shibor日观测数据对预期理论进行检验,结果发现短端和长端利率分别存在波动趋势和线性漂移趋势,进而得出预期理论对这两类利率分别适用,但是对整体并不适用的结论[7]。
综上,目前针对Shibor的理论研究和实践处于摸索阶段,其走势需要利用模型仿真测试。
本人编辑了一个预测模型的程序,但是matlab老是提示出错,请各位大虾指教:非常感谢!!!>> clear all;%define the input and outputp= [974 874 527;388 466 1764;1316 2439 2251;1836 2410 1860;1557 2301 1578;1490 1877 2749;1513 1278 2026;1070 1561 2794;1347 2415 3306;1324 2746 1233;1383 1463 1847;1282 0 2347];t=[19797;24282;34548];% 创建bp网络和定义训练函数net=newff([388 3306],[15 1],{'tansig' 'purelin'});net.trainparam.goal=50;net.trainparam.epochs=5000;%训练神经网络[net,tr]=train(net,p,t);%输出训练后的权值和阈值iw1=net.IW{1};b1=net.b{1};lw2=net.LW{2};b2=net.b{2};%存储训练好的神经网络save netkohler net??? Error using ==> network.trainInputs are incorrectly sized for network.Matrix must have 1 rows.修改后:>> clear all;%define the input and outputp= [974 874 527;388 466 1764;1316 2439 2251;1836 2410 1860;1557 2301 1578;1490 1877 2749;1513 1278 2026;1070 1561 2794;1347 2415 3306;1324 2746 1233;1383 1463 1847;1282 0 2347];t=[19797;24282;34548];% 创建bp网络和定义训练函数net=newff([388 1836;466 2746;527 3306],[15 1],{'tansig' 'purelin'});net.trainparam.goal=50;net.trainparam.epochs=5000;%训练神经网络[net,tr]=train(net,p,t);%输出训练后的权值和阈值iw1=net.IW{1};b1=net.b{1};lw2=net.LW{2};b2=net.b{2};%存储训练好的神经网络save netkohler net??? Error using ==> network.trainInputs are incorrectly sized for network.Matrix must have 3 rows.clear all;%define the input and outputp= [974 874 527;388 466 1764;1316 2439 2251;1836 2410 1860;1557 2301 1578;1490 1877 2749;1513 1278 2026;1070 1561 2794;1347 2415 3306;1324 2746 1233;1383 1463 1847;1282 0 2347];t=[19797 24282 34548];% 创建bp网络和定义训练函数pr=[527 974;388 1764;1316 2439;1836 2410;1557 2301;1490 2749;%这里是为了方便而建立一个矩阵,注意是12x2,不是3x21278 2026;1070 2794;1347 3306;1233 2746;1383 1847;0 2347]net=newff(pr,[15,1],{'tansig' 'purelin'},'trainlm');%这里要加入输出层的转移函数,一般是trainlm net.trainparam.goal=50;net.trainparam.epochs=5000;%训练神经网络[net,tr]=train(net,p,t);%输出训练后的权值和阈值iw1=net.IW{1};b1=net.b{1};lw2=net.LW{2};b2=net.b{2};%存储训练好的神经网络save netkohler net。
BP神经网络算法代码以下是一个简单实现的BP神经网络算法代码,实现了一个简单的二分类任务。
代码主要分为四个部分:数据准备、网络搭建、训练和预测。
```pythonimport numpy as np#数据准备def prepare_data(:X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) # 输入数据return X, y#网络搭建def build_network(X, y, hidden_dim):input_dim = X.shape[1] # 输入维度output_dim = y.shape[1] # 输出维度#初始化权重和偏置np.random.seed(0)W1 = np.random.randn(input_dim, hidden_dim) /np.sqrt(input_dim)b1 = np.zeros((1, hidden_dim))W2 = np.random.randn(hidden_dim, output_dim) / np.sqrt(hidden_dim)b2 = np.zeros((1, output_dim))return W1, b1, W2, b2#前向传播def forward_propagation(X, W1, b1, W2, b2):z1 = np.dot(X, W1) + b1a1 = sigmoid(z1)z2 = np.dot(a1, W2) + b2a2 = sigmoid(z2)return a1, a2#激活函数def sigmoid(x):return 1 / (1 + np.exp(-x))#反向传播def backward_propagation(X, y, a1, a2, W1, W2): m = X.shape[0] # 样本数量#计算损失loss = np.sum((a2-y)**2) / (2*m)#计算梯度delta2 = 1/m * (a2-y) * a2 * (1-a2)dW2 = np.dot(a1.T, delta2)db2 = np.sum(delta2, axis=0, keepdims=True)delta1 = np.dot(delta2, W2.T) * a1 * (1-a1)dW1 = np.dot(X.T, delta1)db1 = np.sum(delta1, axis=0)return loss, dW1, db1, dW2, db2#更新参数def update_parameters(W1, b1, W2, b2, dW1, db1, dW2, db2, learning_rate):W1 -= learning_rate * dW1b1 -= learning_rate * db1W2 -= learning_rate * dW2b2 -= learning_rate * db2return W1, b1, W2, b2#训练def train(X, y, hidden_dim, num_epochs, learning_rate):W1, b1, W2, b2 = build_network(X, y, hidden_dim)for epoch in range(num_epochs):a1, a2 = forward_propagation(X, W1, b1, W2, b2)loss, dW1, db1, dW2, db2 = backward_propagation(X, y, a1, a2, W1, W2)W1, b1, W2, b2 = update_parameters(W1, b1, W2, b2, dW1, db1, dW2, db2, learning_rate)if (epoch+1) % 100 == 0:print("Epoch {}: loss = {}".format(epoch+1, loss))return W1, b1, W2, b2#预测def predict(X, W1, b1, W2, b2):_, a2 = forward_propagation(X, W1, b1, W2, b2)predictions = (a2 > 0.5).astype(int)return predictions#主函数def main(:X, y = prepare_datahidden_dim = 3num_epochs = 1000learning_rate = 0.1W1, b1, W2, b2 = train(X, y, hidden_dim, num_epochs, learning_rate)predictions = predict(X, W1, b1, W2, b2)print("Predictions:", predictions)if __name__ == "__main__":main```注意:这段代码只是一个简单的实现,可能在复杂任务上效果不佳。
附录1:基于MATLAB的神经网络代码%P58机组对一天的预测代码p=0:0.25:671.75;t=load('D:\数据建模\P58.txt');t=t';[pn,meanp,stdp,tn,meant,stdt]=prestd(p,t);%对数据进行归一化[R,Q]=size(pn);iitst=2:4:Q;iival=4:4:Q;iitr=[1:4:Q 3:4:Q];vv.P=pn(:,iival);vv.T=tn(:,iival);vt.P=pn(:,iitst);vt.T=tn(:,iitst);ptr=pn(:,iitr);ttr=tn(:,iitr);net=newff(minmax(ptr),[30 1],{'tansig' 'purelin'},'trainlm');%训练网络net.trainParam.show=25;[net,tr]=train(net,ptr,ttr,[],[],vv,vt);%绘制出训练过程中个误差变化曲线plot(tr.epoch,tr.perf,'r',tr.epoch,tr.vperf,':g',tr.epoch,tr.tperf,'-.b'); legend('训练','正确','²âÊÔ',-1);ylabel('平方误差');xlabel('时间');an=sim(net,pn);a=poststd(an,meant,stdt);figureplot(p,a);%得到一组输出,所以有一个线性回归figure[m(1),b(1),r(1)] = postreg(a(1,:),t(1,:));%得到神经网络逼近曲线和原始曲线figureplot(p,a,'r-',p,t,':');legend('逼近曲线','原来数据曲线,-1);ylabel('功率/KW');xlabel('时间/h');ppp=p(2016:2111); % 预测向量ttt=t(2016:2111);aaa=a(2016:2111);figureplot(ppp,ttt,':',ppp,aaa,'-');legend('风电功率','预测结果',-1);ylabel('功率/KW');xlabel('时间/h');dv=ttt-aaa;figureplot(ppp,dv);dv2=sum(abs(ttt-aaa))/96/49300;%平均绝对误差r2=(1-sqrt(sum(((ttt-aaa)/49300).^2)/96));%r2准确率附录2:基于时间序列的ARMA模型数据处理的部分代码x1=load('E:/1.txt');y1=load('E:/2.txt'); %导入数据,把待预测区间的实测数据和预测数据分别读入到变量x1,y1,x2,y2...a1,b1,a2,b2...a6,b6x1=x1';y1=y1';%数据转置以便于操作,下同x2=load('E:/3.txt');y2=load('E:/4.txt');x2=x2';y2=y2';x3=load('E:/5.txt');y3=load('E:/6.txt');x3=x3';y3=y3';x4=load('E:/7.txt');y4=load('E:/8.txt');x4=x4';y4=y4';x5=load('E:/9.txt');y5=load('E:/10.txt');x5=x5';y5=y5';x6=load('E:/11.txt');y6=load('E:/12.txt');x6=x6';y6=y6';p=2017:2688;%对应时间段为5月31日0时0分至23时45分%subplot(2,3,1);%绘图%plot(p,x1,p,y1);a1=x1(1:96);b1=y1(1:96);a2=x2(1:96);b2=y2(1:96);a3=x3(1:96);b3=y3(1:96);a4=x4(1:96);b4=y4(1:96);a5=x5(1:96);b5=y5(1:96);a6=x6(1:96);b6=y6(1:96);m=2017:2112;%对应时间段为5月31日0时0分至6月6日23时45分%plot(m,a6,m,b6);%求一周预测精度p58=sum(abs(x6-y6))/672/49300;%求平均绝对误差p4=sum(abs(x5-y5))/672/3400;%求平均绝对误差pd=sum(abs(x4-y4))/672/850;%求平均绝对误差pc=sum(abs(x3-y3))/672/850;%求平均绝对误差pb=sum(abs(x2-y2))/672/850;%求平均绝对误差pa=sum(abs(x1-y1))/672/850;%求平均绝对误差p581=(1-sqrt(sum(((x6-y6)/49300).^2)/672))%求准确率p41=(1-sqrt(sum(((x5-y5)/3400).^2)/672))%求准确率pd1=(1-sqrt(sum(((x4-y4)/850).^2)/672))%求准确率pc1=(1-sqrt(sum(((x3-y3)/850).^2)/672))%求准确率pb1=(1-sqrt(sum(((x2-y2)/850).^2)/672))%求准确率pa1=(1-sqrt(sum(((x1-y1)/850).^2)/672))%求准确率%求一天预测精度p582=sum(abs(a6-b6))/96/49300;%求平均绝对误差p42=sum(abs(a5-b5))/96/3400;%求平均绝对误差pd2=sum(abs(a4-b4))/96/850;%求平均绝对误差pc2=sum(abs(a3-b3))/96/850;%求平均绝对误差pb2=sum(abs(a2-b2))/96/850;%求平均绝对误差pa2=sum(abs(a1-b1))/96/850;%求平均绝对误差p583=(1-sqrt(sum(((a6-b6)/49300).^2)/96))%求准确率p43=(1-sqrt(sum(((a5-b5)/3400).^2)/96))%求准确率pd3=(1-sqrt(sum(((a4-b4)/850).^2)/96))%求准确率pc3=(1-sqrt(sum(((a3-b3)/850).^2)/96))%求准确率pb3=(1-sqrt(sum(((a2-b2)/850).^2)/96))%求准确率pa3=(1-sqrt(sum(((a1-b1)/850).^2)/96))%求准确率H=[p58,p4,pd,pc,pb,pa]%每个预测量一周预测平均绝对误差矩阵H1=[p581,p41,pd1,pc1,pb1,pa1]%每个预测量一周预测准确率矩阵H2=[p582,p42,pd2,pc2,pb2,pa2]%每个预测量一日预测平均绝对误差矩阵H3=[p583,p43,pd3,pc3,pb3,pa3]%每个预测量一日预测准确率矩阵。
⾃⼰动⼿实现机器学习算法:神经⽹络(附源代码)神经⽹络的⼀些原理这不做介绍,不清楚的可以搜索相关博客和数据,资料相对较多。
下⾯开始正题⼆、神经⽹络的算法的核⼼过程:2.1. 前向传播求损失2.2. 反向传播更新w3.1.定义激活函数激活函数⼀般有双曲函数和逻辑函数其导数: 1.2 逻辑函数(logistic function) 代码:#!/usr/bin/env # -*- coding:utf-8 -*- import numpy as np def tanh(x): return np.tanh(x) def tanh_derivative(x): return 1.0 - np.tanh(x) * np.tanh(x) def logistic(x): return 1 / (1 + np.exp(-x)) def logistic_derivative(x): return logistic(x) * (1 - logistic(x) ) 3.2 然后定义两层的神经⽹络的class,初始化激活函数,和权值:给权值随机赋值,权值的范围[-0.25,0.25)class NeuralNetworkWith2layers: def __init__(self, layers, activation='tanh'): if activation == 'Logistic': self.activation = logisticself.activation_deriv = logistic_derivative elif activation == 'tanh': self.activation = tanh self.activation_deriv = tanh_derivative self.weights = [] for i in range(1, len(layers)-1): # 初始化权值范围 [-0.25,0.25) # [0,1) * 2 - 1 => [-1,1) => * 0.25 => [-0.25,0.25) self.weights.append( (2*np.random.random((layers[i-1] + 1, layers[i] + 1 ))-1 ) * 0.25 ) self.weights.append( (2*np.random.random((layers[i] + 1, layers[i+1] ))-1 ) * 0.25 ) 3.3下⾯实现神经⽹络的核⼼训练逻辑向前传播计算损失和相互传播更新w3.3.1、函数申明:def fit(self, X, y, learning_rate=0.2, epochs = 10000):参数X为样本数据,y为标签数据,learning_rate 为学习率默认0.2,epochs 为迭代次数默认值100003.3.2、数据预处理:X = np.atleast_2d(X) X = np.column_stack((X, np.ones(len(X)))) y = np.array(y) 上⾯代码,给X加了⼀个值为1的维度,y变成numpy中的array类型3.3.3、数据训练 def fit(self, X, y, learning_rate=0.2, epochs = 10000): X = np.atleast_2d(X) temp = np.ones([X.shape[0],X.shape[1]+1]) temp[:,0:-1] = X X = temp y = np.array(y) for k in range(epochs): i = np.random.randint(X.shape[0]) a = [X[i]] # 正向计算 for l in range(len(self.weights)): a.append(self.activation( np.dot(a[l], self.weights[l])) ) # 反向传播 error = y[i] - a[-1] deltas = [error *self.activation_deriv(a[-1])] # starting backprobagation layerNum = len(a) - 2 for j in range(layerNum, 0, -1): # 倒数第⼆层开始deltas.append(deltas[-1].dot(self.weights[j].T) * self.activation_deriv(a[j])) deltas.reverse() # 更新权值 for i in range(len(self.weights)): layer = np.atleast_2d(a[i]) delta = np.atleast_2d(deltas[i]) self.weights[i] += learning_rate * layer.T.dot(delta) 正向计算部分:将每层的计算节点值保存在⼆维数组a中,下⾯反向传播更新权值时候会⽤到该数据。
clc;
clear all;
%设定期望的误差最小值
err_goal=0.01;
%设定最大循环次数
max_epoch=50;
%设定修正权值的学习速率0.01-0.7
lr=0.7;
epoch=0;
x=0:0.01:0.3;%输入时间序列
%d=sin(8*pi*x)+sin(4*pi*x)+5*sin(pi*x);%
d=[1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 10 9 8 7];%目标输出序列
M=size(x,2);%输入节点的个数
N=M;%输出节点的个数
n=10;%隐形节点的个数
%这个地方需要改进,由于实际上隐形节点的个数可以通过小波的时频分析确定
Wjk=randn(n,M);
Wij=randn(N,n);
% a=randn(1,n);
a=1:1:n;
b=randn(1,n);
% stepa=0.2*(x(M)-x(1));
% a=stepa:1n-1)+stepa;
% step=(x(M)-x(1))/n;
% b=x(1)+step:step:x(1)+n*step;
% y=zeros(1,N);%输出节点初始化
y=zeros(1,N);%输出节点初始化
net=zeros(1,n);%隐形节点初始化
net_ab=zeros(1,n);%隐形节点初始化
%step2--------对网络进行训练-------------------------------------------
for i=1:1:N
for j=1:1:n
for k=1:1:M
net(j)=net(j)+Wjk(j,k)*x(k);
net_ab(j)=(net(j)-b(j))/a(j);
end
y(i)=y(i)+Wij(i,j)*mymorlet(net_ab(j));
%mymorlet是judyever编写的小波函数,以后可以扩展成输入不同的小波名字即可
% y(i)=mysigmoid(2,y(i));
end
end
% plot(x,d,'r',x,y);
% title('训练前的目标序列和实际输出序列');
err=d-y;
SSE=err*err';
%step3--------调整各个参数-------------------------------------------
while (SSE>err_goal & epoch
d_Wij=zeros(N,n);
d_a=zeros(1,n);
d_b=zeros(1,n);
for i=1:1:N
for j=1:1:n
d_Wij(i,j)=-(d(i)-y(i))*mymorlet(net_ab(j));
%调整d_Wij(i,j)
for k=1:1:M
d_Wjk(j,k)=d_Wjk(j,k)+ (d(i)-y(i)) * Wij(i,j) ;%计算还没有结束
d_Wjk(j,k)=-d_Wjk(j,k)*d_mymorlet(net_ab(j))*x(k)/a(j);%计算结束
end
%调整d_Wjk(j,k)
d_b(j)=d_b(j)+(d(i)-y(i))*Wij(i,j);%计算还没有结束
d_b(j)=d_b(j)*d_mymorlet(net_ab(j))/a(j);%计算结束
%调整d_b(j)
d_a(j)=d_a(j)+(d(i)-y(i))*Wij(i,j);%计算还没有结束
d_a(j)=d_a(j)*d_mymorlet(net_ab(j))*((net(j)-b(j))/b(j))/a(j);%计算结束
%调整d_a(j)
end
end
%step4--------网络重新计算-------------------------------------------
Wij=Wij-lr*d_Wij;
Wjk=Wjk-lr*d_Wjk;
b=b-lr*d_b;
a=a-lr*d_a;
%修正各个权值
y=zeros(1,N);%输出节点初始化
net=zeros(1,n);%隐形节点初始化
net_ab=zeros(1,n);%隐形节点初始化
for i=1:1:N
for j=1:1:n
for k=1:1:M
net(j)=net(j)+Wjk(j,k)*x(k);
net_ab(j)=(net(j)-b(j))/a(j);
end
y(i)=y(i)+Wij(i,j)*mymorlet(net_ab(j));
%mymorlet是judyever编写的小波函数,以后可以扩展成输入不同的小波名字即可
% y(i)=mysigmoid(2,y(i));
end
end
epoch=epoch+1;
err=d-y;
SSE=err*err'/M;
[ epoch SSE]
end
%step5--------输出-------------------------------------------
plot(x,d,'r',x,y,':');
title('训练后的目标序列和实际输出序列');
% gtext({'This is the first line','This is the second line'})
% gtext({'First line','Second line'},'FontName','Times','Fontsize',12)
legend('target output','WNN output',1);