大模型 LLM 全栈技术深度解析：从 Transformer 底层原理到 RAG 与 Agent 系统架构

从175B参数的GPT-3到DeepSeek-R1，大模型技术在过去三年经历了从"规模竞赛"到"效率革命"的范式转变。2026年，大模型开发不再只是少数AI实验室的专属领域——开源模型的成熟、推理框架的优化、以及工程化工具链的完善，使得中小团队也能构建生产级LLM应用。本文将系统性地拆解大模型全栈技术的核心组件，从底层架构到上层应用，为开发者提供一幅完整的技术地图。

---

一、LLM核心架构：从Standard Transformer到Decoder-Only

1.1 Transformer的原始设计

2017年，Vaswani等人在《Attention Is All You Need》中提出的Transformer架构包含完整的Encoder-Decoder结构。Encoder负责理解输入序列，Decoder负责生成输出序列。这种设计在机器翻译等seq2seq任务中表现出色。

但GPT系列模型的成功揭示了一个关键洞察：对于自回归语言建模（预测下一个token），Decoder-Only架构不仅更简单，而且更高效。

1.2 Decoder-Only架构的优势

Decoder-Only架构的核心组件：

输入文本
    │
    ▼
Token Embedding + Positional Encoding
    │
    ▼
┌─────────────────────────────┐
│  Masked Multi-Head Self-Attention  │
│  Layer Normalization              │
│  Feed Forward Network (SwiGLU)    │
│  Layer Normalization              │
└─────────────────────────────┘
    │ (重复N层)
    ▼
LM Head (线性投影到词表大小)
    │
    ▼
Softmax → 下一个token的概率分布

Decoder-Only架构的关键设计：

Causal Masking：在自注意力计算中，每个位置只能看到它之前的位置。这确保了模型在生成时不会"偷看未来"。

# Causal Mask的实现
def create_causal_mask(seq_len):
    mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1)
    mask = mask.masked_fill(mask == 1, float('-inf'))
    return mask

# 示例：seq_len=4
# [[0, -inf, -inf, -inf],
#  [0,   0, -inf, -inf],
#  [0,   0,   0, -inf],
#  [0,   0,   0,   0]]

1.3 注意力机制的演进

MHA（Multi-Head Attention）

标准的多头注意力将Q、K、V分别投影到多个子空间，在每个子空间中独立计算注意力，最后拼接结果。这增加了模型的表达能力，但计算和内存开销较大。

MQA（Multi-Query Attention）

多查询注意力让所有头共享K和V，只有Q是独立的。这大幅减少了KV缓存的大小，但可能损失一些表达能力。PaLM等模型使用了这个设计。

GQA（Grouped-Query Attention）

分组查询注意力是MHA和MQA的折中方案：将头分成若干组，每组内共享K和V。Llama 2和Llama 3都采用了GQA（8组），在效率和表达能力之间取得了良好平衡。

# GQA的简化实现
class GroupedQueryAttention(nn.Module):
    def __init__(self, d_model, num_heads, num_kv_groups):
        self.num_heads = num_heads
        self.num_kv_groups = num_kv_groups
        self.heads_per_group = num_heads // num_kv_groups
        
        self.q_proj = nn.Linear(d_model, d_model)
        self.k_proj = nn.Linear(d_model, d_model // self.heads_per_group)
        self.v_proj = nn.Linear(d_model, d_model // self.heads_per_group)
    
    def forward(self, x):
        # Q: 每个头独立
        q = self.q_proj(x).view(batch, seq_len, self.num_heads, head_dim)
        # K, V: 每组共享
        k = self.k_proj(x).view(batch, seq_len, self.num_kv_groups, head_dim)
        v = self.v_proj(x).view(batch, seq_len, self.num_kv_groups, head_dim)
        # 扩展K, V到每个头
        k = k.repeat_interleave(self.heads_per_group, dim=2)
        v = v.repeat_interleave(self.heads_per_group, dim=2)
        # 标准scaled dot-product attention
        # ...

1.4 RoPE位置编码

RoPE（Rotary Position Embedding）已成为2024-2026年主流LLM的标准位置编码方案。它的核心思想是通过旋转矩阵将位置信息编码到注意力计算中：

def apply_rotary_emb(x, cos, sin):
    """x: (batch, seq_len, num_heads, head_dim)"""
    # 将x分成两半，分别旋转
    x_rot = x[..., :head_dim//2]
    x_pass = x[..., head_dim//2:]
    
    x_rot_new = x_rot * cos - x_pass * sin
    x_pass_new = x_pass * cos + x_rot * sin
    
    return torch.cat([x_rot_new, x_pass_new], dim=-1)

RoPE的优势在于：

• 自然地处理任意长度序列（通过外推）
• 相对位置编码天然支持，无需额外计算
• 与线性注意力机制兼容

1.5 SwiGLU激活函数

SwiGLU已成为现代LLM的标准FFN激活函数，替代了传统的ReLU/GELU：

class SwiGLU(nn.Module):
    def __init__(self, d_model, d_ff):
        self.w1 = nn.Linear(d_model, d_ff, bias=False)
        self.w2 = nn.Linear(d_model, d_ff, bias=False)
        self.w3 = nn.Linear(d_ff, d_model, bias=False)
    
    def forward(self, x):
        # SwiGLU(x) = SiLU(xW1) ⊙ (xW2)
        return self.w3(F.silu(self.w1(x)) * self.w2(x))

二、大模型三阶段训练范式

2.1 预训练阶段

预训练是LLM能力的基石。模型在海量文本数据上学习语言的基本模式和知识。

数据工程是预训练中最关键也最被低估的环节：

• 数据收集：Common Crawl、书籍、代码仓库、学术论文
• 数据清洗：去重、质量过滤、个人身份信息移除
• 数据配比：不同来源数据的比例直接影响模型能力
• 数据编排：训练数据的顺序影响学习效率

训练目标：Causal Language Modeling（因果语言建模）

# CLM的损失计算
def clm_loss(logits, labels):
    # logits: (batch, seq_len, vocab_size)
    # labels: (batch, seq_len)
    shift_logits = logits[..., :-1, :].contiguous()
    shift_labels = labels[..., 1:].contiguous()
    loss = F.cross_entropy(
        shift_logits.view(-1, shift_logits.size(-1)),
        shift_labels.view(-1),
        ignore_index=-100  # 忽略padding位置
    )
    return loss

2.2 分布式训练技术栈

训练千亿参数模型需要分布式训练技术：

3D并行：

• 数据并行（DP）：每个GPU持有完整模型副本，处理不同数据批次
• 张量并行（TP）：将单个层的参数切分到多个GPU
• 流水线并行（PP）：将不同层分配到不同GPU，形成流水线

ZeRO优化器：Deepspeed的ZeRO将优化器状态、梯度和参数分片到多个GPU，显著降低单GPU内存需求：

• ZeRO-1：分片优化器状态（8x内存节省）
• ZeRO-2：分片优化器状态+梯度（8x内存节省）
• ZeRO-3：分片优化器状态+梯度+参数（与GPU数量线性扩展）

2.3 监督微调（SFT）

预训练模型虽然知识丰富，但不擅长遵循指令。SFT通过在高质量指令-回答对上进行微调，使模型学会遵循人类意图。

参数高效微调（PEFT）：对于资源有限的团队，LoRA是最常用的PEFT方法：

class LoRALayer(nn.Module):
    def __init__(self, in_dim, out_dim, rank=8, alpha=16):
        self.lora_A = nn.Parameter(torch.randn(in_dim, rank) * 0.01)
        self.lora_B = nn.Parameter(torch.zeros(rank, out_dim))
        self.scaling = alpha / rank
    
    def forward(self, x):
        # 原始权重 + LoRA增量
        return F.linear(x, self.weight) + (x @ self.lora_A @ self.lora_B) * self.scaling

2.4 偏好对齐

RLHF（Reinforcement Learning from Human Feedback）和DPO（Direct Preference Optimization）是两种主流的对齐方法。

DPO的优势在于它不需要单独训练奖励模型，直接在偏好数据上优化：

def dpo_loss(pi_logps, ref_logps, yw_idxs, yl_idxs, beta=0.1):
    """
    pi_logps: 当前模型的log概率
    ref_logps: 参考模型的log概率
    yw_idxs: 偏好回答的索引
    yl_idxs: 非偏好回答的索引
    """
    pi_yw = pi_logps[yw_idxs]
    pi_yl = pi_logps[yl_idxs]
    ref_yw = ref_logps[yw_idxs]
    ref_yl = ref_logps[yl_idxs]
    
    pi_logratios = pi_yw - pi_yl
    ref_logratios = ref_yw - ref_yl
    
    loss = -F.logsigmoid(beta * (pi_logratios - ref_logratios))
    return loss

三、推理加速与生产级RAG

3.1 KV Cache与PagedAttention

KV Cache是LLM推理优化的核心。在自回归生成中，每生成一个新token都需要重新计算所有历史token的K和V。KV Cache缓存这些中间结果，避免重复计算。

PagedAttention（vLLM的核心技术）将KV Cache组织为"页"，类似于操作系统的虚拟内存管理：

# PagedAttention的简化概念
class PagedAttention:
    def __init__(self, block_size=16):
        self.block_size = block_size
        self.kv_blocks = {}  # 页表
    
    def store(self, request_id, token_idx, k, v):
        block_idx = token_idx // self.block_size
        offset = token_idx % self.block_size
        if block_idx not in self.kv_blocks[request_id]:
            self.kv_blocks[request_id][block_idx] = self.allocate_block()
        self.kv_blocks[request_id][block_idx][offset] = (k, v)
    
    def retrieve(self, request_id, seq_len):
        # 从页表中检索KV Cache
        blocks = [self.kv_blocks[request_id][i] for i in range(seq_len // self.block_size + 1)]
        return self.assemble(blocks, seq_len)

3.2 RAG架构设计

RAG（Retrieval-Augmented Generation）是当前最实用的LLM应用模式。一个生产级RAG系统包含以下组件：

用户查询
    │
    ▼
查询重写（Query Rewriting）── 优化查询表达
    │
    ├── 密集检索（Dense Retrieval）── 向量相似度
    └── 稀疏检索（Sparse Retrieval）── BM25/关键词
    │
    ▼
混合排序（Hybrid Search + Re-rank）
    │
    ▼
上下文构建（Context Assembly）
    │
    ▼
LLM生成（带检索上下文的Prompt）
    │
    ▼
回答验证（Citation/事实核查）
    │
    ▼
最终回答

**HyDE（Hypothetical Document Embeddings）**是一个实用的检索增强技术：

def hyde_retrieval(query, llm, vector_store):
    # 1. 让LLM生成一个假设的答案文档
    hypothetical_doc = llm.generate(
        f"Write a passage that answers the question: {query}"
    )
    # 2. 用假设文档的向量去检索（而不是直接用查询向量）
    hypo_embedding = embed(hypothetical_doc)
    results = vector_store.search(hypo_embedding, top_k=10)
    return results

四、AI Agent系统设计

4.1 ReAct范式

ReAct（Reasoning + Acting）是当前Agent系统的基础范式：

class ReActAgent:
    def __init__(self, llm, tools):
        self.llm = llm
        self.tools = {t.name: t for t in tools}
    
    def run(self, task):
        messages = [{"role": "system", "content": self.get_system_prompt()}]
        messages.append({"role": "user", "content": task})
        
        for _ in range(MAX_ITERATIONS):
            response = self.llm.chat(messages)
            
            # 解析action
            action = self.parse_action(response)
            if action["type"] == "final_answer":
                return action["content"]
            
            # 执行工具调用
            tool = self.tools[action["tool"]]
            result = tool.execute(action["input"])
            
            # 将观察结果加入对话
            messages.append({"role": "assistant", "content": response})
            messages.append({"role": "user", "content": f"Observation: {result}"})
        
        raise Exception("Agent exceeded maximum iterations")

4.2 多智能体协同

对于复杂任务，单Agent往往力不从心。多Agent架构通过分工协作来解决这个问题：

协调器-工作者模式：一个协调器Agent负责分解任务和分配工作，多个工作者Agent负责执行具体子任务。

Router模式：根据用户输入的类型，路由到不同的专业Agent。

class MultiAgentSystem:
    def __init__(self):
        self.router = RouterAgent()
        self.agents = {
            "code": CodeAgent(),
            "data": DataAnalysisAgent(),
            "writing": WritingAgent(),
        }
    
    def run(self, user_input):
        # 路由到合适的Agent
        agent_type = self.router.classify(user_input)
        agent = self.agents[agent_type]
        return agent.execute(user_input)

五、总结

大模型全栈技术是一个快速演进的领域。从底层架构的GQA/RoPE/SwiGLU，到训练范式的预训练/SFT/DPO，再到推理优化和RAG/Agent系统，每个层面都在持续创新。对于开发者而言，理解这些技术的"为什么"比"是什么"更重要——理解设计决策背后的权衡，才能在具体的业务场景中做出正确的技术选择。2026年，大模型技术正在从"研究驱动"转向"工程驱动"，掌握全栈能力将成为AI工程师的核心竞争力。