BP神经网络与Python实现

时间 2019-11-29

标签神经网络 python 实现栏目 Python 繁體版

原文原文链接

人工神经网络是一种经典的机器学习模型，随着深度学习的发展神经网络模型日益完善.html

联想你们熟悉的回归问题，神经网络模型其实是根据训练样本创造出一个多维输入多维输出的函数，并使用该函数进行预测，网络的训练过程即为调节该函数参数提升预测精度的过程.神经网络要解决的问题与最小二乘法回归解决的问题并没有根本性区别.python

回归和分类是经常使用神经网络处理的两类问题，若是你已经了解了神经网络的工做原理能够在http://playground.tensorflow.org/上体验一个浅层神经网络的工做过程.git

感知机(Perceptron)是一个简单的线性二分类器，它保存着输入权重，根据输入和内置的函数计算输出.人工神经网络中的单个神经元便是感知机.算法

在前馈神经网络的预测过程当中，数据流从输入到输出单向流动，不存在循环和返回的通道.网络

目前大多数神经网络模型都属于前馈神经网络，在下文中咱们将详细讨论前馈过程.app

多层感知机(Multi Layer Perceptron， MLP)是由多个感知机层全链接组成的前馈神经网络，这种模型在非线性问题中表现出色.dom

所谓全链接是指层A上任一神经元与临近层B上的任意神经元之间都存在链接.机器学习

反向传播(Back Propagation，BP)是偏差反向传播的简称，这是一种用来训练人工神经网络的常见算法，一般与最优化方法(如梯度降低法)结合使用.函数

本文介绍的神经网络模型在结构上属于MLP，由于采用BP算法进行训练，人们也称其为BP神经网络.工具

BP神经网络原理

经典的BP神经网络一般由三层组成: 输入层，隐含层与输出层.一般输入层神经元的个数与特征数相关，输出层的个数与类别数相同，隐含层的层数与神经元数都可以自定义.

每一个神经元表明对数据的一次处理:

每一个隐含层和输出层神经元输出与输入的函数关系为:

\[I_j=\sum_iW_{ij}O_i\]

\[O_j= sigmod(I_l) =\frac{1}{1+e^{-I_l}}\]

其中\(W_{ij}\)表示神经元i与神经元j之间链接的权重，\(O_j\)表明神经元j的输出， sigmod是一个特殊的函数用于将任意实数映射到(0，1)区间.

上文中的sigmod函数称为神经元的激励函数(activation function)，除了sigmod函数\(\frac{1}{1+e^{-I_l}}\)外，经常使用还有tanh和ReLU函数.

咱们用一个完成训练的神经网络处理回归问题，每一个样本拥有n个输入.相应地，神经网络拥有n个输入神经元和1个输出神经元.

实际应用中咱们一般在输入层额外增长一个偏置神经元，提供一个可控的输入修正;或者为每一个隐含层神经元设置一个偏置参数.

咱们将n个特征依次送入输入神经元，隐含层神经元得到输入层的输出并计算本身输出值，输出层的神经元根据隐含层输出计算出回归值.

上述过程通常称为前馈(Feed-Forward)过程，该过程当中神经网络的输入输出与多维函数无异.

如今咱们的问题是如何训练这个神经网络.

做为监督学习算法，BP神经网络的训练过程便是根据前馈获得的预测值和参考值比较，根据偏差调整链接权重\(W_{ij}\)的过程.

训练过程称为反向传播过程(BackPropagation)，数据流正好与前馈过程相反.

首先咱们随机初始化链接权重\(W_{ij}\)，对某一训练样本进行一次前馈过程获得各神经元的输出.

首先计算输出层的偏差:

\[E_j= sigmod'(O_j)*(T_j-O_j) =O_j(1-O_j)(T_j-O_j)\]

其中\(E_j\)表明神经元j的偏差，\(O_j\)表示神经元j的输出， \(T_j\)表示当前训练样本的参考输出， \(sigmod'(x)\)是上文sigmod函数的一阶导数.

计算隐含层偏差:

\[E_j= sigmod'(O_j)*\sum_kE_kW_{jk} =O_j(1-O_j)\sum_kE_kW_{jk}\]

隐含层输出不存在参考值，使用下一层偏差的加权和代替\((T_j-O_j)\).

计算完偏差后就能够更新\(W_{ij}\)和\(\theta_j\):

\[ W_{ij}=W_{ij}+\lambda E_jO_i \]

其中\(\lambda\)是一个称为学习率的参数，通常在(0，0.1)区间上取值.

实际上为了加快学习的效率咱们引入称为矫正矩阵的机制，矫正矩阵记录上一次反向传播过程当中的\(E_jO_i\)值，这样\(W_j\)更新公式变为:

\[ W_{ij}=W_{ij}+\lambda E_jO_i + \mu C_{ij}\]

\(\mu\)是一个称为矫正率的参数.随后更新矫正矩阵:

\[ C_{ij} = E_jO_i \]

每个训练样本都会更新一次整个网络的参数.咱们须要额外设置训练终止的条件.

最简单的训练终止条件为设置最大迭代次数，如将数据集迭代1000次后终止训练.

单纯的设置最大迭代次数不能保证训练结果的精确度，更好的办法是使用损失函数(loss function)做为终止训练的依据.

损失函数能够选用输出层各节点的方差:

\[ L = \sum_j(T_j-O_j)^2\]

为了不神经网络进行无心义的迭代，咱们一般在训练数据集中抽出一部分用做校验.当预测偏差高于阈值时提早终止训练.

Python实现BP神经网络

首先实现几个工具函数:

def rand(a， b):
    return (b - a) * random.random() + a


def make_matrix(m， n， fill=0.0):  # 创造一个指定大小的矩阵
    mat = []
    for i in range(m):
        mat.append([fill] * n)
    return mat

定义sigmod函数和它的导数:

def sigmoid(x):
    return 1.0 / (1.0 + math.exp(-x))


def sigmod_derivate(x):
    return x * (1 - x)

定义BPNeuralNetwork类，使用三个列表维护输入层，隐含层和输出层神经元，列表中的元素表明对应神经元当前的输出值.使用两个二维列表以邻接矩阵的形式维护输入层与隐含层，隐含层与输出层之间的链接权值，经过一样的形式保存矫正矩阵.

定义setup方法初始化神经网络:

def setup(self， ni， nh， no):
    self.input_n = ni + 1
    self.hidden_n = nh
    self.output_n = no
    # init cells
    self.input_cells = [1.0] * self.input_n
    self.hidden_cells = [1.0] * self.hidden_n
    self.output_cells = [1.0] * self.output_n
    # init weights
    self.input_weights = make_matrix(self.input_n， self.hidden_n)
    self.output_weights = make_matrix(self.hidden_n， self.output_n)
    # random activate
    for i in range(self.input_n):
        for h in range(self.hidden_n):
            self.input_weights[i][h] = rand(-0.2， 0.2)
    for h in range(self.hidden_n):
        for o in range(self.output_n):
            self.output_weights[h][o] = rand(-2.0， 2.0)
    # init correction matrix
    self.input_correction = make_matrix(self.input_n， self.hidden_n)
    self.output_correction = make_matrix(self.hidden_n， self.output_n)

定义predict方法进行一次前馈，并返回输出:

def predict(self， inputs):
    # activate input layer
    for i in range(self.input_n - 1):
        self.input_cells[i] = inputs[i]
    # activate hidden layer
    for j in range(self.hidden_n):
        total = 0.0
        for i in range(self.input_n):
            total += self.input_cells[i] * self.input_weights[i][j]
        self.hidden_cells[j] = sigmoid(total)
    # activate output layer
    for k in range(self.output_n):
        total = 0.0
        for j in range(self.hidden_n):
            total += self.hidden_cells[j] * self.output_weights[j][k]
        self.output_cells[k] = sigmoid(total)
    return self.output_cells[:]

定义back_propagate方法定义一次反向传播和更新权值的过程，并返回最终预测偏差:

def back_propagate(self， case， label， learn， correct):
    # feed forward
    self.predict(case)
    # get output layer error
    output_deltas = [0.0] * self.output_n
    for o in range(self.output_n):
        error = label[o] - self.output_cells[o]
        output_deltas[o] = sigmod_derivate(self.output_cells[o]) * error
    # get hidden layer error
    hidden_deltas = [0.0] * self.hidden_n
    for h in range(self.hidden_n):
        error = 0.0
        for o in range(self.output_n):
            error += output_deltas[o] * self.output_weights[h][o]
        hidden_deltas[h] = sigmod_derivate(self.hidden_cells[h]) * error
    # update output weights
    for h in range(self.hidden_n):
        for o in range(self.output_n):
            change = output_deltas[o] * self.hidden_cells[h]
            self.output_weights[h][o] += learn * change + correct * self.output_correction[h][o]
            self.output_correction[h][o] = change
    # update input weights
    for i in range(self.input_n):
        for h in range(self.hidden_n):
            change = hidden_deltas[h] * self.input_cells[i]
            self.input_weights[i][h] += learn * change + correct * self.input_correction[i][h]
            self.input_correction[i][h] = change
    # get global error
    error = 0.0
    for o in range(len(label)):
        error += 0.5 * (label[o] - self.output_cells[o]) ** 2
    return error

定义train方法控制迭代，该方法能够修改最大迭代次数，学习率\(\lambda\)，矫正率\(\mu\)三个参数.

def train(self， cases， labels， limit=10000， learn=0.05， correct=0.1):
    for i in range(limit):
        error = 0.0
        for i in range(len(cases)):
            label = labels[i]
            case = cases[i]
            error += self.back_propagate(case， label， learn， correct)

编写test方法，演示如何使用神经网络学习异或逻辑:

def test(self):
    cases = [
            [0， 0]，
            [0， 1]，
            [1， 0]，
            [1， 1]，
        ]
    labels = [[0]， [1]， [1]， [0]]
    self.setup(2， 5， 1)
    self.train(cases， labels， 10000， 0.05， 0.1)
    for case in cases:
        print(self.predict(case))

完整源代码参见bpnn.py

使用tensorflow实现一个神经网络多是更简单高效的方法，能够参见tensorflow入门指南中的第二节:实现一个简单神经网络.