大模型连"数数"都会数错，这说明了什么？

有一天我突发奇想，给 AI 一串 0 和 1，让它数出里面有多少个 1。结果它数错了。一个能写代码、能翻译、能做数学题的 AI，居然数不清一串数字里有几个 1？这件事让我对大模型的"聪明"产生了深刻的怀疑，也让我真正理解了它的能力边界。

---

第一章：实验现场

我给 AI 出了一道幼儿园级别的题：

我：请数一下 10110010110101 中有多少个 1？

AI：这串数字中有 8 个 1。

我自己数了一下：1-0-1-1-0-0-1-0-1-1-0-1-0-1，应该是 8 个。嗯，这次对了。

那加长一点呢？

我：请数一下 101100101101010011010110 中有多少个 1？

AI：这串数字中有 13 个 1。

我写了段代码验证：

s = "101100101101010011010110"
print(s.count("1"))  # 输出：14

错了。少数了一个。

再来一次，换一串更长的：

我：请数一下 1011001011010100110101101011001011010 中有多少个 1？

AI：这串数字中有 20 个 1。

s = "1011001011010100110101101011001011010"
print(s.count("1"))  # 输出：21

又错了。

一个能写出完美快速排序的 AI，数不清一串数字里有几个 1。这到底是怎么回事？

---

第二章：它根本没在"数"

我们数数时，脑子里是这样的：

1  → 计数器 = 1
0  → 跳过
1  → 计数器 = 2
1  → 计数器 = 3
0  → 跳过
0  → 跳过
1  → 计数器 = 4
...

从左到右，逐个扫描，遇到 1 就加 1，最后报出计数器的值。

你以为 AI 也是这样做的？

它不是。它根本没有"逐个扫描"的能力。

大模型的 Transformer 架构是并行的——它一次性看到所有内容，做一次矩阵运算，然后直接输出答案。它没有循环，没有计数器，没有"一个一个来"的机制。

这就像让你"扫一眼"一把撒在桌上的豆子然后报数量——7 颗以下你能"扫一眼"就说对，再多你就必须一颗颗数了。大模型永远停留在"扫一眼"的阶段。

---

第三章：它看到的甚至不是一个个字符

问题比"不会数"更深——大模型看到的东西和你看到的就不一样。

你看到的是 14 个独立的字符：

1  0  1  1  0  0  1  0  1  1  0  1  0  1

大模型看到的是经过分词器（Tokenizer）切割后的几个"token"：

你看到的：  1  0  1  1  0  0  1  0  1  1  0  1  0  1

分词器可能切成：
  "101" | "100" | "101" | "101"

或者：
  "10" | "110" | "010" | "1101" | "01"

分词器不是按单个字符切的，而是按训练语料中的统计频率来切的。“101” 如果在训练数据里频繁出现，就会被当成一个整体。

这意味着什么？模型拿到的不是 14 个字符，而是 4~5 个 token 块。它要从这些块里数出 “1” 的个数，就好比让你从这堆东西里数出字母 “a” 的个数：

你看到的不是：b a n a n a
而是：        "ban" "ana"

你还能一眼看出有 3 个 a 吗？困难多了。

AI 面对的是一个被切碎重组的输入，还要在没有计数器的情况下给出精确答案。它能猜对短序列已经很不容易了。

---

第四章：它的"数数"实际上是在估算

既然不能逐个扫描，那短序列它是怎么答对的？

大概率靠的是这些策略：

策略 1：模式记忆

"111"    → 训练数据里见过无数次 → 答案是 3
"1010"   → 训练数据里见过无数次 → 答案是 2
"11001"  → 训练数据里见过    → 答案是 3

短的序列直接背答案就行了。

策略 2：估算

看到一串很长的 01 序列
大概感觉 1 占了一半多一点
36 个字符 → 估计 20 个
（不是数的，是猜的）

这解释了为什么它的错误总是"差一两个"而不是"差十个"——估算虽然不精确，但大方向是对的。

策略 3：碰运气

对于中等长度的序列（10~20 个字符）
有时候估对了，有时候估错了
看起来像是"有时候数对有时候数错"
其实根本就不是在数

---

第五章：一个有趣的补救——让它"自言自语"

如果你换一种问法，准确率会大幅提升：

我：请逐个检查 10110010110101 中每一位，标记是 0 还是 1，最后数出 1 的总数。

AI：
  第 1 位：1 → 计数=1
  第 2 位：0 → 计数=1
  第 3 位：1 → 计数=2
  第 4 位：1 → 计数=3
  第 5 位：0 → 计数=3
  第 6 位：0 → 计数=3
  第 7 位：1 → 计数=4
  第 8 位：0 → 计数=4
  第 9 位：1 → 计数=5
  第 10 位：1 → 计数=6
  第 11 位：0 → 计数=6
  第 12 位：1 → 计数=7
  第 13 位：0 → 计数=7
  第 14 位：1 → 计数=8

  共有 8 个 1。 ✓

这就是所谓的 Chain-of-Thought（思维链）。为什么"自言自语"就能数对了？

因为 Transformer 没有工作内存——没有地方暂存"当前数到了几"。但当你让它把中间过程写出来时，输出文本本身就变成了工作内存：

没有思维链：
  输入 → [一次矩阵运算] → 直接输出答案
  没有地方存"数到第 7 个了，当前计数是 4"

有思维链：
  输入 → 生成"第 1 位：1 → 计数=1"
       → 把这段话作为上下文，继续生成"第 2 位：0 → 计数=1"
       → 把前两段话作为上下文，继续生成...
       
  每一步的输出都被"存"在了文本里
  后续的预测可以"读"到前面的中间结果
  文本充当了"草稿纸"

模型用"说出来"代替了"记在脑子里"。 这也是为什么 OpenAI 的 o1 模型要生成那么长的"思考过程"——不是在"深度思考"，而是需要大量的中间文本来当草稿纸。

但即便用了思维链，如果序列足够长，它仍然会数错——因为分词器的问题依然存在，它可能把 “10” 看成一个 token，读不出里面有 1 个 1 和 1 个 0。

---

第六章：这件事告诉我们什么

1. 大模型不是通用计算机

通用计算机（图灵机）：
  ✓ 有内存（可以存中间结果）
  ✓ 有循环（可以一个个处理）
  ✓ 有计数器（可以精确计数）

大模型（Transformer）：
  ✗ 没有可读写的内存
  ✗ 没有循环
  ✗ 没有计数器
  ✓ 有一次性的并行矩阵运算

→ 大模型在计算能力上是弱于图灵机的
→ 它能做到的事情，都是"一次前向传播"能解决的
→ 需要多步精确操作的任务，天然就是它的盲区

2. 擅长的和不擅长的，界限清晰

擅长（模式匹配、关系判断）：
  ✓ 这两句话是不是一个意思？
  ✓ 这段代码大概率下一行是什么？
  ✓ 这篇文章的情感是正面还是负面？
  ✓ 把这段中文翻译成英文

不擅长（精确计数、精确操作）：
  ✗ 数一串数字里有几个 1
  ✗ 数一段话里有几个字
  ✗ 精确反转一个字符串
  ✗ 多位数精确乘法

有一个规律：如果一个任务你需要一步一步做、中间需要记住东西，大模型就大概率会出错。如果一个任务你能"凭感觉"一下子给出答案，大模型就大概率能做对。

3. "聪明"和"精确"是两回事

大模型很"聪明"：
  能写诗、能辩论、能写代码、能总结文章
  这些都是"大方向对就行"的任务

大模型不"精确"：
  数不清数字、算不准乘法、记不住长文本的具体细节
  这些都是"差一个就错"的任务

这就像一个极有文学天赋但算术不好的人——让他写一篇散文，信手拈来；让他算 37×89，抓耳挠腮。不是他不"聪明"，是他的"聪明"不是用来算术的。

4. 最好的试金石

如果你想真正测试一个 AI 模型的能力边界，不要给它难题——给它简单但需要精确执行的题：

❌ 不太好的测试：
  "请推导量子力学的薛定谔方程"
  → 训练数据里有大量推导过程，它可以"背"出来
  → 答对了也不能证明它"理解"了

✓ 好的测试：
  "10110010110101001101011010110010110100110 中有多少个 1？"
  → 训练数据里不可能有这个具体的答案
  → 必须靠真正的"计算"才能答对
  → 答错了就暴露了本质

大模型最好的试金石不是难题，而是简单题。

---

写在最后

“数数会数错"这件事，看起来是一个小 bug，实际上揭示了大模型的根本架构局限——它是一个并行的模式匹配引擎，不是一个顺序的计算机器。 它擅长"大致理解”，不擅长"精确操作"。

这不是通过增加参数、增加训练数据就能解决的问题——你给一台没有循环指令的硬件再多的数据，它也学不会 for 循环。这是架构层面的天花板。

所以下次当你惊叹于 AI 写出了一段完美的代码时，不妨让它数一数那段代码有多少行。也许它会告诉你 42 行，但实际上是 45 行。

这就是 AI：它能写出代码，但数不清自己写了几行。

---

这是"AI 原理探索"系列的第四篇。从向量化原理到微调实战，再到 LoRA，再到本篇的能力边界——一步步从"AI 能做什么"走到了"AI 做不到什么"。理解边界，也许比理解能力更重要。