BP神经网络入门级简介

1. BP神经网络概述

神经网络是一类能够模拟任何函数的一个非线性映射。先简单举个例子,假设有一个神经网络仅由一个神经元构成：

神经网络采用的是给每个$X_1, X_2, X_3, X_4$加上一定的权值$W_1,W_2,W_3,W_4$，因此组合的线性输出为：

$$h_{W,b}(x) = W^TXW+b$$

$h_{W,b}(x)$是一个标量

因此无论网络如何复杂，输出都会是一个关于输出的现象组合。为了模拟好非线性函数，需要加上一个激活函数：

$$f(z)=\frac 1{1+e^{-z}}$$
则：
$$f'(z)=\frac {e^{-z}}{(1+e^{-z})^2}=f(z)(1-f(z))$$
假设我们的训练数据集为：

此时$f_{W,b}(x)=f(W^TX+b)$，令$g(x)=\frac 1{1+e^{-z}}$，此时的损失函数为：

$$J(W,b) = \frac 12\sum_{i=1}^n(f_{W,b}(x^{(i)})-y^{(i)})^2++\frac \lambda {2K}\sum_{k\in K}w_{ji}^2$$
分别对 $W,b$求偏导，得：
$$\begin{align} \frac {\partial J}{\partial w_j} &= \sum_{i=1}^ng(w_ix^{(i)}+b-y^{(i)})g(w_ix^{(i)}+b)(1-g(w_ix^{(i)}+b))\cdot x^{(i)}_j+\frac \lambda Kw_{ji}\\ \frac {\partial f}{\partial b_j} &= \sum_{i=1}^ng(w_ix^{(i)}+b-y^{(i)})g(w_ix^{(i)}+b)(1-g(w_ix^{(i)}+b)) \end{align}$$
后面的正则项是求所有权值的平方和的均值， $K$为权值的总的数目，根据梯度下降算法：
$$w_j = w_j - \alpha \frac {\partial J}{\partial w_j} \\ b_j = b_j - \alpha \frac {\partial J}{\partial b_j}$$

代码的简单实现为：

from numpy import exp, array, random, dot


class NeuralNetwork():
    def __init__(self):
        random.seed(1)
        # gengerate initial random W
        self.synaptic_weights = 2 * random.random((3, 1)) - 1

    def _sigmoid(self, x):
        return 1/(1+exp(-x))

    # gradient of the sigmod curve
    def _sigmoid_derivative(self, x):
        return x * (1-x)

    def train(self, training_set_inputs, train_set_outputs, number_of_training_iterations):
        for iteration in range(number_of_training_iterations):
            output = self.predict(training_set_inputs)
            error = training_set_outputs - output
            adjustment = dot(training_set_inputs.T, error * self._sigmoid_derivative(output))
            # update the W value
            self.synaptic_weights += adjustment

    def predict(self, inputs):
        return self._sigmoid(dot(inputs, self.synaptic_weights))

if __name__ == "__main__":
    neural_network = NeuralNetwork()

    print("Random starting synaptic weights:")
    print(neural_network.synaptic_weights)

    training_set_inputs = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])
    training_set_outputs = array([[1, 1, 1, 0]]).T

    neural_network.train(training_set_inputs, training_set_outputs, 10000)

    print("New synaptic weights after training")
    print(neural_network.synaptic_weights)

    print("predicting:")
    print(neural_network.predict(array([1, 0, 0])))

以上就是BP神经网络的简单介绍。

2. BP神经网络里面的权值迭代

假设有下面这样一个4层的神经网络模型(作为多个隐藏层的代表)：

先给定下面几个字母代号：
$L_n$表示第$n$层，如$L_1$表示输入层。$W_{ij}^{(l)}$表示第$l$层的第$j$个节点到第$l+1$层的第$i$个节点之间的权值。$z^l_{i}$表示第$l$层的第$i$个节点经过上层所有连向该节点的加权求和，$a_i^{(l)}$表示第$l$层的第$i$个节点经过$Activation\hspace{0.1cm}function$之后的输出值，即：

$$a_i^{(l)}=f(z_i^{(l)})=sigmod(z_i^{(l)})$$
$b_i^{(l)}$表示第 $l=1$层第 $i$个节点的偏置，定义$\delta_i^{(l)}$为以 $a_i^{(l)}$作为输入的第 $l$层的第$i$个节点对总体误差的影响，则有：
$$\begin{align} z_i^{(l)}&=\sum_{j=1}^nw_{ij}^{(l-1)}a_j^{(l-1)}+b_i^{(l-1)}\\ a_i^{(l)}&=\frac 1{1+e^{-z_i^{(l)}}} \end{align}$$
设最终的输出值为： $h_{(W,b)(x)}$，实际的值为 $y$，则损失函数为：
$$J(W,b)=\frac 12(h_{W,b}(x)-y)^2+\frac \lambda{2K}\sum_{k \in K}w_{ij}^2$$
后面的为正则项，其中 $K$表示所有权重的数目，正则项即时对所有权重求加权平方和的均值。
BP神经网络的步骤为：
1. 随机初始化权值$W$和 $b$
2. 通过前向传播的网络，计算在当前权重和偏置的情况下的输出$h_{w,b}(x)$以及中间每一层对应的输出 $a^{(l)}$
3. 对于输出层，定义
$$\begin{align} \delta_i^{(L)}&=\sum_{j=1}^m\frac {\partial \frac 12(a_i^{(L)}-y)^2}{\partial a_i^{{L}}}=a_i^{(L)}-y \end{align}$$
后文中，为了方便书写，去掉了求和符号，均假设只有一个样本。多个样本的话，只需叠加即可。
4,对于第 $L-1$层，有：
$$\begin{align} \delta_i^{(L-1)}&=\frac {\partial J_{w,b}(z_i^{(L-1)})}{\partial a_i^{(L-1)}}=\sum_{k=1}^m\sum_{j=1}^n\frac {\partial J_{w,b}^j(a^{L-1}_i)}{\partial a_i^{L-1}}=\sum_{k=1}^m\sum_{j=1}^n\frac {\partial [\frac 12(f(w_{ij}^{(L-1)}a_i^{L-1}+b_j^{(L)}+\cdots)-y_j]^2}{\partial a_i^{(L-1)}} \\ &=\sum_{k=1}^m\sum_{j=1}^n[f(w_{ij}^{(L-1)}a_i^{L-1}+b_j^{(L)}+\cdots)-y]\cdot \frac {\partial [f(w_{ij}^{(L-1)}a_i^{L-1}+b_j^{(L)}+\cdots)-y]}{\partial a_i^{(L-1)}} \\ &=\sum_{k=1}^m\sum_{j=1}^n(a_j^{(L)}-y_j)\cdot f'(a_j^{(L)})\cdot w_{ij}^{(L-1)}\\ &=\sum_{k=1}^m\sum_{j=1}^n(a_j^{(L)}-y_j)\cdot a_j^{(L)}\cdot (1-a_j^{(L)})\cdot w_{ij}^{L-1}\\ &=\sum_{k=1}^m\sum_{j=1}^n\delta_j^{(L)}\cdot a_j^{(L)}\cdot (1-a_j^{(L)})\cdot w_{ij}^{L-1}\\ \end{align}$$
5, 更新第 $L-1$层到第 $L$层的权重$w^{(L-1)}$
$$\begin{align} \frac {\partial J_{w,b}(a_i^{(L-1)})}{\partial w_{ji}}&=\sum_{k=1}^n\frac {\partial J_{w,b}^j(a_i^{(L-1)})}{\partial a_j^{(L)}}\cdot \frac {\partial a_j^{(L)}}{\partial w_{ji}}\\ &=(a_j^{(L)}-y)\cdot a_j^{(L)}\cdot (1-a_j^{(L)})\cdot a_i^{(L-1)} \hspace{1.0cm}注意这里去掉了求和符号\\ &=\delta_j^{(L)}\cdot a_j^{(L)}\cdot (1-a_j^{(L)})\cdot a_i^{(L-1)}\\ 加上正则项以后的偏导数为：\\ \frac {\partial J_{w,b}(a_i^{(L-1)})}{\partial w_{ji}}&=\delta_j^{(L)}\cdot a_j^{(L)}\cdot (1-a_j^{(L)})\cdot a_i^{(L-1)}+\frac \lambda Kw_{ji} \\\\\\ w_{ji}^{(L-1)}&=w_{ji}^{(L-1)}-\alpha\cdot \frac {\partial J_{w,b}(a_i^{(L-1)})}{\partial w_{ji}} \end{align}$$
6，对于第 $l$层和第$l+1$层之间：
$$\begin{align} \frac {\partial J}{\partial a_{i}^{(l)}}&=\sum_{j=1}^n\frac {\partial J}{\partial a_j^{(l+1)}}\cdot \frac {\partial a_j^{(l+1)}}{\partial a_i^{(l)}}\\ \end{align}$$
而
$$a_j^{(l+1)}=f(w_{ji}a_i^{(l)}+b_j+...)=f(z_j^{(l+1)}+\cdots)$$
因此
$$\frac {\partial {a_j^{(l+1)}}}{{\partial a_i^{(l)}}}=f(z_j^{(l+1)}+\cdots)\cdot (1-f(z_j^{(l+1)}+\cdots))\cdot w_{ji}=a_j^{(l+1)}\cdot (1-a_j^{(l+1)})\cdot w_{ji}$$
因此:
$$\begin{align} \delta_i^{(L)}&=\frac {\partial J}{\partial a_{i}^{(l)}}=\sum_{j=1}^n[\frac {\partial J}{\partial a_j^{(l+1)}}\cdot a_j^{(l+1)}\cdot (1-a_j^{(l+1)})\cdot w_{ji}]\\ &=\sum_{j=1}^n[\delta_i^{(L+1)}\cdot a_j^{(l+1)}\cdot (1-a_j^{(l+1)})\cdot w_{ji}] \end{align}$$
而对于最后一层：
$$\frac {\partial J}{\partial a_{i}^{(L)}}=a_i^{(L)}-y_i \hspace{1.0cm}i表示输出层的第i个节点$$
故：
$$\begin{align} \frac {\partial J}{\partial w_{ji}^{(l)}}&=\frac {\partial J}{\partial a_{j}^{(l+1)}}\cdot a_j^{(l+1)}(1-a_j^{(l+1)})a_i^{(l)}+\frac \lambda Kw_{ji}\\ &=\delta_j^{(l+1)}\cdot a_j^{(l+1)}(1-a_j^{(l+1)})a_i^{(l)}+\frac \lambda Kw_{ji}\\\\\\ \frac {\partial J}{\partial b_{i}^{(l)}}&=\frac {\partial J}{\partial a_{j}^{(l+1)}}\cdot a_j^{(l+1)}(1-a_j^{(l+1)})\\ &=\delta_j^{(l+1)}\cdot a_j^{(l+1)}(1-a_j^{(l+1)}) \\\\\\ w_{ji}&=w_{ji}-\alpha\cdot \frac {\partial J}{\partial w_{ji}}\\ b_i^{(l)}&=b_i^{(l)}-\alpha\cdot \frac {\partial J}{\partial b_{i}^{(l)}} \end{align}$$
注意，这里:
$$\delta_j^{(l)}=\frac {\partial J}{\partial a_j^{(l)}}$$
由此可以看出，要想求出每一层的权重的偏导数 $\frac {\partial J}{\partial w_{ji}}$，需要先求出误差对于后面一层所有节点的的输出值 $a_j^{(l+1）}$的偏导数，因此总共需要3个变量来分别存储 $a_i^{(l)}$、 $\frac {\partial J}{\partial a_i^{(l)}}$、 $w_{ji}^{(l)}$，其中 $a_i^{(l)}$、 $\frac {\partial J}{\partial a_i^{(l)}}$需要一个2维数组来存， $w_{ji}^{(l)}$需要一个3维度数组来存。

这里有一个简单的例子，很直观。

4. TensorFlow搭建一个简单的BP神经网络

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
n_nodes_hl1 = 500
n_nodes_hl2 = 500
n_nodes_hl3 = 500

n_classes = 10
batch_size = 100

x = tf.placeholder("float", [None, 784])
y = tf.placeholder("float", [None, n_classes])


def neural_network_model(data):
    # 创建第一个隐藏层节点500个
    hidden_1_layer = {"weight": tf.Variable(tf.random_normal([784, n_nodes_hl1])),
                      "biases": tf.Variable(tf.random_normal([n_nodes_hl1]))}
    # 创建第二个隐藏层节点500个
    hidden_2_layer = {"weight": tf.Variable(tf.random_normal([n_nodes_hl1, n_nodes_hl2])),
                      "biases": tf.Variable(tf.random_normal([n_nodes_hl2]))}
    # 创建第三个隐藏层节点500个
    hidden_3_layer = {"weight": tf.Variable(tf.random_normal([n_nodes_hl2, n_nodes_hl3])),
                      "biases": tf.Variable(tf.random_normal([n_nodes_hl3]))}
    # 创建输出层节点10个
    output_layer = {"weight": tf.Variable(tf.random_normal([n_nodes_hl3, n_classes])),
                      "biases": tf.Variable(tf.random_normal([n_classes]))}

    # 连接输入层
    l1 = tf.add(tf.matmul(data, hidden_1_layer["weight"]), hidden_1_layer["biases"])
    l1 = tf.nn.relu(l1)

    # 连接hidden layer 1和hidden layer 2
    l2 = tf.add(tf.matmul(l1, hidden_2_layer["weight"]), hidden_2_layer["biases"])
    l2 = tf.nn.relu(l2)

    # 连接hidden layer 2和hidden layer 3
    l3 = tf.add(tf.matmul(l2, hidden_3_layer["weight"]), hidden_3_layer["biases"])
    l3 = tf.nn.relu(l3)

    # 连接hidden layer 3和output layer
    output = tf.add(tf.matmul(l3, output_layer["weight"]), output_layer["biases"])
    # output = tf.nn.softmax(output)

    return output


def train(x):
    # 获取输出值
    predict = neural_network_model(x)
    # 定义对数损失函数
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=predict, labels=y))
    # 定义最优化损失的计算方法
    optimizer = tf.train.AdamOptimizer().minimize(cost)

    hm_epochs = 10

    with tf.Session() as sess:  # 真正运行在这里面
        sess.run(tf.initialize_all_variables())

        for epoch in range(hm_epochs):
            epoch_loss = 0
            for _ in range(int(mnist.train.num_examples / batch_size)):
                epoch_x, epoch_y = mnist.train.next_batch(batch_size)
                _, c = sess.run([optimizer, cost], feed_dict={x: epoch_x, y: epoch_y})
                epoch_loss += c  # 叠加所有样本的损失
            print("Epoch", epoch, "completed out of ", hm_epochs, "loss: ", epoch_loss)

        correct = tf.equal(tf.arg_max(predict, 1), tf.arg_max(y, 1))

        accuracy = tf.reduce_mean(tf.cast(correct, "float"))  # 所有元素取均值
        print("Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))

train(x)

注意事项：
1. 初始化权重和偏置的时候，不能都设为一样的，应该要随机初始化，否则可能造成权重完全相同，例如：

这是截取的网络的一部分，此时如果输出层的两个神经元相等，则以后的迭代过程当中，这两个神经元相连的前面一层的权值也相等，如果往前回溯，由于：

$$\frac {\partial J}{\partial w_{ji}^{(l)}}=\delta_j^{(l+1)}a_j^{(l+1)}(1-a_j^{(l+1)})a_i^{(l)}$$
会造成偏导相等，从而权值也会呈现对称的特征，因此可能导致网络性能受到影响。
2. 对于求导的检查
神经网络的计算过程中，求导过程比较复杂，为了检验是否出错，可以用如下方法检验：

对于其上某点 $(x_i, y_i)$点的导数近似等于：
$$\frac {\partial f(x)}{\partial x} \approx \frac {f(x+\epsilon)-f(x-\epsilon)}{2\epsilon}$$
此处 $\epsilon$取尽可能小的值，例如 $10^{-6}$。因此对于神经网络，可以：
$$\frac {\partial J(w_{ji})}{\partial w_{ji}} \approx \frac {J(w_{ji}+\epsilon)-J(w_{ji}-\epsilon)}{2\epsilon}\hspace{1.5cm}\epsilon = 10^{-6}$$
当发现精确值和近似值相近时，说明导数计算正确，解除检验操作即可。