大模型 LLM 全栈技术深度解析：从 Transformer 底层原理到 RAG 与 Agent 系统架构-三亩地-编程学习日记

大模型 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的实现defcreate_causal_mask(seq_len):mask=torch.triu(torch.ones(seq_len,seq_len),diagonal=1)mask=mask.masked_fill(mask==1,float('-inf'))returnmask# 示例：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的简化实现classGroupedQueryAttention(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)defforward(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的标准位置编码方案。它的核心思想是通过旋转矩阵将位置信息编码到注意力计算中：

defapply_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*sinreturntorch.cat([x_rot_new,x_pass_new],dim=-1)

RoPE的优势在于：

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

1.5 SwiGLU激活函数

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

classSwiGLU(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)defforward(self,x):# SwiGLU(x) = SiLU(xW1) ⊙ (xW2)returnself.w3(F.silu(self.w1(x))*self.w2(x))

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

2.1 预训练阶段

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

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

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

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

# CLM的损失计算defclm_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位置)returnloss

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方法：

classLoRALayer(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/rankdefforward(self,x):# 原始权重 + LoRA增量returnF.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的优势在于它不需要单独训练奖励模型，直接在偏好数据上优化：

defdpo_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))returnloss

三、推理加速与生产级RAG

3.1 KV Cache与PagedAttention

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

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

# PagedAttention的简化概念classPagedAttention:def__init__(self,block_size=16):self.block_size=block_size self.kv_blocks={}# 页表defstore(self,request_id,token_idx,k,v):block_idx=token_idx//self.block_size offset=token_idx%self.block_sizeifblock_idxnotinself.kv_blocks[request_id]:self.kv_blocks[request_id][block_idx]=self.allocate_block()self.kv_blocks[request_id][block_idx][offset]=(k,v)defretrieve(self,request_id,seq_len):# 从页表中检索KV Cacheblocks=[self.kv_blocks[request_id][i]foriinrange(seq_len//self.block_size+1)]returnself.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）**是一个实用的检索增强技术：

defhyde_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)returnresults

四、AI Agent系统设计

4.1 ReAct范式

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

classReActAgent:def__init__(self,llm,tools):self.llm=llm self.tools={t.name:tfortintools}defrun(self,task):messages=[{"role":"system","content":self.get_system_prompt()}]messages.append({"role":"user","content":task})for_inrange(MAX_ITERATIONS):response=self.llm.chat(messages)# 解析actionaction=self.parse_action(response)ifaction["type"]=="final_answer":returnaction["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}"})raiseException("Agent exceeded maximum iterations")

4.2 多智能体协同

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

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

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

classMultiAgentSystem:def__init__(self):self.router=RouterAgent()self.agents={"code":CodeAgent(),"data":DataAnalysisAgent(),"writing":WritingAgent(),}defrun(self,user_input):# 路由到合适的Agentagent_type=self.router.classify(user_input)agent=self.agents[agent_type]returnagent.execute(user_input)

五、总结

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

日记详情

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