BP神经网络反向传播算法公式推导：从数学原理到高效实现

1次阅读

没有评论

共计 2269 个字符，预计需要花费 6 分钟才能阅读完成。

在开始反向传播之前，我们需要先明确前向传播的计算过程。假设我们有一个 L 层的神经网络，第 l 层的权重矩阵为 $W^{(l)}$，偏置向量为 $b^{(l)}$，激活函数为 $\sigma(\cdot)$。

对于第 l 层的输出 $a^{(l)}$，其计算过程为：

$$
z^{(l)} = W^{(l)}a^{(l-1)} + b^{(l)}
$$
$$
a^{(l)} = \sigma(z^{(l)})
$$

其中 $a^{(0)}$ 就是网络的输入 x。

假设我们使用均方误差 (MSE) 作为损失函数：

$$
J = \frac{1}{2}||y – a^{(L)}||^2
$$

其中 y 是真实标签，$a^{(L)}$ 是网络输出。

首先计算输出层的误差 $\delta^{(L)}$：

$$
\delta^{(L)} = \frac{\partial J}{\partial z^{(L)}} = (a^{(L)} – y) \odot \sigma'(z^{(L)})
$$

这里 $\odot$ 表示逐元素相乘。

对于第 l 层 (l < L) 的误差 $\delta^{(l)}$：

$$
\delta^{(l)} = ((W^{(l+1)})^T \delta^{(l+1)}) \odot \sigma'(z^{(l)})
$$

得到各层的误差后，就可以计算权重和偏置的梯度：

$$
\frac{\partial J}{\partial W^{(l)}} = \delta^{(l)}(a^{(l-1)})^T
$$
$$
\frac{\partial J}{\partial b^{(l)}} = \delta^{(l)}
$$

import numpy as np

class NeuralNetwork:
    def __init__(self, layers):
        self.layers = layers
        self.weights = [np.random.randn(y, x)/np.sqrt(x) 
                        for x, y in zip(layers[:-1], layers[1:])]
        self.biases = [np.random.randn(y, 1) for y in layers[1:]]

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

    def sigmoid_prime(self, z):
        return self.sigmoid(z)*(1-self.sigmoid(z))

    def forward(self, x):
        a = x
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, a) + b
            a = self.sigmoid(z)
        return a

    def backward(self, x, y):
        # 前向传播
        activation = x
        activations = [x]
        zs = []
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, activation) + b
            zs.append(z)
            activation = self.sigmoid(z)
            activations.append(activation)

        # 反向传播
        delta = (activations[-1] - y) * self.sigmoid_prime(zs[-1])
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        nabla_w[-1] = np.dot(delta, activations[-2].T)
        nabla_b[-1] = delta

        for l in range(2, len(self.layers)):
            z = zs[-l]
            sp = self.sigmoid_prime(z)
            delta = np.dot(self.weights[-l+1].T, delta) * sp
            nabla_w[-l] = np.dot(delta, activations[-l-1].T)
            nabla_b[-l] = delta

        return (nabla_w, nabla_b)

在深层网络中，梯度可能在反向传播过程中指数级减小 (消失) 或增大(爆炸)。主要原因：