深度学习入门：从零理解AE反向传播的数学原理与实现

1次阅读

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

自动编码器 (Autoencoder, AE) 是深度学习中的基础模型，广泛应用于数据降维、特征学习和生成任务。它通过压缩输入数据到低维空间再重建的方式，学习数据的有效表示。反向传播算法则是训练 AE 的核心，理解它的数学原理对掌握深度学习至关重要。

AE 由编码器和解码器两部分组成。假设输入数据为 $x$，编码过程为 $h = f(W_1x + b_1)$，解码过程为 $\hat{x} = f(W_2h + b_2)$，其中 $f$ 是激活函数（如 sigmoid）。

损失函数通常采用均方误差：
$$L = \frac{1}{2N}\sum_{i=1}^N (x_i – \hat{x}_i)^2$$

反向传播通过链式法则计算各层参数的梯度。以单隐层 AE 为例：

输出层梯度：
$$\frac{\partial L}{\partial W_2} = \frac{\partial L}{\partial \hat{x}} \cdot \frac{\partial \hat{x}}{\partial W_2} = (\hat{x}-x) \cdot f'(z_2) \cdot h^T$$
隐层梯度：
$$\frac{\partial L}{\partial W_1} = \frac{\partial L}{\partial h} \cdot \frac{\partial h}{\partial W_1} = W_2^T(\hat{x}-x)f'(z_2) \cdot f'(z_1) \cdot x^T$$

import numpy as np

class Autoencoder:
    def __init__(self, input_dim, hidden_dim):
        # 初始化权重（Xavier 初始化）self.W1 = np.random.randn(input_dim, hidden_dim) * np.sqrt(2./input_dim)
        self.b1 = np.zeros(hidden_dim)
        self.W2 = np.random.randn(hidden_dim, input_dim) * np.sqrt(2./hidden_dim)
        self.b2 = np.zeros(input_dim)

    def forward(self, x):
        self.z1 = np.dot(x, self.W1) + self.b1
        self.h = self.sigmoid(self.z1)
        self.z2 = np.dot(self.h, self.W2) + self.b2
        return self.sigmoid(self.z2)

    def backward(self, x, lr=0.01):
        # 计算梯度
        error = self.forward(x) - x
        delta2 = error * self.sigmoid_derivative(self.z2)
        grad_W2 = np.dot(self.h.T, delta2)
        grad_b2 = np.sum(delta2, axis=0)

        delta1 = np.dot(delta2, self.W2.T) * self.sigmoid_derivative(self.z1)
        grad_W1 = np.dot(x.T, delta1)
        grad_b1 = np.sum(delta1, axis=0)

        # 参数更新
        self.W1 -= lr * grad_W1
        self.b1 -= lr * grad_b1
        self.W2 -= lr * grad_W2
        self.b2 -= lr * grad_b2

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

    def sigmoid_derivative(self, x):
        return self.sigmoid(x) * (1 - self.sigmoid(x))

使用 MNIST 数据集训练 AE：

数据预处理：

from tensorflow.keras.datasets import mnist
(x_train, _), (x_test, _) = mnist.load_data()
x_train = x_train.reshape(-1, 784) / 255.0
x_test = x_test.reshape(-1, 784) / 255.0

训练过程：

ae = Autoencoder(input_dim=784, hidden_dim=64)
for epoch in range(50):
    ae.backward(x_train)
    loss = np.mean((ae.forward(x_test) - x_test)**2)
    print(f"Epoch {epoch+1}, Test Loss: {loss:.4f}")

当网络层数较深时容易出现：