深度学习三剑客：BP神经网络、循环神经网络与残差神经网络的原理对比与实战指南

1次阅读

没有评论

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

在深度学习领域，BP 神经网络、循环神经网络 (RNN) 和残差神经网络 (ResNet) 是三种基础而重要的网络结构，它们各自有着不同的特点和适用场景。

BP 神经网络：是最基础的前馈神经网络，通过反向传播算法调整权重，适用于结构化数据的分类和回归任务。
循环神经网络(RNN)：专门为序列数据设计，具有记忆功能，适用于自然语言处理、时间序列预测等任务。
残差神经网络(ResNet)：通过引入残差连接解决了深层网络训练困难的问题，在图像识别等领域表现优异。

BP 神经网络在训练深层网络时容易遇到梯度消失问题。当网络层数增加时，梯度在反向传播过程中会逐渐变小，导致浅层网络的权重更新缓慢甚至停止更新。

传统 RNN 在处理长序列时存在以下问题：

长期依赖问题：难以捕捉远距离的时序依赖关系
梯度爆炸 / 消失：与 BP 神经网络类似，在时间维度上也会出现梯度问题
计算效率低：无法并行计算整个序列

随着网络深度增加，训练会变得困难，主要原因包括：

梯度传播路径变长
参数空间增大
优化曲面更加复杂

三种网络的结构差异主要体现在信息流动方式上：

BP 神经网络：前向传播，无循环连接
RNN：具有时间循环连接
ResNet：包含跨层连接（shortcut connections）

BP 神经网络：y = f(Wx + b)
RNN：h_t = f(W_hh_{t-1} + W_xx_t + b)
ResNet：y = F(x, {W_i}) + x

BP 神经网络：O(n^2)（n 为神经元数量）
RNN：O(Tn^2)（T 为时间步长）
ResNet：与普通 CNN 类似，但增加了 shortcut 连接的计算

import torch
import torch.nn as nn
import torch.optim as optim

class BPNet(nn.Module):
    def __init__(self):
        super(BPNet, self).__init__()
        self.fc1 = nn.Linear(784, 512)
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 10)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = x.view(-1, 784)  # 展平输入
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

class RNN(nn.Module):
    def __init__(self):
        super(RNN, self).__init__()
        self.rnn = nn.RNN(input_size=28, hidden_size=128, num_layers=2, batch_first=True)
        self.fc = nn.Linear(128, 10)

    def forward(self, x):
        # x shape: (batch, 1, 28, 28) -> (batch, 28, 28)
        x = x.squeeze(1).permute(0, 2, 1)
        out, _ = self.rnn(x)
        out = self.fc(out[:, -1, :])
        return out

class ResBlock(nn.Module):
    def __init__(self, in_channels):
        super(ResBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)
        self.bn1 = nn.BatchNorm2d(in_channels)
        self.conv2 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(in_channels)
        self.relu = nn.ReLU()

    def forward(self, x):
        residual = x
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += residual
        out = self.relu(out)
        return out

class ResNet(nn.Module):
    def __init__(self):
        super(ResNet, self).__init__()
        self.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU()
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        self.layer1 = self._make_layer(64, 2)
        self.layer2 = self._make_layer(128, 2)

        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(128, 10)

    def _make_layer(self, channels, blocks):
        layers = []
        for _ in range(blocks):
            layers.append(ResBlock(channels))
        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.relu(self.bn1(self.conv1(x)))
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)

        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)
        return x

ReLU 及其变体（LeakyReLU、PReLU）是大多数情况下的首选
最后一层分类任务通常不使用激活函数（或使用 softmax）
RNN 中 tanh 比 sigmoid 更常用

在卷积 / 全连接层后、激活函数前使用 BN
训练和测试时 BN 的行为不同
BN 可以显著加速训练并提高模型稳定性

初始学习率设置：0.1-0.001
常用调整策略：StepLR、ReduceLROnPlateau、CosineAnnealing
不同层可以使用不同学习率

BP 神经网络：内存占用最小
RNN：中等，取决于序列长度
ResNet：最大，因为参数最多

BP 神经网络：最快
RNN：较慢，无法并行计算
ResNet：中等，可以利用 GPU 并行计算

在 MNIST 数据集上的测试准确率：

BP 神经网络：约 98%
RNN：约 97%
ResNet：约 99%

BP 神经网络：结构化数据、输入维度不高、任务相对简单
RNN：时序数据、自然语言处理、需要记忆历史信息的任务
ResNet：图像数据、需要深层网络的复杂任务

尝试在 CIFAR-10 数据集上实现这三种网络，比较它们的性能差异
研究 LSTM 和 GRU 如何解决 RNN 的长期依赖问题
探索 ResNet 中不同的残差连接方式对模型性能的影响

Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep learning. MIT press.
He, K., Zhang, X., Ren, S., & Sun, J. (2016). Deep residual learning for image recognition. In CVPR.
Hochreiter, S., & Schmidhuber, J. (1997). Long short-term memory. Neural computation.

正文完