Part8.第15章：Transformer

第15章：Transformer

动机与影响

Transformer与全连接前馈网络（FFN）、卷积神经网络（CNN）、循环神经网络（RNN）并称为深度学习的四大核心架构。
序列建模的挑战

Transformer的突破性贡献

注意力机制

在Transformer里，计算Q和K是直接计算Q和K的点乘。当然，计算点乘的前提是Q和K的维度是一致的。一个Q和一组K分别计算点乘，得到一组logits值，再通过softmax，就得到注意力权重。

1.自注意力机制

2.多头自注意力

3.矩阵运算加速

以一个头的注意力机制为例，也就是q、k、v向量的维度和embedding向量的维度都一样，为hidden_size。
我们将序列内所有token产生的q向量合并到一起，形成一个Q矩阵，形状为[seq_len,hidden_size]。将所有的k向量合并到一起，形成一个K矩阵，形状为[seq_len,hidden_size]。
同理生成V矩阵，形状也为[seq_len,hidden_size]。此时，将Q乘以K的转置相乘：$Q{K}^T$，得到结果形状为[seq_len,seq_len]。然后按行应用softmax就得到了注意力权重矩阵。



比如上边就是4个token的Q，K，V矩阵，token的hidden_size为6，分了3个头，每个头的q,k,v向量维度为2。整个序列的4个token进行多头注意计算时就是Head1、Head2、Head3的Q,K,V矩阵分别进行计算，分别得到结果矩阵，再将结果矩阵进行拼接，就得到4个token更新后的Embedding。

一个完整的注意力机制计算后还会通过一个全连接层来整理token的embedding。这个全连接层不会改变token embedding的维度。

4.Pytorch实现代码

class MultiHeadAttentionBlock(nn.Module):

    def __init__(self, d_model: int, h: int, dropout: float) -> None:
        super().__init__()
        self.d_model = d_model  # embedding特征大小
        self.h = h  # 头的个数
        assert d_model % h == 0, "d_model 不能被 h整除" # 确保d_model可以被h整除，多头分割的必要条件

        self.d_k = d_model // h  # 每个头特征大小
        self.w_q = nn.Linear(d_model, d_model, bias=False)  # Wq，Q矩阵的线性变换层（无偏置）
        self.w_k = nn.Linear(d_model, d_model, bias=False)  # Wk，类似Wq
        self.w_v = nn.Linear(d_model, d_model, bias=False)  # Wv，类似Wq
        self.w_o = nn.Linear(d_model, d_model, bias=False)  # Wo，输出投影层（合并多头结果）
        self.dropout = nn.Dropout(dropout)

    @staticmethod
    def attention(query, key, value, mask, dropout: nn.Dropout):
        # 获取d_k的值。
        d_k = query.shape[-1]
        # Q乘以K的转置，除以根号下d_k。
        # (batch, h, seq_len, d_k) --> (batch, h, seq_len, seq_len)
        attention_scores = (query @ key.transpose(-2, -1)) / math.sqrt(d_k)
        if mask is not None:
            # 给mask为0的位置填入一个很大的负值，这样在进行softmax，注意力就为0。
            attention_scores.masked_fill_(mask == 0, -1e9)
        # 进行softmax，归一化。得到注意力权重
        # (batch, h, seq_len, seq_len)
        attention_scores = attention_scores.softmax(dim=-1)
        if dropout is not None:
            attention_scores = dropout(attention_scores)
        # 注意力权重乘以V，得到更新后的embedding。
        # (batch, h, seq_len, seq_len) --> (batch, h, seq_len, d_k)
        return (attention_scores @ value), attention_scores

    def forward(self, q, k, v, mask):
        # 通过3个全连接层，获取Q、K、V矩阵
        query = self.w_q(q)  # (batch, seq_len, d_model) --> (batch, seq_len, d_model)
        key = self.w_k(k)  # (batch, seq_len, d_model) --> (batch, seq_len, d_model)
        value = self.w_v(v)  # (batch, seq_len, d_model) --> (batch, seq_len, d_model)

        # 对多头进行拆分
        # (batch, seq_len, d_model) --> (batch, seq_len, h, d_k) --> (batch, h, seq_len, d_k)
        query = query.view(query.shape[0], query.shape[1], self.h, self.d_k).transpose(1, 2)
        key = key.view(key.shape[0], key.shape[1], self.h, self.d_k).transpose(1, 2)
        value = value.view(value.shape[0], value.shape[1], self.h, self.d_k).transpose(1, 2)

        # 计算注意力
        x, self.attention_scores = MultiHeadAttentionBlock.attention(query, key, value, mask, self.dropout)

        # 多个头合并
        # (batch, h, seq_len, d_k) --> (batch, seq_len, h, d_k) --> (batch, seq_len, d_model)
        x = x.transpose(1, 2).contiguous().view(x.shape[0], -1, self.h * self.d_k)

        # 乘以输出层
        return self.w_o(x)

forward函数传入的q,k,v是尚未经过全连接层的原始向量，在self-attention里，这里的q,k,v都是token的embedding。并且这里的embedding的形状为（batch,seq_len,d_model)。可见Transformer里的tensor将batch size放在第一个维度，因为Transformer里可以同时对所有token进行处理，并不需要按照序列顺序依次处理。
Attention计算时，可以传入一个mask矩阵，mask矩阵用0标记了哪些位置不参与注意力计算。比如对于$<pad>$ token就不必参与注意力计算。对于mask标记了0的位置，在注意力logits值计算完成后，给赋值一个很大的负值，这样在进行softmax后，对于这个位置的注意力就为0。相当于不参加注意力计算。
关于代码的几个问题：
【1】Q矩阵的线性变换层（无偏置）为啥无偏置？
1.1.参数效率与过拟合风险控制
每个注意力头独立拥有d_model维的线性变换层（Q/K/V各一层）。若启用偏置，每个头需额外存储3个长度为d_model的偏置向量，总参数增加3×h×d_model（h为头数）；
1.2.数学性质保持
注意力计算的核心是$Q\cdot K^T$ 的缩放点积。偏置项会引入额外的常数偏移，可能破坏点积的对称性或数值稳定性。例如，若Q的变换层包含偏置$b_q$，则实际计算变为$(Q\cdot W_q+b_q)\cdot K^T$，等价于$Q\cdot (W_q\cdot K^T)+b_q\cdot K^T$。后一项$b_q\cdot K^T$是全局偏移，可能干扰注意力权重的分布，尤其在序列较长时累加效应明显；
1.3.表达冗余性消除
在深度学习中，层归一化（LayerNorm）和残差连接已能处理输入分布的偏移。若线性层再引入偏置，可能造成双重偏移补偿，导致表达冗余；
1.4.工程实践验证
原始论文《Attention Is All You Need》通过消融实验发现，无偏置设计在机器翻译、文本建模等任务上性能与含偏置版本相当，甚至略优。
【2】attention_scores = (query @ key.transpose(-2, -1)) / math.sqrt(d_k)，语法解释？
2.1.矩阵乘法运算符 @
在Python的NumPy/PyTorch库中，@是矩阵乘法（Matmul） 的专用运算符，等价于 torch.matmul() 或 torch.einsum() 的高效实现。
2.2.维度交换方法 transpose(-2, -1)
参数含义：-2 和 -1 是 张量的最后两个维度索引（PyTorch采用负数索引从后往前计数）。
操作效果：交换张量最后两个维度的位置。
示例：若原始 key 形状为 (batch_size, h, seq_len, d_k)，则 key.transpose(-2, -1) 变为 (batch_size, h, d_k, seq_len)。
2.3.缩放因子 math.sqrt(d_k)。数学动机：防止点积结果过大导致softmax梯度消失。
【3】attention_scores.masked_fill_(mask == 0, -1e9)，这句代码含义？

【4】query = self.w_q(q) # (batch, seq_len, d_model) --> (batch, seq_len, d_model)，代码含义？
多头注意力机制的核心初始化步骤，通过三个独立的线性全连接层将输入序列投影到查询（Q）、键（K）、值（V）三个不同的表示子空间。
线性变换

query = self.w_q(q)  # 等价于 q @ W_q^T + b_q（但b_q=0）

通过三个独立的全连接层，将相同的输入序列映射到三个不同的表示空间
Q（查询）：捕捉“需要关注什么信息”的意图向量
K（键）：存储“可被关注的信息”的索引向量
V（值）：承载“实际信息内容”的载体向量
这种分离使模型能同时学习“如何提问”（Q）、“如何响应”（K）、“如何提取信息”（V）三种能力。
【5】 query = query.view(query.shape[0], query.shape[1], self.h, self.d_k).transpose(1, 2)，代码含义？
多头拆分是多头注意力机制的核心步骤，通过维度重组将输入特征分割为多个并行的注意力头，使每个头能独立学习不同子空间的特征表示？
a.特征空间分割：将高维特征分解为多个低维子空间
b.计算效率优化：通过批量矩阵运算提升GPU利用率
c.表达容量扩展：通过并行子空间学习增强模型特征提取能力

【6】x = x.transpose(1, 2).contiguous().view(x.shape[0], -1, self.h * self.d_k)，这句代码详细解释？
transpose(1, 2)：交换张量的第1和第2维度（索引从0开始）
contiguous()：确保张量在内存中连续存储（解决transpose导致的非连续问题）
view(…)：重塑张量形状（等价于reshape，但要求张量连续）

层归一化

LN的Pytorch实现

class LayerNormalization(nn.Module):

    def __init__(self, features: int, eps: float = 10 ** -6) -> None:
        super().__init__()
        self.eps = eps # 数值稳定性常数
        # 可学习权重
        self.alpha = nn.Parameter(torch.ones(features))  # 缩放参数，初始化为1
        # 可学习偏差
        self.bias = nn.Parameter(torch.zeros(features))  # 偏移参数，初始化为0

    def forward(self, x):
        # x: (batch, seq_len, hidden_size)
        # 保留维度来进行广播
        mean = x.mean(dim=-1, keepdim=True)  # 计算均值：沿隐藏层维度（最后一维）求均值，保持维度为(batch, seq_len, 1)
        std = x.std(dim=-1, keepdim=True)  # 计算标准差：沿隐藏层维度求标准差，保持维度(batch, seq_len, 1)
        # eps 是为了防止除0设置的很小的值
        return self.alpha * (x - mean) / (std + self.eps) + self.bias

BN是在不同样本的同一个维度做归一, 因为样本的个数会发生变化就不太稳定;LN是在同一个样本的不同维度做归一, 这样就可以保证稳定性。
在推理阶段，层归一化（Layer Normalization）中的可学习参数 α（缩放） 和 β（偏移） 的值是直接使用训练过程中优化得到的固定值，无需重新计算或调整。

举个例子：

位置编码

给token加入位置信息。


pytorch实现位置编码

class PositionalEncoding(nn.Module):

    def __init__(self, d_model: int, seq_len: int, dropout: float) -> None:
        super().__init__()
        self.d_model = d_model
        self.seq_len = seq_len
        self.dropout = nn.Dropout(dropout)
        # 创建一个空的tensor
        pe = torch.zeros(seq_len, d_model)  # (seq_len, d_model)
        # 创建一个位置向量
        position = torch.arange(0, seq_len, dtype=torch.float).unsqueeze(1)  
        # 计算分母
        div_term = torch.pow(10000.0, -torch.arange(0, d_model, 2, dtype=torch.float) / d_model)  # (d_model / 2)
        # 偶数位调用sin
        pe[:, 0::2] = torch.sin(position * div_term) 
        # 奇数为调用cos
        pe[:, 1::2] = torch.cos(position * div_term) 
        # 增加batch维度
        pe = pe.unsqueeze(0)  # (1, seq_len, d_model)
        # 注册位置编码为一个buffer，这个tensor不会参与训练，但是会随同模型一起被保存或者迁移到GPU。
        self.register_buffer('pe', pe)

    def forward(self, x):
        x = x + (self.pe[:, :x.shape[1], :]).requires_grad_(False) 
        return self.dropout(x)

把这一切组装起来 TODO