从零手写微型Transformer：大模型构建全流程实战

1. 从零构建 LLM 的整体思路：不要只做调包侠

过去两年我身边不少同事、朋友都在聊大模型，但大多数人的“理解”停留在调 API、写 Prompt、套 LangChain 这个层面。不是说这不对，而是如果你想真正理解大语言模型，总有一天你会发现，浮在表面是不够的：为什么这个模型回答会崩？为什么同样的数据别人训练出来效果更好？为什么加大 batch size 会 OOM？这些问题的答案，全藏在模型的构建细节里。

我当时给自己定的目标很简单：从零开始，不靠现成的大模型框架，纯粹用基础组件手写一个微型 Transformer，然后在这个基础上训练出一个能对话、能写短句的模型。整个过程相当于“自己造一遍轮子”，虽然轮子造得糙，但造完之后再去看主流模型的架构、论文、技术报告，很多以前看不明白的地方会突然通透。

这篇文章想分享的就是那条我从零走下来的路线图，内容覆盖了模型结构、分词、数据配比、训练策略、对齐技巧，以及一路上必然会踩的坑。适合下面这类人：还没完全理解 Attention 机制但想彻底搞懂 LLM 的开发者；已经会调用大模型 API 但不满足于“黑盒”的技术人；或者正在做小型 LLM 训练、微调，想提升自己对模型控制力的同学。如果你是零基础，也没关系，我会尽量把每一步的“为什么”也讲清楚，而不是只给结论。

一定要说“从零构建”的意义，大概率不只是为了造一个小模型出来自嗨，而是通过这个过程获得一种更底层的能力：当别人还在试 Prompt 的时候，你已经可以直接从权重角度判断模型行为，这是完全不同的level。

2. 核心组件拆解：大模型躯干里的每一个关键零件

2.1 Tokenizer 是大楼的“砖块生产线”

严格来说，训练大模型的第一步不是搭模型，而是做分词。你给模型喂进去的都是原始文本，但模型处理的是 token。Tokenizer 的作用就是把文本切成 token，再把 token 映射成数字 ID。这里有一个很多人会忽略的细节：可训练模型中的词汇表大小、分词规则，直接决定了模型的记忆容量和泛化能力。

我选择的是 BPE（Byte Pair Encoding，字节对编码）方案。BPE 的核心逻辑非常朴素——统计字符串里高频出现的相邻字符对，把它们合并，然后不断迭代合并直至达到目标词表大小。比如 “low” 和 “lower” 这两个词，在 BPE 的词表里很可能共享前缀 “low”，从压缩效率来看，这就是一种聪明的方式。为了让分词器对中文也友好，我用了字符级 BPE，避免直接按字切割导致信息密度过低。

构建 BPE 词表时有几个参数很关键：词表大小、最小频率阈值、是否区分大小写。我实测下来，在中文场景下词表大小在 8000～16000 这个区间是性价比比较高的。太小，句子会被切得很碎，模型要学更长的依赖；太大，embedding 层的参数量会暴涨，对小模型来说很亏。你在构建自己的 Tokenizer 时，可以用你手头语料的 pre-tokenization 统计结果来倒推词表大小，而不是拍脑袋定。

另一个容易踩坑的地方是：训练 Tokenizer 的语料和训练模型的语料最好是一致的，不要混用。如果分词器是从代码语料学出来的，你去喂大量中文新闻，很多词会碎成细小的 token，导致上下文长度被无谓拉长，效果打折扣。

2.2 Embedding：把 token ID 变成模型能“理解”的向量

Embedding 层本质上是一个可学习的查表操作。词汇表里每个 token 对应一个固定维度的向量，比如 GPT-2 用的是 768 维，我的实验模型用 512 维。这个维度不是随便选的，它受模型总参数量、层数、头数共同约束，也决定了模型能承载的信息上限。

有一个大致经验：embedding 维度与 Transformer 隐藏层维度（d_model）保持一致。如果你的隐藏维度是 512，embedding 输出也应该是 512。这样做的好处是后续各层之间可以直接做残差连接，不需要额外的维度投影层，省参又省计算。我在设计实验时试过 embedding 128、隐藏层 512 的方案，结果模型收敛速度明显变慢，因为输入空间和内部表示空间不一致，需要额外的映射来“翻译”，这种不一致会浪费训练效率。

另外需要注意：embedding 层的参数量等于 vocab_size × d_model。一个小模型如果词表已经 32000，d_model 512，单 embedding 层就是 1600多万参数，这在总参数量只有一两亿的模型里占了相当大的比例。所以很多现代模型的词表大小都控制在 32K～64K 之间，不是没有道理的——压缩词表，就是压缩参数，也是变相提高数据利用效率。

2.3 多头注意力机制：模型如何“看到”上下文中的关键信息

Attention 是 Transformer 的灵魂。它的本质可以理解为：给序列中每个 token 一个“查询”，然后通过点积计算与所有其他 token 的“键”的相似度，再用 softmax 变成权重，最后按权重加权“值”向量，得到新的表示。

用生活化的类比来解释：

你在读一句话“小明因为考了满分，所以被老师表扬了”，当你读到“表扬”这个词时，你的目光会不自觉去回看前面的“满分”，Attention 机制干的就是这件事——它让每个位置都能根据语义相关性，主动决定“注意力”分配给哪些其他位置。

不同头的作用也不同：有的头负责关注句法关系，有的头负责关注共指关系，有的头甚至专门跟踪句号、逗号这些位置。多头设计的意义就在于让模型并行学习多种注意力模式，而不是只学到一种全局平均的模式。

我做实验时用的是 8 头注意力，每头维度 d_k = 64，这样 8×64=512，刚好等于 d_model。这个结构参数的选择几乎是工程上的“黄金分割”：头数太少，不同注意力模式的学习容量不够；头数太多，单个头的维度太小，表达能力受限。如果你自己设计模型，建议在 d_model 一定时，让 d_k 保持在 32～128 之间，这是实践下来比较稳的区间。

然后就是注意力计算中必不可少的位置编码。由于 Attention 本身是“顺序无关”的，token 调换位置后计算结果完全一样，所以必须加入位置信息。这里我用的是 RoPE（旋转位置编码），现在主流模型几乎都用它。RoPE 的核心思路是把位置信息编码成旋转角度，注入到 Q 和 K 向量的内积计算中，让内积结果天然依赖相对位置——注意是相对位置，不是绝对位置。这就比旧式的绝对位置编码（sinusoidal）更灵活，外推性也更友好。

2.4 前馈网络与归一化：直觉与非线性能力的来源

每个 Transformer 块里，Attention 之后会接一个 MLP 层，通常包含两个线性和一个 GELU / SwiGLU 激活函数。Attention 的作用是“选择”信息，MLP 的作用是“加工”信息。如果把 Attention 比作会议主持人，让各人发言并汇总观点，那 MLP 就是各个专家待在独立办公室，把拿到手的信息深度消化，产出更抽象的判断。

这个 MLP 层的中间维度设计有讲究。最早 GPT-2 用 4×d_model，后来 LLaMA 家族普遍用 2.67×d_model 左右的扩展比，配合 SwiGLU 激活函数。SwiGLU 相比 GELU 的改进在于它引入了一个门控机制，相当于对每个维度的信息进行一个可学习的“闸门”控制。我实测下来，SwiGLU 在小模型上的收益也明显，收敛更平滑，最终 loss 更低，而且几乎没有额外推理开销。

LayerNorm 的位置也值得说。很多初学者会把 LayerNorm 放在 Attention 之前和之后的位置搞混。现代实现的通行做法是“Pre-LN”：先归一化，再过子层，最后残差相加。这比原始 Transformer 论文里的“Post-LN”训练更稳定，对大学习率更宽容。我自己用梯度累积、大 batch 训练时，Pre-LN 几乎不担心梯度爆炸的问题，而 Post-LN 则要小心翼翼调 warmup。

2.5 KV Cache 与推理优化：训练出来的模型还要用起来爽

训练完成后进入推理阶段，如果你直接用训练时的方式逐 token 生成，会重复计算之前的 Key 和 Value 向量——这非常浪费。工程上几乎无一例外会用 KV Cache：缓存已经计算过的历史 token 的 K 值、V 值，后续生成新 token 时只增量计算，时间复杂度从 O(n²) 降到 O(n)。

这里要注意一个内存消耗公式：

KV Cache 内存 ≈ 2 × 层数 × 头数 × d_k × 序列长度 × 字节数

举个例子：12 层模型，8 头，d_k=64，序列长度 2048，用 FP16，那么每个 token 需要 2×12×8×64×2=24576 字节。2048 个 token 就是约 48MB。这在单个推理请求里已经很夸张了。如果还要并发处理多个用户，KV Cache 会成为显存的主要消耗者。这也是为什么 GQA（分组查询注意力）近两年会成为主流——多个头共享 K/V，在保持效果的同时砍掉大量缓存。

我在实际部署一个简单文本生成服务时，用 KV Cache 之后单次推理 latency 降低了 37% 左右，显存占用也明显下降。这些优化就像把一辆组装好的车做调校，虽然不改变引擎性能，但直接影响驾驶体验。

3. 实操全流程：一步步搭出可训练的微型大语言模型

3.1 构建训练数据：规模、清洗与配比的艺术

很多人以为大模型训练的首要任务是堆 GPU，但真正动手之后你会发现，数据才是那条最粗的“大腿”。数据质量和数量，决定了模型能力的天花板，模型结构和训练技巧只是逼近这个天花板的手段。

我构建实验数据集时，主要用了三类数据：

• 通用文本：来自开源的中文语料，覆盖新闻、百科、书籍，负责给模型“通识”能力；
• 代码与结构化文本：代码文件、JSON、Markdown，负责培养模型的逻辑推理和格式遵循能力；
• 指令对话对：人为构造的指令-回答对，负责让模型学会“听话”。

三部分的配比大概是 6:2:2。这个比例不是我拍脑袋来的，而是参考了主流开源模型数据配比的经验。你会发现代码数据虽然量不大，但对提升模型的推理能力贡献显著。如果把所有数据混在一起直接训练，模型会丢失重点，所以真实项目里要先按 domain 做数据配比，而不是简单堆料。

文本清洗阶段有几个细节，你可能会觉得琐碎但至关重要：

• 去掉 HTML 标签、乱码字符、URL 残留；
• 统一全角半角字符，特别是中文引号、逗号；
• 处理连续空白字符，避免让 Tokenizer 学到无意义的高频模式；
• 按质量分数过滤：可以用一个简单的长度统计 + 重复率检测，重复度过高的文档直接丢弃。

数据清洗完成后要检查一组核心指标：总 token 数、每个文档的平均 token 长度、词表覆盖率。如果平均长度过短，说明语料碎片化严重，模型学不到长程依赖；如果词表覆盖率不升反降，说明词汇分布不均，要考虑补充对应领域的语料。

3.2 模型架构设计与参数量估算

在设计微型大模型时，我参考了 GPT-2 与 LLaMA 的混合架构，参数设定如下：

参数量估算可以这样算：Embedding 层 16000×512=819万；12 层每层包含 Attention 和 MLP 两部分，Attention 参数量约 512×512×4=105万，MLP 约 512×(512×2.7)×2≈141万，每层合计约 246万，12 层约 2952万；最后加输出层约 819万。总计大概在 4600万参数左右。这个规模单张消费级显卡就能训练，非常适合做实验。

有一个规律值得记住，大约是“8000 倍规则”：一个 d_model=512 的模型，总参数大约在 40M～90M 区间。而观察主流模型时会发现 d_model=4096 的模型参数在 7B 左右，d_model=8192 的模型参数在 70B 级别。这种缩放规律对你去判断一个陌生模型的总参数量非常有用。

3.3 训练过程中的关键技巧：loss 不是唯一指标

训练过程是这场实验最磨人的阶段。loss 曲线并不总是平滑下降的，尤其在 wamrup 阶段之后，loss 会出现一个回落再上升的“v型谷”，很多人会误以为训练出了问题，其实这是学习率迈过高位后的正常调整。

我这里分享一套比较稳妥的训练流程：

1. 先用 100 step 跑一个 smoke test，确认前向和反向通路能够跑通，loss 在可见范围内下降。
2. 开启正式训练时，设置 warmup steps 为总步数的 10%，峰值学习率用 3e-4（对 d_model=512 的模型来说，这个量级很安全）。
3. 使用梯度裁剪，max_grad_norm 设为 1.0。这一步几乎必做，尤其是你动了学习率或者 batch size 之后，梯度爆炸是隐藏风险。
4. 每 500 步记录一次 loss 和梯度范数，观察梯度范数是否在稳定范围内，如果持续上涨，优先降低学习率。
5. 每 2000 步做一次生成测试，直接把最朴素的 prompt 输入模型，看输出的文本连贯性，比 loss 数值直观得多。

我实际遇到的一个有趣现象：loss 降到了 2.7 附近之后，生成结果看起来还是“像模像样但语义完全错乱”。当时把我困惑了很久，最后发现是数据集里混入了大量重复和无意义的模板文本。清理数据后，同样的 loss 水平下生成质量明显提升。这说明 loss 低并不等于数据好，评估生成质量必须结合人工判断。

3.4 对齐与微调：从“会说话”到“会听话”

基座模型训练完成后，模型只会做“文本续写”，远谈不上听话。你问它“1+1等于几”，它很可能跟你继续聊出几句不相关的话。此时需要做指令微调（SFT），用大量指令输入-标准输出对，教会模型“理解指令并给出答案”的交互模式。

构建 SFT 数据时，优先级是这样的：质量 > 数量。我手头整理了几千条指令数据，但每条都是逐条打磨过的，覆盖了问答、写作、摘要、翻译、代码生成等大类。微调时用较低学习率（1e-5 到 2e-5），冻结底层几层，只微调高层——这里有个经验：底层特征更通用，适合冻结；高层特征更任务相关，适合更新。这样做既省显存，又能保持模型原有的通用能力不退化。

如果你连 SFT 都不需要，只是想让模型更符合某种口味，可以尝试轻量微调方法（比如 LoRA）。它的本质是在原有权重旁并联低秩矩阵，训练时只更新低秩矩阵，参数效率极高。但要注意：LoRA 的秩（rank）不要选太大，8～16 之间通常表现最好；选太大反而容易过拟合，选太小则表达能力不足。

对齐阶段我想额外提一步：RLHF 能不做就不做，至少不要在小模型上做。小模型本身能力有限，强行对齐反而可能“对齐过头”，出现复读机现象或者政治正确的废话。如果你要的是能跑通的实验流程，SFT 已经足够。

4. 常见问题与调试方法：训练大模型的真实摔打记录

4.1 Loss 不降怎么办

这是我被问到最多的问题，也是最让人抓狂的。排查思路按照可能性从高到低：

1. 数据问题：文本太长被截断导致信息缺失，或 label 错位导致模型学不到正确预测。我建议先检查数据的 token ID 与 label 是否严格对齐。
2. 学习率问题：学习率太低模型几乎不动，太高容易震荡甚至发散。对比实验最直接，把 lr 调成原来的 5 倍看 loss 是否下降，再调回。
3. 模型初始化问题：不是所有初始化都适合 deep model。我用的是均值为 0、标准差 0.02 的正态分布初始化，并手动设置了残差层的 scaled 初始化。这一步对几十层模型尤为关键。
4. 梯度消失/爆炸：加梯度裁剪，检查梯度范数是不是长期为 0 或无穷大。

排查时记住一个原则：一次只改一个变量，不要同时动多个超参，否则永远找不到归因。

4.2 显存 OOM：不是让你买卡，是让你省卡

训练没有显存的话，只能从工程上想招。我常用的降显存手段：

• 梯度累积：把小 batch 拆成多步累积，等效于大的有效 batch，但每步只保存一个小 batch 的中间激活。
• 混合精度训练：FP16 或 BF16。但要注意 FP16 的精度范围窄，容易出现 inf，使用前要用 loss scaling 保护。
• 激活检查点：以少量计算换显存。它把中间激活丢弃，反向传播时又重新计算一遍。
• 减少 sequence length：如果数据平均长度 512，你硬塞到 2048，不仅显存翻四倍，训练效率也低。

有个隐藏很深的 OOM 原因：KV Cache 在推理阶段不加限制地增长，会把显存慢慢吃掉。服务端要做长度限制或者 KV Cache 量化，不然跑一晚上服务就挂。

4.3 模型生成内容重复、套话、死循环

很多初学者以为这是没训练好，其实更多是“采样策略”的问题。生成阶段如果用贪心解码（greedy decoding），模型会倾向于选择概率最大的 token，结果就是陷入重复的循环。解决办法：

• Temperature 调高一点，比如 0.7～0.9，概率分布更平滑，增加多样性。
• Top-p（nucleus sampling）截断：只从累计概率超过 p 的 token 里采样，默认设 0.9 比较稳。
• Repetition Penalty：对已经出现过的 token 做降权，能很直接地打击复读机现象。

采样参数本身不是越多越好，高 temperature + 高 top-p 容易让输出变得散乱。比较稳的搭配是 temperature=0.8、top_p=0.9、repetition_penalty=1.1，这是我的默认起点，具体再按任务微调。

4.4 训练效率低、显存利用率不稳定

做实验时我发现一个现象：GPU 利用率忽高忽低，后来排查发现是数据管线的问题——CPU 做 tokenize 的速度跟不上 GPU 的消费速度，导致 GPU 长时间 idle。解决办法是采用 DataLoader 的 prefetch 机制，或者预先 tokenize 好存入二进制文件，训练时直接读。另外一个常见原因是频繁的 checkpoint 保存，每 500 步存一次虽然稳妥，但保存动作会阻塞训练主流程。建议用异步保存线程，或者隔 2000 步再存一次。

显存利用率不稳定，还可能是 batch size 没吃满单卡显存。我优化显存之后，把 batch size 增大了一倍，有效加速了训练，几乎没有额外耗时。GPU 显存这东西，要么全用，要么根本别开，这是训练加速的最简单杠杆。

5. 一个完整的端到端实验记录

这一节把我的实验细节完整贴出来，方便你自己复现和参考。

训练环境：

• 单卡 24GB 消费级 GPU
• PyTorch（FP16 混合精度）
• 数据总计约 1.2GB 清洗后文本，token 化后约 18亿 token（实验里实际用了其中约 5 亿）

训练配置：

• batch size：32，梯度累积 4 步，等效 batch 128
• 优化器：AdamW，β=(0.9, 0.95)，eps=1e-8
• 学习率：峰值 3e-4，cosine 衰减到 3e-5
• warmup：1000 步
• 训练总步数：约 50000 步（约 2 个 epoch 不到）

训练时间大概 3 天左右，最终验证集 loss 在 2.53 左右。这个数字到生成质量是什么概念呢？拿它来续写中文句子已经比较流畅了，但多轮对话仍然经常逻辑断裂——基本符合这个参数规模和数据集量级的正常水平。

如果你想让模型变得实用，至少要做到 SFT 这一步。SFT 使用了大约 8000 条高质量指令，训练了 5 个 epoch，学习率降到 1e-5。微调之后，模型已经具备基础的问答能力，像是“解释什么是原子”、“写一封请假邮件”这类指令都能完成，但遇到复杂推理和多步指令还是会“胡言乱语”。

这个结果恰恰说明了几个真实的大模型规律：

• 模型尺寸和数据量是硬约束。小模型可以“理解”语言，但常识容量和推理深度有限。
• 对齐阶段可以极大改善交互体验，但不会补上模型的固有缺陷。
• 从零构建的价值，在于你能精确知道模型能力的边界来自哪里，而不是笼统说“这个模型不行”。

6. 后续还能往哪里走

做完这个实验之后，你会发现自己对大模型的“手感”完全不一样了。再读技术博客、看模型报告时，不再只是感叹参数大，而是会说“哦，这个设计是为了缓解某个训练问题”“这个数据配比参考了之前开源社区的做法”。这种从欣赏者变成参与者的转变，是我觉得最值得的一点。

如果你想继续深入，建议按下面的路径走：

1. 用同样的数据流程，把参数量从四千多万扩展到 3 亿左右，观察量化后的能力变化——这会让你直观感受参数量与能力间的非线性关系。
2. 自己动手做一下继续预训练：在基座模型上注入某个垂直领域的数据（比如医疗问答、法律文书），对比注入前后的能力变化，理解领域适配的全过程。
3. 研究 MoE（混合专家）架构：把前馈网络换成多个并行的“专家”网络，并加一个 router 做 token 级分流。这个方向是当前大模型扩展性的核心方向之一，用一个小 MoE 模型去对比同等稠密模型，是很好的进阶实验。
4. 关注推理阶段的极致优化：量化（INT8/INT4）、投机采样、page attention。这些优化能显著降低服务成本。

从零构建小模型的意义，不在于“我也有个大模型了”，而在于每一次踩坑、每一条经验，都让你对大模型技术栈有了别人不具备的深度理解。动手做一次的效果顶得上读十篇综述，这也是我推荐每个对 LLM 感兴趣的人，都应该尝试走一遍这条路的原因。

最后分享一个我在实验过程中发现的非常实用的调试技巧：保持一个几万条数据的小型验证集，每次修改模型结构、损失函数、采样策略前，先跑一遍这个小验证集，观察输出变化。这比盯着 loss 曲线直观得多，也是很多开源项目里高频使用的做法，但极少写进文档里，希望这个经验对你有帮助。