预训练策略：从 GPT 到 Llama，大模型的"九年义务教育"

1
2017: Transformer (Vaswani et al.)
2
  │
3
2018: GPT-1 (Radford et al.)
4
  │   首次展示预训练 + 微调的范式
5
  │
6
2018: BERT (Devlin et al.)
7
  │   双向编码预训练
8
  │
9
2019: GPT-2 (1.5B)
10
  │   零样本学习的曙光
11
  │
12
2020: GPT-3 (175B)
13
  │   In-context learning 涌现
14
  │
15
2021: Switch Transformer (1.6T)
16
  │   稀疏 MoE
17
  │
18
2022: Chinchilla (70B)
19
  │   提出 Chinchilla Scaling Law
20
  │
21
2023: Llama 2 / GPT-4
22
  │   开源 + 闭源双轨发展
23
  │
24
2024: Llama 3 (405B)
25
  │   更大规模，更优数据
26
  │
27
2025+: 多模态预训练
28
       + RLHF 集成
29
       + 工具集成

1
class PretrainingObjectives:
2
    """预训练目标集合"""
3

4
    CAUSAL_LM = "clm"               # 因果 LM
5
    MASKED_LM = "mlm"               # 掩码 LM
6
    PREFIX_LM = "prefix_lm"         # 前缀 LM
7
    SPAN_MASKING = "span_mask"      # 跨度掩码
8
    NEXT_SENTENCE = "nsp"           # 下一句预测
9
    SENTENCE_ORDER = "sop"          # 句子顺序
10
    REPLACEMENT = "RTD"             # 替换检测 (ELECTRA)
11
    CONTRASTIVE = "contrastive"     # 对比学习
12

13
# 不同模型采用不同组合
14
MODELS_OBJECTIVES = {
15
    'GPT': ['clm'],
16
    'BERT': ['mlm', 'nsp'],
17
    'T5': ['span_mask'],
18
    'ELECTRA': ['RTD'],
19
    'XLNet': ['permutation_lm'],
20
    'Llama': ['clm'],
21
}

1
def bpe_train(corpus, vocab_size):
2
    """训练 BPE"""
3
    # 1. 初始化: 字符集合
4
    vocab = set(char for text in corpus for char in text)
5

6
    while len(vocab) < vocab_size:
7
        # 2. 统计相邻 token 对的频率
8
        pairs = count_pairs(corpus)
9

10
        # 3. 找最频繁的对
11
        most_frequent = max(pairs, key=pairs.get)
12

13
        # 4. 合并
14
        merge_pair(most_frequent, corpus)
15
        vocab.add(most_frequent)
16

17
    return vocab
18

19
# 示例:
20
# 初始: 今天 天气 很 好
21
# 统计: (今天, 天气) 出现 100 次最多
22
# 合并: 今天天气 → 一个 token
23
# 继续: 看 (今天天气, 很好) ...

1
class MultilingualTokenizer:
2
    """多语言 tokenizer"""
3

4
    def __init__(self, vocab_size=100000):
5
        # 让高频语言共享 token
6
        # 低频语言用较长表示
7
        self.vocab_size = vocab_size
8

9
    def token_efficiency(self, text, lang):
10
        """不同语言的 token 效率"""
11
        tokens = self.encode(text)
12
        compression_ratio = len(tokens) / len(text)
13

14
        # 高资源语言（英语）: 1 token ≈ 4 字符
15
        # 低资源语言（冰岛语）: 1 token ≈ 1 字符
16
        return compression_ratio

1
DATA_SOURCES = {
2
    'CommonCrawl': {
3
        'size': '~250B 网页 (清洗后)',
4
        'quality': '中',
5
        '使用率': '~70%',
6
    },
7
    'GitHub': {
8
        'size': '~50B 行代码',
9
        'quality': '高（需要过滤）',
10
        '使用率': '~10% (Llama)',
11
    },
12
    'Books': {
13
        'size': '~10B books',
14
        'quality': '高',
15
        '使用率': '~5% (Books3, Project Gutenberg)',
16
    },
17
    'Wikipedia': {
18
        'size': '~20M articles',
19
        'quality': '极高',
20
        '使用率': '~5%',
21
    },
22
    'Papers': {
23
        'size': '~10M papers',
24
        'quality': '高',
25
        '使用率': '~5% (arXiv, PubMed)',
26
    },
27
    '问答/论坛': {
28
        'size': '~10B',
29
        'quality': '中',
30
        '使用率': '~10% (StackExchange)',
31
    }
32
}

1
# Llama 1 的数据配比
2
DATA_MIX = {
3
    'CommonCrawl': 67.0,
4
    'C4': 15.0,
5
    'GitHub': 4.5,
6
    'Wikipedia': 4.5,
7
    'Books': 4.5,
8
    'StackExchange': 2.0,
9
    '其他': 2.5,
10
}
11

12
# Llama 2 调整为:
13
LLAMA2_MIX = {
14
    'CommonCrawl': 60+,
15
    '高质量来源': ~40%,
16
    # 高质量来源占比增加
17
}
18

19
# 关键: 在训练过程中可能调整配比

1
原始数据
2
    │
3
    ▼
4
[1] HTML/格式清洗（去标签、提内容）
5
    │
6
    ▼
7
[2] 语言识别（filter_english, fasttext）
8
    │
9
    ▼
10
[3] 质量过滤（启发式规则 + 模型评分）
11
    │
12
    │
13
    ├──▶ 去重（文档级、段落级）
14
    │
15
    ▼
16
[4] NSFW 过滤
17
    │
18
    ▼
19
[5] PII（个人身份信息）移除
20
    │
21
    ▼
22
[6] 数据增强/标准化
23
    │
24
    ▼
25
最终训练数据

1
class Deduplicator:
2
    """数据去重"""
3

4
    def exact_dedup(self, documents):
5
        """精确去重"""
6
        seen = set()
7
        unique = []
8
        for doc in documents:
9
            if doc.hash not in seen:
10
                seen.add(doc.hash)
11
                unique.append(doc)
12
        return unique
13

14
    def fuzzy_dedup(self, documents, threshold=0.85):
15
        """模糊去重（基于 MinHash）"""
16
        # MinHash 用于估计 Jaccard 相似度
17
        unique = []
18
        for doc in documents:
19
            is_dup = False
20
            for existing in unique:
21
                similarity = self._minhash_similarity(doc, existing)
22
                if similarity > threshold:
23
                    is_dup = True
24
                    break
25

26
            if not is_dup:
27
                unique.append(doc)
28

29
        return unique

1
class QualityScorer:
2
    """基于模型的文档质量评分"""
3

4
    def __init__(self, quality_model):
5
        self.model = quality_model
6

7
    def score(self, documents):
8
        """使用 kenlm / fastText 等打分"""
9
        scores = []
10
        for doc in documents:
11
            # kenlm 困惑度（越低越好）
12
            perplexity = self.model.perplexity(doc.text)
13

14
            # 文档长度
15
            length = len(doc.text.split())
16

17
            # 符号比例
18
            symbol_ratio = self._symbol_ratio(doc.text)
19

20
            # 综合评分
21
            score = self._compute_score(perplexity, length, symbol_ratio)
22
            scores.append(score)
23

24
        return scores

1
class ContaminationDetector:
2
    """检测训练数据与测试集的重叠"""
3

4
    def detect(self, train_doc, test_questions):
5
        """检测污染"""
6
        contaminated = []
7

8
        for q in test_questions:
9
            # 1. n-gram 重叠检测
10
            overlap = self._ngram_overlap(train_doc, q)
11
            if overlap > 0.5:
12
                contaminated.append(q)
13
                continue
14

15
            # 2. 语义相似度
16
            sim = self._semantic_similarity(train_doc, q)
17
            if sim > 0.8:
18
                contaminated.append(q)
19

20
        return contaminated

1
class TransformerArchitectures:
2
    """Transformer 架构变体"""
3

4
    DECODER_ONLY = {
5
        'name': 'Decoder-Only',
6
        '代表': 'GPT, Llama, Mistral',
7
        '优势': '适合生成任务',
8
        '劣势': '不能同时看到完整上下文',
9
        '应用': '大多数现代 LLM',
10
    }
11

12
    ENCODER_ONLY = {
13
        'name': 'Encoder-Only',
14
        '代表': 'BERT, RoBERTa',
15
        '优势': '双向注意力',
16
        '劣势': '不适合生成长文本',
17
        '应用': '分类、检索',
18
    }
19

20
    ENCODER_DECODER = {
21
        'name': 'Encoder-Decoder',
22
        '代表': 'T5, BART, FLAN-T5',
23
        '优势': '输入输出分离',
24
        '劣势': '复杂、参数利用率低',
25
        '应用': '翻译、摘要',
26
    }

1
class LlamaBlock(nn.Module):
2
    """Llama 块"""
3

4
    def __init__(self, dim, n_heads, n_kv_heads=None, hidden_dim=None):
5
        super().__init__()
6
        n_kv_heads = n_kv_heads or n_heads
7
        hidden_dim = hidden_dim or 4 * dim
8

9
        # 1. RMSNorm
10
        self.attention_norm = RMSNorm(dim)
11

12
        # 2. Self-Attention (GQA + RoPE)
13
        self.attention = Attention(dim, n_heads, n_kv_heads)
14

15
        # 3. RMSNorm
16
        self.ffn_norm = RMSNorm(dim)
17

18
        # 4. SwiGLU FFN
19
        self.ffn = SwiGLU_FFN(dim, int(2/3 * 4 * dim))
20

21
    def forward(self, x):
22
        # 残差连接 + Pre-Norm
23
        x = x + self.attention(self.attention_norm(x))
24
        x = x + self.ffn(self.ffn_norm(x))
25
        return x
26

27

28
class LlamaModel(nn.Module):
29
    """完整 Llama 模型"""
30

31
    def __init__(self, vocab_size, dim, n_layers, n_heads, n_kv_heads=None):
32
        super().__init__()
33
        # 1. Token 嵌入
34
        self.embed_tokens = nn.Embedding(vocab_size, dim)
35

36
        # 2. Rotary Embeddings
37
        self.rotary = RotaryEmbedding(dim)
38

39
        # 3. N 个 Transformer Block
40
        self.layers = nn.ModuleList([
41
            LlamaBlock(dim, n_heads, n_kv_heads)
42
            for _ in range(n_layers)
43
        ])
44

45
        # 4. 最终 Norm + 输出
46
        self.norm = RMSNorm(dim)
47
        self.lm_head = nn.Linear(dim, vocab_size, bias=False)
48

49
        # 5. 权重共享
50
        self.lm_head.weight = self.embed_tokens.weight
51

52
    def forward(self, input_ids):
53
        x = self.embed_tokens(input_ids)
54

55
        for layer in self.layers:
56
            x = layer(x, self.rotary)
57

58
        x = self.norm(x)
59
        return self.lm_head(x)

1
LLAMA_CONFIGS = {
2
    'Llama-7B': {
3
        'dim': 4096,
4
        'n_layers': 32,
5
        'n_heads': 32,
6
        'vocab_size': 32000,
7
    },
8
    'Llama-13B': {
9
        'dim': 5120,
10
        'n_layers': 40,
11
        'n_heads': 40,
12
    },
13
    'Llama-65B': {
14
        'dim': 8192,
15
        'n_layers': 80,
16
        'n_heads': 64,
17
    },
18
    'Llama-3-8B': {
19
        'dim': 4096,
20
        'n_layers': 32,
21
        'n_heads': 32,
22
        'vocab_size': 128000,
23
    },
24
    'Llama-3-405B': {
25
        'dim': 16384,
26
        'n_layers': 126,
27
        'vocab_size': 128000,
28
    },
29
}

1
# Kaplan 2020 早期发现
2
KAPLAN_LAW = """
3
固定计算预算下:
4
- 大模型 + 少数据 比 小模型 + 多数据 好
5
- 但只看模型大小是不够的
6
"""
7

8
# Chinchilla 2022 修正
9
CHINCHILLA_LAW = """
10
固定计算预算下:
11
- 模型 和 数据 应该同比增长
12
- 最优比例 ≈ 20 token/参数
13
"""
14

15
# Llama 3 (2024) 实践
16
LLAMA3_APPROACH = """
17
训练了 405B 模型，超 15T tokens
18
虽然 Chinchilla 说应该 8T tokens
19
但高数据量在下游表现更好
20
"""

1
# 给出固定的计算预算，最优的 (模型大小, 数据量)
2
def optimal_compute_budget(compute_budget):
3
    """计算最优配置"""
4
    # Chinchilla 公式
5
    # C ≈ 6 N D
6
    # L 是 N 和 D 的函数
7

8
    # 近似计算
9
    a, b = 0.34, 0.28
10
    A = 406.4
11
    B = 410.7
12
    E = 1.69
13

14
    # 由 C = 6ND 给出 N 和 D
15
    # 假设 C = compute_budget
16
    C = compute_budget
17

18
    # 数值求解
19
    N = (C / (6 * 20)) ** 0.5  # 20 tokens/param
20
    D = 20 * N
21

22
    return N, D

1
class ScalingExperiment:
2
    """Scaling 实验管理"""
3

4
    def __init__(self):
5
        self.results = []
6

7
    def run(self, model_sizes, compute_budgets):
8
        """运行 Scaling 曲线"""
9
        for compute in compute_budgets:
10
            for size in model_sizes:
11
                # 训练模型
12
                model = train_model(size, compute)
13

14
                # 评估
15
                loss = evaluate(model)
16

17
                self.results.append({
18
                    'compute': compute,
19
                    'model_size': size,
20
                    'loss': loss,
21
                })
22

23
        # 拟合 Scaling Law
24
        params = fit_scaling_law(self.results)
25
        return params

1
┌──────────────────────────────────────────────────────────────┐
2
│                  LLM 训练集群                                │
3
├──────────────────────────────────────────────────────────────┤
4
│                                                               │
5
│  ┌─────────────────────────────────────────────────────┐    │
6
│  │           ZeRO / FSDP (内存优化)                     │    │
7
│  │   Model + Optimizer states 分片到所有 GPU           │    │
8
│  └─────────────────────────────────────────────────────┘    │
9
│                                                               │
10
│  ┌─────────────────────────────────────────────────────┐    │
11
│  │      Tensor Parallel (张量并行)                       │    │
12
│  │   单层切分到 8/16 个 GPU                             │    │
13
│  └─────────────────────────────────────────────────────┘    │
14
│                                                               │
15
│  ┌─────────────────────────────────────────────────────┐    │
16
│  │      Pipeline Parallel (流水线并行)                  │    │
17
│  │   不同层在不同的 GPU 组上                            │    │
18
│  └─────────────────────────────────────────────────────┘    │
19
│                                                               │
20
│  ┌─────────────────────────────────────────────────────┐    │
21
│  │      Data Parallel (数据并行)                        │    │
22
│  │   不同的数据批次到不同 GPU                           │    │
23
│  └─────────────────────────────────────────────────────┘    │
24
│                                                               │
25
│  ┌─────────────────────────────────────────────────────┐    │
26
│  │           节点间: InfiniBand / NVLink               │    │
27
│  │           节点内: NVLink / PCIe                     │    │
28
│  └─────────────────────────────────────────────────────┘    │
29
│                                                               │
30
└──────────────────────────────────────────────────────────────┘

1
class DataParallel:
2
    """数据并行"""
3

4
    def setup(self, model, n_gpus=8):
5
        # 复制模型到每个 GPU
6
        replicas = [copy(model) for _ in range(n_gpus)]
7

8
        # 每个 GPU 处理不同的数据批次
9
        # 梯度同步（all-reduce）
10

11
    def step(self, batch_id, gpu_id):
12
        # 在 GPU gpu_id 上处理批次 batch_id
13
        loss = replicas[gpu_id].forward(batch[batch_id])
14
        loss.backward()
15

16
        # 同步梯度
17
        all_reduce(gradients)
18

19
        # 同步更新
20
        replicas[gpu_id].step()

1
class MixedPrecisionTraining:
2
    """混合精度训练"""
3

4
    def __init__(self, model, optimizer):
5
        self.model = model
6
        self.optimizer = optimizer
7
        self.scaler = GradScaler()
8

9
    def step(self, batch):
10
        # 1. 前向 (autocast FP16/BF16)
11
        with autocast():
12
            output = self.model(batch)
13
            loss = compute_loss(output)
14

15
        # 2. 反向
16
        self.scaler.scale(loss).backward()
17

18
        # 3. 优化器步骤
19
        self.scaler.step(self.optimizer)
20
        self.scaler.update()

1
class GradientAccumulation:
2
    """梯度累积"""
3

4
    def __init__(self, accumulation_steps=8):
5
        self.accumulation_steps = accumulation_steps
6

7
    def step(self, batch_id, total_batches):
8
        # 等效 batch_size = accumulation_steps * micro_batch_size
9

10
        loss = model_forward(batch)
11
        loss = loss / self.accumulation_steps
12
        loss.backward()
13

14
        if (batch_id + 1) % self.accumulation_steps == 0:
15
            optimizer.step()
16
            optimizer.zero_grad()
17

18
class GradientCheckpointing:
19
    """梯度检查点"""
20

21
    def forward(self, x):
22
        # 不保存中间激活值
23
        # 反向时重新计算
24
        with checkpoint:
25
            return self._forward(x)

1
class AdamW:
2
    """AdamW - 主流 LLM 优化器"""
3

4
    def __init__(self, params, lr=1e-4, betas=(0.9, 0.95), weight_decay=0.1):
5
        self.params = params
6
        self.lr = lr
7
        self.beta1, self.beta2 = betas
8
        self.weight_decay = weight_decay
9

10
        # 一阶、二阶动量
11
        self.m = [torch.zeros_like(p) for p in params]
12
        self.v = [torch.zeros_like(p) for p in params]
13

14
    def step(self):
15
        for i, p in enumerate(self.params):
16
            # 权重衰减（解耦）
17
            p.data.mul_(1 - self.lr * self.weight_decay)
18

19
            # 梯度
20
            g = p.grad
21

22
            # 动量更新
23
            self.m[i] = self.beta1 * self.m[i] + (1 - self.beta1) * g
24
            self.v[i] = self.beta2 * self.v[i] + (1 - self.beta2) * g ** 2
25

26
            # 偏差修正
27
            m_hat = self.m[i] / (1 - self.beta1 ** self.t)
28
            v_hat = self.v[i] / (1 - self.beta2 ** self.t)
29

30
            # 参数更新
31
            p.data -= self.lr * m_hat / (torch.sqrt(v_hat) + self.eps)