机器学习之深入理解神经网络理论基础、BP算法及其Python实现

╰+哭是因爲堅強的太久メ 2022-07-12 07:13 140阅读 0赞

人工神经网络（Artificial Neural Networks，ANN）系统是 20 世纪 40 年代后出现的。它是由众多的神经元可调的连接权值连接而成，具有大规模并行处理、分布式信 息存储、良好的自组织自学习能力等特点。BP（Back Propagation）算法又称为误差反向传播算法，是人工神经网络中的一种监督式的学习算法。BP 神经网络算法在理 论上可以逼近任意函数，基本的结构由非线性变化单元组成，具有很强的非线性映射能力。而且网络的中间层数、各层的处理单元数及网络的学习系数等参数可根据具体情况设定，灵活性很大，在优化、信号处理与模式识别、智能控制、故障诊断等许 多领域都有着广泛的应用前景。

--------------------

**神经元模型**

神经网络中最基本的成分是神经元模型。在这个模型中，神经元接收到来自n个其他神经元传递过来的输入信号，这些输入信号通过带权重的连接进行传递，神经元接收到的总数入值将与神经元的阈值进行比较，然后通过激活函数处理以产生神经元的输出。  
![这里写图片描述][SouthEast_pic_center]  
理想中的激活函数是下图中（a）所表示的阶跃函数，它将输入值映射为输出值0或者1，然而，阶跃函数具有不连续性、不光滑等不太好的性质，因此实际常用Sigrnoid函数作为激活函数，典型的Sigrnoid函数是下图中（b）所示，它把可能在较大范围内变化的输入值挤压到（0,1）输出值范围内。  
![这里写图片描述][SouthEast_pic_center 1]

--------------------

**多层前向神经网络**

常见的神经网络层级结构是**多层前向神经网络**。

多层前向神经网络由三部分组成：输出层、隐藏层、输出层，每层由单元组成；

输入层由训练集的实例特征向量传入，经过连接结点的权重传入下一层，前一层的输出是下一层的输入；隐藏层的个数是任意的，输入层只有一层，输出层也只有一层；

除去输入层之外，隐藏层和输出层的层数和为n，则该神经网络称为n层神经网络，如下图为2层的神经网络；  
![这里写图片描述][SouthEast_pic_center 2]

一层中加权求和，根据非线性方程进行转化输出；理论上，如果有足够多的隐藏层和足够大的训练集，可以模拟出任何方程；

使用神经网络之前，必须要确定神经网络的层数，以及每层单元的个数；

为了加速学习过程，特征向量在传入输入层前，通常需要标准化到0和1之间；

离散型变量可以被编码成每一个输入单元对应一个特征值可能赋的值,比如：特征值A可能去三个值（a0,a1,a2），那么可以使用3个输入单元来代表A

如果A= a 0 a\_0 a0，则代表 a 0 a\_0 a0的单元值取1，其余取0；  
如果A= a 1 a\_1 a1，则代表 a 1 a\_1 a1的单元值取1，其余取0；  
如果A= a 2 a\_2 a2，则代表 a 2 a\_2 a2的单元值取1，其余取0；  
![这里写图片描述][SouthEast_pic_center 3]

神经网络既解决分类（classification）问题，也可以解决回归（regression）问题。对于分类问题，如果是两类，则可以用一个输出单元（0和1）分别表示两类；如果多余两类，则每一个类别用一个输出单元表示，所以输出层的单元数量通常等一类别的数量。

没有明确的规则来设计最佳个数的隐藏层，一般根据实验测试误差和准确率来改进实验。

--------------------

**误差逆传播算法（BP算法）**

通过迭代来处理训练集中的实例；

对比经过神经网络后预测值与真实值之间的差；

反方向（从输出层=>隐藏层=>输入层）来最小化误差，来更新每个连接的权重；

**算法详细介绍：**

输入：数据集、学习率、一个多层神经网络构架；

输出：一个训练好的神经网络；

初始化权重和偏向：随机初始化在-1到1之间（或者其他），每个单元有一个偏向；对于每一个训练实例X，执行以下步骤：

1、由输入层向前传送：

结合神经网络示意图进行分析：  
![这里写图片描述][SouthEast_pic_center 4]

由输入层到隐藏层：  
 O j = ∑ i w i j x i + θ j O\_j=\\sum\\limits\_\{i\}^\{\}w\_\{ij\}x\_i+\\theta\_j Oj=i∑wijxi\+θj  
由隐藏层到输出层：  
 O k = ∑ j w j k O j + θ k O\_k=\\sum\\limits\_\{j\}^\{\}w\_\{jk\}O\_j+\\theta\_k Ok=j∑wjkOj\+θk  
两个公式进行总结，可以得到：  
 I j = ∑ i w i j O i + θ j I\_j=\\sum\\limits\_\{i\}^\{\}w\_\{ij\}O\_i+\\theta\_j Ij=i∑wijOi\+θj  
 I j I\_j Ij为当前层单元值， O i O\_i Oi为上一层的单元值， w i j w\_\{ij\} wij为两层之间，连接两个单元值的权重值， θ j \\theta\_j θj为每一层的偏向值。我们要对每一层的输出进行非线性的转换，示意图如下：  
![这里写图片描述][SouthEast_pic_center 5]

当前层输出为 I j I\_j Ij，f为非线性转化函数，又称为激活函数，定义如下：  
 f ( x ) = 1 1 + e − x f(x)=\\frac\{1\}\{1+e^\{-x\}\} f(x)=1\+e−x1  
即每一层的输出为：  
 O j = 1 1 + e − I j O\_j=\\frac\{1\}\{1+e^\{-I\_j\}\} Oj=1\+e−Ij1

这样就可以通过输入值正向得到每一层的输出值。  
2、根据误差反向传送 对于输出层：其中 T k T\_k Tk是真实值， O k O\_k Ok是预测值:  
 E r r k = O k ( 1 − O k ) ( T k − O k ) Err\_k=O\_k(1-O\_k)(T\_k-O\_k) Errk=Ok(1−Ok)(Tk−Ok)  
对于隐藏层：  
 E r r j = O j ( 1 − O j ) ∑ k E r r k w j k Err\_j=O\_j(1-O\_j)\\sum\\limits\_\{k\}^\{\}Err\_kw\_\{jk\} Errj=Oj(1−Oj)k∑Errkwjk  
权重更新：其中 l l l为学习率:  
 Δ w i j = ( l ) E r r j O i \\Delta w\_\{ij\}=(l)Err\_jO\_i Δwij=(l)ErrjOi  
 w i j = w i j + Δ w i j w\_\{ij\}=w\_\{ij\}+\\Delta w\_\{ij\} wij=wij\+Δwij  
偏向更新：  
 Δ θ j = ( l ) E r r j \\Delta \\theta\_j=(l)Err\_j Δθj=(l)Errj  
 θ j = θ j + Δ θ j \\theta\_j=\\theta\_j+\\Delta \\theta\_j θj=θj\+Δθj

3、终止条件

① 偏重的更新低于某个阈值；  
②预测的错误率低于某个阈值；  
③达到预设一定的循环次数；

算法举例：  
![这里写图片描述][SouthEast_pic_center 6]  
![这里写图片描述][SouthEast_pic_center 7]

--------------------

**反向传播详细推导过程**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]  
**情况2：隐藏单元的权值 训练法则**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]

--------------------

**BP神经网络的python实现**

需要先导入numpy模块

import numpy as np

定义非线性转化函数，由于还需要用到给函数的导数形式，因此一起定义

def tanh(x):
        return np.tanh(x)
    def tanh_deriv(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))

设计BP神经网络的形式（几层，每层多少单元个数），用到了面向对象，主要是选择哪种非线性函数，以及初始化权重。layers是一个list，里面包含每一层的单元个数。

class NeuralNetwork:
        def __init__(self, layers, activation='tanh'):
            """
            :param layers: A list containing the number of units in each layer.
            Should be at least two values
            :param activation: The activation function to be used. Can be
            "logistic" or "tanh"
            """
            if activation == 'logistic':
                self.activation = logistic
                self.activation_deriv = logistic_derivative
            elif activation == 'tanh':
                self.activation = tanh
                self.activation_deriv = tanh_deriv
     
            self.weights = []
            for i in range(1, len(layers) - 1):
                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)

实现算法

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])]
     
                for l in range(len(a) - 2, 0, -1):
                    deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_deriv(a[l]))
                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)

实现预测

def predict(self, x):
            x = np.array(x)
            temp = np.ones(x.shape[0]+1)
            temp[0:-1] = x
            a = temp
            for l in range(0, len(self.weights)):
                a = self.activation(np.dot(a, self.weights[l]))
            return a

我们给出一组数进行预测，我们上面的程序文件保存名称为BP

from BP import NeuralNetwork
    import numpy as np
     
    nn = NeuralNetwork([2,2,1], 'tanh')
    x = np.array([[0,0], [0,1], [1,0], [1,1]])
    y = np.array([1,0,0,1])
    nn.fit(x,y,0.1,10000)
    for i in [[0,0], [0,1], [1,0], [1,1]]:
        print(i, nn.predict(i))

结果如下：

([0, 0], array([ 0.99738862]))
    ([0, 1], array([ 0.00091329]))
    ([1, 0], array([ 0.00086846]))
    ([1, 1], array([ 0.99751259]))

--------------------

**链式求导过程举例**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]

--------------------

参考：[神经网络理论基础][Link 1]

--------------------

**相关博客：**

1、机器学习系列之[机器学习之决策树（Decision Tree）及其Python代码实现][Decision Tree_Python]

2、机器学习系列之[机器学习之Validation（验证，模型选择）][Validation]

3、机器学习系列之[机器学习之Logistic回归(逻辑蒂斯回归）][Logistic]

4、机器学习系列之[机器学习之拉格朗日乘数法][Link 2]

5、机器学习系列之[机器学习之深入理解SVM][SVM]

6、机器学习系列之[机器学习之深入理解K-means、与KNN算法区别及其代码实现][K-means_KNN]

--------------------

\#\#具体更多资源可前往[机器学习专题][Link 3]

[SouthEast_pic_center]: /images/20220711/f3c0a3e2a7e14721b42759e1ca189451.png
[SouthEast_pic_center 1]: /images/20220711/e1799525e1ea46a0bcbb1bd7f0f25dcb.png
[SouthEast_pic_center 2]: /images/20220711/4e1b7315e8b342ed83134fb10b3e1ca7.png
[SouthEast_pic_center 3]: /images/20220711/cefcf54685724a35a2154ca0f95b9e59.png
[SouthEast_pic_center 4]: /images/20220711/088cacb03bae4f49b4aaa214e885f4eb.png
[SouthEast_pic_center 5]: /images/20220711/ef1b4cce41d64ae9a8d617b58601aa75.png
[SouthEast_pic_center 6]: /images/20220711/fa81ee2ec10344a4844efe484012b2ed.png
[SouthEast_pic_center 7]: /images/20220711/2241b024827e47b88cdc06b8762e4c02.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: /images/20220711/13c55139c2d6477bb13992cb732f9577.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: /images/20220711/fcc8cfe14e944e399fae419b1bf3a564.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]: /images/20220711/882a87c045434a9fa79aa39fe52008d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]: /images/20220711/c7176057640f443ca2747a3abfea7e99.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]: /images/20220711/e2e8140babe84d2781aad73f0063dec7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]: /images/20220711/0c6154314a9a43079f3f7e8d73e0fd4d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ3FpbmppYW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]: /images/20220711/29489e8aeae0435fbfdaa5835618634e.png
[Link 1]: http://mp.weixin.qq.com/s/Wa3Q5cIDtuQFyvSpL1oupg
[Decision Tree_Python]: http://blog.csdn.net/sinat_35512245/article/details/54927178
[Validation]: http://blog.csdn.net/sinat_35512245/article/details/54924160
[Logistic]: http://blog.csdn.net/sinat_35512245/article/details/54881672
[Link 2]: http://blog.csdn.net/sinat_35512245/article/details/53232808
[SVM]: http://blog.csdn.net/sinat_35512245/article/details/54984251
[K-means_KNN]: http://blog.csdn.net/sinat_35512245/article/details/55051306
[Link 3]: https://github.com/HuangQinJian/Machine-Learning