第一次用基座模型的人,多半会经历同一个错愕。你输入「请把下面这句话翻译成英文:今天下雨了」,它不翻译,而是接着往下写「明天可能转晴,出门记得带伞」。你要求输出 JSON,它给你一段格式正确、内容胡说八道的散文。它不是不会,而是根本没在「答题」,它在做它被训练时唯一会做的事:根据前文,猜下一个最可能出现的词。

这就是预训练留下的痕迹。预训练让模型读遍大量文本,学会语言的样子,却没有教它「听指令」。很多人把这两件事混在一起,要么觉得模型能写文章就什么都会,要么觉得它不听格式就很笨。其实它只是一个极其熟练的续写器。

这篇讲三件事:下一 token 预测在优化什么,为什么这么简单的目标能逼出语法、事实和推理;数据从哪来、怎么洗;最后算一笔参数量与显存的粗账。

续写很顺,答题不行

把预训练模型当成一个函数来看:输入一段 token 序列,输出词表里每个 token 作为下一个位置的概率。它一次只预测一个位置,然后把预测出来的 token 接到输入后面,再预测下一个位置,如此循环。所谓「生成」,就是这样一步一步接出来的。

这个机制解释了大部分看起来奇怪的行为。它擅长补全,因为补全正是训练任务;它不擅长遵守格式,因为格式要求是「外部约束」,不在它的训练目标里;它容易一本正经地编,因为编出来的句子在语法和搭配上通顺,从似然的角度看并不差。

它不是在执行指令,而是在顺着你给的前文续写。理解这一点,后面讲微调和提示工程就不会觉得是玄学。

下一 token 预测到底在算什么

训练时,模型对每个位置都输出一组分数,叫 logits,可以理解为词表里每个候选 token 的原始打分,还没有归一化。softmax 把这些分数变成概率,所有候选加起来等于一。损失函数用的是交叉熵,简单说就是「正确 token 的预测概率越接近一,损失越小;越接近零,损失越大」。公式写成负对数:损失等于正确 token 概率的对数取负。

举个不带数字的例子。如果词表只有三个候选,正确 token 拿到的概率是零点七,另外两个分走剩下的零点三,这次预测的损失就小;如果正确 token 只拿到零点一,损失就大。训练的过程就是调整参数,让训练语料里真实出现的下一个 token 概率更高一点。所有位置的平均损失,就是常说的训练 loss。

为什么不用「预测对了几个」作为指标?因为准确率是离散的,猜对和猜错之间没有梯度,没法告诉模型「你刚才差一点」。交叉熵是光滑的,能给每个候选一个明确的调整方向。

还有一个工程细节叫教师强制:训练时喂给模型的前文是真实文本,不是模型自己上一步生成的内容。这样每个位置可以并行计算,训练效率高。代价是训练和推理之间存在一点错位,模型没见过自己犯错后的前文。这个错位在长文本生成里会累积,是后面讲推理和评测时会碰到的现象。

为什么这个目标能逼出语法、事实和推理

刚开始接触的人常有一个疑问:只猜下一个词,怎么可能学会「北京是中国首都」这种知识?答案在于,要在一个足够大的语料上把下一个词猜准,模型被迫建立了大量统计规律。

语法层:要猜准下一个词,必须先掌握词性、搭配、语序。主谓一致、介词搭配这些规则,会以统计约束的形式被模型吸收。
事实层:文本里反复出现「某国的首都是某城」,模型会把这些共现关系压进参数。见得多的事实记得牢,见得少的只能靠猜。
推理层:论证、代码、数学题里有大量「因为所以」「先定义再使用」的模式。学会这些模式,模型就能在相似结构里接着往下推。

换句话说,预测下一个词,等于对产生这些文本的过程做压缩。压缩得好,就得抓住语言规则、世界知识和行文习惯。这也解释了为什么它学到的知识是模糊的、统计性的,而不是数据库式的精确查询。

但也必须看到这个目标的局限。它奖励的是「像训练语料里会出现的下一个词」,不是「真实」。如果语料里充斥着错误说法,模型学到的就是错误说法;如果语料里没有人纠正某个谣言,模型没有动力去怀疑它。幻觉不是 bug,而是这个目标的自然产物:一个通顺但错误的句子,在似然意义下可能比一个正确但生硬的句子得分更高。

长尾知识也是同样的问题。某个冷门人物的生卒年,在语料里可能只出现一次。模型要么记住这一次,要么在需要时编一个看起来合理的。参数越多能记住的越多,但没有任何机制保证它记住的是对的。

数据从哪来

预训练数据的来源,大致可以分成几类,每一类都有自己的毛病。

常见的预训练数据来源与主要风险
网页抓取:量大,噪声和垃圾也多
书籍与论文:质量高,版权与格式麻烦
代码仓库:结构强,许可证与密钥要清
问答与论坛:口语真实,答案未必对
合成数据:可控,但会放大教师模型的错

网页抓取是最大的一块,通常来自公开的爬虫存档。它覆盖广、更新快,但夹杂着导航栏、广告、模板文本、机器翻译垃圾和大量重复。直接拿来训练,模型会学会写网页样板,而不是写文章。

书籍、论文、百科质量高、句子完整,是学习长程结构的好材料。但版权复杂,抽取时表格、公式、脚注经常变成乱码。代码仓库能显著提升模型的格式感和逻辑性,但许可证不统一,仓库里还可能混进密钥、内网地址、测试数据,必须在训练前清掉。

问答和论坛接近真实对话,但答案质量参差,还带着情绪和错误信息。合成数据成本低、可控,但教师模型的错误会被放大,样式也单一,训练久了模型会变得像教师模型的复印件。

数据决定了模型的上限:同样参数量、同样时长,数据干净、配比合理的模型,和什么都往里塞的模型,效果可能差一个档次,算法补不回来。

清洗:去重、过滤、配比、防污染

原始数据不能直接进训练。中间要过一条流水线,每一步都在损失信息,也都在提升质量。

第一步是抽取和语言识别。从网页里剥出正文,去掉导航、广告、脚本;判断这段文本是哪种语言,把语种标错的数据剔掉。第二步是质量过滤,常见做法包括长度阈值、符号比例、停用词比例、重复行比例,以及用一个小的质量分类器给文本打分。规则简单粗暴,但有效,能挡掉大部分垃圾。

第三步是去重,分精确去重和近似去重。精确去重按整段或按行做哈希,重复的直接删。近似去重用 MinHash 这类方法,把文本切成片段、估算相似度,把改了标题、加了广告的转载也找出来。去重不只为了省空间,更为了控制记忆:同一段文本在训练里出现几十次,模型更容易原样背出来,既浪费算力又有泄露风险。

第四步是安全与合规清理,去掉个人信息、联系方式、密钥和违法内容。第五步是配比,决定网页、书籍、代码、中英文各占多少;配比没有万能答案,要靠小规模消融实验来试。

最后一步常被忽略:防污染。如果评测集的题目混进了训练语料,跑出来的分数就是虚的。检测方法包括 n 元组重叠、近似匹配、在评测集里埋入特殊字符串看模型会不会复述。污染不一定是故意的,公开网页上有人讨论题目,爬虫就把它带进来了。

数据清洗没有「一遍过」。训练前洗一遍,训练后还要测模型是否特别擅长复述某段文本,这通常说明数据重复或污染过多。

训练不稳定是什么样

预训练不是「按下开始,等 loss 下降」。大规模训练里,不稳定是常态,只是程度不同。最常见的现象是 loss 曲线突然尖峰:前一秒还在缓慢下降,下一秒跳到一个明显更高的值,然后要么慢慢恢复,要么一路发散。

常见原因有几类。学习率过大,参数更新步子迈得太狠;某个批次的样本异常,比如超长重复文本、乱码、极端格式;数值溢出,尤其在低精度训练时,梯度或激活超出表示范围;数据顺序有问题,连续多个批次来自同一来源,分布偏移。

对应的手段也比较固定:学习率预热,开始时用小学习率,逐步升到目标值;梯度裁剪,把过大的梯度按比例缩回去;损失缩放,在低精度训练里放大损失再缩回,避免下溢;跳过异常批次并记录;定期存训练状态,出问题能回滚。

还有一类不写在 loss 里:硬件故障。某张卡悄悄算错、某次通信丢包,表现可能是 loss 缓慢变差。所以框架要能检测、能断点续训,恢复时优化器状态、调度器和数据加载位置都要对上。

Scaling law:只谈方向,不背数字

Scaling law 说的是:在相当大的范围内,损失随参数量、数据量、计算量增加,按幂律稳定下降。幂律就是规模每增加一个比例,损失按固定指数往下走。它是统计规律,不是保证,启发是规模、数据、算力要匹配。

如果模型参数量很大,训练 token 数却很少,模型没喂饱,参数浪费;反过来,token 很多而模型太小,容量不够,loss 降不下去。所谓「计算最优」就是在这个约束下找一个配比,让固定的算力花得最值。具体比例在不同数据、不同结构下不一样,而且这几年随着数据质量变化一直在调整,所以这里不给数字。

幂律也意味着收益递减。投入翻倍,loss 不会减半,只是按一个小于一的指数往下走。到了某个阶段,继续堆规模的钱,可能不如把数据洗干净、把配比调对、把评测做准。

对做业务的人来说,它最大的用处是判断「该不该自己训」。开源模型够用,就微调或检索;数据独有、量足够大、任务够宽,才值得继续预训练。规模不是目的,单位成本下的效果才是。

算一笔粗账:参数与显存

下面这段程序按一个常见的结构假设,粗估参数量和混合精度训练显存。它不连接真实框架,纯粹是乘法和单位换算。假设是 32 层、隐藏维度 4096、前馈维度四倍、词表三万二、批大小 8、序列长度 2048。

# -*- coding: utf-8 -*-
# 粗估:参数量与混合精度训练显存,按公开的常见结构假设,不是实测

layers = 32
d_model = 4096
d_ff = 4 * d_model
vocab = 32000
batch = 8
seq = 2048

# 每层参数:Q/K/V/O 四个 d*d 矩阵,MLP 两个 d*d_ff 矩阵;偏置忽略
per_layer = 4 * d_model * d_model + 2 * d_model * d_ff
embed = vocab * d_model
total = per_layer * layers + embed

print("结构假设: layers=%d d_model=%d d_ff=%d vocab=%d" % (layers, d_model, d_ff, vocab))
print("每层参数: %.3f 亿" % (per_layer / 1e8))
print("嵌入参数: %.3f 亿" % (embed / 1e8))
print("总参数: %.3f 亿 (约 %.2f B)" % (total / 1e8, total / 1e9))
print()

fp16 = 2
fp32 = 4
weights = total * fp16
grads = total * fp16
master = total * fp32
adam_m = total * fp32
adam_v = total * fp32
optim = master + adam_m + adam_v

# 激活粗估:每层每 token 约 20 个 d 维向量的读写。不含注意力分数矩阵,未计重计算
act_bytes = layers * batch * seq * d_model * 20

def gb(n):
    return n / 1024 ** 3

print("权重 bf16:        %.2f GiB" % gb(weights))
print("梯度 bf16:        %.2f GiB" % gb(grads))
print("优化器状态 fp32:  %.2f GiB" % gb(optim))
print("  其中主权重:     %.2f GiB" % gb(master))
print("  其中一阶动量:   %.2f GiB" % gb(adam_m))
print("  其中二阶动量:   %.2f GiB" % gb(adam_v))
print("激活粗估:        %.2f GiB  (batch=%d seq=%d)" % (gb(act_bytes), batch, seq))
print("合计:            %.2f GiB" % gb(weights + grads + optim + act_bytes))
print()
print("每卡放不下时: 参数/梯度/优化器状态按卡数切分,激活与临时缓冲仍随 batch 增长")
for n in (8, 16, 32):
    print("  若 %d 卡切分参数类: %.2f GiB/卡 + 激活 %.2f GiB" % (n, gb(weights + grads + optim) / n, gb(act_bytes)))
python train_budget.py
结构假设: layers=32 d_model=4096 d_ff=16384 vocab=32000
每层参数: 2.013 亿
嵌入参数: 1.311 亿
总参数: 65.735 亿 (约 6.57 B)

权重 bf16:        12.24 GiB
梯度 bf16:        12.24 GiB
优化器状态 fp32:  73.46 GiB
  其中主权重:     24.49 GiB
  其中一阶动量:   24.49 GiB
  其中二阶动量:   24.49 GiB
激活粗估:        40.00 GiB  (batch=8 seq=2048)
合计:            137.95 GiB

每卡放不下时: 参数/梯度/优化器状态按卡数切分,激活与临时缓冲仍随 batch 增长
  若 8 卡切分参数类: 12.24 GiB/卡 + 激活 40.00 GiB
  若 16 卡切分参数类: 6.12 GiB/卡 + 激活 40.00 GiB
  若 32 卡切分参数类: 3.06 GiB/卡 + 激活 40.00 GiB

这些数字是粗估,不是实测,真实训练未在本机跑过。第一,参数只算了注意力四个矩阵和前馈两个矩阵,没算偏置、归一化、位置编码;第二,优化器按 Adam 的主权重加一阶、二阶动量,每个参数占十二字节,加上权重和梯度各两字节,合计十六字节;第三,激活按每层每 token 二十个隐藏维度向量估,把所有层的激活都留着,属于偏保守的上界。

量级很清楚:六点五七 B 参数的模型,混合精度全套训练状态就要一百三十多 GiB,单卡放不下。实际训练会把权重、梯度、优化器状态切到多张卡上,再用激活重计算换显存。切分后每卡压力下降,但通信开销上来。

预训练是重资产生意:要集群、存储、网络、容错和整套数据管线。对多数团队,从零预训练不划算,拿开源权重继续预训练或微调更现实。

出了问题先看哪里

现象真实原因第一步查什么
续写流畅,但不按格式答题预训练目标只有下一 token 预测,没有指令数据确认模型是否经过指令微调,检查对话模板
模型非常自信地说错事实似然目标奖励通顺,不直接奖励真实查语料里该事实的出现次数与是否有纠正文本
loss 突然尖峰后不下降学习率过大、异常批次或数值溢出看该步梯度范数、学习率、样本文本
loss 正常但下游任务很差数据配比不对,或评测集被污染做训练集与评测集的 n 元组重叠检查
同规模模型效果差一截数据质量、去重率、训练 token 数不同对比语料来源、去重比例、实际训练的 token 数
显存够却仍然跑不起来激活、临时缓冲、通信区被低估按权重、优化器、激活三项分别估,再开激活重计算
中文能力明显偏弱中文语料占比低,或清洗时被大量过滤统计训练语料的语种分布和中文留存率

边界与代价

预训练解决的是「会语言」,不解决「听话」。一个基座模型可以写诗、补代码、续写合同,但你让它按指定格式输出,它往往不配合。这不是它不聪明,是它没被教过。要让模型成为助手,还需要指令微调和偏好对齐,那是下一篇和后续文章的内容。

预训练也解决不了知识更新。模型的知识停在训练数据截止的那一天,之后发生的事它不知道。想让它知道,要么重新训练,要么外挂检索,要么在微调数据里补。三条路都有代价:重训贵,检索依赖外部系统,微调容易只记住表面说法。

数据和法律是另一条边界:版权、代码许可证、个人信息处理各有要求。数据来源要能追溯,清洗日志要留。

最后是评估。训练 loss 只说明拟合程度,说明不了能力。要看下游任务、人工评测和业务验收集;没有验收集的预训练,等于蒙着眼睛开车。

当天能验证的练习

  1. 把文中脚本的批大小改成 1、8、16,记录激活粗估的变化,并解释为什么总显存不会随批大小等比例下降。
  2. 取一份公开语料的一小段,按行做哈希去重,统计重复行占比,再估算全量去重能省多少训练 token。
  3. 构造十条训练样本,故意把三道评测题原文混进去,写一个 n 元组重叠脚本把它们找出来。
  4. 手算一个五分类的交叉熵:给定一组概率,算出正确类别的损失,再和脚本结果对齐,确认自己理解了口径。
  5. 找一段公开的训练日志或自己跑的小模型日志,标出预热、尖峰、恢复三个位置,各写一条可能原因。

这五个练习不需要 GPU,全部可以在本机用标准库完成。做完之后,你对「预训练在学什么」的理解应该能从比喻落到具体的数字和现象上。

下一篇:微调

预训练把模型变成了一个合格的续写器,但你要的是能听指令、守格式、按业务口径回答的助手。这中间隔着一层训练,叫微调。下一篇讲全参微调、LoRA 和指令微调三者的区别与代价,也会解释为什么很多人微调完格式学会了,原来会的东西却忘了。下一篇的标题是《微调:全参、LoRA 与指令微调的区别和代价》。