一、预测下一个 token

先把「token」这个词说清。 它不是字，也不是词，是「模型眼里的最小单位」。英文里常见词可能是一个 token， 罕见词会被拆成几段；中文一个字可能一个 token，也可能两个字一个。 代码里的 def、return、( 基本都是单独的 token。 模型做的事，用一句话说完：给它前面的一串 token，它算出「下一个 token 最可能是什么」， 挑一个，接上去，再算下一个。 就这样一个循环，重复几百次，一段代码就出来了。 这里有个容易被忽略的点：它每次只做一次选择，不做全局规划。 它没有「先把整个函数想好再写」这一步—— 它是写一个字算一次，写下一个字的时候，前面写的东西已经变成「既定事实」了。 这就是为什么它一开始写歪了，后面会一路歪下去。 也正因为这样，它没法「回头改」。 它改代码的方式是「把前面那段重新生成一遍」—— 在你看来是「它改了第三行」，在它看来是「从第三行开始，后面全部重写」。 这个视角一换，很多行为就说得通了。

二、代码为什么特别适合这种预测

「猜下一个」这件事，难易程度取决于「有多少种合理的下一个」。 候选越少，越好猜；候选越多，越容易猜错。

代码的候选少，是因为它有大量硬约束： 括号必须配平、引号必须成对、缩进有语法含义、关键字后面只能跟特定几类东西。 这些约束把「可能性空间」压得很小——小到统计规律就能抓住。 自然语言没有这种硬约束。「我今天很」后面可以是高兴、累、忙、想你、 不想说话……每一种都合法，而且没有语法能排除掉任何一种。 所以同一个模型，在代码上显得聪明，在闲聊上显得平庸—— 不是它偏科，是这两件事的难度本来就不一样。

三、训练数据里有什么、没有什么

它见过的东西，大致是这些：GitHub 上的公开代码、技术文档、问答网站、博客、教程、issue 讨论。 这些量非常大，大到「常见的写法」它都见过。 但它没见过的东西同样关键：

这张表要记住，因为它解释了后面所有的「它怎么会这样」。 它犯的错，绝大部分不是「不会」，是「没见过」或者「见过旧的」。 还有一个更微妙的问题：它见过「坏代码」。 训练数据里既有好代码也有烂代码，而且烂代码往往更多（因为烂代码不需要通过审查就能上传）。 所以它默认写出来的东西，是「平均水平的代码」，不是「好代码」。 想要好代码，得靠规矩和审查，不能靠它自觉。

四、动手 Demo：用 2-gram 猜下一个 token，代码比中文好猜多少

这个 Demo 自己搭一个最小的语言模型：2-gram。 它的全部本事就是「数一数 A 后面出现过什么，挑最常见的那个」。 真模型只是把「前一个」换成「前几千个」，把「数数」换成「神经网络」——原理没变，毛病也没变。 要量两个数：困惑度（平均在几个候选里犹豫）、生成出来的东西能不能跑。 第二个数是这个 Demo 的重点——它生成的代码看着特别像代码，然后一跑就报错。

import collections, math, re

def tok(s):
    return re.findall(r"[A-Za-z_]\w*|\d+|[^\s\w]", s)

class NG:
    def __init__(self):
        self.c = collections.defaultdict(collections.Counter)

    def fit(self, t):
        for i in range(len(t) - 1):
            self.c[t[i]][t[i + 1]] += 1

    def guess(self, w):
        if w in self.c:
            return self.c[w].most_common(1)[0][0]

# 代码语料 vs 中文语料，各训一个，比困惑度与生成结果

实跑输出：

--------------------------------------------------------------------
用 2-gram 猜下一个 token，代码比中文好猜多少
--------------------------------------------------------------------


  ① 先把两段文字切成 token
  --------------------------------------------------------------------
  代码切出 43 个 token，中文切出 57 个 token。
  代码前 16 个：def total ( items ) : s = 0 for x in items : s =
  中文前 16 个：这 个 函 数 先 把 所 有 元 素 加 起 来 ， 然 后

  ② 一个极简的 2-gram：只看前一个 token 猜下一个
  --------------------------------------------------------------------
  这是语言模型的最小形态：数一数「A 后面出现过什么」，按频率挑最常见的那个。
  真模型只是把「前一个」换成「前几千个」，把「数数」换成「神经网络」。原理没变。

  ③ 同一个位置，几种可能
  --------------------------------------------------------------------
  代码里 def      后面出现过 2 种不同 token，最常见的是 ['total']
  代码里 return   后面出现过 3 种不同 token，最常见的是 ['s']
  代码里 =        后面出现过 2 种不同 token，最常见的是 ['0']
  代码里 (        后面出现过 1 种不同 token，最常见的是 ['items']

  ④ 猜得准不准：困惑度
  --------------------------------------------------------------------
  代码语料的困惑度 8.40
  中文语料的困惑度 23.12
  困惑度的意思是「平均在几个候选里犹豫」。数值越小越好猜。
  代码这边小 2.8 倍。
  ! 这个差距不是「代码简单」，是「代码的约束多」——括号必须配平、缩进有含义、
  关键字后面只能跟那几样。

  ⑤ 让它自己往下写 24 个 token
  --------------------------------------------------------------------
  生成：def total ( items ) : s = 0 for x in items ) : s = 0 for x in items ) : s
  ! 看着像代码，但它不是代码——它是「形状对的字符串」。

  ⑥ 拿去真跑
  --------------------------------------------------------------------
  写进 gen.py，跑一遍：退出码 1
  报错：SyntaxError: invalid decimal literal
  这就是语言模型和程序的区别：它保证「下一个 token 像那么回事」，不保证「整段能跑」。
  形状是学出来的，语义不是。

困惑度是 8.40 对 23.12，代码这边小 2.8 倍。 这个数说明的是「代码的局部规律强」，不是「模型懂代码」。 2-gram 只往前看一个 token，它依然「猜得很准」—— 因为它只需要知道「def 后面跟标识符」这种局部规律。 生成那一段更值得看：def total ( items ) : s = 0 for x in items ) : s = 0 …。 它完美地复现了代码的形状——有函数头、有冒号、有赋值、有循环关键字。 但它把括号配错了（items ) 前面没有左括号），而且 for 写在了冒号后面。 第六步是这一篇的落点：把这段生成的代码存成 gen.py 真跑一遍，退出码 1， 报 SyntaxError: invalid decimal literal。 形状是学出来的，语义不是。 它保证「下一个 token 像那么回事」，不保证「整段能跑」。 这个 2-gram 的毛病和真模型是同一类：局部看着很对，全局一跑就崩。 区别只在概率——2-gram 几乎必崩，真模型偶尔崩。 「偶尔崩」比「必崩」危险得多，因为它会让你放松警惕。

30 秒实验

1. 随便找一段你熟悉的代码，遮住下一行，自己猜两次。 猜对的那一刻，你就体会到了「为什么代码好猜」—— 因为你脑子里也在做同一件事：按约束排除候选。
2. 把同一段代码里的注释删掉再让模型读，看它的理解差多少。 注释是唯一「用自然语言写代码意图」的地方——删掉之后，很多决定就没法解释了。
3. 想一想：你项目里有哪些「它一定没见过」的东西？ 自研的框架、内部约定、私有的依赖——这些东西你如果不说，它只能按公开世界的惯例猜。

常见误区

1. 「它会思考，只是我们看不见过程。」 它没有「先想好再写」这一步——它是写一个算一个，写下的就是既定事实。 所谓「推理」，是它在 token 序列里复现了推理的写法，不是脑子里真有个推理器。
2. 「2-gram 这种玩具说明不了真模型。」 它说明的是「预测下一个」这个原理本身的局限，而这个局限真模型也有。 真模型只是把这个局限推到了很少发生的位置——很少发生不等于不发生。
3. 「它训练时见过那么多代码，肯定懂编程。」 见过不等于懂。 它见过大量「能跑的代码」，也见过大量「看起来能跑其实不能跑的代码」—— 而它分不出这两类的区别，因为它在训练时只学「下一个是什么」，没人告诉它「这段能不能跑」。

下一篇 2.2 讲它做一件事还需要什么：光会猜下一个 token 不够， 还得看得见上下文、能伸手读文件、能跑命令看结果——四样凑齐才能干活。

• ☐ （本篇完，下一篇 2.2 Codex 完成任务时依赖什么）

相关笔记

• AI 编程工具的三次演进：从代码补全到智能体
• 第二条边界：Codex 会犯三类工程错误
• 22 课 Harness 技术架构原理
• 🛠️ Codex快速入门 · 索引