ToB企服应用市场:ToB评测及商务社交产业平台

标题: 【深度学习】神经网络和BP算法(含源码实现) [打印本页]

作者: 伤心客    时间: 2024-7-30 07:18
标题: 【深度学习】神经网络和BP算法(含源码实现)
神经网络(neural networks)

神经元

感知机模型(Perceptron)

感知机模型

感知机是由神经元复合的线性分类器
                                         y                            =                            f                            (                                       ∑                                           i                                  =                                  1                                          n                                                 w                               i                                                 x                               i                                      −                            θ                            )                            =                            f                            (                                       w                               T                                      x                            −                            θ                            )                                  y =f(\sum_{i=1}^n w_ix_i -\theta) = f(w^Tx-\theta)                     y=f(i=1∑n​wi​xi​−θ)=f(wTx−θ)
此中:

如何这里的                                   f                              f                  f为阶跃函数                                   ϵ                         (                         ⋅                         )                              \epsilon(·)                  ϵ(⋅),则感知机模型可以表示为激活函数:
                                         (                            1                            )                            y                            =                            ϵ                            (                                       w                               T                                      x                            −                            θ                            )                            =                                       {                                                                                                                                                    1                                              ,                                                               w                                                 T                                                              x                                              >                                              =                                              θ                                                                                                                                                                                                 0                                              ,                                                               w                                                 T                                                              x                                              <                                              θ                                                                                                             (1)y =\epsilon(w^Tx-\theta) =\left\{ \begin{matrix} \ 1,w^Tx>=\theta\\ \ 0,w^Tx<\theta \end{matrix} \right.                     (1)y=ϵ(wTx−θ)={ 1,wTx>=θ 0,wTx<θ​
由                                   n                              n                  n维空间中的超平面方程:
                                                    w                               1                                                 x                               1                                      +                                       w                               2                                                 x                               2                                      +                                       w                               3                                                 x                               3                                      +                            .                            .                            .                            +                                       w                               n                                                 x                               n                                      +                            b                            =                                       w                               T                                      x                            +                            b                            =                            0                                  w_1x_1+w_2x_2+w_3x_3+...+w_nx_n+b=w^Tx+b=0                     w1​x1​+w2​x2​+w3​x3​+...+wn​xn​+b=wTx+b=0
可知                                   (                         1                         )                              (1)                  (1)式将n维空间分别,可以看作一个超平面,将n维空间分别为                                             w                            T                                  x                         >                         =                         θ                              w^Tx>=\theta                  wTx>=θ和                                             w                            T                                  x                         <                         θ                              w^Tx<\theta                  wTx<θ两个空间,落在前者的输出值为1,后者的输出值为0,于是实现了分类功能。
感知机的学习策略以及参数的调整规则

所以线性模型中的思考,我们必要对权重向量                                             w                            T                                       w^T                  wT和偏置                                   θ                              \theta                  θ进行选择,这就是感知机的学习
不妨考虑一种简单的环境,如今有特性矩阵                                             x                            1                                       x_1                  x1​=[2, 3],                                             x                            2                                       x_2                  x2​=[1,5],包含标签的向量                                   y                         =                         {                         1                         ,                         0                         }                              y=\{1,0\}                  y={1,0}

每层神经元与下一层神经元全互连,同层神经元不进行连接,也不跨层连接,上一层神经元的输出作为下一层神经元的输入,我们界说这样的神经网络为"多层前馈神经网络"(multi-layer feedback neural networks).神经元之间用**“连接权”和阈值**进行连接。
单隐层前馈网络是指只有一个隐藏层,双隐层前馈网络有两层隐藏层,必要留意的是,输入层神经元没有激活函数进行处理,仅仅作为输入。
误差逆流传算法(BP神经网络)

由于构造了复杂的学习模型多层前馈神经网络,我们的单层感知机模型的学习方法                                   Δ                         w                         =                         η                         (                         y                         −                                   y                                       p                               r                               e                               d                                            )                         x                              \Delta w = η(y-y_{pred})x                  Δw=η(y−ypred​)x
                                    Δ                         θ                         =                         −                         η                         (                         y                         −                                   y                                       p                               r                               e                               d                                            )                              \Delta\theta = -η(y-y_{pred})                  Δθ=−η(y−ypred​)已经无法正常运行。因此我们必要更实用的算法。
**误差逆流传算法(error BackPropagation,BP)**是一种实用于多层前馈神经网络的学习算法(BP算法不止实用于多层前馈神经网络)。

我们来解释一下BP算法的具体过程。
BP算法手动实现

对每个训练样例,BP算法执行以下操作:
(1)先将输入示例提供给输入层神经元,然后逐层将信号前传,直到产生输出层的结果;
(2)然后计算输出层的误差(第4-5行)
(3)再将误差逆向流传至隐层神经元(第6行)
(4)最后根据各层神经元的误差来对连接权和阈值进行调整(第7行)。
该迭代过程循环进行,直到达到某些停止条件为止,比方训练误差达到一个很小的值。图给出了在2个属性、5个样本的西瓜数据上,随着训练样例的增长,网络参数和分类界限的变革环境。

  1. 输入:训练集 $D = \{(x_k, y_k)\}_{k=1}^m$
  2.       学习率 $\eta$
  3. 过程:
  4. 1. 在 $[-1, 0, 1]$ 范围内随机初始化网络中所有连接权和阈值
  5. 2. repeat
  6. 3. for all $(x_k, y_k) \in D$ do
  7. 4. 根据式(5.3)计算当前样本的输出 $y_{kj}^*$
  8. 5. 根据式(5.10)计算输出层神经元的梯度 $g_j$
  9. 6. 根据式(5.11)计算隐层神经元的梯度 $e_h$
  10. 7. 根据式(5.12)-(5.14)更新连接权 $w_{hj}, v_{ih}$ 和阈值 $\theta_j, \gamma_h$
  11. 8. until 达到停止条件
  12. 输出:连接权与阈值确定的多层前馈神经网络
复制代码
附上手写的源码:
  1. import numpy as np
  2. class nn:
  3.     def __init__(self, input_size, hidden_size, output_size, eta):
  4.         self.weight_1 = np.random.randn(hidden_size, input_size)
  5.         self.weight_2 = np.random.randn(output_size, hidden_size)
  6.         self.thre_1 = np.random.randn(hidden_size)
  7.         self.thre_2 = np.random.randn(output_size)
  8.         self.eta = eta
  9.     def _get_input(self, weight, X):
  10.         return np.dot(X, weight.T)
  11.    
  12.     def _sigmoid(self, input, thre):
  13.         input = np.array(input) - thre
  14.         return 1 / (1 + np.exp(-input))
  15.    
  16.     def _get_output(self, input, thre):
  17.         return self._sigmoid(input, thre)
  18.    
  19.     def _get_MSE(self, output, pre_output):
  20.         return np.mean((pre_output - output) ** 2) / 2
  21.    
  22.     def _get_new_weight(self, grad, X):
  23.         delta_weight = self.eta * np.outer(grad, X)
  24.         return delta_weight
  25.    
  26.     def _get_new_thre(self, grad):
  27.         return -self.eta * np.sum(grad, axis=0)
  28.    
  29.     def _get_output_grad(self, output, y):
  30.         error_output = output - y
  31.         grad_output = error_output * output * (1 - output)
  32.         return grad_output
  33.    
  34.     def _get_hide_grad(self, weight, output, grad_output):
  35.         error_hidden = np.dot(weight.T, grad_output)
  36.         grad_hidden = error_hidden * output * (1 - output)
  37.         return grad_hidden
  38.     def fit(self, X, y, num_epochs=1000):
  39.         for epoch in range(num_epochs):
  40.             # 前向传播
  41.             input_1 = self._get_input(self.weight_1, X)
  42.             output_1 = self._get_output(input_1, self.thre_1)
  43.             
  44.             input_2 = self._get_input(self.weight_2, output_1)
  45.             output_2 = self._get_output(input_2, self.thre_2)
  46.             
  47.             # 计算损失
  48.             loss = self._get_MSE(y, output_2)
  49.             
  50.             # 反向传播
  51.             grad_output = self._get_output_grad(output_2, y)
  52.             grad_hidden = self._get_hide_grad(self.weight_2, output_1, grad_output)
  53.             
  54.             # 更新权重和偏置
  55.             delta_weight_2 = self._get_new_weight(grad_output, output_1)
  56.             self.weight_2 -= delta_weight_2
  57.             self.thre_2 -= self._get_new_thre(grad_output)
  58.             
  59.             delta_weight_1 = self._get_new_weight(grad_hidden, X)
  60.             self.weight_1 -= delta_weight_1
  61.             self.thre_1 -= self._get_new_thre(grad_hidden)
  62.             
  63.             if epoch % 100 == 0:
  64.                 print(f"Epoch {epoch}, Loss: {loss}")
  65.     def predict(self, X):
  66.         input_1 = self._get_input(self.weight_1, X)
  67.         output_1 = self._get_output(input_1, self.thre_1)
  68.         
  69.         input_2 = self._get_input(self.weight_2, output_1)
  70.         output_2 = self._get_output(input_2, self.thre_2)
  71.         
  72.         return output_2
  73.         
  74. input_size = 4
  75. hidden_size = 5
  76. output_size = 3
  77. eta = 0.7
  78. model = nn(input_size, hidden_size, output_size, eta)
  79. X = np.array([0.5, 1.0, 1.5, 2.0])
  80. y = np.array([0.1, 0.2, 0.3])
  81. model.fit(X, y)
  82. prediction = model.predict(X)
  83. print(f"Prediction: {prediction}")
  84. '''
  85. Epoch 0, Loss: 0.08452484439144649
  86. Epoch 100, Loss: 0.00043097425030784627
  87. Epoch 200, Loss: 6.173784504106113e-05
  88. Epoch 300, Loss: 6.111382932194645e-06
  89. Epoch 400, Loss: 5.274844786786648e-07
  90. Epoch 500, Loss: 4.445371701622411e-08
  91. Epoch 600, Loss: 3.7266722662723944e-09
  92. Epoch 700, Loss: 3.1195917455011153e-10
  93. Epoch 800, Loss: 2.6102862257159366e-11
  94. Epoch 900, Loss: 2.1838569148871845e-12
  95. Prediction: [0.1000008  0.19999945 0.3000004 ]
  96. '''
复制代码
累积误差逆流传算法(累积BP)

前面介绍的BP算法针对单个均方误差                                             E                            k                                       E_k                  Ek​,这意味着每次参数更新都只针对一个样例数据,导致更新频繁以及可能出现的差别样例导致的参数调整抵消等问题。所以为了使数据集整体达到同样的误差极小点,累积BP直接针对累积误差最小化:                                   E                         =                                   1                            m                                            ∑                                       k                               =                               1                                      m                                            E                            k                                       E = \frac{1}{m} \sum_{k=1}^{m}E_k                  E=m1​∑k=1m​Ek​,读取数据集一遍之后再进行更新,然而累积BP在累积误差下降到一定程度时,可能出现下降迟钝的环境,这时尺度BP会得到更好的解。
类似随机梯度下降和尺度梯度下降的区别。
过拟合


                                         E                            =                            λ                                       1                               m                                                 ∑                                           k                                  =                                  1                                          m                                                 E                               k                                      +                            (                            1                            −                            λ                            )                                       ∑                               i                                                 w                               i                               ∗                                                                   ,                                  E=\lambda \frac{1}{m}\sum_{k=1}^m E_k + (1-\lambda)\sum_i w_i^*\ ,                     E=λm1​k=1∑m​Ek​+(1−λ)i∑​wi∗​ ,
:                                   E                         =                                   1                            m                                            ∑                                       k                               =                               1                                      m                                            E                            k                                       E = \frac{1}{m} \sum_{k=1}^{m}E_k                  E=m1​∑k=1m​Ek​,读取数据集一遍之后再进行更新,然而累积BP在累积误差下降到一定程度时,可能出现下降迟钝的环境,这时尺度BP会得到更好的解。
类似随机梯度下降和尺度梯度下降的区别。
过拟合


                                         E                            =                            λ                                       1                               m                                                 ∑                                           k                                  =                                  1                                          m                                                 E                               k                                      +                            (                            1                            −                            λ                            )                                       ∑                               i                                                 w                               i                               ∗                                                                   ,                                  E=\lambda \frac{1}{m}\sum_{k=1}^m E_k + (1-\lambda)\sum_i w_i^*\ ,                     E=λm1​k=1∑m​Ek​+(1−λ)i∑​wi∗​ ,
此中                                   λ                         ∈                         (                         0                         ,                         1                         )                              \lambda \in (0,1)                  λ∈(0,1)用于履历误差与网络复杂度这两项进行折中。常利用交叉验证法来估计。

免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!更多信息从访问主页:qidao123.com:ToB企服之家,中国第一个企服评测及商务社交产业平台。




欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4