反向传播算法的算法原理与Python实现

前言

反向传播算法是深度学习中最常用的算法之一，用于训练神经网络。它通过计算网络输出的误差，然后反向传播误差到每个神经元，不断更新网络参数，以使误差最小化。
反向传播算法的原理可以分为两个步骤：前向传播和反向传播。

前向传播

在前向传播过程中，我们首先将输入数据传入神经网络中，然后通过神经元之间的连接和激活函数计算出网络的输出。具体而言，对于一个有 $L$ 层的神经网络，假设输入层有 $n$ 个神经元，输出层有 $m$ 个神经元，第 $i$ 层的神经元个数为 $h_i$ ，则前向传播的计算公式如下：

$z^{(i+1)} = W^{(i)}a^{(i)} + b^{(i)}$

$a^{(i+1)} = f(z^{(i+1)})$

其中， $a^{(1)}$ 为输入数据， $f$ 为激活函数， $W$ 为权重矩阵， $b$ 为偏置向量， $z$ 为加权输入。

反向传播

在反向传播过程中，我们首先计算出网络输出与期望输出之间的误差，然后将误差反向传播到每个神经元，根据误差调整每个神经元之间的权重和偏置。具体而言，对于一个有 $L$ 层的神经网络，假设输出层的误差为 $E$ ，第 $i$ 层的误差为 $E^{(i)}$ ，则反向传播的计算公式如下：

$\frac{1}{2}\sum_{j=1}^{m}(y_j-\hat{y}_j)^2$

$E^{(i)} = \frac{\partial E}{\partial z^{(i)}} = \frac{\partial E}{\partial a^{(i)}} \frac{\partial a^{(i)}}{\partial z^{(i)}}$

$\frac{\partial E}{\partial W^{(i)}} = \frac{\partial E^{(i)}}{\partial W^{(i)}} = a^{(i-1)}(E^{(i)})^T$

$\frac{\partial E}{\partial b^{(i)}} = \frac{\partial E^{(i)}}{\partial b^{(i)}} = E^{(i)}$

其中， $y$ 为期望输出， $\hat{y}$ 为网络输出， $\frac{\partial E}{\partial z^{(i)}}$ 为第 $i$ 层的误差， $\frac{\partial E}{\partial W^{(i)}}$ 为权重矩阵的梯度， $\frac{\partial E}{\partial b^{(i)}}$ 为偏置向量的梯度。

在得到权重和偏置的梯度之后，我们可以根据梯度下降法，不断更新权重和偏置，以最小化误差函数 $E$ 。

import numpy as np

class NeuralNetwork:
    def __init__(self, input_dim, hidden_dim, output_dim):
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.output_dim = output_dim
        self.W1 = np.random.randn(input_dim, hidden_dim)
        self.b1 = np.zeros((1, hidden_dim))
        self.W2 = np.random.randn(hidden_dim, output_dim)
        self.b2 = np.zeros((1, output_dim))

    def forward(self, X):
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = np.tanh(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = np.tanh(self.z2)

    def backward(self, X, y):
        self.delta2 = self.a2 - y
        self.delta1 = np.dot(self.delta2, self.W2.T) * (1 - np.power(self.a1, 2))
        self.dW2 = np.dot(self.a1.T, self.delta2)
        self.db2 = np.sum(self.delta2, axis=0, keepdims=True)
        self.dW1 = np.dot(X.T, self.delta1)
        self.db1 = np.sum(self.delta1, axis=0)

    def update(self, alpha):
        self.W1 -= alpha * self.dW1
        self.b1 -= alpha * self.db1
        self.W2 -= alpha * self.dW2
        self.b2 -= alpha * self.db2

    def fit(self, X, y, epochs, alpha):
        for i in range(epochs):
            self.forward(X)
            self.backward(X, y)
            self.update(alpha)

    def predict(self, X):
        self.forward(X)
        return self.a2