2022年 11月 4日

机器学习—西瓜书BP算法python实现

算法流程：

python代码实现：

  1. import numpy as np
  2. np.set_printoptions(suppress=True)  #取消使用科学计数法
  3.  
  4. def Sigmoid(x):  # 激活函数
  5.     function = 1.0 / (1.0 + np.exp(-x))
  6.     return function
  7.  
  8.  
  9. def forward(X, v1, v2, w1, w2, yz1, yz2, yz3, yz4):  # 前向传播
  10.     y_hat1 = []
  11.     y_hat2 = []
  12.     for i in range(X.shape[0]):  # X.shape表示有几个样本
  13.         x = X[i]
  14.         # 隐层的两个神经元的输入值
  15.         h1 = np.dot(x, v1)
  16.         h2 = np.dot(x, v2)
  17.         # 隐层的两个神经元的输出值 也就是 输出层的输入
  18.         h1_out = Sigmoid(h1 - yz1)
  19.         h2_out = Sigmoid(h2 - yz2)
  20.         h_out = np.array([h1_out, h2_out])
  21.         # 输出层的两个神经元的输出层
  22.         out1 = np.dot(h_out, w1)
  23.         out2 = np.dot(h_out, w2)
  24.         # 预测值的输出
  25.         y_hat1.append(Sigmoid(out1 - yz3))
  26.         y_hat2.append(Sigmoid(out2 - yz4))
  27.  
  28.     Y_hat = np.array(list(zip(y_hat1, y_hat2)))  # 训练集对应的预测值
  29.     return Y_hat
  30.  
  31.  
  32. def loss(y, y_hat):  # 误差函数
  33.     out = np.sum((y - y_hat) ** 2) / 2 * y.shape[0]  # y.shape[0]指神经元的个数
  34.     return out
  35.  
  36. # 误差逆传播(标准bp算法)
  37. def BackPropagation(X, v1, v2, w1, w2, yz1, yz2, yz3, yz4, Y, learnrate):  
  38.     Y_hat = forward(X, v1, v2, w1, w2, yz1, yz2, yz3, yz4)
  39.     Ek_sum = 0
  40.     for i in range(X.shape[0]):
  41.         x = X[i]
  42.         # 隐层的两个神经元的输入值
  43.         h1 = np.dot(x, v1)
  44.         h2 = np.dot(x, v2)
  45.         # 隐层的两个神经元的输出值 也就是 输出层的输入
  46.         h1_out = Sigmoid(h1 - yz1)
  47.         h2_out = Sigmoid(h2 - yz2)
  48.         y1 = Y_hat[i][0]
  49.         y2 = Y_hat[i][1]
  50.         Ek = loss(Y[i], Y_hat[i])
  51.         Ek_sum = Ek_sum + Ek
  52.         # 输出层神经元的梯度项
  53.         g1 = y1 * (1 - y1) * (Y[i][0] - y1)
  54.         g2 = y2 * (1 - y2) * (Y[i][1] - y2)
  55.         # 隐层神经元的梯度项
  56.         e1 = h1_out * (1 - h1_out) * (w1[0] * g1 + w1[1] * g2)
  57.         e2 = h2_out * (1 - h2_out) * (w2[0] * g1 + w2[1] * g2)
  58.         # 更新连接权和阈值
  59.         v1[0] = v1[0] + (learnrate * e1 * x[0])
  60.         v1[1] = v1[1] + (learnrate * e2 * x[0])
  61.         v2[0] = v2[0] + (learnrate * e1 * x[1])
  62.         v2[1] = v2[1] + (learnrate * e2 * x[1])
  63.         w1[0] = w1[0] + (learnrate * g1 * h1_out)
  64.         w1[1] = w1[1] + (learnrate * g2 * h1_out)
  65.         w2[0] = w2[0] + (learnrate * g1 * h2_out)
  66.         w2[1] = w2[1] + (learnrate * g2 * h2_out)
  67.         yz1 = yz1 + (-learnrate * e1)
  68.         yz2 = yz2 + (-learnrate * e2)
  69.         yz3 = yz3 + (-learnrate * g1)
  70.         yz4 = yz4 + (-learnrate * g2)
  71.     print(Ek_sum)
  72.     return v1, v2, w1, w2, yz1, yz2, yz3, yz4
  73.  
  74. # 误差逆传播(累计bp算法)
  75. def BackPropagation_accumulate(X, v1, v2, w1, w2, yz1, yz2, yz3, yz4, Y, learnrate):  
  76.     Y_hat = forward(X, v1, v2, w1, w2, yz1, yz2, yz3, yz4)
  77.     Ek_sum = 0
  78.     g1 = []
  79.     g2 = []
  80.     e1 = []
  81.     e2 = []
  82.     for i in range(X.shape[0]):
  83.         x = X[i]
  84.         # 隐层的两个神经元的输入值
  85.         h1 = np.dot(x, v1)
  86.         h2 = np.dot(x, v2)
  87.         # 隐层的两个神经元的输出值 也就是 输出层的输入
  88.         h1_out = Sigmoid(h1 - yz1)
  89.         h2_out = Sigmoid(h2 - yz2)
  90.         y1 = Y_hat[i][0]
  91.         y2 = Y_hat[i][1]
  92.         Ek = loss(Y[i], Y_hat[i])
  93.         Ek_sum = Ek_sum + Ek
  94.         # 输出层神经元的梯度项
  95.         g1.append(y1 * (1 - y1) * (Y[i][0] - y1))
  96.         g2.append(y2 * (1 - y2) * (Y[i][1] - y2))
  97.         # 隐层神经元的梯度项
  98.         e1.append(h1_out * (1 - h1_out) * (w1[0] * g1[i] + w1[1] * g2[i]))
  99.         e2.append(h2_out * (1 - h2_out) * (w2[0] * g1[i] + w2[1] * g2[i]))
  100.         # 更新连接权和阈值
  101.     g1_aver = np.mean(g1)
  102.     g2_aver = np.mean(g2)
  103.     e1_aver = np.mean(e1)
  104.     e2_aver = np.mean(e2)
  105.     v1[0] = v1[0] + (learnrate * e1_aver * x[0])
  106.     v1[1] = v1[1] + (learnrate * e2_aver * x[0])
  107.     v2[0] = v2[0] + (learnrate * e1_aver * x[1])
  108.     v2[1] = v2[1] + (learnrate * e2_aver * x[1])
  109.     w1[0] = w1[0] + (learnrate * g1_aver * h1_out)
  110.     w1[1] = w1[1] + (learnrate * g2_aver * h1_out)
  111.     w2[0] = w2[0] + (learnrate * g1_aver * h2_out)
  112.     w2[1] = w2[1] + (learnrate * g2_aver * h2_out)
  113.     yz1 = yz1 + (-learnrate * e1_aver)
  114.     yz2 = yz2 + (-learnrate * e2_aver)
  115.     yz3 = yz3 + (-learnrate * g1_aver)
  116.     yz4 = yz4 + (-learnrate * g2_aver)
  117.     print(Ek_sum)
  118.     return v1, v2, w1, w2, yz1, yz2, yz3, yz4
  119.  
  120.  
  121. #  ---------------------main-------------------
  122. # 对于输出层神经元，假设好瓜应为10，坏瓜为01
  123. # 在（0,1）范围内随机初始化网络中所有连接权和阈值
  124. v11, v12, v21, v22, w11, w12, w21, w22, yz1, yz2, yz3, yz4 = np.random.random(12)  
  125. v1 = np.array([v11, v12])
  126. v2 = np.array([v21, v22])
  127. w1 = np.array([w11, w12])
  128. w2 = np.array([w21, w22])
  129. # 学习率
  130. learnrate = 0.1
  131. p = [0.634, 0.608, 0.556, 0.403, 0.481, 0.437,
  132.      0.666, 0.639, 0.657, 0.593,0.719]  # 密度
  133. sug = [0.264, 0.318, 0.215, 0.237, 0.149, 0.211,
  134.        0.091, 0.161, 0.198, 0.042,0.103]  # 糖分
  135. Y = np.array([[1, 0], [1, 0], [1, 0], [1, 0], [1, 0], [1, 0],
  136.               [0, 1], [0, 1], [0, 1], [0, 1], [0, 1]])  # y值
  137. X = np.array(list(zip(p, sug)))
  138. a = forward(X, v1, v2, w1, w2, yz1, yz2, yz3, yz4)  # 初始的权值和阈值 算出来的预测值
  139. print(a)
  140. for i in range(10000):
  141.     v1, v2, w1, w2, yz1, yz2, yz3, yz4 = BackPropagation_accumulate(X, v1, v2, w1, w2, yz1, yz2, yz3, yz4, Y, learnrate)  # 训练
  142. b = forward(X, v1, v2, w1, w2, yz1, yz2, yz3, yz4)  # 训练的权值和阈值 算出来的预测值
  143. print(b)

 本次实验中，使用一个隐层，且一个隐层只包含2个神经元，在输出层我使用【0,1】表示坏瓜，【1,0】表示好瓜

 

训练集：

训练之前根据初始的权值和阈值 算出来的预测值：

训练时：误差函数不断下降

 训练10000次后 输出的预测值：

累计BP：误差函数下降的很慢（我认为可能是分类编码的原因）

 

训练了一万次：

下降的非常慢，以我目前的水平还不知道为啥。