Transformer架构深度解析：现代AI的基石

平安的平安2026-02-12 9:52


✨"俺はモンキー・D・ルフィ。海贼王になる男だ！"

引言

2017年，Google团队发表了划时代论文《Attention Is All You Need》，提出了Transformer架构。这个架构彻底改变了自然语言处理领域，成为了ChatGPT、BERT等大模型的基础。

为什么需要Transformer？

在Transformer之前，RNN和LSTM是处理序列数据的主流模型，但它们存在两个主要问题：

问题 说明
顺序计算限制 无法并行处理，训练速度慢
长距离依赖 难以记住长序列中的早期信息

Transformer通过自注意力机制解决了这些问题。

整体架构

解码器
编码器
Self-Attention层
Feed Forward层
Masked Self-Attention
Cross-Attention
Feed Forward层
输入嵌入
输出嵌入
线性+Softmax

核心组件详解

1. 自注意力机制（Self-Attention）

自注意力是Transformer的核心，让模型能够关注序列中不同位置的关系。
输入向量 X
生成 Q, K, V
计算 Attention Score
缩放点积
Softmax归一化
加权求和

计算公式
复制代码 
Attention(Q, K, V) = softmax(QK^T / √d_k) × V
  • Q（Query）：查询向量，表示要找什么
  • K（Key）：键向量，表示被查询的内容
  • V（Value）：值向量，表示实际内容
代码实现
python 复制代码 
import torch
import torch.nn as nn
import torch.nn.functional as F

class SelfAttention(nn.Module):
    def __init__(self, embed_size, heads):
        super(SelfAttention, self).__init__()
        self.embed_size = embed_size
        self.heads = heads
        self.head_dim = embed_size // heads

        # 线性变换生成Q, K, V
        self.values = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.keys = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.queries = nn.Linear(self.head_dim, self.head_dim, bias=False)

        # 输出投影
        self.fc_out = nn.Linear(heads * self.head_dim, embed_size)

    def forward(self, values, keys, query, mask):
        N = query.shape[0]  # batch size
        value_len, key_len, query_len = values.shape[1], keys.shape[1], query.shape[1]

        # 分割成多个头
        values = values.reshape(N, value_len, self.heads, self.head_dim)
        keys = keys.reshape(N, key_len, self.heads, self.head_dim)
        queries = query.reshape(N, query_len, self.heads, self.head_dim)

        # 计算注意力分数
        energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])

        # 缩放
        energy = energy / (self.embed_size ** (1/2))

        # Mask（可选，用于解码器）
        if mask is not None:
            energy = energy.masked_fill(mask == 0, float("-1e20"))

        # Softmax
        attention = torch.softmax(energy, dim=3)

        # 加权求和
        out = torch.einsum("nhql,nlhd->nqhd", [attention, values])

        # 拼接所有头
        out = out.reshape(N, query_len, self.heads * self.head_dim)

        return self.fc_out(out)

2. 多头注意力（Multi-Head Attention）

多头注意力让模型从不同角度理解输入：
输入
头1: 关注语法
头2: 关注语义
头3: 关注上下文
头4: 关注情感
拼接
线性变换

python 复制代码 
class TransformerBlock(nn.Module):
    def __init__(self, embed_size, heads, dropout, forward_expansion):
        super(TransformerBlock, self).__init__()
        self.attention = SelfAttention(embed_size, heads)
        self.norm1 = nn.LayerNorm(embed_size)
        self.norm2 = nn.LayerNorm(embed_size)

        self.feed_forward = nn.Sequential(
            nn.Linear(embed_size, forward_expansion * embed_size),
            nn.ReLU(),
            nn.Linear(forward_expansion * embed_size, embed_size)
        )

        self.dropout = nn.Dropout(dropout)

    def forward(self, value, key, query, mask):
        # 多头注意力 + 残差连接
        attention = self.attention(value, key, query, mask)
        x = self.dropout(self.norm1(attention + query))

        # 前馈网络 + 残差连接
        forward = self.feed_forward(x)
        out = self.dropout(self.norm2(forward + x))
        return out

3. 位置编码（Positional Encoding）

由于注意力机制没有顺序概念，需要位置编码注入位置信息：

python 复制代码 
class PositionalEncoding(nn.Module):
    def __init__(self, embed_size, max_len=5000):
        super(PositionalEncoding, self).__init__()

        # 创建位置编码矩阵
        pe = torch.zeros(max_len, embed_size)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, embed_size, 2).float() *
                             (-math.log(10000.0) / embed_size))

        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0)

        # 注册为buffer（不是参数，但会保存到模型）
        self.register_buffer('pe', pe)

    def forward(self, x):
        # x shape: [batch_size, seq_len, embed_size]
        return x + self.pe[:, :x.size(1)]

完整Transformer实现

python 复制代码 
import math
import torch
import torch.nn as nn

class Transformer(nn.Module):
    def __init__(self, src_vocab_size, trg_vocab_size, embed_size=512,
                 num_layers=6, heads=8, forward_expansion=4, dropout=0.1):
        super(Transformer, self).__init__()

        # 词嵌入
        self.src_word_embedding = nn.Embedding(src_vocab_size, embed_size)
        self.trg_word_embedding = nn.Embedding(trg_vocab_size, embed_size)

        # 位置编码
        self.position_encoding = PositionalEncoding(embed_size)

        # 编码器层
        self.encoder = nn.ModuleList([
            TransformerBlock(embed_size, heads, dropout, forward_expansion)
            for _ in range(num_layers)
        ])

        # 解码器层
        self.decoder = nn.ModuleList([
            TransformerBlock(embed_size, heads, dropout, forward_expansion)
            for _ in range(num_layers)
        ])

        # 输出层
        self.fc_out = nn.Linear(embed_size, trg_vocab_size)
        self.dropout = nn.Dropout(dropout)

    def forward(self, src, trg, src_mask, trg_mask):
        # 嵌入 + 位置编码
        src_embed = self.dropout(self.position_encoding(self.src_word_embedding(src)))
        trg_embed = self.dropout(self.position_encoding(self.trg_word_embedding(trg)))

        # 编码器
        enc_output = src_embed
        for layer in self.encoder:
            enc_output = layer(enc_output, enc_output, enc_output, src_mask)

        # 解码器
        dec_output = trg_embed
        for layer in self.decoder:
            dec_output = layer(dec_output, enc_output, dec_output, trg_mask)

        # 输出预测
        out = self.fc_out(dec_output)
        return out

Transformer处理流程

输出概率 解码器×N层 编码器×N层 词嵌入+位置编码 输入序列 输出概率 解码器×N层 编码器×N层 词嵌入+位置编码 输入序列 Token IDs 添加位置信息 编码后的向量 多层注意力处理 编码器输出(作为K,V) 自注意力+交叉注意力 预测下一个词

实际应用示例：机器翻译

python 复制代码 
# 简化的翻译模型使用示例
def translate_sentence(model, sentence, src_vocab, trg_vocab, device, max_length=50):
    model.eval()

    # 分词并转换为索引
    tokens = [src_vocab.get(token, src_vocab['<unk>']) for token in sentence.split()]
    tokens = torch.LongTensor(tokens).unsqueeze(0).to(device)

    # 创建目标序列（从<sos>开始）
    trg_tensor = torch.LongTensor([[trg_vocab['<sos>']]]).to(device)

    with torch.no_grad():
        for _ in range(max_length):
            # 生成mask
            trg_mask = (trg_tensor != trg_vocab['<pad>']).unsqueeze(1)

            # 前向传播
            output = model(tokens, trg_tensor, src_mask=None, trg_mask=trg_mask)

            # 获取预测的下一个词
            pred_token = output.argmax(2)[:, -1].item()

            # 如果是结束符，停止
            if pred_token == trg_vocab['<eos>']:
                break

            # 添加到输出序列
            trg_tensor = torch.cat([trg_tensor,
                                   torch.LongTensor([[pred_token]]).to(device)], dim=1)

    return trg_tensor

Transformer家族

Transformer
编码器为主
BERT
RoBERTa
ALBERT
解码器为主
GPT系列
BLOOM
LLaMA
编解码器
原始Transformer
T5
BART

总结

Transformer的核心优势：

  1. 并行计算：所有位置同时处理，训练速度快
  2. 长距离依赖：注意力机制直接连接任意位置
  3. 可扩展性：通过增加heads和layers提升性能
  4. 通用性强：适用于NLP、CV、多模态等多种任务

进一步学习

  • BERT：双向编码器，适合理解任务
  • GPT：自回归解码器，适合生成任务
  • ViT：将Transformer应用于计算机视觉
  • Efficient Transformer：线性注意力等优化方法

参考资料：

相关推荐
九.九6 小时前
ops-transformer：AI 处理器上的高性能 Transformer 算子库
人工智能·深度学习·transformer
春日见6 小时前
拉取与合并：如何让个人分支既包含你昨天的修改，也包含 develop 最新更新
大数据·人工智能·深度学习·elasticsearch·搜索引擎
恋猫de小郭6 小时前
AI 在提高你工作效率的同时，也一直在增加你的疲惫和焦虑
前端·人工智能·ai编程
deephub7 小时前
Agent Lightning：微软开源的框架无关 Agent 训练方案，LangChain/AutoGen 都能用
人工智能·microsoft·langchain·大语言模型·agent·强化学习
偷吃的耗子7 小时前
【CNN算法理解】：三、AlexNet 训练模块(附代码)
深度学习·算法·cnn
大模型RAG和Agent技术实践7 小时前
从零构建本地AI合同审查系统：架构设计与流式交互实战（完整源代码）
人工智能·交互·智能合同审核
老邋遢7 小时前
第三章-AI知识扫盲看这一篇就够了
人工智能
互联网江湖7 小时前
Seedance2.0炸场：长短视频们“修坝”十年，不如AI放水一天？
人工智能
PythonPioneer7 小时前
在AI技术迅猛发展的今天，传统职业该如何“踏浪前行”？
人工智能
冬奇Lab8 小时前
一天一个开源项目（第20篇）：NanoBot - 轻量级AI Agent框架，极简高效的智能体构建工具
人工智能·开源·agent
热门推荐
01GitHub 镜像站点02Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services03openclaw配置教程（linux+局域网ollama）04UV安装并设置国内源05Linux下V2Ray安装配置指南06openclaw使用nginx反代部署过程 与disconnected (1008): pairing required解决07AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南08【Linux操作系统12】Git版本控制与GDB调试：从入门到实践09Vue-skills的中文文档10OpenClaw Chrome扩展使用教程 - 浏览器中继控制