Qwenputer 深读:把一台 RISC-V CPU 编译进 Qwen3.5 的权重,精确靠的是把浮点数逼成整数

Qwenputer 把一台 RISC-V CPU 编译进 Qwen3.5 的权重,用 Gated DeltaNet 状态当 RAM。我读了编译器源码,用 numpy 复现了它的内存和一台玩具 CPU(6528 条指令 0 错),算清它为什么必须把门值钉死在 1.0、为什么 bf16 比 fp32 更精确。

一个 4B 的语言模型,算 123456789 × 987654321 时不调任何外部工具,也不靠”心算”去猜:它前面多出的 11 层权重里有一台 32 位 RISC-V CPU,每生成一个 token,就往前跑一小步。作者把模型输出回放了约 23 万个位置,跟参考机对比,零错。

先说结论:这事能成,靠的不是模型多聪明,而是作者把所有浮点运算都逼到了”不可能出错”的区间里。 存的只有 0/1 和小整数;门只取 0、½、1 三个值;每个非线性都工作在”刚好等于 ReLU”的地方。权重里能编码的”程序”,就是”在浮点数上做整数运算”的程序。一旦越出这个区间,比如门值是 0.98 而不是 1.0,精确性几十个 token 就会塌掉。下面第三节我用 numpy 实测了这一点。

本文的材料分三档,就地标注:我读的源码(仓库 commit bec1a0c,带行号)、我自己用 numpy 跑的实验(脚本全文或核心片段都贴出来)、作者报告的数字(我没有 24 GB 显卡,没跑原模型)。

先认几个词

术语一句话解释
Gated DeltaNet(GDN)一种”线性注意力”:每个头只维护一块固定大小的矩阵当记忆,每读一个 token 就改写一次这块矩阵,不像普通注意力那样把历史全存下来。站内有专文从源码拆过它
状态矩阵 SGDN 每个头的那块记忆,Qwen3.5 里是 128×128;本文把它的每一行当成一格内存
one-hot 向量全是 0、只有一个位置是 1 的向量,相当于一个内存地址
RV32IMRISC-V 指令集的 32 位整数版,加上乘除法扩展;能跑 gcc 编出来的 C 程序
bf16 / fp32两种浮点格式。bf16 只有 8 位有效精度,大模型权重常用它;fp32 有 24 位
SiLU / ReLU两种激活函数。ReLU 是 max(x, 0);SiLU 是 x · sigmoid(x),是 ReLU 的平滑版,Qwen 的 MLP 用的是它
RMSNorm把一个向量除以它自身的均方根,让输出尺度稳定。GDN 每个头的输出都要过一次
编译权重不训练,由程序直接算出每一个权重值,让这几层执行一个事先写好的电路

一、先把事实摆清:它是什么,不是什么

作者在原文里的描述是:一个 stock Qwen3.5-4B,前面加 11 层编译出来的”芯片层”。这些层用 Qwen3.5 自带的 GDN 状态当 RAM,CPU 在前向计算里运行。这个说法基本属实,但读完源码,有三处细节要补上,它们决定了你该怎么理解”CPU 在权重里”这句话:

说法源码里的实际情况意味着什么
CPU 在权重里对。11 层的每个权重都由编译器算出,没有训练(chipformer/q35/ir.py:1-30 的设计说明)权重里存的是电路,不是程序
程序也在模型里固件(ROM)、寄存器、PC 是驱动 RvChat 在 prompt 之后直接写进 GDN 的循环状态的:rv/chat.py:333 调 core.snapshot,:342 调 hf.inject,后者在 rv/hf.py:61-71 里逐行 S[row] = ... 覆写状态程序和数据在状态里,由一个”引导程序”装载。好比芯片焊在主板上,系统是开机时从硬盘读进内存的
普通 generate() 就能跑不能。CPU 的执行轨迹 token(chip token)只过前 11 层:rv/chat.py:301 的 n = self.n_chip if pos is None else len(self.lm.layers)Qwen 自己的 32 层看不到 CPU 的执行过程,只看到最后打印出来的结果文字

第三点作者在原文”Limits”一节里自己也写了:“it doesn’t run with a plain generate() call yet”。所以更准确的说法是:CPU 的逻辑全在权重里,但要靠一个外部驱动开机、分流 token。 驱动只做路由,不做计算,每个 token 仍然是权重算出来的。这个区别在讨论”模型能不能自己藏一台计算机”这类安全问题时很要紧(作者另写了两篇后续,讨论 RNN 状态里能不能藏推理,我没读,不展开)。

还有一个数字对不上的地方。原文说”free-running 1800 万条指令无一出错”。在设计文档里,我找到的汇总是”P2 阶段自由运行 1530 万条”(docs/rv32.md:261)和”共 405 万条已验证”(docs/rv32.md:438)。两者的统计口径文档里没说清,量级是一致的,但我没能对出 1800 万这个精确数。

二、前置:权重里到底能装什么样的”程序”

HN 评论区有人问:“这些层是训练出来预测 RISC-V 指令输出的吗?” 不是。 这正是整件事的地基,值得单独讲清楚。

一层 Transformer 给你三样现成的零件:

零件能干什么当成计算机部件是坏掉会怎样
残差流(residual stream)每个位置一个长向量,层层往上传、往上加寄存器总线:每一维存一个数维度被别人写脏,所有下游读数都错
注意力 / GDN 头按”键”去找、按”值”取回查表、读写内存地址找偏,读回来的是几格内容的混合
MLP对每个位置独立做一个非线性函数ALU:加法、比较、与或非阈值没对齐,0 和 1 分不清

把一段程序翻译成这三样零件的组合,再把权重值直接算出来,这就叫”编译进权重”。它有一条清晰的祖先链(arXiv 编号均已当场核实):

  • RASP(Weiss 等, 2106.06981,2021):提出一门”像 Transformer 一样思考”的编程语言。它的原语只有”选择 + 聚合”(对应注意力)和逐位置运算(对应 MLP),用来论证 Transformer 天生能表达哪些算法。
  • Tracr(Lindner 等, 2301.05062,2023):DeepMind 把 RASP 程序真的编译成了 Transformer 权重,用作可解释性研究的”标准答案”:权重干什么是已知的,可以拿来检验解释工具准不准。
  • Looped Transformers as Programmable Computers(Giannou 等, 2301.13196,2023):证明一个固定的、循环调用的 Transformer 可以模拟一台通用计算机,指令和数据都放在输入里。
  • Linear Transformers Are Secretly Fast Weight Programmers(Schlag 等, 2102.11174,2021):指出带 delta rule 的线性注意力就是一块可以写入、可以覆盖的联想记忆。Qwenputer 原文自己引了这篇。

Qwenputer 在这条链上的位置是:把 Tracr 式的编译用到一个已经训练好的生产模型上,内存用的是 Looped Transformer 那种外置的”纸带”,只不过换成了模型自带的 GDN 状态。 后面会看到,这个选择让它不必像 Looped Transformer 那样把内存放进输入序列里,内存成本也不再随运行时长增长。

那”为什么能做到确定性”?答案藏在一个很朴素的事实里:浮点数在小整数上的加法、乘以 2 的幂,都是精确的。 bf16 能精确表示 −256 到 256 之间的所有整数。只要电路里每个中间值都是这个范围里的整数,每个非线性都只用来做”大于某个阈值吗”,浮点误差就从源头上不存在。后面几节讲的都是作者怎么把每一个可能引入误差的地方堵死。

三、RAM:delta rule 有四个旋钮,钉死三个就是内存

GDN 的状态更新公式(Yang 等, 2412.06464,已核实)是:

St=αt St−1 (I−βt ktkt⊤)+βt vtkt⊤,ot=St qtS_t = \alpha_t \, S_{t-1}\,(I - \beta_t\, k_t k_t^\top) + \beta_t\, v_t k_t^\top, \qquad o_t = S_t\, q_t

人话版:先把旧记忆整体乘一个衰减系数 α(遗忘);再把 k 方向上的旧内容擦掉 β 那么多,写入新值 v;读的时候用 q 去”照”一下状态。四个旋钮是 α、β、k、q。作者的做法是把 α 钉在 1(永不遗忘),β 钉在 1(完全覆盖),k、q 都用 one-hot。这样 I−kk⊤I - k k^\top 正好把第 k 列清零,vk⊤v k^\top 正好把新值放进第 k 列,就是一次精确的内存写入。

道理一句话就能说完,但我想看看每个旋钮松开时各自坏成什么样。于是写了下面这个脚本:64 个地址,随机写 1 万次 8 位值,最后把每个地址读回来,和最后一次写入的值比对。

# ram.py — 四种"用循环状态当 RAM"的写法,谁能精确读回
import numpy as np

rng = np.random.default_rng(0)
N_ADDR, D_K, BITS, T = 64, 128, 8, 10_000

def gdn_write(S, k, v, alpha, beta):
    # Gated DeltaNet 的状态更新:S <- alpha * S (I - beta k k^T) + beta v k^T
    return alpha * (S - beta * np.outer(S @ k, k)) + beta * np.outer(v, k)

def run(name, keys, alpha, beta, delta=True):
    S = np.zeros((BITS, D_K), np.float32)
    truth = {}
    for _ in range(T):
        a = int(rng.integers(N_ADDR))
        v = rng.integers(0, 2, BITS).astype(np.float32)
        if delta:
            S = gdn_write(S, keys[a], v, alpha, beta).astype(np.float32)
        else:                                  # 普通线性注意力:只加不删
            S = (alpha * S + np.outer(v, keys[a])).astype(np.float32)
        truth[a] = v
    bit_err = exact = 0
    for a, v in truth.items():
        o = S @ keys[a]
        bit_err += int(((o > 0.5) != (v > 0.5)).sum())
        exact += int(np.array_equal(o, v))
    print(f"{name:<34} 地址 {len(truth)}  错位 {bit_err:4d}/{len(truth)*BITS}"
          f"  逐位完全相等 {exact}/{len(truth)}")

onehot = np.eye(D_K, dtype=np.float32)[:N_ADDR]
rand = rng.standard_normal((N_ADDR, D_K)).astype(np.float32)
rand /= np.linalg.norm(rand, axis=1, keepdims=True)

run("A 默认风格: 随机键 a=0.98 b=0.6", rand, 0.98, 0.6)
run("B 随机键 + a=1 b=1", rand, 1.0, 1.0)
run("C one-hot 键, 无 delta(只加)", onehot, 1.0, 1.0, delta=False)
run("D one-hot 键 + a=1 b=1 (Qwenputer)", onehot, 1.0, 1.0)

我实测的原始输出(python ram.py,numpy 2.5.4):

A 默认风格: 随机键 a=0.98 b=0.6           地址 64  错位  199/512  逐位完全相等 0/64
B 随机键 + a=1 b=1                    地址 64  错位   50/512  逐位完全相等 0/64
C one-hot 键, 无 delta(只加)           地址 64  错位  258/512  逐位完全相等 0/64
D one-hot 键 + a=1 b=1 (Qwenputer)  地址 64  错位    0/512  逐位完全相等 64/64

四组各说明一件事:

  • A 接近一个正常训练出来的 GDN 头(“a=0.98 b=0.6”是我随手取的,不是 Qwen 的真实门值):错了 39%,跟抛硬币差不多。它本来就不是为精确存取设计的,它是一块会模糊、会遗忘的摘要记忆。
  • B 门钉死了,但键是随机方向:仍错 50 位。64 个随机方向在 128 维里并不正交,擦一个地址会顺带擦掉其他地址的一部分。地址必须两两正交,one-hot 是最简单的正交键。
  • C 键是 one-hot,但去掉 delta 的”先擦后写”:错 258 位,比 A 还差。这就是普通线性注意力:同一个地址写两次,读出来是两次的和。没有擦除就没有”覆盖”,只有累加。
  • D 三个旋钮全钉死:64 个地址全部逐位相等,不只是阈值后相等,是浮点值完全等于 0 和 1。

为什么 α 必须正好是 1,而不是”足够接近 1”

这是我写脚本前没想清楚的一点。如果 α 比 1 小一点点,写进去的值会按 αt\alpha^t 衰减,衰减到一半所需的 token 数是 ln⁡0.5/ln⁡α\ln 0.5 / \ln \alpha。手算三档(calc.py 验算过):

α半衰期(token)
0.9834
bf16 能表示的、比 1 小的最大数 1−2−81 - 2^{-8}177
fp32 能表示的、比 1 小的最大数 1−2−241 - 2^{-24}约 1163 万

我先犯了个错。我以为把上面 D 组的 α 改成 0.999,1 万次写入后肯定错一大片。实际跑出来是:

D' one-hot + a=0.999 b=1           地址 64  错位    0/512  逐位完全相等 1/64
D'' one-hot + a=0.99 b=1           地址 64  错位   76/512  逐位完全相等 1/64

α=0.999 时,按 0.5 取阈值一位都没错。原因是 64 个地址被随机反复重写,每个地址距离最后一次写入平均只有六十几个 token,0.99964≈0.940.999^{64} \approx 0.94,离 0.5 还远。但”逐位完全相等”只剩 1/64:数值已经在漂了,只是阈值暂时还兜得住。

真正会出事的是只写一次的内存。我又写了个 rom_decay.py:开机时写一次 64 格 ROM,之后每个 token 只衰减、不重写,记录第一次读错出现在第几个 token:

alpha = 0.999: 第一次读错出现在第 693 个 token(2000 个 token 内)
alpha = 1.0: 第一次读错出现在第 None 个 token(2000 个 token 内)

693 跟半衰期公式手算的 692.8 对上了。fp32 那一档看着够用了,但它的固件 ROM 只在开机时写一次,之后整个运行期间都要靠它取指。作者在设计文档里汇总过,一个阶段就自由运行了 1530 万条指令,每条指令至少一个 token。哪怕用浮点能表示的”最接近 1 的数”,ROM 也会在运行中途衰减过半。 所以 α 只能正好等于 1。“足够接近”在这里不存在。

为什么用 GDN 而不是普通注意力当 RAM

普通的 softmax 注意力也能做查表,Tracr 就是这么干的。但它的”内存”是 KV cache:每个 token 都要存一份键和值,内存随运行长度线性增长。单头、head_dim 128、bf16 下算一笔账(calc.py 验算过):

运行了多少 tokenKV cacheGDN 状态倍数
1,0000.5 MiB32 KiB16×
100,00048.8 MiB32 KiB1,562×
18,000,0008,789 MiB32 KiB281,250×

用注意力当内存,跑到千万 token 量级时,一个头就要 8.6 GiB,而 CPU 要用几十个头。GDN 的状态不管运行多久都是 128×128,这是 Qwenputer 能”自由运行上千万条指令”的物理前提。作者原文的说法是”a GDN head’s state stays the same size however long the conversation gets”,这里只是把它换成了具体数字。

四、精确的秘密:被钉死的四个常数

钉死旋钮只解决了内存。整台机器还要过 MLP 的激活函数、GDN 的门控公式、输出端的 RMSNorm,每一处都可能引入浮点误差。我在 chipformer/q35/ir.py 里找到了作者堵这几处的常数,逐个用 fp32 验算了一遍:

# chipformer/q35/ir.py:38-42(原文摘录)
K = 128           # silu gate scale: silu(K n) = K relu(n) for integers n
A_REF = 2**24     # ballast value of a state row (two columns)
A_BIT = 2**7      # value of a set bit in a state row
DECAY = {0.0: 1.0, 110.0: 0.5, 238.0: 0.0}  # a -> exp(g) with dt_bias = -110, A_log = 0

常数 1:让 SiLU 精确等于 ReLU。 Qwen 的 MLP 用的是 SiLU,它在 0 附近是一条平滑曲线,不能直接拿来做阈值判断。ir.py:278 的 silu_ok 规定,送进 SiLU 的值只能是 0、≥18 或 ≤−104:在这三个区间里,fp32 算出的 SiLU 和 ReLU 一模一样。编译器把每个门都放大 K=128 倍,保证整数输入落在这个区间里。我验算的结果是:

稳定写法 sigmoid: silu(x)!=0 的最小负整数 -103
exp(-103)= 1e-45  exp(-104)= 0.0  fp32 最小次正规数= 1e-45

−104 不是随手挑的数:e−104≈6.8×10−46e^{-104} \approx 6.8\times10^{-46},正好小于 fp32 最小次正规数(约 1.4×10−451.4\times10^{-45})的一半,所以会被舍入成 0。从 −104 往下,sigmoid 在 fp32 里严格等于 0。正数一侧,我在 CPU 上测到从 17 起 SiLU 就已经等于 x,作者取 18,多留了一格。我猜这是给 GPU 上更快但精度略低的 exp 实现留的余量,没核实。

常数 2:写入强度 β 只有 0 和 1。 ir.py:443 的注释是 beta = sigmoid(256 g - 128):g=1 时是 sigmoid(128),g≤0 时是 sigmoid(≤−128)。实测 fp32 下分别正好是 1.0 和 0.0。于是”这一步写不写”变成了一个精确的开关。

常数 3:衰减只有三档,保持、减半、清空。 GDN 的门是 exp⁡(−softplus(a+dt_bias))\exp(-\text{softplus}(a + \text{dt\_bias}))。作者把 dt_bias 设成 −110,让 a 只取 0、110、238 三个值。实测 fp32 下三档分别正好得 1.0、0.5、0.0。中间那档 0.5 很巧妙:乘 0.5 在浮点里是精确的,所以一个每步减半的头就成了计数器(设计文档原话:“α = ½ makes a head halve every step, which the circuit uses as a counter”)。

常数 4:用”镇重物”(ballast)骗过 RMSNorm。 这是我觉得整个设计里最隐蔽的一处。GDN 每个头的输出都要过一次 RMSNorm,也就是除以这一行自己的均方根。如果一行存的是 0b0000_0001,另一行存的是 0b1111_1111,它们的均方根不同,读出来的缩放也就不同,同一个 bit 读回来的数值会随这一行其余位的内容变化。

作者的解法(ir.py:489 附近的检查)是:每一行固定留两列,填上巨大的 2242^{24},数据位只填 272^7。镇重物的能量压倒数据位,归一化分母实际上只由镇重物决定。我验算了最坏情况,126 个数据位全为 1:

data/ref = 3.667e-09  < 2^-26 = 1.490e-08: True
RMSNorm 分母: 含数据 np.float32(2.097152e+06)  不含 np.float32(2.097152e+06)  相等: True

数据位对分母的贡献小于 fp32 能分辨的精度,被舍入掉了。所以不管这一行存什么,RMSNorm 都只是乘一个固定常数,后面的权重把它折回去就行。

这四个常数拼起来,就是第二节那句话的落地版:每个可能引入误差的环节,都被钉在浮点运算恰好精确的那几个点上。

五、一个反直觉的发现:bf16 是逐位精确的,fp32 反而不是

读设计文档时,这一段我第一遍以为自己看反了(docs/rv32.md:606-617):

bf16 (the merged model’s dtype): bit-exact. Every IR dim matches at every position in all 18 runs. … fp32: 0 wrong tokens in all 18 runs, but 70-400 dims per run are not bit-exact (1-ulp noise).

精度更高的 fp32 反而有误差?作者给的原因是:GPU 内核里注意力 q 的缩放是 1/128=2−3.51/\sqrt{128} = 2^{-3.5},不是 2 的幂,乘上去再乘回来会留下 1 个 ulp(最小精度单位)的残差。bf16 的最后一步类型转换恰好把这点残差舍掉了,fp32 没有这一步,残差就留了下来。

我用一个简化的例子复现了这个机制。注意这不是真实的内核路径,只演示”非 2 的幂缩放 + 低精度舍入”这一个效应:

# precision.py(核心几行)
s = f32(1) / np.sqrt(f32(128))        # 1/sqrt(128) = 2^-3.5,不是 2 的幂
vals = np.arange(1, 257, dtype=np.float32)
back = (vals * s) * np.sqrt(f32(128))  # 缩放后再乘回来
fp32 乘回后不等于原整数的个数: 110 / 256  例: [1. 2. 3.] -> [0.99999994 1.9999999  2.9999998 ]
先转 bf16 再比较不等的个数:    0 / 256

1 到 256 这 256 个整数,fp32 下有 110 个乘回来差了 1 个 ulp;转成 bf16 后全部回到原整数。

我从这里得到的判断是:对”在浮点上做整数运算”的电路来说,精度不是越高越好,粗粒度的舍入本身就是一种纠错。 只要误差远小于 bf16 的格距,最后那一次转换就会把它吸收掉。作者也指出,fp32 下 token 依然全对,因为电路里与门、阈值的余量足够大(“The circuit’s AND/threshold margins absorb it”)。逐位精确和结果正确是两个不同的标准,Qwenputer 在 bf16 下两个都做到了,在 fp32 下只做到后一个。

六、自己搭一台:70 行 numpy 的玩具 CPU

读完源码,我想验证一个更强的说法:只用三种操作,线性组合、ReLU、delta rule 读写,就能拼出一台能跑循环和分支的 CPU。 于是写了一台 8 位的玩具机:4 个寄存器、16 格 ROM、1 格 PC,全部是 α=β=1 的 delta-rule 状态;4 条指令 ADD / ADDI / BNEZ / HALT;ALU 全部由 ReLU 门拼成。每个中间量都断言为整数,有一处不是就直接报错。

关键的几个门(toycpu.py 摘录;完整脚本 83 行,去掉空行和注释 70 行。时钟周期那段为了短,压成了 4 行):

# 全部输入都是 0/1 或小整数,所以每一步都是精确的
AND  = lambda a, b: relu(a + b - 1)
MUX  = lambda c, x, y: relu(x + c - 1) + relu(y - c)          # c ? x : y
NZ   = lambda bits: relu(bits.sum()) - relu(bits.sum() - 1)   # 任一位为 1
def add(a, b):                        # 行波进位:s = a+b+c 只可能是 0..3
    out, c = [], 0.0
    for x, y in zip(a, b):
        s = x + y + c
        c = relu(s - 1) - relu(s - 2)       # 进位 = [s >= 2]
        out.append(s - 2 * c)               # 本位 = s mod 2
    return check(np.array(out))

# 一个时钟周期:取 PC → 取指 → 读寄存器 → ALU → 写回(beta 即"写不写")→ 更新 PC
pc = pcm.read(one); w = rom.read(onehot(pc))
a = regs.read(onehot(rs)); b = MUX(op[ADD], regs.read(onehot(imm[:2])), imm)
regs.write(onehot(rd), add(a, b), beta=op[ADD] + op[ADDI])
pcm.write(one, MUX(AND(op[BNEZ], NZ(a)), imm[:4], add(pc, bits(1, 4))), 1.0)

进位那一行就是 Qwenputer 那个与门技巧(chipformer/q35/prims.py:45-50 的 t_and,门值设成 4·(sum − n + ½))的同类:输入是整数时,ReLU 的拐点正好落在整数之间,输出只可能是精确的 0 或 1。

测试程序是”用加法循环做乘法”:r3 = x × y。我对 x、y ∈ [0,15] 的全部 256 种组合各跑一次,和 Python 的 x*y 对比:

256 个乘法程序,共执行 6528 条指令,结果错误 0 个
13 x 11 = 143

6528 这个数可以手算核对:每个程序先执行 2 条 ADDI 和 1 条 BNEZ,循环体每轮 3 条,共 3+3y3 + 3y 条;对 16 个 x 和 y=0..15 求和,16×∑y=015(3+3y)=16×408=652816 \times \sum_{y=0}^{15}(3+3y) = 16 \times 408 = 6528。

和真机比,我这台玩具机省掉了很多东西,其中有一处值得点出来:我每条指令都把 PC 重写一遍,真机不写。 rv/spec.py:3-6 写明 PC 是推出来的:“PC = ROM_BASE + 4 * (anchor + n)“。anchor 是最近一次跳转的目标,n 是从那之后提交了多少条指令,由一个减半计数器头来数。顺序执行时根本不需要写 PC,只有跳转才写一次。在一台”每次写内存都要花一个 token”的机器上,这直接省掉了每条指令里的一次写。

七、跑分该怎么读:n = 40

作者的算术跑分(README 表格和 docs/rv32.md 的 Gate results,作者报告值,我没复现)每个数据集只有 40 道题。所以 97.5% 就是 39/40,95% 就是 38/40,差一道题就是 2.5 个百分点。95% Wilson 置信区间(calc.py 算的):

成绩95% 区间
40/40[91.2%, 100%]
39/40[87.1%, 99.6%]
38/40[83.5%, 98.6%]
29/40[57.2%, 83.9%]
22/40[39.8%, 69.3%]

能得出的结论是:

  1. Qwenputer 和”Qwen + 宿主机 Python 工具”在统计上分不出高下。 两者每个集上都只差 0 到 1 道题,区间大面积重叠。原文用 97.5% vs 95% 来讲 div_big,这一道题的差别不说明问题。
  2. 相对 base Qwen 的提升是实打实的:mul_big 从 22/40 到 39/40,区间不重叠。
  3. “CPU 精确”不等于”答案正确”。 设计文档里有一组没进博客正文的数字:用第一版 calc 固件时,mul_div_multiple_longer 上 Qwenputer 只有 20/40,比不带工具的 base(36/40)还差得多。原因是固件 v1 不允许分数出现在中间结果里,1,040 次调用中有 610 次返回 error,Qwen 随后陷入重试循环(docs/rv32.md “mul_div: the tool was the problem”)。换成支持有理数的 v2 后才到 40/40。机器从头到尾没算错过一次,错的是工具的接口设计,以及 Qwen 怎么用它。

第三点是我认为这个项目最值得工程读者带走的教训,它跟我做 Code Mode 对照实验时的体会一致:给模型一个完美的计算器,瓶颈会立刻转移到”模型会不会用这个计算器”上。 文档统计的 rv1 失误全部是 Qwen 的:已有正确结果后又重算一遍、丢了正负号、一个问题调用了 44 次。

另外,CHIP-8 旧版的跑分表下方有一句:“These numbers are the best mode per benchmark across our development checkpoints”,即每个数据集取的是所有开发版本里的最好成绩。新版 RV32 的表没有这句话,我按字面理解它是同一个 checkpoint 跑出来的,但没核实。

八、为什么只能长成这样

Qwenputer 把每个值都压成小整数、把每个门都钉在 0/½/1,是因为它没有任何纠错机制,而状态要跨越上千万个 token 一直存在。 一次 1e-7 的误差,在训练好的模型里会被下一层的软性计算冲淡;在一个读写都靠状态矩阵的 CPU 里,它会留在 RAM 里,被之后每一条指令读到。

这句话可以反过来检验。假设条件不成立,设计会变成什么样?

  • 如果有纠错,比如每 1000 步用参考机同步一次状态,那门值取 0.98、键用近似正交的方向都无所谓,设计会退化成”一个训练出来的、近似的神经计算器”。这正是 2014 年 Neural Turing Machine(已核实)走的路:寻址是可微的、软的,因为要靠梯度学出来。HN 上有人说 Qwenputer 只是 NTM 的复杂版,区别恰恰在这里:NTM 的地址是学出来的、模糊的;Qwenputer 不需要梯度,所以地址可以是硬的、精确的。
  • 如果状态不跨 token,每次计算都从输入重新读取(Looped Transformer 的做法),误差就不会累积,但内存要放进序列里,回到第三节那张 KV cache 表的线性增长。

往前追,它是两个老想法的拼接:Schlag 2021 指出线性注意力就是”快速权重”,一块可以在前向计算里改写的记忆;RASP 和 Tracr 证明了 Transformer 的权重可以由程序直接算出来。新的地方在于第三件事:在一个从数据里学出来的模型内部嵌入一块人手写的规则电路,两者通过模型原本就会的 tool-call 格式对接,模型不需要任何额外训练就会用它。

小结

精确性来自”没有纠错”这个硬条件:状态要撑过上千万个 token,每一步浮点运算就只能落在恰好精确的点上,比如小整数、2 的幂,或者能被舍入吸收掉的极小量。α 只要不是正好 1,只写一次的 ROM 就会在几百到上千万个 token 后读错(取决于离 1 多近);换成注意力当内存,内存会随运行长度线性涨到不可用。

所以权重里能装下的”程序”,本质上是在浮点数上模拟整数电路的程序。它精不精确取决于每一处非线性有没有被钉在精确区间里,跟模型大小无关。而计算精确之后,瓶颈立刻转移到模型会不会用这台计算机上。

自己跑一遍:十分钟,只要 numpy

不需要 GPU。把第三节的 ram.py 存成文件,运行 uv run --with numpy python ram.py,应该看到和上文一样的四行输出。然后做一个我没做的实验:把 D 组的键从 one-hot 换成”one-hot 加一点噪声”(比如每个分量加 1e-3 量级的高斯噪声再归一化),看错位数从 0 开始涨的那个噪声幅度是多少。它回答的问题是:地址的正交性能容忍多大的偏差,也就是一个训练出来的 GDN 头离”能当 RAM”还差多远。

通俗总结

把 Qwen3.5 想象成一家公司,原来的 32 层是一群很会写文章、但算数常出错的员工。Qwenputer 在大门口加了一间小机房,机房里是一台规规矩矩的老式计算器:它不会思考,只会一格一格地拨算珠。员工遇到大数乘法,就按公司惯用的格式填一张”计算申请单”递过去,计算器拨完算珠,把结果写回单子上,员工接着往下写。

这台计算器能做到一个数都不错,不是因为它聪明,而是因为它的每颗算珠只有”拨上”和”拨下”两个位置,没有”拨到一半”。员工们平时用的是可以拨到任何位置的算珠,那样很灵活,但没法保证一次都不错。

一句话讲给同事:Qwenputer 精确,不是因为模型变聪明了,而是作者把权重里的每一步浮点运算都钉死在了不会出错的整数格子上;而就算计算器完美无缺,模型会不会用它仍然是另一回事。

参考来源

工程实践

arXiv 论文(编号均经 arXiv API 当场核实)

  • Weiss, Goldberg, Yahav. Thinking Like Transformers. 2106.06981
  • Lindner 等. Tracr: Compiled Transformers as a Laboratory for Interpretability. 2301.05062
  • Giannou 等. Looped Transformers as Programmable Computers. 2301.13196
  • Schlag, Irie, Schmidhuber. Linear Transformers Are Secretly Fast Weight Programmers. 2102.11174
  • Yang, Kautz, Hatamizadeh. Gated Delta Networks: Improving Mamba2 with Delta Rule. 2412.06464
  • Graves, Wayne, Danihelka. Neural Turing Machines. 1410.5401