不是所有人都需要从零手搓一个神经网络但如果你真的想搞懂 AI 工程里那些“调参”、“过拟合”、“显存爆炸”到底是怎么回事从零开始把一个大语言模型造一遍是最快、也最扎实的路。这篇内容就是围绕“ai-engineering-from-scratch”这条学习路径展开的实操总结讲清楚为什么“从零构建”能解决“只会调库、不懂原理”的痛点也把整条路线里最核心的知识点、动手环节和踩坑经验一次说透。无论你是准备入行 AI 工程的新人还是已经在用 PyTorch 但总觉得基础不牢的开发者这篇都值得看完。1. 整体设计与思路拆解为什么“从零手搓”是最快的学习路径“ai-engineering-from-scratch”这个标题看着挺唬人其实核心就一件事不借助现成的训练框架和预训练权重从数学原理、数据处理、模型结构到训练推理一步步亲手实现一个可运行的语言模型。这个思路在国外技术社区很流行典型的代表就是 Sebastian Raschka 那本《Build a Large Language Model from Scratch》很多人跟着它从零写出了迷你版 GPT。这套路线之所以有价值是因为它把 AI 工程里最容易被“框架封装”掩盖掉的底层逻辑全部暴露了出来。1.1 这条路到底解决了什么问题市面上绝大多数 AI 相关教程都在教你怎么用 HuggingFace 加载模型、怎么用 Trainer 跑微调、怎么调用 API。这些内容本身没问题问题在于如果你只知道model AutoModel.from_pretrained(xxx)一旦遇到显存优化、自定义损失函数、分布式训练、模型推理性能调优这类工程问题就会完全无从下手因为你不清楚这行代码背后发生了什么。而从零构建一个模型相当于把整个过程“降维”成了几个可以逐个击破的环节数据怎么处理、词表怎么构建、注意力机制怎么算、梯度怎么回传、loss 怎么收敛。每一个环节都亲手写过之后再回头看那些封装好的工具你看到的就不再是黑盒而是一层熟悉的封装。到这一步才算是真正具备“AI 工程能力”而不仅仅是“会用 AI 库”。我自己带过不少新人一个很明显的规律是那些愿意花时间从零实现过 Transformer 的人后面上手分布式训练、量化部署、模型优化这些进阶内容速度明显快于只会调接口的人。原因很简单——底层机制清楚上层工具再怎么变本质都能看懂。1.2 和“直接调库”相比这条路的核心优势从零构建和直接调库本质上不是两种学习方法而是两种完全不同的认知深度。打个比方调库就像是开一辆自动挡汽车你只要会踩油门和刹车就能上路而从零构建像是亲手组装这辆车你要知道发动机怎么点火、变速箱怎么换挡、刹车油路怎么走。日常生活中自动挡当然够用但真出了故障、想改装、想优化性能懂机械原理的人才能动手。具体到技术层面从零构建的优势有三点第一对训练过程有完整的掌控感。你自己实现的数据加载、模型前向、loss 计算、反向传播每一步都是透明的出任何问题都能直接定位到具体环节而不是对着 PyTorch 的报错信息干瞪眼。第二对资源消耗有真实的感知。自己实现一遍就会发现一个 1 亿参数的小模型光 forward 一遍就要几百 MB 显存一个 batch 的数据要经过多少次矩阵乘法才能算出 loss。这种对计算量的“体感”是看文档永远学不来的。第三对模型结构有深入的理解。从零实现 Transformer 的时候你会被迫搞清楚 Q、K、V 三个矩阵到底怎么变换、多头注意力为什么要把头拆开、层归一化放在哪个位置、残差连接为什么能稳定训练。这些细节在大模型时代尤其重要因为现在所有主流架构——GPT、LLaMA、Mistral——都是在这个基础结构上演进的。提示如果你是纯新手不建议一上来就挑战复现完整的 LLaMA 或 GPT-4 级别的架构。最合理的起点是从一个微型 GPT参数量 1000 万以下开始跑通全流程再逐步加规模、加技巧、加优化。先把骨架搭起来再谈填肉。1.3 设计这条学习路线的底层逻辑“from scratch”不代表“从零开始学数学”——那是数学系的事。工程视角下的 from scratch指的是在已有编程和基础数学能力的前提下从零构建一个可用的 AI 系统。所以这条路线的设计逻辑是分层递进基础层是数学和编程原理层是模型架构工程层是训练与部署系统层是性能与扩展。每一层都是上一层的支撑跳级必然后面补课。这条路线和传统“先学理论再学应用”的路线最大的区别在于它把理论学习和动手实践牢牢绑在一起。你学完注意力机制的公式立刻就要把它写成代码你理解了交叉熵损失马上就要用它训练模型。每一个抽象的概念都有对应的代码实现和运行结果知识不再是悬空的而是落地可验证的。这种“学完即用”的节奏对工程思维的养成非常重要。2. 核心知识体系拆解数学、编程、深度学习缺一不可既然说“从零开始”那就绕不开基础知识的准备。很多人在这一步容易被劝退因为看到数学公式就头大。其实 AI 工程真正高频使用的数学并没有想象中那么多把关键部分吃透就够了不需要成为数学家。2.1 数学基础需要掌握到什么程度AI 工程里用得最多的数学知识可以浓缩成三块线性代数、微积分、概率统计。线性代数是整个深度学习的基石。矩阵乘法、向量点积、矩阵转置、矩阵求逆这些是最基本的操作。Transformer 里的注意力机制本质就是一组矩阵运算模型参数的存储和更新本质也是矩阵运算。你需要理解的是矩阵乘法的维度变化规律——这一点非常重要模型代码里 90% 的 bug 都出在维度对不上。微积分方面核心是导数和链式法则。反向传播算法就是链式法则的工程化应用从 loss 开始逐层往后求梯度每一层的梯度都依赖于前一层的输出。你不需要会手推复杂的偏导公式但必须理解“梯度是 loss 对参数的敏感性”这个直觉理解学习率为什么不能太大也不能太小。概率统计方面最常用的是概率分布、期望、交叉熵。语言模型本质上是在学习一个概率分布给定前文预测下一个 token 的概率。交叉熵损失函数直接对应“模型预测分布和真实分布的差异”。这些概念配合代码理解起来并不难关键是不要脱离代码枯看公式。实操建议学数学的时候每学一个公式都在 PyTorch 里用随机张量验证一遍。比如学完矩阵乘法就写几行代码看看(B, T, C)形状的张量乘(C, C)形状的矩阵输出变成什么形状。这种“代码验证公式”的习惯能把抽象的数学变成看得见摸得着的东西学习效率高好几倍。2.2 Python 与编程能力哪些是硬指标Python 是 AI 工程的第一语言需要掌握的程度比“能写脚本”要深一些。硬指标有这么几项熟练掌握numpy的基础操作尤其是数组的 shape 操作、广播机制、切片索引。很多数据预处理环节离了 numpy 寸步难行。熟练掌握 PyTorch 的核心 APItorch.Tensor、torch.nn.Module、torch.optim、torch.utils.data.Dataset和DataLoader。不需要背 API但要知道查文档的方向。理解 Python 的面向对象编程因为模型、层、数据集这些概念在代码里都是以类的方式组织的。会写简单的单元测试至少能自己验证数据预处理、词表构建这类工具函数是否正确。这些要求不算高但都是实打实的工程底线。如果你现在写 Python 还在靠复制粘贴改参数建议先花一两周把 Python 基础补扎实再开始 AI 工程路线不然后面会很痛苦。2.3 深度学习核心概念必须亲手实现一遍深度学习领域有一批“听起来懂、一写就废”的概念从零构建过程中必须逐个攻克张量多维数组是深度学习的基本数据结构。要理解 shape、dtype、device 三个属性理解在 CPU 和 GPU 上的区别。自动求导PyTorch 的核心能力之一。你只需要定义前向计算图框架会自动帮你算梯度。但从零构建时你要理解这个自动求导背后是链式法则在起作用理解为什么每个中间结果都要保留。模型层nn.Linear就是一次矩阵乘法加偏置nn.Embedding就是一个查找表nn.LayerNorm就是对最后一维做归一化。每一个看似高级的层拆开看都是基础运算的组合。激活函数ReLU、GELU、SiLU 这些函数的作用是给模型引入非线性。没有非线性多层线性变换叠在一起仍然等价于一层线性变换模型就没有表达能力。损失函数语言模型用的是交叉熵损失。要理解logits和target的维度关系理解为什么要在logits上做 log_softmax。优化器SGD、Adam、AdamW。要理解动量、学习率、权重衰减这些概念对训练的影响。实践中语言模型几乎都用 AdamW它把权重衰减和动量更新分开了效果好且稳定。训练循环一个标准的训练循环包括 forward → loss → backward → optimizer.step() → 梯度清零。看似简单但数据处理、batch 组织、梯度累积、学习率调度每一个细节都有讲究。这些概念如果只是看书很容易产生“我会了”的错觉。只有亲手把每个概念写成代码跑起来看到 loss 真的下降才算真正过关。2.4 从零构建的核心技术栈与工具选型工具链选择上第一推荐还是 Python PyTorch生态成熟、调试方便、社区资料多。具体到“from scratch”路线上有一批高频使用的核心库工具用途选择理由PyTorch深度学习框架自动求导、动态图机制、生态最全NumPy数值计算数据处理和原型验证的根基HuggingFace Tokenizers训练分词器高性能、易用支持 BPE 等主流算法Datasets数据加载处理大规模数据集支持流式加载TensorBoard / Weights Biases训练监控观察 loss 曲线和梯度分布定位训练问题PEFT / LoRA高效微调训练推理模型时大幅降低显存需求注意这里说的“from scratch”指的是不直接用现成的预训练模型权重而不是不能使用 PyTorch 这种基础框架。如果你真的连 PyTorch 都不用那复杂度就失控了——得先从写矩阵乘法库开始那就不是 AI 工程而是 AI 框架研发了。3. 实操全程实录从零构建一个微型语言模型理论说再多都不如动手写一个微型模型来得实在。这里我用一个完整的实操案例带你把“从零构建语言模型”走一遍。目标是构建一个参数量约 1000 万级别的微型 GPT在小型数据集上训练让它能生成看起来像模像样的文本。3.1 数据准备没有好数据模型就是空中楼阁训练一个语言模型第一步是准备训练语料。对于微型模型不需要用几十 TB 的巨型数据集选一个和模型容量匹配的小型纯文本语料即可。经典的入门选择是 TinyShakespeare——一个约 100 万字符的莎士比亚戏剧合集。这个数据集好处很多体积小CPU 上几十分钟就能完成训练语言风格鲜明很容易看出模型有没有学会东西字符级或词元级处理都方便适合验证全流程。如果你不想用现成数据集也可以自己准备找几本公版电子书合并成纯文本文件就行。关键是数据质量——编码统一用 UTF-8去掉多余空行和特殊符号保证文本干净一致。实操中数据处理的第一个环节是构建词表。词表是模型“认识”的所有 token 的集合。最简单的方案是字符级词表——每个字符对应一个 id。这种方案实现简单适合教学但真实项目中基本不用因为字符级建模序列太长、信息密度太低。实践中最低限度也要用 BPEByte Pair Encoding这类子词分词算法。BPE 的核心思想不复杂从字符级开始反复统计最频繁出现的相邻字符对把它们合并成一个新的 token直到词表达到预设大小。HuggingFace 的tokenizers库把这个过程封装得很好几十行代码就能训练出一个 BPE 词表。from tokenizers import Tokenizer from tokenizers.models import BPE from tokenizers.pre_tokenizers import Whitespace from tokenizers.trainers import BpeTrainer # 初始化一个 BPE tokenizer tokenizer Tokenizer(BPE(unk_tokenunk)) tokenizer.pre_tokenizer Whitespace() trainer BpeTrainer(vocab_size5000, special_tokens[unk, s, /s, pad]) # 在语料上训练词表 files [shakespeare.txt] tokenizer.train(files, trainer) # 保存词表便于复用 tokenizer.save(tokenizer.json)这段代码做了三件事定义 BPE 模型、指定预切分规则为空白切分、在语料上训练出 5000 词的子词词表。训练完成后tokenizer.json就是最终的词表文件后续训练和推理都要用同一个词表所以务必保存好。实操心得训练词表的时候语料要尽量和目标任务匹配。如果你的最终目标是让模型写代码就用在 GitHub 上爬的代码语料训练词表目标是写文章就用文章语料。词表和训练数据不匹配会直接导致分词效率低下模型学起来事倍功半。3.2 模型构建用代码实现一个微型 GPT接下来是核心环节——用 PyTorch 实现一个微型 GPT。这里不追求大而全只实现最必要的组件token 嵌入层、位置嵌入层、Transformer 解码器块、输出投影层。整个模型可以拆成几个模块来写嵌入层包括 token 嵌入和位置嵌入。token 嵌入是一个查找表形状是(vocab_size, d_model)位置嵌入给每个位置一个向量让模型知道 token 的顺序信息。GPT 用的是可学习的位置嵌入每个位置一个固定向量。Transformer 解码器块这是核心。每个块包含一个掩码多头自注意力机制、一个前馈网络以及两个层归一化和残差连接。掩码多头自注意力是整个模型最复杂的部分。它要做的计算是把输入序列的每个 token 映射成 Query、Key、Value 三个向量计算 Query 和所有 Key 的点积得到注意力分数再对分数做缩放和 softmax 归一化最后用归一化后的权重去加权求和 Value 向量。“掩码”指的是在计算注意力分数时把未来位置的分数设为负无穷这样当前 token 就只能看到自己和之前的信息看不到未来——这是生成模型的核心机制。下面是一个简化版的单头注意力实现方便理解核心逻辑import torch import torch.nn as nn import torch.nn.functional as F class CausalSelfAttention(nn.Module): def __init__(self, d_model, n_heads, dropout0.1): super().__init__() assert d_model % n_heads 0 self.d_model d_model self.n_heads n_heads self.head_dim d_model // n_heads # 统一用一个大矩阵计算 Q、K、V方便且高效 self.c_attn nn.Linear(d_model, 3 * d_model) self.c_proj nn.Linear(d_model, d_model) self.dropout nn.Dropout(dropout) def forward(self, x): B, T, C x.shape # batch size, 序列长度, 特征维度 # 计算 Q、K、V 并拆分成多头 qkv self.c_attn(x) # (B, T, 3*C) q, k, v qkv.chunk(3, dim-1) # 将最后一维拆成 (n_heads, head_dim) q q.view(B, T, self.n_heads, self.head_dim).transpose(1, 2) # (B, n_heads, T, head_dim) k k.view(B, T, self.n_heads, self.head_dim).transpose(1, 2) v v.view(B, T, self.n_heads, self.head_dim).transpose(1, 2) # 缩放点积注意力 att (q k.transpose(-2, -1)) * (self.head_dim ** -0.5) # (B, n_heads, T, T) # 因果掩码保证当前位置只能看到过去位置 mask torch.tril(torch.ones(T, T, devicex.device)).view(1, 1, T, T) att att.masked_fill(mask 0, float(-inf)) att F.softmax(att, dim-1) att self.dropout(att) y att v # (B, n_heads, T, head_dim) y y.transpose(1, 2).contiguous().view(B, T, C) # 合并多头 return self.c_proj(y)这段代码最值得关注的是因果掩码的实现方式先生成一个下三角矩阵然后把上三角部分全部填充为负无穷。这样 softmax 之后未来位置的权重趋近于零模型就“看不到”未来信息了。完整的 Transformer 解码器块还要包含前馈网络和层归一化。前馈网络通常是两个线性层加一个 GELU 激活函数层归一化放在注意力之前这就是 GPT-2 之后流行的 pre-norm 结构。整个块的写法如下class MLP(nn.Module): def __init__(self, d_model, expansion4, dropout0.1): super().__init__() self.fc1 nn.Linear(d_model, expansion * d_model) self.fc2 nn.Linear(expansion * d_model, d_model) self.gelu nn.GELU() self.dropout nn.Dropout(dropout) def forward(self, x): return self.dropout(self.fc2(self.gelu(self.fc1(x)))) class TransformerBlock(nn.Module): def __init__(self, d_model, n_heads, dropout0.1): super().__init__() self.ln1 nn.LayerNorm(d_model) self.attn CausalSelfAttention(d_model, n_heads, dropout) self.ln2 nn.LayerNorm(d_model) self.mlp MLP(d_model, expansion4, dropoutdropout) def forward(self, x): x x self.attn(self.ln1(x)) # pre-norm 残差连接 x x self.mlp(self.ln2(x)) return x最后把嵌入层、若干个 Transformer 块、输出投影层拼起来就成了微型 GPTclass MiniGPT(nn.Module): def __init__(self, vocab_size, d_model384, n_heads6, n_layers6, block_size256, dropout0.1): super().__init__() self.token_embedding nn.Embedding(vocab_size, d_model) self.position_embedding nn.Embedding(block_size, d_model) self.blocks nn.Sequential(*[ TransformerBlock(d_model, n_heads, dropout) for _ in range(n_layers) ]) self.ln_f nn.LayerNorm(d_model) self.lm_head nn.Linear(d_model, vocab_size, biasFalse) # 参数初始化对 embedding 层做缩放 self.apply(self._init_weights) def _init_weights(self, module): if isinstance(module, nn.Linear): nn.init.normal_(module.weight, mean0.0, std0.02) if module.bias is not None: nn.init.zeros_(module.bias) elif isinstance(module, nn.Embedding): nn.init.normal_(module.weight, mean0.0, std0.02) def forward(self, idx): B, T idx.shape tok_emb self.token_embedding(idx) # (B, T, d_model) pos_emb self.position_embedding(torch.arange(T, deviceidx.device)) # (T, d_model) x tok_emb pos_emb x self.blocks(x) x self.ln_f(x) logits self.lm_head(x) # (B, T, vocab_size) return logits这里有几个参数值得解释一下。d_model384是特征维度n_heads6表示 6 个注意力头n_layers6是 6 层 Transformer 块block_size256是最大序列长度。这几个参数组合起来参数量大约在 1000 万级别——不大不小CPU 上也能训练但结构上已经是一个完整的 GPT。注意位置嵌入的维度是block_size也就是说模型最多处理 256 个 token 的序列。如果想处理更长的文本要么增大block_size代价是训练更慢要么换成 RoPE 这类可外推的位置编码。入门阶段先用可学习位置嵌入就够了。3.3 训练循环从 loss 到收敛的完整流程模型定义好之后就进入训练环节。训练的核心是让模型学会预测下一个 token所以每个训练样本的构造方式是给定一串 token模型读前几个 token预测后一个 token。数据处理这块要用滑动窗口的方式从原始文本里切出样本。比如有一段 1000 个 token 的文本block_size256那就可以切出 745 个不同的上下文-目标对——第 1-256 个 token 预测第 2-257 个 token第 2-257 个 token 预测第 3-258 个 token以此类推。这样数据利用率很高每个位置都能当训练样本。训练循环本身并不复杂但有一个容易被忽略的细节梯度累积。如果你的显存不够大一个 batch 装不下太多样本可以用梯度累积来模拟更大的 batch size——多跑几个小 batch把梯度累加起来再更新一次参数。def train(model, dataloader, optimizer, device, grad_accum_steps8): model.train() total_loss 0 optimizer.zero_grad() for step, (x, y) in enumerate(dataloader): x, y x.to(device), y.to(device) logits model(x) # (B, T, vocab_size) # 将 logits 和 target 展平后计算交叉熵 loss F.cross_entropy(logits.view(-1, logits.size(-1)), y.view(-1)) # 梯度累积scale 一下 loss 保证等效 batch 大小不变 loss loss / grad_accum_steps loss.backward() if (step 1) % grad_accum_steps 0: optimizer.step() optimizer.zero_grad() total_loss loss.item() * grad_accum_steps return total_loss / len(dataloader)训练的超参数设置上有几个经验值供参考学习率 3e-4 左右配合余弦退火调度batch size 视显存而定32 到 128 都可以AdamW 优化器的 betas 用(0.9, 0.95)这是 GPT 系列训练时的常见配置。训练过程中重点关注 loss 曲线——正常情况是稳步下降如果出现 loss 震荡或者不降优先排查学习率是否过大、数据预处理是否有问题。3.4 推理生成让模型开口说话训练完成后最激动人心的环节就是让模型生成文本。自回归生成的核心逻辑很简单把当前已有的 token 序列输入模型得到下一个 token 的概率分布采样一个 token 拼到序列末尾重复这个过程直到达到目标长度。这里有一个小技巧值得注意采样温度和 top-k 过滤。温度参数控制概率分布的尖锐程度——温度越低采样越倾向于高分词温度越高采样越发散。top-k 过滤则是只从概率最高的 k 个 token 里采样避免选中那些概率极低的“离谱”token。def generate(model, tokenizer, prompt, max_new_tokens100, temperature0.8, top_k40): model.eval() input_ids tokenizer.encode(prompt).ids input_ids torch.tensor([input_ids], devicenext(model.parameters()).device) for _ in range(max_new_tokens): # 只取最后一个 block_size 长度的上下文 x input_ids[:, -block_size:] logits model(x)[:, -1, :] # (1, vocab_size) # 温度缩放 logits logits / temperature # top-k 过滤 if top_k is not None: v, _ torch.topk(logits, top_k) logits[logits v[:, -1].unsqueeze(-1)] -float(inf) probs F.softmax(logits, dim-1) next_token torch.multinomial(probs, num_samples1) input_ids torch.cat([input_ids, next_token], dim-1) return tokenizer.decode(input_ids[0].tolist())生成质量在微型模型上不可能太好但如果你能看到它产出“语法基本正确、局部话题连贯”的文本就说明训练是成功的。别忘了这只是一个 1000 万参数的玩具模型和真正的大模型差了三个数量级能学会基本语法已经证明你的代码实现没有大问题。实操心得训练完一个模型后第一件事不是看生成效果而是检查 loss 是否降到了和数据集熵值接近的水平。字符级 Shakespeare 语料的交叉熵大约在 1.5-2.0 左右如果你的模型 loss 能压到 2.0 以下说明真的学到了东西如果卡在 3.0 以上不动先去查数据预处理和词表构建大概率是那里出了问题。4. 进阶实操从零构建一个推理模型的核心路径在你看热搜词里有个很有意思的短语“build a reasoning model from scratch”。如果说从零构建语言模型是 AI 工程入门的里程碑那从零构建推理模型就是当前行业最热门的方向之一。从 ChatGPT 的思维链到 OpenAI 的 o1 系列推理能力已经成为大模型竞争的焦点。这里把推理模型和普通语言模型的区别、以及如何从零构建一个简化版推理模型的操作路径讲清楚。4.1 推理模型和普通语言模型的本质区别普通语言模型的任务是“接龙”——给定前文预测最可能的后续 token。它学的是文本的统计规律生成的文字流畅但未必有逻辑。推理模型则更进一步它不仅要生成流畅的文本还要在生成过程中进行多步思考最终输出一个经过推理得出的答案。这两者的核心区别在于训练目标。普通语言模型直接优化“下一个 token 预测准确率”而推理模型要在中间引入“思维链”——一种让模型先输出推理过程、再输出最终答案的中间表示。思维链之所以有效是因为它把复杂问题分解成多个简单步骤每一步的难度都远低于直接一步到位。这就像做数学题直接写答案很难但一步步列公式、代数字最后算出来就容易多了。从零构建一个真正像 o1 那样具备自主推理能力的模型难度非常高涉及搜索策略、强化学习、过程奖励模型等一大堆复杂技术。但我们可以构建一个简化版本先训练一个基座语言模型再用带思维链数据的监督微调学会“先推理后回答”的模式。这个简化版本已经能让你完全理解推理模型的工作机制。4.2 简化推理模型的数据构造与训练流程训练推理模型的第一步是构造带思维链的训练数据。简单说就是每个训练样本都要包含“问题 → 推理步骤 → 答案”三段结构。这里给一个具体的例子。比如数学题“一个农场有 12 只鸡每只鸡每天下 1 个蛋3 天后一共有多少个鸡蛋”对应的思维链数据是这样的问题一个农场有 12 只鸡每只鸡每天下 1 个蛋3 天后一共有多少个鸡蛋 推理每天下蛋数量为 12 * 1 12 个。3 天的总蛋数为 12 * 3 36 个。所以答案是 36 个鸡蛋。 答案36 个鸡蛋。注意训练的时候要把这三段拼接成一条完整的序列模型的任务仍然是“预测下一个 token”。只不过由于训练数据里包含了推理过程模型就学会了在遇到问题时先输出推理步骤、再给出答案的模式。手工标注思维链数据又累又贵所以实践中常用蒸馏的方式来生成训练数据用一个能力强的模型比如 GPT-4 或 Claude生成思维链再拿这些数据训练小模型。这种“大模型教小模型”的做法是当前行业里训练推理模型的主流方式之一也是从零构建推理模型的可行路径。4.3 使用 LoRA 高效微调基座模型直接全参数微调一个完整的推理模型对个人开发者来说成本太高。更现实的方案是下载一个开源的中等规模基座模型用 LoRALow-Rank Adaptation做参数高效微调。LoRA 的原理很巧妙——冻结原始模型的全部参数只训练注入的低秩矩阵。这样做有两个好处显存占用大幅下降训练参数量可能只有原来的 1% 左右同时效果上和全参数微调差距很小特别适合资源有限的场景。用 HuggingFace 的peft库实现 LoRA 微调非常方便from peft import LoraConfig, get_peft_model, TaskType from transformers import AutoModelForCausalLM # 加载一个开源基座模型 model AutoModelForCausalLM.from_pretrained(your-base-model) # 配置 LoRA lora_config LoraConfig( task_typeTaskType.CAUSAL_LM, r8, # 低秩矩阵的秩 lora_alpha16, # 缩放因子一般设为 r 的 2 倍 target_modules[q_proj, v_proj], # 注入注意力层的 q 和 v 投影 lora_dropout0.05, ) # 包装模型 model get_peft_model(model, lora_config) model.print_trainable_parameters() # 只会显示 LoRA 部分的参数量通常远小于全模型这段代码里r8是 LoRA 最重要的超参数。r 越小训练参数越少但表达能力也越弱r 越大表达能力越强但显存占用越高。实践中 r8 到 r32 是比较常见的范围。lora_alpha控制 LoRA 缩放比例通常设成 r 的两倍也可以理解为一个“放大系数”放大 LoRA 对模型输出的影响。注意LoRA 只注入到部分模块这里选了注意力层的 q 和 v不代表其他模块不重要而是在“效率-效果”之间的一个平衡。如果想提高效果可以增加target_modules比如加上k_proj、o_proj甚至 MLP 里的线性层代价是训练参数增多。新手先从 q 和 v 开始跑通了再逐步扩大范围。微调之后把 LoRA 权重保存下来。推理的时候需要先把 LoRA 权重合并回原始模型或者用peft的加载接口动态加载。合并权重的代码如下from peft import PeftModel merged_model PeftModel.from_pretrained(model, ./lora_weights) merged_model merged_model.merge_and_unload()合并之后的模型就是一个完整的推理模型不需要额外依赖 LoRA 也能独立运行。这个流程放在实际项目里非常实用——基座模型可以换更大的开源权重LoRA 层只占几十 MB 存储分发和部署都很轻量。4.4 推理模型的评测方法与效果验证训练完推理模型怎么判断它真的具备推理能力而不是“背题”最直接的方法是构造训练集之外的题目而且题型要和训练数据有差异。比如训练数据全是算术题评测时就出一些几何题或逻辑题看看模型能不能举一反三。另一个重要的评测维度是思维链质量。一个会“做题”的模型其推理过程应该是分步清晰、逻辑连贯的。如果模型输出的推理步骤是“8 * 3 21”哪怕最终答案凑对了也不代表它会推理只是运气好。实践中一定要同时看推理过程和最终答案不要只盯准确率。还有一个进阶玩法是自洽性提升同一个问题用不同的温度参数让模型生成多条推理链然后对答案做多数投票。这个技巧在实践中有不错的提升效果本质是利用多次独立采样来降低单次推理的随机性。简单说就是让模型多“想”几遍取出现次数最多的答案准确率通常会更高。5. 学习资源筛选与避坑指南AI 工程领域的信息量巨大资源筛选本身就是一项工程能力。这里把从零构建路线中最值得看的资源整理出来再分享一些我自己踩过的坑。5.1 必读书籍、论文与开源项目先给一张精简版的资源清单覆盖从理论到实操的完整链条资源类型核心价值Sebastian Raschka《Build a Large Language Model from Scratch》书籍最系统的 LLM 从零构建实操指南Andrej Karpathy“Lets build GPT”系列视频视频教程用 2 小时手写 GPT-2工程感极强《Attention Is All You Need》论文Transformer 原始论文注意力机制的第一手资料《Deep Learning》(Goodfellow) 相关章节书籍深度学习的经典教材补数学基础和概念HuggingFace Transformers 文档文档每个 API 都能和你的从零实现对应起来nanoGPT 开源项目代码库小而美的 GPT 训练项目代码简洁清晰Llama 系列开源模型的技术报告技术报告了解现代 LLM 工程细节如 RMSNorm、RoPE、GQA在这份清单里Sebastian Raschka 的书和 Andrej Karpathy 的视频是最推荐优先入手的两份资源。前者结构完整从数据准备到预训练到微调部署全流程覆盖后者有一个非常经典的实操 demo——只用约 200 行代码就把一个 GPT 的训练、生成跑通了。两份资源配合使用一个搭框架一个补细节效果很好。提示很多初学者会先去看《Attention Is All You Need》原文结果被公式劝退。建议顺序是先看代码实现Karpathy 视频再回头读论文。先建立直觉再看公式推导会轻松很多。直接硬啃论文属于“没有地图就进森林”效率很低。5.2 常见坑与避坑经验从零构建的路线上有几个坑几乎每个人都会踩提前知道了能省下大量时间。第一个坑数学基础没补齐就硬上。很多人看到注意力公式里的 softmax、矩阵乘法就发怵然后停下来刷《线性代数》。其实不必要。正确的做法是先实现一个最简单的模型跑通流程遇到卡住的数学概念再有针对性地查。在项目中学习数学远比孤立刷题高效因为你知道每个公式是干什么用的学的目的性极强。第二个坑过度依赖框架把“from scratch”理解成“用点高级库”。有人用 HuggingFace 的 Trainer 接口把自己实现了一遍模型就声称“从零构建”。这里要说清楚从零构建的核心价值在于亲手实现训练循环、backward、loss 计算这些“框架细节”如果你把这些都交给 Trainer 帮你做那和直接调库没本质区别。最起码训练循环要自己写。第三个坑显卡焦虑。很多人在开始之前就担心“我的 GPU 只有 8GB 显存能不能跑”事实是训练一个 1000 万参数的模型8GB 显存绰绰有余用 LoRA 微调 7B 级别模型8GB 也勉强能跑。真正的瓶颈从来不是显存而是是否愿意花时间去调小 batch size、用梯度累积、选合适的数据规模。等你把这些技巧都用熟练了你的“工程能力”反而比那些拿着 A100 只会跑默认参数的人更值钱。第四个坑硬刚英文资料。如果你英文阅读吃力不要硬啃英文教程那会严重拖慢进度。中文社区已经有大量优质的解读文章、翻译文档和开源项目推荐先把中文资源吃透英文原版作为后续进阶参考完全可以。学习路径上不必有“原文崇拜”看懂、用会才是目的。6. 写在最后的个人实操体会把“ai-engineering-from-scratch”这条路线完整走一遍我个人最大的体会是它真正改变的不是你的技术栈而是你对 AI 系统的认知方式。没亲手实现过 Transformer 之前我看模型结构图就像看城市地图——知道每条路叫什么名字但不知道为什么这条路要这样修。亲手写过一次之后再看 LLaMA 的结构改进能第一时间看出它动了哪里的螺丝再看训练不稳定的时候能直接推断出大概是梯度消失还是学习率调度出了问题。这种“结构感”和“直觉”是任何文档都无法直接传授的只能在一次次手写代码、debug、调参的循环里积累出来。最后再分享一个小技巧给自己设定一个“从零复现”的阶段性目标不要贪大。第一个目标是复现一个微型 GPT第二个目标是复现一个带 LoRA 微调的分类器第三个目标才是触碰推理模型。每个目标都要求自己写核心代码、记录实验笔记、总结踩坑经验。等你积累了三个完整项目之后AI 工程的大门才算真正向你敞开。到那时候再回头看会发现当初令你头疼的注意力公式、反向传播、显存优化其实都是非常朴素的东西——只是需要你亲手走一遍它们才从“知识”变成“能力”。 
长河君 · 2026/10/3 11:38:52 · 阅读 1.2k 从零构建大语言模型：AI工程实战路径与核心技术拆解
不是所有人都需要从零手搓一个神经网络但如果你真的想搞懂 AI 工程里那些“调参”、“过拟合”、“显存爆炸”到底是怎么回事从零开始把一个大语言模型造一遍是最快、也最扎实的路。这篇内容就是围绕“ai-engineering-from-scratch”这条学习路径展开的实操总结讲清楚为什么“从零构建”能解决“只会调库、不懂原理”的痛点也把整条路线里最核心的知识点、动手环节和踩坑经验一次说透。无论你是准备入行 AI 工程的新人还是已经在用 PyTorch 但总觉得基础不牢的开发者这篇都值得看完。1. 整体设计与思路拆解为什么“从零手搓”是最快的学习路径“ai-engineering-from-scratch”这个标题看着挺唬人其实核心就一件事不借助现成的训练框架和预训练权重从数学原理、数据处理、模型结构到训练推理一步步亲手实现一个可运行的语言模型。这个思路在国外技术社区很流行典型的代表就是 Sebastian Raschka 那本《Build a Large Language Model from Scratch》很多人跟着它从零写出了迷你版 GPT。这套路线之所以有价值是因为它把 AI 工程里最容易被“框架封装”掩盖掉的底层逻辑全部暴露了出来。1.1 这条路到底解决了什么问题市面上绝大多数 AI 相关教程都在教你怎么用 HuggingFace 加载模型、怎么用 Trainer 跑微调、怎么调用 API。这些内容本身没问题问题在于如果你只知道model AutoModel.from_pretrained(xxx)一旦遇到显存优化、自定义损失函数、分布式训练、模型推理性能调优这类工程问题就会完全无从下手因为你不清楚这行代码背后发生了什么。而从零构建一个模型相当于把整个过程“降维”成了几个可以逐个击破的环节数据怎么处理、词表怎么构建、注意力机制怎么算、梯度怎么回传、loss 怎么收敛。每一个环节都亲手写过之后再回头看那些封装好的工具你看到的就不再是黑盒而是一层熟悉的封装。到这一步才算是真正具备“AI 工程能力”而不仅仅是“会用 AI 库”。我自己带过不少新人一个很明显的规律是那些愿意花时间从零实现过 Transformer 的人后面上手分布式训练、量化部署、模型优化这些进阶内容速度明显快于只会调接口的人。原因很简单——底层机制清楚上层工具再怎么变本质都能看懂。1.2 和“直接调库”相比这条路的核心优势从零构建和直接调库本质上不是两种学习方法而是两种完全不同的认知深度。打个比方调库就像是开一辆自动挡汽车你只要会踩油门和刹车就能上路而从零构建像是亲手组装这辆车你要知道发动机怎么点火、变速箱怎么换挡、刹车油路怎么走。日常生活中自动挡当然够用但真出了故障、想改装、想优化性能懂机械原理的人才能动手。具体到技术层面从零构建的优势有三点第一对训练过程有完整的掌控感。你自己实现的数据加载、模型前向、loss 计算、反向传播每一步都是透明的出任何问题都能直接定位到具体环节而不是对着 PyTorch 的报错信息干瞪眼。第二对资源消耗有真实的感知。自己实现一遍就会发现一个 1 亿参数的小模型光 forward 一遍就要几百 MB 显存一个 batch 的数据要经过多少次矩阵乘法才能算出 loss。这种对计算量的“体感”是看文档永远学不来的。第三对模型结构有深入的理解。从零实现 Transformer 的时候你会被迫搞清楚 Q、K、V 三个矩阵到底怎么变换、多头注意力为什么要把头拆开、层归一化放在哪个位置、残差连接为什么能稳定训练。这些细节在大模型时代尤其重要因为现在所有主流架构——GPT、LLaMA、Mistral——都是在这个基础结构上演进的。提示如果你是纯新手不建议一上来就挑战复现完整的 LLaMA 或 GPT-4 级别的架构。最合理的起点是从一个微型 GPT参数量 1000 万以下开始跑通全流程再逐步加规模、加技巧、加优化。先把骨架搭起来再谈填肉。1.3 设计这条学习路线的底层逻辑“from scratch”不代表“从零开始学数学”——那是数学系的事。工程视角下的 from scratch指的是在已有编程和基础数学能力的前提下从零构建一个可用的 AI 系统。所以这条路线的设计逻辑是分层递进基础层是数学和编程原理层是模型架构工程层是训练与部署系统层是性能与扩展。每一层都是上一层的支撑跳级必然后面补课。这条路线和传统“先学理论再学应用”的路线最大的区别在于它把理论学习和动手实践牢牢绑在一起。你学完注意力机制的公式立刻就要把它写成代码你理解了交叉熵损失马上就要用它训练模型。每一个抽象的概念都有对应的代码实现和运行结果知识不再是悬空的而是落地可验证的。这种“学完即用”的节奏对工程思维的养成非常重要。2. 核心知识体系拆解数学、编程、深度学习缺一不可既然说“从零开始”那就绕不开基础知识的准备。很多人在这一步容易被劝退因为看到数学公式就头大。其实 AI 工程真正高频使用的数学并没有想象中那么多把关键部分吃透就够了不需要成为数学家。2.1 数学基础需要掌握到什么程度AI 工程里用得最多的数学知识可以浓缩成三块线性代数、微积分、概率统计。线性代数是整个深度学习的基石。矩阵乘法、向量点积、矩阵转置、矩阵求逆这些是最基本的操作。Transformer 里的注意力机制本质就是一组矩阵运算模型参数的存储和更新本质也是矩阵运算。你需要理解的是矩阵乘法的维度变化规律——这一点非常重要模型代码里 90% 的 bug 都出在维度对不上。微积分方面核心是导数和链式法则。反向传播算法就是链式法则的工程化应用从 loss 开始逐层往后求梯度每一层的梯度都依赖于前一层的输出。你不需要会手推复杂的偏导公式但必须理解“梯度是 loss 对参数的敏感性”这个直觉理解学习率为什么不能太大也不能太小。概率统计方面最常用的是概率分布、期望、交叉熵。语言模型本质上是在学习一个概率分布给定前文预测下一个 token 的概率。交叉熵损失函数直接对应“模型预测分布和真实分布的差异”。这些概念配合代码理解起来并不难关键是不要脱离代码枯看公式。实操建议学数学的时候每学一个公式都在 PyTorch 里用随机张量验证一遍。比如学完矩阵乘法就写几行代码看看(B, T, C)形状的张量乘(C, C)形状的矩阵输出变成什么形状。这种“代码验证公式”的习惯能把抽象的数学变成看得见摸得着的东西学习效率高好几倍。2.2 Python 与编程能力哪些是硬指标Python 是 AI 工程的第一语言需要掌握的程度比“能写脚本”要深一些。硬指标有这么几项熟练掌握numpy的基础操作尤其是数组的 shape 操作、广播机制、切片索引。很多数据预处理环节离了 numpy 寸步难行。熟练掌握 PyTorch 的核心 APItorch.Tensor、torch.nn.Module、torch.optim、torch.utils.data.Dataset和DataLoader。不需要背 API但要知道查文档的方向。理解 Python 的面向对象编程因为模型、层、数据集这些概念在代码里都是以类的方式组织的。会写简单的单元测试至少能自己验证数据预处理、词表构建这类工具函数是否正确。这些要求不算高但都是实打实的工程底线。如果你现在写 Python 还在靠复制粘贴改参数建议先花一两周把 Python 基础补扎实再开始 AI 工程路线不然后面会很痛苦。2.3 深度学习核心概念必须亲手实现一遍深度学习领域有一批“听起来懂、一写就废”的概念从零构建过程中必须逐个攻克张量多维数组是深度学习的基本数据结构。要理解 shape、dtype、device 三个属性理解在 CPU 和 GPU 上的区别。自动求导PyTorch 的核心能力之一。你只需要定义前向计算图框架会自动帮你算梯度。但从零构建时你要理解这个自动求导背后是链式法则在起作用理解为什么每个中间结果都要保留。模型层nn.Linear就是一次矩阵乘法加偏置nn.Embedding就是一个查找表nn.LayerNorm就是对最后一维做归一化。每一个看似高级的层拆开看都是基础运算的组合。激活函数ReLU、GELU、SiLU 这些函数的作用是给模型引入非线性。没有非线性多层线性变换叠在一起仍然等价于一层线性变换模型就没有表达能力。损失函数语言模型用的是交叉熵损失。要理解logits和target的维度关系理解为什么要在logits上做 log_softmax。优化器SGD、Adam、AdamW。要理解动量、学习率、权重衰减这些概念对训练的影响。实践中语言模型几乎都用 AdamW它把权重衰减和动量更新分开了效果好且稳定。训练循环一个标准的训练循环包括 forward → loss → backward → optimizer.step() → 梯度清零。看似简单但数据处理、batch 组织、梯度累积、学习率调度每一个细节都有讲究。这些概念如果只是看书很容易产生“我会了”的错觉。只有亲手把每个概念写成代码跑起来看到 loss 真的下降才算真正过关。2.4 从零构建的核心技术栈与工具选型工具链选择上第一推荐还是 Python PyTorch生态成熟、调试方便、社区资料多。具体到“from scratch”路线上有一批高频使用的核心库工具用途选择理由PyTorch深度学习框架自动求导、动态图机制、生态最全NumPy数值计算数据处理和原型验证的根基HuggingFace Tokenizers训练分词器高性能、易用支持 BPE 等主流算法Datasets数据加载处理大规模数据集支持流式加载TensorBoard / Weights Biases训练监控观察 loss 曲线和梯度分布定位训练问题PEFT / LoRA高效微调训练推理模型时大幅降低显存需求注意这里说的“from scratch”指的是不直接用现成的预训练模型权重而不是不能使用 PyTorch 这种基础框架。如果你真的连 PyTorch 都不用那复杂度就失控了——得先从写矩阵乘法库开始那就不是 AI 工程而是 AI 框架研发了。3. 实操全程实录从零构建一个微型语言模型理论说再多都不如动手写一个微型模型来得实在。这里我用一个完整的实操案例带你把“从零构建语言模型”走一遍。目标是构建一个参数量约 1000 万级别的微型 GPT在小型数据集上训练让它能生成看起来像模像样的文本。3.1 数据准备没有好数据模型就是空中楼阁训练一个语言模型第一步是准备训练语料。对于微型模型不需要用几十 TB 的巨型数据集选一个和模型容量匹配的小型纯文本语料即可。经典的入门选择是 TinyShakespeare——一个约 100 万字符的莎士比亚戏剧合集。这个数据集好处很多体积小CPU 上几十分钟就能完成训练语言风格鲜明很容易看出模型有没有学会东西字符级或词元级处理都方便适合验证全流程。如果你不想用现成数据集也可以自己准备找几本公版电子书合并成纯文本文件就行。关键是数据质量——编码统一用 UTF-8去掉多余空行和特殊符号保证文本干净一致。实操中数据处理的第一个环节是构建词表。词表是模型“认识”的所有 token 的集合。最简单的方案是字符级词表——每个字符对应一个 id。这种方案实现简单适合教学但真实项目中基本不用因为字符级建模序列太长、信息密度太低。实践中最低限度也要用 BPEByte Pair Encoding这类子词分词算法。BPE 的核心思想不复杂从字符级开始反复统计最频繁出现的相邻字符对把它们合并成一个新的 token直到词表达到预设大小。HuggingFace 的tokenizers库把这个过程封装得很好几十行代码就能训练出一个 BPE 词表。from tokenizers import Tokenizer from tokenizers.models import BPE from tokenizers.pre_tokenizers import Whitespace from tokenizers.trainers import BpeTrainer # 初始化一个 BPE tokenizer tokenizer Tokenizer(BPE(unk_tokenunk)) tokenizer.pre_tokenizer Whitespace() trainer BpeTrainer(vocab_size5000, special_tokens[unk, s, /s, pad]) # 在语料上训练词表 files [shakespeare.txt] tokenizer.train(files, trainer) # 保存词表便于复用 tokenizer.save(tokenizer.json)这段代码做了三件事定义 BPE 模型、指定预切分规则为空白切分、在语料上训练出 5000 词的子词词表。训练完成后tokenizer.json就是最终的词表文件后续训练和推理都要用同一个词表所以务必保存好。实操心得训练词表的时候语料要尽量和目标任务匹配。如果你的最终目标是让模型写代码就用在 GitHub 上爬的代码语料训练词表目标是写文章就用文章语料。词表和训练数据不匹配会直接导致分词效率低下模型学起来事倍功半。3.2 模型构建用代码实现一个微型 GPT接下来是核心环节——用 PyTorch 实现一个微型 GPT。这里不追求大而全只实现最必要的组件token 嵌入层、位置嵌入层、Transformer 解码器块、输出投影层。整个模型可以拆成几个模块来写嵌入层包括 token 嵌入和位置嵌入。token 嵌入是一个查找表形状是(vocab_size, d_model)位置嵌入给每个位置一个向量让模型知道 token 的顺序信息。GPT 用的是可学习的位置嵌入每个位置一个固定向量。Transformer 解码器块这是核心。每个块包含一个掩码多头自注意力机制、一个前馈网络以及两个层归一化和残差连接。掩码多头自注意力是整个模型最复杂的部分。它要做的计算是把输入序列的每个 token 映射成 Query、Key、Value 三个向量计算 Query 和所有 Key 的点积得到注意力分数再对分数做缩放和 softmax 归一化最后用归一化后的权重去加权求和 Value 向量。“掩码”指的是在计算注意力分数时把未来位置的分数设为负无穷这样当前 token 就只能看到自己和之前的信息看不到未来——这是生成模型的核心机制。下面是一个简化版的单头注意力实现方便理解核心逻辑import torch import torch.nn as nn import torch.nn.functional as F class CausalSelfAttention(nn.Module): def __init__(self, d_model, n_heads, dropout0.1): super().__init__() assert d_model % n_heads 0 self.d_model d_model self.n_heads n_heads self.head_dim d_model // n_heads # 统一用一个大矩阵计算 Q、K、V方便且高效 self.c_attn nn.Linear(d_model, 3 * d_model) self.c_proj nn.Linear(d_model, d_model) self.dropout nn.Dropout(dropout) def forward(self, x): B, T, C x.shape # batch size, 序列长度, 特征维度 # 计算 Q、K、V 并拆分成多头 qkv self.c_attn(x) # (B, T, 3*C) q, k, v qkv.chunk(3, dim-1) # 将最后一维拆成 (n_heads, head_dim) q q.view(B, T, self.n_heads, self.head_dim).transpose(1, 2) # (B, n_heads, T, head_dim) k k.view(B, T, self.n_heads, self.head_dim).transpose(1, 2) v v.view(B, T, self.n_heads, self.head_dim).transpose(1, 2) # 缩放点积注意力 att (q k.transpose(-2, -1)) * (self.head_dim ** -0.5) # (B, n_heads, T, T) # 因果掩码保证当前位置只能看到过去位置 mask torch.tril(torch.ones(T, T, devicex.device)).view(1, 1, T, T) att att.masked_fill(mask 0, float(-inf)) att F.softmax(att, dim-1) att self.dropout(att) y att v # (B, n_heads, T, head_dim) y y.transpose(1, 2).contiguous().view(B, T, C) # 合并多头 return self.c_proj(y)这段代码最值得关注的是因果掩码的实现方式先生成一个下三角矩阵然后把上三角部分全部填充为负无穷。这样 softmax 之后未来位置的权重趋近于零模型就“看不到”未来信息了。完整的 Transformer 解码器块还要包含前馈网络和层归一化。前馈网络通常是两个线性层加一个 GELU 激活函数层归一化放在注意力之前这就是 GPT-2 之后流行的 pre-norm 结构。整个块的写法如下class MLP(nn.Module): def __init__(self, d_model, expansion4, dropout0.1): super().__init__() self.fc1 nn.Linear(d_model, expansion * d_model) self.fc2 nn.Linear(expansion * d_model, d_model) self.gelu nn.GELU() self.dropout nn.Dropout(dropout) def forward(self, x): return self.dropout(self.fc2(self.gelu(self.fc1(x)))) class TransformerBlock(nn.Module): def __init__(self, d_model, n_heads, dropout0.1): super().__init__() self.ln1 nn.LayerNorm(d_model) self.attn CausalSelfAttention(d_model, n_heads, dropout) self.ln2 nn.LayerNorm(d_model) self.mlp MLP(d_model, expansion4, dropoutdropout) def forward(self, x): x x self.attn(self.ln1(x)) # pre-norm 残差连接 x x self.mlp(self.ln2(x)) return x最后把嵌入层、若干个 Transformer 块、输出投影层拼起来就成了微型 GPTclass MiniGPT(nn.Module): def __init__(self, vocab_size, d_model384, n_heads6, n_layers6, block_size256, dropout0.1): super().__init__() self.token_embedding nn.Embedding(vocab_size, d_model) self.position_embedding nn.Embedding(block_size, d_model) self.blocks nn.Sequential(*[ TransformerBlock(d_model, n_heads, dropout) for _ in range(n_layers) ]) self.ln_f nn.LayerNorm(d_model) self.lm_head nn.Linear(d_model, vocab_size, biasFalse) # 参数初始化对 embedding 层做缩放 self.apply(self._init_weights) def _init_weights(self, module): if isinstance(module, nn.Linear): nn.init.normal_(module.weight, mean0.0, std0.02) if module.bias is not None: nn.init.zeros_(module.bias) elif isinstance(module, nn.Embedding): nn.init.normal_(module.weight, mean0.0, std0.02) def forward(self, idx): B, T idx.shape tok_emb self.token_embedding(idx) # (B, T, d_model) pos_emb self.position_embedding(torch.arange(T, deviceidx.device)) # (T, d_model) x tok_emb pos_emb x self.blocks(x) x self.ln_f(x) logits self.lm_head(x) # (B, T, vocab_size) return logits这里有几个参数值得解释一下。d_model384是特征维度n_heads6表示 6 个注意力头n_layers6是 6 层 Transformer 块block_size256是最大序列长度。这几个参数组合起来参数量大约在 1000 万级别——不大不小CPU 上也能训练但结构上已经是一个完整的 GPT。注意位置嵌入的维度是block_size也就是说模型最多处理 256 个 token 的序列。如果想处理更长的文本要么增大block_size代价是训练更慢要么换成 RoPE 这类可外推的位置编码。入门阶段先用可学习位置嵌入就够了。3.3 训练循环从 loss 到收敛的完整流程模型定义好之后就进入训练环节。训练的核心是让模型学会预测下一个 token所以每个训练样本的构造方式是给定一串 token模型读前几个 token预测后一个 token。数据处理这块要用滑动窗口的方式从原始文本里切出样本。比如有一段 1000 个 token 的文本block_size256那就可以切出 745 个不同的上下文-目标对——第 1-256 个 token 预测第 2-257 个 token第 2-257 个 token 预测第 3-258 个 token以此类推。这样数据利用率很高每个位置都能当训练样本。训练循环本身并不复杂但有一个容易被忽略的细节梯度累积。如果你的显存不够大一个 batch 装不下太多样本可以用梯度累积来模拟更大的 batch size——多跑几个小 batch把梯度累加起来再更新一次参数。def train(model, dataloader, optimizer, device, grad_accum_steps8): model.train() total_loss 0 optimizer.zero_grad() for step, (x, y) in enumerate(dataloader): x, y x.to(device), y.to(device) logits model(x) # (B, T, vocab_size) # 将 logits 和 target 展平后计算交叉熵 loss F.cross_entropy(logits.view(-1, logits.size(-1)), y.view(-1)) # 梯度累积scale 一下 loss 保证等效 batch 大小不变 loss loss / grad_accum_steps loss.backward() if (step 1) % grad_accum_steps 0: optimizer.step() optimizer.zero_grad() total_loss loss.item() * grad_accum_steps return total_loss / len(dataloader)训练的超参数设置上有几个经验值供参考学习率 3e-4 左右配合余弦退火调度batch size 视显存而定32 到 128 都可以AdamW 优化器的 betas 用(0.9, 0.95)这是 GPT 系列训练时的常见配置。训练过程中重点关注 loss 曲线——正常情况是稳步下降如果出现 loss 震荡或者不降优先排查学习率是否过大、数据预处理是否有问题。3.4 推理生成让模型开口说话训练完成后最激动人心的环节就是让模型生成文本。自回归生成的核心逻辑很简单把当前已有的 token 序列输入模型得到下一个 token 的概率分布采样一个 token 拼到序列末尾重复这个过程直到达到目标长度。这里有一个小技巧值得注意采样温度和 top-k 过滤。温度参数控制概率分布的尖锐程度——温度越低采样越倾向于高分词温度越高采样越发散。top-k 过滤则是只从概率最高的 k 个 token 里采样避免选中那些概率极低的“离谱”token。def generate(model, tokenizer, prompt, max_new_tokens100, temperature0.8, top_k40): model.eval() input_ids tokenizer.encode(prompt).ids input_ids torch.tensor([input_ids], devicenext(model.parameters()).device) for _ in range(max_new_tokens): # 只取最后一个 block_size 长度的上下文 x input_ids[:, -block_size:] logits model(x)[:, -1, :] # (1, vocab_size) # 温度缩放 logits logits / temperature # top-k 过滤 if top_k is not None: v, _ torch.topk(logits, top_k) logits[logits v[:, -1].unsqueeze(-1)] -float(inf) probs F.softmax(logits, dim-1) next_token torch.multinomial(probs, num_samples1) input_ids torch.cat([input_ids, next_token], dim-1) return tokenizer.decode(input_ids[0].tolist())生成质量在微型模型上不可能太好但如果你能看到它产出“语法基本正确、局部话题连贯”的文本就说明训练是成功的。别忘了这只是一个 1000 万参数的玩具模型和真正的大模型差了三个数量级能学会基本语法已经证明你的代码实现没有大问题。实操心得训练完一个模型后第一件事不是看生成效果而是检查 loss 是否降到了和数据集熵值接近的水平。字符级 Shakespeare 语料的交叉熵大约在 1.5-2.0 左右如果你的模型 loss 能压到 2.0 以下说明真的学到了东西如果卡在 3.0 以上不动先去查数据预处理和词表构建大概率是那里出了问题。4. 进阶实操从零构建一个推理模型的核心路径在你看热搜词里有个很有意思的短语“build a reasoning model from scratch”。如果说从零构建语言模型是 AI 工程入门的里程碑那从零构建推理模型就是当前行业最热门的方向之一。从 ChatGPT 的思维链到 OpenAI 的 o1 系列推理能力已经成为大模型竞争的焦点。这里把推理模型和普通语言模型的区别、以及如何从零构建一个简化版推理模型的操作路径讲清楚。4.1 推理模型和普通语言模型的本质区别普通语言模型的任务是“接龙”——给定前文预测最可能的后续 token。它学的是文本的统计规律生成的文字流畅但未必有逻辑。推理模型则更进一步它不仅要生成流畅的文本还要在生成过程中进行多步思考最终输出一个经过推理得出的答案。这两者的核心区别在于训练目标。普通语言模型直接优化“下一个 token 预测准确率”而推理模型要在中间引入“思维链”——一种让模型先输出推理过程、再输出最终答案的中间表示。思维链之所以有效是因为它把复杂问题分解成多个简单步骤每一步的难度都远低于直接一步到位。这就像做数学题直接写答案很难但一步步列公式、代数字最后算出来就容易多了。从零构建一个真正像 o1 那样具备自主推理能力的模型难度非常高涉及搜索策略、强化学习、过程奖励模型等一大堆复杂技术。但我们可以构建一个简化版本先训练一个基座语言模型再用带思维链数据的监督微调学会“先推理后回答”的模式。这个简化版本已经能让你完全理解推理模型的工作机制。4.2 简化推理模型的数据构造与训练流程训练推理模型的第一步是构造带思维链的训练数据。简单说就是每个训练样本都要包含“问题 → 推理步骤 → 答案”三段结构。这里给一个具体的例子。比如数学题“一个农场有 12 只鸡每只鸡每天下 1 个蛋3 天后一共有多少个鸡蛋”对应的思维链数据是这样的问题一个农场有 12 只鸡每只鸡每天下 1 个蛋3 天后一共有多少个鸡蛋 推理每天下蛋数量为 12 * 1 12 个。3 天的总蛋数为 12 * 3 36 个。所以答案是 36 个鸡蛋。 答案36 个鸡蛋。注意训练的时候要把这三段拼接成一条完整的序列模型的任务仍然是“预测下一个 token”。只不过由于训练数据里包含了推理过程模型就学会了在遇到问题时先输出推理步骤、再给出答案的模式。手工标注思维链数据又累又贵所以实践中常用蒸馏的方式来生成训练数据用一个能力强的模型比如 GPT-4 或 Claude生成思维链再拿这些数据训练小模型。这种“大模型教小模型”的做法是当前行业里训练推理模型的主流方式之一也是从零构建推理模型的可行路径。4.3 使用 LoRA 高效微调基座模型直接全参数微调一个完整的推理模型对个人开发者来说成本太高。更现实的方案是下载一个开源的中等规模基座模型用 LoRALow-Rank Adaptation做参数高效微调。LoRA 的原理很巧妙——冻结原始模型的全部参数只训练注入的低秩矩阵。这样做有两个好处显存占用大幅下降训练参数量可能只有原来的 1% 左右同时效果上和全参数微调差距很小特别适合资源有限的场景。用 HuggingFace 的peft库实现 LoRA 微调非常方便from peft import LoraConfig, get_peft_model, TaskType from transformers import AutoModelForCausalLM # 加载一个开源基座模型 model AutoModelForCausalLM.from_pretrained(your-base-model) # 配置 LoRA lora_config LoraConfig( task_typeTaskType.CAUSAL_LM, r8, # 低秩矩阵的秩 lora_alpha16, # 缩放因子一般设为 r 的 2 倍 target_modules[q_proj, v_proj], # 注入注意力层的 q 和 v 投影 lora_dropout0.05, ) # 包装模型 model get_peft_model(model, lora_config) model.print_trainable_parameters() # 只会显示 LoRA 部分的参数量通常远小于全模型这段代码里r8是 LoRA 最重要的超参数。r 越小训练参数越少但表达能力也越弱r 越大表达能力越强但显存占用越高。实践中 r8 到 r32 是比较常见的范围。lora_alpha控制 LoRA 缩放比例通常设成 r 的两倍也可以理解为一个“放大系数”放大 LoRA 对模型输出的影响。注意LoRA 只注入到部分模块这里选了注意力层的 q 和 v不代表其他模块不重要而是在“效率-效果”之间的一个平衡。如果想提高效果可以增加target_modules比如加上k_proj、o_proj甚至 MLP 里的线性层代价是训练参数增多。新手先从 q 和 v 开始跑通了再逐步扩大范围。微调之后把 LoRA 权重保存下来。推理的时候需要先把 LoRA 权重合并回原始模型或者用peft的加载接口动态加载。合并权重的代码如下from peft import PeftModel merged_model PeftModel.from_pretrained(model, ./lora_weights) merged_model merged_model.merge_and_unload()合并之后的模型就是一个完整的推理模型不需要额外依赖 LoRA 也能独立运行。这个流程放在实际项目里非常实用——基座模型可以换更大的开源权重LoRA 层只占几十 MB 存储分发和部署都很轻量。4.4 推理模型的评测方法与效果验证训练完推理模型怎么判断它真的具备推理能力而不是“背题”最直接的方法是构造训练集之外的题目而且题型要和训练数据有差异。比如训练数据全是算术题评测时就出一些几何题或逻辑题看看模型能不能举一反三。另一个重要的评测维度是思维链质量。一个会“做题”的模型其推理过程应该是分步清晰、逻辑连贯的。如果模型输出的推理步骤是“8 * 3 21”哪怕最终答案凑对了也不代表它会推理只是运气好。实践中一定要同时看推理过程和最终答案不要只盯准确率。还有一个进阶玩法是自洽性提升同一个问题用不同的温度参数让模型生成多条推理链然后对答案做多数投票。这个技巧在实践中有不错的提升效果本质是利用多次独立采样来降低单次推理的随机性。简单说就是让模型多“想”几遍取出现次数最多的答案准确率通常会更高。5. 学习资源筛选与避坑指南AI 工程领域的信息量巨大资源筛选本身就是一项工程能力。这里把从零构建路线中最值得看的资源整理出来再分享一些我自己踩过的坑。5.1 必读书籍、论文与开源项目先给一张精简版的资源清单覆盖从理论到实操的完整链条资源类型核心价值Sebastian Raschka《Build a Large Language Model from Scratch》书籍最系统的 LLM 从零构建实操指南Andrej Karpathy“Lets build GPT”系列视频视频教程用 2 小时手写 GPT-2工程感极强《Attention Is All You Need》论文Transformer 原始论文注意力机制的第一手资料《Deep Learning》(Goodfellow) 相关章节书籍深度学习的经典教材补数学基础和概念HuggingFace Transformers 文档文档每个 API 都能和你的从零实现对应起来nanoGPT 开源项目代码库小而美的 GPT 训练项目代码简洁清晰Llama 系列开源模型的技术报告技术报告了解现代 LLM 工程细节如 RMSNorm、RoPE、GQA在这份清单里Sebastian Raschka 的书和 Andrej Karpathy 的视频是最推荐优先入手的两份资源。前者结构完整从数据准备到预训练到微调部署全流程覆盖后者有一个非常经典的实操 demo——只用约 200 行代码就把一个 GPT 的训练、生成跑通了。两份资源配合使用一个搭框架一个补细节效果很好。提示很多初学者会先去看《Attention Is All You Need》原文结果被公式劝退。建议顺序是先看代码实现Karpathy 视频再回头读论文。先建立直觉再看公式推导会轻松很多。直接硬啃论文属于“没有地图就进森林”效率很低。5.2 常见坑与避坑经验从零构建的路线上有几个坑几乎每个人都会踩提前知道了能省下大量时间。第一个坑数学基础没补齐就硬上。很多人看到注意力公式里的 softmax、矩阵乘法就发怵然后停下来刷《线性代数》。其实不必要。正确的做法是先实现一个最简单的模型跑通流程遇到卡住的数学概念再有针对性地查。在项目中学习数学远比孤立刷题高效因为你知道每个公式是干什么用的学的目的性极强。第二个坑过度依赖框架把“from scratch”理解成“用点高级库”。有人用 HuggingFace 的 Trainer 接口把自己实现了一遍模型就声称“从零构建”。这里要说清楚从零构建的核心价值在于亲手实现训练循环、backward、loss 计算这些“框架细节”如果你把这些都交给 Trainer 帮你做那和直接调库没本质区别。最起码训练循环要自己写。第三个坑显卡焦虑。很多人在开始之前就担心“我的 GPU 只有 8GB 显存能不能跑”事实是训练一个 1000 万参数的模型8GB 显存绰绰有余用 LoRA 微调 7B 级别模型8GB 也勉强能跑。真正的瓶颈从来不是显存而是是否愿意花时间去调小 batch size、用梯度累积、选合适的数据规模。等你把这些技巧都用熟练了你的“工程能力”反而比那些拿着 A100 只会跑默认参数的人更值钱。第四个坑硬刚英文资料。如果你英文阅读吃力不要硬啃英文教程那会严重拖慢进度。中文社区已经有大量优质的解读文章、翻译文档和开源项目推荐先把中文资源吃透英文原版作为后续进阶参考完全可以。学习路径上不必有“原文崇拜”看懂、用会才是目的。6. 写在最后的个人实操体会把“ai-engineering-from-scratch”这条路线完整走一遍我个人最大的体会是它真正改变的不是你的技术栈而是你对 AI 系统的认知方式。没亲手实现过 Transformer 之前我看模型结构图就像看城市地图——知道每条路叫什么名字但不知道为什么这条路要这样修。亲手写过一次之后再看 LLaMA 的结构改进能第一时间看出它动了哪里的螺丝再看训练不稳定的时候能直接推断出大概是梯度消失还是学习率调度出了问题。这种“结构感”和“直觉”是任何文档都无法直接传授的只能在一次次手写代码、debug、调参的循环里积累出来。最后再分享一个小技巧给自己设定一个“从零复现”的阶段性目标不要贪大。第一个目标是复现一个微型 GPT第二个目标是复现一个带 LoRA 微调的分类器第三个目标才是触碰推理模型。每个目标都要求自己写核心代码、记录实验笔记、总结踩坑经验。等你积累了三个完整项目之后AI 工程的大门才算真正向你敞开。到那时候再回头看会发现当初令你头疼的注意力公式、反向传播、显存优化其实都是非常朴素的东西——只是需要你亲手走一遍它们才从“知识”变成“能力”。