深度学习入门指南：从BP神经网络到残差网络的实战演进

1次阅读

没有评论

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

假设我们要处理两个实际问题：

股票价格预测 ：这是一个典型的时序预测问题，需要模型能够记住历史数据的趋势。循环神经网络（RNN）因其具有记忆功能，能够很好地处理这种具有时间依赖性的数据。
手写数字识别 ：这是一个图像分类问题，BP 神经网络和残差网络（ResNet）都能胜任。但 ResNet 通过跳跃连接解决了深层网络梯度消失的问题，在更复杂的图像任务中表现更好。

BP 神经网络由输入层、隐藏层和输出层组成。其前向传播过程可以用以下数学表达式描述：

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

其中 $\sigma$ 是激活函数，常用 ReLU 或 Sigmoid。

RNN 通过循环连接处理序列数据，其核心公式为：

$$
h_t = \sigma(W_{hh}h_{t-1} + W_{xh}x_t + b_h)
$$
$$
y_t = W_{hy}h_t + b_y
$$

这种结构使得网络能够保留之前时间步的信息。

ResNet 通过引入跳跃连接解决了深度网络中的梯度消失问题：

$$
F(x) = H(x) – x
$$
$$
H(x) = F(x) + x
$$

这种结构使得深层网络能够被有效训练。

import torch
from torchvision import datasets, transforms

# 数据预处理
transform = transforms.Compose([transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('./data', train=False, transform=transform)

# 数据加载器
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1000, shuffle=False)

import torch.nn as nn
import torch.nn.functional as F

class BPNet(nn.Module):
    def __init__(self):
        super(BPNet, self).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 10)

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

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

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

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.conv2 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)

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

class ResNet(nn.Module):
    def __init__(self):
        super(ResNet, self).__init__()
        self.conv1 = nn.Conv2d(1, 16, kernel_size=3, padding=1)
        self.resblock = ResBlock(16)
        self.fc = nn.Linear(16*28*28, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.resblock(x)
        x = x.view(-1, 16*28*28)
        x = self.fc(x)
        return F.log_softmax(x, dim=1)