深度学习架构演进：从CNN、RNN到GAN的原理、优缺点与结构图解

1次阅读

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

在深度学习兴起之前，传统机器学习方法（如 SVM、随机森林）在处理复杂数据时面临三大挑战：

图像数据：手工设计特征（如 SIFT、HOG）无法捕捉像素间的空间层级关系
序列数据：时间维度上的动态模式难以用固定维度的特征向量表示
生成任务：缺乏从隐空间到数据空间的非线性映射能力

卷积神经网络 (Convolutional Neural Network) 通过三个关键设计解决图像问题：

局部感受野 ：卷积核(Convolution Kernel) 在输入上滑动计算局部特征
权重共享：同一卷积核在整个图像上复用，大幅减少参数量
层级抽象：通过多层卷积 - 池化交替逐步提取高阶语义特征

graph TD
    A[输入图像] --> B[Conv1+ReLU]
    B --> C[MaxPooling]
    C --> D[Conv2+ReLU]
    D --> E[MaxPooling]
    E --> F[全连接层]
    F --> G[输出分类]

优点	缺点
自动提取空间特征	难以处理时序数据
参数效率高	全连接层参数量大
平移不变性	池化丢失空间信息

import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, 3)  # 输入通道, 输出通道, 卷积核
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(16*13*13, 10)  # 假设输入为 32x32

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = torch.flatten(x, 1)
        x = self.fc1(x)
        return x

循环神经网络 (Recurrent Neural Network) 通过隐藏状态传递历史信息：

时间展开：每个时间步共享同一组参数
门控机制：LSTM 引入遗忘门 / 输入门 / 输出门控制信息流
BPTT：通过时间反向传播更新参数

LSTM 单元结构：[h_t-1, x_t]
        ||
   [遗忘门] → (决定保留多少旧记忆)
        ||
   [输入门] → (决定添加多少新记忆)
        ||
   [输出门] → (决定输出多少当前状态)
        ||
      h_t

优点	缺点
处理变长序列	梯度消失 / 爆炸问题
记忆历史信息	并行计算困难
时序建模能力强	长期依赖仍有限

class SimpleLSTM(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super().__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, 1)

    def forward(self, x):
        # x 形状: (batch, seq_len, features)
        out, (h_n, c_n) = self.lstm(x)
        return self.fc(out[:, -1, :])  # 取最后时间步

生成对抗网络 (Generative Adversarial Network) 通过双网络博弈：

生成器(Generator)：将随机噪声映射到数据空间
判别器(Discriminator)：区分真实数据与生成样本
Minimax 博弈：目标函数 V(D,G)=E[logD(x)]+E[log(1-D(G(z)))]

graph LR
    Z[噪声向量] --> G[生成器]
    G --> X_fake[生成样本]
    X_real[真实数据] --> D[判别器]
    X_fake --> D
    D --> Loss

优点	缺点
无需显式建模分布	训练不稳定
生成质量高	模式崩溃问题
隐空间插值可控	评估指标复杂

# 生成器
class Generator(nn.Module):
    def __init__(self, z_dim, img_dim):
        super().__init__()
        self.net = nn.Sequential(nn.Linear(z_dim, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, img_dim),
            nn.Tanh()  # 输出归一化到[-1,1]
        )

    def forward(self, z):
        return self.net(z)

# 判别器
class Discriminator(nn.Module):
    def __init__(self, img_dim):
        super().__init__()
        self.net = nn.Sequential(nn.Linear(img_dim, 128),
            nn.LeakyReLU(0.2),
            nn.Linear(128, 1),
            nn.Sigmoid())

    def forward(self, x):
        return self.net(x)