mini-LM 实战:把第四、五部分跑起来

# ① 下载公版原文(繁体 UTF-8,公有领域,可自由使用)
curl -O https://www.gutenberg.org/cache/epub/23950/pg23950.txt      1

# ② 用仓库自带 tools/clean_text.py --keep-non-ascii 去 Gutenberg 页眉页脚
#    (许可证、制作人员信息混在正文里,不洗掉模型会学这些废话)      2

# ③ OpenCC 繁转简(t2s):「三國志演義」→「三国志演义」               3

# ④ 字符集收敛:只保留 汉字 + ，。 + 换行                             4
#    结果:571,567 字,3,981 个不同字符(汉字 ≈ 3978 + 3 个符号)

1. 公版书没有版权问题,这是选它的第一理由;顺带它文体统一、量够大。
2. 页眉页脚里全是英文许可证,留着只会污染词表和学习信号。
3. 繁简混排等于把"国"和"国"学成两个字,平白浪费本就可怜的参数。
4. 为什么只留三种符号?字符级模型的词表大小 = embedding 行数 = 输出层宽度:每多一个稀有符号(花引号、【】、装饰符……),词表大一圈、小模型更难学,还会被极少数病态字符拖累 softmax。换行符单独保留——它就当段落/句子的边界,模型能学会"换行之后另起一段"。

./bin/mini_lm init --model sanguo.param --corpus-file sanguo_clean.txt \
  --tokenizer utf8-char \                                              1
  --model-dim 128 --head-num 4 --feed-forward-dim 512 \
  --block-num 4 --context-size 48 --rand-seed 42                     2

$ ./bin/mini_lm info --model sanguo.param
Tokenizer: utf8-char
Vocab size: 3981
Vocabulary: [第] [一] [回] [宴] [桃] [园] [豪] [杰] [...               3

1. utf8-char:一个汉字一个 token。若用默认字节级,一个汉字会被拆成 3 个 UTF-8 字节,模型要先学会"拼字节"才能谈语言,白白浪费容量。另外还有词级 --tokenizer word,那是给英文语料准备的。
2. 这些就是下一节要逐一拆解的 Config 字段;rand-seed 让初始化可复现。
3. 注意词表编号顺序:框架的分词器是“首次出现即编号”——语料开头是《第一回宴桃园豪杰三结义》,所以「第」拿 0 号、「一」拿 1 号……这带来一个副作用:两个模型的词表不能互换,模型文件只能绑定自己那份词表。

// ① 扫语料建词表:见过的跳过,新字符分配下一个 id(首次出现顺序)
for (char ch : text) {
  if (char_to_id.count(ch) != 0) continue;
  char_to_id[ch] = vocabulary.size();
  vocabulary.push_back(ch);
}                                                                  1

// ② 建 embedding 表并按 Xavier-uniform 随机初始化
const double limit = std::sqrt(6.0 / (vocab_size + model_dim));
std::uniform_real_distribution<double> dist(-limit, limit);       2

// ③ 存盘:结构+权重写 .param(二进制),字符表写 .param.vocab(纯文本) 3

1. 所以词表顺序就是"语料开头长什么样"的顺序(《三国演义》开头是「第一回宴桃园…」,故「第」拿 0 号);两个模型的词表不能互换,LoadModel 时会校验词表大小一致。
2. Xavier 均匀分布(第 9 章讲的初始化)按 rand_seed 可复现——同一个种子,两次 init 出来的模型一模一样。
3. 一个模型是两个文件,拷贝/备份必须成对;词表文件里还能看到 tokenizer 类型(utf8-char)。完整格式约定见 docs/mini-lm-demo.md。

vocab_size_       = 3981  // 汉字+，。+\n(扫语料得出,冻结)      1
model_dim_        = 128   // 每个 token 的向量维度               2
head_num_         = 4     // 多头注意力(第 17 章)               3
feed_forward_dim_ = 512   // Block 内 FFN 宽度(第 18 章)            4
block_num_        = 4     // 叠 4 层 Block                                 5
backbone_type_    = BACKBONE_DECODER  // causal mask,不能偷看未来  6
max_context_size_ = 48    // 上下文窗口:一次最多看 48 个字         7

1. 词表大小同时决定 embedding 行数和 LM 输出头宽度(第 19 章)。
2. model_dim 是信息流动的“管道宽度”,训练成本按平方增长——从 32 提到 128,每样本耗时大约贵 16 倍;真实大模型是几千。
3. 头数必须整除 model_dim(每个头均分维度,128/4 = 每头 32 维)。
4. FFN 隐藏宽度,惯例取 model_dim 的 4 倍左右。
5. 每多一层 Block,能力和耗时同涨;Block 数量直接决定“深度”。
6. decoder 带 causal mask(第 17、18 章),每个位置只能看左边,正是生成式模型要的。
7. 生成时只喂最近 48 个字(实现里叫 CalcNextTokenLogits:超长就裁尾部窗口),让位置编码始终落在训练见过的范围内。

CharacterDataset::RC CharacterDataset::BuildNextTokenSamples(
    std::vector<std::vector<int>> &input_samples, std::vector<int> &target_tokens) {
  // ... 校验略 ...
  for (int i = 0; i + context_size_ < (int)token_ids_.size();
       i += sample_stride_) {                                  1
    input_samples.push_back(std::vector<int>(token_ids_.begin() + i,
                            token_ids_.begin() + i + context_size_));
    target_tokens.push_back(token_ids_[i + context_size_]);   2
  }
  return SUCCESS;
}

1. 本次新增 set_sample_stride()+--sample-stride:步长 1 是逐字滑窗(旧行为,默认),设成 context_size 就是非重叠切块——GPT 预训练的标准做法。每个字每轮照样被预测一次,但样本数从 571,567 直接除以 48 变成 11,907,一个 epoch 从 7.6 天缩到 3.8 小时。
2. 每个样本 = 48 个字的上文 + 1 个"正确的下一个字"——这就是语言模型的"题目和答案"。

# 第一轮:3 epochs,batch 240(事后看是个错误决定,见第 5 节)
nohup ./bin/mini_lm train --model sanguo.param \
  --corpus-file sanguo_clean.txt --epochs 3 \
  --batch-size 240 --thread-num 24 --learning-rate 0.001 \
  --sample-stride 48 --progress-every-sec 300 > train.log 2>&1 &

# 第二轮:从 checkpoint 续训到总计 12 epochs,batch 降到 48
nohup ./bin/mini_lm train --model sanguo.param \
  --checkpoint sanguo.param.ckpt --resume-checkpoint \              1
  --corpus-file sanguo_clean.txt --epochs 12 \
  --batch-size 48 --thread-num 24 --learning-rate 0.001 \
  --sample-stride 48 --skip-final-eval > train2.log 2>&1 &          2

1. --resume-checkpoint 语义:--epochs 传的是目标总轮数,不是"再训几轮"——已完成 3 轮 + 目标 12 = 再训 9 轮。注意 checkpoint 只存权重、词表和训练轮数,不保存 Adam 的动量状态,恢复后优化器冷启动(短期 loss 可能小波动,教学项目可接受)。
2. --skip-final-eval:训练末尾默认会对全部样本再做一次全量评估(stride=1 的 57 万份,在这个里就是再白等几个小时),我们是"每轮看日志"党,直接跳过。

// ① 每个 batch 先给每个 worker 拷一份完整模型(含 Adam 状态)
for (int i = 0; i < worker_num; i++) workers.push_back(*this);  1

// ② worker 各领 batch 里的不同样本,并行做前向+反向,梯度各自累积
threads.emplace_back([order_pos = begin + worker_idx; ...
  workers[worker_idx].BackwardSample(sample, target, ..., true, ...);

// ③ 主线程合并所有 worker 的梯度,做一次 Adam 更新
AddAccumulatedGradientsFrom(workers[i]);                       2
ApplyAccumulatedGradients(epoch_lr, block_lr, 1.0 / batch_n);  3

1. 这是教学代码直来直去的代价:182 万参数 × 24 份拷贝,每个 batch 一次。真实框架会用共享只读权重 + 每线程梯度缓冲,这一节你可以想想怎么改。
2. 合并梯度 = 对位求和;等价于把 batch 里每个样本的梯度加起来。
3. 一轮 Adam 更新 = 第 8 章那一套(动量 + 二阶矩 + bias correction);学习率由 第 9 章的 WarmupCosineLR 逐轮给出:0.001 起步、1 轮 warmup、余弦退火到约 1.2e-4 收工。

// ① 前向:embedding 查表 ×√128 + 位置编码 → 4 层 decoder Block
EncodeSequence(sample, encoded);                                    1

// ② 对窗口里每个位置:3981 维 logits → softmax → 交叉熵
for (pos = 0..47) {
  logits[tok] = Σ output_weight[tok][d] · encoded[pos][d] + bias;  2
  probs = Softmax(logits);  loss += -log(probs[target[pos]]);      3
  grad_logits = probs;  grad_logits[target] -= 1;                  4
  grad_logits *= 1.0 / seq_len;   // 让 batch 内长短样本同权
}

// ③ 反向:梯度从输出头回传,穿过 4 层 Block 回到每个位置
decoder.BackwardAccumulate(grad_encoded, grad_hidden);             5
for (i, tok : sample) grad_embedding[tok][d] += grad_hidden[i][d]; 6

1. 查表 + 缩放 + 位置编码:embedding 行向量乘 √128,再按位置加正弦/余弦编码(第 17 章);然后依次过 4 层 Block(注意力→残差→LayerNorm→FFN→残差→LayerNorm,第 18 章)。
2. 一个 48 字样本要算 48 次"全词表 softmax"——这就是为什么词表收窄到 3981 仍然是大头开销。
3. 对每个位置取"正确的下一个字"的预测概率,−log 累加,就是第 4 章的交叉熵。
4. softmax + 交叉熵的梯度有个优雅的简化形式:预测概率减去 one-hot 答案(probs −1 于目标位),第 4 章推导过。
5. 梯度按"输出头 → Block 堆 → 位置"一路传回(第 6 章反向传播);Accumulate 版本只攒梯度不更新,留给 batch 合并。
6. embedding 的梯度按 token id 散射回对应行:同一个字在窗口里出现几次就累加几次,因此高频字的 embedding 被更新得最多。

ApplyAccumulatedGradients(epoch_lr, block_lr, 1.0 / batch_sample_num);
//  三个优化器实例分管输出头/embedding/各层 Block,
//  Adam 内部:动量 m、二阶矩 v、bias correction(第 8 章)           1

1. 注意 1.0 / batch_sample_num:合并的是平均梯度,batch 大小不会改变期望更新方向,只改变方差和步数——这又把第 4 节的"步数预算"串起来了。

Resumed checkpoint: completed_epoch=3 last_loss=6.24456 last_perplexity=515.201
epoch 4/12 sample 11136/11907 loss=5.99894 recent_loss=5.48098 samples/s=2.75 epoch_eta=4m40s 1
epoch 4/12 loss=5.96081 perplexity=387.922 recent_loss=5.42029 lr=0.000928564 elapsed=1h10m49s
Saved checkpoint: sanguo.param.ckpt completed_epoch=4                 2
...
epoch 12/12 loss=3.6166 perplexity=37.211 recent_loss=3.6063 lr=0.000118228 elapsed=7h32m0s
Saved updated weights: sanguo.param                                  3

1. 进度行:loss 是当前轮累计平均,recent_loss 是最近一段样本的滑动平均——后者更快反映"现在学得怎么样"。
2. 每个 epoch 完整跑完都会落盘一份 checkpoint,断电/Ctrl+C 都不至于从头再来。
3. 完训时权重写回模型文件(sanguo.param + .vocab 成对儿存在,缺一不可)。

auto probs = SoftmaxWithTemperature(logits, option.temperature_); 1
std::sort(order.begin(), order.end(),
          [&](int a, int b){ return probs[a] > probs[b]; });      2
if (option.top_k_ > 0) keep = min(keep, option.top_k_);          3
for (i...) { cumulative += probs[order[i]];
             if (cumulative >= option.top_p_) break; }           4
// 截断 → 重归一 → 在幸存候选里按归一后概率掷骰子                5

1. 温度先缩放 logits:T<1 拉大差距(更保守),T>1 拉平(更敢写)(第 19 章)。
2. 按概率从高到低排序整个词表(3981 个候选)。
3. top-k:只保留前 k 名。
4. top-p(nucleus):从头部累计概率,够到 p 就停——候选集大小随分布胖瘦自适应。
5. 幸存候选重新归一化后按概率抽取;三个参数可以任意组合,命令行上给一个就算采样模式。

# 贪心(不给任何采样参数)
./bin/mini_lm generate --model sanguo.param --prompt "话说天下大势" --generate-num 60

# 采样
./bin/mini_lm generate --model sanguo.param --prompt "孔明曰" \
  --generate-num 60 --temperature 0.7 --top-k 10

# 不传 --prompt:进入交互模式,输一句它接一句,空行/:q 退出      1

1. 三种模式都是逐字流式输出(每算出一个字就打印并 flush)——你在 ChatGPT 聊天框里看字一个个蹦出来,底层就是这种自回归循环,规模天差地别,机制分毫不差。