大语言模型原理硬核拆解:从下一个词预测到注意力机制

简介: 本文从大语言模型(LLM)本质——自回归概率建模出发,系统拆解其目标函数(Next-Token Prediction)、Tokenizer(BPE)、核心架构(Transformer+RoPE+FFN)、训练流程(Pretrain→SFT→DPO)及推理工程(KV Cache、解码策略),辅以精炼可运行代码,讲清LLM第一性原理。

大语言模型(LLM)的本质是一个自回归的概率语言模型:给定 Token 序列,输出词表上的条件概率分布。本文从这个定义出发,拆解它的目标函数、架构、训练流程和推理工程,全文配可运行的代码。

一、目标函数:一切始于 Next-Token Prediction

设词表大小为 $|V|$,Token 序列为 $x_{1:t-1}$,语言模型建模的是:

$$P(x_t \mid x_{

其中 $h_t$ 是网络在位置 $t$ 的隐藏状态,$\theta$ 是待学习的参数。整个模型的训练目标是对语料库的负对数似然(等价于交叉熵损失):

$$\mathcal{L}(\theta) = -\sum_t \log P(x_t \mid x_{

这个目标看起来平平无奇,但注意一个关键事实:为了压低这个损失,模型被迫学会语法、事实、推理。要在 "The capital of France is ___" 后输出 "Paris",模型必须存储世界知识;要在长代码中匹配括号,模型必须学会结构化追踪。GPT-3 论文里明确展示了:损失随规模的下降曲线上,"小样本学习能力"作为副产品涌现。

用 PyTorch 写一个最小训练循环(约 30 行,这就是 LLM 预训练的骨架):

import torch
import torch.nn.functional as F

def training_step(model, batch, optimizer):
    """batch: (B, T) 的 token id 矩阵"""
    x, y = batch[:, :-1], batch[:, 1:]      # 输入右移一位即标签
    logits = model(x)                        # (B, T-1, |V|)
    loss = F.cross_entropy(
        logits.reshape(-1, logits.size(-1)),  # 展平成 (B*(T-1), |V|)
        y.reshape(-1),
    )
    optimizer.zero_grad()
    loss.backward()                          # 反向传播算梯度
    optimizer.step()                         # 参数更新
    return loss.item()

# 困惑度(Perplexity)= exp(loss),语言模型最通用的评价指标
# loss=2.0 → PPL≈7.4,即模型对下一个词的"有效猜测数"约7.4个

注意 x, y = batch[:, :-1], batch[:, 1:] 这一行:标签就是输入左移一位。训练信号完全免费——任何文本自己就是自己的标签。这就是为什么预训练能用"整个互联网"当数据集,不需要人工标注。

二、Tokenizer:字节对编码(BPE)

现代 LLM 的词表几乎都由 BPE(Byte-Pair Encoding)或其变体生成。算法逻辑:从字节级字符开始,反复合并语料中最高频的相邻对,直到达到目标词表大小。

一个可运行的最小 BPE 实现:

from collections import Counter

def train_bpe(corpus: str, vocab_size: int):
    """极简 BPE:空格分词(仅演示英文),返回合并规则"""
    tokens = [list(w) + ["</w>"] for w in corpus.split()]
    merges = {
   }
    for i in range(vocab_size - 256):
        # 统计所有相邻 token 对的频率
        pairs = Counter()
        for seq in tokens:
            pairs.update(zip(seq, seq[1:]))
        best, freq = pairs.most_common(1)[0]
        merges[best] = i
        # 应用最优合并
        tokens = [
            merge_seq(seq, best)
            for seq in tokens
        ]
    return merges

def merge_seq(seq, pair):
    out, i = [], 0
    while i < len(seq):
        if i < len(seq) - 1 and (seq[i], seq[i+1]) == pair:
            out.append(seq[i] + seq[i+1]); i += 2
        else:
            out.append(seq[i]); i += 1
    return out

生产级的实现(如 GPT-4o 使用的 o200k_base,词表 20 万)要复杂得多,但核心思想一致。工程上真正需要记住的是:

  • 中文大约 1~2 字/Token,英文约 0.75 词/Token,这直接决定 API 计费和上下文有效长度
  • 数字、生僻 Unicode、代码缩进是分词的重灾区——这是模型算术差、对空白敏感的架构级根源
  • 上下文窗口长度(8K/128K/1M)指的是 Token 数,不是字符数
import tiktoken
enc = tiktoken.get_encoding("o200k_base")
print(len(enc.encode("我只需要被处理,不需要被理解")))
# 15 —— 每个 Token 对应词表中的一个整数 id

三、Transformer:只有注意力是主角

整型 Token id 先过 Embedding 查表变成向量,加上位置信息,然后流经 N 层重复的块,每层是"注意力 + 前馈网络"两个子层,各配残差连接和 LayerNorm:

$$h = h + \mathrm{Attention}(\mathrm{LN}(h)), \quad h = h + \mathrm{FFN}(\mathrm{LN}(h))$$

3.1 Scaled Dot-Product Attention

$$\mathrm{Attention}(Q, K, V) = \mathrm{softmax}\!\left(\frac{QK^\top}{\sqrt{d_k}}\right)V$$

$Q$(query)、$K$(key)、$V$(value)由同一输入经三个不同投影矩阵得到。除以 $\sqrt{d_k}$ 是因为点积方差随维度线性增长,大量纲会让 softmax 饱和、梯度消失。NumPy 版骨架:

import numpy as np

def softmax(x, axis=-1):
    e = np.exp(x - x.max(axis=axis, keepdims=True))
    return e / e.sum(axis=axis, keepdims=True)

def attention(Q, K, V, mask=None):
    d_k = Q.shape[-1]
    scores = Q @ K.swapaxes(-2, -1) / np.sqrt(d_k)   # (B, H, T, T)
    if mask is not None:
        scores = np.where(mask, scores, -1e9)        # 因果掩码
    A = softmax(scores)                              # 注意力权重
    return A @ V, A                                  # 加权聚合

T, d = 5, 8
X = np.random.randn(T, d)
Wq, Wk, Wv = (np.random.randn(d, d) for _ in range(3))
Q, K, V = X @ Wq, X @ Wk, X @ Wv
causal_mask = np.tril(np.ones((T, T), dtype=bool))   # 下三角:只许看过去
out, A = attention(Q, K, V, causal_mask)
print(A.round(2))  # 上三角全为0 —— 未来词被掩码屏蔽

因果掩码(causal mask)是理解训练与推理一致性的关键:训练时整个序列并行计算,但每个位置只允许 attend 自己之前的 Token,否则就是在偷看答案。

3.2 多头注意力(Multi-Head)

单头注意力只有一个相似度度量。多头机制把 $d_{model}$ 维切成 $h$ 份,每头在 $dk = d{model}/h$ 维独立做注意力再拼接。不同的头在训练后自发分工:有头专管指代消解、有头追踪句法依赖、有头做位置对齐(这部分可解释性来自 Anthropic、DeepMind 的电路分析工作)。

class MultiHeadAttention:
    def __init__(self, d_model, n_heads):
        assert d_model % n_heads == 0
        self.d_k = d_model // n_heads
        self.n_heads = n_heads
        self.Wq, self.Wk, self.Wv, self.Wo = (
            np.random.randn(d_model, d_model) for _ in range(4))

    def __call__(self, X, mask=None):
        B, T, _ = X.shape
        # (B, T, d_model) → 拆头 → (B, n_heads, T, d_k)
        def split(x, W):
            x = x @ W
            return x.reshape(B, T, self.n_heads, self.d_k).transpose(0, 2, 1, 3)
        Q, K, V = split(X, self.Wq), split(X, self.Wk), split(X, self.Wv)
        out, _ = attention(Q, K, V, mask)
        # 合头还原形状,过输出投影
        out = out.transpose(0, 2, 1, 3).reshape(B, T, -1)
        return out @ self.Wo

3.3 FFN:知识主要存在这里

注意力负责"搬运信息",而模型约 2/3 的参数在前馈网络(FFN)里,通常是两层 MLP 加一个非线性:

def ffn(x, W1, W2):
    # 现代 LLM 普遍用 SwiGLU 替代原始 GELU 版本
    return (gelu(x @ W1)) @ W2   # d_model → 4*d_model → d_model

插一句目前的主流共识:注意力层像"寻址-读取",FFN 层像 key-value 记忆库——大量探针实验表明事实性知识("巴黎是法国首都")主要编码在 FFN 的权重里。

3.4 位置编码

注意力本身是置换等变的——不打乱顺序标记,"狗咬人"和"人咬狗"没有区别。必须注入位置信息。从正弦编码到可学习编码,再到如今主流的 RoPE(旋转位置编码):把 Query/Key 在二维平面上按位置旋转,使得 $q_m \cdot k_n$ 只依赖于相对距离 $m - n$。RoPE 外推性好,是 LLaMA 系列能拉长上下文的关键组件之一。

3.5 组装一个微型 GPT

把上述组件拼起来,就是一个结构上与 GPT-2 同源的模型(Llama 系列的差异主要在:RMSNorm 替代 LayerNorm、SwiGLU 替代 GELU FFN、RoPE 替代学习式位置编码):

import torch, torch.nn as nn

class Block(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.ln1, self.ln2 = nn.LayerNorm(d_model), nn.LayerNorm(d_model)
        self.attn = nn.MultiheadAttention(d_model, n_heads, batch_first=True)
        self.ffn = nn.Sequential(
            nn.Linear(d_model, 4 * d_model), nn.GELU(),
            nn.Linear(4 * d_model, d_model))

    def forward(self, x, attn_mask):
        a, _ = self.attn(self.ln1(x), self.ln1(x), self.ln1(x),
                         attn_mask=attn_mask, need_weights=False)
        x = x + a                       # 残差
        return x + self.ffn(self.ln2(x))

class MiniGPT(nn.Module):
    def __init__(self, vocab_size, d_model=512, n_layers=8, n_heads=8, ctx=256):
        super().__init__()
        self.ctx = ctx
        self.tok_emb = nn.Embedding(vocab_size, d_model)
        self.pos_emb = nn.Embedding(ctx, d_model)
        self.blocks = nn.ModuleList(Block(d_model, n_heads) for _ in range(n_layers))
        self.ln_f = nn.LayerNorm(d_model)
        self.head = nn.Linear(d_model, vocab_size, bias=False)

    def forward(self, idx):
        B, T = idx.shape
        mask = torch.triu(torch.full((T, T), float("-inf")), diagonal=1)
        x = self.tok_emb(idx) + self.pos_emb(torch.arange(T, device=idx.device))
        for blk in self.blocks:
            x = blk(x, mask)
        return self.head(self.ln_f(x))   # (B, T, vocab_size) 未归一化 logits

四、解码策略:从概率分布到文本

模型输出的是词表上的 logits,怎么采样直接决定输出质量。常用的策略一族:

import torch
import torch.nn.functional as F

def sample_next(logits, temperature=0.8, top_k=50, top_p=0.9):
    # 1. 温度缩放:调节分布熵
    logits = logits / temperature
    # 2. Top-k:只保留概率最高的 k 个
    if top_k:
        kth = torch.topk(logits, top_k).values[..., -1, None]
        logits = logits.masked_fill(logits < kth, float("-inf"))
    # 3. Top-p(nucleus):保留累计概率达 p 的最小集合
    if top_p < 1.0:
        sorted_logits, idx = torch.sort(logits, descending=True)
        cum = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
        drop = cum - F.softmax(sorted_logits, dim=-1) > top_p
        logits[idx[drop]] = float("-inf")
    # 4. 归一化后按概率采样
    return torch.multinomial(F.softmax(logits, dim=-1), 1)
策略 行为 适用
Greedy(argmax) 永远选最优 确定性任务,但易重复
Temperature 缩放整个分布 创造性任务调高,代码任务调低
Top-k 截断长尾 防止极低概率词污染输出
Top-p 动态截断 候选数随分布形状自适应

推理时逐 Token 生成还有一个工程现实:每生成一个 Token,都要对整个前缀重新计算注意力。KV Cache 的思路是把每层的 K、V 缓存下来,每步只算最新一个 Token 的 QKV,把每步复杂度从 $O(t^2)$ 降到 $O(t)$:

# vLLM / llama.cpp 这类推理框架的核心就是高效 KV Cache 管理
# 代价:显存占用 ∝ 2 × layers × heads × d_k × seq_len × batch × bytes
# 7B 模型、4K 上下文、fp16,KV Cache 约 2GB —— 这就是长上下文贵的原因

由此也能立刻推出几个工程事实:显存是长上下文的硬约束、Prompt 前缀相同可复用 KV(prefix caching)、批处理是吞吐的关键。

五、训练流水线:Pretrain → SFT → RLHF/RLAIF

预训练:上述交叉熵目标 + 万亿级 Token + 数千卡集群。训练本身是个系统工程:数据清洗与去重(质量比数量重要)、混合数据配比(代码数据显著提升推理能力)、分布式并行(数据并行 + 张量并行 + 流水线并行)、检查点容错。前沿模型单次预训练成本以千万美元计。

监督微调(SFT):几十万条人工写的(指令, 回复)对,依然用同一个交叉熵损失——只是数据从"任意网页文本"换成了"指令对话格式"。损失通常只计算在回复部分,避免浪费容量在复述指令上。

对齐(RLHF / DPO):这一步解决的问题是"什么是好的回复"难以写成可微的损失函数。经典 RLHF 流程:

  1. 收集人类偏好数据(同一 prompt 的两个回复,人标注哪个更好)
  2. 训练奖励模型(Reward Model)模仿人类打分
  3. 用 PPO 等强化学习算法优化策略模型,使奖励最大化,同时用 KL 散度惩罚防止模型漂移过远
# RLHF 的目标函数(简化形式)
def rlhf_objective(response, reward_model, ref_model, beta=0.1):
    r = reward_model(response)                      # 人类偏好代理
    kl = KL(policy(response) || ref_model(response)) # 别把语言能力跑崩了
    return r - beta * kl

DPO(Direct Preference Optimization)是后来的简化:跳过显式的奖励模型,直接从偏好对导出一个闭式分类损失,训练稳定性好、成本低,已成为开源社区对齐的默认选项。

测试时扩展(Test-time Compute):o1/o3、DeepSeek-R1 这一代模型的新变量——不再只堆训练算力,而是在推理时生成长思维链并用 RL 训练,用"想得更久"换"答得更准"。这把 Scaling Law 从训练时扩展到了推理时。

六、幻觉与评测

幻觉的机理可以直接从目标函数推出:模型被训练去最大化 $\log P(xt \mid x{<t})$,即"似然",而用户要的是"真值"。二者在训练数据可靠时高度相关,在长尾知识上彻底脱钩——模型会用高概率的"论文体文本"续写一篇不存在的论文。这不是 bug,是目标的错位。

缓解手段与其原理一一对应:

  • RAG:把外部检索结果放进上下文,把"从参数里回忆"改造成"从上下文里抄写"——后者对 Transformer 是分布内任务,可靠得多
  • logprobs 监控:低置信度输出触发拒答或人工复核
  • 自一致性(Self-Consistency):同一问题采样多次投票,降低单次采样噪声

评测方面,单选准确率(MMLU 风格)已不足以刻画能力,主流转向:竞争性编程(LiveCodeBench)、研究生级推理(GPQA)、长上下文检索(RULER)、以及最难防止污染的——人类偏好盲测(Chatbot Arena 的 Elo 评分)。

七、小结

用一张表收束全文:

组件 解决的问题 代表技术
BPE Tokenizer 文本 → 整数序列 字节级 BPE
Embedding + RoPE 序列 → 向量 + 位置 旋转位置编码
Multi-Head Attention 上下文信息路由 GQA / FlashAttention
FFN 知识存储 SwiGLU
交叉熵预训练 从数据中学习语言与世界 Scaling Law
SFT + RLHF/DPO 从续写器到助手 PPO, DPO, RLVR
解码与 KV Cache 概率 → 文本,工程提速 Top-p, vLLM/PagedAttention

剥掉所有工程外壳,LLM 就是:在互联网语料上最小化下一个 Token 交叉熵的自回归 Transformer,再用对齐技术把"统计续写"扭转成"遵循指令"。理解了这一点,它的能力边界、失效模式和改进方向,都可以从第一性原理推导出来。

相关文章
|
24天前
|
安全 算法 定位技术
《高性价比人生指南》完整原版:普通人用最少的资源,过好这一生的底层逻辑~How To Live Better
📖《高性价比人生指南》是一份基于实证、拒绝焦虑的生存手册,倡导以“人生时薪”为视角,重新计算时间、金钱与精力的成本与收益。它不承诺逆袭,只教人算清账:省下的钱若耗掉时间便亏;买体验比买物品更值;睡眠是最高杠杆的健康投资;关系贵在情绪价值而非表面热络;学习重在改变行为而非自我安慰。核心理念:用低成本、高回报的微小行动,换取长期的选择权——不是成为谁,而是掌控自己人生的主动权。
2726 8
|
24天前
|
人工智能 JSON API
2026 阿里云双 11 特辑|Jev 决策模型全维度解析:核心原理、实操测评与手把手落地指南
Jev的出现,给AI工程带来了一个全新的分层思路——‌复杂生成任务交给传统大模型,高频简单判断交给Jev‌。二者组合搭建的分层智能架构,才能同时兼顾输出能力、响应速度与调用成本。 2026年阿里云双11期间,阿里云百炼大模型服务平台也为开发者提供了丰富的免费额度与灵活计费方案,新人开通可领取超7000万Token免费额度、90天超长有效期,正是体验Jev等前沿模型的最佳窗口。 对于做客服系统、Agent智能体、内容审核、批量数据打标签的开发者——‌这篇文章是你的起点,而不是终点。‌ 现在就前往‌阿里云百炼大模型服务平台页面‌,开启你的Jev实战之旅吧。
522 1
|
5月前
|
机器学习/深度学习 人工智能 网络架构
深度解析:Transformer 的“灵魂”——QKV 变换的物理直觉
本文用图书馆检索等生活隐喻,从物理意义与认知科学角度解析Transformer中QKV设计的精妙本质:解耦查询(q)、键(k)、值(v)三重角色,实现语义分离、避免自注意力“自恋”,模拟人类动态信息路由的认知过程。(239字)
1165 13
|
2月前
|
人工智能 JavaScript 测试技术
从0到1玩转DeepSeek Harness:架构解析、命令速查、插件扩展、业务场景落地全流程
2026年,DeepSeek正式对外开源DeepSeek Harness(简称dsh),这套AI Agent运行时项目在GitHub发布12小时内收获5万星标,迅速引发全球开发者的广泛关注。它提出了一个核心公式:**Agent = Model + Harness**,模型作为智能体的大脑,负责思考推理;而Harness充当智能体的手脚,赋予模型读写本地文件、执行系统命令、调用各类工具、调度子任务的实操能力。
1497 0
|
5月前
|
存储 人工智能 应用服务中间件
AI 应用类程序的开发费用
AI应用成本结构迥异于传统软件:研发为一次性投入,而模型推理、云服务等产生持续费用。主要包括人力开发(3万–40万)、大模型调用(按Token计费)、云与向量数据库(500–2000元/月)及可选微调(数千至数万元)。初创项目建议预算8–20万+月均千元运营费。
|
6月前
|
存储 人工智能 缓存
长上下文大模型的企业成本治理:从调用链到预算控制
Claude 1M 长上下文、Claude Code、MCP、Agent workflow 的讨论升温后,企业侧的关注点正在从“模型能力是否足够强”转向“能不能稳定、合规、可控地跑在业务里”。
370 2
|
6月前
|
数据采集 前端开发 搜索推荐
数据平台怎么搭建?数据平台与业务中台和主数据平台有什么区别?
业务中台(能力复用)、数据中台(资产化分析)、主数据平台(核心数据治理)三者定位迥异:前者支撑敏捷业务,后者驱动智能决策,中间者筑牢数据根基。混淆易致项目失败——弄清本质与边界,是数字化转型规划的第一课。
|
4月前
|
人工智能 运维 NoSQL
OpenSpec 三阶段工作流实操:从 Propose 到 Archive让代码返工率降到三分之一以下
OpenSpec是AI原生规范驱动开发(SDD)框架,以Propose→Apply→Archive三阶段强制工作流,将需求精准转为AI可读、可验、可追溯的结构化规范,实测降低代码返工率超2/3。
663 0
|
7月前
|
缓存 人工智能 API
DeepSeek-V4上线阿里云百炼,API调用价格与官网一致,百万Tokens输入最低1元、Tokens输出2元
阿里云百炼上线DeepSeek-V4-pro(1.6T参数,强推理)与V4-flash(284B参数,高性价比)两款MoE大模型,均支持百万级上下文。V4-flash输入仅1元/百万tokens,输出2元;V4-pro性能更强,价格适配高阶场景。开通即赠100万Tokens,购节省计划享5折优惠,申请开通:https://t.aliyun.com/U/fPVHqY
4715 1
|
10月前
|
存储 人工智能 并行计算
AI算力选择终极指南:如何像配电脑一样,配好你的大模型“发动机”
博主maoku为你详解AI算力配置:用“计算—存储—网络”铁三角模型,通俗类比GPU显存(油箱)、互联带宽(传动轴)、存储分层(粮仓+传送带)等核心概念;提供四步实战指南——需求诊断、GPU选型、部署模式(云主机/容器/裸金属)、成本优化,并教你看懂利用率、吞吐量与真实成本。助你告别CUDA OOM焦虑,高效构建高性价比大模型环境。
1913 12