上线两天近 800 星、最近一小时还在加速:把推理调优经验封装成技能包,为什么突然被抢着订

原创2026-11-19 10:19:2855 阅读

上线两天近 800 星、最近一小时还在加速:把推理调优经验封装成技能包,为什么突然被抢着订

一个 32 KB 的仓库,17 个文件,1171 行新增代码,一次 squash 提交,作者只有一个人(提交信息里带一行 Co-Authored-By: Claude Opus 5.5)。2026-11-16 18:40 UTC 建仓,两天后 star 数逼近 800;本文写作时再查 GitHub API,已经变成 1046 stars / 91 forks / 4 个 open issue,updated_at 停在 2026-11-18T16:29Z——也就是建仓后约 46 小时。仓库里没有模型权重、没有推理引擎、没有 CUDA kernel,连一张 benchmark 曲线图都没有。

它卖的东西只有一件:把"怎么把本地 LLM 服务调快"这件事,写成一份 agent 可以照着执行、可以复核、可以拒绝执行的过程文档。

这件事值得认真拆一次,因为它触及了一个正在发生的变化:推理调优长期是少数人的手感,现在有人试图把它变成可加载的清单;而清单能不能替代手感,取决于它写得多诚实。

它到底交付了什么:三段式结构,而不是一排启动参数

仓库根目录的 README.md 开门见山地把定位说清楚了:这不是 flag 列表,而是"我们实际是怎么拿到这些加速"的编码。整个技能包被切成三块,加载策略本身就是设计:

第一块是 SKILL.md,166 行,只有流程。开头的 YAML front matter 里 description 字段写得极长,把触发条件全塞了进去:hill climb、tok/s、decode speed、MTP、EAGLE、draft model、speculative decoding、KV cache、TTFT、theoretical maximum。这是 Skill 机制的关键——agent 平时只看到这段描述,只有当任务命中描述时,才会去读正文。所以描述里塞的不是营销词,是路由键。

第二块是 references/ 下五个文件,按需加载,这是整个设计里最省钱的一招:

  • ceilings.md:79 行,教你怎么算理论天花板,附一个完整算例;
  • methodology.md:55 行,测量陷阱与统计;
  • levers.md:87 行,按"通常收益"排序的杠杆清单,每条带实测证据;
  • gotchas.md:58 行,vLLM / SGLang / llama.cpp / ExLlama 以及 Intel / NVIDIA / Apple / AMD 的坑;
  • publishing.md:64 行,验收闸门、pin、发布。

第三块是 scripts/,四个文件加起来 358 行,纯标准库 Python 加 bash,不依赖任何框架:

  • bench.py:262 行,测任何 OpenAI 兼容服务;
  • ceiling.py:51 行,从一份 JSON 算天花板;
  • queue.sh:14 行,串行化的跑批队列;
  • mem.sh:31 行,算容器的真实显存占用。

安装方式也刻意做得很土,没有任何包管理器:

git clone https://github.com/sybil-solutions/inference-optimisation-skill
mkdir -p ~/.claude/skills
cp -r inference-optimisation-skill/skills/inference-optimisation ~/.claude/skills/

不用 agent 也能跑,README.md 给了一条四行 quick start:

S=skills/inference-optimisation
python3 $S/scripts/ceiling.py $S/examples/ceiling-ornith-b390.json
mkdir -p configs && cp $S/examples/config-existing-server.json configs/base.json
python3 $S/scripts/bench.py run configs/base.json --long 131072
bash $S/scripts/queue.sh base cand base

注意第三、四行的顺序:先单跑一次,再跑 base cand base。控制组夹住候选组,这是全文的技术底色,后面所有数字都建立在它上面。

"先算天花板":这条规矩为什么反直觉,又为什么关键

绝大多数调优教程的第一句是"打开配置文件,把 --max-num-seqs 改成 256"。这个技能包的第一句是"先算出这台机器物理上最多能跑多少"。

SKILL.md 第 1 节把这件事拆成五个可算的量,并且明确要求"测量硬件,不要相信 spec sheet":

  • Decode 受显存带宽约束。每吐一个 token 要读的字节数 = 稠密权重 + 激活专家(top_k / n_experts × expert_bytes)+ LM head + 工作上下文下的 KV 读取,除以实测带宽。
  • Prefill 受算力约束。flops_per_token ≈ 2 × active_params,再加注意力项,除以实测峰值的约 50%。
  • TTFT 地板:一次前向 + tokenize + 调度。
  • 启动地板:权重字节除以磁盘或 page cache 速度,前提是 JIT 和 graph cache 能复用。
  • KV:每 token 每层字节 × 真正有 KV 的层数(hybrid 模型层数很少),反推内存上限下能塞几条满长序列。

ceiling.py 把这个算术固化了。最核心的是两个函数,逻辑短到可以直接读完:

def decode_ceiling(m, drafts, accept, ctx=0, n=1):
    union = 1 - (1 - m["top_k"] / m["n_experts"]) ** ((drafts + 1) * n) if m.get("experts_gb") else 0
    verify = m["dense_gb"] + m["lm_head_gb"] + m.get("experts_gb", 0) * union
    verify += n * m.get("kv_bytes_per_token", 0) * ctx / 1e9 * (drafts + 1 if m.get("kv_per_verify_row") else 1)
    draft = drafts * n * (m.get("draft_layer_gb", 0) + m.get("draft_head_gb", m["lm_head_gb"]))
    return m["bandwidth_gbs"] / ((verify + draft) / (accept * n)) * n

这里有两个容易被忽略的工程细节。第一,MoE 的专家读取用的是并集而不是简单相加:1 - (1 - top_k/n_experts)^((drafts+1)*n),因为一次 verify 要读的是所有 draft 行路由到的专家集合,去重之后才是真实字节。第二,投机解码的分母是 accept * n,即"每个 verify step 平均产出多少 token",而不是"接受率"——这个区别后面会要人命。

输入文件是 examples/ceiling-ornith-b390.json,三行 JSON,把带宽 115 GB/s、峰值 36 TFLOPS、MFU 0.5、稠密 0.758 GB、专家 16.26 GB、top_k 8、256 专家、LM head 0.382 GB、KV 10240 B/token、draft 层与 head 尺寸、以及三档投机配置全写死。

输出直接给结论。README 里那张 B390 的表最值得读,因为它同时给出了"目标"和"现实":

模式 每 token 读取 天花板
不投机 1.68 GB 68 tok/s
1 个 MTP draft,完整 draft head,a = 1.85 1.38 GB 83 tok/s
1 个 draft,裁剪到 32K 词表的 draft head 1.19 GB 97 tok/s
2 个 draft,a ≈ 2.5 1.11 GB ~103 tok/s

而实测 c1 decode 是 53 tok/s。这个数字单看毫无意义:说它好,它离 103 差了一半;说它差,它已经比基线 43.6 高了 21%。

天花板给了它意义:53 是理论上限的约 55%,而剩下的差距有明确归属——这个模型的 MTP head 在 depth 2 只有约 14% 接受率,所以"2 drafts"那一行根本不可达,真正该对比的是 97 那一行;剩余缺口来自量化 GEMV kernel,verify 图里的有效带宽只有约 76 GB/s。同样地,prefill 在 256K 上做到 628 tok/s,而实用天花板是 670–684,长上下文 prefill 基本贴住了物理极限。

这就是"先算天花板"的真正价值:它把"还能不能更快"从观点问题变成了算术问题。 如果用户的目标高于天花板,agent 应该在开工前就带着算式告诉你不可能,而不是陪你调三天参数。

测量学才是主体:为什么"跑分涨了"经常是假的

如果说天花板是这份技能包的骨架,methodology.md 就是它的良心。55 行里几乎没有一句是"技巧",全是"你刚才那个结论是错的,原因是这个"。

最狠的三条:

第一,不要数 SSE chunk。 开了投机解码后,引擎一个 chunk 会吐好几个 token。按 chunk 计数会系统性低估 MTP 的成绩。正确做法是 stream_options: {include_usage: true} 或 continuous_usage_stats,拿服务端的 usage 统计。bench.py 在 chat() 里就是这么写的:请求体固定带 "stream_options": {"include_usage": True},token 数只从 ev["usage"] 取,从不 len(chunks)。

第二,prompt 要用真 tokenizer 量。 文档里记载得很具体:用"随机单词"拼出来的文档实际是每词约 3.5 个 token,而不是 1.3–1.9,于是名义上的"32K / 128K"格子实际是 58K / 232K。这种错误不会让曲线变形,只会让整张表失去可比性——而且它极难自查,因为每个格子看起来都"差不多符合预期"。

第三,漂移可能大于你要测的效应。 原文给了一个数字:同一个配置,间隔一小时测得 53.8 和 49.5。所以规矩是"只和邻居比":控制组、候选组、控制组,候选必须同时赢过左右两个邻居,且不能让任何指标回退超过 3%。queue.sh 把这个模式变成了一行命令:

bash queue.sh ctl-a cand ctl-b

它用 flock 锁住 /tmp/inference-hillclimb.lock,保证跨调用者一次只跑一个 GPU 任务;长队列要求 setsid nohup ... & disown 脱离,因为 agent 重启会杀掉子进程——这条在 gotchas.md 里单独列了一行。

bench.py 里还有几个细节,全是踩过坑之后长出来的:

  • PROMPTS 是固定的六个 prompt 面板,注释写着"接受率和速度都依赖内容,所以永远不要随机化"。文档里给了对照:随机 prompt 会把接受长度从 2.4 拉到 3.7,让 c1 比较彻底变成噪声。
  • document(tokens, seed, needles=3) 生成填充文档时,先插一个 [doc {seed}-{time_ns}] 的头,专门用来打掉 prefix cache;正文里放三个随机 8 位码,分散在不同深度,最后要求模型原样列出——这就是长上下文检索门禁,返回 retrieval: "3/3"。
  • looping(text) 用重复 n-gram 占比判断退化输出。文档里那个例子值一提:一个 117 tok/s 的"纪录",实际是模型在循环输出编号列表。
  • MemWatch 线程按 interval_s 采样内存探针,超 cap 就调 stop_server() 杀掉。mem.sh 是配套探针,它知道统一内存的坑:Intel/AMD iGPU 上 GPU 分配不计入 cgroup,MemAvailable 变化显示 14 GiB 而真实占用 29.4 GiB。所以它去 /proc/<pid>/fdinfo 里读 drm-resident-*,按 drm-client-id 去重,再加 cgroup 的 anon。
  • on_ac() 检查电源。require_ac: true 时,电池上直接 sys.exit。理由很硬:笔记本用电池或平衡电源方案会慢 8–10%,后台一点 CPU 负载就能把 107 tok/s 打到 75 tok/s。

显存、批处理、量化:三条线各自被怎么处理

标题里那三条"调优线",在这个仓库里的权重完全不同,值得分开说,因为它的取舍本身就是观点。

显存这条线写得最细,因为它最容易出错。 levers.md 里有一类模型是传统教程完全没覆盖的:hybrid SSM/GDN/Mamba。这类模型卡并发的不是 KV token,而是 state slot。原文给了两个具体数字:SGLang 在 --max-mamba-cache-size 调大之前拒绝调度超过 1 个请求;vLLM 保留精确的 1600-token block 而不是向上取整到 2048,让 c16 从 10 条流变成 14 条,聚合吞吐 +17%。KV 池则要求"按 N × context 显式设定,并用并发满长 soak 证明"——B390 从 264K token 扩到 1.05M(4 × 256K),soak 在 36.8 GiB 峰值下找到 4/4 个 needle。

还有一个反面教训:显存留白。在 Arc 上过度分配会把整机拖进 livelock,要求至少留 1.5 GB;vLLM 在统一内存上会把 gpu_memory_utilization 和空闲 host RAM 比,接近 0.985 的值会被直接拒绝。

批处理这条线被拆成了两个互相打架的目标。 chunk size 不是越大越好:B70 上从 8192 降到 2048,把最坏 decode 卡顿从 7.1 s 压到 1.95 s,代价是 decode 掉 4%,最后取 4096 作折中;B390 上 1024 升到 4096 再叠加 INT8 GEMM,32K 处 +50%。同一份文档里还有一条更"脏"的经验:grouped MoE GEMM 要避开 padding cliff,M = 17–48 行的中间块尺寸会掉 5%;改成 64 行 M-block,每行权重的解码次数减半,B390 端到端 prefill +7%,且 bit-exact。

量化这条线,仓库的处理方式非常克制:它不提供任何量化脚本。 量化被当作既成事实,只影响两个决策。一是"选硬件能原生解码的格式"——RTX 3090 上 AWQ-INT4 打赢 FP8,因为 Ampere 没有 FP8 单元。二是"KV 量化的 dtype 是一笔交易":FP8 KV 省一半显存,但在某个 flash-attention kernel 上注意力吞吐直接腰斩(39 vs 69–74 TFLOPS),把 block 反量化到 fp16 再合 LSE 才救回来,128K prefill 从 760 回到 1059 tok/s;而在 64 层里只有 16 层带 KV 的模型上,q8_0 KV 反而把 llama.cpp 从 45.4 打到 27.0 tok/s。

这种"不给量化器、只给量化决策树"的做法,恰恰是它和"又一个一键脚本"的分界线。

杠杆清单:按赔率排序,而不是按热度

SKILL.md 第 3 节给了一个明确的施力顺序,从最便宜的开始,levers.md 提供每条的证据。这套顺序和网上流传的"调优 checklist"最大的区别是:每条都带 before → after,且标明适用范围。

  1. 持久化 JIT / compile / autotune 缓存(启动时间 −50~70%)。Arc B390 + SGLang:113 s → 43 s;4× RTX PRO 6000 + vLLM:后续启动从约 22 min 降到 7 min。附带一条 vLLM 专属的:某些文件系统上 mmap 加载只有约 60 MB/s,27 GB 要 26 分钟,--safetensors-load-strategy eager 把它降到秒级。
  2. Decode graph(CUDA/XPU graph capture),被标注为"第一条杠杆":Arc Pro B70 14.4 → 28.4 tok/s,SGLang XPU 16 → 32,vLLM INT4 11 → 27。
  3. 投机解码,但要看"每步成本"而不是接受率。这里有三条硬证据:
    • 裁剪 draft LM head 词表:B70 上 c1 从 37.9 → 48.2(+27%),只保留 1940 个 block 里的 512 个,覆盖率 98.6%;B390 上保留 256 个 block,+14%。因为 target 仍用全词表验证,输出不变。
    • draft 长度必须按并发和上下文扫:B70 上 c1 用 k=4、c4 用 k=3、c16 用 k=2(+11%,因为能塞下更多流);B390 在 128K 上下文下,1 个 draft 跑 29.6 tok/s,3 个 draft 只有 15.5,尽管短上下文下 3 个 draft 更优。
    • verify 必须走 decode 风格的 attention。把 k-query verify 丢给 prefill kernel,步时会随上下文每 1K token 涨 3.5 ms(16K 时 47 → 104 ms);改成每行按 decode query 跑,SGLang B70 c1 从 vLLM 的 75.7 变成 82.6。
  4. 并发与 KV 定容,含前缀缓存必须显式开启并确认 cached_tokens > 0:66K token 的第二轮 TTFT 从 36 s 降到 0.45 s,32K 从 29 s 降到 0.95 s。有些引擎对 hybrid 模型会静默关闭前缀缓存。
  5. Prefill:chunk size、更快的 attention 库(oneDNN fused SDPA 在 4K–254K 上比 FA2 高 7–18%;手写 flash attention 只有 48 vs 61 TFLOPS)、int8/fp8 prefill GEMM(Hadamard 旋转域下 per-row scale 就够,所有 linear 快 1.89×,NLL +0.17%,top-1 一致率 97.2%,decode 保持 bit-exact)。
  6. Kernel 线程与 tile 尺寸——默认值往往是给更大的卡调的。B70 上 4096 → 1024 线程,code c1 从 48.5 到 56.9。
  7. 真正改 kernel,只在配置杠杆平台期之后做。这时才有 ISA 级发现:B70 上 stride-3 的寄存器区间被编译成逐元素 move,改成 planar 后 LM head 从 4.05 ms 降到 1.72 ms。

这份清单里最值得学的是第 3 条和第 7 条之间的落差:前六条是"改配置 + 换库",第七条是"读 ISA"。技能包没有假装第七条能靠 agent 自动完成,它写的是"profile、读 ISA、修主导 kernel,且只在配置杠杆平台期之后"。

负面结果同样是交付物

README 里有一句几乎可以当论文标题的话:PLAN.md 里大部分价值,是那些"没成"的东西和原因。

仓库确实按这个标准执行了。B390 上三次独立的融合尝试(fused GEMV、shared-expert fusion、fold attention)结果全部正确,收益全部是 0%——因为开了 graph 之后,时间在大 kernel 内部,融合小 kernel 没有意义。这个结论直接改变了后续策略:别再融合了。

投机解码也不是免费加速。Apple M4 上开 3 个 MTP draft,从 6.35 掉到 3.25 tok/s;llama.cpp 的 MTP 在难 prompt 上是 36.7,不开是 45.4。文档还给了原因层面的判据:接受率更高不等于更快——一个 7-token draft 接受长度 3.26,高于 MTP 的 2.85,但实际慢 11–14%,因为每步成本更高。所以正确指标是"每 verify 步的毫秒数"和"接受长度"分开看,tok/s = a ÷ step_time。

在 Intel Xe 上被测量并否决的还有一长串:软件流水/预取(寄存器溢出,M=16 从 39 ms 恶化到 86 ms)、查表式 codebook(比 ALU 解码慢 4 倍)、LSC prefetch(等于噪声)、async scheduling(0%)。

这些条目对读者的实际价值,高于任何一条"提速 27%":它们划掉的是你可能花两周去走的路。

从"能跑"到"能发":六道闸门和一个干净构建

绝大多数调优经验死在传播环节——作者在自己机器上跑出了数字,别人复现不出来。这个仓库把"可复现"写成了流程的最后一环。

SKILL.md 第 2 节第 6 条规定:一个配置只有在通过三道稳定性门禁后才配叫"best"——约 50% 和约 100% 上下文处的 needle 精确命中、KV 池按 N 用户定容时的并发满长 soak、以及声称无损时的 greedy 等价性检查。

publishing.md 再往前推一步,给出六道验收闸门,全部要求跑在干净构建上:加载(/v1/models 列出模型)、聊天(短答 + stop 收尾)、推理(thinking 与 content 分离且答案正确)、工具(完整往返,模型调用工具、拿到结果、引用其中的 code)、上下文(约 85% 窗口处的 needle 精确命中)、速度(首 token 后前 30 s 的单用户 decode,不设输出上限,用服务端 tokenizer 计数,高于地板值)。

然后是最容易被跳过的一步:把干净构建和你的调优最优镜像背靠背 A/B,证明两者在噪声内一致。不一致就先找差异,别发。

再往后是供应链纪律:镜像按 digest pin、引擎与 kernel 按 commit pin、Python 包按版本 pin(pip freeze 不一致就让构建失败)、权重按 revision pin;构建日志作为证据保留;持有 pin 构建 commit 的分支不许删,否则可复现性断裂。

发布前的最后一个动作是 grep 整个产物包,找 secret、凭证文件路径、token、个人邮箱和家目录用户名。这条不是形式主义——PROMPT.md 里专门有一节讲凭证:sudo 密码或 token 只通过 harness 的 secret 机制问一次,存进 mode-600 文件,永不打印、永不提交、永不把路径写进任何要发布的东西。

examples/config-sglang-docker.json 里有个细节能看出这套流程的成熟度。它的 stop 不是 docker stop,而是:

"stop": ["bash", "-c", "curl -s -X POST localhost:8000/abort_request -d '{\"abort_all\":true}' -H 'Content-Type: application/json'; sleep 5; docker stop -t 60 llm; docker rm -f llm"]

先 abort,再等 5 秒排水,最后给 60 秒超时停止。原因写在 SKILL.md 第 2 节第 7 条和 gotchas.md 里:长 prefill 中途强制停容器,直接把 Intel xe 驱动搞出 GPU page fault;在 Arc Pro B70 上,那些"device lost"崩溃最后被追到 PCIe 链路掉线——AER replay 超时、link down,三天内 8 次。

两天 1000 星的增长曲线,能读出什么

先把事实摆清楚:建仓 2026-11-16 18:40 UTC,单次提交,1171 行,17 个文件;updated_at 为 2026-11-18T16:29Z;写作时 stars 1046、forks 91、open issues 4、仓库体积 32 KB、主语言标记为 Python。标题里的"近 800"是某个快照时刻,之后继续往上走,到本文落笔时已经过千。

第一条可验证的读数:fork/star 比约 8.7%。 91 / 1046。这个比例在"收藏型"技术仓库里偏高——纯资讯类项目常见 2%–5%,因为 star 是"稍后读",fork 是"我要改"。8.7% 意味着相当一部分人是把 skills/inference-optimisation 直接拷进 ~/.claude/skills,或者把 PROMPT.md 拿去改字段。安装方式本身在鼓励这个动作:一行 cp -r,没有依赖,没有构建。

第二条:第二个 24 小时比第一个更陡,符合"可验证产物"的传播规律,而不是"话题"的传播规律。 话题型项目的曲线是首日冲高、次日衰减,因为转发一次就到顶了;可验证型项目的曲线是首日小、次日陡,因为第一天的读者需要时间去跑一遍 ceiling.py、改一份 configs/base.json、看 ledger.jsonl 里出现自己的机器名。跑通了才会转发,转发时带的是自己的数字而不是作者的数字。README 那张结果表恰好为这种二次传播准备了模板——硬件、模型/量化/引擎、before → after,一格一格填。

第三条:46 小时里 open issues 只有 4 个,而 PR 门槛被写得很硬。 README 的 Contributing 一节要求每个 PR 必须带:硬件、模型、量化、引擎版本、before → after 数字、测量方法、以及原始数据链接。这个门槛会压掉大量"我觉得这样更快"的提交,也让 issue 区不至于变成求助灌水。对一个两天大的仓库来说,这是稀缺品。

需要说明的是,以上三条是从仓库元数据与文档结构推出的解释,不是作者的自述。star 曲线本身不构成因果证据;能确证的只有一件事:这个仓库在极短时间内聚集了一批愿意 fork 的人,而 fork 是比 star 更贵的行为。

需求侧:从"老手的手感"到"可复核的清单"

把视角拉远一点,这个仓库撞上的是一个正在成形的空档。

同期中文技术社区里,关于 Skill 的讨论已经明显过了"是什么"的阶段。能看到的分歧很具体:一边是在讲怎么把能力拆成原子单元、怎么用 YAML + Markdown 描述触发条件、怎么做渐进式披露以控制 token;另一边已经开始反向清理——有文章在讨论"Skill 过度膨胀",主张只保留稳定、可触发、不替代思考的领域知识,并且给出了"精简到 9 个核心 Skill 后定位准确率提升、token 消耗下降"这样的实测;也有文章直接把"所有 Skill 终将消亡"当标题,论证模型能力上涨会吞掉一部分技能。甚至还有"Skills 刚火,零 Skill 的 Agent 就来了"这类观察。

这些声音指向同一件事:Skill 的稀缺性不在数量,在可信度。 一个"帮我写周报"的 Skill,模型变强一次就过时;一个"先算带宽天花板、再用控制组夹住候选"的 Skill,模型变强反而更好用,因为它约束的是方法论,不是话术。

推理调优正好落在后一类里,而且它的需求侧正在发生结构性变化,有三个可见的推力:

其一,硬件碎片化把"经验"的保质期压到了几个月。 这份技能包自己就是证据:同一套杠杆,在 B70 上 4096 线程是错的、1024 才对;在 B390 上 256 线程是小赢;在 Apple M4 上深度投机直接负收益;在 Ampere 上 FP8 打不过 INT4;q8_0 KV 在一个模型上是灾难、在另一个模型上没感觉。当"我上次这么调就快了"的命中率跌到掷硬币水平,人会主动去找一份写着"什么情况下这条不适用"的清单。

其二,本地推理的规模上来了,调优的人却没上来。 README 里那些目标机器——Arc B390 笔记本 iGPU、Arc Pro B70、RTX 3090、4× H200 NVL——横跨消费级到数据中心。会调 vLLM 的人不一定会在 XPU 上调 SGLang,会调 SGLang 的人不一定碰过 hybrid GDN 的 state slot。技能包做的事,是把四个引擎、四家硬件、若干量化格式的坑压进 87 行 levers.md 和 58 行 gotchas.md,让一个只懂一种栈的人不至于从零开始。

其三,也是最现实的一条:调优结论正在变成需要交付的产物。 一旦你要把"这台机器上 53 tok/s"发给别人、写进 README、或者放进采购决策,你就必须回答"天花板是多少""怎么测的""换台机器还成立吗"。这三个问题恰好对应 ceiling.py、bench.py 和 publishing.md 的六道闸门。需求不是"再快一点",是"快多少是可辩护的"。

PROMPT.md 里那张报告模板,其实就是这个需求的形状:

Metric Baseline Now Ceiling How measured
c1 decode median of N, thinking on/off, prompt panel, temperature
cN decode wall-clock aggregate
Prefill 4K / 32K / long cold unique prompt, prompt_tokens ÷ TTFT
KV capacity tokens, and N × context proven by soak
Startup / TTFT
Peak memory driver residency + anon, vs cap

有五列,第四列是天花板,第五列强制写清测量口径。这份表格的形状,就是"手感"和"清单"的分界线:手感给不出第四列。

它不能替你做的事

写到这里必须把边界划清,否则这篇文章就变成了另一种营销。

它不含任何可复用的 kernel 优化。 B390 上 GEMV kernel 卡在约 76 GB/s 有效带宽,B70 上 stride-3 寄存器布局的修复,这些都只写在 levers.md 的条目里,没有代码。想在别人的卡上重现,你得自己读 ISA。

它的证据分布很不均匀。 结果表里 Intel Arc 占了三行,NVIDIA 占三行,Apple 只有一条负面结论(M4 上投机解码掉一半),AMD 只出现在 ExLlama 的 HIP graph 泄漏里。所谓"any hardware"目前更准确的表述是"在四类硬件上验证过方法论,在一类硬件上验证得最透"。

它假设你有 shell 权限和一台独占的机器。 一套流程要求:一次只跑一个 GPU 任务、AC 供电、固定性能方案、空闲宿主、内存看门狗、长任务用 setsid 脱离。放到共享集群或者多租户推理服务上,前四条直接失效。

最后,它治不了"目标本身不合理"。 SKILL.md 能做的只是在天花板算出来之后,带着算式告诉你"100 tok/s 在这台机器上不可能"。这句话不好听,但它是这份技能包最值钱的部分之一——它把"再调调看"这个无底洞,换成了一个可以结束的对话。

一个两天破千星的仓库,通常不是因为它回答了所有问题,而是因为它把某个一直含糊的问题问清楚了。这次被问清楚的是:当你把一个 token 的读取字节数、一台机器的实测带宽、和一次 verify 步的接受长度摆在一起,调优就不再是玄学,而是一道可以算错、也可以算对的题。 而能够被算错的题,才有可能被做对。

登录后查看全文
inference-optimisation-skill