🏠 返回首页

⚙️ AI 知识全景图

从 Token 编码到 Agent 工程化
面向 AI 开发者的系统性知识梳理
🔵 专业版 🟢 切换到大白话版

CH.01 文本表示与编码

一切 LLM 应用的起点:将人类语言映射到机器可计算的数学空间。

Token / subword tokenization

TokenBPE / WordPiece / SentencePiece

Token 是模型处理文本的最小单元。现代 LLM 使用子词分词算法(如 BPE),将文本拆分为子词单元。例如 "unhappiness" 可能被拆为 ["un", "happ", "iness"]。中文通常一个汉字对应 1-2 个 Token,英文一个单词约 1-1.5 个 Token。

vocab_size = |V| | sequence = [t1, t2, ..., tn] | ti in V

Embedding / token embedding

Embeddingnn.Embedding(vocab_size, d_model)

将离散的 Token ID 映射为 d_model 维连续向量。嵌入矩阵 W_emb in R^(|V| x d_model) 是可学习参数。语义相近的 Token 在向量空间中距离更近(由余弦相似度衡量),这是模型"理解"语义的数学基础。

# Token -> Embedding 全流程 from transformers import AutoTokenizer, AutoModel tokenizer = AutoTokenizer.from_pretrained("gpt2") model = AutoModel.from_pretrained("gpt2") text = "Hello, world!" tokens = tokenizer(text, return_tensors="pt") # tokens.input_ids: tensor([[15496, 11, 995, 0]]) embeddings = model.embed_tokens(tokens.input_ids) # embeddings.shape: [1, 4, 768] -- 4个token, 每个768维向量
数学表示

输入序列: X = [x1, x2, ..., xn],每个 xi 是 Token ID

嵌入后: E = W_emb[X],其中 E in R^(n x d_model)

位置编码: E_final = E + P(P 是位置编码矩阵,注入序列位置信息)

CH.02 Transformer 架构详解

Transformer 是几乎所有现代 LLM 的核心架构(GPT/DeepSeek/Llama/Qwen),由 Vaswani 等人在 2017 年提出。其核心创新是完全基于注意力机制,摒弃了 RNN 的序列依赖。

+---------------------------------------------+ | Transformer Block x N | | +---------------------------------------+ | | | 1. Multi-Head Self-Attention | | | | Q = X * Wq K = X * Wk V = X*Wv| | | | Attn = softmax(QK^T/d)*V | | | +------------------+--------------------+ | | +------------------v--------------------+ | | | 2. Add and LayerNorm | | | +------------------+--------------------+ | | +------------------v--------------------+ | | | 3. Feed-Forward Network | | | | FFN(x) = W2*ReLU(W1*x+b) | | | +------------------+--------------------+ | | +------------------v--------------------+ | | | 4. Add and LayerNorm | | | +---------------------------------------+ | +---------------------------------------------+

Self-Attention / scaled dot-product attention

Self-AttentionQ, K, V matrices

对输入序列的每个位置,计算它与其他所有位置的关联强度。Query (Q) 表示"我在找什么",Key (K) 表示"我有什么",Value (V) 是实际传递的信息。Attention 权重 = softmax(QK^T / sqrt(d_k)),决定了每个位置应该从其他位置"吸收"多少信息。

Attention(Q, K, V) = softmax( Q * K^T / sqrt(d_k) ) * V
多头注意力 (Multi-Head Attention)

将 Q/K/V 投影到 h 个不同的子空间,分别做 attention,再拼接:

MultiHead = Concat(head1, ..., headh) * W_O

headi = Attention(Q*Wi_Q, K*Wi_K, V*Wi_V)

多头让模型在不同表示子空间捕获不同模式(语法/语义/长距离依赖等)。

Feed-Forward Network / FFN

FFNtwo linear layers + activation

对每个位置独立施加两层线性变换+非线性激活。FFN 是模型存储"知识"的主要位置(研究显示事实知识主要编码在 FFN 权重中)。现代 LLM 常用 SwiGLU 替代 ReLU,效果更好。

FFN(x) = W2 * activation( W1 * x + b1 ) + b2
标准版用 ReLU;现代模型常用 SwiGLU: SwiGLU(x) = Swish(x*W1) * (x*W3) * W2

SoftMax / normalized exponential function

SoftMaxsoftmax(zi) = e^zi / Sum(e^zj)

将 logits(未归一化分数)转换为概率分布。在 Attention 中用于计算注意力权重,在输出层用于计算词表概率分布。注意 SoftMax 对输入做了指数归一化,大 logit 值会被放大,小值会被压制。

概念串联

Token -> Embedding 是文本到向量的映射;Self-Attention 让每个位置融合上下文信息;FFN 对融合后的表示做非线性变换提取特征;N 层堆叠形成深层理解;最终 SoftMax 将隐含表示映射到词表概率分布,实现"预测下一个 Token"。

CH.03 训练机制:从 Loss 到梯度更新

模型从随机初始化到具备能力,核心是"定义损失函数 -> 计算梯度 -> 更新参数"的循环。

参数量与可学习权重 / Parameters

参数量model.parameters()

模型所有可学习权重(矩阵、偏置、嵌入等)的总数。参数量决定了模型的容量上限。GPT-3: 175B, Llama-3-70B: 70B, DeepSeek-V3: 671B (MoE)。参数 = Attention 的 Wq/Wk/Wv/Wo + FFN 的 W1/W2 + Embedding + LayerNorm 等。

Loss 损失函数 / Cross-Entropy Loss

LossL = -Sum log P(yi | x<i)

LLM 训练的核心损失是自回归交叉熵损失:给定前 i 个 Token,预测第 i+1 个 Token 的负对数似然。Loss 越低,模型对下一个 Token 的预测越准确。

L = - (1/N) * Sum_i log P(ti | t1, t2, ..., t(i-1); theta)

反向传播 / Backpropagation

Backpropchain rule dL/dtheta

利用链式法则从 Loss 出发,反向逐层计算 Loss 对每个参数 theta 的偏导数 dL/dtheta。PyTorch 中通过 autograd 自动实现。反向传播的结果是梯度——指示每个参数应该朝哪个方向调整才能降低 Loss。

梯度下降 / Gradient Descent

GD / SGD / AdamWtheta <- theta - eta * grad(L)

根据梯度更新参数。实际训练使用 AdamW 优化器(结合动量+自适应学习率+权重衰减),而非朴素 SGD。大规模训练还使用 ZeRO/FSDP 进行分布式参数分片。

theta(t+1) = theta(t) - eta * gradL(theta(t))
AdamW: mt = b1*mt-1 + (1-b1)*gt; vt = b2*vt-1 + (1-b2)*gt^2; theta <- theta - eta*mt/(sqrt(vt)+eps) - eta*lambda*theta

学习率 / Learning Rate (eta)

Learning Ratetypically 1e-5 ~ 5e-4

控制每次参数更新的步长。LR 过大 -> Loss 震荡发散;LR 过小 -> 收敛极慢。实际训练使用学习率调度:先 warmup 线性增长,再 cosine 衰减。大模型训练的 LR 选择对训练稳定性至关重要。

训练循环(伪代码)
for batch in dataloader: input_ids, labels = batch logits = model(input_ids) # 前向传播 loss = cross_entropy(logits, labels) # 计算 Loss loss.backward() # 反向传播: 自动计算 dL/dtheta optimizer.step() # 梯度下降: theta <- theta - eta*gradL optimizer.zero_grad() # 清空梯度

CH.04 架构变体:Dense vs MoE vs RNN

RNN / Recurrent Neural Network

RNN / LSTM / GRUht = f(ht-1, xt)

Transformer 之前的主流序列模型。通过隐状态 ht 传递历史信息,但存在梯度消失/爆炸问题,难以建模长距离依赖。Transformer 通过 Self-Attention 的全局感受野彻底解决了这一问题,使并行训练成为可能。

RNN

序列计算,无法并行

O(n) 时间复杂度

长距离依赖差

梯度消失问题

Transformer

全局注意力,可并行

O(n^2) 时间复杂度

长距离依赖强

自注意力全局感受野

Dense vs MoE 架构

Denseall params active per token

标准 Transformer 中每个 Token 经过所有参数计算。参数量 = 计算量。优点是表达力强,缺点是参数增大时推理成本线性增长。代表:GPT-3 (175B), Llama-2-70B。

MoEMixture of Experts

将 FFN 替换为多个"专家"网络(Expert),由 Router(门控网络)为每个 Token 选择 Top-K 个专家。总参数量大但每次只激活一小部分,实现参数解耦。DeepSeek-V3: 671B 总参数,每 Token 仅激活 37B。

MoE FFN: y = Sum_i Gi(x) * Expert_i(x) Gi(x) = softmax(TopK(x * W_gate))
维度Dense (GPT-3)MoE (DeepSeek-V3)
总参数175B671B
每Token激活参数175B (全部)37B (~5.5%)
推理FLOPs低 (相对参数量)
训练效率线性增长参数与计算解耦
路由机制Gate网络 + Top-K + 负载均衡
概念串联

RNN -> Transformer 解决了长距离依赖和并行化问题;Dense -> MoE 解决了参数规模增长与计算成本的矛盾。两条进化线共同推动了大模型从"百亿"走向"千亿甚至万亿"参数规模。

CH.05 三阶段训练对齐

从 base model 到 chat model 需要三个阶段:预训练获得语言能力,SFT 学会指令遵循,RLHF 实现人类偏好对齐。

预训练 / Pre-training

Pre-trainingnext-token prediction on trillion tokens

在海量文本(Web/Wiki/Books/Code,数万亿 Token)上训练 next-token prediction。模型学习语言的统计规律和世界知识。预训练后的模型是 Base Model,能续写文本但不能遵循指令。

监督微调 / SFT

SFTinstruction -> response pairs

使用高质量的"指令-回答"对(通常数万~数十万条)微调模型,使其学会"被提问时给出有帮助的回答"。SFT 将 Base Model 转化为 Instruct/Chat Model。数据质量远比数量重要。

# SFT 训练数据格式 { "instruction": "用Python实现快速排序", "input": "", "output": "def quicksort(arr): ..." }

RLHF / Reinforcement Learning from Human Feedback

RLHFreward model + PPO / DPO

三步走:1) 训练 Reward Model(人类对多个回答排序 -> 训练打分模型);2) 用 RL 算法(PPO 或 DPO)优化 LLM 使其输出最大化 Reward。RLHF 让模型学习人类偏好:有用性、诚实性、无害性(HHH)。

Pre-training (万亿Token)->SFT (指令微调)->RLHF/DPO (偏好对齐)->Chat Model

涌现能力 / Emergent Abilities

Emergencephase transition at scale

当模型规模(参数量/训练数据/计算量)超过某个阈值,某些能力会从"几乎为零"突变到"显著水平"——如多步推理、少样本学习、代码生成等。这是规模定律 (Scaling Law) 的非线性体现。近期研究也表明某些"涌现"可能是评估指标的非线性造成的。

In-Context Learning / ICL

ICLfew-shot via prompt, no weight update

模型无需梯度更新,仅通过 Prompt 中提供的示例就能执行新任务。这是 LLM 的核心能力之一,与涌现能力密切相关。ICL 本质上是模型在预训练中学到了"元学习"能力——利用 Attention 机制从上下文中检索模式并应用。

CH.06 推理与生成机制

自回归 / Autoregressive Generation

AutoregressiveP(xt | x1,...,xt-1)

GPT 类模型采用自回归方式生成:每步根据已生成的全部 Token 预测下一个 Token 的概率分布,采样后追加到序列末尾,重复直到 EOS 或达到长度上限。每次前向传播的输出是词表大小的 logits -> SoftMax -> 概率分布。

# 自回归生成伪代码 generated = prompt_tokens while not eos and len(generated) < max_len: logits = model(generated) # [1, seq_len, vocab_size] next_logits = logits[:, -1, :] # 取最后一个位置 probs = softmax(next_logits / temperature) next_token = sample(probs, top_p=top_p) # 采样 generated.append(next_token)

上下文窗口 / Context Window

Context Windowmax_seq_len

模型一次能处理的最大 Token 数。Self-Attention 的 O(n^2) 计算复杂度使得窗口扩展困难。通过 RoPE 外推、Ring Attention、Flash Attention 等技术,窗口已从 GPT-2 的 1024 扩展到 Gemini 的 1M+。窗口大小直接影响 RAG 和 Agent 能塞入多少信息。

Temperature / temperature sampling

Temperature tauprobs = softmax(logits / tau)

tau->0 时退化为贪心解码(始终选最高概率词);tau=1 为原始分布;tau>1 拉平分布增加多样性。代码生成通常 tau=0~0.2,创意写作 tau=0.7~1.0。

Top-p / Nucleus Sampling

Top-pcumulative probability threshold

选择概率累积和达到 p 的最小 Token 集合,只在该集合内采样。p=0.9 表示只考虑概率前 90% 的 Token,过滤掉长尾噪声。与 Temperature 组合使用效果最佳。

流式输出 / Streaming Output

StreamingSSE / chunked transfer

利用自回归生成逐 Token 产出的特性,通过 Server-Sent Events (SSE) 或 WebSocket 逐 Token 推送给客户端,实现"打字机效果"。降低首 Token 延迟 (TTFT),改善用户体验。推理优化中常用 KV Cache 避免重复计算历史 Token。

KV Cache 加速

自回归生成时,已生成 Token 的 K/V 不变。缓存这些 K/V 矩阵,每步只需计算新 Token 的 Q/K/V,避免对全序列重算。代价是显存占用 O(n x d_model x n_layers x 2),长序列时需要 PagedAttention 等优化。

CH.07 幻觉与推理增强

幻觉 / Hallucination

Hallucinationfactually incorrect output

模型生成看似合理但事实上错误的内容。根本原因:LLM 学习的是 Token 的统计分布("什么词最可能跟在后面"),而非事实本身。常见类型:事实性幻觉(编造不存在的事实)、忠实性幻觉(与给定上下文矛盾)。这是 LLM 落地最大的可靠性挑战。

幻觉的根因

1. 训练数据中的噪声和过时信息;2. 自回归生成没有"不确定就拒绝"的机制;3. 模型的概率分布在知识边界外仍然平滑输出;4. RLHF 可能鼓励"看起来有帮助"而非"准确"的回答。

Prompt / Prompt Engineering

Promptinput context + instruction

控制模型行为的直接接口。Prompt 质量决定输出质量。关键技术:System Prompt 设定角色/约束;Few-shot 提供示例(利用 ICL);结构化 Prompt 明确输出格式。

思维链 / CoT (Chain of Thought)

CoT"Let's think step by step"

在 Prompt 中引导模型逐步推理,将复杂问题分解为中间步骤。CoT 让模型"展示工作过程",利用更多前向计算来处理复杂推理。Zero-shot CoT ("Let's think step by step") 和 Few-shot CoT(给出推理示例)均能显著提升推理任务表现。

# 普通 Prompt Q: 一个商店有 23 个苹果,卖了 17 个,又进了 12 个,还有几个? A: 18 # CoT Prompt Q: 一个商店有 23 个苹果,卖了 17 个,又进了 12 个,还有几个? A: 让我一步步算: 起始: 23 个苹果 卖了 17 个: 23 - 17 = 6 个 又进了 12 个: 6 + 12 = 18 个 答案: 18
减少幻觉的策略

1. CoT 推理:让模型分步推理,中间步骤可验证

2. RAG:提供权威参考材料,约束输出范围

3. 低 Temperature:减少随机采样,提高确定性

4. Self-Consistency:多次采样取多数投票

5. 明确约束:System Prompt 中要求"不确定时说明"

CH.08 RAG 检索增强生成

RAG (Retrieval-Augmented Generation) 通过外部知识库增强模型回答,是解决幻觉和知识时效性的主流方案。

用户提问->Query Embedding->向量检索 Top-K->Prompt 拼接->LLM 生成

Chunking / 文本分块

Chunkingrecursive / semantic / fixed-size

将长文档切分为适合检索和 LLM 上下文窗口的小块。策略包括:固定大小切分(如 512 Token + 50 重叠)、递归切分(按段落->句子->词层级)、语义切分(按内容相似度边界)。Chunk 大小直接影响检索精度和生成质量。

# Chunking 示例 from langchain.text_splitter import RecursiveCharacterTextSplitter splitter = RecursiveCharacterTextSplitter( chunk_size=512, # 每块最大 512 字符 chunk_overlap=50, # 块间重叠 50 字符 separators=["\n\n", "\n", ".", ",", " "] ) chunks = splitter.split_text(long_document) # 每个 chunk -> embedding -> 存入向量数据库

上下文管理 / Context Management

Context Mgmtwindow packing / compression / summarization

在有限的上下文窗口内最大化有效信息密度。策略包括:1) 检索结果重排 (Rerank),只保留最相关 Chunk;2) 历史对话压缩/摘要;3) 上下文窗口动态分配(System + Retrieved + History + Query 的 Token 预算管理)。目标是让模型在有限窗口内获得最优上下文。

概念串联

Chunking 决定了知识库的粒度 -> 检索精度取决于 Chunk 质量和 Embedding 模型 -> 检索结果通过上下文管理塞入上下文窗口 -> Prompt 将检索结果和用户问题组合 -> LLM 基于增强上下文生成回答,大幅减少幻觉

CH.09 Agent 与工具链

从 LLM(语言模型)到 Agent(智能体),核心是赋予模型感知环境、调用工具、自主规划的能力。

Function Call / 函数调用

Function Callstructured tool invocation

模型根据用户意图输出结构化的函数调用请求(函数名+参数 JSON),由外部代码执行后返回结果。OpenAI/Anthropic/DeepSeek 等均原生支持。模型被训练来识别"何时需要调用工具"和"如何构造参数"。

# Function Call 定义 tools = [{ "type": "function", "function": { "name": "get_weather", "description": "查询指定城市天气", "parameters": { "type": "object", "properties": { "city": {"type": "string", "description": "城市名"}, "unit": {"type": "string", "enum": ["C", "F"]} }, "required": ["city"] } } }] # 模型决定调用: get_weather(city="北京", unit="C") # 你的代码执行函数, 返回: {"temp": 28, "condition": "晴"} # 模型根据结果回答用户

MCP / Model Context Protocol

MCPopen standard for tool integration

Anthropic 发起的开放协议,标准化 LLM 与外部工具/数据源的交互接口。MCP 定义了 Server(提供能力)和 Client(LLM 侧)的通信规范,类似 LSP 之于编辑器。一次集成即可与所有支持 MCP 的 LLM 互操作,避免 vendor lock-in。

Skill / 技能包

Skillpackaged capability module

将特定领域能力封装为可插拔模块(含 Prompt 模板、工具定义、知识库、工作流)。LLM 按需加载 Skill 扩展能力。与 Function Call 的区别:Skill 是更粗粒度的能力封装(一个 Skill 可能包含多个 Function),强调场景化封装而非单点工具。

Agent / 智能体

Agentautonomous goal-directed system

以 LLM 为大脑,具备感知->规划->行动->观察循环的自主系统。核心模式:ReAct (Reasoning + Acting)——模型先推理下一步该做什么,执行工具,观察结果,再推理下一步。Agent 区别于单次 Function Call 的关键:自主多步决策和状态管理。

# ReAct Agent 循环 while not task_complete: thought = llm.reason(observations, goal) # 推理: "我需要先查..." action = llm.decide_action(thought, tools) # 决策: 调用哪个工具 observation = execute(action) # 执行工具, 获得结果 observations.append((thought, action, observation)) # 循环直到模型判断任务完成

LangChain / LLM 应用框架

LangChainLLM application framework

提供 LLM + Prompt + Memory + Tools + RAG + Chains 的组件化框架。核心抽象:Chain(将多个步骤串联)、Memory(对话历史管理)、Retriever(检索器)、Tool(工具封装)。适合中等复杂度的 LLM 应用快速开发。

LangGraph / Agent 工作流引擎

LangGraphstateful, cyclic agent graphs

LangChain 团队推出的 Agent 编排框架,以有向图建模 Agent 工作流。节点 = 状态转换函数(LLM 调用/工具执行/条件判断),边 = 状态流转。支持循环(ReAct 循环)、条件分支、多 Agent 协作、人在回路 (Human-in-the-loop)。解决 LangChain Chain 的线性局限。

LangGraph Agent 工作流示例: +----------+ | START | +----+-----+ v +----------+ +----------+ | Plan |---->| Execute | | (LLM) | | (Tools) | +----------+ +----+-----+ v +----------+ +----------| Observe | | +----------+ v +----------+ | Complete?|---No--> back to Plan +----+-----+ | Yes v +----------+ | END | +----------+
完整工具链串联

Function Call 是 LLM 调用工具的底层能力 -> MCP 将工具接口标准化 -> Skill 在工具之上封装场景化能力 -> LangChain 提供应用层组件 -> LangGraph 支持复杂 Agent 工作流编排 -> 最终构建出能自主规划、调用工具、多步执行的 Agent 系统。RAG 为 Agent 提供知识,CoT 为 Agent 提供推理能力。

CH.10 AI 编程范式

AI 辅助编程正在从"代码补全"进化为"AI 自主编码",形成了三种不同的范式。

Vibe Coding / 氛围编程

Vibe Codingnatural-language-first, intuition-driven

由 Andrej Karpathy 提出的概念。开发者用自然语言描述意图,AI 生成代码,开发者凭直觉和"氛围"判断是否满意,不深究实现细节。核心特征:弱规格、弱验证、重迭代。适合快速原型、一次性脚本、非关键路径工具。代表工具:Cursor、Claude Artifacts、v0.dev。

Spec-Coding / 规约编程

Spec-Codingspecification-driven, contract-first

先编写结构化的规格说明文档(Spec),定义接口契约、数据模型、业务规则、边界条件,再由 AI 根据规格生成代码。规格文档作为"单一事实来源"(SSOT),既是 AI 的输入也是验收标准。优势:可追溯、可验证、可维护。适合正式项目开发。核心思路:从需求文档 -> 设计文档 -> 代码的 AI 辅助流水线。

需求文档(Word/PRD)->Spec规格说明->AI生成代码->Harness自动验证->交付代码

Harness Engineering / 约束工程

Harness Engineeringguardrails, validation, CI for AI code

为 AI 生成代码构建的工程化约束框架,确保输出质量和安全。包含:1) 静态分析(类型检查/Lint/AST 验证);2) 自动化测试(单元/集成/E2E);3) 沙箱执行(隔离 AI 代码运行环境);4) 代码审查(AI 辅助 review + 人工 gate);5) 回滚机制。"Harness" 指赛马的缰绳——不让 AI 代码"脱缰"。

Vibe Coding

输入: 自然语言描述

规格: 无/弱

验证: 人工目测

控制: 低

适用: 原型/POC/实验

风险: 不可维护

Spec-Coding + Harness

输入: 结构化规格文档

规格: 严格 SSOT

验证: 自动测试套件

控制: 高

适用: 正式项目开发

风险: 前期投入大

实践建议

原型阶段:Vibe Coding 快速验证想法可行性

开发阶段:编写详细 Spec -> AI 生成 -> Harness 自动验证

生产阶段:Spec-Coding 为主,Vibe Coding 辅助探索性任务

三者不是互斥关系,而是同一项目中不同阶段的工具选择。关键是在 Harness Engineering 的框架下,确保 AI 代码始终在可控、可验证的轨道上运行。

全景总结

从底层到应用,AI 技术栈的完整链路:

Token -> Embedding -> Transformer (Self-Attention + FFN + SoftMax) 构成模型基础 -> 预训练 + SFT + RLHF 训练出 Chat 模型 -> 通过 Prompt + CoT + Temperature/Top-p 控制推理生成 -> RAG + Chunking + 上下文管理 增强知识与时效性 -> Function Call + MCP + Skill 扩展工具能力 -> LangChain + LangGraph 构建 Agent 系统 -> 最终在 Vibe Coding / Spec-Coding / Harness Engineering 范式下实现 AI 辅助开发闭环。