小波神经网络（WNN）的实现（Python，附源码及数据集）

一、理论根本

小波神经网络（Wavelet Neural Network，简称WNN）是基于小波变更理论构造而成，其原理原理与反向传播神经网络（BPNN）较为靠近，最重要的特征是它的隐含层神经元激活函数为小波基函数，这一特性使其充分使用了小波变更的局部化性质和神经网络的大规模数据并行处置惩罚、自学习能力，因而具有较强的逼近能力和较快的收敛速度。
反向传播神经网络（BPNN）原理参考：
反向传播神经网络（BPNN）的实现（Python，附源码及数据集）
1、小波神经网络结构

小波神经网络的结构图如下图所示：

2、前向传播过程

假设输入层、隐含层、输出层的节点数分别为n、i和m，则数据由输出层传递到隐含层时，隐含层第j个节点的输入数据的盘算公式如下：

此中x_k为输入数据中第k个样本数据，ω_kj为隐含层节点的毗连权值。
上述盘算效果在隐含层节点处举行小波基的伸缩厘革，具体的变更公式如下：


此中∅(x)为小波基函数，b_j为基函数的平滑因子，a_j为基函数的伸缩因子，h_j为隐含层第j个节点的输出数据。
最后隐含层第j个节点的输出数据进入输出层，颠末盘算后从输出层的t个节点输出，此节点上的盘算公式如下：

此中ω_jt为输出层的毗连权值，φ为激活函数。
激活函数原理参考：
神经网络根本知识之激活函数
3、反向传播过程

由前向传播过程可以相识到，数据在神经元与神经元之间的传递是单向的，每个神经元只担当上一层神经元传递过来的数据并对其处置惩罚。在这个处置惩罚过程中，小波神经网络重要有四个参数到场盘算，这四个参数分别是小波基函数的平滑因子b_j与伸缩因子a_j以及隐含层与输出层的两个毗连权值，这四个参数值的巨细将直接影响网络的性能。因此WNN的训练过程如BPNN一样重要使用反向传播算法如随机梯度下降法（SGD）对这四个参数举行不绝的修正。
以输出层的权值为例，其更新公式如下：

此中E为误差函数，μ为学习率。
损失函数原理参考：
呆板学习根本知识之损失函数
反向传播原理参考：
神经网络之反向传播算法（梯度、误差反向传播算法BP）
4、建模步调

以使用小波神经网络举行猜测为例，可以将小波神经网络猜测模子的建模步调总结如下：

• 根据输入数据的相干特征确定小波神经网络输入层、隐含层以及输出层的节点数；
  
• 选择一种参数初始化方法对小波神经网络隐含层的毗连权值、平滑因子和伸缩因子、输出层的毗连权值举行随机初始化；
  
• 数据由输入层输入小波神经网络，传递至隐含层后经小波变更对数据举行非线性转换；
  
• 数据在隐含层输出后传递至输出层，在与输出层的毗连权值举行线性盘算后由激活函数举行非线性转换，最后得到网络的前向传播输出；
  
• 选择一种损失函数对网络的前向传播输出以及目标值举行相干盘算得到损失值；
  
• 以输出层的损失值盘算得到输出层毗连权值以及阈值的梯度，选择一种反向传播算法对它们举行调整；
  
• 损失值传递至隐含层，同样使用相同的反向传播算法对隐含层的中心点以及宽度向量举行调整；
  
• 得到一个参数得到更新后的小波神经网络；
  
• 在到达最大迭代次数或满足停止迭代条件之前，重复步调4到步调8，在到达最大迭代次数后，输出全部参数确定的小波神经网络。
  

参数初始化方法参考：
神经网络根本知识之参数初始化
二、小波神经网络的实现

以数据猜测为例，下面先容基于Python实现小波神经网络的过程。
选用某省市的表层土壤重金属元素数据集作为实验数据，该数据集统共96组，随机选择此中的24组作为测试数据集，72组作为训练数据集。选取重金属Ti的含量作为待猜测的输出特征，选取重金属Co、Cr、Mg、Pb作为模子的输入特征。
1、训练过程（WNN.py）

1. #库的导入
2. import numpy as np
3. import pandas as pd
4. import math
6. #激活函数
7. def tanh(x):
8.     return (np.exp(x)-np.exp(-x))/(np.exp(x)+np.exp(-x))
9. #激活函数偏导数
10. def de_tanh(x):
11.     return (1-x**2)
12. #小波基函数
13. def wavelet(x):
14.     return (math.cos(1.75*x)) * (np.exp((x**2)/(-2)))
15. #小波基函数偏导数
16. def de_wavelet(x):
17.     y = (-1) * (1.75 * math.sin(1.75 * x)  + x * math.cos(1.75 * x)) * (np.exp(( x **2)/(-2)))
18.     return y
20. #参数设置
21. samnum = 72   #输入数据数量
22. hiddenunitnum = 8   #隐含层节点数
23. indim = 4   #输入层节点数
24. outdim = 1   #输出层节点数
25. maxepochs = 500   #迭代次数
26. errorfinal = 0.65*10**(-3)   #停止迭代训练条件
27. learnrate = 0.001   #学习率
30. #输入数据的导入
31. df = pd.read_csv("train.csv")
32. df.columns = ["Co", "Cr", "Mg", "Pb", "Ti"]
33. Co = df["Co"]
34. Co = np.array(Co)
35. Cr = df["Cr"]
36. Cr = np.array(Cr)
37. Mg=df["Mg"]
38. Mg=np.array(Mg)
39. Pb = df["Pb"]
40. Pb =np.array(Pb)
41. Ti = df["Ti"]
42. Ti = np.array(Ti)
43. samplein = np.mat([Co,Cr,Mg,Pb])
44. #数据归一化，将输入数据压缩至0到1之间，便于计算，后续通过反归一化恢复原始值
45. sampleinminmax = np.array([samplein.min(axis=1).T.tolist()[0],samplein.max(axis=1).T.tolist()[0]]).transpose()#对应最大值最小值
46. #待预测数据为Ti
47. sampleout = np.mat([Ti])
48. sampleoutminmax = np.array([sampleout.min(axis=1).T.tolist()[0],sampleout.max(axis=1).T.tolist()[0]]).transpose()#对应最大值最小值
49. sampleinnorm = ((np.array(samplein.T)-sampleinminmax.transpose()[0])/(sampleinminmax.transpose()[1]-sampleinminmax.transpose()[0])).transpose()
50. sampleoutnorm = ((np.array(sampleout.T)-sampleoutminmax.transpose()[0])/(sampleoutminmax.transpose()[1]-sampleoutminmax.transpose()[0])).transpose()
52. #给归一化后的数据添加噪声
53. noise = 0.03*np.random.rand(sampleoutnorm.shape[0],sampleoutnorm.shape[1])
54. sampleoutnorm += noise
56. #
57. scale = np.sqrt(3/((indim+outdim)*0.5))
58. w1 = np.random.uniform(low=-scale,high=scale,size=[hiddenunitnum,indim])
59. b = np.random.uniform(low=-scale, high=scale, size=[hiddenunitnum,1])
60. a = np.random.uniform(low=-scale, high=scale, size=[hiddenunitnum,1])
61. w2 = np.random.uniform(low=-scale,high=scale,size=[hiddenunitnum,outdim])
63. #对隐含层的连接权值w1、平滑因子被b和伸缩因子a、输出层的连接权值w2进行随机初始化
64. inputin=np.mat(sampleinnorm.T)
65. w1=np.mat(w1)
66. b=np.mat(b)
67. a=np.mat(a)
68. w2=np.mat(w2)
70. #errhistory存储每次迭代训练计算的误差
71. errhistory = np.mat(np.zeros((1,maxepochs)))
72. #开始训练
73. for i in range(maxepochs):
74.     #前向计算：
75.     #hidden_out为隐含层输出
76.     hidden_out = np.mat(np.zeros((samnum,hiddenunitnum)))
77.     for m in range(samnum):
78.         for j in range(hiddenunitnum):
79.             d=((inputin[m, :] * w1[j, :].T) - b[j,:]) * (a[j,:] ** (-1))
80.             hidden_out[m,j] = wavelet(d)
81.     #output为输出层输出
82.     output = tanh(hidden_out * w2)
83.     #计算误差
84.     out_real = np.mat(sampleoutnorm.transpose())
85.     err = out_real - output
86.     loss = np.sum(np.square(err))
87.     #判断是否停止训练
88.     if loss < errorfinal:
89.         break
90.     errhistory[:,i] = loss
91.     #反向计算
92.     out_put=np.array(output.T)
93.     belta=de_tanh(out_put).transpose()
94.     #分别计算每个参数的误差项
95.     for j in range(hiddenunitnum):
96.         sum1 = 0.0
97.         sum2 = 0.0
98.         sum3 = 0.0
99.         sum4 = 0.0
100.         sum5 = 0.0
101.         for m in range(samnum):
102.             sum1+= err[m,:] * belta[m,:] * w2[j,:] * de_wavelet(hidden_out[m,j]) * (inputin[m,:] / a[j,:])
103.             #1*1
104.             sum2+= err[m,:] * belta[m,:] * w2[j,:] * de_wavelet(hidden_out[m,j]) * (-1) * (1 / a[j,:])
105.             #1*1
106.             sum3+= err[m,:] * belta[m,:] * w2[j,:] * de_wavelet(hidden_out[m,j]) * (-1) * ((inputin[m,:] * w1[j,:].T - b[j,:]) / (a[j,:] * a[j,:]))
107.             #1*1
108.             sum4+= err[m,:] * belta[m,:] * hidden_out[m,j]
109.         delta_w1 = sum1
110.         delta_b = sum2
111.         delta_a = sum3
112.         delta_w2 = sum4
113.         #根据误差项对四个参数进行更新
114.         w1[j,:] = w1[j,:] + learnrate * delta_w1
115.         b[j,:] = b[j,:] + learnrate * delta_b
116.         a[j,:] = a[j,:] + learnrate * delta_a
117.         w2[j,:] = w2[j,:] + learnrate * delta_w2
118.     print("the generation is:",i+1,",the loss is:",loss)
120. print('更新的w1:',w1)
121. print('更新的b:',b)
122. print('更新的w2:',w2)
123. print('更新的a:',a)
124. print("The loss after iteration is ：",loss)
126. np.save("w1.npy",w1)
127. np.save("b.npy",b)
128. np.save("w2.npy",w2)
129. np.save("a.npy",a)

复制代码

2、测试过程（test.py）

1. #库的导入
2. import numpy as np
3. import pandas as pd
4. import math
6. #小波基函数
7. def wavelet(x):
8.     return (math.cos(1.75*x)) * (np.exp((x**2)/(-2)))
9. #激活函数tanh
10. def tanh(x):
11.     return (np.exp(x)-np.exp(-x))/(np.exp(x)+np.exp(-x))
14. #输入数据的导入，用于测试数据的归一化与返归一化
15. df = pd.read_csv("train.csv")
16. df.columns = ["Co", "Cr", "Mg", "Pb", "Ti"]
17. Co = df["Co"]
18. Co = np.array(Co)
19. Cr = df["Cr"]
20. Cr = np.array(Cr)
21. Mg=df["Mg"]
22. Mg=np.array(Mg)
23. Pb = df["Pb"]
24. Pb =np.array(Pb)
25. Ti = df["Ti"]
26. Ti = np.array(Ti)
27. samplein = np.mat([Co,Cr,Mg,Pb])
28. sampleinminmax = np.array([samplein.min(axis=1).T.tolist()[0],samplein.max(axis=1).T.tolist()[0]]).transpose()#对应最大值最小值
29. sampleout = np.mat([Ti])
30. sampleoutminmax = np.array([sampleout.min(axis=1).T.tolist()[0],sampleout.max(axis=1).T.tolist()[0]]).transpose()#对应最大值最小值
32. #导入WNN.py训练好的参数
33. w1=np.load('w1.npy')
34. b=np.load('b.npy')
35. a=np.load('a.npy')
36. w2=np.load('w2.npy')
37. w1 = np.mat(w1)
38. w2 = np.mat(w2)
39. b = np.mat(b)
40. a = np.mat(a)
42. #隐含层节点数
43. hiddenunitnum = 8
44. #测试数据数量
45. testnum = 24
48. #测试数据的导入
49. df = pd.read_csv("test.csv")
50. df.columns = ["Co", "Cr", "Mg", "Pb", "Ti"]
51. Co = df["Co"]
52. Co = np.array(Co)
53. Cr = df["Cr"]
54. Cr = np.array(Cr)
55. Mg=df["Mg"]
56. Mg=np.array(Mg)
57. Pb = df["Pb"]
58. Pb =np.array(Pb)
59. Ti = df["Ti"]
60. Ti = np.array(Ti)
61. input=np.mat([Co,Cr,Mg,Pb])
63. #测试数据中输入数据的归一化
64. inputnorm=(np.array(input.T)-sampleinminmax.transpose()[0])/(sampleinminmax.transpose()[1]-sampleinminmax.transpose()[0])
65. #hidden_out2用于保存隐含层输出
66. hidden_out = np.mat(np.zeros((testnum,hiddenunitnum)))
67. #计算隐含层输出
68. for m in range(testnum):
69.     for j in range(hiddenunitnum):
70.         d = ((inputnorm[m, :] * w1[j, :].T) - b[j, :]) * (a[j, :] ** (-1))
71.         hidden_out[m, j] = wavelet(d)
72. #计算输出层输出
73. output = tanh(hidden_out * w2 )
74. #对输出结果进行反归一化
75. diff = sampleoutminmax[:,1]-sampleoutminmax[:,0]
76. networkout2 = output*diff+sampleoutminmax[0][0]
77. networkout2 = np.array(networkout2).transpose()
78. output1=networkout2.flatten()#降成一维数组
79. output1=output1.tolist()
80. for i in range(testnum):
81.     output1[i] = float('%.2f'%output1[i])
82. print("the prediction is:",output1)
84. #将输出结果与真实值进行对比，计算误差
85. output=Ti
86. rmse = (np.sum(np.square(output-output1))/len(output)) ** 0.5
87. mae = np.sum(np.abs(output-output1))/len(output)
88. average_loss1=np.sum(np.abs((output-output1)/output))/len(output)
89. mape="%.2f%%"%(average_loss1*100)
90. f1 = 0
91. for m in range(testnum):
92.     f1 = f1 + np.abs(output[m]-output1[m])/((np.abs(output[m])+np.abs(output1[m]))/2)
93. f2 = f1 / testnum
94. smape="%.2f%%"%(f2*100)
95. print("the MAE is :",mae)
96. print("the RMSE is :",rmse)
97. print("the MAPE is :",mape)
98. print("the SMAPE is :",smape)
100. #计算预测值与真实值误差与真实值之比的分布
101. A=0
102. B=0
103. C=0
104. D=0
105. E=0
106. for m in range(testnum):
107.     y1 = np.abs(output[m]-output1[m])/np.abs(output[m])
108.     if y1 <= 0.1:
109.         A = A + 1
110.     elif y1 > 0.1 and y1 <= 0.2:
111.         B = B + 1
112.     elif y1 > 0.2 and y1 <= 0.3:
113.         C = C + 1
114.     elif y1 > 0.3 and y1 <= 0.4:
115.         D = D + 1
116.     else:
117.         E = E + 1
118. print("Ratio <= 0.1 :",A)
119. print("0.1< Ratio <= 0.2 :",B)
120. print("0.2< Ratio <= 0.3 :",C)
121. print("0.3< Ratio <= 0.4 :",D)
122. print("Ratio > 0.4 :",E)

复制代码

3、测试效果


注：由于每次初始化天生的参数差别，因此对参数设置相同的神经网络举行多次训练和猜测，测试效果不会完全一致，此外测试效果的好坏也会受到隐含层节点数、学习率、训练次数等参数的影响。
4、参考源码及实验数据集

参考源码及实验数据集

来源：https://blog.csdn.net/weixin_42051846/article/details/128765295
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！