从 0 到 1 构建大语言模型 —— 自上向下学习路线图

一、什么是大语言模型（LLM）？

大语言模型（Large Language Model，LLM）是一种基于海量文本训练的 AI 系统，能够理解并生成自然语言。

“大”：参数量通常在数十亿到数万亿之间（GPT-4 约 1.8 万亿参数）
“语言”：处理对象是文字、符号（而非图像、声音）
“模型”：本质是一个数学函数，输入一段文字 → 输出下一个词的概率

一句话理解：LLM 就是一个极其复杂的”下一词预测器”，给它”今天天气很”，它预测”好”的概率最高。

二、大语言模型制作全景（树根）

构建一个大语言模型
│
├── 1. 数据准备 ← 模型的"课本"，决定模型能力上限
│   ├── 1.1 计算机如何理解文字？（编码原理：ASCII → Unicode → UTF-8）
│   ├── 1.2 什么是分词？为什么需要分词？
│   ├── 1.3 BPE分词算法完整推导（从256字节到50000词表）
│   ├── 1.4 数据收集与清洗的5个步骤
│   ├── 1.5 Chinchilla定律：需要多大的数据集？
│   └── 1.6 从分词到模型的完整流程
│
├── 2. 模型架构设计 ← 模型的"大脑结构"
│   ├── 2.1 什么是 Transformer？为什么选它？
│   ├── 2.2 Self-Attention机制（Query、Key、Value详解）
│   ├── 2.3 多头注意力、位置编码、残差连接
│   ├── 2.4 从文本到向量的完整流程（分词→Embedding→位置编码）
│   ├── 2.5 原始Attention的三大缺陷（低秩瓶颈、Attention Sink、缺乏稀疏性）
│   ├── 2.6 Gated Attention改进（门控机制、非线性增益）
│   └── 2.7 Embedding如何学习？为什么相似词有相似向量？
│
├── 3. 预训练 ← 让模型"阅读"海量文本
│   ├── 3.1 预训练目标：预测下一个词
│   ├── 3.2 损失函数（模型错了多少？）
│   ├── 3.3 优化器与学习率调度
│   └── 3.4 大规模分布式训练（多 GPU/多机器）
│
├── 4. 对齐与微调 ← 让模型"听话"、"有用"
│   ├── 4.1 指令微调（SFT）
│   ├── 4.2 人类反馈强化学习（RLHF）
│   └── 4.3 偏好优化（DPO）
│
└── 5. 部署与推理 ← 让模型上线服务
    ├── 5.1 量化压缩（模型瘦身）
    ├── 5.2 推理加速框架
    └── 5.3 API 服务封装

三、逐层深入

3.1 数据准备

数据是大语言模型的基石。如果把模型比作一个学生，数据就是它要读的所有课本。

深入学习

完整的数据准备指南请查看：3.1数据准备-完整版

完整版包含：

第一部分：计算机如何理解文字（ASCII → GBK → UTF-8编码演变）

第二部分：分词技术详解（BPE算法完整推导，从256字节到50000词表）

第三部分：从分词到模型的完整流程（Tokenization vs Word2Vec vs Embedding）

第四部分：概念关系图（BERT vs GPT，Gemini是什么）

第五部分：数据收集与清洗的5个步骤（fastText、MinHash去重）

自我检验：20道思考题 + 费曼学习法检验

核心概念速览：

1. 编码原理

计算机只认识0和1
    ↓
需要"翻译规则"把文字变成数字
    ↓
ASCII（128个字符，只够英文）
    ↓
GBK（2万多汉字，只有中文）
    ↓
UTF-8（全世界通用，256个基础字节通过组合表示所有文字）✅

2. BPE分词算法

初始：256个UTF-8字节
    ↓
统计：找最常出现的字符对
    ↓
合并：把高频对合并成新Token
    ↓
重复：直到词表达到目标大小（如50000）

例子：
  "the" → [t, h, e]
  → 合并"th" → [th, e]
  → 合并"the" → [the]

3. 关键区别

	Tokenization	Word2Vec	Embedding
输出	整数ID	固定向量	动态向量
包含语义	❌	✅	✅
现在用吗	✅ 必须	❌ 废弃	✅ 必须

4. 数据清洗流程

原始数据（几百TB）
  → 去HTML标签
  → 语言过滤（fastText识别）
  → 质量过滤（删短文、广告、乱码、有害内容）
  → 去重（MinHash算法）
  → 隐私过滤（删除个人信息）
  → 清洗后数据（只剩10%-30%）

5. 数据量需求（Chinchilla定律）

$最优 Token 数 \approx 20 \times 参数量$

模型大小	需要Token数	约等于
1B	20B	300亿字 ≈ 40GB
7B	140B	2100亿字 ≈ 280GB
70B	1.4T	2万亿字 ≈ 2.8TB

3.2 模型架构 —— Transformer

概念：Transformer 是 2017 年 Google 提出的架构，统治了现代 NLP。核心创新是Self-Attention机制：让模型处理每个词时，都能同时关联到句子中所有其他词。

类比：读文章时，你的大脑会自动把”他”和前文的”张三”联系起来。注意力机制就是在做这件事。

深入学习

完整的Transformer架构指南请查看：3.2 Transformer架构-完全指南

完整版包含：

第一部分：预备知识（RNN的问题、Transformer的核心思想）

第二部分：Self-Attention机制（Q、K、V详解、数学推导、代码实现）

第三部分：多头注意力（为什么需要多头、如何并行计算）

第四部分：Transformer完整架构（Encoder-Decoder、位置编码、残差连接）

第五部分：原始Attention的三大缺陷（低秩瓶颈、Attention Sink、缺乏稀疏性）

第六部分：Gated Attention改进（门控机制、非线性增益、数学推导）

第七部分：数学推导和实现细节（Embedding学习、复杂度分析）

自我检验：25道思考题 + 附录A（深度答疑）+ 附录B（流程图解）

核心概念速览：

1. Self-Attention机制

核心公式： $Attention (Q, K, V) = softmax (\frac{Q K ^{T}}{d _{k}}) V$

每个词的向量
    ↓
通过三个矩阵变换得到 Q、K、V
    ↓
Q @ K^T：计算每个词和其他词的相关性（注意力分数）
    ↓
除以√d_k：缩放，防止数值过大
    ↓
Softmax：转换为概率分布（和为1）
    ↓
乘以V：加权求和，得到输出

12岁版解释：

Q（Query）：当前词在问”谁和我相关？”
K（Key）：每个词在说”我能匹配什么问题”
V（Value）：每个词的实际内容信息

2. 多头注意力

为什么需要多头？
  → 一个头只能关注一种关系
  → 多个头可以同时关注多种关系

例子："我爱吃苹果"
  头1：关注主谓关系（我→爱）
  头2：关注动宾关系（吃→苹果）
  头3：关注修饰关系（吃→爱）

3. 从文本到向量的完整流程

"今天天气很好"
    ↓ [分词]
[1234, 5678, 9012, 3456]
    ↓ [Token Embedding]
[[0.1, 0.2, ...], [0.3, 0.4, ...], ...]
    ↓ [位置编码]
[[0.1+sin(0), 0.2+cos(0), ...], [0.3+sin(1), 0.4+cos(1), ...], ...]
    ↓ [Self-Attention]
理解词与词之间的关系
    ↓ [前馈网络]
增加非线性表达能力
    ↓
输出向量

4. 原始Attention的三大缺陷

缺陷	问题	影响
低秩瓶颈	Softmax输出是低秩矩阵	表达能力受限
Attention Sink	第一个Token吸收大量注意力	信息分配不均
缺乏稀疏性	所有Token都有注意力	计算浪费

5. Gated Attention改进

原始Attention：
  Attention(Q,K,V) = softmax(QK^T/√d_k)V

Gated Attention：
  Attention(Q,K,V) = σ(QU^T) ⊙ (AV)

  其中：
  - σ：Sigmoid函数（门控）
  - U：可学习的门控矩阵
  - A：注意力矩阵（不用softmax）
  - ⊙：逐元素相乘

改进效果：

✅ 解决低秩瓶颈（去掉softmax）
✅ 缓解Attention Sink（门控机制）
✅ 增加稀疏性（Sigmoid可以输出接近0的值）

6. 代码实现（简化版）

import torch
import torch.nn as nn
 
class SelfAttention(nn.Module):
    def __init__(self, d_model):
        super().__init__()
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
 
    def forward(self, x):
        B, T, C = x.shape
        Q, K, V = self.W_q(x), self.W_k(x), self.W_v(x)
        # 计算注意力权重
        scores = Q @ K.transpose(-2, -1) / (C ** 0.5)
        # 因果掩码：只看过去，不看未来
        mask = torch.tril(torch.ones(T, T))
        scores = scores.masked_fill(mask == 0, float('-inf'))
        weights = torch.softmax(scores, dim=-1)
        return weights @ V

7. Embedding如何学习？

初始化：随机向量
    ↓
训练过程：
  - 模型预测下一个词
  - 计算损失（预测错了多少）
  - 反向传播更新Embedding
    ↓
结果：相似的词有相似的向量

例子：
  "猫"和"狗"的向量会很接近（都是动物）
  "猫"和"汽车"的向量会很远（完全不同）

3.3 预训练

概念：在海量无标注文本上，让模型学会”预测下一个词”。

规模感知：LLaMA-3 8B 模型在约 1.5 万亿个 Token 上训练，用了数百块 A100 GPU 跑了数月。

流程：

初始化随机权重
    ↓ 输入 Token 序列
模型预测每个位置的下一个 Token
    ↓
计算预测与真实值的差距（损失）
    ↓
反向传播，更新权重
    ↓
重复数千亿次 → 得到基础模型（Base Model）

深挖：损失函数（交叉熵）

$L = - \frac{1}{T} \sum_{t = 1}^{T} lo g P (x_{t} ∣ x_{1}, ..., x_{t - 1})$

含义：对每个位置，计算模型预测正确词的概率的对数，取平均后取负值。越小越好。

3.4 对齐与微调

概念：预训练模型只会”续写文字”，不会”按指令回答问题”。对齐的目的是让模型行为符合人类期望。

三阶段：

预训练基础模型
    ↓
[Stage 1] 指令微调（SFT）
    用 (问题, 答案) 对训练，教模型"如何回答"
    ↓
[Stage 2] 奖励建模
    人类对多个回答排序 → 训练"打分模型"
    ↓
[Stage 3] RLHF / DPO
    用打分模型反馈优化，让回答更符合人类偏好
    ↓
对话模型（ChatGPT 背后的原理）

深挖：为什么需要 RLHF？

SFT 只能模仿示例，无法泛化。RLHF 让模型主动”追求”高质量输出。

优化目标：

$max_{θ} E [r (x, y)] - β \cdot D_{K L} [π_{θ} ∥ π_{r e f}]$

$r (x, y)$ ：奖励分数（越高越好）
$D_{K L}$ ：防模型偏离原始分布太远（防”作弊”）

3.5 部署与推理

概念：训练好的模型动辄几十 GB，直接部署成本高。需要压缩加速。

主要技术：

原始模型（FP32，几十 GB）
    ↓ [量化] 权重从 32位 压缩到 4位/8位
小模型（缩小 4-8x，速度更快）
    ↓ [推理框架] vLLM / llama.cpp
    ↓ [API 封装]
对外提供服务（像 OpenAI API 一样调用）

四、自上向下学习路径

第 1 周：先跑通一个小 GPT
    → 推荐：Andrej Karpathy 的 nanoGPT 教程（YouTube 有完整视频）
    → 遇到不懂 → 按需查阅本文对应章节

第 2 周：用 HuggingFace 微调真实模型
    → pip install transformers
    → 加载 GPT-2 / LLaMA，在自己的数据上微调

第 3 周起：按需读论文补理论
    → Attention Is All You Need（2017）—— Transformer 原论文
    → InstructGPT（2022）—— RLHF 详解
    → Scaling Laws（2020）—— 为什么更大更好

自上向下核心原则：代码和数学是最深层的细节，遇到需要时才深入，先把系统跑起来，理解自然而然会来。

zero2hero 学习笔记

探索

从0到1构建大模型-自上向下学习法