Sean's Blog

神经网络层类型详解

25分钟阅读

神经网络层类型详解

学习目标： 系统掌握神经网络中各类层的原理、应用场景和实现细节。 关联笔记： 神经网络、Transformer

1 全连接层（Dense/Linear Layer）

1.1 核心原理

数学定义：

其中：

  • - 输入向量
  • - 权重矩阵
  • - 偏置向量
  • - 输出向量

关键特点：

  • ✅ 每个输出神经元与 所有 输入神经元连接
  • ✅ 参数量：
  • ❌ 参数量随维度平方增长，大规模输入不适用
  • ❌ 无空间/时序结构假设（对图像/序列不高效）

1.2 代码实现

import torch
import torch.nn as nn
 
# PyTorch 内置
linear = nn.Linear(in_features=512, out_features=256, bias=True)
 
# 手动实现
class LinearLayer(nn.Module):
    def __init__(self, in_dim, out_dim):
        super().__init__()
        self.weight = nn.Parameter(torch.randn(out_dim, in_dim) * 0.01)
        self.bias = nn.Parameter(torch.zeros(out_dim))
    
    def forward(self, x):
        # x: [batch, in_dim]
        return x @ self.weight.T + self.bias  # [batch, out_dim]

1.3 应用场景

场景作用示例
分类头将特征映射到类别ImageNet 1000 类分类
特征变换调整特征维度512 → 256 降维
MLP 块多层感知机主体Transformer FFN
嵌入投影低维离散 → 高维连续Word Embedding 后接 Linear
回归输出预测连续值房价预测最后一层

1.4 优化技巧

初始化策略：

# Xavier (适合 Sigmoid/Tanh)
nn.init.xavier_uniform_(linear.weight)
 
# Kaiming (适合 ReLU)
nn.init.kaiming_normal_(linear.weight, mode='fan_in', nonlinearity='relu')

参数量优化：

  • 低秩分解： ，其中 ,
    • 原始参数：
    • 分解后：
    • 当 时大幅减少参数

2 卷积层（Convolutional Layer）

2.1 核心原理

数学定义（2D 卷积）：

关键概念：

  • 局部感受野（Receptive Field）： 每个输出仅连接输入的局部区域
  • 权重共享（Weight Sharing）： 同一卷积核在整个输入上滑动
  • 平移不变性（Translation Invariance）： 相同模式在不同位置产生相似响应

2.2 超参数详解

参数含义典型值影响
kernel_size卷积核大小3×3, 5×5, 7×7感受野大小
stride滑动步长1, 2输出分辨率（stride=2 减半）
padding边缘填充0, 1, 2保持尺寸（same padding）
dilation空洞率1, 2, 4扩大感受野不增加参数
groups分组卷积1, in_channels降低计算量（Depthwise）
in_channels输入通道数3 (RGB)-
out_channels输出通道数（滤波器数）64, 128, 256特征丰富度

2.3 输出尺寸计算

示例：

  • 输入：，kernel=7, stride=2, padding=3
  • 输出：

2.4 卷积变体

2.4.1 标准卷积 vs 深度可分离卷积

类型操作参数量计算量代表模型
标准卷积直接卷积所有通道高ResNet, VGG
深度可分离卷积 (Depthwise)先逐通道卷积 + 再 1×1 混合低 8-9×MobileNet, Xception

代码对比：

# 标准卷积
conv_std = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1)
# 参数量: 3*3*64*128 = 73,728
 
# 深度可分离卷积
conv_depthwise = nn.Conv2d(64, 64, 3, padding=1, groups=64)  # 逐通道
conv_pointwise = nn.Conv2d(64, 128, 1)  # 1×1 混合
# 参数量: 3*3*64 + 64*128 = 576 + 8,192 = 8,768 (减少 88%)

2.4.2 空洞卷积（Dilated/Atrous Convolution）

原理： 在卷积核元素间插入空洞，扩大感受野而不增加参数。

# dilation=1 (标准 3×3)
# ● ● ●
# ● ● ●
# ● ● ●
 
# dilation=2 (感受野 5×5，参数仍为 9 个)
# ●   ●   ●
#   
# ●   ●   ●
#   
# ●   ●   ●
 
conv_dilated = nn.Conv2d(64, 64, kernel_size=3, dilation=2, padding=2)

应用： 语义分割（DeepLab）、大感受野音频处理（WaveNet）

2.5 代码示例

import torch.nn as nn
 
class ConvBlock(nn.Module):
    """标准卷积块：Conv + BN + ReLU"""
    def __init__(self, in_channels, out_channels, kernel_size=3):
        super().__init__()
        padding = kernel_size // 2  # same padding
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, padding=padding)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
    
    def forward(self, x):
        return self.relu(self.bn(self.conv(x)))
 
# 使用
block = ConvBlock(in_channels=3, out_channels=64, kernel_size=7)
x = torch.randn(1, 3, 224, 224)
out = block(x)  # [1, 64, 224, 224]

2.6 应用场景

领域任务典型架构原因
计算机视觉图像分类ResNet, EfficientNet局部特征提取
目标检测YOLO, Faster R-CNN多尺度特征
语义分割U-Net, DeepLab保留空间信息
音频处理语音识别Wav2Vec 2.0时间局部性
音乐生成WaveNet空洞卷积扩大感受野
时间序列传感器数据分析TCN (Temporal CNN)因果卷积处理序列

3 循环层（Recurrent Layers）

3.1 基础 RNN

数学定义：

核心思想： 隐藏状态 递归依赖前一时刻 ，实现序列建模。

致命问题：梯度消失/爆炸

  • 长序列反向传播时，梯度连乘导致：
    • （梯度消失）→ 无法学习长期依赖
    • （梯度爆炸）→ 训练不稳定

3.2 LSTM（Long Short-Term Memory）

核心创新： 引入 细胞状态（Cell State） 和 三个门控机制。

3.2.1 门控机制

门公式作用
遗忘门决定丢弃多少旧信息
输入门决定更新多少新信息
输出门决定输出多少细胞状态

细胞状态更新：

关键优势：

  • ✅ 细胞状态提供 ” 高速公路 “，梯度可直接流动
  • ✅ 门控机制自适应调节信息流

3.2.2 代码实现

import torch
import torch.nn as nn
 
# PyTorch 内置 LSTM
lstm = nn.LSTM(input_size=128, hidden_size=256, num_layers=2, 
               batch_first=True, dropout=0.2, bidirectional=True)
 
# 前向传播
x = torch.randn(32, 50, 128)  # [batch, seq_len, input_size]
h0 = torch.zeros(4, 32, 256)  # [num_layers*directions, batch, hidden_size]
c0 = torch.zeros(4, 32, 256)
 
output, (hn, cn) = lstm(x, (h0, c0))
# output: [32, 50, 512] (双向拼接)
# hn: [4, 32, 256] (最后时刻隐藏状态)
# cn: [4, 32, 256] (最后时刻细胞状态)

3.3 GRU（Gated Recurrent Unit）

简化版 LSTM： 合并细胞状态和隐藏状态，只用两个门。

公式：

对比 LSTM：

维度LSTMGRU
门数量3 (遗忘/输入/输出)2 (更新/重置)
参数量多少 ~25%
训练速度慢快
表达能力强略弱但通常够用
应用场景长序列、复杂任务中短序列、实时

3.4 双向 RNN（Bidirectional RNN）

原理： 同时从前向和后向处理序列，捕获双向上下文。

# 前向 RNN: h1 → h2 → h3 → h4
# 后向 RNN: h4 ← h3 ← h2 ← h1
# 最终输出: [h1_forward; h1_backward] 拼接
 
bi_lstm = nn.LSTM(128, 256, bidirectional=True)
# 输出维度: 256*2 = 512

应用： 文本分类、命名实体识别（需要全句上下文）

3.5 应用场景与局限

应用RNN 类型原因
机器翻译LSTM/GRU序列到序列
语音识别双向 LSTM需要双向上下文
时间序列预测LSTM长期依赖建模
视频分析3D CNN + LSTM空间特征 + 时序依赖
大模型预训练TransformerRNN 已被淘汰（并行性差）

为什么 Transformer 取代了 RNN？

  1. ❌ 串行计算： RNN 必须逐步计算，无法并行（训练慢 10-100×）
  2. ❌ 长序列能力： 即使 LSTM，超过 1000 步仍会退化
  3. ❌ 梯度问题： 深层 RNN 训练困难
  4. ✅ Transformer 优势： 全局注意力 + 完全并行 + 可扩展性

4 注意力层（Attention Layers）

4.1 核心思想

类比： 人类阅读时会 ” 注意 ” 重点部分，注意力机制让模型也这样做。

数学本质： 通过 Query-Key 匹配 计算权重，对 Value 加权求和。

4.2 自注意力（Self-Attention）

定义： Query、Key、Value 都来自同一个输入序列。

步骤：

  1. 线性投影：
  2. 计算相似度：
  3. 归一化权重：
  4. 加权求和：

可视化示例：

输入句子: "The cat sat on the mat"
Query: "cat" 的向量
Key: 所有词的向量
相似度计算: cat 与每个词的匹配度
结果: "sat" 和 "mat" 获得高权重（语义相关）

4.3 多头注意力（Multi-Head Attention）

原理： 用多个注意力头并行学习不同的注意模式。

为什么需要多头？

  • 单头：只能关注一种模式（如位置关系）
  • 多头：同时关注多种模式（如语法、语义、共指）

典型配置：

  • GPT-3: 96 头，每头维度 128
  • BERT-base: 12 头，每头维度 64

4.4 注意力变体

类型公式/特点复杂度应用
标准注意力 全连接Transformer 基础
因果注意力上三角 mask（不看未来）GPT 解码器
交叉注意力Q 来自解码器，K/V 来自编码器机器翻译、图像描述
稀疏注意力仅计算部分位置Longformer, BigBird
线性注意力核技巧近似Performer
滑动窗口注意力局部窗口 + 全局 tokenMistral
Flash AttentionIO-aware 块计算 但快 20×主流实现

4.5 代码实现

import torch
import torch.nn as nn
import torch.nn.functional as F
 
class SelfAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        assert d_model % n_heads == 0
        self.d_k = d_model // n_heads
        self.n_heads = n_heads
        
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)
    
    def forward(self, x, mask=None):
        batch_size, seq_len, d_model = x.shape
        
        # 线性投影 + 分头
        Q = self.W_q(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
        K = self.W_k(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
        V = self.W_v(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
        # 形状: [batch, n_heads, seq_len, d_k]
        
        # 计算注意力分数
        scores = torch.matmul(Q, K.transpose(-2, -1)) / (self.d_k ** 0.5)
        # [batch, n_heads, seq_len, seq_len]
        
        if mask is not None:
            scores = scores.masked_fill(mask == 0, float('-inf'))
        
        attn_weights = F.softmax(scores, dim=-1)
        
        # 加权求和
        output = torch.matmul(attn_weights, V)
        # [batch, n_heads, seq_len, d_k]
        
        # 合并多头
        output = output.transpose(1, 2).contiguous().view(batch_size, seq_len, d_model)
        return self.W_o(output)

4.6 应用场景

任务注意力类型作用
机器翻译交叉注意力对齐源语言和目标语言
文本生成因果注意力自回归生成
文本分类双向注意力捕获全局语义
问答系统交叉注意力问题与文档对齐
图像描述生成交叉注意力图像区域与词对齐
长文档理解稀疏注意力降低复杂度

详见 Transformer 专题笔记。

5 状态空间层（State Space Models）

5.1 从 RNN 到 SSM 的演进

问题： RNN 串行计算慢，Transformer 长序列内存爆炸。

SSM 核心思想： 用状态空间方程建模序列，可以并行训练 + 线性推理。

5.2 线性时不变 SSM (LTI-SSM)

连续时间公式：

离散化后（用于神经网络）：

关键矩阵：

  • - 状态转移矩阵
  • - 输入矩阵
  • - 输出矩阵

训练技巧： 可以转换为卷积形式并行计算！

5.3 Mamba：选择性状态空间模型

创新点： 让 （时间步长）变成 输入依赖 的参数。

为什么重要？

  • 传统 SSM：所有位置共享参数（类似 CNN）
  • Mamba：根据输入动态调整（类似 Attention 的内容感知）

结果：

  • ✅ 线性时间复杂度
  • ✅ 可以选择性记住重要信息（解决复制任务等）
  • ✅ 训练并行化（转为卷积）
  • ✅ 推理递归化（逐步更新状态）

5.4 Mamba 架构

class MambaBlock(nn.Module):
    def __init__(self, d_model, d_state=16, expand=2):
        super().__init__()
        self.d_inner = d_model * expand
        
        # 输入投影
        self.in_proj = nn.Linear(d_model, self.d_inner * 2)
        
        # SSM 参数
        self.conv1d = nn.Conv1d(self.d_inner, self.d_inner, kernel_size=3, 
                                padding=1, groups=self.d_inner)
        self.x_proj = nn.Linear(self.d_inner, d_state * 2 + 1)  # B, C, Δ
        self.dt_proj = nn.Linear(d_state, self.d_inner)
        
        # 状态空间参数
        self.A = nn.Parameter(torch.randn(self.d_inner, d_state))
        self.D = nn.Parameter(torch.ones(self.d_inner))
        
        # 输出投影
        self.out_proj = nn.Linear(self.d_inner, d_model)
    
    def forward(self, x):
        # x: [batch, seq_len, d_model]
        batch, seq_len, _ = x.shape
        
        # 门控投影
        x_and_res = self.in_proj(x)
        x, res = x_and_res.split(self.d_inner, dim=-1)
        
        # 1D 卷积（局部依赖）
        x = x.transpose(1, 2)  # [batch, d_inner, seq_len]
        x = self.conv1d(x)
        x = x.transpose(1, 2)  # [batch, seq_len, d_inner]
        
        # 选择性扫描（这里简化，实际需要 CUDA kernel）
        # ... SSM 计算 ...
        
        # 门控 + 输出
        y = x * F.silu(res)
        return self.out_proj(y)

5.5 SSM vs Attention 对比

维度Transformer AttentionSSM/Mamba
时间复杂度
空间复杂度 (KV Cache) (状态固定大小)
并行训练✅ 完全并行✅ 完全并行（卷积视角）
推理效率慢（需完整前向）快（递归更新）
长序列能力需优化（Flash/稀疏）原生支持
内容召回强（全局注意力）中（受状态维度限制）
生态成熟度极高发展中

5.6 应用场景

场景优势
超长上下文（100K+）内存占用恒定
实时流式推理无需存储历史
音频/视频处理长序列天然支持
时间序列预测连续动态系统建模
边缘设备部署推理内存小

局限：

  • 随机访问任意历史位置能力弱（不如 Attention）
  • 训练需要特殊实现（CUDA kernel）
  • 调试和可解释性较差

6 正则化层

6.1 Dropout

原理： 训练时随机 ” 丢弃 ” 部分神经元（输出置 0）。

数学：

\frac{x}{1-p} \cdot m, & \text{训练时} \\ x, & \text{测试时} \end{cases}$$ 其中 $m \sim \text{Bernoulli}(1-p)$ **作用：** - 防止过拟合（类似集成学习） - 强制学习鲁棒特征 **代码：** ```python dropout = nn.Dropout(p=0.5) # 丢弃 50% x = dropout(x) # 训练时随机置零，测试时不变 ``` **使用建议：** - 全连接层：p=0.5（大模型可 0.1） - 卷积层：p=0.2-0.3 - RNN：用 Dropout Variational（时间步共享 mask） - Transformer：残差前 dropout ### 6.2 Stochastic Depth（随机深度） **原理：** 训练时随机 " 跳过 " 整个残差块。 ```python def stochastic_depth(x, residual_fn, drop_prob, training): if training and random.random() < drop_prob: return x # 跳过残差块 else: return x + residual_fn(x) ``` **优势：** - 加速训练（平均减少层数） - 缓解梯度消失 - 提升泛化 **应用：** EfficientNet、ViT 等深层网络 --- ## 7 嵌入层（Embedding Layers） ### 7.1 词嵌入（Word Embedding） **原理：** 将离散 token ID 映射到连续向量空间。 ```python embedding = nn.Embedding(num_embeddings=50000, embedding_dim=512) token_ids = torch.tensor([[10, 25, 300]]) # [batch, seq_len] vectors = embedding(token_ids) # [batch, seq_len, 512] ``` **预训练方案：** - Word2Vec：CBOW/Skip-gram - GloVe：全局词共现矩阵分解 - FastText：子词级别（处理 OOV） ### 7.2 位置编码（Positional Encoding） **为什么需要？** Transformer/MLP 本身无法区分位置顺序。 #### 7.2.1 正弦位置编码（Sinusoidal） $$PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d}}\right)$$ $$PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d}}\right)$$ **优点：** 无需训练，可外推到更长序列 #### 7.2.2 可学习位置嵌入 ```python position_embedding = nn.Embedding(max_position=2048, embedding_dim=512) pos_ids = torch.arange(seq_len) pos_vectors = position_embedding(pos_ids) ``` **优点：** 更灵活 **缺点：** 不能外推到训练时未见过的长度 #### 7.2.3 旋转位置编码（RoPE） **原理：** 通过旋转矩阵注入相对位置信息。 $$\text{RoPE}(x_m, m) = \begin{pmatrix} \cos m\theta & -\sin m\theta \\ \sin m\theta & \cos m\theta \end{pmatrix} \begin{pmatrix} x_1 \\ x_2 \end{pmatrix}$$ **优势：** - 编码 **相对位置**（更符合语言特性） - 更好的外推能力 - 当前大模型主流（LLaMA, Mistral, Qwen） #### 7.2.4 ALiBi（Attention with Linear Biases） **原理：** 在注意力分数上添加线性偏置。 $$\text{softmax}\left(\frac{QK^T}{\sqrt{d_k}} + m \cdot [0, -1, -2, \ldots, -(n-1)]\right)$$ **优点：** 极简，外推性能优秀（BLOOM, MPT） ### 7.3 位置编码对比 | 方法 | 训练 | 外推能力 | 相对/绝对 | 代表模型 | | ------ | ---- | -------- | --------- | -------------- | | 正弦 | ❌ | ✅ | 绝对 | Transformer | | 可学习 | ✅ | ❌ | 绝对 | BERT, GPT-2 | | RoPE | ❌ | ✅ | 相对 | LLaMA, Mistral | | ALiBi | ❌ | ✅✅ | 相对 | BLOOM, MPT | --- ## 8 图神经网络层（GNN Layers） ### 8.1 图卷积网络（GCN） **核心思想：** 聚合邻居节点特征。 **公式：** $$h_v^{(l+1)} = \sigma\left(W^{(l)} \sum_{u \in \mathcal{N}(v)} \frac{h_u^{(l)}}{\sqrt{d_v d_u}}\right)$$ 其中 $\mathcal{N}(v)$ 是节点 $v$ 的邻居集合。 ### 8.2 图注意力网络（GAT） **创新：** 邻居权重由注意力机制学习（而非固定归一化）。 $$\alpha_{vu} = \text{softmax}\left(\text{LeakyReLU}(a^T [W h_v \| W h_u])\right)$$ $$h_v^{(l+1)} = \sigma\left(\sum_{u \in \mathcal{N}(v)} \alpha_{vu} W h_u^{(l)}\right)$$ ### 8.3 GraphSAGE **特点：** 采样固定数量邻居（避免度数差异大）。 **聚合函数：** - Mean：$h_v = \text{mean}(\{h_u : u \in \mathcal{N}(v)\})$ - Pool：$h_v = \max(\{\text{MLP}(h_u) : u \in \mathcal{N}(v)\})$ - LSTM：按顺序聚合邻居 ### 8.4 应用场景 | 任务 | 说明 | 示例 | | ------------ | ----------------- | ---------------- | | 节点分类 | 预测节点标签 | 社交网络用户分类 | | 链接预测 | 预测是否存在边 | 好友推荐 | | 图分类 | 预测整个图的标签 | 分子性质预测 | | 社区检测 | 发现图的子结构 | 社交圈识别 | | 知识图谱嵌入 | 实体/关系表示学习 | 问答系统 | --- ## 9 归一化层对比 ### 9.1 主流归一化方法 | 方法 | 归一化维度 | 公式 | 依赖批次 | 适用场景 | | ---------------- | ------------------------ | ------------------------------------------------ | -------- | --------------- | | **BatchNorm** | (Batch, H, W) 对 Channel | $\frac{x - \mu_B}{\sqrt{\sigma_B^2 + \epsilon}}$ | ✅ | CNN（大批次） | | **LayerNorm** | (C, H, W) 对每个样本 | $\frac{x - \mu_L}{\sqrt{\sigma_L^2 + \epsilon}}$ | ❌ | Transformer/RNN | | **GroupNorm** | 分组内归一化 | 介于 LN 和 IN 之间 | ❌ | 小批次 CNN | | **InstanceNorm** | (H, W) 对每个通道 | $\frac{x - \mu_I}{\sqrt{\sigma_I^2 + \epsilon}}$ | ❌ | 风格迁移 | | **RMSNorm** | 仅归一化方差（无减均值） | $\frac{x}{\sqrt{\text{mean}(x^2) + \epsilon}}$ | ❌ | LLaMA, T5 | ### 9.2 代码示例 ```python # BatchNorm (2D) bn = nn.BatchNorm2d(num_features=64) x = torch.randn(32, 64, 28, 28) # [B, C, H, W] out = bn(x) # LayerNorm ln = nn.LayerNorm(normalized_shape=512) x = torch.randn(32, 50, 512) # [B, T, D] out = ln(x) # RMSNorm (手动实现) class RMSNorm(nn.Module): def __init__(self, dim, eps=1e-6): super().__init__() self.eps = eps self.weight = nn.Parameter(torch.ones(dim)) def forward(self, x): rms = torch.sqrt(x.pow(2).mean(dim=-1, keepdim=True) + self.eps) return x / rms * self.weight ``` ### 9.3 Pre-LN vs Post-LN **Post-LN（原始 Transformer）：** ```python x = x + sublayer(x) x = LayerNorm(x) ``` **Pre-LN（GPT-2/3, LLaMA）：** ```python x = x + sublayer(LayerNorm(x)) ``` **对比：** | 维度 | Post-LN | Pre-LN | | ---------- | ---------------- | ------------ | | 训练稳定性 | 较差（深层难训） | 更稳定 | | 性能 | 略高 | 略低但可接受 | | 应用 | BERT | GPT-3, LLaMA | --- ## 10 层选择决策树 ``` 问题：需要处理什么数据？ │ ├─ 图像/视频 │ ├─ 局部特征重要 → 卷积层（CNN） │ ├─ 全局依赖重要 → Vision Transformer (ViT) │ └─ 时序建模 → 3D CNN / Temporal Attention │ ├─ 文本/序列 │ ├─ 长度 < 512 → Transformer（标准注意力） │ ├─ 长度 512-8K → FlashAttention / ALiBi │ ├─ 长度 > 8K → Mamba / Sparse Attention │ └─ 实时流式 → LSTM / Mamba（递归推理） │ ├─ 图结构 │ ├─ 节点特征聚合 → GCN │ ├─ 边权重重要 → GAT │ └─ 大规模图 → GraphSAGE（邻居采样） │ ├─ 表格数据 │ └─ 全连接层（MLP）+ Feature Engineering │ └─ 多模态 ├─ 图像 + 文本 → 交叉注意力 / Q-Former └─ 音频 + 视频 → 多流融合 + Temporal Alignment ``` --- ## 11 实践建议 ### 11.1 层堆叠原则 1. **浅层 → 深层：** 低级特征 → 高级语义 - CNN：边缘 → 纹理 → 部件 → 对象 - NLP：字符 → 词 → 短语 → 句子 2. **残差连接：** 深度 > 10 层必须加 ```python x = x + F(x) # 避免梯度消失 ``` 3. **瓶颈设计：** 降维 → 处理 → 升维 ```python x = conv1x1(x, channels//4) # 降维 x = conv3x3(x) # 处理 x = conv1x1(x, channels) # 升维 ``` ### 11.2 调试 Checklist | 问题 | 检查项 | | -------- | ------------------------------ | | 梯度消失 | 激活函数、残差、归一化 | | 过拟合 | Dropout、数据增强、正则化 | | 训练慢 | 批量大小、学习率、并行化 | | 显存不足 | 梯度检查点、混合精度、降低批量 | | NaN loss | 梯度裁剪、初始化、学习率 | ### 11.3 推荐学习路径 1. **入门：** 实现全连接层分类 MNIST 2. **进阶：** CNN 处理 CIFAR-10 3. **序列：** LSTM 文本分类 4. **注意力：** 手写 Transformer Encoder 5. **前沿：** 复现 Mamba 并对比 Transformer --- ## 12 扩展阅读 **论文：** - [Attention Is All You Need](https://arxiv.org/abs/1706.03762) - Transformer - [Mamba: Linear-Time Sequence Modeling](https://arxiv.org/abs/2312.00752) - [Deep Residual Learning](https://arxiv.org/abs/1512.03385) - ResNet - [Batch Normalization](https://arxiv.org/abs/1502.03167) **工具库：** - PyTorch 官方文档：`torch.nn` 模块 - Hugging Face Transformers：预训练模型 - TorchVision：视觉模型 - PyTorch Geometric：图神经网络 --- **相关笔记：** - [[神经网络]] - 总览 - [[Transformer]] - 注意力机制详解 - [[卷积神经网络]] - CNN 架构演进 - [[循环神经网络]] - RNN/LSTM/GRU 深入 - [[图神经网络]] - GNN 理论与应用 --- **最后更新：** 2025-01-07 **维护者：** sean2077

目录

Graph View

反向链接