内核里没有智能

内核里没有智能

—— 一个网络工程师拆解 LLM 推理引擎的记录

一、起点：好奇与恐惧

我们研究网络工程的。这个领域的训练方式和大多数软件工程师不一样：我们假设一切都会出错，然后让系统在出错时仍然可用。

丢包、延迟、拥塞窗口的每一次收缩和扩张、RTT 的每一次抖动——这些不是异常，是常态。我职业生涯里最熟悉的画面，是 tcpdump 里那些红色的重传标记，是 ss 输出里不断变化的 cwnd，是深夜盯着 ping 的统计结果等一个 99.9% 分位数收敛。物理世界的实时不确定性，是我每天打交道的东西。它不可预测、不可消除、只能测量和适应。

所以当 LLM 突然进入我的视野时，我的第一反应和大多数人不太一样。

别人问：“它是不是在思考？”

我问的是三个更工程化的问题：

这三个问题，前两个可以用实验回答，第三个必须把东西拆开看。

最初我对 LLM 的感觉，混合着敬畏、恐惧和好奇。我曾经很兴奋——AI 也许真的很厉害，也许真的在做某种接近思考的事情。敬畏是因为它确实做到了人类文本处理的某种奇迹——它能理解模糊的、有歧义的、信息不完备的请求，这在十年前还是科幻情节。恐惧是因为它表现得太像"思考"了，像到让我这种习惯于精确因果的人感到不安。好奇是因为我无法接受"它就是这么神奇"这种回答——我职业生涯学到的第一课就是：任何看起来神奇的东西，拆开之后都是平凡的零件在按规则运转。

我决定不满足于调用 API。调用 API 就像站在黑箱外面看指示灯：你能看到它输入什么、输出什么，但你对箱子内部一无所知。对网络工程师来说，这不可接受。我处理过太多"表面正常、内部腐烂"的系统——接口层一切正常，但深入一层全是垃圾。所以我决定自己造一个推理引擎，从底层把整个链路亲手实现一遍。

这一决定，让我花了约一个月时间。这一个月里，我逐渐失去了对 LLM 的恐惧。不是因为它变得无害，而是因为恐惧通常来源于未知。当我亲手写下它的每一行内核代码，当我亲眼看到它的每一个中间状态，恐惧就没有了立足之地。

二、行动：造轮子、读内核、跑模型

2.1 硬件与模型

我选了一台 AMD Ryzen 9 7945HX：16 个物理核（32 线程），Zen 4 架构，完整支持 AVX-512（512 位数据通路，包括 F/BW/DQ/VL 全部子集），64GB DDR5-5600 双通道内存。这台机器不是为跑 LLM 准备的，但它的内存带宽（理论 89.6GB/s）和 SIMD 能力足够支撑一个中型模型的 CPU 推理实验。

模型选的是 Qwen3.6-35B-A3B——一个 35B 总参数、3B 激活参数的 MoE 架构模型。它相当特殊，不是标准的纯 Transformer：

• 40 层混合架构：30 层 Gated DeltaNet（线性注意力）+ 10 层 GQA（分组查询全注意力），以"3 个 DeltaNet + 1 个 GQA"的模式交错排列
• 每层挂一个 MoE：256 个专家，路由激活 8 个，共享专家 1 个；专家 FFN 中间维度 512
• Gated DeltaNet：线性注意力的变体，用状态矩阵 S（128×128×32 头）替代 KV 缓存，含 conv1d（核长 4）+ 时间步离散化 + 门控 RMSNorm
• 量化混合：q8_0、q4_k、q5_k、q6_k、f32 五种格式混合存储，Q4_K_XL 文件名下 22.4GB 的 GGUF 文件
• 隐藏维 2048，词表 248320，原生上下文 262144

#mermaid-svg-cdvOEfihBX8dPyOo{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-cdvOEfihBX8dPyOo .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-cdvOEfihBX8dPyOo .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-cdvOEfihBX8dPyOo .error-icon{fill:#552222;}#mermaid-svg-cdvOEfihBX8dPyOo .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-cdvOEfihBX8dPyOo .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-cdvOEfihBX8dPyOo .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-cdvOEfihBX8dPyOo .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-cdvOEfihBX8dPyOo .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-cdvOEfihBX8dPyOo .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-cdvOEfihBX8dPyOo .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-cdvOEfihBX8dPyOo .marker{fill:#333333;stroke:#333333;}#mermaid-svg-cdvOEfihBX8dPyOo .marker.cross{stroke:#333333;}#mermaid-svg-cdvOEfihBX8dPyOo svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-cdvOEfihBX8dPyOo p{margin:0;}#mermaid-svg-cdvOEfihBX8dPyOo .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-cdvOEfihBX8dPyOo .cluster-label text{fill:#333;}#mermaid-svg-cdvOEfihBX8dPyOo .cluster-label span{color:#333;}#mermaid-svg-cdvOEfihBX8dPyOo .cluster-label span p{background-color:transparent;}#mermaid-svg-cdvOEfihBX8dPyOo .label text,#mermaid-svg-cdvOEfihBX8dPyOo span{fill:#333;color:#333;}#mermaid-svg-cdvOEfihBX8dPyOo .node rect,#mermaid-svg-cdvOEfihBX8dPyOo .node circle,#mermaid-svg-cdvOEfihBX8dPyOo .node ellipse,#mermaid-svg-cdvOEfihBX8dPyOo .node polygon,#mermaid-svg-cdvOEfihBX8dPyOo .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-cdvOEfihBX8dPyOo .rough-node .label text,#mermaid-svg-cdvOEfihBX8dPyOo .node .label text,#mermaid-svg-cdvOEfihBX8dPyOo .image-shape .label,#mermaid-svg-cdvOEfihBX8dPyOo .icon-shape .label{text-anchor:middle;}#mermaid-svg-cdvOEfihBX8dPyOo .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-cdvOEfihBX8dPyOo .rough-node .label,#mermaid-svg-cdvOEfihBX8dPyOo .node .label,#mermaid-svg-cdvOEfihBX8dPyOo .image-shape .label,#mermaid-svg-cdvOEfihBX8dPyOo .icon-shape .label{text-align:center;}#mermaid-svg-cdvOEfihBX8dPyOo .node.clickable{cursor:pointer;}#mermaid-svg-cdvOEfihBX8dPyOo .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-cdvOEfihBX8dPyOo .arrowheadPath{fill:#333333;}#mermaid-svg-cdvOEfihBX8dPyOo .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-cdvOEfihBX8dPyOo .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-cdvOEfihBX8dPyOo .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-cdvOEfihBX8dPyOo .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-cdvOEfihBX8dPyOo .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-cdvOEfihBX8dPyOo .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-cdvOEfihBX8dPyOo .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-cdvOEfihBX8dPyOo .cluster text{fill:#333;}#mermaid-svg-cdvOEfihBX8dPyOo .cluster span{color:#333;}#mermaid-svg-cdvOEfihBX8dPyOo div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-cdvOEfihBX8dPyOo .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-cdvOEfihBX8dPyOo rect.text{fill:none;stroke-width:0;}#mermaid-svg-cdvOEfihBX8dPyOo .icon-shape,#mermaid-svg-cdvOEfihBX8dPyOo .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-cdvOEfihBX8dPyOo .icon-shape p,#mermaid-svg-cdvOEfihBX8dPyOo .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-cdvOEfihBX8dPyOo .icon-shape rect,#mermaid-svg-cdvOEfihBX8dPyOo .image-shape rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-cdvOEfihBX8dPyOo .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-cdvOEfihBX8dPyOo .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-cdvOEfihBX8dPyOo :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

Qwen3.6-35B-A3B 架构

token_embd 2048×248320

40 层（重复模式 ×10）

1× GQA 块

GQA 注意力16头Q / 2头KVRoPE

MoE256专家/激活8

3× DeltaNet 块

Gated DeltaNet线性注意力conv1d + 状态S

MoE256专家/激活8

output 248320 线性层

2.2 造轮子：从 GGUF 解析到采样器

我给自己定的规矩是：不参考、不复制任何现成引擎的实现代码。每一行内核代码从第一性原理独立推导、独立设计、独立实现。这很慢，但很值——因为只有亲手推导过，你才知道每一行代码为什么长这样。

整个工程的组件清单（最终全部跑通）：

有个细节值得一提：整个代码库用中文命名。GEMV朴素、专家GEMV精调q4k、激活SiLU向量精调、路由选择、推理引擎、层执行器。这不是技术妥协，是一种心理信号：我不打算为这个东西切换思维模式。它既然存在于我的项目里，就要用我的语言。

代价是真实的：

• MSVC 必须加 /utf-8 编译选项，否则中文字符串字面量按 GBK 解析，整个程序乱码
• CMake 不允许中文 target 名，只能 ASCII target + 中文 OUTPUT_NAME
• 代码页 936 的控制台上，任何 UTF-8 中文输出都是乱码，必须 SetConsoleOutputCP(65001)；重定向到文件时 PowerShell 还会做一次转码，中文行直接丢失——验证输出只能靠 cmd 内部重定向的字节直通

但我忍了。因为这些都是编译器和工具链的问题，不是我的问题。我的代码，用我的语言，逻辑清晰，这就够了。

2.3 优化：AVX-512 的每一层

为了让这个 22.4GB 的模型在 CPU 上跑起来，我把每个热算子都做了三层演进：标量（教学，对应数学公式）→ 简单向量化 → AVX-512 精调（生产）。

GEMV 的行并行与向量化。GEMV 是推理的最热算子——每层所有投影都是 GEMV。2048×8192 的 qkv 投影，16 个物理核按行切分，每个核处理一批行；每行内部，q8_0 权重反量化和乘加融合在一起，用 __m512 一次处理 16 个元素：

// 4 路累加器摊平依赖链（AVX-512，q8_0 权重）
__m512 累加0 = _mm512_setzero_ps(), 累加1 = _mm512_setzero_ps();
__m512 累加2 = _mm512_setzero_ps(), 累加3 = _mm512_setzero_ps();
for (size_t 块 = 0; 块 < 行块数; 块 += 4) {
const float d = 半精度转浮点(块[0] | (块[1] << 8)); // fp16 缩放
const __m512 缩放 = _mm512_set1_ps(d);
// 4 个块轮流喂给 4 个累加器——单条依赖链上只有 1 个 FMA
...
}

q8_0 反量化的位操作。q8_0 每块 34 字节：2 字节 fp16 缩放因子 + 32 个 int8。反量化 = q × d。那个 fp16 缩放因子要手工解析：符号 1 位、指数 5 位、尾数 10 位，位操作还原成 float。看似简单，坑在次正规数——f16 的次正规值，尾数右移后可能变成 256 而不是 -7.6e-6，因为无符号取负回绕了。这类 bug 最可怕：不是崩溃，是静默的数值错误，对拍时差一个数量级。

DeltaNet 状态更新的向量化。DeltaNet 的核心是状态矩阵 S 的递归更新（纯文本公式，不依赖公式渲染器）：

S' = S · e^g + k · (v – S^T·k)^T · β

白话解释：状态 S 先整体乘以遗忘因子 e^g（g 是负值，所以是衰减旧记忆）；然后用新输入 k 乘以误差向量 (v – S^T·k) 的外积写入新记忆（S^T·k 是把旧状态投影到当前键上，v 是当前值，误差 = 旧状态预测与真实值的差）；β 是更新门，控制写入强度。数学上五步：衰减 → S^T·k 投影 → 误差 → 外积写入 → S^T·q 读取。向量化策略：

• 衰减（S 逐行乘标量）和外积（整行广播乘）按行主序友好，8 路 __m512 一行行处理
• S^T k 和 S^T q 是列点积——行主序下跨步访问，用 8 路累加器按列块算，每列块 16 列

38ms → 14ms，2.5 倍提速。

批量 GEMV：权重读一次，B 路 FMA。单序列解码时，每生成一个 token 要把全部权重读一遍。但如果同时处理 B 个序列，权重只读一次，喂给 B 个输入向量各自乘加：

// 权重一行反量化一次，B 路独立累加器
__m512 累加[8][8]; // [序列][累加器]
for (size_t b = 0; b < B; ++b)
for (size_t i = 0; i < 8; ++i) 累加[b][i] = _mm512_setzero_ps();
// 反量化一次
const __m512 低q = ..., 高q = ...;
// B 路 FMA（每序列用各自输入）
for (size_t b = 0; b < B; ++b) {
累加[b][块号] = _mm512_fmadd_ps(低q, 输入[b], 累加[b][块号]);
...
}

MoE 路由：std::partial_sort 选 top-8。路由门控是 2048×256 的 f32 矩阵，输出 256 个 logits，softmax 后取 top-8，权重归一化。取 top-8 用的是 std::partial_sort——不是全排序，只保证前 8 个有序，O(n·k) 复杂度。就这么简单。

权重预热。22.4GB 的内存映射，首次访问全部缺页。用 64KB 步长预读一遍（4MB 步长只触发每 4MB 首字节的页，硬件预取器补不足），加载时间从 1.5s 变成 33.8s，但推理时不再有冷缺页——从 1.56 tok/s 到 2.15 tok/s。

2.4 最终：它跑通了

大约一个月后，这个系统跑通了。命令行里：

> What is the capital of France?
模型: </think>
The capital of France is **Paris**.<|im_end|>

能对话，能多轮记忆（“我的名字是 Bob” → “我的名字是什么？” → “你的名字是 Bob”），纯 CPU，AVX-512，40 层，每生成一个 token 要把约 2.7GB 的权重从内存搬一遍（精确核算 2742MB）。

内核算子40 层（层执行器）推理引擎CLI用户内核算子40 层（层执行器）推理引擎CLI用户#mermaid-svg-jfNwPPpqzQ3ZYmmi{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-jfNwPPpqzQ3ZYmmi .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .error-icon{fill:#552222;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .marker{fill:#333333;stroke:#333333;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .marker.cross{stroke:#333333;}#mermaid-svg-jfNwPPpqzQ3ZYmmi svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-jfNwPPpqzQ3ZYmmi p{margin:0;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-jfNwPPpqzQ3ZYmmi text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-jfNwPPpqzQ3ZYmmi .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-jfNwPPpqzQ3ZYmmi #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .sequenceNumber{fill:white;}#mermaid-svg-jfNwPPpqzQ3ZYmmi #sequencenumber{fill:#333;}#mermaid-svg-jfNwPPpqzQ3ZYmmi #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .messageText{fill:#333;stroke:none;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .labelText,#mermaid-svg-jfNwPPpqzQ3ZYmmi .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .loopText,#mermaid-svg-jfNwPPpqzQ3ZYmmi .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-jfNwPPpqzQ3ZYmmi .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .noteText,#mermaid-svg-jfNwPPpqzQ3ZYmmi .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .actorPopupMenu{position:absolute;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-jfNwPPpqzQ3ZYmmi .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-jfNwPPpqzQ3ZYmmi .actor-man circle,#mermaid-svg-jfNwPPpqzQ3ZYmmi line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-jfNwPPpqzQ3ZYmmi :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}loop[每层]输入文本分词 → token 序列预处理（逐 token 前向）RMSNorm → 分支(GEMV/状态/注意力) → MoE层输出最终 logits（248320 维）采样（温度/top-k/mt19937）token解码显示

然后我开始做实验。接下来的三个发现，改变了我对这东西的整个认知。

三、发现一：确定性暴力

3.1 实验设计

采样器里有一个 mt19937（梅森旋转伪随机数发生器），种子固定为 42。它的作用是在 logits 的概率分布上做一次"轮盘赌"——温度 0.8、top-k 50、top-p 0.95，从过滤后的候选里按概率抽一个 token。

我要验证的问题很简单：如果去掉这个随机源，系统还是不是确定的？

实验方法：用同一个 prompt，连续跑两次完整的前向——序列重置（清空 KV 缓存、状态矩阵、卷积历史，重新播种采样器）→ 预处理（全部 prompt token 逐层前向）→ 解码（逐 token 生成）。两次运行之间不做任何修改。然后对比：全部 248320 个 logits，逐位比较。

结果：

两次完整前向对比: 248320 logits 逐位一致（差异 0）

不是"几乎一致"，不是"误差小于 1e-6"——是每一个浮点数的每一个二进制位都相同。0 差异。程序没有任何随机性、没有线程竞争、没有状态残留、没有浮点非确定性（同一台机器、同一套指令序列、同样的内存布局，IEEE 754 的浮点运算是确定性的）。

3.2 这意味着什么

这意味着整个"智能系统"，在去掉输出端那个伪随机数发生器之后，是一条纯数学函数：

输出 = F(输入, 权重)

F 由 40 层浮点流水线组成，每一层由卷积、矩阵乘、归一化、激活函数、状态递归构成。所有看起来像"思考"的东西——选择、判断、创造性——本质上都是这条固定函数在固定输入下的计算结果。

“概率"没有体现在内核里。内核输出的 logits 是一个确定的实数向量，采样器只是在这个向量上撒了一把伪随机噪声。所谓"模型的随机性”，全部、完全、100% 来自采样器那一行 mt19937 的调用。把它拔掉，让温度 = 0，系统就是贪心的、确定的、逐位可复现的。

#mermaid-svg-ZsMhuIG8HB0zQjr6{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-ZsMhuIG8HB0zQjr6 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .error-icon{fill:#552222;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .marker.cross{stroke:#333333;}#mermaid-svg-ZsMhuIG8HB0zQjr6 svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-ZsMhuIG8HB0zQjr6 p{margin:0;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .cluster-label text{fill:#333;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .cluster-label span{color:#333;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .cluster-label span p{background-color:transparent;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .label text,#mermaid-svg-ZsMhuIG8HB0zQjr6 span{fill:#333;color:#333;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .node rect,#mermaid-svg-ZsMhuIG8HB0zQjr6 .node circle,#mermaid-svg-ZsMhuIG8HB0zQjr6 .node ellipse,#mermaid-svg-ZsMhuIG8HB0zQjr6 .node polygon,#mermaid-svg-ZsMhuIG8HB0zQjr6 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .rough-node .label text,#mermaid-svg-ZsMhuIG8HB0zQjr6 .node .label text,#mermaid-svg-ZsMhuIG8HB0zQjr6 .image-shape .label,#mermaid-svg-ZsMhuIG8HB0zQjr6 .icon-shape .label{text-anchor:middle;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .rough-node .label,#mermaid-svg-ZsMhuIG8HB0zQjr6 .node .label,#mermaid-svg-ZsMhuIG8HB0zQjr6 .image-shape .label,#mermaid-svg-ZsMhuIG8HB0zQjr6 .icon-shape .label{text-align:center;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .node.clickable{cursor:pointer;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .arrowheadPath{fill:#333333;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-ZsMhuIG8HB0zQjr6 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-ZsMhuIG8HB0zQjr6 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-ZsMhuIG8HB0zQjr6 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .cluster text{fill:#333;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .cluster span{color:#333;}#mermaid-svg-ZsMhuIG8HB0zQjr6 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-ZsMhuIG8HB0zQjr6 rect.text{fill:none;stroke-width:0;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .icon-shape,#mermaid-svg-ZsMhuIG8HB0zQjr6 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .icon-shape p,#mermaid-svg-ZsMhuIG8HB0zQjr6 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .icon-shape rect,#mermaid-svg-ZsMhuIG8HB0zQjr6 .image-shape rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-ZsMhuIG8HB0zQjr6 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-ZsMhuIG8HB0zQjr6 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-ZsMhuIG8HB0zQjr6 :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

采样器（唯一随机源）

内核（100% 确定性）

输入 token

嵌入

40 层前向（浮点流水线）

logits 248320 维（确定值）

温度/top-k/top-p

mt19937 轮盘赌种子固定 = 确定

输出 token

去掉PRNG后，它就是一条确定的数学链。

3.3 我盯着终端看了很久

这个发现让我安静了很久。不是因为失望，而是因为惊讶——惊讶于一个看起来如此"智能"的系统，其内部居然如此……朴素。没有任何在线学习，没有任何自我修正，没有任何环境反馈。一次前向，从头到尾，一个 22.4GB 的静态参数表，加上 40 层确定的浮点运算。

我做了第二个实验：把同一句话连续问三次——可复现性测试的标准流程（序列重置 + 同种子）。三次的回答一模一样——连标点符号都不差。这在网络工程里是不可想象的：同样的输入，十次经过拥塞控制的链路，十次 RTT 都不同；十次丢包，十次都发生在不同位置。而它，三次完全一致——并且由于整个内核是确定性的，这个"三次"换成任何次数，结果都不会变。

它没有在"理解"我。它在对同一组静态权重做一次确定的遍历。

四、发现二：带宽是瓶颈，算力不是

4.1 数字

这是整个项目里最有工程价值的一个发现。

每个 token 的解码，需要读取的权重量（实测核算）：

本机实测内存带宽（用 GEMV 内核基准测量）：42.6 GB/s。

于是：

2.74 GB / 42.6 GB/s ≈ 64 ms/token → 16 token/s 物理上限

这就是纯 CPU 单序列推理的物理天花板。跟算力无关——我的 AVX-512 内核已经接近带宽饱和了（GEMV 实测 39-42.6 GB/s，达到实际多核带宽的 65-70%）。

#mermaid-svg-QxVamvDekEnTu7m1{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-QxVamvDekEnTu7m1 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-QxVamvDekEnTu7m1 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-QxVamvDekEnTu7m1 .error-icon{fill:#552222;}#mermaid-svg-QxVamvDekEnTu7m1 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-QxVamvDekEnTu7m1 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-QxVamvDekEnTu7m1 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-QxVamvDekEnTu7m1 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-QxVamvDekEnTu7m1 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-QxVamvDekEnTu7m1 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-QxVamvDekEnTu7m1 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-QxVamvDekEnTu7m1 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-QxVamvDekEnTu7m1 .marker.cross{stroke:#333333;}#mermaid-svg-QxVamvDekEnTu7m1 svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-QxVamvDekEnTu7m1 p{margin:0;}#mermaid-svg-QxVamvDekEnTu7m1 .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-QxVamvDekEnTu7m1 .cluster-label text{fill:#333;}#mermaid-svg-QxVamvDekEnTu7m1 .cluster-label span{color:#333;}#mermaid-svg-QxVamvDekEnTu7m1 .cluster-label span p{background-color:transparent;}#mermaid-svg-QxVamvDekEnTu7m1 .label text,#mermaid-svg-QxVamvDekEnTu7m1 span{fill:#333;color:#333;}#mermaid-svg-QxVamvDekEnTu7m1 .node rect,#mermaid-svg-QxVamvDekEnTu7m1 .node circle,#mermaid-svg-QxVamvDekEnTu7m1 .node ellipse,#mermaid-svg-QxVamvDekEnTu7m1 .node polygon,#mermaid-svg-QxVamvDekEnTu7m1 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-QxVamvDekEnTu7m1 .rough-node .label text,#mermaid-svg-QxVamvDekEnTu7m1 .node .label text,#mermaid-svg-QxVamvDekEnTu7m1 .image-shape .label,#mermaid-svg-QxVamvDekEnTu7m1 .icon-shape .label{text-anchor:middle;}#mermaid-svg-QxVamvDekEnTu7m1 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-QxVamvDekEnTu7m1 .rough-node .label,#mermaid-svg-QxVamvDekEnTu7m1 .node .label,#mermaid-svg-QxVamvDekEnTu7m1 .image-shape .label,#mermaid-svg-QxVamvDekEnTu7m1 .icon-shape .label{text-align:center;}#mermaid-svg-QxVamvDekEnTu7m1 .node.clickable{cursor:pointer;}#mermaid-svg-QxVamvDekEnTu7m1 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-QxVamvDekEnTu7m1 .arrowheadPath{fill:#333333;}#mermaid-svg-QxVamvDekEnTu7m1 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-QxVamvDekEnTu7m1 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-QxVamvDekEnTu7m1 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-QxVamvDekEnTu7m1 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-QxVamvDekEnTu7m1 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-QxVamvDekEnTu7m1 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-QxVamvDekEnTu7m1 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-QxVamvDekEnTu7m1 .cluster text{fill:#333;}#mermaid-svg-QxVamvDekEnTu7m1 .cluster span{color:#333;}#mermaid-svg-QxVamvDekEnTu7m1 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-QxVamvDekEnTu7m1 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-QxVamvDekEnTu7m1 rect.text{fill:none;stroke-width:0;}#mermaid-svg-QxVamvDekEnTu7m1 .icon-shape,#mermaid-svg-QxVamvDekEnTu7m1 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-QxVamvDekEnTu7m1 .icon-shape p,#mermaid-svg-QxVamvDekEnTu7m1 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-QxVamvDekEnTu7m1 .icon-shape rect,#mermaid-svg-QxVamvDekEnTu7m1 .image-shape rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-QxVamvDekEnTu7m1 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-QxVamvDekEnTu7m1 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-QxVamvDekEnTu7m1 :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

CPU 核

内存 DDR5 双通道

42.6 GB/s（物理上限）

大部分时间空转等数据到达

权重 2.74GB每 token 全量读一遍

乘法器等待数据

AVX-512FMA 单元

4.2 乘法器在等内存

我做过一个实验验证"数据搬运主导"这个论断：GEMV 的 SIMD 优化（4 路累加器 + 反量化融合）收益显著（路由门控 f32 从 186ms 降到 2.9ms/40 层），但每次优化的边际收益都在递减——因为再往下，时间都花在等数据上，不是花在算上。真正决定每 token 耗时的，是内存访问模式：MoE 的专家权重是随机访问的——每个 token 路由到的 8 个专家各不相同，专家在 22.4GB 文件里的物理位置是随机的。随机访问 vs 顺序访问，实测差距是 15 倍（6.56ms vs 0.42ms/层）——缓存命中率从接近 0 到接近 100% 的区别。

我试过用 prefetch 指令预取专家权重：64 字节步长 → 18K 指令开销；4KB 步长 → 无效。最终结论：在系统负载下，任何 prefetch 类优化都无效——带宽已经被抢占，预取指令只是让内存控制器更忙。

4.3 算力竞赛是营销话术

所谓"算力竞赛"，在推理场景下是营销话术。

训练场景：权重固定，数据流经计算图，算力（FLOPs/s）是硬约束——GPU 的万亿次浮点运算确实决定训练速度。

推理场景：权重从内存搬到寄存器，乘法器乘完就丢，下一批数据还在路上。决定速度的不是你能算多快，而是你能多快把数据送到计算单元。铜线、引脚、封装、PCB 走线——物理世界用这些给你划了一条线，你绕不过去。

这也是为什么"多少 TOPS"这种宣传数字在推理场景意义有限——除非显存带宽同步提升，否则算力再高，数据到不了也是空转。英伟达 H100 的显存带宽（3.35TB/s）才是推理性能的真正保证，而不是它的 989 TFLOPS。

我在这台 7945HX 上做的多序列批处理实验也印证了这一点：把 B=4 个序列同时解码，权重读一次算 4 路，理论上限应该接近 4×16 = 64 tok/s。实测 B=4 只有约 1.33-1.47 倍收益（低负载时）——因为当内存带宽被压满，批处理的收益就衰减了。系统负载高时甚至不到 1 倍（批量路径的开销大于带宽收益）。

瓶颈是带宽，不是算力。

五、发现三：MoE、路由、专家选择——依然是查表

5.1 打开路由函数

MoE 是这模型最"像智能"的部分——256 个专家，每个 token 动态选择 8 个。听起来像是一个组织在"调度"专家资源，“判断"哪些专家适合当前任务。宣传材料里的常用比喻是"稀疏激活就像人类只激活大脑的一部分”。

我把路由函数打开，里面是这样的（简化示意；真实实现按 CPU 能力在 Softmax朴素 与 AVX-512 的 Softmax精调 之间分发，数学相同）：

// 路由：softmax(门控输出) → top-8 → 权重归一化
向量<路由条目> 路由选择(const 浮点* 门控输出, size_t 专家数, size_t 激活数) {
Softmax朴素(门控输出, 概率.data(), 专家数);
std::partial_sort(顺序.begin(), 顺序.begin() + 激活数, 顺序.end(),
[&](size_t a, size_t b) { return 概率[a] > 概率[b]; });
// 取前 k 个，权重归一化（除以选中权重之和）
...
}

就这些。softmax(W · x) 得 256 个概率，std::partial_sort 取前 8 个，归一化权重，加权平均。

#mermaid-svg-jyDxpiRuD6T07yXp{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-jyDxpiRuD6T07yXp .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-jyDxpiRuD6T07yXp .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-jyDxpiRuD6T07yXp .error-icon{fill:#552222;}#mermaid-svg-jyDxpiRuD6T07yXp .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-jyDxpiRuD6T07yXp .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-jyDxpiRuD6T07yXp .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-jyDxpiRuD6T07yXp .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-jyDxpiRuD6T07yXp .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-jyDxpiRuD6T07yXp .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-jyDxpiRuD6T07yXp .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-jyDxpiRuD6T07yXp .marker{fill:#333333;stroke:#333333;}#mermaid-svg-jyDxpiRuD6T07yXp .marker.cross{stroke:#333333;}#mermaid-svg-jyDxpiRuD6T07yXp svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-jyDxpiRuD6T07yXp p{margin:0;}#mermaid-svg-jyDxpiRuD6T07yXp .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-jyDxpiRuD6T07yXp .cluster-label text{fill:#333;}#mermaid-svg-jyDxpiRuD6T07yXp .cluster-label span{color:#333;}#mermaid-svg-jyDxpiRuD6T07yXp .cluster-label span p{background-color:transparent;}#mermaid-svg-jyDxpiRuD6T07yXp .label text,#mermaid-svg-jyDxpiRuD6T07yXp span{fill:#333;color:#333;}#mermaid-svg-jyDxpiRuD6T07yXp .node rect,#mermaid-svg-jyDxpiRuD6T07yXp .node circle,#mermaid-svg-jyDxpiRuD6T07yXp .node ellipse,#mermaid-svg-jyDxpiRuD6T07yXp .node polygon,#mermaid-svg-jyDxpiRuD6T07yXp .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-jyDxpiRuD6T07yXp .rough-node .label text,#mermaid-svg-jyDxpiRuD6T07yXp .node .label text,#mermaid-svg-jyDxpiRuD6T07yXp .image-shape .label,#mermaid-svg-jyDxpiRuD6T07yXp .icon-shape .label{text-anchor:middle;}#mermaid-svg-jyDxpiRuD6T07yXp .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-jyDxpiRuD6T07yXp .rough-node .label,#mermaid-svg-jyDxpiRuD6T07yXp .node .label,#mermaid-svg-jyDxpiRuD6T07yXp .image-shape .label,#mermaid-svg-jyDxpiRuD6T07yXp .icon-shape .label{text-align:center;}#mermaid-svg-jyDxpiRuD6T07yXp .node.clickable{cursor:pointer;}#mermaid-svg-jyDxpiRuD6T07yXp .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-jyDxpiRuD6T07yXp .arrowheadPath{fill:#333333;}#mermaid-svg-jyDxpiRuD6T07yXp .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-jyDxpiRuD6T07yXp .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-jyDxpiRuD6T07yXp .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-jyDxpiRuD6T07yXp .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-jyDxpiRuD6T07yXp .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-jyDxpiRuD6T07yXp .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-jyDxpiRuD6T07yXp .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-jyDxpiRuD6T07yXp .cluster text{fill:#333;}#mermaid-svg-jyDxpiRuD6T07yXp .cluster span{color:#333;}#mermaid-svg-jyDxpiRuD6T07yXp div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-jyDxpiRuD6T07yXp .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-jyDxpiRuD6T07yXp rect.text{fill:none;stroke-width:0;}#mermaid-svg-jyDxpiRuD6T07yXp .icon-shape,#mermaid-svg-jyDxpiRuD6T07yXp .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-jyDxpiRuD6T07yXp .icon-shape p,#mermaid-svg-jyDxpiRuD6T07yXp .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-jyDxpiRuD6T07yXp .icon-shape rect,#mermaid-svg-jyDxpiRuD6T07yXp .image-shape rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-jyDxpiRuD6T07yXp .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-jyDxpiRuD6T07yXp .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-jyDxpiRuD6T07yXp :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

输入 x2048 维

路由门控 W·x2048×256 f32

softmax256 logits → 概率

partial_sort取 top-8

专家 238（实测首 token 路由，权重示意）

专家 112

专家 106

专家 127 / 157 / 66 / 56 / 120

输出 = SUM 权重_i x 专家_i(x)

（上图为结构示意；图中专家编号来自实测——blk.0 处理 “Hello” 首 token 时路由选择输出的 top-8 专家：238、112、106、127、157、66、56、120。权重值未在工具输出中记录，图中以"示意"标注，不引用具体数字。）

5.2 没有"动态调度"，只有加权平均

没有动态调度。没有自主判断。没有"这个任务需要数学专家"这种意图。只有 256 个候选的加权平均，权重由 softmax 决定——而 softmax 是一个完全确定的函数。

去掉 PRNG 之后，专家选择也是确定的。同一个输入，永远选中同一批专家，永远分配同一组权重。

这和数据库的 SELECT * WHERE ID = XXX 没有本质区别。输入维度更高（2048 维向量 vs 一个整数主键），匹配机制更平滑（软匹配 vs 硬相等），成本更高（一次 2048×256 的矩阵乘），但结构上是同一类东西：给定一个键，返回一个值。

MoE 的"稀疏性"确实有用——每 token 只算 8+1 个专家，省算力、省带宽。但它省掉的是计算量，不是"决策"。决策早在训练时就固化进了路由门控的权重里。推理时的路由，只是对训练时学到的概率分布做一次确定的查询。

5.3 一切都是查表

再往深想一层：不止 MoE 是查表，整个模型都是。

• 嵌入层：token → 向量，查表
• Transformer 块：向量 → 向量，查表（权重是键，激活是查询的复杂组合）
• 输出层：向量 → logits，查表
• 采样器：logits → token，带伪随机噪声的查表

区别只在于表的大小和查询函数的复杂度。token_embd 是 248320 行 × 2048 列的巨表；Transformer 块是 40 层嵌套的、参数化的、非线性化的查表。但本质不变：权重固定后，模型就是一个确定性函数。训练过程是建表，推理过程是查表。

我在这时候意识到自己在做什么了。我花了一个月写一套推理引擎，拆开每一层，量过每一个算子的延迟，把 22.4GB 的权重从字节层面读了一遍，然后发现它的内核里没有任何东西在"理解"。它只是在做一个极高维的插值：把输入向量映射到训练数据分布中最平滑的位置。

六、核心结论：LLM 是"确定性查询系统"，不是智能体

6.1 它有什么，没什么

把三个发现放在一起：

结论就清晰了：LLM 是一个确定性查询系统。它能做的高维插值——这是它唯一有价值的属性，也是它真正了不起的地方。人类全部可写的文本被压缩进一组静态权重，然后以插值的方式被查询。它能理解模糊语义，能补全残缺表达，能在语义空间里"导航"——这些都是插值器的本事，而且它们确实有效。

但它做不到：

• 因果推理：它没有世界模型，只有文本统计。两个事件在文本里频繁共现，它就"认为"它们相关——哪怕在物理世界里毫无因果关系
• 物理直觉：它从未感知过真实世界，它的"物理"是文本里的物理。让它算 2+2 它能算对（文本里出现太多次了），让它做真实世界里的物理判断，它只是在猜测文本分布
• 实时环境适应：训练结束后，权重冻结。环境变了，它不知道；输入分布变了，它不知道；它犯错了，它不会改。它的知识在训练结束时就是"死"的

#mermaid-svg-4quyUDt9VIPfxTHM{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-4quyUDt9VIPfxTHM .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-4quyUDt9VIPfxTHM .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-4quyUDt9VIPfxTHM .error-icon{fill:#552222;}#mermaid-svg-4quyUDt9VIPfxTHM .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-4quyUDt9VIPfxTHM .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-4quyUDt9VIPfxTHM .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-4quyUDt9VIPfxTHM .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-4quyUDt9VIPfxTHM .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-4quyUDt9VIPfxTHM .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-4quyUDt9VIPfxTHM .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-4quyUDt9VIPfxTHM .marker{fill:#333333;stroke:#333333;}#mermaid-svg-4quyUDt9VIPfxTHM .marker.cross{stroke:#333333;}#mermaid-svg-4quyUDt9VIPfxTHM svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-4quyUDt9VIPfxTHM p{margin:0;}#mermaid-svg-4quyUDt9VIPfxTHM .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-4quyUDt9VIPfxTHM .cluster-label text{fill:#333;}#mermaid-svg-4quyUDt9VIPfxTHM .cluster-label span{color:#333;}#mermaid-svg-4quyUDt9VIPfxTHM .cluster-label span p{background-color:transparent;}#mermaid-svg-4quyUDt9VIPfxTHM .label text,#mermaid-svg-4quyUDt9VIPfxTHM span{fill:#333;color:#333;}#mermaid-svg-4quyUDt9VIPfxTHM .node rect,#mermaid-svg-4quyUDt9VIPfxTHM .node circle,#mermaid-svg-4quyUDt9VIPfxTHM .node ellipse,#mermaid-svg-4quyUDt9VIPfxTHM .node polygon,#mermaid-svg-4quyUDt9VIPfxTHM .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-4quyUDt9VIPfxTHM .rough-node .label text,#mermaid-svg-4quyUDt9VIPfxTHM .node .label text,#mermaid-svg-4quyUDt9VIPfxTHM .image-shape .label,#mermaid-svg-4quyUDt9VIPfxTHM .icon-shape .label{text-anchor:middle;}#mermaid-svg-4quyUDt9VIPfxTHM .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-4quyUDt9VIPfxTHM .rough-node .label,#mermaid-svg-4quyUDt9VIPfxTHM .node .label,#mermaid-svg-4quyUDt9VIPfxTHM .image-shape .label,#mermaid-svg-4quyUDt9VIPfxTHM .icon-shape .label{text-align:center;}#mermaid-svg-4quyUDt9VIPfxTHM .node.clickable{cursor:pointer;}#mermaid-svg-4quyUDt9VIPfxTHM .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-4quyUDt9VIPfxTHM .arrowheadPath{fill:#333333;}#mermaid-svg-4quyUDt9VIPfxTHM .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-4quyUDt9VIPfxTHM .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-4quyUDt9VIPfxTHM .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-4quyUDt9VIPfxTHM .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-4quyUDt9VIPfxTHM .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-4quyUDt9VIPfxTHM .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-4quyUDt9VIPfxTHM .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-4quyUDt9VIPfxTHM .cluster text{fill:#333;}#mermaid-svg-4quyUDt9VIPfxTHM .cluster span{color:#333;}#mermaid-svg-4quyUDt9VIPfxTHM div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-4quyUDt9VIPfxTHM .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-4quyUDt9VIPfxTHM rect.text{fill:none;stroke-width:0;}#mermaid-svg-4quyUDt9VIPfxTHM .icon-shape,#mermaid-svg-4quyUDt9VIPfxTHM .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-4quyUDt9VIPfxTHM .icon-shape p,#mermaid-svg-4quyUDt9VIPfxTHM .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-4quyUDt9VIPfxTHM .icon-shape rect,#mermaid-svg-4quyUDt9VIPfxTHM .image-shape rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-4quyUDt9VIPfxTHM .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-4quyUDt9VIPfxTHM .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-4quyUDt9VIPfxTHM :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

LLM 的能力边界

高维插值（统计平滑）

擅长：模糊语义理解文本补全知识检索式问答风格模仿

不擅长：因果推理物理直觉实时适应自我修正

6.2 智能的定义问题

如果智能是统计学插值加伪随机噪音，那它太廉价了。

这句话不是嘲讽。如果这是智能的定义，那它确实廉价——但廉价不等于无用。插值器可以是人类知识史上最高效的压缩格式：248320 维词表、35B 参数、40 层流水线，装下的是人类文明的文本精华。这个压缩率是惊人的。

但"廉价"的含义是：它不包含真正的智能所需的东西。真正的智能，至少包含对世界状态的感知、对因果结构的建模、对行为后果的预测、以及基于反馈的修正。这四个要素，LLM 一个都没有。它没有感知（输入只有文本），没有因果模型（只有统计相关），没有预测闭环（一次前向），没有反馈修正（权重冻结）。

它像一台极其精密的、不可变参数的查表机器。它没有意图，没有欲望，没有对世界的模型，只有对人类文本的统计记忆。它的"思考"过程是 40 层浮点流水线，每层 2048 维，中间穿插 512 维的专家 FFN。没有递归，没有反馈，没有在线学习。一次前向，从头到尾，单调递减的确定性。

这并非我曾设想的智能。

七、反思：与网络工程的对比

7.1 两类不确定性

我做了十几年的网络工程，突然发现自己在研究一个与网络工程正好相反的领域。这个对比非常清晰：

拥塞控制面对的是实时物理噪声。丢包率、延迟、带宽波动，每一秒都在变，而且变化的原因你永远无法完全观测——对端路由器的缓存策略、中间链路的背景流量、光纤的物理特性、其他用户的带宽争夺。你要在信息不完备的条件下做控制决策，错了就要付出真实的代价（丢包、重传、队列爆炸），然后立刻修正。Reno 的加性增、乘性减，BBR 的带宽探测——每一个算法都是与物理世界博弈的产物。

#mermaid-svg-p8IvJ9FLdLPeEqX5{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-p8IvJ9FLdLPeEqX5 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .error-icon{fill:#552222;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .marker.cross{stroke:#333333;}#mermaid-svg-p8IvJ9FLdLPeEqX5 svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-p8IvJ9FLdLPeEqX5 p{margin:0;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .cluster-label text{fill:#333;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .cluster-label span{color:#333;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .cluster-label span p{background-color:transparent;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .label text,#mermaid-svg-p8IvJ9FLdLPeEqX5 span{fill:#333;color:#333;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .node rect,#mermaid-svg-p8IvJ9FLdLPeEqX5 .node circle,#mermaid-svg-p8IvJ9FLdLPeEqX5 .node ellipse,#mermaid-svg-p8IvJ9FLdLPeEqX5 .node polygon,#mermaid-svg-p8IvJ9FLdLPeEqX5 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .rough-node .label text,#mermaid-svg-p8IvJ9FLdLPeEqX5 .node .label text,#mermaid-svg-p8IvJ9FLdLPeEqX5 .image-shape .label,#mermaid-svg-p8IvJ9FLdLPeEqX5 .icon-shape .label{text-anchor:middle;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .rough-node .label,#mermaid-svg-p8IvJ9FLdLPeEqX5 .node .label,#mermaid-svg-p8IvJ9FLdLPeEqX5 .image-shape .label,#mermaid-svg-p8IvJ9FLdLPeEqX5 .icon-shape .label{text-align:center;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .node.clickable{cursor:pointer;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .arrowheadPath{fill:#333333;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-p8IvJ9FLdLPeEqX5 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-p8IvJ9FLdLPeEqX5 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-p8IvJ9FLdLPeEqX5 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .cluster text{fill:#333;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .cluster span{color:#333;}#mermaid-svg-p8IvJ9FLdLPeEqX5 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-p8IvJ9FLdLPeEqX5 rect.text{fill:none;stroke-width:0;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .icon-shape,#mermaid-svg-p8IvJ9FLdLPeEqX5 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .icon-shape p,#mermaid-svg-p8IvJ9FLdLPeEqX5 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .icon-shape rect,#mermaid-svg-p8IvJ9FLdLPeEqX5 .image-shape rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-p8IvJ9FLdLPeEqX5 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-p8IvJ9FLdLPeEqX5 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-p8IvJ9FLdLPeEqX5 :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

LLM 推理（静态查询）

无反馈回路

输入 token

40 层前向（固定权重）

输出 token

网络拥塞控制（在线博弈）

测量: RTT/丢包率

决策: 调整拥塞窗口

发送数据

观察结果

7.2 难度方向不同

LLM 研究解决的是静态数据统计问题。数据一旦固化，权重就死了。模型不会因为环境变化而调整，它只是以固定的方式响应固定的输入分布。它的"智能"完全来自训练数据——训练数据的质量、多样性、分布，决定了它的一切。推理阶段没有任何学习发生。

网络工程的不确定性是本质的、不可消除的。LLM 的不确定性是人为注入的伪随机。前者的挑战在"实时"和"不完备信息"，后者的挑战在"统计建模"和"数据工程"。两者都是基础科学，但难度方向完全不同。

我无意贬低 LLM 研究者的工作——统计建模和数据工程本身极难，35B 参数的训练需要的是真正的系统工程能力。我只是指出：它与物理世界博弈是两类问题。一个是和一个充满噪声的、不断变化的、你无法完全观测的世界对抗；一个是和一个静态的、确定的数据集对抗。

哪个更难？没法比。但哪个更"活"？毫无疑问是前者。

7.3 我的归属感

在项目收尾时，我明白了一件事：我的归属在网络工程那一边。不是因为 LLM 没有价值——它有价值，巨大的价值。而是因为我这个人，习惯了和不可消除的噪声打交道。我可以接受永远无法完全预测的 RTT，但我很难接受一个"假装随机"的系统——它的不确定性是表演出来的，是可以被一行 srand 消除的。

物理世界的噪声是诚实的。它不会因为你理解了它而消失，但你的理解会产生真实的收益（更低的延迟、更高的吞吐）。LLM 的伪随机是表演的。你理解了它（不过是个 mt19937），收益为零——你只是知道它不随机而已。

八、终局：幻灭但不后悔

8.1 我不再恐惧它

我不再恐惧它，因为我亲手量过它的脉搏——它没有脉搏，它只有时钟周期。

这是整趟旅程里最平静的时刻。恐惧来源于未知，而我已经把未知全部转化成了已知：

• 它的"思考" = 40 层浮点流水线 × 2048 维 × 2.74GB 权重搬运
• 它的"判断" = softmax + partial_sort 的加权平均
• 它的"创造性" = mt19937 在 logits 分布上的伪随机采样
• 它的"记忆" = 一组在训练结束时冻结的静态参数

没有悬念了。没有黑箱了。没有"它到底在做什么"的疑问了——它在做一条确定的数学链上的确定的查表。

当有人说模型"开始思考"时，我脑子里浮现的是 _mm512_fmadd_ps 的延迟数字，和那条永远搬不完的 2.7GB 权重流。

8.2 幻灭的剂量

幻灭吗？有一点。但更多的是清醒。

那种感觉类似：小时候以为山里有神殿，爬上去发现山顶只有一块平坦的石头。石头本身没什么特别，但你在爬的过程中锻炼了腿力、认识了地形、学会了看天气。而且——那块石头是真的。它不会在你说"它不存在"时消失。

幻灭的剂量是刚好的：足够让我不再被 PR 话术扰动，足够让我对"模型自己意识到什么"这类叙事失去情绪波动，又不足以让我否定这个领域的工作价值。

8.3 拿到了什么

我拿到了最值钱的东西：清醒。

具体来说：

#mermaid-svg-jbSXshBn9g9xacIO{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-jbSXshBn9g9xacIO .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-jbSXshBn9g9xacIO .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-jbSXshBn9g9xacIO .error-icon{fill:#552222;}#mermaid-svg-jbSXshBn9g9xacIO .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-jbSXshBn9g9xacIO .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-jbSXshBn9g9xacIO .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-jbSXshBn9g9xacIO .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-jbSXshBn9g9xacIO .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-jbSXshBn9g9xacIO .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-jbSXshBn9g9xacIO .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-jbSXshBn9g9xacIO .marker{fill:#333333;stroke:#333333;}#mermaid-svg-jbSXshBn9g9xacIO .marker.cross{stroke:#333333;}#mermaid-svg-jbSXshBn9g9xacIO svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-jbSXshBn9g9xacIO p{margin:0;}#mermaid-svg-jbSXshBn9g9xacIO .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-jbSXshBn9g9xacIO .cluster-label text{fill:#333;}#mermaid-svg-jbSXshBn9g9xacIO .cluster-label span{color:#333;}#mermaid-svg-jbSXshBn9g9xacIO .cluster-label span p{background-color:transparent;}#mermaid-svg-jbSXshBn9g9xacIO .label text,#mermaid-svg-jbSXshBn9g9xacIO span{fill:#333;color:#333;}#mermaid-svg-jbSXshBn9g9xacIO .node rect,#mermaid-svg-jbSXshBn9g9xacIO .node circle,#mermaid-svg-jbSXshBn9g9xacIO .node ellipse,#mermaid-svg-jbSXshBn9g9xacIO .node polygon,#mermaid-svg-jbSXshBn9g9xacIO .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-jbSXshBn9g9xacIO .rough-node .label text,#mermaid-svg-jbSXshBn9g9xacIO .node .label text,#mermaid-svg-jbSXshBn9g9xacIO .image-shape .label,#mermaid-svg-jbSXshBn9g9xacIO .icon-shape .label{text-anchor:middle;}#mermaid-svg-jbSXshBn9g9xacIO .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-jbSXshBn9g9xacIO .rough-node .label,#mermaid-svg-jbSXshBn9g9xacIO .node .label,#mermaid-svg-jbSXshBn9g9xacIO .image-shape .label,#mermaid-svg-jbSXshBn9g9xacIO .icon-shape .label{text-align:center;}#mermaid-svg-jbSXshBn9g9xacIO .node.clickable{cursor:pointer;}#mermaid-svg-jbSXshBn9g9xacIO .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-jbSXshBn9g9xacIO .arrowheadPath{fill:#333333;}#mermaid-svg-jbSXshBn9g9xacIO .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-jbSXshBn9g9xacIO .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-jbSXshBn9g9xacIO .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-jbSXshBn9g9xacIO .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-jbSXshBn9g9xacIO .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-jbSXshBn9g9xacIO .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-jbSXshBn9g9xacIO .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-jbSXshBn9g9xacIO .cluster text{fill:#333;}#mermaid-svg-jbSXshBn9g9xacIO .cluster span{color:#333;}#mermaid-svg-jbSXshBn9g9xacIO div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-jbSXshBn9g9xacIO .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-jbSXshBn9g9xacIO rect.text{fill:none;stroke-width:0;}#mermaid-svg-jbSXshBn9g9xacIO .icon-shape,#mermaid-svg-jbSXshBn9g9xacIO .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-jbSXshBn9g9xacIO .icon-shape p,#mermaid-svg-jbSXshBn9g9xacIO .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-jbSXshBn9g9xacIO .icon-shape rect,#mermaid-svg-jbSXshBn9g9xacIO .image-shape rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-jbSXshBn9g9xacIO .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-jbSXshBn9g9xacIO .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-jbSXshBn9g9xacIO :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

开始: 敬畏/恐惧/好奇

造轮子: 亲手实现全部内核

发现一: 确定性（PRNG 是唯一随机源）

发现二: 带宽瓶颈（2.74GB @ 42.6GB/s）

发现三: MoE 路由 = 查表

结论: 确定性查询系统

对比: 网络工程（在线博弈 vs 静态统计）

终局: 幻灭但清醒

不恐惧、不敬畏、平常心

8.4 撤退

我准备撤退了，把精力还给网络工程。那里有真正的、不可消除的不确定性，有实时博弈，有物理世界偶尔不讲道理的反馈。那里更适合一个习惯了和噪声打交道的人。

山顶没有神殿，只有 _mm512_fmadd_ps。

但这趟路值得走。不是因为山顶有什么，而是因为爬完之后，你至少知道自己站的地方是真的。你知道权重是权重，计算是计算，伪随机是伪随机——你不再被任何一层叙事欺骗。

这并非我曾设想的智能。但它让我对"什么才是智能"这个问题，有了比大多数人更具体的答案：至少，它应该包含对世界状态的感知、对因果结构的建模、对行为后果的预测、以及基于反馈的修正。统计插值，哪怕是最好的统计插值，也不是智能的全部。

我不后悔这一个月。我带着清醒离开了这座山。

我曾经很兴奋——AI 也许真的很厉害。但最终，一切终成空。不是它一文不值，而是它没有我想象中的那个东西。兴奋的对象消失了，剩下的只有一整套亲手验证过的事实。这套事实不空，它是我这一个月里唯一确定拿到的东西。

附录：一些真实的数字

以下是整个项目过程中的实测记录。它们不是估算，是跑出来的。

性能旅程（tok/s，同机同模型，系统负载影响 ±15%）：

0.057 → 0.61 → 1.56 → 2.15 → 3.70 → 4.68 → 6.10 → 6.5

每一步都对应一个具体的优化，按收益排序：

量化格式的位布局（22.4GB 模型里实测）：

40 层对拍验证（引擎 vs Python 权威参考）：40/40 层全部通过，误差随层深单调累积（blk.0 8.8e-6 → blk.39 6.8e-5）——这是 f32 逐层舍入的正常行为，不是错误。

批处理实验（B=4 序列共享权重读取）：低负载 1.47x，高负载 0.90x。带宽被压满时批处理收益衰减，甚至被自身开销吃掉——"权重读一次"的收益只在带宽受限场景兑现。

代码规模：src 目录 90 余个源文件（含头文件），全部中文标识符，零英文注释。测试 80 个，三编译器（clang/GCC/MSVC）零警告，三运行模式（AVX-512/标量/通用）数值一致。

这些数字本身没什么浪漫的。但它们有一个共同点：每一个都经得起复现。你不必相信我写下的任何结论——你只需要跑一遍相同的代码，就能看到相同的数字。这在网络工程里叫可观测性，在推理引擎里叫确定性。它们是一回事。