硬盘能像神经元一样记忆吗：把 30B 参数固化到裸盘上

Qwen3-30B-A3B 有 30,532,122,624 个参数¹，用 BF16 存是 61 GB，量化到 4 位约 15 GB。假设我们已经把量化好的权重拼成了一个连续的二进制文件，拿一块新盘，不分区、不格式化，直接把它写进去：

dd if=qwen3-30b-a3b-q4.bin of=/dev/nvme1n1 bs=4M oflag=direct

写完以后，这块盘上没有文件名，也没有目录。从第 0 个扇区开始，就是这三百亿个数。拔掉电源放进抽屉，一年后插上，它们还在。

我们常说，大脑的长期记忆存在突触的强度里，而突触强度也是一个能保持很久的物理量。一个 4 位的权重和一个突触的强度，看起来都是“用一个物理量存住的一个数”。于是就有了下面几个问题：

1. 没有文件系统时，这 30B 个参数在盘上是什么形态？落到物理介质上，它们和突触有多像？
2. 盘里存着这些数，算不算像神经元那样“记住”了？两种记忆差在哪里？
3. 不把参数全部搬进内存，直接从盘上边读边用，30B 能跑多快？
4. 能不能让盘里的存储单元自己参与计算，甚至像突触一样边用边学？
5. 如果真要把 30B 参数固化到盘上，什么样的模型、什么样的盘最合适？

本文就顺着这五个问题，一层一层往下讲。

一、裸盘上的三百亿个数

没有文件系统，盘就是一个大数组

在 Linux 下，一块不分区、不格式化的盘，就是 /dev/nvme1n1 这样一个块设备。对程序来说它只有一个属性：大小。读写时给出偏移量和长度，盘就把那一段字节交出来；偏移量除以扇区大小（今天的盘多是 4 KiB），就是 LBA（逻辑块地址）。

文件系统是在这个大数组上又加的一层：文件名、目录、权限，以及“这个文件的第 N 个字节在盘上哪里”的映射表。去掉文件系统，名字没了，但偏移量本身就是地址，不需要再查表。

对模型权重来说，名字这一层本来就可有可无。一个模型是一组形状和顺序都固定的张量。常见的 safetensors 格式，本身就是一个 JSON 头加一段连续的原始字节，头里记着每个张量的形状和起止偏移²。把它铺到裸盘上，什么都不会丢。

以 Qwen3-30B-A3B 为例。它有 48 层，每层 128 个专家，每个专家是三个矩阵：gate_proj 和 up_proj 是 768×2048，down_proj 是 2048×768¹。一个专家共 4,718,592 个参数，按 4 位存是 2,359,296 字节，正好 576 个 4 KiB 扇区（为了算得整齐，这里不计量化格式里的缩放因子，实际的 4 位格式每个参数还要多出零点几位）。把专家按“层号、专家号”的顺序依次排好，第 layer 层第 e 个专家的位置就是：

offset = (layer × 128 + e) × 2,359,296

要读第 0 层的 1 号专家，算出 LBA 576，连续读 576 个扇区就行。

不过，“裸”只裸到接口这一层。在 SSD 里，LBA 只是一个逻辑地址：闪存不能原地改写，只能按页（常见 16 KiB）写、按块擦，所以控制器内部维护一张 FTL（闪存转换层）映射表，把每个 LBA 映射到某颗芯片、某个块、某一页，并且在垃圾回收和磨损均衡时不断搬动数据³。机械硬盘好一些，LBA 基本按顺序对应到磁道上的扇区，只有坏扇区会被重映射到备用区。所以，裸盘给主机的是一个平整的地址空间，但底下的介质并不长这个样子。

一个存储单元能存多少

再往下一层，到一个存储单元。今天的大容量 SSD 多用 QLC 闪存：每个单元是一个浮栅（或电荷俘获）晶体管，里面存着一些电荷，电荷多少决定了它的阈值电压。阈值电压是一个连续量，控制器把它划成 16 个窗口，于是一个单元能存 4 位。

按数量算，一个 4 位权重刚好对应一个 QLC 单元。30.5B 个参数就是 30.5B 个单元；一块 1 TB 的 QLC 盘大约有 2×10¹² 个单元，这个模型只占其中的 1.5%。

突触这边，有一项研究用电镜重建了大鼠海马里的突触，按突触的大小估计，它们大约能区分出 26 档强度，折合约 4.7 比特⁴。两边惊人地接近：都是一个断电后仍然保持的模拟量，都被分成了十几二十档，大约 4 比特。

但盘并不让“一个权重的值”等于“一个单元的电荷量”。控制器写入之前，先把数据和一段伪随机序列做异或（加扰），避免全 0、全 1 这类图案加重单元之间的干扰，再加上 ECC 校验位。而在 QLC 的一条字线上，一个单元的 4 位分属 4 个不同的页，同一页里相邻的位落在相邻的单元里³。结果是：一个权重的 4 位分散在 4 个单元里，每个单元又混着另外 3 页里不相干的数据。

所以，按数量算，这块盘装得下 30B 个“突触”，每个单元的精度也和突触差不多；只是值和物理量之间的对应关系，被控制器有意打乱了。那么，盘里存着这些数，算不算像神经元那样“记住”了它们？

二、两种记忆：按地址读取与按内容回忆

盘的记忆：给出地址，取回一块

从盘里取东西，唯一的办法是给出地址。如果你只记得内容的一部分，比如“那条记忆大概是 1011 0010 开头的”，盘帮不上忙，只能把整块盘读出来，由 CPU 一条条去比。比较这件事发生在 CPU 里，不在盘里。

盘上的存储单元还被刻意设计成互不影响。机械硬盘的磁性颗粒之间隔着非磁性的晶界，免得一个颗粒的磁化方向带动邻居；闪存里，相邻单元之间的电容耦合被当成一种错误来源，控制器要花力气去补偿它³。互不影响带来了局部性：一个扇区的数据只在那一个地方，坏了就是坏了。ECC 纠不回来时，盘返回的是整个扇区的读错误，不会给你“大致对的”数据。

神经元的记忆：给出一部分，回忆出全部

神经网络里最经典的记忆模型是 1982 年的 Hopfield 网络⁵。它有 N 个神经元，每个取值 ±1，任意两个神经元之间有一个连接权重 $W_{ij}$。要存 P 条记忆 $\xi^1, \dots, \xi^P$，用 Hebb 规则（一起激活的神经元，连接就加强）把它们叠加到同一个权重矩阵里：

回忆时，从一条线索 $s$ 出发，反复做 $s \leftarrow \operatorname{sign}(W s)$，直到状态不再变化。只要存的条数不超过约 0.138N，每条记忆都是一个稳定的吸引子⁶：线索落在它附近，就会被拉回到它本身。

这里有两点和盘完全不同。第一，每条记忆都摊在全部 N² 个权重上，每个权重也都承载着所有记忆的一小部分，没有“第 17 条记忆存在哪”这回事。第二，取回记忆靠的不是地址，而是内容：给出一个有错、不全的版本，网络自己演化到最近的那条。

实验：同样 50 条记忆，两种存法

光说不够直观，我们做一个小实验。随机生成 50 条记忆，每条 1024 位，分别用两种方式存：

• 扇区方式：每条记忆占一个扇区，用内容的 SHA-256 当地址。这是在按地址存储上做“按内容找”最直接的办法。
• Hopfield 方式：N = 1024 个神经元，50 条记忆用 Hebb 规则叠进一个 1024×1024 的权重矩阵，负载 50/1024 ≈ 0.049，远低于容量上限。

然后测两件事：线索有错时能不能取回，以及介质坏掉一部分以后还能取回几条。介质损坏在扇区方式里是随机坏掉一部分扇区，在 Hopfield 方式里是随机剪断一部分连接（把权重置零）。

表 1 说明了三件事。

按内容取，盘只认完全一样的线索。 错 1 位，哈希就完全不同，50 条一条也找不回来；Hopfield 网络在线索错了 30% 时仍然全部回忆正确。

坏的方式不一样。 扇区坏掉一半，就有一半记忆整条消失，剩下的一半完好无损；Hopfield 的连接剪掉 70%，没有一条记忆还能一位不差，但每条平均仍有 99.1% 的位是对的。前者是“要么全有、要么全无”，后者是所有记忆一起慢慢变模糊。

神经元式的记忆很贵。 扇区方式用 51,200 位存了 51,200 位；Hopfield 用了 1,048,576 个权重（每个还不止 1 位），是前者的 20 倍以上。每回忆一次，还要做好几次 1024×1024 的矩阵乘向量。

差别在“读”的方式，不在存储单元

把这个实验拆开看：Hopfield 网络的“记忆”，是权重矩阵 $W$ 加上更新规则 $s \leftarrow \operatorname{sign}(W s)$ 两部分合起来才有的。只有 $W$，它就是一百万个数；把 $W$ 写进盘，盘有了 $W$，却没有那个规则。

大模型也是这样。有研究发现，Transformer 的前馈层就像一组键值记忆：隐藏向量和每个“键”做内积，衡量当前输入和某种文本模式有多匹配，再按匹配程度把对应的“值”加权求和⁷。注意力的更新规则，也已经被证明和现代 Hopfield 网络的更新等价⁸。在这些模型里，“按内容回忆”都是靠矩阵乘法完成的。

所以，对第二个问题的回答是：盘有了突触，但没有神经元。 写进盘的 30B 个参数，要变成记忆，必须有什么东西拿着它们去做矩阵乘法。最直接的分工，就是盘只负责存，CPU 或 GPU 负责算。那么，每生成一个 token，要从盘里搬多少数据？

三、盘只存储、处理器计算：每个 token 的读盘量

稠密模型：每个 token 都要把权重读一遍

大模型生成文字是一个 token 一个 token 往外吐的。每生成一个 token，每个权重都要参与一次乘加。只服务一个用户时，从存储里读出的每个字节只换来一两次运算，速度几乎完全由读权重的带宽决定。

如果是一个 30B 的稠密模型，4 位量化后约 15.3 GB，那么每生成一个 token 就要把这 15.3 GB 读一遍。

MoE：一个 token 只用到一小部分专家

Qwen3-30B-A3B 是 MoE（混合专家）模型：每一层有一个路由器，根据当前 token 的隐藏向量，从 128 个专家里挑 8 个来算¹。专家参数一共 28,991,029,248 个，占全部参数的 95%；每个 token 只用到其中的 48 × 8 = 384 个专家，按 4 位算是 0.91 GB。剩下的 1.54B 个非专家参数（注意力、词嵌入、路由器）4 位后约 0.77 GB，每个 token 都要用，常驻内存。

这和神经元的工作方式有一点像：大脑里的神经元在任一时刻也只有一小部分在放电。

算账：不同的盘，每个 token 要等多久

只看读盘时间，不算计算，也不考虑缓存，结果如表 2。

机械硬盘那一行要多解释一句。它的顺序读能到 250 MB/s 左右，但每次随机读都要先移动磁头、再等盘片转到位置：7200 转的盘转一圈 8.33 ms，平均要等半圈 4.17 ms，再加上平均约 8 ms 的寻道，每次随机读要多花约 12 ms。MoE 每个 token 要做 384 次这样的随机读，光等磁头就要 4.7 秒。

云盘那一行是实测的：我写这篇文章用的是一台 4 核的云主机，系统盘是一块 50 GB 的云盘（lsblk 显示型号为 PersistentDisk）。用文末的脚本按上面的布局写了 8 层专家（2.42 GB），用 O_DIRECT 绕过页缓存读回来，顺序读和按 MoE 模式随机读都是 160 MB/s 左右，折算到 48 层每个 token 要 5.6 秒。这块盘被限速了，2.36 MB 一次的读也足够大，所以随机读没有比顺序读慢。

让常用的专家留在内存里

上面的算法有一个明显的浪费：相邻的几个 token 往往会用到大量相同的神经元和专家，每次都从盘上重新读，等于把同样的数据搬了很多遍。

苹果的 LLM in a flash 就是从这里入手的⁹。它把最近几个 token 激活过的神经元留在内存里（窗口化），每个新 token 只从闪存读新增的那部分；再把一起被用到的行和列存在相邻位置，让每次读都尽量大、尽量连续（行列捆绑）。这样能跑比内存大一倍的模型，比朴素的按需加载在 CPU 上快 4–5 倍，在 GPU 上快 20–25 倍。PowerInfer-2 用类似的思路，按神经元簇来调度计算和 I/O，在手机上跑起了 47B 的模型，11.68 token/s¹⁰。

到这里，第三个问题有了答案：用 NVMe 固态盘配 MoE 模型，把 30B 参数平铺在裸盘上、边读边算，是可以跑起来的，每秒几个 token；机械硬盘每个 token 要等好几秒，不实用。 但是在这种分工里，盘只是一块慢一点的内存，“回忆”这件事仍然发生在处理器里。能不能不把数据搬出来，让参数在盘里就地参与计算？

四、让存储单元参与计算

浮栅单元本来就能做乘法

一个浮栅晶体管存的电荷，决定了它在给定电压下能导通多大的电流，可以把它看成一个可调的电导 $G$。在它两端加一个电压 $V$，流过的电流就是 $I = G \cdot V$，一次乘法就完成了。把一列单元并联在同一根位线上，各自的电流在位线上自然相加（基尔霍夫电流定律），于是这根位线上的总电流就是一个内积 $\sum_i G_i V_i$。整个阵列一次读出，就完成了一次矩阵乘向量。

这样的实验早就有人做过。2016 年，Strukov 和 Likharev 等人把商用 180 nm NOR 闪存改造成模拟计算阵列，用 101,780 个浮栅单元当突触，每个单元的电导可以调到约 1% 的精度。在 MNIST 手写数字识别上，芯片做到了 94.65% 的准确率（仿真为 96.2%），分类一张图不到 1 微秒，耗能约 20 纳焦¹¹。在这里，一个权重的值就是一个单元的状态，图 2 里被控制器打乱的那种对应关系又回来了。

SSD 里的 NAND：串联结构只适合按位运算

问题在于，SSD 用的不是 NOR，而是 NAND。NAND 为了密度，把几十到上百个单元串联成一串，共用一根位线。读其中一个单元时，要给串上其他所有单元加一个足够高的导通电压，让它们全部导通，只留被读的那个决定电流。串联的单元电流不会相加，只会被最弱的那个卡住。

串联也不是全无用处。Flash-Cosmos 发现，同时感应一串里的多条字线，只有每个单元都导通时才有电流，相当于对这些位做“与”；同时感应挂在同一根位线上的多个块，任何一串导通就有电流，相当于做“或”。作者在 160 颗真实的 3D NAND 芯片上验证了这种做法¹²。但这只是按位运算，不是乘加。

要在闪存里跑大模型，就得改芯片。Cambricon-LLM 设计了一颗专门的 NAND 闪存芯片，在片内加入计算单元和 ECC，让闪存负责轻量的片上运算，NPU 负责其余的矩阵运算和特殊函数。在它的评估里，70B 模型能跑到 3.44 token/s，7B 模型 36.34 token/s，比从闪存卸载权重的方案快 22–45 倍¹³。

这些都是专门设计的芯片。买来的 SSD 只通过 NVMe 或 SATA 接口收发数据块，主机没有办法让它的闪存去做乘加。机械硬盘更不行：磁头一次只能沿一条磁道串行地读，介质本身没有可以利用的并行物理过程。机械硬盘这条路，到这里就走到头了。

模拟计算还有它自己的代价：单元的电导会随温度漂移，每根位线都要配一个模数转换器，1% 的精度大约只相当于 6–7 位。4 位量化的大模型能容忍一定的噪声，但要在几十层里层层累积，误差能不能控制住，仍是这类芯片要解决的问题。

单元能算了，下一步自然想问：它能不能像突触一样，边用边学？

五、在盘上学习：写入的代价

突触可以双向调整，闪存单元只能单向写

突触的强度可以增强（长时程增强，LTP），也可以减弱（长时程抑制，LTD），调整只发生在这一个突触上，不影响旁边的。

闪存单元做不到。编程（写）是往浮栅里注入电子，只能让阈值电压升高，而且以页为单位进行；要让阈值电压降回来，只能把整个块擦除，一个块里有成百上千个页³。梯度下降的每一步，都要让每个权重或增或减，落到闪存上，就只能把新值写到新的页里，旧页标记作废，等以后整块搬走、擦除。

寿命算账

这不只是理论上的别扭。ZeRO-Infinity 确实把训练时的参数和优化器状态放到 NVMe 上，以此在有限的 GPU 上训练超大模型¹⁴。但如果 30B 模型用 Adam 训练，FP32 主权重和两份动量每个参数 12 字节，每一步都要重写 366 GB。三星 990 PRO 2 TB 款的标称写入寿命是 1,200 TBW¹⁵，够写约 3,300 步。预训练一个大模型动辄几十万步，这块盘撑不过开头。

闪存适合“写一次、读很多次”

反过来，只读的推理正是闪存擅长的。按 JEDEC 的规定，消费级 SSD 即使用完了标称寿命，断电放在 30°C 下数据也要能保持一年¹⁶；新盘的保持时间还要长得多。长期反复读同一块数据，会因为读干扰让邻近单元慢慢偏移，但控制器会定期把数据刷新到新位置³。

所以对“能不能在盘上学习”的回答是：可以写，但每次更新都是整页搬迁，写入寿命经不起训练的消耗。“固化”这个词其实很准确：在 GPU 上训练好，把参数一次写进盘里，以后只读。顶多再挂一个很小的 LoRA 适配器，只更新这一小部分参数。

既然盘最适合“训练完写一次、以后只读”，那要把 30B 固化到盘上，模型应该长成什么样？

六、适合固化在盘上的模型结构

前面几节提出的要求

把前面的结论收拢一下，一个适合放在盘上的模型应该满足四点：

1. 按地址读，而不是按内容搜（第二节）。内容到地址的换算由处理器来做，盘只负责“给地址、还一块”。
2. 每个 token 读得少（第三节）。读盘量决定速度。
3. 地址要早知道（第三节）。机械硬盘每次随机读要等 12 ms，NVMe 也有几十微秒的延迟，越早知道要读什么，越能把等待藏在计算后面。
4. 参数训练好以后不再改（第五节）。

MoE 满足前两点的一部分：每个 token 只读 0.91 GB。但它的路由器要用当前层的隐藏向量来选专家，要读哪些专家，直到这一层开始算之前才知道，没有提前预取的余地。

记忆层与 Engram：把查表做成模型的一层

另一类结构直接把“查表”做成了模型的一层。2019 年的乘积键记忆层（Product Key Memory）给 Transformer 加了一张最多十亿参数的大表，每个 token 只按键取出其中几行；加了这一层的 12 层模型，效果超过了 24 层的基线，推理还快一倍¹⁷。2024 年 Meta 把这种记忆层扩到了 128B 参数，在计算量相当时，效果超过了计算量多一倍以上的稠密模型，也超过了计算量和参数量都相当的 MoE，在事实类任务上提升尤其明显¹⁸。

2026 年初 DeepSeek 发表的 Engram 更进一步¹⁹。它把经典的 N-gram 嵌入现代化：取当前位置前面的几个 token 组成 N-gram，用几个哈希函数算出它在一张大嵌入表里的行号，取出那几行，再由一个门控根据当前隐藏向量决定用多少。论文把 Engram 扩到 27B 参数，在总参数量和计算量都相同的条件下超过了纯 MoE 的基线。

对盘来说，Engram 最关键的性质是：行号只取决于输入的 token，不取决于隐藏向量。前向计算一开始，甚至在它开始之前，就知道要读哪些行，可以提前取。论文的实验是把一张 100B 参数的表整个放在主机内存里，通过 PCIe 预取，8B 骨干的吞吐只降了 2.8%。论文还指出，N-gram 的出现频率服从 Zipf 分布，常用的少数行可以缓存在显存或内存里，长尾放到 NVMe SSD 上¹⁹。

这正好满足了上面的四点要求：按地址读，每个 token 只读几行，前向一开始就知道地址，表训练好以后不再改。分工也随之清楚了：留在内存或显存里的是一个较小的骨干网络，放到盘上的是那张大表。按图 7 的示意，每个 token 从盘上只读几十 KB，比 MoE 的 0.91 GB 小四个数量级。不过要说明：论文实测的是主机内存，长尾放在 SSD 上只是论文提出的方向；表放在裸盘上能跑多快，是本文的推断，还没有人测过。

有意思的是，engram 这个词在神经科学里，指的正是一段记忆在大脑里留下的物理痕迹。

固化的另一端：把参数做成电路

如果把“固化”推到极致，就是连盘也不要了，直接把参数做成电路。Taalas 在 2026 年 2 月发布的 HC1 芯片，把 Llama 3.1 8B 硬连线进了硅片，采用 3 位和 6 位混合量化，单用户能跑到每秒 17,000 个 token；参数本身不能改，只保留了上下文长度的配置和 LoRA 微调²⁰。在这里，存储和计算彻底合成了一件事，和突触最像，代价是一个芯片只能是一个模型。

把这几种“固化”的程度放在一起比较：

七、回到那块写满权重的盘

现在可以回答开头的问题了。那块 dd 过的盘上，确实存着 30B 个“突触”：每个 QLC 单元的精度和一个突触差不多，断电一年也不会丢。但它记住这些数的方式，是图书馆的方式，不是大脑的方式：

• 它只能按地址取，不能按内容回忆；错一位的线索，什么也找不回来。
• 坏掉的扇区整块丢失，不会“大致记得”。
• 它不会自己用这些数做任何计算，“回忆”要靠处理器完成。

要让这块盘真正派上用场，有三条路：

• NVMe 加 MoE，处理器边读边算，Qwen3-30B-A3B 每秒能出几个 token。今天就能做，llama.cpp 用 mmap 加载模型，其实就是让操作系统替你做这件事，只不过中间隔着文件系统。
• 在闪存芯片里计算，让单元的电荷直接参与乘加。这已经接近一个突触阵列，但要专门的芯片，不是买来的 SSD。
• 换一种模型结构，像 Engram 那样把知识放进一张按 token 寻址的大表，让盘只做它最擅长的事：给地址，还一块。

至于在盘上学习，闪存单向写、整块擦的特性和有限的写入寿命，决定了它只适合训练好以后写一次。“固化”这个词，恰好描述了盘能做的事。

小结

从一块写满权重的裸盘出发，我们一路追问到了：

1. 裸盘上的参数是什么形态？ 一个按偏移量寻址的大数组，适合按层、按专家平铺。往下一层，一个 QLC 单元约存 4 位，和一个突触约 4.7 比特的精度很接近，但控制器的加扰和页编码把“一个值对应一个单元”打乱了。
2. 盘算不算“记住”了？ 它有突触，没有神经元。按地址读取，错一位就找不回来，坏一块就丢一块；Hopfield 网络按内容回忆，线索错 30% 仍能想起，代价是 20 倍以上的存储和每次回忆都要做矩阵乘法。
3. 盘只存储、处理器计算，30B 能跑多快？ 稠密模型每个 token 要读 15.3 GB，NVMe 上要 2 秒；MoE 只读 0.91 GB，NVMe 上每秒约 8 个 token 的上限，机械硬盘每个 token 要 8 秒以上。
4. 存储单元能不能就地计算、就地学习？ NOR 闪存可以靠欧姆定律和基尔霍夫定律做模拟乘加，SSD 里串联的 NAND 只适合按位运算，要算大模型就得用专门的芯片。闪存只能单向写、整块擦，写入寿命经不起训练，只适合写一次。
5. 怎样固化 30B 最合适？ 选按地址查表、地址只取决于输入的结构，比如记忆层和 Engram；放在 NVMe 上，热的行留在内存里。

如果想自己验证，下面是文中用到的两个脚本，只依赖 NumPy。

第一个是第二节的实验，比较按扇区存和用 Hopfield 网络存（4 核机器上约 8 秒）：

"""同样 50 条 1024 位的记忆，分别按“扇区”和按 Hopfield 网络存，比较两件事：
1. 拿一条有噪声的线索去取，能不能取回原来那条；
2. 存储介质坏掉一部分以后，还能取回几条。
"""
import hashlib
import numpy as np

N, P = 1024, 50          # 每条记忆 1024 位，共 50 条
rng = np.random.default_rng(0)
patterns = rng.choice([-1, 1], size=(P, N)).astype(np.int8)


def flip(x, frac, rng):
    """随机翻转 frac 比例的位，模拟一条不完整、有错的线索。"""
    y = x.copy()
    idx = rng.choice(N, size=int(frac * N), replace=False)
    y[idx] *= -1
    return y


# ---------- 方式一：按地址存（扇区） ----------
# 用内容的哈希当地址：这是“按内容找”在按地址存储上最直接的做法。
def addr(x):
    return hashlib.sha256(x.tobytes()).hexdigest()

disk = {addr(p): p for p in patterns}
sector_of = {addr(p): i for i, p in enumerate(patterns)}   # 每条记忆占一个扇区


def disk_recall(cue, dead=frozenset()):
    a = addr(cue)
    if a not in disk or sector_of[a] in dead:
        return None
    return disk[a]


# ---------- 方式二：Hopfield 网络 ----------
W = (patterns.T.astype(np.float32) @ patterns.astype(np.float32)) / N   # Hebb 规则
np.fill_diagonal(W, 0)


def hopfield_recall(W, cue, steps=20):
    s = cue.astype(np.float32)
    for _ in range(steps):                     # 同步更新，直到不再变化
        s_new = np.where(W @ s >= 0, 1.0, -1.0)
        if np.array_equal(s_new, s):
            break
        s = s_new
    return s.astype(np.int8)


def exact(out, p):
    return out is not None and np.array_equal(out, p)


print(f"N={N} 位/条, P={P} 条")
print(f"扇区方式占用: {P * N} 位;  Hopfield 权重: {N * N} 个")
print()

print("实验一：线索有噪声（不坏介质）")
print("噪声比例  扇区:完整取回  Hopfield:完整取回  Hopfield:平均每条对的位数")
for noise in [0.0, 0.01, 0.05, 0.10, 0.20, 0.30, 0.40]:
    r = np.random.default_rng(1)
    cues = [flip(p, noise, r) for p in patterns]
    d = sum(exact(disk_recall(c), p) for c, p in zip(cues, patterns))
    outs = [hopfield_recall(W, c) for c in cues]
    h = sum(exact(o, p) for o, p in zip(outs, patterns))
    acc = np.mean([np.mean(o == p) for o, p in zip(outs, patterns)])
    print(f"{noise:>6.0%}     {d:>4}/{P}          {h:>4}/{P}           {acc:.2%}")
print()

print("实验二：介质坏掉一部分（扇区用干净线索；Hopfield 用 10% 噪声的线索）")
print("损坏比例  扇区:完整取回  Hopfield:完整取回  Hopfield:平均每条对的位数")
for dmg in [0.0, 0.10, 0.30, 0.50, 0.70, 0.80, 0.90]:
    r = np.random.default_rng(2)
    # 扇区：坏掉的扇区整块读不出来（ECC 纠不回来时，盘返回的是读错误）
    dead = frozenset(r.choice(P, size=int(dmg * P), replace=False).tolist())
    d = sum(exact(disk_recall(p, dead), p) for p in patterns)
    # Hopfield：随机剪断 dmg 比例的“突触”（权重置零，保持对称）
    mask = r.random((N, N)) >= dmg
    mask = np.triu(mask, 1); mask = mask | mask.T
    Wd = W * mask
    cues = [flip(p, 0.10, r) for p in patterns]
    outs = [hopfield_recall(Wd, c) for c in cues]
    h = sum(exact(o, p) for o, p in zip(outs, patterns))
    acc = np.mean([np.mean(o == p) for o, p in zip(outs, patterns)])
    print(f"{dmg:>6.0%}     {d:>4}/{P}          {h:>4}/{P}           {acc:.2%}")

第二个是第三节的读盘实验。先 write 把 8 层专家按文中的布局写进去，再 read 测顺序读和 MoE 模式的读，并折算到 48 层。目标可以是一个普通文件，也可以是一块空盘的裸设备（会覆盖上面的数据）：

"""把一个 MoE 模型的专家权重平铺到裸盘（或一个大文件）上，再按“生成一个 token”的访问模式读回来，
测每个 token 要在 I/O 上花多少时间。

布局照 Qwen3-30B-A3B：每层 128 个专家，每个专家 3 个 768×2048 的矩阵，
4 位量化后正好 2,359,296 字节 = 576 个 4 KiB 扇区。专家 (layer, e) 放在
    offset = (layer * 128 + e) * 2,359,296
没有文件系统，地址就是偏移量。

用法：
    python3 disk_stream.py write /path/to/target --layers 8
    python3 disk_stream.py read  /path/to/target --layers 8 --tokens 20
target 可以是 /dev/nvme1n1 这样的裸设备（会覆盖上面的数据，需要 --i-know-this-erases），
也可以是普通文件。读写都用 O_DIRECT，绕过页缓存，测的是盘本身。
"""
import argparse, mmap, os, sys, time
import numpy as np

EXPERTS, TOPK, FULL_LAYERS = 128, 8, 48
EXPERT_BYTES = 3 * 768 * 2048 // 2          # 4 位量化：两个参数一个字节
assert EXPERT_BYTES % 4096 == 0


def offset(layer, e):
    return (layer * EXPERTS + e) * EXPERT_BYTES


def open_direct(path, write):
    flags = (os.O_RDWR | os.O_CREAT) if write else os.O_RDONLY
    return os.open(path, flags | os.O_DIRECT, 0o644)


def cmd_write(a):
    if a.target.startswith("/dev/") and not a.i_know_this_erases:
        sys.exit("写裸设备会覆盖上面的数据，确认后加 --i-know-this-erases")
    fd = open_direct(a.target, True)
    buf = mmap.mmap(-1, EXPERT_BYTES)        # mmap 出来的内存按页对齐，O_DIRECT 需要
    rng = np.random.default_rng(0)
    t0 = time.perf_counter()
    for layer in range(a.layers):
        for e in range(EXPERTS):
            buf[:] = rng.integers(0, 256, EXPERT_BYTES, dtype=np.uint8).tobytes()
            os.pwritev(fd, [buf], offset(layer, e))
    os.fsync(fd)
    dt = time.perf_counter() - t0
    total = a.layers * EXPERTS * EXPERT_BYTES
    print(f"写入 {total / 1e9:.2f} GB，用时 {dt:.1f} s，{total / dt / 1e6:.0f} MB/s")


def cmd_read(a):
    fd = open_direct(a.target, False)
    buf = mmap.mmap(-1, EXPERT_BYTES)
    rng = np.random.default_rng(1)

    # 1) 顺序读：稠密模型每个 token 要把全部权重扫一遍，就是这种模式
    total = a.layers * EXPERTS * EXPERT_BYTES
    t0 = time.perf_counter()
    for i in range(a.layers * EXPERTS):
        os.preadv(fd, [buf], i * EXPERT_BYTES)
    seq = total / (time.perf_counter() - t0)
    print(f"顺序读：{seq / 1e6:.0f} MB/s")

    # 2) MoE 模式：每层随机挑 8 个专家，每个专家是一次 2.36 MB 的读
    lat = []
    for _ in range(a.tokens):
        t0 = time.perf_counter()
        for layer in range(a.layers):
            for e in rng.choice(EXPERTS, TOPK, replace=False):
                os.preadv(fd, [buf], offset(layer, int(e)))
        lat.append(time.perf_counter() - t0)
    per_layer = np.median(lat) / a.layers
    moe_bytes = a.layers * TOPK * EXPERT_BYTES * a.tokens
    print(f"MoE 读：{moe_bytes / sum(lat) / 1e6:.0f} MB/s，每层 {per_layer * 1e3:.1f} ms")
    print(f"折算到 {FULL_LAYERS} 层：每个 token 读 {FULL_LAYERS * TOPK * EXPERT_BYTES / 1e9:.2f} GB，"
          f"I/O 约 {per_layer * FULL_LAYERS:.2f} s，上限 {1 / (per_layer * FULL_LAYERS):.2f} token/s")
    dense = 30.5e9 / 2
    print(f"对照：稠密 30B（4 位，{dense / 1e9:.1f} GB）按顺序读速度，每个 token {dense / seq:.1f} s")


p = argparse.ArgumentParser()
p.add_argument("cmd", choices=["write", "read"])
p.add_argument("target")
p.add_argument("--layers", type=int, default=8)
p.add_argument("--tokens", type=int, default=20)
p.add_argument("--i-know-this-erases", action="store_true")
a = p.parse_args()
cmd_write(a) if a.cmd == "write" else cmd_read(a)

参考资料