Token Lab搜索

TRANSFORMERS / FROM SCRATCH

从字节到训练好的 Transformer:从零实现语言模型

完整的 CPU 小模型项目:字节编码、因果注意力、损失、AdamW、检查点与生成,附可运行 Python 及明确能力边界。

来源与版本详情
本文目录

1. 我们要造什么:语言模型究竟学什么

想象一个运维控制台,自动补全“node 107: status is”。我们将构造因果 Transformer,随机初始化全部权重,用原创合成语料训练,保存检查点,再生成字节。不加载预训练权重,不下载数据集,也不调用模型 API。PyTorch 提供张量、自动微分和优化器基础设施;这里的“从零”指亲自实现架构和训练流程,并非重新写 GPU 内核或自动微分引擎。

训练与生成的全链路

小屏幕可横向查看,或打开原尺寸图。 查看原尺寸图

训练与生成的全链路. 先划分训练和验证文档,再抽取窗口。只有训练损失参与参数更新,验证过程只观察固定参数下的预测。检查点将训练得到的参数交给生成程序;生成时参数不变,输入序列逐步增长。此图对应随文提供的 CPU 教学实现,不代表生产模型服务架构。
先划分训练和验证文档,再抽取窗口。只有训练损失参与参数更新,验证过程只观察固定参数下的预测。检查点将训练得到的参数交给生成程序;生成时参数不变,输入序列逐步增长。此图对应随文提供的 CPU 教学实现,不代表生产模型服务架构。

语言模型估计给定前文时下一个 token 的概率分布。权重编码统计规律,并不是经过核验的事实数据库。这个 134,912 参数的小模型可以在 CPU 上运行,展示大模型的计算骨架,却不是通用助手或指令模型。贯穿全文的例子会揭示一个关键区别:学会状态消息的句式,并不等于知道哪个节点应该忙碌。

先修要求是理解矩阵乘向量、概率分布和链式法则。矩阵乘法混合特征,softmax 把分数变成概率,链式法则让误差信号穿过每一层。如果不熟悉这些运算,可以先读文末的基础教程,再尝试修改模型。

2. 准备运行环境与项目文件

下载下方完整项目并解压到新目录。tiny_lm.py 包含模型、合成语料、训练循环与内置检查;generate.py 是独立推理入口,两者应放在同一目录。可以把完整实现作为对照,按照后续章节重新实现每个函数。章节代码摘自实际项目,不是可以不加判断地拼接的独立程序。

实测参考环境为 Linux、Python 3.12 与 PyTorch 2.5.1 CPU。按下方命令创建隔离虚拟环境,安装固定版本的 CPU 包。安装会下载软件,但训练使用内置原创语料,不调用模型 API,也不需要 GPU。其他平台可能需要兼容的官方 PyTorch 安装包,数值结果也可能略有差异。

项目最终生成 tiny.pt,其中保存配置、权重、优化器状态、步数和随机数状态。本文先解释如何构造这个产物,再说明如何在另一个进程中加载。完成组件实现讲解后,在文末实践区集中执行训练、检查和生成命令。开始时无需检查点或预训练模型。

下载完整项目 ZIP

unzip from-zero-lm.zip -d tokenlab-lm
cd tokenlab-lm
python3.12 -m venv .venv
. .venv/bin/activate
python -m pip install torch==2.5.1 --index-url https://download.pytorch.org/whl/cpu

3. 从文档到监督样本

内置语料有 120 条状态文档:偶数编号为 ready,奇数编号为 busy。先按文档划分,0–99 号用于训练,100–119 号用于验证,再抽取窗口,每条以换行结尾。这避免同一文档的窗口随机散落到两个集合,却不意味着验证模板独立:两边共享语法,结果只反映这个微小分布中的插值能力。

UTF-8 字节词表固定为 ,编码精确,不需要额外训练 tokenizer。“Hi”对应 [72,105],一个汉字通常需要多个字节。因此字节困惑度不能与 BPE token 困惑度直接比较。真实语料需要许可检查、敏感信息清理、明确的规范化、跨集合去重和文档清单。可选 --text 只做按顺序 90/10 字节切分,是便利入口,并非生产数据治理流程。

从每个起点读取 T+1 个字节,前 T 个作输入,后 T 个作目标。[65,66,67,10] 会形成输入 [65,66,67] 和目标 [66,67,10]。批次形状是 [B,T],不是 [B,T,V]。拼接文档允许窗口跨过换行;如果任务不应学习跨文档预测,就应加入明确边界和损失遮罩。

实现数据契约

先在 tiny_lm.py 中实现 corpus() 与 batch(),再连接训练循环。corpus() 返回两个字节串;batch() 只把指定集合转换为 torch.long 类型的 token ID。起点必须为 T+1 个字节留出空间:N 个字节对应 N−T 个合法起点,编号为 0 到 N−T−1。每个样本返回两行长度 32 的序列,16 个样本组成的 x、y 均为 [16,32]。训练中复用同一个随机数生成器,让状态逐步推进,而不是每步重新播种、反复读取相同批次。

实现代码节选 · 运行时请使用完整项目

def corpus():
    # Original synthetic sentences. Split document IDs BEFORE window extraction.
    docs = [f'node {i:03d}: status is {"ready" if i % 2 == 0 else "busy"}.\n' for i in range(120)]
    return ''.join(docs[:100]).encode(), ''.join(docs[100:]).encode()

def batch(raw, generator, size=16):
    data=torch.tensor(list(raw), dtype=torch.long)
    t=CFG['context']
    starts=torch.randint(len(data)-t, (size,), generator=generator)
    return torch.stack([data[i:i+t] for i in starts]), torch.stack([data[i+1:i+t+1] for i in starts])

数据划分是统计边界,而不只是文件名不同。使用 --text 时应先完成语料准备,且两个集合都必须超过 32 字节。程序会拼接文档并抽取字节窗口,没有实现文档级遮罩与去重。解释损失时必须保留这一前提:增加语料不仅改变数据分布,也改变一段文本在训练中被抽到的频率。

一个序列如何产生三个预测目标

小屏幕可横向查看,或打开原尺寸图。 查看原尺寸图

一个序列如何产生三个预测目标. 图中用 T=3 的教学窗口代替程序默认的 T=32:一次取四个字节,目标序列向后错开一位。在第二个位置,模型只能依据 A、B 预测 C;C 是该位置的监督目标,不能作为该预测的可见输入。因果遮罩隔离未来位置,因此三个位置的损失可以并行计算。
图中用 T=3 的教学窗口代替程序默认的 T=32:一次取四个字节,目标序列向后错开一位。在第二个位置,模型只能依据 A、B 预测 C;C 是该位置的监督目标,不能作为该预测的可见输入。因果遮罩隔离未来位置,因此三个位置的损失可以并行计算。

4. 注意力是带因果边界的加权读取

实现采用 条序列、 个位置、模型宽度 与 个头,因此每头有 16 维特征。一层 Linear 同时输出 Q、K、V,再拆成 [B,H,T,16]。QKᵀ 的形状是 [B,H,T,T],除以 √16=4。在特征近似独立、方差为一的粗略假设下,未缩放点积方差为 16;缩放避免仅因头宽增大就让 softmax 过尖。这个方差解释并不保证训练后的特征仍独立。

在 softmax 前,把键位置 j 大于查询位置 i 的元素置为负无穷;沿键维归一化,再乘 V。教学算例中,缩放后的 logits [0,log 3] 对应概率 [0.25,0.75],值 [2,0] 与 [0,4] 得到输出 [0.5,3]。第一个位置屏蔽第二个键,结果就是 [2,0]。实现使用 PyTorch 稳定 softmax,不能沿批次维归一化。

把四个 [T,16] 头合成 [T,64] 后再投影。分数张量包含 16×4×32×32=65,536 个 float32,即每层仅分数就占 256 KiB。稠密注意力对 T 是二次复杂度,完整 block 还有特征投影成本。这个清晰实现不是 FlashAttention,也没有 KV cache。注意力权重只是混合系数,不能直接当成决策的因果解释。

逐步追踪多头拆分与合并

QKV 投影先将 [16,32,64] 变为 [16,32,192],chunk 再拆成三个宽度 64 的张量。每个张量 reshape 为 [16,32,4,16],交换时间轴与头轴后得到 [16,4,32,16]。分数矩阵为 [16,4,32,32];最后一轴索引 key,所以 softmax(dim=-1) 是对每个 query 可关注的位置归一化。下三角 buffer 会广播到 batch 与各个头;它随模型状态保存,但不是优化器更新的参数。

实现代码节选 · 运行时请使用完整项目

class Attention(nn.Module):
    def __init__(self, width, heads, context):
        super().__init__()
        assert width % heads == 0
        self.heads, self.dim = heads, width // heads
        self.qkv = nn.Linear(width, 3 * width)
        self.out = nn.Linear(width, width)
        self.register_buffer('mask', torch.ones(context, context, dtype=torch.bool).tril())

    def forward(self, x):
        b, t, c = x.shape
        q, k, v = self.qkv(x).chunk(3, dim=-1)
        q, k, v = [a.view(b, t, self.heads, self.dim).transpose(1, 2) for a in (q, k, v)]
        scores = q @ k.transpose(-2, -1) / math.sqrt(self.dim)
        scores = scores.masked_fill(~self.mask[:t, :t], float('-inf'))
        mixed = scores.softmax(dim=-1) @ v
        return self.out(mixed.transpose(1, 2).contiguous().view(b, t, c))

加权聚合后得到 [16,4,32,16],先交换回原轴顺序,再 contiguous,最后把四个头合并为宽度 64 并做输出投影。漏掉轴交换会把时间位置与头特征混在一起。缩放分母是每头维度的 √16=4,而不是模型宽度的 √64=8。如果在 softmax 后直接清零且不重新归一化,总概率会减少;这里是在归一化之前遮罩分数。

因果注意力:从遮罩到加权向量

小屏幕可横向查看,或打开原尺寸图。 查看原尺寸图

因果注意力:从遮罩到加权向量. 行表示 query 位置,列表示 key 位置;softmax 之前将上三角位置遮住。取第二行的教学分数 [0, ln 3, −∞],softmax 得到 [0.25, 0.75, 0]。若前两个 value 向量为 [2,0]、[0,4],则输出为 [0.5,3];第三个 value 无论是什么都不参与。这里是人为构造的算例,不是训练模型的实测注意力。
行表示 query 位置,列表示 key 位置;softmax 之前将上三角位置遮住。取第二行的教学分数 [0, ln 3, −∞],softmax 得到 [0.25, 0.75, 0]。若前两个 value 向量为 [2,0]、[0,4],则输出为 [0.5,3];第三个 value 无论是什么都不参与。这里是人为构造的算例,不是训练模型的实测注意力。

5. 逐个追踪解码器张量

取 条序列、 个位置、 个特征、 个头、 层。查询 [256,64] 的 token embedding 后得到 [16,32,64]。可学习位置表 [32,64] 沿批次维广播相加。没有位置信息,注意力无法完整区分相同 token 集合的不同排列。

每个预归一化 block 有两次残差更新:先对 LayerNorm(X) 做注意力,再对新状态归一化后通过前馈网络。前馈网络逐位置执行 64→256、GELU、256→64。注意力混合位置,前馈层转换特征。残差保留穿过网络深度的直接路径,但不意味着所有优化困难都会消失。

两层之后,最终 LayerNorm 和独立的 [64,256] 投影产生 [16,32,256] logits。输出权重特意不与输入 embedding 共享。包括偏置和归一化参数,共 134,912 个可训练参数;float32 参数本身占 539,648 字节,此外还有梯度、Adam 动量和中间激活,不能把参数大小当成训练总内存。

LayerNorm 对每个 token 的 D 个特征单独计算均值与方差,再施加学习得到的缩放与偏置,不混合样本,也不偷看未来。GELU 是平滑非线性门控;没有非线性,连续逐位置线性映射会折叠成一个线性映射。block 公式按单 token 列向量书写:W₁ 为 [4D,D],W₂ 为 [D,4D];Python Linear 按此形状存权重,实际让输入行向量乘权重转置。

按依赖顺序组装解码器

依次实现 Attention、Block、TinyLM。nn.Module 会注册子层,使 model.parameters() 能找到全部可训练权重,state_dict() 能完整保存它们。token ID 用来索引 embedding 的行,并不是按数值大小参与乘法。位置 embedding 区分同一字节出现在不同位置的情况。残差分支必须输出与输入相同的 [B,T,D] 形状,因为相加是逐元素操作。两个 block 处理上下文特征,最后的线性输出层把 64 维特征映射为 256 个未经归一化的类别分数。

实现代码节选 · 运行时请使用完整项目

class Block(nn.Module):
    def __init__(self, c):
        super().__init__()
        d=c['width']
        self.n1, self.n2 = nn.LayerNorm(d), nn.LayerNorm(d)
        self.attn = Attention(d, c['heads'], c['context'])
        self.ff = nn.Sequential(nn.Linear(d, 4*d), nn.GELU(), nn.Linear(4*d, d))

    def forward(self, x):
        x = x + self.attn(self.n1(x))
        return x + self.ff(self.n2(x))

class TinyLM(nn.Module):
    def __init__(self, cfg=CFG):
        super().__init__()
        self.cfg = cfg
        self.tokens = nn.Embedding(cfg['vocab'], cfg['width'])
        self.positions = nn.Embedding(cfg['context'], cfg['width'])
        self.blocks = nn.Sequential(*[Block(cfg) for _ in range(cfg['layers'])])
        self.norm = nn.LayerNorm(cfg['width'])
        self.head = nn.Linear(cfg['width'], cfg['vocab'], bias=False)
        self.apply(self.init)

    @staticmethod
    def init(m):
        if isinstance(m, (nn.Linear, nn.Embedding)):
            nn.init.normal_(m.weight, std=.02)
            if getattr(m, 'bias', None) is not None: nn.init.zeros_(m.bias)

    def forward(self, ids):
        if ids.ndim != 2 or not 0 < ids.shape[1] <= self.cfg['context']:
            raise ValueError('Expected [batch, time], 1 <= time <= context')
        x = self.tokens(ids) + self.positions(torch.arange(ids.shape[1], device=ids.device))
        return self.head(self.norm(self.blocks(x)))

构造与重载模型时,统一以 CFG 定义架构。修改宽度、词表或层数会改变参数形状,旧检查点通常无法直接装入新模型。forward 明确拒绝超过 32 个位置的输入,避免访问位置表之外的数据。扩展上下文必须同时修改位置表与遮罩,并重新考虑注意力的平方级显存成本,而不只是放宽命令行输入限制。

原创训练参考图:虚线反馈更新可训练参数。生成使用保存权重,不执行优化器更新。
原创训练参考图:虚线反馈更新可训练参数。生成使用保存权重,不执行优化器更新。 查看原尺寸图
阶段输入 → 输出边界
嵌入[B,T] → [B,T,D]; T≤32
Q / K / V[B,T,D] → [B,H,T,D/H]64 ÷ 4 = 16
注意力[B,H,T,T] × [B,H,T,D/H]j≤i
输出投影[B,T,D] → [B,T,V]134,912 个参数
损失[BT,V] + [BT] → 标量nats / 字节

6. 损失、梯度与参数更新

训练采用 teacher forcing:每个位置看到真实前序字节,而不是此前采样的预测。把 logits [B,T,V] 展平为 [BT,V],目标展平为 [BT],将原始 logits 传入 cross_entropy。它稳定地组合 log-softmax 和负对数似然,前面不要额外 softmax。若正确字节概率为 0.25,该项损失为 − nats。平均 token 损失对应当前采样方式下的负对数似然估计。

自动微分沿 embedding、注意力和前馈层计算导数。每步先清空旧梯度,计算损失、反向传播,把整体梯度范数裁剪至 1,再执行 AdamW。它用梯度的一阶和二阶矩调整更新幅度,解耦权重衰减则单独收缩参数。教学脚本对所有参数统一衰减;生产配方常排除偏置和归一化参数,应把这作为明确实验选择。

标称峰值学习率为 0.002,20 步预热因子与余弦因子相乘,后者在末尾趋近 10%。学习率是更新乘数,不是“学会的概率”。过大会不稳定,过小会看似没有进展。保存优化器动量、配置、步数和随机状态,为恢复训练提供基础。本脚本验证重载,但没有 resume 命令;真正恢复还必须还原学习率进度和数据顺序。

单个目标类别 y 与 logits z 的交叉熵导数为 pᵢ−1[。正确类预测过低时导数为负,梯度下降会抬高其 logit。256 字节均匀预测的损失是 nats/byte,可作量级参照。AdamW 中 g 是裁剪后梯度,m、v 为矩估计,β、β、ε⁸、λ,η 是当前学习率。优化器 β 与 LayerNorm 的学习偏置 β 无关。

要把标量损失与实际参数联系起来,可以单独观察输出层。令 h 为形状 [D,1] 的归一化隐状态列向量,W 为实际存储的输出权重矩阵 [V,D], 得到 [V,1] 的 logits。概率向量减去目标的 one-hot 向量,得到 ᵧ。外积 ghᵀ 给出每个输出权重的梯度,Wᵀg 则把误差信号传回隐状态。自动微分继续沿 block 和 embedding 传播这条链。BT 个位置的平均损失会对这些贡献取平均,因此单个位置的导数不等于整个批次梯度。

先实现一次更新,再组成训练循环

每步获取新的 x、y 批次,设置学习率并清空梯度。loss() 将 16×32 个位置展开为 512 个分类样本,每个样本有 256 种字节类别。backward() 把梯度累积到 parameter.grad,opt.step() 再利用这些梯度更新权重;除非明确设计梯度累积,否则必须清空上一步梯度。300 步处理 153,600 个采样目标位置,其中包含重复;这个数字既不是语料的独立字节数,也不是训练 epoch 数。

实现代码节选 · 运行时请使用完整项目

def loss(model, x, y):
    logits=model(x)
    return F.cross_entropy(logits.reshape(-1, CFG['vocab']), y.reshape(-1))
opt=torch.optim.AdamW(model.parameters(),lr=.002,weight_decay=.01)
    before=heldout_loss(model,val)
    for step in range(args.steps):
        model.train();x,y=batch(train,generator)
        lr=.002*min((step+1)/20,1)*(.1+.9*.5*(1+math.cos(math.pi*step/args.steps)))
        for group in opt.param_groups:group['lr']=lr
        opt.zero_grad(set_to_none=True);value=loss(model,x,y)
        if not torch.isfinite(value):raise RuntimeError('nonfinite loss')
        value.backward();nn.utils.clip_grad_norm_(model.parameters(),1.0);opt.step()

调度器把预热因子与余弦因子相乘;余弦从预热期间就开始变化,所以实际最大值略低于标称的 0.002。训练后在检查点字典中分别保存模型参数与优化器状态;梯度本身不是训练好的模型。保存的优化器和随机状态为续训提供材料,但本项目生成时只加载模型权重,尚未实现与不中断训练完全一致的恢复逻辑。

从预测误差到权重更新

小屏幕可横向查看,或打开原尺寸图。 查看原尺寸图

从预测误差到权重更新. 这个简化输出层只有一个输入特征 h=2、两个类别,目标为 y=0。梯度更新会抬高目标类别的 logit,并压低另一类别的 logit。为了展示每一步计算,图中使用学习率 0.1 的普通 SGD;随文训练代码实际采用梯度裁剪与 AdamW。此图是手算示例,不是实测训练步骤,也不保证每次更新都降低验证损失。
这个简化输出层只有一个输入特征 h=2、两个类别,目标为 y=0。梯度更新会抬高目标类别的 logit,并压低另一类别的 logit。为了展示每一步计算,图中使用学习率 0.1 的普通 SGD;随文训练代码实际采用梯度裁剪与 AdamW。此图是手算示例,不是实测训练步骤,也不保证每次更新都降低验证损失。

7. 从检查点到文本生成

推理先编码非空提示词,保留最后 32 字节,运行解码器,只取最后位置的 logits。除以正温度,保留 top-k,再归一化并采样一个字节,追加后循环。温度小于一会使分布更尖,top-k 去掉尾部后重新归一化;两者都不自动提高事实可靠性。这里按固定字节数停止,没有 EOS token。

裁剪后每次把位置重新设为 0…31,并忘掉更早内容。重算整个窗口容易理解,却不适合长输出。KV cache 会保存历史键和值,但必须处理位置语义、失效和一致性;不能一边重置学习位置,一边直接追加缓存,期待输出仍相同。

UTF-8 解码会用替换字符处理不完整序列,所以任意生成可能出现替换字符。合成语料是 ASCII,基本绕开了此问题。要成为有用助手,还需要更广泛合法数据、足够容量、指令训练、部署系统和有证据的安全过程,增大参数并不能自动补齐。本模型也不足以驱动配套 Agent;后者另有面向本地指令模型的适配器。

在独立进程中加载检查点

将 generate.py 与 tiny_lm.py 放在同一目录,通过 import TinyLM 复用架构;main 保护条件避免导入时意外启动训练。把检查点加载到 CPU,依据保存的 config 重建结构,再加载 model 状态并切换到 eval 模式。模型构造中的初始化也会消耗随机数,所以应在构造完成后再次设置采样种子。这样训练产物与推理入口相互独立,同环境同种子的重复生成也更容易比较。

实现代码节选 · 运行时请使用完整项目

"""Generate from a trusted checkpoint without retraining."""
import argparse,torch
from tiny_lm import TinyLM
p=argparse.ArgumentParser();p.add_argument('checkpoint');p.add_argument('--prompt',default='node 10');p.add_argument('--seed',type=int,default=42)
a=p.parse_args();torch.set_num_threads(1);torch.manual_seed(a.seed)
s=torch.load(a.checkpoint,map_location='cpu',weights_only=True)
m=TinyLM(s['config']);m.load_state_dict(s['model']);m.eval()
torch.manual_seed(a.seed)
print(m.generate(a.prompt))

训练命令结束后执行 python generate.py tiny.pt --prompt "node 10"。返回文本包括原始提示词及新生成的 80 个字节。这是命令行语言模型,不是 HTTP API,也没有指令微调或 Agent 协议。后续可以增加带输入限制与排队的独立推理服务,但在真正实现前不能把它当作现有能力。只加载可信检查点;weights_only 能减少加载器暴露面,却不能证明文件来源可信。

自回归生成:每次追加一个字节

小屏幕可横向查看,或打开原尺寸图。 查看原尺寸图

自回归生成:每次追加一个字节. 每轮复用同一组固定权重,只用最后位置的 logits 选择下一个字节。图中假设依次采到 C 和换行,仅用于展示流程,并不表示训练模型必然生成这两个字节。序列超过 32 字节后,下一轮前向计算只保留最近 32 字节,并重置学习位置编号;当前实现会重新计算注意力,没有 KV cache。
每轮复用同一组固定权重,只用最后位置的 logits 选择下一个字节。图中假设依次采到 C 和换行,仅用于展示流程,并不表示训练模型必然生成这两个字节。序列超过 32 字节后,下一轮前向计算只保留最近 32 字节,并重置学习位置编号;当前实现会重新计算注意力,没有 KV cache。

8. 实践、验证与面试练习

运行下方完整程序,检查输出形状、未来 token 不影响过去输出、上下文边界、一个输出权重的中心有限差分梯度及检查点 logits 完全一致。扩展实验固定语料、划分、种子、步数和验证协议,对照 bigram、一层/两层以及随机初始化/训练后模型。分开报告留出损失与奇偶规则正确率,至少重复三个种子。去掉因果遮罩只能用于泄漏反例,不能作为合法竞争模型。自有文本先核实许可与划分,再传 --text;不要无限次用验证集选择模型。

完整实现与命令

下载完整项目 ZIP

python tiny_lm.py --steps 300 --output tiny.pt
python generate.py tiny.pt --prompt 'node 10'
# Optional: your own licensed UTF-8 text, after data preparation
# python tiny_lm.py --text corpus.txt --steps 300 --output own.pt
tiny_lm.py

tiny_lm.py

"""Original Token Lab byte-level causal LM. Python 3.12 / torch 2.5.1 CPU.
Run: python tiny_lm.py --steps 300 --output tiny.pt
No pretrained weights, downloads, model API or third-party dataset.
"""
import argparse
import math
from pathlib import Path
import torch
from torch import nn
from torch.nn import functional as F

CFG = dict(vocab=256, context=32, width=64, heads=4, layers=2)

class Attention(nn.Module):
    def __init__(self, width, heads, context):
        super().__init__()
        assert width % heads == 0
        self.heads, self.dim = heads, width // heads
        self.qkv = nn.Linear(width, 3 * width)
        self.out = nn.Linear(width, width)
        self.register_buffer('mask', torch.ones(context, context, dtype=torch.bool).tril())

    def forward(self, x):
        b, t, c = x.shape
        q, k, v = self.qkv(x).chunk(3, dim=-1)
        q, k, v = [a.view(b, t, self.heads, self.dim).transpose(1, 2) for a in (q, k, v)]
        scores = q @ k.transpose(-2, -1) / math.sqrt(self.dim)
        scores = scores.masked_fill(~self.mask[:t, :t], float('-inf'))
        mixed = scores.softmax(dim=-1) @ v
        return self.out(mixed.transpose(1, 2).contiguous().view(b, t, c))

class Block(nn.Module):
    def __init__(self, c):
        super().__init__()
        d=c['width']
        self.n1, self.n2 = nn.LayerNorm(d), nn.LayerNorm(d)
        self.attn = Attention(d, c['heads'], c['context'])
        self.ff = nn.Sequential(nn.Linear(d, 4*d), nn.GELU(), nn.Linear(4*d, d))

    def forward(self, x):
        x = x + self.attn(self.n1(x))
        return x + self.ff(self.n2(x))

class TinyLM(nn.Module):
    def __init__(self, cfg=CFG):
        super().__init__()
        self.cfg = cfg
        self.tokens = nn.Embedding(cfg['vocab'], cfg['width'])
        self.positions = nn.Embedding(cfg['context'], cfg['width'])
        self.blocks = nn.Sequential(*[Block(cfg) for _ in range(cfg['layers'])])
        self.norm = nn.LayerNorm(cfg['width'])
        self.head = nn.Linear(cfg['width'], cfg['vocab'], bias=False)
        self.apply(self.init)

    @staticmethod
    def init(m):
        if isinstance(m, (nn.Linear, nn.Embedding)):
            nn.init.normal_(m.weight, std=.02)
            if getattr(m, 'bias', None) is not None: nn.init.zeros_(m.bias)

    def forward(self, ids):
        if ids.ndim != 2 or not 0 < ids.shape[1] <= self.cfg['context']:
            raise ValueError('Expected [batch, time], 1 <= time <= context')
        x = self.tokens(ids) + self.positions(torch.arange(ids.shape[1], device=ids.device))
        return self.head(self.norm(self.blocks(x)))

    @torch.no_grad()
    def generate(self, prompt, count=80, temperature=.8, top_k=20):
        if not prompt or temperature <= 0 or not 1 <= top_k <= self.cfg['vocab']:
            raise ValueError('Nonempty prompt, positive temperature, valid top_k required')
        self.eval()
        ids = torch.tensor([list(prompt.encode('utf-8'))], dtype=torch.long)
        for _ in range(count):
            logits = self(ids[:, -self.cfg['context']:])[:, -1, :] / temperature
            threshold = logits.topk(top_k).values[:, -1:]
            logits = logits.masked_fill(logits < threshold, float('-inf'))
            ids = torch.cat((ids, torch.multinomial(logits.softmax(-1), 1)), dim=1)
        return bytes(ids[0].tolist()).decode('utf-8', errors='replace')

def corpus():
    # Original synthetic sentences. Split document IDs BEFORE window extraction.
    docs = [f'node {i:03d}: status is {"ready" if i % 2 == 0 else "busy"}.\n' for i in range(120)]
    return ''.join(docs[:100]).encode(), ''.join(docs[100:]).encode()

def batch(raw, generator, size=16):
    data=torch.tensor(list(raw), dtype=torch.long)
    t=CFG['context']
    starts=torch.randint(len(data)-t, (size,), generator=generator)
    return torch.stack([data[i:i+t] for i in starts]), torch.stack([data[i+1:i+t+1] for i in starts])

def loss(model, x, y):
    logits=model(x)
    return F.cross_entropy(logits.reshape(-1, CFG['vocab']), y.reshape(-1))

@torch.no_grad()
def heldout_loss(model, raw):
    model.eval()
    data=torch.tensor(list(raw),dtype=torch.long)
    total, count=0.,0
    for i in range(0,len(data)-1,CFG['context']):
        t=min(CFG['context'],len(data)-1-i)
        x,y=data[i:i+t][None,:],data[i+1:i+t+1][None,:]
        total += loss(model,x,y).item()*t
        count += t
    return total/count

def checks(model):
    model.eval()
    x=torch.arange(12)[None,:]
    changed=x.clone();changed[:,7:]=200
    with torch.no_grad():
        a,b=model(x),model(changed)
    assert a.shape == (1,12,256)
    assert torch.allclose(a[:,:7],b[:,:7],atol=1e-6), 'future leak'
    try:model(torch.zeros(1,33,dtype=torch.long))
    except ValueError:pass
    else:raise AssertionError('context overflow accepted')
    # One coordinate of the readout gradient, central finite difference.
    target=torch.arange(1,13)[None,:]
    model.zero_grad(set_to_none=True)
    loss(model,x,target).backward()
    analytical=model.head.weight.grad[1,0].item()
    original=model.head.weight[1,0].item();eps=.01
    with torch.no_grad():
        model.head.weight[1,0]=original+eps;plus=loss(model,x,target).item()
        model.head.weight[1,0]=original-eps;minus=loss(model,x,target).item()
        model.head.weight[1,0]=original
    assert abs(analytical-(plus-minus)/(2*eps))<.002, 'gradient mismatch'

def main():
    p=argparse.ArgumentParser();p.add_argument('--steps',type=int,default=300)
    p.add_argument('--output',default='tiny.pt');p.add_argument('--text',help='Optional owned UTF-8 corpus; chronological 90/10 split')
    args=p.parse_args()
    if args.steps<1:raise ValueError('steps must be positive')
    torch.set_num_threads(1);torch.manual_seed(42);torch.use_deterministic_algorithms(True)
    generator=torch.Generator().manual_seed(123)
    train,val=corpus()
    if args.text:
        raw=Path(args.text).read_text(encoding='utf-8').encode();cut=int(.9*len(raw));train,val=raw[:cut],raw[cut:]
    if min(len(train),len(val))<=CFG['context']:raise ValueError('each split must exceed context')
    model=TinyLM();checks(model)
    opt=torch.optim.AdamW(model.parameters(),lr=.002,weight_decay=.01)
    before=heldout_loss(model,val)
    for step in range(args.steps):
        model.train();x,y=batch(train,generator)
        lr=.002*min((step+1)/20,1)*(.1+.9*.5*(1+math.cos(math.pi*step/args.steps)))
        for group in opt.param_groups:group['lr']=lr
        opt.zero_grad(set_to_none=True);value=loss(model,x,y)
        if not torch.isfinite(value):raise RuntimeError('nonfinite loss')
        value.backward();nn.utils.clip_grad_norm_(model.parameters(),1.0);opt.step()
    after=heldout_loss(model,val)
    torch.save({'config':CFG,'model':model.state_dict(),'optimizer':opt.state_dict(),
                'step':args.steps,'rng':torch.get_rng_state(),'batch_rng':generator.get_state()},args.output)
    saved=torch.load(args.output,weights_only=True);restored=TinyLM(saved['config']);restored.load_state_dict(saved['model']);restored.eval();model.eval()
    probe=torch.tensor([[1,2,3]])
    assert torch.equal(model(probe),restored(probe)), 'checkpoint mismatch'
    checks(model)
    print(f'parameters={sum(p.numel() for p in model.parameters())}')
    print(f'validation_nats_per_byte: {before:.6f} -> {after:.6f}')
    print(f'validation_perplexity_per_byte={math.exp(after):.6f}')
    print('checks: shapes, causal mask, context bound, gradient, checkpoint passed')
    if not args.text and args.steps>=300:assert after<before, 'synthetic learning failed'
    torch.manual_seed(42);print('sample='+repr(model.generate('node 10')))

if __name__=='__main__':main()
generate.py

generate.py

"""Generate from a trusted checkpoint without retraining."""
import argparse,torch
from tiny_lm import TinyLM
p=argparse.ArgumentParser();p.add_argument('checkpoint');p.add_argument('--prompt',default='node 10');p.add_argument('--seed',type=int,default=42)
a=p.parse_args();torch.set_num_threads(1);torch.manual_seed(a.seed)
s=torch.load(a.checkpoint,map_location='cpu',weights_only=True)
m=TinyLM(s['config']);m.load_state_dict(s['model']);m.eval()
torch.manual_seed(a.seed)
print(m.generate(a.prompt))

实测输出与验证边界

本地执行环境为 Python 3.12、PyTorch 2.5.1+cpu,单 CPU 线程,初始化种子 42、批次种子 123,300 步。留出损失从 5.575623 降至 0.546086 nats/byte,字节困惑度 1.726483。这是合成状态语料测量,不是自然语言能力基准。生成中 node 046 被写成 busy,但偶数节点规则应为 ready:平均损失低不证明学会规则。验证每 32 字节重置上下文,按 token 数加权;不同平台可能略有数值差异。

parameters=134912
validation_nats_per_byte: 5.575623 -> 0.546086
validation_perplexity_per_byte=1.726483
checks: shapes, causal mask, context bound, gradient, checkpoint passed
sample='node 107: status is busy.\nnode 046: status is busy.\nnode 096: status is ready.\nnode 081'

首次运行后的排错指南

现象含义下一步
ModuleNotFoundError: torch运行中的 Python 找不到已安装依赖。激活 .venv;对照 python -m pip --version 与 python -c "import sys; print(sys.executable)",通过同一解释器安装。
检查点不存在或形状不兼容训练未完成、路径错误或架构配置已改变。使用 --output 指定的路径;先用保存的 config 构造模型再加载 state_dict,不要忽略形状错误;主动修改架构后重新训练。
损失低,但节点状态错误字节预测质量不等于任务规则准确率。按语料的奇偶规则检查生成标签,单独报告规则准确率;公平对照时固定训练设置与提示词。

原创模拟面试题,并非公司真实面试题

每题按 1–5 分评分:1 分能说出术语;2 分定义正确;3 分能走通具体算例;4 分能解释失败及应对;5 分能提出公平对照并说明证据不能证明什么。只有代码而无解释不能得满分。

1. 去掉因果遮罩后,模型为什么可能看起来特别好?

提示

在输入窗口中找到移位后的目标。

答案与分析

除最后位置外,下一个字节已出现在未来输入位置;未遮罩时训练能偷看,生成却不能。这是泄漏,不是建模提升。固定前缀、修改未来字节,早期 logits 必须不变。

2. 为什么困惑度 1.73 不能证明模型是有用助手?

提示

检查语料、单位和错误生成。

答案与分析

这是重复合成句式的字节困惑度,不是 BPE 困惑度,也不是事实或任务正确率。node 046 违反奇偶规则。需要独立任务与分布,报告编码和划分。

3. 同样步数就能公平比较宽度 64 和 128 吗?

提示

区分相同数据暴露与相同计算量。

答案与分析

同批次和步数控制数据暴露,不控制 FLOPs 或内存;投影成本约随 D² 增长,注意力还依赖 T。报告固定数据对照,必要时再做实测计算预算对照,并重复种子。

4. 为什么只保存权重不足以精确恢复训练?

提示

追踪影响下一次更新的全部状态。

答案与分析

Adam 动量、步数/调度、随机生成器与数据位置都会影响更新,还要保留配置及兼容软件。参考程序保存了大部分状态但只实现重载;恢复功能要还原依赖,并对照连续与中断训练。

把基础真正讲清楚

回顾本方法依赖的共同基础,再通过算例与检查定位理解上的缺口。

神经网络首先是一串函数的复合,不是一组需要背诵的名词。先看形状为 [B,d] 的输入 X:B 表示样本数,d 表示每个样本的特征数。它乘以形状为 [d,h] 的权重 W,得到每个样本的 h 个加权和;形状为 [h] 的偏置再逐列加上去。

你需要能手算其中一个输出元素,并解释为什么相乘的内部维度必须相等。随后加入非线性激活;如果只堆叠仿射层,无论多少层,整体仍然只是仿射变换。

这里采用样本按行排列的约定。后文单样本按列向量计算时,权重写成 [h,d],正好是这里权重的转置;两种写法描述同一个映射。

先独立推理,再看答案

导数描述一个量对微小变化的敏感程度。链式法则把“损失对预测有多敏感”和“预测对权重有多敏感”连接起来。考虑单个样本 、,预测值为 w×x,损失为 (预测值−y)²/2。在 时,损失和它对 w 的导数是多少?若学习率为 0.1,先预测更新后的权重,再展开答案。

逐步解析

预测值为 2,损失为 0.5。损失对预测值的导数是 −1,预测值对 w 的导数是 2,因此 dL/。梯度下降得到 w_×(−2)=1.2,新预测值为 2.4,新损失为 0.18。反向传播负责计算导数,优化器负责决定如何用导数更新参数。把这两个步骤混为一谈,会让训练故障很难定位。

为什么在应用中重要

XOR 实验把这个标量计算扩展到隐藏表示。(0,0) 和 (1,1) 的标签是 0,(0,1) 和 (1,0) 的标签是 1,一条直线无法把两类分开。非线性隐藏层可以改变表示,使最后的线性分类器能够分离两类。这体现了语言与视觉模型学习特征的基础思想,但不代表这个小网络拥有那些模型的能力。

怎样证明自己理解了

继续之前,逐步标注前向计算的张量形状,在光滑点用中心有限差分核对解析梯度,并改变差分步长观察舍入误差。然后在相同数据与训练预算下比较线性和非线性模型。训练损失低不等于对新输入有效:泛化需要单独的留出任务或划分,不能把记住 XOR 的四行数据称为泛化实验。

运行完整 Python 算例

Python 3.10+ · 仅标准库 · 确定性计算,无需随机种子 · 不联网。保存文件后执行下方命令。这些是教学检查,不是模型基准。

下载 Python · neural.py
python3 neural.py
# Python 3.10+; standard library; deterministic; no network.
from math import isclose

def loss(w):
    return (w * 2.0 - 3.0) ** 2 / 2

w, learning_rate = 1.0, 0.1
gradient = (w * 2.0 - 3.0) * 2.0
h = 1e-5
numeric = (loss(w + h) - loss(w - h)) / (2 * h)
assert isclose(gradient, numeric, abs_tol=1e-8)
w_new = w - learning_rate * gradient
assert isclose(w_new, 1.2)
assert isclose(loss(w_new), 0.18)
assert loss(w_new) < loss(w)
print("gradient=-2.0; weight=1.2; loss=0.18")

预期输出

gradient=-2.0; weight=1.2; loss=0.18

补齐先修知识 →

基础讲解更新:

延伸教程、论文与实现参考

资料核对日期:2026 年 11 月 10 日。实现、算例和图均为原创教学材料。文末教程提供互补学习路线,不代表背书,也不证明小项目复现了其模型。论文日期与本站发布日期分开标注。

  1. Nano AI · Build a language modelhttps://nano-ai.tech/articles/

    中文逐模块路线,从推理过渡到训练,适合与本篇完整小项目对照。

  2. Nano AI · GPT from scratchhttps://nano-ai.tech/articles/llm-from-scratch/

    对照重建 GPT-2 推理与本文随机初始化训练;该教程以预训练权重起步,目标不同。

  3. Andrej Karpathy · Neural Networks: Zero to Herohttps://karpathy.ai/zero-to-hero.html

    从反向传播到逐渐扩大的语言模型;如果梯度仍像黑盒,可从这里补基础。

  4. Sebastian Raschka · LLMs from scratchhttps://github.com/rasbt/LLMs-from-scratch

    配套书籍实现,适合进一步系统学习架构、训练与适配。

  5. Andrej Karpathy · nanoGPThttps://github.com/karpathy/nanoGPT

    理解小项目后阅读实际训练仓库,注意硬件与数据要求不同。

  6. Attention Is All You Needhttps://arxiv.org/abs/1706.03762

    原始 Transformer 论文,对照编码器—解码器与本文仅解码器简化。首次 2017-06-12;v7 为 2023-08-02。

    PDF · https://arxiv.org/pdf/1706.03762v7

  7. OpenAI · Language Models are Unsupervised Multitask Learners (2019)https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf

    GPT-2 历史报告,理解下一 token 预训练,不把 GPT-2 能力归给教学模型。

  8. PyTorch · cross_entropyhttps://docs.pytorch.org/docs/main/generated/torch.nn.functional.cross_entropy.html

    用于核对 logits、形状和优化器语义。链接文档跟随 main;可运行项目独立固定并测试于 PyTorch 2.5.1+cpu。

  9. PyTorch · AdamWhttps://docs.pytorch.org/docs/main/generated/torch.optim.AdamW.html

    用于核对 logits、形状和优化器语义。链接文档跟随 main;可运行项目独立固定并测试于 PyTorch 2.5.1+cpu。

带着问题看视频

观看 → 解释 → 实现 → 测试

以下为外部英文视频,字幕与可用性由 YouTube 提供。点击播放后才连接 YouTube,不发送实验输入。

下一步学什么

通过因果遮罩测试,比较缓存与完整计算的输出,再测速度。

实现与验收 → · 继续学习路线 →

预测、检验与证据记录

展开答案前先预测一个结果;练习后记录差异和迁移测试。记录仅存本地,在不同语言版本间共用。

打开记录/导出/清除 →

数学复核范围逐篇记录,不代表完成论文实证复现;可在笔记中记录疑似错误。 复核范围