【实验目的】

理解神经网络原理，掌握神经网络前向推理和后向传播方法；

掌握神经网络模型的编程实现方法。

【实验内容】

1.1981年生物学家格若根（W.Grogan）和维什（W.Wirth）发现了两类蚊子（或飞蠓midges），他们测量了这两类蚊子每个个体的翼长和触角长，数据如下：

翼长 触角长 类别
1.78 1.14 Apf
1.96 1.18 Apf
1.86 1.20 Apf
1.72 1.24 Apf
2.00 1.26 Apf
2.00 1.28 Apf
1.96 1.30 Apf
1.74 1.36 Af
1.64 1.38 Af
1.82 1.38 Af
1.90 1.38 Af
1.70 1.40 Af
1.82 1.48 Af
1.82 1.54 Af
2.08 1.56 Af

现有三只蚊子的相应数据分别为（1.24，1.80）、（1.28，1.84）、（1.40，2.04），请判断这三只蚊子的类型。

【实验报告要求】

建立三层神经网络模型，编写神经网络训练的推理的代码，实现类型预测；
对照实验内容，撰写实验过程、算法及测试结果，程序不得使用sklearn库；
代码规范化：命名规则、注释；
查阅文献，讨论神经网络的应用场景。

小知识

设计一个神经网络时，输入层与输出层的节点数往往是固定的，中间层则可以自由指定；

神经网络结构图中的拓扑与箭头代表着预测过程时数据的流向，跟训练时的数据流有一定的区别；

结构图里的关键不是圆圈（代表“神经元”），而是连接线（代表“神经元”之间的连接）。每个连接线对应一个不同的权重（其值称为权值），这是需要训练得到的。 

作用

神经元模型的使用可以这样理解：

我们有一个数据，称之为样本。样本有四个属性，其中三个属性已知，一个属性未知。我们需要做的就是通过三个已知属性预测未知属性。

具体办法就是使用神经元的公式进行计算。三个已知属性的值是a1，a2，a3，未知属性的值是z。z可以通过公式计算出来。

这里，已知的属性称之为特征，未知的属性称之为目标。假设特征与目标之间确实是线性关系，并且我们已经得到表示这个关系的权值w1，w2，w3。那么，我们就可以通过神经元模型预测新样本的目标。

前向推理

1     def forward(self,x):
2         h1 = self.w1 * x[0] + self.w2 * x[1] + self.b1
3         h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2
4         out = sigmoid(self.w5 *h1 +self.w6 *h2 +self.b3)
5         return out

神经网络模型

  1 import numpy as np
  2 def sigmoid(x):
  3     return 1 / (1 + np.exp(-x))
  4 def sigmoid_2(x):
  5     return sigmoid(x)*(1-sigmoid(x))
  6 def mes_loss(x,y):
  7     return ((x-y)**2).mean()
  8 class NeuralNetwork():
  9     def __init__(self):
 10         #初始化参数s
 11         self.w1 = np.random.normal()
 12         self.w2 = np.random.normal()
 13         self.w3 = np.random.normal()
 14         self.w4 = np.random.normal()
 15         self.w5 = np.random.normal()
 16         self.w6 = np.random.normal()
 17         self.b1 = np.random.normal()
 18         self.b2 = np.random.normal()
 19         self.b3 = np.random.normal()
 20     def forward(self,x):
 21         h1 = self.w1 * x[0] + self.w2 * x[1] + self.b1
 22         h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2
 23         out = sigmoid(self.w5 *h1 +self.w6 *h2 +self.b3)
 24         return out
 25 
 26     def train(self,data,all_y_trues):
 27         learn_rate = 0.1
 28         epochs = 1000
 29         for epoch in range(epochs):
 30             for x,y_true in zip(data,all_y_trues):
 31                 sum_h1 = self.w1 * x[0] + self.w2 * x[1] + self.b1
 32                 h1 = sigmoid(sum_h1)
 33                 sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2
 34                 h2 = sigmoid(sum_h2)
 35                 sum_o1 = self.w5 *h1 +self.w6 *h2 +self.b3
 36                 o1 = sigmoid(sum_o1)
 37                 y_pred = o1
 38                 d_L_d_ypred = -2 * (y_true - y_pred)
 39                 
 40                 d_ypred_d_w5 = h1*sigmoid_2(sum_o1)
 41                 d_ypred_d_w6 = h2*sigmoid_2(sum_o1)
 42                 d_ypred_d_b3 = sigmoid_2(sum_o1)
 43                 d_ypred_d_h1 = self.w5*sigmoid_2(sum_o1)
 44                 d_ypred_d_h2 = self.w6*sigmoid_2(sum_o1)
 45                 
 46                 d_h1_d_w1 = x[0] * sigmoid_2(sum_h1)
 47                 d_h1_d_w2 = x[1] * sigmoid_2(sum_h1)
 48                 d_h1_d_b1 = sigmoid_2(sum_h1)
 49                 
 50                 d_h2_d_w3 = x[0] * sigmoid_2(sum_h2)
 51                 d_h2_d_w4 = x[1] * sigmoid_2(sum_h2)
 52                 d_h2_d_b2 = sigmoid_2(sum_h2)
 53                 
 54                 self.w1 -= learn_rate* d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w1
 55                 self.w2 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w2
 56                 self.b1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_b1
 57                 
 58                 self.w3 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w3
 59                 self.w4 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w4
 60                 self.b2 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_b2
 61                 
 62                 self.w5 -= learn_rate * d_L_d_ypred * d_ypred_d_w5
 63                 self.w6 -= learn_rate * d_L_d_ypred * d_ypred_d_w6
 64                 self.b3 -= learn_rate * d_L_d_ypred * d_ypred_d_b3
 65                 
 66                 if epoch % 10==0:
 67                     y_preds=np.apply_along_axis(self.forward,1,data)
 68                     loss=mes_loss(all_y_trues,y_preds)
 69                     print("Epoch %d loss:%.3f" % (epoch,loss))
 70                     
 71 
 72     data=np.array([
 73     [1.78,1.14],
 74     [1.96,1.18],
 75     [1.86,1.20],
 76     [1.72,1.24],
 77     [2.00,1.26],
 78     [2.00,1.28],
 79     [1.96,1.30],
 80     [1.74,1.36],
 81     [1.64,1.38],
 82     [1.82,1.38],
 83     [1.90,1.38],
 84     [1.70,1.40],
 85     [1.82,1.48],
 86     [1.82,1.54],
 87     [2.08,1.56],
 88 ])
 89 label = np.array([
 90     1,
 91     1,
 92     1,
 93     1,
 94     1,
 95     1,
 96     1,
 97     0,
 98     0,
 99     0,
100     0,
101     0,
102     0,
103     0,
104     0,
105 ])
106 network=NeuralNetwork()
107 network.train(data,label)
108 
109 #预测
110 test1=np.array([1.24,1.80])
111 test2=np.array([1.28,1.84])
112 test3=np.array([1.40,2.04])
113 print("test1: %.3f" % network.forward(test1))
114 print("test2: %.3f" % network.forward(test2))
115 print("test3: %.3f" % network.forward(test3))
116 for i in (test1,test2,test3):
117     if network.forward(i)>0.5:
118         print("test类型是：Apf")
119     else:
120         print("test类型是：Af")

结果

Epoch 0 loss:0.336
Epoch 0 loss:0.343
Epoch 0 loss:0.349
Epoch 0 loss:0.355
Epoch 0 loss:0.360
Epoch 0 loss:0.366
Epoch 0 loss:0.371
Epoch 0 loss:0.365
Epoch 0 loss:0.358
Epoch 0 loss:0.351
Epoch 0 loss:0.345
Epoch 0 loss:0.338
Epoch 0 loss:0.332
Epoch 0 loss:0.326
Epoch 0 loss:0.320
Epoch 10 loss:0.302
Epoch 10 loss:0.308
Epoch 10 loss:0.314
Epoch 10 loss:0.320
Epoch 10 loss:0.327
Epoch 10 loss:0.334
Epoch 10 loss:0.340
Epoch 10 loss:0.334
Epoch 10 loss:0.327
Epoch 10 loss:0.321
...
test3: 0.000
test类型是：Af
test类型是：Af
test类型是：Af

神经网络的应用场景

神经网络可以用于模式识别、信号处理、知识工程、专家系统、优化组合、机器人控制等