11-transformer-arch-2

transformer 中用到的常见网络: 多头 Attention, FNN

Seq2Seq

1-FFN

class MLP(nn.Module):
    def __init__(self, dim: int, hidden_dim: int, dropout: float):
        super().__init__()
        # 第一层：升维 (通常 dim → 4*dim)
        self.w1 = nn.Linear(dim, hidden_dim, bias=False)
        # 第二层：降维 (hidden_dim → dim)
        self.w2 = nn.Linear(hidden_dim, dim, bias=False)
        # Dropout 防止过拟合
        self.dropout = nn.Dropout(dropout)
 
    def forward(self, x):
        # 升维 → 激活 → 降维 → Dropout
        return self.dropout(self.w2(F.relu(self.w1(x))))

关键特点：

两层线性变换：升维 → 降维
中间激活函数：ReLU（引入非线性）
维度变化：通常是 dim → 4*dim → dim
Dropout 正则化：防止过拟合

标准的 FNN, 在 w1 把特征扩散到高维后马上用 Relu 在高维度学习更复杂的特征

2-层归一化

归一化有用的逻辑是这样的，预测的分布其实是相同的. 深度神经中每一层都会改变输出的值，我们为了保持分布的稳定性，就引入了归一化.

层归一化（Layer Norm）是深度学习中经典的归一化操作，与批归一化（Batch Norm）并列为神经网络中的两种主流归一化方法。

归一化的核心目的是让不同层输入的取值范围或分布保持一致。在深度神经网络中：

每一层的输入都是上一层的输出
多层传递下，网络较高层的输入分布会因前面所有层的参数变化而发生较大改变
各层输出分布的差异随网络深度增大而增大
预测的条件分布始终相同，分布不一致造成预测误差

因此需要归一化操作，将每一层的输入都归一化成标准分布, 也就是在不改变分布形状的把方差和期望都标准化, 1 和. 0 。

计算方法

计算样本均值： $μ_{j} = \frac{1}{m} \sum_{i = 1}^{m} Z_{j}^{i}$

其中：
- $Z_{j}^{i}$ 是样本 i 在第 j 个维度上的值
- m 是 mini-batch 的大小
计算样本方差： $σ^{2} = \frac{1}{m} \sum_{i = 1}^{m} (Z_{j}^{i} - μ_{j})^{2}$
归一化变换： $\tilde{Z_{j}} = \frac{Z _{j} - μ _{j}}{σ ^{2} + ϵ}$

其中 $ϵ$ 是极小量，用于避免分母为0。

归一化的维度不同

假设我们有一个形状为 [batch_size=4, features=3] 的张量：

样本1: [1.0, 2.0, 3.0]
样本2: [4.0, 5.0, 6.0]  
样本3: [7.0, 8.0, 9.0]
样本4: [2.0, 3.0, 4.0]

Batch Norm 对每个特征维度，计算所有样本的均值和方差，在 Batch 维度上归一：

# 对第1个特征 [1.0, 4.0, 7.0, 2.0]
mean_feature1 = (1.0 + 4.0 + 7.0 + 2.0) / 4 = 3.5
var_feature1 = 计算这4个值的方差
 
# 对第2个特征 [2.0, 5.0, 8.0, 3.0]  
mean_feature2 = (2.0 + 5.0 + 8.0 + 3.0) / 4 = 4.5
var_feature2 = 计算这4个值的方差
 
# 对第3个特征 [3.0, 6.0, 9.0, 4.0]
mean_feature3 = (3.0 + 6.0 + 9.0 + 4.0) / 4 = 5.5
var_feature3 = 计算这4个值的方差

Layer Norm 对每个样本，计算所有特征的均值和方差：

# 对样本1 [1.0, 2.0, 3.0]
mean_sample1 = (1.0 + 2.0 + 3.0) / 3 = 2.0
var_sample1 = 计算这3个特征值的方差
 
# 对样本2 [4.0, 5.0, 6.0]
mean_sample2 = (4.0 + 5.0 + 6.0) / 3 = 5.0
var_sample2 = 计算这3个特征值的方差
 
# 对样本3 [7.0, 8.0, 9.0]
mean_sample3 = (7.0 + 8.0 + 9.0) / 3 = 8.0
var_sample3 = 计算这3个特征值的方差
 
# 对样本4 [2.0, 3.0, 4.0]
mean_sample4 = (2.0 + 3.0 + 4.0) / 3 = 3.0
var_sample4 = 计算这3个特征值的方差

graph TB
    subgraph "Batch Norm: 纵向归一化"
        A[样本1: 1,2,3] 
        B[样本2: 4,5,6]
        C[样本3: 7,8,9]
        D[样本4: 2,3,4]
        
        A --> E[特征1统计: 1,4,7,2]
        B --> E
        C --> E
        D --> E
        
        A --> F[特征2统计: 2,5,8,3]
        B --> F
        C --> F
        D --> F
        
        A --> G[特征3统计: 3,6,9,4]
        B --> G
        C --> G
        D --> G
    end
    
    subgraph "Layer Norm: 横向归一化"
        H[样本1: 1,2,3] --> I[样本1统计: 1,2,3]
        J[样本2: 4,5,6] --> K[样本2统计: 4,5,6]
        L[样本3: 7,8,9] --> M[样本3统计: 7,8,9]
        N[样本4: 2,3,4] --> O[样本4统计: 2,3,4]
    end

为什么 `Layer Norm` 更适合某些场景

Layer Norm: 每个样本独立归一化，不依赖其他的样本
需要整个 batch 的信息，再归一化

在序列模型中, 不同位置的特征含义不同, 跨多个样本去统计没有什么意义. 如下:

# 句子1: "我 爱 北京"     -> [emb1, emb2, emb3]
# 句子2: "今天 天气 很好"  -> [emb4, emb5, emb6] 
# 句子3: "机器 学习"      -> [emb7, emb8, 0]
 
# Batch Norm会计算位置1的统计: [emb1, emb4, emb7] - 没有语义意义
# Layer Norm计算每个句子内部的统计 - 更合理

mindmap
  root((Batch Norm 缺陷))
    小批次问题
      显存有限时mini-batch较小
      样本统计信息不能反映全局分布
      效果变差
    RNN适用性问题
      时间维度展开
      不同句子同一位置分布不同
      归一化失去意义
    测试阶段问题
      需要保存每个step的统计信息
      变长句子可能超出训练范围
      缺乏对应的统计量
    计算开销
      每个step都需要保存和计算batch统计量
      耗时又耗力

代码实现

import torch
import torch.nn as nn
 
# 输入: [batch_size=2, seq_len=3, hidden_dim=4]
x = torch.randn(2, 3, 4)
 
# Batch Norm: 在batch维度归一化
batch_norm = nn.BatchNorm1d(4)  # 对最后一个维度
# 需要reshape: [batch*seq, hidden] -> [6, 4]
x_bn = batch_norm(x.view(-1, 4)).view(2, 3, 4)
 
# Layer Norm: 在特征维度归一化  
layer_norm = nn.LayerNorm(4)    # 对最后一个维度
x_ln = layer_norm(x)  # 直接应用，每个样本独立归一化
 
print("原始形状:", x.shape)
print("Batch Norm后:", x_bn.shape) 
print("Layer Norm后:", x_ln.shape)

关键点：Layer Norm让每个样本的特征分布标准化，而不是让同一特征在不同样本间标准化。这在序列建模和小batch场景下更加稳定和有效。

个性化恢复

 
class LayerNorm(nn.Module):
 
    def __init__(self, features: int, eps=1e-6):
        """
        LayerNorm 类, 用于将输入的维度转换为隐藏维度, 再转换为输出维度
        """
        super(LayerNorm, self).__init__()
        self.a_2 = nn.Parameter(torch.ones(features))
        self.b_2 = nn.Parameter(torch.zeros(features))
        self.eps = eps
 
    def forward(self, x):
        # 在统计每个样本所有维度的值, 求均值和方差
        mean = x.mean(-1, keepdim=True)
        std = x.std(-1, keepdim=True)
 
        # 使用均值和方差来标准化输入
        # 在最后一个维度发生了广播
        return self.a_2 * (x - mean) / (std + self.eps) + self.b_2

graph TD
    A[标准化后<br/>均值=0, 方差=1] --> B[a_2 * x + b_2]
    
    C[a_2初始值=1] --> D[训练中学习]
    E[b_2初始值=0] --> D
    
    D --> F[a_2变化 → 调整方差]
    D --> G[b_2变化 → 调整均值]
    
    F --> H[重新分配特征重要性]
    G --> H
    
    H --> I[最终分布适应任务需求]

⁠torch.ones(features): 初始化a_2为1，表示初始时保持标准化的方差
⁠torch.zeros(features): 初始化b_2为0，表示初始时保持标准化的均值
训练过程中: 这些参数会根据任务需求自动调整
最终效果: 每个特征都找到最适合的均值和方差

3-残差连接

Transformer 模型的层数还是很深的，为了防止模型退化， Transformer 采用了残差连接的思想来连接每一个子层, 残差的思想就是下一层的输入不仅仅包含了上一层的输出，还包含了上一层的输入.

传统网络： $y = F (x)$

残差网络： $y = x + F (x)$

其中：

$x$ 是输入
$F (x)$ 是要学习的变换函数
$y$ 是输出

Encoder 中的残差

第一个子层（多头自注意力）： $SubLayer_{1} (x) = x + MultiHeadAttention (LayerNorm (x))$

第二个子层（前馈网络）： $SubLayer_{2} (h) = h + FFN (LayerNorm (h))$

其中 $h = SubLayer_{1} (x)$

完整的 encoder 块公式

🪴 Quartz 4.0

Explorer

11-transformer-arch-2

Seq2Seq

1-FFN

2-层归一化

计算方法

归一化的维度不同

为什么 `Layer Norm` 更适合某些场景

代码实现

个性化恢复

3-残差连接

Encoder 中的残差

Graph View

Table of Contents

Backlinks

🪴 Quartz 4.0

Explorer

11-transformer-arch-2

Seq2Seq

1-FFN

2-层归一化

计算方法

归一化的维度不同

为什么 Layer Norm 更适合某些场景

代码实现

个性化恢复

3-残差连接

Encoder 中的残差

Graph View

Table of Contents

Backlinks

为什么 `Layer Norm` 更适合某些场景