TensorFold 原生 CUDA 引擎运行 Kolibri-1:block FP8 研究检查点的部署、分块预填充与验证实践

原创2026-11-14 16:59:442,295 阅读
文章标签:人工智能大模型推理引擎模型推理服务本地部署桌面应用交互助手

TensorFold 原生 CUDA 引擎运行 Kolibri-1:block FP8 研究检查点的部署、分块预填充与验证实践

本文围绕 TensorFold 的 kolibri1 family,讲清如何在一张 NVIDIA GPU 上通过 lane host 用原生 CUDA 引擎服务 Aleph Alpha 的 Kolibri-1 研究检查点:它的 block FP8 权重要求、混合注意力几何、6/384 sigmoid 路由、8,192 行的分块预填充、KV 缓存核算,以及一组可以在真实检查点上复现的自检命令。读完后你可以独立完成从检查点校验、启动参数调优到数值与吞吐验证的完整闭环。

原配方文件见 Kolibri-1,family 的实现在 zig/src/families/kolibri1 目录下;本文在保留该配方全部实测命令、限制与数据的前提下,补充了源码级的参数含义和拒绝路径说明。

一、这份配方覆盖什么

kolibri1 服务的是 Aleph Alpha 的 Kolibri-1,运行在单张 NVIDIA GPU 上,走引擎的 lane host。它是一个草稿族(draft family):普通解码和"从 prompt 自身文本复制"的 copy drafts 已经可用,EAGLE-3 drafter 属于下一步,当前不加载。

这意味着两件事:

  • 你得到的是一个功能完整的服务端模型族,普通请求、采样、多流共享 round、prompt cache 保态都能跑;
  • 你不能把 Kolibri-1 当作已经完成投机解码优化的族来评估——--drafter 会被明确按名字拒绝,见第六节。

从源码结构看,这个 family 只做"装配"工作:配置校验、张量映射、布局打包、层图与 lane 后端,不写自己的 kernel,所有 launch 都是引擎共享的 CUDA 算子。这一点决定了它的可移植性和它的能力边界,也是理解后文所有限制的关键。

二、检查点:revision、分片与量化格式

配方钉住的版本是:

项 值
仓库 Aleph-Alpha/Kolibri-1
revision e52eb4627d11516b0c01de49210ab5a4e4061444
分片 32 个 safetensors 分片
体积 74 GB
量化 block FP8:128 × 128 块内 e4m3 code,配 fp32 weight_scale_inv
未量化部分 routers、norms、embeddings、head 为 bf16
model.safetensors.index.json 的 publisher sha256 c6769a34820c9057b404b2a5cae1ac24fd7b4a9ca08b84eb0a06e7b5bad3005e

拉取检查点可以用原生二进制自带的能力:

tensorfold pull Aleph-Alpha/Kolibri-1@e52eb4627d11516b0c01de49210ab5a4e4061444

(该命令与检查点的对应关系见 README.md 的 qualified models 表;本 family 条目同时标注"Text only; copy drafts, no EAGLE-3/neural drafter"。)

2.1 张量清单如何被校验

family 打开检查点时会先读 config.json,再建立全量张量名映射,然后才逐层打包上传。映射逻辑在 names.zig:

  • 每个 FP8 投影声明为 name.weight(F8_E4M3,形状 [n, k])加 name.weight_scale_inv(F32,形状 [ceil(n/128), ceil(k/128)]),任何 dtype 或形状不符都会在上传前失败;
  • 每层读取 model.layers.N.self_attn.{q,k,v,o}_proj、q_norm/k_norm、input_layernorm、post_attn_norm、post_attention_layernorm(注释特别说明:这是 MoE 前的 norm,名字有误导性)、post_ffn_norm、mlp.gate.weight、moe.router.expert_bias;
  • 路由专家按 model.layers.N.mlp.experts.J 逐个读,shared expert 放在最后一位,名字是 model.layers.N.mlp.shared_experts;
  • 结尾 if (ck.unused() != 0) return error.UnusedTensors;——多出来的张量同样拒绝,这就是配方里"116,303 tensors, none left over"的机制来源。对应的检查点断言在 names.zig 的测试里(第 49 层 385 个 expert 条目 = 384 路由 + 1 共享)。

这种"宁可在加载期报错,也不在推理期静默读错权重"的策略,对研究检查点尤其重要:Kolibri-1 是研究发布,字段命名与主流开源模型不完全一致。

三、模型几何:50 层、双注意力模式与 6/384 路由

配方给出的关键尺寸:

  • 50 层,hidden 2,560,48 个 query head 对 4 个 key head,head_dim 128;
  • 每第 5 层(第 4、9、…、49 层)对所有 key 做不带位置编码的全注意力;
  • 其余 40 层对 513 个 key 的窗口做带 RoPE 的滑动注意力;
  • 每层按 sigmoid 加 expert bias 路由到 384 个专家中的 6 个,权重用未归一化的 sigmoid,外加 1 个 ungated shared expert。

config.json 中真正被读取的键(所有取值都在 config.zig 中解析):

键 含义 本检查点取值
model_type 必须精确为 kolibri1 kolibri1
num_hidden_layers 层数,上限 64 50
hidden_size hidden 宽度,必须是 128 的整数倍 2560
num_attention_heads query head 数 48
num_key_value_heads key head 数 4
head_dim 必须为 128 128
vocab_size 词表 128000
num_experts 路由专家数,上限 4096 384
num_experts_per_tok top-k,k + 1 ≤ 64 6
moe_intermediate_size 专家宽度,必须是 128 的整数倍 512
shared_expert_intermediate_size 必须与专家宽度相等 512
sliding_window 滑动窗口,必须 ≥ 2 513
rope_theta 默认 10000.0 10000.0
rms_norm_eps RMSNorm epsilon 1e-06
layer_types 每层一个 full_attention 或 sliding_attention 5 层一循环
quantization_config quant_method: fp8 且 weight_block_size: [128, 128] 匹配
norm_topk_prob 必须为 false false
eos_token_id 结束 token,最多 4 个 127906

qkvDim() 的定义是 (heads + 2 * kv_heads) * head_dim,代入即 (48 + 8) * 128 = 7168,这一数值在 config.zig 的测试中被固定下来。Q、K、V 三个投影在打包时按行拼成一次 qkv 调用(见 pack.zig 的 Linear 与 layer() 中的 linear(gpa, &.{ m.q, m.k, m.v })),所以 7168 这个宽度是"一次 launch 处理完 QKV"的直接后果。

3.1 两条注意力路径的实现差别

全注意力层与滑动层在引擎里走两组不同的共享算子,这是本 family 最值得注意的工程细节:

  • 滑动层:prompt 行用 window_attention 的 prompt 路径,decode 行用 WindowAttention.decode,key 按 key p at ring row p % ring 落在环形缓冲里(见 forward.zig 的 window())。window 语义是半开区间 (pos - window, pos],共 513 个 key。
  • 全注意力层:prompt 行同样用 window_attention,但把 win 设为 0,表示"该行之前的每一个 key";decode 行改用 tree_attention,先读各流已提交(committed)的 key,再叠加本行自己的 chain。

环的大小由 ringSize() 决定:

pub fn ringSize(rows: usize, window: usize) usize {
    return (rows + window + key_block - 1) / key_block * key_block;
}

prompt_rows = 8192、window = 513、key_block = 64,于是 ringSize(8192, 513) = 8768——正好对应配方中"Each sliding layer's ring holds a pass and its window (8,768 keys)"。同一文件的测试直接在 forward.zig 里断言 8,768 与 ring - 513 >= 8192。

3.2 路由:为什么"未归一化"是一个硬约束

moe_glue 的 top-k 选择按 sigmoid(logit) + expert_bias 进行,权重取未归一化的 sigmoid;shared expert 作为"额外一个 slot、权重 1"参与加权求和(kernels.zig 的 topk 与 combine,shared = true,slots_e = top_k + 1)。

正因为算术定义如此,配置一旦声明 norm_topk_prob: true 就必须拒绝——这就是第 6 节"加载期拒绝"里 error.UnsupportedRouting 的由来。同理,专家宽度与 shared expert 宽度必须相等,因为两者被堆叠进同一份 experts.Layer 布局(experts = c.experts + 1,shared 在最后)。

四、family 层:不写 kernel,只做装配

配方明确写"it brings no kernels of its own"。下面把每个共享算子和它在本 family 中的角色对齐:

共享算子 用途 源码锚点
cuda/fp8.zig + qlinear 注意力投影的 block FP8 乘加,fp8g lane tile 布局 pack.zig、weights.zig
cuda/experts.zig 路由专家与 shared expert 的 grouped 调用,fp8g,shared 以权重 1 堆在最后 pack.zig
qk_rows QK norm、RoPE、写入 KV cache(pos % len) kernels.zig
norms RMSNorm 与 addRms 残差融合 kernels.zig
embed_rows bf16 词嵌入行取,再精确加宽到 fp32 kernels.zig
moe_glue sigmoid top-k + bias,未归一化权重,slot 合并 kernels.zig
dense_rows router 与 head 的稠密行计算 kernels.zig
window_attention 各层 prompt 行(全注意力层 win = 0)+ 滑动层 decode 行 kernels.zig
tree_attention 全注意力层 decode 行:已提交 key + 每条窗口的 chain kernels.zig

此外,Kernels.load 还加载了 sample(采样)、torch_argmax(torch 的 first-maximum 规则 argmax)与 torch_pointwise(bf16↔fp32 转换)三张镜像,因为采样路径要复刻 Python 引擎的 argmax 与舍入语义(kernels.zig、kernels.zig)。

4.1 权重打包:host 侧一次成形

pack.layer() 把一层打包成设备布局(pack.zig):

  • qkv:Q/K/V 三个 block-FP8 投影的 code 与 scale 按行拼接后,再用 fp8.packCodes / fp8.packScales 重排成 [npad/64][k/64][8][32][2][8] 的 lane 布局;
  • router:以 bf16 原样保留([E, D]),bias 则加宽为 fp32;
  • up / down:fx8.packGateUp 把 gate 与 up 交错,fx8.packOne 处理 down;scale 的排布是 up_scale: [E][2][NI/128][D/128](gate 再 up)、down_scale: [E][1][D/128][NI/128];
  • 所有 norm 统一由 widen() 从 bf16 精确加宽到 fp32——bf16 的位模式左移 16 位即得 fp32,该函数对非 bf16 dtype 直接返回 error.UnexpectedTensor,并有独立测试。

权重上传顺序与读取顺序解耦:weights.load() 通过 core.checkpoint_read_ahead 做只读预读(cuda_load_prefetch.zig),对应 TF_LOAD_PREFETCH 开关;预读失败会点名来源,上传与释放顺序保持不变。

4.2 一层的前向调用链

Model.launch() 是理解全局的地方(forward.zig)。逐层顺序为:

  1. lin.prompt / lin.decode 跑 L.qkv;
  2. o.qkv(...):Q、K 做 RMSNorm(滑动层再叠 RoPE),K/V 同时写入 cache 的 pos % len 行;
  3. 分页模式下(全注意力层走 pool page),额外调用 o.put(...) 把本行 K/V 写进页;
  4. 注意力:prompt 用 o.promptRows,滑动 decode 用 o.sliding,全注意力 decode 用 o.full(tree_attention);
  5. lin 跑 L.o,然后 addRms 把注意力输出加回残差,并顺便算出下一个 norm 的 bf16 输入(post_attn_norm → pre_moe_norm);
  6. o.dense 算 router logits,o.topk 选专家,router.route 生成 grouped plan,gx.prompt / gx.decode 跑 up 与 down,o.combine 按 slot 加权合并;
  7. 再 addRms(post_moe_norm → 下一层 input_norm,最后一层用 w.norm);
  8. 所有层结束后,把选中的行拷进 sel,跑一次 dense 得到 fp32 logits。

注意第 6 步 prompt 与 decode 的差异:prompt 走 gx.prompt 且 down 输出 bf16,decode 走 gx.decode 且 down 输出 fp32,combine 的 y_bf16 参数随之切换。promptTile(.fp8g) 与 16 行的 tile 选择也在此分叉——这解释了为什么不同宽度下的性能特征不一样,但数值结果相同。

4.3 两种执行形态,同一位

  • 一行一步:captureStep() 为每个 slot 捕获一次 CUDA graph(forward.zig),step() 只上传 token/position/slot 三个标量、改一次 stream row,然后 launchOn(s) 回放。图里的 paths 只算一次("a lone root: its path never changes")。
  • 更宽的窗口与共享 round:走 eager 路径,每行仍然逐层执行同样的算子序列。

配方说"One-row steps replay a CUDA graph a stream; wider windows and shared rounds run eager. Both give a row the same bits."——这一点由 kolibri-full 自检直接断言:eager 逐行、captured step、lane round、drafted、sampled 全部逐 token 相等(见 kolibri_tests.zig)。

五、服务与调度

启动命令与配方一致:

tensorfold-native serve /path/to/Kolibri-1 --name kolibri-1 --context 32768 --parallel 8

参数含义(结合 cli.zig 与 native.zig):

参数 作用 本 family 的约束
--name 对外服务名,用于 OpenAI 兼容端点 任意
--context 逻辑上下文窗口 内部会加上 16 行的验证预留并向上取整到 1,024 的倍数(见 5.3)
--parallel 并发流数 auto 表示"最多 8,能放下多少就放多少";显式数字即固定值,超过 64 会以 ParallelPastRound 拒绝
--no-drafts 关闭 copy drafts 关闭后走 plain round
--drafter 加载神经 drafter 本 family 明确拒绝

不指定 --context 时,native 层的默认值是 65536(native.zig)。

5.1 预填充:8,192 行一段

prompt 按最多 8,192 行一段执行,一段一个 step,与其他流的 round 交替。配方给出实测:一个满段大约占用 3.7 s。

关键在于行级位相等:一段的字节结果不依赖切分方式。配方实测,对 5,000 与 20,000 token 的 prompt 分别用 1,000、1,536、2,048 行切分,最后一行 logits 与 8,192 行整段逐字节相同。这条性质在 cuts() 中实现并断言(kolibri_tests.zig):两种长度 × 三种切分,比较 std.mem.eql 的字节相等,并打印最大差值以便诊断。

从源码看这条性质为什么成立:prompt 行只写自己位置上的 cache 行,注意力只读"该行之前"的 key,因此切分点不改变任何一行看到的 key 集合。滑动层的 ring 也必须能容纳"一段 + 一个窗口",这正是 ringSize 取 8,768 的原因。

5.2 并发流与共享 round

并发流共享最多 64 行的 round。每个流的 cache 在加载期分配,一个 --parallel 对应一个流。默认(paged)情况下,全注意力层的 K/V 取自核心 KV pool 的页,每个页持有 512 个位置(page_tokens = tree_attention.span = 512,见 forward.zig)。

配方的内存数据:

窗口 每流 cache
32k 1.29 GiB
64k 1.92 GiB

这个数字可以直接从 streamBytes() 复算(forward.zig):

for (c.full[0..c.layers]) |full| total += 2 * (if (full) context else ringSize(prompt_rows, c.window)) * c.kv_heads * c.head_dim * 2;
  • 40 个滑动层:每层 2 × 8768 × 4 × 128 × 2 B ≈ 17.1 MiB,合计约 685 MiB;
  • 10 个全注意力层:32k 时每层 2 × 32768 × 4 × 128 × 2 B = 64 MiB,合计 640 MiB;两者相加约 1.29 GiB。
  • 64k 时全注意力层翻倍到 1,280 MiB,合计约 1.92 GiB。

也就是说,"滑动层的内存与上下文长度无关"——这是这个混合架构在长上下文下的主要内存优势,因为 40/50 的层只按 8,768 键的 ring 付费。

显存预算不足时的行为是明确的:open() 先用 Plan.bytes(n) 在不分配的前提下算出 n 个流的总字节(fwd.Model.openBytes + be.Kolibri.openBytes),再与权重剩余空间比较;--parallel auto 会一路减到能放下的最大值,固定值则报 ParallelPastMemory 并在日志里给出"需要多少 / 剩多少 / 能放几个"的具体数字(native.zig、native.zig)。

5.3 prompt cache 的保态语义

配方:"The prompt cache keeps a stream's state at any row: full layers' keys up to it and each sliding layer's last 512."

实现在 snap.zig:一个 Saved 状态记录 at 位置、from(已被池页覆盖的起点)、以及一段设备缓冲或池页 blob。核心是 each()——按层、按 K/V、按位置顺序生成一串"连续 run":

  • 全注意力层:paged 时按页走,一个 run 不跨页;linear 时从 0 到 at 直接连续拷贝;
  • 滑动层:只拷 tail(m, at) = min(at, window - 1) = 512 行,并按 ring 回绕切成两段(先 at-window..ring,再 0..at)。这就是"last 512"的来源。

snap_lookahead = 0(native.zig)表示"保态就是该位置之前的所有 cache,不含任何前瞻"——因为本 family 没有 draft head 需要读下一个 token 的隐藏态。

5.4 草稿:只有 copy drafts

lane 核心的 copy drafts 以最多 16 行的窗口验证。这个宽度来自 max_window = limits.reserve = 16,并作为 exact_width 交给 lane planner(backend.zig):

pub fn facts(x: *const Kolibri) lanes.Model {
    return .{ .root_copies = x.priority_copies, .context_copies = x.priority_copies,
              .copy_match = if (x.priority_copies) 4 else 8, .exact_width = max_window,
              .gpu_tokens = false, .mtp = false, .speculate = false,
              .hidden_rows = true, .batch_rows = round_rows,
              .max_streams = @intCast(@min(x.m.slotCap(), round_rows)) };
}

注意 mtp = false、speculate = false、gpu_tokens = false——这就是"没有 draft head"的结构性表达。draft() 对任何 depth != 0 或带 lanes 的请求直接返回 error.NoDraftHead(backend.zig)。

TF_KOLIBRI_COPIES=1 可以把 copy 策略升级为 root/context copies,并把匹配长度从 8 降到 4;未设置或 0 保持原策略,其他值在权重加载前按名字拒绝(cuda/priority_copies.zig 的 read/enabled,copy_match 的取值见上)。该开关的适用范围、对照方法与"不得声称设备收益"的约定,见 CUDA lane 上的验证拷贝。

六、加载期拒绝清单

这是本 family 最需要提前知道的部分。以下情况都会在加载或请求入口以明确文案失败,而不是在推理中途给出可疑结果:

拒绝项 触发条件 错误名
非本模型 model_type != "kolibri1" NotKolibri1
其他量化 quant_method != "fp8",或 weight_block_size != [128,128] UnsupportedQuantization
归一化路由 norm_topk_prob: true UnsupportedRouting
其他层类型 layer_types 中出现非 full_attention/sliding_attention UnsupportedLayer
层数过多 num_hidden_layers > 64 BadConfig
缩放 RoPE rope_parameters 或 legacy rope_scaling 请求 YaRN UnsupportedRope
视觉塔 config.json 含 vision_config VisionTower
形状不匹配 head_dim ≠ 128;query/key head 比不是 4/8/12/16;hidden 或专家宽度不是 128 的倍数;shared 宽度 ≠ 专家宽度;专家数 > 4096;top_k + 1 > 64;window < 2 UnsupportedShapes
捕获内核集 设置了 TENSORFOLD_CUDA_KERNELS CapturedKernels
--vision / --precision 该 family 的 Options 不含这两个字段 按名字拒绝
--drafter takes_drafter = false 见下

--drafter 的拒绝文案是固定的:

--drafter: Kolibri-1 on CUDA loads no drafter yet; serve it without --drafter

而 explain() 会把本 family 自己的错误翻译成人话(native.zig),例如:

  • PastContext → 提示与回复超出上下文窗口,建议缩短 prompt 或降低 max_tokens;
  • NoFreeSlot → 所有流的 cache 都在使用中,等其他请求结束再试;
  • ParallelPastRound → 本 family 最多 64 个流(一个 round 的行数);
  • ParallelPastMemory / NoStreamFits → 显存预算放不下,建议降低 --parallel/--context,或调整 TENSORFOLD_MEMORY_RESERVE_GIB、TENSORFOLD_CUDA_MEMORY_LIMIT_GB;
  • StructuresUnsupported → 本 family 的 CUDA 路径尚未实现结构化输出。

另外,--context 并不是"直接使用"的:positions() 会调用 limits.capacity(),把 context + 16 向上取整到 1,024 的倍数(context.zig)。所以 --context 65000 实际得到 65,536,而 --context 65536 得到 66,560;fits() 还要求"prompt + reply 之后仍留出 16 行验证预留"。这解释了为什么逻辑上限与物理容量之间总有一点余量。

七、环境变量与运行开关

变量 取值 效果
TENSORFOLD_KOLIBRI_KV_PAGES 精确 0 关闭全注意力层的池页,退回线性 cache(environment.md、native.zig)
TENSORFOLD_KOLIBRI_GRAPHS 精确 0 每一步都走 eager,不复用捕获的 CUDA graph(backend.zig、backend.zig)
TF_KOLIBRI_COPIES 精确 0 / 1 copy 策略:默认 8 token 匹配的 suffix;1 启用 4 token 的 root/context copies;其他值拒绝启动
TF_KV_SHARE n 把 prompt 以核心 pool 的页形式保存(opt-in);本 family 支持
TF_LOAD_PREFETCH 数字 只读预读线程数,未设置为 0
TENSORFOLD_CUDA_KERNELS 任意 对本 family 一律拒绝(CapturedKernels)
TENSORFOLD_MEMORY_RESERVE_GIB / TENSORFOLD_CUDA_MEMORY_LIMIT_GB 数字 影响 room 的计算,从而影响 --parallel auto 能取到的流数

TF_KV_SHARE 有一条已记录的代价:prompt store 以整 512 token 的页保存,短于一个页的共享前缀(例如对话模板的前 45 个 token)不会被复用,prompt 也会在页边界被切断;在 GB10 上,冷的 2K 对话 prompt 到首 token 比不开 store 慢约 10%(0.87 s 对 0.79 s),解码速度与 token 完全一致。详见 已知问题。

八、自检:从编译到五条断言

配方给出的自检流程:

zig build -Doptimize=ReleaseFast -Dnvcc=/usr/local/cuda/bin/nvcc
zig-out/bin/tf-cuda-test kolibri-reference MODEL IDS   # layer 0 and the head against float64 from the checkpoint
zig-out/bin/tf-cuda-test kolibri-layers MODEL IDS      # the 513-key window edge, layer 4's full reach
zig-out/bin/tf-cuda-test kolibri-full MODEL IDS 128    # steps, drafted, sampled, shared rounds, cuts, kept states
zig-out/bin/tf-cuda-test kolibri-greedy MODEL PROMPTS N OUT   # greedy ids and top-2 margins a step
zig-out/bin/tf-cuda-test kolibri-logits MODEL IDS OUT  # teacher-forced logits of 2,048 rows, for quality

IDS 是真实文本的 token id 文件:kolibri-full 需要 20,000 个以上,kolibri-layers 需要 3,000 个。配方特别强调"Random ids give flat logits and say nothing about quality"——随机 id 无法暴露 top-6/384 路由在近并列行上的分歧。

每条命令的判据可以从源码读出:

  • kolibri-reference:只加载第 1 层,用 checkpoint 自身张量在 float64 下重算(kolibri_ref.zig),fp8 code 按 e4m3 解码后乘 128×128 块的 scale,bf16 按 nearest-even 舍入、fp32 按 fp32 舍入;比较对象包含"整段 prompt 的最后一行"与"前 n-1 行 + 一次 decode 行"两种路径(kolibri_layer_tests.zig)。
  • kolibri-layers:加载前 5 层,把最后一个位置能看到的第 n-1-win 个 key 改掉,断言最后一行的结果必须变化;把窗口外的第 n-win 个 key 改掉,断言结果必须不变,prompt 与 decode 两种形态各测一遍(kolibri_layer_tests.zig)。第 5 层(index 4)是全注意力层,用来验证"全可达"。
  • kolibri-full:这是信息量最大的一条。它先构造两个 prompt——200 token 的短 prompt,以及一个 3,000 token、后半段重复前半段的"长 prompt"(保证 copy drafts 能落地)——然后断言 eager 逐行、单流 lane round、带 drafts 的 round 三者 hash 相同;再用固定 seed(temperature 0.8, top_k 20, top_p 0.95)比较 plain 与 drafted;再把 4 个流放进同一 round,逐个与"单独跑"对比(kolibri_tests.zig)。
  • kolibri-greedy:对每个 JSON id 列表逐步 greedy,输出每步的 argmax 与 top-2 margin,并附整段 token 的 Wyhash。margin 是判断"这一族是否在近并列处开始分叉"的直接工具。
  • kolibri-logits:把前 2,048 行的 teacher-forced fp32 logits 落盘(2048 × 128000),可选再追加每个 prompt 的最后一行为 .last 文件,用于与 Python 引擎做分布级对比。

tf-cuda-test 还提供一条配方未列出的命令 kolibri-pages MODEL TEXT N(main.zig),用于验证"全注意力层走池页"与"线性 cache"给出逐字节相同的回复与 logits:用例覆盖 300 / 1,500 / 900 token(一页内、跨三页、退回被释放的页),保态位置取 1,000(故意不在页网格上),并检查页能否被重新租用(kolibri_pages_tests.zig)。

九、与 Python 引擎的数值差异

原生行与 Python 引擎不是逐字节相等的:Python 的 glue 是 Triton,这里是共享 CUDA 算子,fp32 舍入在此处彼处相差一个 ulp。

对多数模型这无关紧要,对 Kolibri-1 却会被放大:6/384 的 top-k 路由会把 ulp 级差异变成"选中了不同的专家",于是 greedy 回复会在两个 token 近乎并列处开始分叉。

配方给出的 2,048 行真实文本 teacher-forced 对比:

指标 原生(本族) Python 引擎
next-token top-1 一致率 92.3% —
KL 0.06 —
NLL 3.574 3.578
top-1 准确率 35.96% 35.47%
平均熵 2.354 2.358

读法建议:先看 KL 与 NLL,再看 greedy 分叉。上表说明两者分布在统计上几乎重合(KL 0.06、NLL 差 0.004),而 92.3% 的 top-1 一致率意味着约 7.7% 的行存在"另一个 token 也几乎同样合理"。用 kolibri-greedy 输出的 top-2 margin 可以定位这些行:margin 接近 0 的位置就是分叉高发区,属于架构性差异而非缺陷。

另一处已知的舍入细节是 RoPE 频率表。forward.zig 用 float64 算 p / theta^(2j/D)、再把 cos/sin 舍入到 fp32,并把两半重复(neox 布局);测试把该实现与 core 的 rope_freq.inverseFrequencies 逐位比较,结论是 64 个频率中有 19 个相差 1 ulp,首个出现在 index 7(forward.zig)。这是"同一位"承诺的边界:同一引擎内所有路径位相等,但与另一套实现之间允许 1 ulp。

十、性能数据

GB10、greedy、tensorfold-native 服务、开启 copy drafts:

场景 tok/s(code / chat)
单流,bench_openai.py,256 tokens 51.9 / 49.8
4 流,聚合 124.0 / 126.0
8 流,聚合 175.5 / 183.1

冷 prompt 到首 token(bench_cache.py --require-cold --repeats 3 --prompt-cache-gib 0,取冷请求中位数):

prompt 长度 首 token 时间
2,048 0.97 s
8,192 3.72 s
32,768 16.8 s
64,000 37.8 s

这些命令的语义可以直接查证:bench_openai.py 的 --tokens(默认 64)与 --temperatures(默认 1.0,0,其中 0 即 greedy);bench_cache.py 的 --repeats(默认 2)、--require-cold(要求首个请求报告零缓存 token,否则判定不合格)与 --prompt-file(JSON 无符号 32 位 token id 数组,需用检查点自己的 tokenizer 生成)。

--prompt-cache-gib 0 的作用是把 prompt cache 容量归零,从而保证测到的是真正的冷预填充;这与配方里 0.97 s → 3.72 s → 16.8 s → 37.8 s 的近似线性增长一致,也与 8,192 行一段、一段约 3.7 s 的描述互相印证:8,192 token 恰好是一段,32,768 是四段(≈14.9 s 理论值,实测 16.8 s),64,000 接近八段。

十一、下一步

配方只列了一条:通过 lane 核心的 drafter 接口接入 EAGLE-3 drafter。

把当前状态和这条路线对齐,需要三件事同时到位:

  1. takes_drafter 改为 true,并去掉 --drafter 的固定拒绝文案;
  2. draft() 不再对 depth != 0 返回 NoDraftHead,而是真正调用 head;
  3. snap_lookahead 从 0 改为实际需要的前瞻行数——因为保态时刻需要覆盖 draft head 读到的下一个 token 的隐藏态。

在此之前,copy drafts 已经是可用的:它从请求自身的文本历史里找匹配,最长 16 行一个验证窗口,不需要任何神经网络 drafter 权重。

附:相关文档与源码索引

登录后查看全文
TensorFold