反向传播(BP)算法的推导与前馈神经网络的实现

1. BP算法的推导

考虑前馈神经网络, 即整个网络中不存在反馈.

如图所示, w_ji表示当前层神经元 j 的来自上层神经元 i 的输入的权值.
设样本集为D, 输出集是outputs, 标签值和预估值分别用 t 和 o 表示. 对于回归问题, 整个网络的损失函数定义为:

由于每个样本都是对称的, 于是考虑单个样本d的损失函数:

记以下符号:

: 当前层神经元 j 的输入的加权和
: 所有输入含有神经元 j 的下一层神经元

欲更新各w_ji, 需要求

由链式求导法则

定义误差项
设激活函数为sigmoid函数.

1.1 输出层的梯度

对回归问题而言, 输出层不再作用激活函数. 有

1.2 隐藏层的梯度

隐藏层误差项的求解会借助下一层神经元, 根据输出层的求解结果计算最后一层隐藏层, 然后依次向后计算, 故称为反向传播.

1.3 BP算法流程

初始化参数. 对每个训练样本:

1. 前向传播一次, 求每个神经元 的输出
2. 对每个输出层神经元, 求误差项:

3. 对每个隐藏层神经元, 求误差项:

4. 更新参数 :
   

2. 简单前馈神经网络的实现

基于mini-batch, 即每次随机选取一定数量(batch_size)的样本来更新参数.

class SimpleFeedForwardNetwork(object):
    """mini-batch based feedforward neural network"""
    def __init__(self, input_units, hidden_units, output_units=1):
        self._n_input_units = input_units
        self._n_hidden_units = copy.deepcopy(hidden_units)
        self._n_output_units = output_units

        self._weights = list()
        self._bias = list()

        # 用正态分布初始化每层连接的参数
        input_nums = [self._n_input_units] + self._n_hidden_units
        output_nums = self._n_hidden_units + [self._n_output_units]
        for in_units, out_units in zip(input_nums, output_nums):
            self._weights.append(np.random.randn(in_units, out_units))
            self._bias.append(np.random.randn(out_units))

    def fit(self, X, y, batch_size, epochs, eta):
        input_idx = np.arange(X.shape[0])
        evaluate_res = list()
        for epoch in range(epochs):
            np.random.shuffle(input_idx)
            for i in range(0, input_idx.shape[0], batch_size):
                batch_idx = input_idx[i: i+batch_size]
                batch_size = batch_idx.shape[0]

                delta_weights, delta_bias = self._backword(X[batch_idx], y[batch_idx])
                for idx, (delta_w, delta_b) in enumerate(zip(delta_weights, delta_bias)):
                    self._weights[idx] -= eta / batch_size * delta_w
                    self._bias[idx] -= eta / batch_size * delta_b

            evaluate_res.append(self.evaluate(X, y))
            sys.stdout.write('Epoch {}: {}\n'.format(epoch, evaluate_res[-1]))

    def predict(self, X):
        layer_outs = self._forward(X)
        return layer_outs[-1]

    def evaluate(self, X, y):
        y_pred = self.predict(X)
        return np.square(y - y_pred).sum()

    def _activation(self, z):
        return 1 / (1 + np.exp(-z))

    # 前向传播过程, 求各层输出
    def _forward(self, inputs):
        layer_outs = [inputs]
        for w, b in zip(self._weights[:-1], self._bias[:-1]):
            net = np.dot(layer_outs[-1], w) + b
            layer_outs.append(self._activation(net))

        layer_outs.append(np.dot(layer_outs[-1], self._weights[-1]) + self._bias[-1])
        return layer_outs

    # 反向传播过程, 更新参数
    def _backword(self, inputs, outputs):
        # 1. 前向传播求预估值
        layer_outs = self._forward(inputs)

        delta_weights = [np.zeros(w.shape) for w in self._weights]
        delta_bias = [np.zeros(b.shape) for b in self._bias]

        # 2. 计算输出层误差项和梯度
        delta = layer_outs[-1] - outputs
        delta_weights[-1] = np.dot(layer_outs[-2].T, delta)
        delta_bias[-1] = delta.sum()

        # 3. 计算隐藏层误差项和梯度
        for h in range(2, len(self._weights)+1):
            delta = np.dot(delta, self._weights[-h + 1].T) * layer_outs[-h] * (1 - layer_outs[-h])
            delta_weights[-h] = np.dot(layer_outs[-h - 1].T, delta)
            delta_bias[-h] = delta.sum()

        return delta_weights, delta_bias