實際影片長度:11:19.000。原文、繁中、雙語可點擊句子跳轉影片。
0:00.166–0:02.335
OK 今天来讲一下千问 3.8 27B
0:02.335–0:04.771
这个模型我最近发现了一个新框架
0:04.938–0:06.139
这个框架叫 NInfer
0:06.206–0:07.907
在特定的长上下文再加
0:07.907–0:09.743
上 MTP 的场景里面啊官方和
0:09.743–0:12.479
社区的测试速度甚至能达到两倍
0:12.712–0:15.081
那我自己这张 4090 到底能快多少呢
0:15.281–0:16.249
看到最后你就知道了
0:16.416–0:17.117
上上个星期我不是
0:17.117–0:21.154
刚部署好千问 3.8 27B 嘛那时候用 的呢是 llama.cpp
0:21.287–0:22.889
也是为了优化卯足了劲儿
0:22.922–0:24.624
十几个小时的矩阵测试
0:24.724–0:27.260
就是为了得到最好的那一个参数
0:27.360–0:29.396
啊然后终于搞满意了固定下来了
0:29.429–0:30.330
200K 上下文
0:30.497–0:31.664
七八十 tokens 每秒
0:31.765–0:33.400
那 llama.cpp 在这个阶段呢
0:33.400–0:36.202
对于我自己的硬件而言基本上是被优化到顶了
0:36.469–0:38.905
但是呢就在前两天我发现全白测了
0:39.005–0:41.808
就是在研究 VLLM 或者 SGLang 这些框架的时候呢
0:41.808–0:43.510
我发现了一个叫做 NInfer 的东西
0:43.576–0:44.944
看大家的评价是非常的
0:44.944–0:48.581
疯狂什么直接暴涨两倍的速度四舍九入那将像
0:48.581–0:49.349
四舍九入
0:49.682–0:52.585
四舍五入那就相当于多给了我一张 4090 啊
0:52.819–0:54.454
嗯这还不赶紧部署起来试试
0:54.721–0:57.557
于是呢我就让 GPT-5.6 Sol 写 了一个详细的方案
0:57.590–0:59.859
一整套啊包括部署包括测试的方案
1:00.126–1:03.129
然后把整个 plan 丢给我服务器上的 DeepSeek V4 Flash 去干
1:03.329–1:05.498
V4 Flash 一个人是吭哧吭哧干了
1:05.498–1:07.267
五个小时包括配置包括
1:07.267–1:09.769
对 NInfer 的各种参数进行矩阵测试
1:09.836–1:11.538
之后再和 llama.cpp 进行矩阵对 比
1:11.604–1:12.305
我就出了个门
1:12.405–1:13.873
然后回来他就直接给我
1:13.873–1:16.509
交付了一份能用的最佳配置和整个对比
1:16.509–1:17.177
结果的报告
1:17.310–1:18.711
这感觉太爽了就
1:18.711–1:20.113
要知道就在四五个月前
1:20.113–1:23.850
这种事情都是不可能的那时候我是逮着 GPT 对线
1:23.850–1:25.485
手搓配置 vLLM
1:25.518–1:27.220
整整搓了好几天才跑起来
1:27.353–1:30.523
来啊那给不了解的小伙伴先解释一下所谓的 NInfer 其
1:30.523–1:32.926
其实就是类似于 llama.cpp 或者 vLLM
1:32.926–1:35.595
这种框架但它和那些都不一样啊它
1:35.595–1:38.731
不是那些的派生而是一个从零写的推理引擎
1:38.865–1:40.300
它特殊的地方就在于其
1:40.300–1:42.001
他的框架是要需要考虑
1:42.001–1:43.736
不同的模型不同的硬件
1:43.736–1:46.339
怎么兼容而 NInfer 特别的地方就在 于
1:46.439–1:49.976
它把模型和硬件这一条路径给固定死了
1:50.176–1:53.146
原版主要盯的就是 RTX 5090 这个 显卡
1:53.313–1:55.682
模型呢主要就是千问 3.8 这个家族
1:55.815–1:58.818
后面有大神把它移植到了 3090 上面后 来呢又有人
1:58.852–2:03.523
根据 3090 做了 4090 的优化那 我这次用的就是这个 4090 fork
2:03.590–2:04.591
所以基本上就是把
2:04.624–2:09.162
千问 3.8 27B 这一个模型和 RTX 4090 这一张显卡
2:09.195–2:11.231
这两个固定下来往死里优化
2:11.331–2:12.999
它不需要像 llama.cpp 那样去
2:12.999–2:13.266
考虑
2:13.333–2:15.101
他拿到一个 GGUF 之后要去看
2:15.101–2:17.003
一下它的架构是什么再解析
2:17.003–2:18.705
然后再根据设备去选
2:18.705–2:20.607
一个后端再去运行这一
2:20.607–2:24.010
整套啊 llama.cpp 是为了兼容很 多模型和设备嘛
2:24.310–2:27.213
所以不可避免的会有很多妥协还有一些小 bug
2:27.413–2:31.117
但 NInfer 就是这样一个极端优化极 端固定的概念就
2:31.117–2:32.685
一旦这一条路跑通了就
2:32.685–2:35.788
优化到极致之后就连参数它都基本上不变了
2:35.955–2:38.858
那我比喻一下啊我又要来了就是一个比喻
2:39.025–2:41.127
llama.cpp 它就像一辆很优秀的
2:41.127–2:43.196
丰田 S U V 你把它开去哪里
2:43.196–2:46.599
都可以啊全世界都有零件你去哪儿都能维修
2:46.866–2:50.336
雪地沙地山路上都可以啊速度呢也还行
2:50.670–2:52.405
那 vLLM 呢可以说它像一个
2:52.405–2:56.042
地铁系统啊它在乎的不是我一个乘客能跑多快
2:56.209–2:57.977
它在乎的是我每个小时
2:57.977–3:01.281
的总吞吐量可以把多少人给并行的运起来
3:01.447–3:03.383
它最经典的技术呢就是 PagedAttention
3:03.650–3:06.419
把 KV 缓存像虚拟内存一样分页管理啊
3:06.419–3:07.387
减少显存碎片
3:07.520–3:08.221
再配合一个
3:08.354–3:09.589
continuous batching 就是
3:09.589–3:10.523
连续批处理
3:10.557–3:12.125
非常适合高并发的服务
3:12.492–3:13.193
它现在呢也有
3:13.193–3:16.596
prefix caching 啊就是可以 把以前算过的前缀直接复用
3:16.896–3:18.798
然后呢就是 SGLang 这个是特别
3:18.798–3:20.333
强调复杂工作流里面的
3:20.333–3:22.068
缓存复用比如说他会去
3:22.068–3:23.836
考虑哪些货物可以共享
3:23.836–3:25.672
路线啊哪些可以缓存哪
3:25.672–3:28.508
些可以有共同的 prefix 怎么复用这 些状态
3:28.708–3:31.544
所以呢它可能就像一个智能物流中心
3:31.744–3:32.679
它很有代表性的技
3:32.679–3:35.281
术叫做 RadixAttention 粗 略理解一下它
3:35.281–3:38.284
就是把大量的请求的 prefix 组成一 棵树
3:38.551–3:40.987
然后呢重复的 prefix 它就不重复计 算了
3:41.354–3:43.289
所以它对于 agent 的 loop 来 讲有很
3:43.289–3:45.158
多东西都是重复的嘛非常有效
3:45.391–3:47.493
那那最后就是我这回尝试的 NInfer
3:47.627–3:49.262
它呢就是一辆 F1 赛车
3:49.395–3:52.532
你赛道就是这一个赛道发动机就这一台发动机
3:52.699–3:54.334
轮胎我都是这一组轮胎
3:54.434–3:56.135
变速箱悬挂什么的都不变就
3:56.135–3:57.971
就连天气啊我都给它固定住了
3:58.037–4:01.040
所有的都是已知条件然后就往死里去刷圈
4:01.407–4:02.442
这样极端优化的
4:02.442–4:03.576
结果呢就是我这样
4:03.576–4:06.145
一张 4090 24GB 的卡 NInfer 可以
4:06.145–4:09.916
把整个 256K 的模型原生上下文啊全都 塞进去
4:10.049–4:12.585
而且生成速度可以达到平均一百 tokens 每秒
4:12.719–4:14.988
关于速度啊这些测试我后面会再展开讲一下
4:15.388–4:18.591
啊其实千问 3.8 27B 这个模型它本 身也比较特殊啊它
4:18.591–4:20.093
它不是每一层都有巨大
4:20.093–4:22.028
的 KV 缓存它是一个混合架构
4:22.128–4:23.863
所以才能在 24GB 级别的卡上
4:23.896–4:27.533
把 256K 的上下文给开满就放在以前想 都不敢想
4:27.867–4:29.302
但这个缓存呢并不是就
4:29.302–4:34.340
说原始精度而是量化后的 Q4 呃但又不是 普通的 K4V4
4:34.340–4:37.010
而是 RK4V4-E8
4:37.176–4:38.378
那这个参数具体是什么
4:38.378–4:39.579
意思呢我就不展开讲了
4:39.579–4:42.515
讲了你也听不懂啊主要是因为呢我也看不懂
4:42.682–4:44.050
啊反正就是一种比普通
4:44.050–4:45.785
压缩精度要更好一点的
4:45.818–4:49.455
旋转跳跃的压缩方式它前面那个二代表的是 rotate 嘛
4:50.023–4:50.056
啊
4:50.256–4:51.557
所以可以在精度损失很
4:51.557–4:56.062
小的前提下可以比 Q8 或者 FP16 的 KV 缓存能更省显存
4:56.396–4:57.530
就它主要的目的其实不
4:57.530–5:00.366
是提速啊它反而是比 Q8 要慢一点点
5:00.466–5:01.834
它主要是为了用尽可能
5:01.834–5:04.103
小的质量代价把 KV 压的更小
5:04.370–5:07.840
好把完整的 256K 上下文全都塞进 24GB 里面
5:08.074–5:09.142
所以总结来说啊
5:09.275–5:11.077
别的框架是要模型和
5:11.110–5:13.880
硬件向框架妥协以获取兼容
5:14.047–5:17.283
但 NInfer 呢是把自己改成了 千问 3.8 的那个形状
5:17.317–5:21.688
特别是 4090 这个 fork 只为 千问 3.8 27B 一个人服务
5:21.854–5:24.123
这是什么样的硬件榨汁儿行为啊
5:24.324–5:25.491
所以如果你有对应的九
5:25.491–5:27.126
零系列的硬件真的可以去尝试一下
5:27.360–5:31.564
呃我都我想象了一下这个框架用来跑 4090 48GB 哦
5:31.731–5:33.900
那那应该是一种天下无双的体验
5:33.966–5:35.368
果如果有优化好的话啊
5:35.368–5:37.970
他我不知道他有没有单独为了 48GB 版 本优化
5:38.004–5:40.740
哎如果有大佬试过的话可以来评论区炫耀一下
5:41.007–5:42.075
让我长长见识
5:42.108–5:43.643
那 NInfer 整个部署好之后呢我
5:43.643–5:44.811
首先让它去做了一个小
5:44.811–5:47.113
任务去修改我的 A I 本地控制台
5:47.280–5:49.148
让他把自己的 profile 给加进去
5:49.315–5:50.683
我是做了这样一个网站
5:50.683–5:51.784
部署在我自己的服务器
5:51.784–5:53.086
上这样我可以非常简单
5:53.086–5:54.687
的去切换各种服务各种
5:54.687–5:56.723
模型或者就监控大模型的流量
5:57.156–5:58.458
那给我的第一个感受啊
5:58.458–6:01.694
就是它首 token 变慢了就 llama.cpp 里面
6:01.694–6:03.463
大概是五秒钟左右就会
6:03.463–6:06.432
出首 token 它要十二三秒但这
6:06.432–6:07.533
里得说清楚啊我这里拿
6:07.533–6:09.535
的是实际 Agent 跑的时候第一
6:09.535–6:13.005
轮冷请求看到的 TTFT 也就是首 token 延迟
6:13.306–6:14.607
如果我们真的去做那个
6:14.607–6:19.112
benchmark 去测试的话呢其实纯 prefill 的吞吐没有慢那么两倍啊
6:19.145–6:20.947
大概就是落后个两三成左右
6:21.214–6:22.749
那主要是这种冷启动的
6:22.749–6:24.417
情况下一次性灌一大堆
6:24.417–6:26.386
上下文进去的场景它是要慢一点
6:26.452–6:29.522
后续呢就是缓存命中越来越高之后会越用越低
6:29.722–6:32.091
一开始大概十几秒后面就是能达到几秒
6:32.225–6:34.293
然后呢就是速度啊用下来之后
6:34.293–6:37.864
我发现一些小任务能达到 130 tokens/s 左右
6:38.030–6:40.066
就我按照以前的体感啊给他派一个任务
6:40.066–6:41.567
然后我自己切去干别的事情了
6:41.701–6:42.702
结果没过一会儿他跟我
6:42.702–6:44.470
说干好了我就有点不习惯
6:44.570–6:46.372
就跟我以前的那个体感不太一样
6:46.539–6:47.974
然后呢长链开发现在是
6:47.974–6:49.976
稳定在一百多一点 tokens 啊这
6:49.976–6:51.310
也是一个非常不错的成绩
6:51.577–6:52.912
呃因为在上下文稍微长
6:52.912–6:55.448
一点之后呢 llama.cpp 你是即便 开
6:55.481–6:59.752
MTP 它的速度大概其实也就五六十个 tokens 每秒了
6:59.786–7:01.320
好一点的情况也只有七十
7:01.587–7:04.190
所以基本上就是一个一点五倍的速度提升
7:04.357–7:05.491
然后在这个速度之外还
7:05.491–7:06.759
有一点非常牛逼的就是
7:06.759–7:09.595
呢在 NInfer 框架里面把上下文开到 顶
7:09.929–7:11.864
也就是 256K 上下文全都塞进
7:11.864–7:15.802
去的情况下还剩 1.3GB 左右的显存也 就是说啊
7:15.802–7:17.970
我们可以把视觉模型也同时给开起来
7:18.204–7:20.306
llama.cpp 呢在我个人的这台机器
7:20.306–7:23.409
上对最多我是开到 208K 左右的上下文
7:23.409–7:25.178
然后再开一个视觉基本
7:25.178–7:26.512
上就是你看到那根红线
7:26.512–7:29.215
顶着跑了啊跑着跑着就就不太稳定啊
7:29.282–7:30.850
就是命悬一线那种感觉
7:30.950–7:33.152
就每次发一个请求我菊花都紧紧的
7:33.386–7:34.487
生怕它直接爆了
7:34.554–7:36.856
啊但开 NInfer 之后呢我就直接全上 下文
7:36.956–7:38.424
然后视觉模型同时开起来
7:38.624–7:40.126
呃所以总结下来孩子吃
7:40.126–7:41.894
了 NInfer 粉之后呢显存占用更
7:41.894–7:44.797
少了上下文更长了速度更快了这有三个优点
7:44.964–7:48.501
唯一的缺点就是冷 prefill 的速度 要降低百分之二三十
7:48.901–7:51.771
再然后就是关于功耗啊这个非常的重要啊
7:51.771–7:53.639
因为我这台机器 decode 的时候
7:53.940–7:57.243
整机墙上功耗最高是会到五百三四十瓦
7:57.543–7:59.245
但是 prefill 的阶段呢就没有那么 高
7:59.478–8:00.847
特别是当缓存命中的时
8:00.847–8:02.648
候有时候大概是两三百瓦这样
8:02.915–8:04.350
然啊当然这是我说这套
8:04.350–8:07.186
NInfer 再加上 4090 的这个配 置的实测
8:07.353–8:08.654
并不是说所有的或者你
8:08.654–8:10.590
的机器也是这样你自己也可以实测一下
8:10.790–8:14.260
你可以看我这个墙上功耗的实测就是用 llama.cpp 那几天
8:14.360–8:17.263
token 总量这几天用的都是差不多的都 是一个亿左右
8:17.363–8:21.968
llama.cpp 还要再少一点啊但是呢 一天下来墙上功耗 llama.cpp 是
8:22.201–8:23.636
六千瓦到七千瓦之间就
8:23.636–8:26.405
奔着七我感觉它有时候都要破七了
8:26.706–8:28.474
但换成 NInfer 之后呢我这两天
8:28.474–8:30.977
大概就是四点五到五千瓦时之间
8:31.110–8:32.712
所以这个就光电费的区
8:32.712–8:34.046
别按照我现在的电价来
8:34.046–8:36.983
粗算一下年化下来是能省一千块钱
8:37.149–8:38.684
就换了这么个框架而已
8:39.051–8:41.654
啊当然目前这个样本还比较少没有办法确定说
8:41.754–8:44.323
但就我体感而言它的那个发热的量还
8:44.357–8:46.459
还有风扇呼啸的时间都是要更少的
8:46.726–8:48.728
最后啊总结一下我的体
8:48.728–8:52.198
验最开始我用的是 llama.cpp 啊 部署完之后用了一阵子
8:52.265–8:54.533
跟在线 API 比起来就还是
8:54.700–8:56.002
有一点点慢就有一点点
8:56.168–8:58.604
比三点六要好很多了但是就还是
8:58.771–9:00.106
有那么一点点便秘的感觉
9:00.239–9:02.308
但换成 NInfer 之后这个一百 token 每
9:02.308–9:04.410
秒的速度啊这就相当可用了
9:04.610–9:04.977
呀呃因为之
9:04.977–9:06.812
前的 DeepSeek V4 Flash 呃我
9:06.812–9:08.447
用 Open Code Go 的那个 plan
9:08.748–9:11.017
它给到的速度也就是一百到一百五之间
9:11.284–9:12.485
当然你要跟最新的
9:12.485–9:17.390
DeepSeek V4.1 Flash 这种复写式生成的速度那肯定是没法比的
9:17.657–9:19.325
啊但反正啊总之这个优
9:19.325–9:20.760
化下来我个人是非常非
9:20.760–9:22.061
常满意的我现在是直接
9:22.061–9:23.996
把整个生产都切换到了 NInfer 上面
9:24.363–9:25.398
而且用起来非常稳定就
9:25.398–9:28.100
没有触发任何问题也没有觉得质量有下降
9:28.301–9:29.902
反而啊至少在我现在
9:29.902–9:32.738
这套配置里面 NInfer 是比 llama.cpp 更省心的
9:33.105–9:34.473
因为它很多容量或者设
9:34.473–9:35.942
置在启动的时候就已经
9:35.975–9:38.744
固定和校验好了超过预算就直接起不来
9:38.811–9:40.746
而不是跑一半突然给你来个 OOM
9:41.080–9:44.483
这个之前我在 llama.cpp 里面经 历过就是在长 session 里面会
9:44.483–9:46.752
会出现一些显存和 slot 管理上的问题
9:46.852–9:49.822
因为 llama 如果你默认不去设置 KV slot 你
9:49.822–9:52.525
你不把它固定在一的话它现在默认是四
9:52.525–9:54.226
然后用的是 unified KV
9:54.293–9:56.562
这个功能概念上很好我很喜欢
9:56.696–9:58.064
但是那个我目前的配置
9:58.064–10:00.633
好像有点硬件啊可能有点水土不服
10:00.900–10:03.269
啊反正就是上下文越长越不稳定最后会崩掉
10:03.569–10:06.372
那么目前啊本地部署对我个人来说
10:06.372–10:08.808
我觉得还差最后一个问题就是并发
10:09.008–10:10.543
目前呢我个人是不希望
10:10.543–10:12.378
损失上下文去搞并发的啊
10:12.378–10:14.447
因为就 4090 单张卡而言我现
10:14.447–10:17.016
在把上下文开到 256K 个人是
10:17.016–10:19.118
非常舒爽的一个状态特
10:19.118–10:20.720
别是在 agent 搞长链开发的时
10:20.720–10:22.722
候呢有的人会觉得说一
10:22.722–10:24.490
百二十八 k 上下文够用但
10:24.490–10:25.925
我个人啊就是觉得有点
10:25.925–10:27.293
不够我甚至希望再长一点
10:27.727–10:29.095
然后在保持这个上下文
10:29.095–10:32.231
的前提下有办法啊把并发给做起来那是更好
10:32.565–10:33.933
个啊希望有什么框架可
10:33.933–10:35.468
以这个打破一下物理定律
10:35.735–10:38.304
可以让 4090 二十四 G 搞一个啊
10:38.304–10:41.707
四个左右吧我也不贪心四个长上下文并发啊
10:41.774–10:45.011
上下文在 256K 左右生成速度都维持在 一百左右
10:45.344–10:46.178
的哼宛如做梦
10:46.479–10:47.947
啊但也不是不可能的我
10:48.014–10:51.217
不是痴人说梦你看现在软件的优化是真的
10:51.217–10:53.119
翻天覆地前几个月同样
10:53.119–10:54.553
的硬件更弱的模型就
10:54.553–10:56.322
千问 3.6 那个版本嘛我
10:56.322–10:58.157
是开了 MTP 都只有
10:58.157–11:00.693
40–50 tokens/s 那才过了这 么几个月
11:00.960–11:02.728
更强的三点八模型更快
11:02.728–11:05.297
的速度啊原生四五十 MTP 直接破百
11:05.431–11:06.799
搞得我上个星期跑了十
11:06.799–11:09.568
几个小时的矩阵测试啊好不容易定下来的参数
11:09.635–11:10.870
到今天已经没卵用了
11:11.070–11:12.071
了啊但没关系啊毕竟我
11:12.071–11:14.206
自己就是非常喜欢折腾这种事情嘛啊多
11:14.273–11:16.375
多折腾一下也有更多的话题可以跟你们聊
11:16.542–11:18.244
有空欢迎再来听我唠嗑下期再见
0:00.166–0:02.335
OK 今天来讲一下千问 3.8 27B
0:02.335–0:04.771
这个模型我最近发现了一个新框架
0:04.938–0:06.139
这个框架叫 NInfer
0:06.206–0:07.907
在特定的长上下文再加
0:07.907–0:09.743
上 MTP 的场景里面啊官方和
0:09.743–0:12.479
社区的测试速度甚至能达到两倍
0:12.712–0:15.081
那我自己这张 4090 到底能快多少呢
0:15.281–0:16.249
看到最后你就知道了
0:16.416–0:17.117
上上个星期我不是
0:17.117–0:21.154
刚部署好千问 3.8 27B 嘛那时候用 的呢是 llama.cpp
0:21.287–0:22.889
也是为了优化卯足了劲儿
0:22.922–0:24.624
十几个小时的矩阵测试
0:24.724–0:27.260
就是为了得到最好的那一个参数
0:27.360–0:29.396
啊然后终于搞满意了固定下来了
0:29.429–0:30.330
200K 上下文
0:30.497–0:31.664
七八十 tokens 每秒
0:31.765–0:33.400
那 llama.cpp 在这个阶段呢
0:33.400–0:36.202
对于我自己的硬件而言基本上是被优化到顶了
0:36.469–0:38.905
但是呢就在前两天我发现全白测了
0:39.005–0:41.808
就是在研究 VLLM 或者 SGLang 这些框架的时候呢
0:41.808–0:43.510
我发现了一个叫做 NInfer 的东西
0:43.576–0:44.944
看大家的评价是非常的
0:44.944–0:48.581
疯狂什么直接暴涨两倍的速度四舍九入那将像
0:48.581–0:49.349
四舍九入
0:49.682–0:52.585
四舍五入那就相当于多给了我一张 4090 啊
0:52.819–0:54.454
嗯这还不赶紧部署起来试试
0:54.721–0:57.557
于是呢我就让 GPT-5.6 Sol 写 了一个详细的方案
0:57.590–0:59.859
一整套啊包括部署包括测试的方案
1:00.126–1:03.129
然后把整个 plan 丢给我服务器上的 DeepSeek V4 Flash 去干
1:03.329–1:05.498
V4 Flash 一个人是吭哧吭哧干了
1:05.498–1:07.267
五个小时包括配置包括
1:07.267–1:09.769
对 NInfer 的各种参数进行矩阵测试
1:09.836–1:11.538
之后再和 llama.cpp 进行矩阵对 比
1:11.604–1:12.305
我就出了个门
1:12.405–1:13.873
然后回来他就直接给我
1:13.873–1:16.509
交付了一份能用的最佳配置和整个对比
1:16.509–1:17.177
结果的报告
1:17.310–1:18.711
这感觉太爽了就
1:18.711–1:20.113
要知道就在四五个月前
1:20.113–1:23.850
这种事情都是不可能的那时候我是逮着 GPT 对线
1:23.850–1:25.485
手搓配置 vLLM
1:25.518–1:27.220
整整搓了好几天才跑起来
1:27.353–1:30.523
来啊那给不了解的小伙伴先解释一下所谓的 NInfer 其
1:30.523–1:32.926
其实就是类似于 llama.cpp 或者 vLLM
1:32.926–1:35.595
这种框架但它和那些都不一样啊它
1:35.595–1:38.731
不是那些的派生而是一个从零写的推理引擎
1:38.865–1:40.300
它特殊的地方就在于其
1:40.300–1:42.001
他的框架是要需要考虑
1:42.001–1:43.736
不同的模型不同的硬件
1:43.736–1:46.339
怎么兼容而 NInfer 特别的地方就在 于
1:46.439–1:49.976
它把模型和硬件这一条路径给固定死了
1:50.176–1:53.146
原版主要盯的就是 RTX 5090 这个 显卡
1:53.313–1:55.682
模型呢主要就是千问 3.8 这个家族
1:55.815–1:58.818
后面有大神把它移植到了 3090 上面后 来呢又有人
1:58.852–2:03.523
根据 3090 做了 4090 的优化那 我这次用的就是这个 4090 fork
2:03.590–2:04.591
所以基本上就是把
2:04.624–2:09.162
千问 3.8 27B 这一个模型和 RTX 4090 这一张显卡
2:09.195–2:11.231
这两个固定下来往死里优化
2:11.331–2:12.999
它不需要像 llama.cpp 那样去
2:12.999–2:13.266
考虑
2:13.333–2:15.101
他拿到一个 GGUF 之后要去看
2:15.101–2:17.003
一下它的架构是什么再解析
2:17.003–2:18.705
然后再根据设备去选
2:18.705–2:20.607
一个后端再去运行这一
2:20.607–2:24.010
整套啊 llama.cpp 是为了兼容很 多模型和设备嘛
2:24.310–2:27.213
所以不可避免的会有很多妥协还有一些小 bug
2:27.413–2:31.117
但 NInfer 就是这样一个极端优化极 端固定的概念就
2:31.117–2:32.685
一旦这一条路跑通了就
2:32.685–2:35.788
优化到极致之后就连参数它都基本上不变了
2:35.955–2:38.858
那我比喻一下啊我又要来了就是一个比喻
2:39.025–2:41.127
llama.cpp 它就像一辆很优秀的
2:41.127–2:43.196
丰田 S U V 你把它开去哪里
2:43.196–2:46.599
都可以啊全世界都有零件你去哪儿都能维修
2:46.866–2:50.336
雪地沙地山路上都可以啊速度呢也还行
2:50.670–2:52.405
那 vLLM 呢可以说它像一个
2:52.405–2:56.042
地铁系统啊它在乎的不是我一个乘客能跑多快
2:56.209–2:57.977
它在乎的是我每个小时
2:57.977–3:01.281
的总吞吐量可以把多少人给并行的运起来
3:01.447–3:03.383
它最经典的技术呢就是 PagedAttention
3:03.650–3:06.419
把 KV 缓存像虚拟内存一样分页管理啊
3:06.419–3:07.387
减少显存碎片
3:07.520–3:08.221
再配合一个
3:08.354–3:09.589
continuous batching 就是
3:09.589–3:10.523
连续批处理
3:10.557–3:12.125
非常适合高并发的服务
3:12.492–3:13.193
它现在呢也有
3:13.193–3:16.596
prefix caching 啊就是可以 把以前算过的前缀直接复用
3:16.896–3:18.798
然后呢就是 SGLang 这个是特别
3:18.798–3:20.333
强调复杂工作流里面的
3:20.333–3:22.068
缓存复用比如说他会去
3:22.068–3:23.836
考虑哪些货物可以共享
3:23.836–3:25.672
路线啊哪些可以缓存哪
3:25.672–3:28.508
些可以有共同的 prefix 怎么复用这 些状态
3:28.708–3:31.544
所以呢它可能就像一个智能物流中心
3:31.744–3:32.679
它很有代表性的技
3:32.679–3:35.281
术叫做 RadixAttention 粗 略理解一下它
3:35.281–3:38.284
就是把大量的请求的 prefix 组成一 棵树
3:38.551–3:40.987
然后呢重复的 prefix 它就不重复计 算了
3:41.354–3:43.289
所以它对于 agent 的 loop 来 讲有很
3:43.289–3:45.158
多东西都是重复的嘛非常有效
3:45.391–3:47.493
那那最后就是我这回尝试的 NInfer
3:47.627–3:49.262
它呢就是一辆 F1 赛车
3:49.395–3:52.532
你赛道就是这一个赛道发动机就这一台发动机
3:52.699–3:54.334
轮胎我都是这一组轮胎
3:54.434–3:56.135
变速箱悬挂什么的都不变就
3:56.135–3:57.971
就连天气啊我都给它固定住了
3:58.037–4:01.040
所有的都是已知条件然后就往死里去刷圈
4:01.407–4:02.442
这样极端优化的
4:02.442–4:03.576
结果呢就是我这样
4:03.576–4:06.145
一张 4090 24GB 的卡 NInfer 可以
4:06.145–4:09.916
把整个 256K 的模型原生上下文啊全都 塞进去
4:10.049–4:12.585
而且生成速度可以达到平均一百 tokens 每秒
4:12.719–4:14.988
关于速度啊这些测试我后面会再展开讲一下
4:15.388–4:18.591
啊其实千问 3.8 27B 这个模型它本 身也比较特殊啊它
4:18.591–4:20.093
它不是每一层都有巨大
4:20.093–4:22.028
的 KV 缓存它是一个混合架构
4:22.128–4:23.863
所以才能在 24GB 级别的卡上
4:23.896–4:27.533
把 256K 的上下文给开满就放在以前想 都不敢想
4:27.867–4:29.302
但这个缓存呢并不是就
4:29.302–4:34.340
说原始精度而是量化后的 Q4 呃但又不是 普通的 K4V4
4:34.340–4:37.010
而是 RK4V4-E8
4:37.176–4:38.378
那这个参数具体是什么
4:38.378–4:39.579
意思呢我就不展开讲了
4:39.579–4:42.515
讲了你也听不懂啊主要是因为呢我也看不懂
4:42.682–4:44.050
啊反正就是一种比普通
4:44.050–4:45.785
压缩精度要更好一点的
4:45.818–4:49.455
旋转跳跃的压缩方式它前面那个二代表的是 rotate 嘛
4:50.023–4:50.056
啊
4:50.256–4:51.557
所以可以在精度损失很
4:51.557–4:56.062
小的前提下可以比 Q8 或者 FP16 的 KV 缓存能更省显存
4:56.396–4:57.530
就它主要的目的其实不
4:57.530–5:00.366
是提速啊它反而是比 Q8 要慢一点点
5:00.466–5:01.834
它主要是为了用尽可能
5:01.834–5:04.103
小的质量代价把 KV 压的更小
5:04.370–5:07.840
好把完整的 256K 上下文全都塞进 24GB 里面
5:08.074–5:09.142
所以总结来说啊
5:09.275–5:11.077
别的框架是要模型和
5:11.110–5:13.880
硬件向框架妥协以获取兼容
5:14.047–5:17.283
但 NInfer 呢是把自己改成了 千问 3.8 的那个形状
5:17.317–5:21.688
特别是 4090 这个 fork 只为 千问 3.8 27B 一个人服务
5:21.854–5:24.123
这是什么样的硬件榨汁儿行为啊
5:24.324–5:25.491
所以如果你有对应的九
5:25.491–5:27.126
零系列的硬件真的可以去尝试一下
5:27.360–5:31.564
呃我都我想象了一下这个框架用来跑 4090 48GB 哦
5:31.731–5:33.900
那那应该是一种天下无双的体验
5:33.966–5:35.368
果如果有优化好的话啊
5:35.368–5:37.970
他我不知道他有没有单独为了 48GB 版 本优化
5:38.004–5:40.740
哎如果有大佬试过的话可以来评论区炫耀一下
5:41.007–5:42.075
让我长长见识
5:42.108–5:43.643
那 NInfer 整个部署好之后呢我
5:43.643–5:44.811
首先让它去做了一个小
5:44.811–5:47.113
任务去修改我的 A I 本地控制台
5:47.280–5:49.148
让他把自己的 profile 给加进去
5:49.315–5:50.683
我是做了这样一个网站
5:50.683–5:51.784
部署在我自己的服务器
5:51.784–5:53.086
上这样我可以非常简单
5:53.086–5:54.687
的去切换各种服务各种
5:54.687–5:56.723
模型或者就监控大模型的流量
5:57.156–5:58.458
那给我的第一个感受啊
5:58.458–6:01.694
就是它首 token 变慢了就 llama.cpp 里面
6:01.694–6:03.463
大概是五秒钟左右就会
6:03.463–6:06.432
出首 token 它要十二三秒但这
6:06.432–6:07.533
里得说清楚啊我这里拿
6:07.533–6:09.535
的是实际 Agent 跑的时候第一
6:09.535–6:13.005
轮冷请求看到的 TTFT 也就是首 token 延迟
6:13.306–6:14.607
如果我们真的去做那个
6:14.607–6:19.112
benchmark 去测试的话呢其实纯 prefill 的吞吐没有慢那么两倍啊
6:19.145–6:20.947
大概就是落后个两三成左右
6:21.214–6:22.749
那主要是这种冷启动的
6:22.749–6:24.417
情况下一次性灌一大堆
6:24.417–6:26.386
上下文进去的场景它是要慢一点
6:26.452–6:29.522
后续呢就是缓存命中越来越高之后会越用越低
6:29.722–6:32.091
一开始大概十几秒后面就是能达到几秒
6:32.225–6:34.293
然后呢就是速度啊用下来之后
6:34.293–6:37.864
我发现一些小任务能达到 130 tokens/s 左右
6:38.030–6:40.066
就我按照以前的体感啊给他派一个任务
6:40.066–6:41.567
然后我自己切去干别的事情了
6:41.701–6:42.702
结果没过一会儿他跟我
6:42.702–6:44.470
说干好了我就有点不习惯
6:44.570–6:46.372
就跟我以前的那个体感不太一样
6:46.539–6:47.974
然后呢长链开发现在是
6:47.974–6:49.976
稳定在一百多一点 tokens 啊这
6:49.976–6:51.310
也是一个非常不错的成绩
6:51.577–6:52.912
呃因为在上下文稍微长
6:52.912–6:55.448
一点之后呢 llama.cpp 你是即便 开
6:55.481–6:59.752
MTP 它的速度大概其实也就五六十个 tokens 每秒了
6:59.786–7:01.320
好一点的情况也只有七十
7:01.587–7:04.190
所以基本上就是一个一点五倍的速度提升
7:04.357–7:05.491
然后在这个速度之外还
7:05.491–7:06.759
有一点非常牛逼的就是
7:06.759–7:09.595
呢在 NInfer 框架里面把上下文开到 顶
7:09.929–7:11.864
也就是 256K 上下文全都塞进
7:11.864–7:15.802
去的情况下还剩 1.3GB 左右的显存也 就是说啊
7:15.802–7:17.970
我们可以把视觉模型也同时给开起来
7:18.204–7:20.306
llama.cpp 呢在我个人的这台机器
7:20.306–7:23.409
上对最多我是开到 208K 左右的上下文
7:23.409–7:25.178
然后再开一个视觉基本
7:25.178–7:26.512
上就是你看到那根红线
7:26.512–7:29.215
顶着跑了啊跑着跑着就就不太稳定啊
7:29.282–7:30.850
就是命悬一线那种感觉
7:30.950–7:33.152
就每次发一个请求我菊花都紧紧的
7:33.386–7:34.487
生怕它直接爆了
7:34.554–7:36.856
啊但开 NInfer 之后呢我就直接全上 下文
7:36.956–7:38.424
然后视觉模型同时开起来
7:38.624–7:40.126
呃所以总结下来孩子吃
7:40.126–7:41.894
了 NInfer 粉之后呢显存占用更
7:41.894–7:44.797
少了上下文更长了速度更快了这有三个优点
7:44.964–7:48.501
唯一的缺点就是冷 prefill 的速度 要降低百分之二三十
7:48.901–7:51.771
再然后就是关于功耗啊这个非常的重要啊
7:51.771–7:53.639
因为我这台机器 decode 的时候
7:53.940–7:57.243
整机墙上功耗最高是会到五百三四十瓦
7:57.543–7:59.245
但是 prefill 的阶段呢就没有那么 高
7:59.478–8:00.847
特别是当缓存命中的时
8:00.847–8:02.648
候有时候大概是两三百瓦这样
8:02.915–8:04.350
然啊当然这是我说这套
8:04.350–8:07.186
NInfer 再加上 4090 的这个配 置的实测
8:07.353–8:08.654
并不是说所有的或者你
8:08.654–8:10.590
的机器也是这样你自己也可以实测一下
8:10.790–8:14.260
你可以看我这个墙上功耗的实测就是用 llama.cpp 那几天
8:14.360–8:17.263
token 总量这几天用的都是差不多的都 是一个亿左右
8:17.363–8:21.968
llama.cpp 还要再少一点啊但是呢 一天下来墙上功耗 llama.cpp 是
8:22.201–8:23.636
六千瓦到七千瓦之间就
8:23.636–8:26.405
奔着七我感觉它有时候都要破七了
8:26.706–8:28.474
但换成 NInfer 之后呢我这两天
8:28.474–8:30.977
大概就是四点五到五千瓦时之间
8:31.110–8:32.712
所以这个就光电费的区
8:32.712–8:34.046
别按照我现在的电价来
8:34.046–8:36.983
粗算一下年化下来是能省一千块钱
8:37.149–8:38.684
就换了这么个框架而已
8:39.051–8:41.654
啊当然目前这个样本还比较少没有办法确定说
8:41.754–8:44.323
但就我体感而言它的那个发热的量还
8:44.357–8:46.459
还有风扇呼啸的时间都是要更少的
8:46.726–8:48.728
最后啊总结一下我的体
8:48.728–8:52.198
验最开始我用的是 llama.cpp 啊 部署完之后用了一阵子
8:52.265–8:54.533
跟在线 API 比起来就还是
8:54.700–8:56.002
有一点点慢就有一点点
8:56.168–8:58.604
比三点六要好很多了但是就还是
8:58.771–9:00.106
有那么一点点便秘的感觉
9:00.239–9:02.308
但换成 NInfer 之后这个一百 token 每
9:02.308–9:04.410
秒的速度啊这就相当可用了
9:04.610–9:04.977
呀呃因为之
9:04.977–9:06.812
前的 DeepSeek V4 Flash 呃我
9:06.812–9:08.447
用 Open Code Go 的那个 plan
9:08.748–9:11.017
它给到的速度也就是一百到一百五之间
9:11.284–9:12.485
当然你要跟最新的
9:12.485–9:17.390
DeepSeek V4.1 Flash 这种复写式生成的速度那肯定是没法比的
9:17.657–9:19.325
啊但反正啊总之这个优
9:19.325–9:20.760
化下来我个人是非常非
9:20.760–9:22.061
常满意的我现在是直接
9:22.061–9:23.996
把整个生产都切换到了 NInfer 上面
9:24.363–9:25.398
而且用起来非常稳定就
9:25.398–9:28.100
没有触发任何问题也没有觉得质量有下降
9:28.301–9:29.902
反而啊至少在我现在
9:29.902–9:32.738
这套配置里面 NInfer 是比 llama.cpp 更省心的
9:33.105–9:34.473
因为它很多容量或者设
9:34.473–9:35.942
置在启动的时候就已经
9:35.975–9:38.744
固定和校验好了超过预算就直接起不来
9:38.811–9:40.746
而不是跑一半突然给你来个 OOM
9:41.080–9:44.483
这个之前我在 llama.cpp 里面经 历过就是在长 session 里面会
9:44.483–9:46.752
会出现一些显存和 slot 管理上的问题
9:46.852–9:49.822
因为 llama 如果你默认不去设置 KV slot 你
9:49.822–9:52.525
你不把它固定在一的话它现在默认是四
9:52.525–9:54.226
然后用的是 unified KV
9:54.293–9:56.562
这个功能概念上很好我很喜欢
9:56.696–9:58.064
但是那个我目前的配置
9:58.064–10:00.633
好像有点硬件啊可能有点水土不服
10:00.900–10:03.269
啊反正就是上下文越长越不稳定最后会崩掉
10:03.569–10:06.372
那么目前啊本地部署对我个人来说
10:06.372–10:08.808
我觉得还差最后一个问题就是并发
10:09.008–10:10.543
目前呢我个人是不希望
10:10.543–10:12.378
损失上下文去搞并发的啊
10:12.378–10:14.447
因为就 4090 单张卡而言我现
10:14.447–10:17.016
在把上下文开到 256K 个人是
10:17.016–10:19.118
非常舒爽的一个状态特
10:19.118–10:20.720
别是在 agent 搞长链开发的时
10:20.720–10:22.722
候呢有的人会觉得说一
10:22.722–10:24.490
百二十八 k 上下文够用但
10:24.490–10:25.925
我个人啊就是觉得有点
10:25.925–10:27.293
不够我甚至希望再长一点
10:27.727–10:29.095
然后在保持这个上下文
10:29.095–10:32.231
的前提下有办法啊把并发给做起来那是更好
10:32.565–10:33.933
个啊希望有什么框架可
10:33.933–10:35.468
以这个打破一下物理定律
10:35.735–10:38.304
可以让 4090 二十四 G 搞一个啊
10:38.304–10:41.707
四个左右吧我也不贪心四个长上下文并发啊
10:41.774–10:45.011
上下文在 256K 左右生成速度都维持在 一百左右
10:45.344–10:46.178
的哼宛如做梦
10:46.479–10:47.947
啊但也不是不可能的我
10:48.014–10:51.217
不是痴人说梦你看现在软件的优化是真的
10:51.217–10:53.119
翻天覆地前几个月同样
10:53.119–10:54.553
的硬件更弱的模型就
10:54.553–10:56.322
千问 3.6 那个版本嘛我
10:56.322–10:58.157
是开了 MTP 都只有
10:58.157–11:00.693
40–50 tokens/s 那才过了这 么几个月
11:00.960–11:02.728
更强的三点八模型更快
11:02.728–11:05.297
的速度啊原生四五十 MTP 直接破百
11:05.431–11:06.799
搞得我上个星期跑了十
11:06.799–11:09.568
几个小时的矩阵测试啊好不容易定下来的参数
11:09.635–11:10.870
到今天已经没卵用了
11:11.070–11:12.071
了啊但没关系啊毕竟我
11:12.071–11:14.206
自己就是非常喜欢折腾这种事情嘛啊多
11:14.273–11:16.375
多折腾一下也有更多的话题可以跟你们聊
11:16.542–11:18.244
有空欢迎再来听我唠嗑下期再见
0:00.166–0:02.335
OK 今天来讲一下千问 3.8 27B
OK 今天来讲一下千问 3.8 27B
0:02.335–0:04.771
这个模型我最近发现了一个新框架
这个模型我最近发现了一个新框架
0:04.938–0:06.139
这个框架叫 NInfer
这个框架叫 NInfer
0:06.206–0:07.907
在特定的长上下文再加
在特定的长上下文再加
0:07.907–0:09.743
上 MTP 的场景里面啊官方和
上 MTP 的场景里面啊官方和
0:09.743–0:12.479
社区的测试速度甚至能达到两倍
社区的测试速度甚至能达到两倍
0:12.712–0:15.081
那我自己这张 4090 到底能快多少呢
那我自己这张 4090 到底能快多少呢
0:15.281–0:16.249
看到最后你就知道了
看到最后你就知道了
0:16.416–0:17.117
上上个星期我不是
上上个星期我不是
0:17.117–0:21.154
刚部署好千问 3.8 27B 嘛那时候用 的呢是 llama.cpp
刚部署好千问 3.8 27B 嘛那时候用 的呢是 llama.cpp
0:21.287–0:22.889
也是为了优化卯足了劲儿
也是为了优化卯足了劲儿
0:22.922–0:24.624
十几个小时的矩阵测试
十几个小时的矩阵测试
0:24.724–0:27.260
就是为了得到最好的那一个参数
就是为了得到最好的那一个参数
0:27.360–0:29.396
啊然后终于搞满意了固定下来了
啊然后终于搞满意了固定下来了
0:29.429–0:30.330
200K 上下文
200K 上下文
0:30.497–0:31.664
七八十 tokens 每秒
七八十 tokens 每秒
0:31.765–0:33.400
那 llama.cpp 在这个阶段呢
那 llama.cpp 在这个阶段呢
0:33.400–0:36.202
对于我自己的硬件而言基本上是被优化到顶了
对于我自己的硬件而言基本上是被优化到顶了
0:36.469–0:38.905
但是呢就在前两天我发现全白测了
但是呢就在前两天我发现全白测了
0:39.005–0:41.808
就是在研究 VLLM 或者 SGLang 这些框架的时候呢
就是在研究 VLLM 或者 SGLang 这些框架的时候呢
0:41.808–0:43.510
我发现了一个叫做 NInfer 的东西
我发现了一个叫做 NInfer 的东西
0:43.576–0:44.944
看大家的评价是非常的
看大家的评价是非常的
0:44.944–0:48.581
疯狂什么直接暴涨两倍的速度四舍九入那将像
疯狂什么直接暴涨两倍的速度四舍九入那将像
0:48.581–0:49.349
四舍九入
四舍九入
0:49.682–0:52.585
四舍五入那就相当于多给了我一张 4090 啊
四舍五入那就相当于多给了我一张 4090 啊
0:52.819–0:54.454
嗯这还不赶紧部署起来试试
嗯这还不赶紧部署起来试试
0:54.721–0:57.557
于是呢我就让 GPT-5.6 Sol 写 了一个详细的方案
于是呢我就让 GPT-5.6 Sol 写 了一个详细的方案
0:57.590–0:59.859
一整套啊包括部署包括测试的方案
一整套啊包括部署包括测试的方案
1:00.126–1:03.129
然后把整个 plan 丢给我服务器上的 DeepSeek V4 Flash 去干
然后把整个 plan 丢给我服务器上的 DeepSeek V4 Flash 去干
1:03.329–1:05.498
V4 Flash 一个人是吭哧吭哧干了
V4 Flash 一个人是吭哧吭哧干了
1:05.498–1:07.267
五个小时包括配置包括
五个小时包括配置包括
1:07.267–1:09.769
对 NInfer 的各种参数进行矩阵测试
对 NInfer 的各种参数进行矩阵测试
1:09.836–1:11.538
之后再和 llama.cpp 进行矩阵对 比
之后再和 llama.cpp 进行矩阵对 比
1:11.604–1:12.305
我就出了个门
我就出了个门
1:12.405–1:13.873
然后回来他就直接给我
然后回来他就直接给我
1:13.873–1:16.509
交付了一份能用的最佳配置和整个对比
交付了一份能用的最佳配置和整个对比
1:16.509–1:17.177
结果的报告
结果的报告
1:17.310–1:18.711
这感觉太爽了就
这感觉太爽了就
1:18.711–1:20.113
要知道就在四五个月前
要知道就在四五个月前
1:20.113–1:23.850
这种事情都是不可能的那时候我是逮着 GPT 对线
这种事情都是不可能的那时候我是逮着 GPT 对线
1:23.850–1:25.485
手搓配置 vLLM
手搓配置 vLLM
1:25.518–1:27.220
整整搓了好几天才跑起来
整整搓了好几天才跑起来
1:27.353–1:30.523
来啊那给不了解的小伙伴先解释一下所谓的 NInfer 其
来啊那给不了解的小伙伴先解释一下所谓的 NInfer 其
1:30.523–1:32.926
其实就是类似于 llama.cpp 或者 vLLM
其实就是类似于 llama.cpp 或者 vLLM
1:32.926–1:35.595
这种框架但它和那些都不一样啊它
这种框架但它和那些都不一样啊它
1:35.595–1:38.731
不是那些的派生而是一个从零写的推理引擎
不是那些的派生而是一个从零写的推理引擎
1:38.865–1:40.300
它特殊的地方就在于其
它特殊的地方就在于其
1:40.300–1:42.001
他的框架是要需要考虑
他的框架是要需要考虑
1:42.001–1:43.736
不同的模型不同的硬件
不同的模型不同的硬件
1:43.736–1:46.339
怎么兼容而 NInfer 特别的地方就在 于
怎么兼容而 NInfer 特别的地方就在 于
1:46.439–1:49.976
它把模型和硬件这一条路径给固定死了
它把模型和硬件这一条路径给固定死了
1:50.176–1:53.146
原版主要盯的就是 RTX 5090 这个 显卡
原版主要盯的就是 RTX 5090 这个 显卡
1:53.313–1:55.682
模型呢主要就是千问 3.8 这个家族
模型呢主要就是千问 3.8 这个家族
1:55.815–1:58.818
后面有大神把它移植到了 3090 上面后 来呢又有人
后面有大神把它移植到了 3090 上面后 来呢又有人
1:58.852–2:03.523
根据 3090 做了 4090 的优化那 我这次用的就是这个 4090 fork
根据 3090 做了 4090 的优化那 我这次用的就是这个 4090 fork
2:03.590–2:04.591
所以基本上就是把
所以基本上就是把
2:04.624–2:09.162
千问 3.8 27B 这一个模型和 RTX 4090 这一张显卡
千问 3.8 27B 这一个模型和 RTX 4090 这一张显卡
2:09.195–2:11.231
这两个固定下来往死里优化
这两个固定下来往死里优化
2:11.331–2:12.999
它不需要像 llama.cpp 那样去
它不需要像 llama.cpp 那样去
2:12.999–2:13.266
考虑
考虑
2:13.333–2:15.101
他拿到一个 GGUF 之后要去看
他拿到一个 GGUF 之后要去看
2:15.101–2:17.003
一下它的架构是什么再解析
一下它的架构是什么再解析
2:17.003–2:18.705
然后再根据设备去选
然后再根据设备去选
2:18.705–2:20.607
一个后端再去运行这一
一个后端再去运行这一
2:20.607–2:24.010
整套啊 llama.cpp 是为了兼容很 多模型和设备嘛
整套啊 llama.cpp 是为了兼容很 多模型和设备嘛
2:24.310–2:27.213
所以不可避免的会有很多妥协还有一些小 bug
所以不可避免的会有很多妥协还有一些小 bug
2:27.413–2:31.117
但 NInfer 就是这样一个极端优化极 端固定的概念就
但 NInfer 就是这样一个极端优化极 端固定的概念就
2:31.117–2:32.685
一旦这一条路跑通了就
一旦这一条路跑通了就
2:32.685–2:35.788
优化到极致之后就连参数它都基本上不变了
优化到极致之后就连参数它都基本上不变了
2:35.955–2:38.858
那我比喻一下啊我又要来了就是一个比喻
那我比喻一下啊我又要来了就是一个比喻
2:39.025–2:41.127
llama.cpp 它就像一辆很优秀的
llama.cpp 它就像一辆很优秀的
2:41.127–2:43.196
丰田 S U V 你把它开去哪里
丰田 S U V 你把它开去哪里
2:43.196–2:46.599
都可以啊全世界都有零件你去哪儿都能维修
都可以啊全世界都有零件你去哪儿都能维修
2:46.866–2:50.336
雪地沙地山路上都可以啊速度呢也还行
雪地沙地山路上都可以啊速度呢也还行
2:50.670–2:52.405
那 vLLM 呢可以说它像一个
那 vLLM 呢可以说它像一个
2:52.405–2:56.042
地铁系统啊它在乎的不是我一个乘客能跑多快
地铁系统啊它在乎的不是我一个乘客能跑多快
2:56.209–2:57.977
它在乎的是我每个小时
它在乎的是我每个小时
2:57.977–3:01.281
的总吞吐量可以把多少人给并行的运起来
的总吞吐量可以把多少人给并行的运起来
3:01.447–3:03.383
它最经典的技术呢就是 PagedAttention
它最经典的技术呢就是 PagedAttention
3:03.650–3:06.419
把 KV 缓存像虚拟内存一样分页管理啊
把 KV 缓存像虚拟内存一样分页管理啊
3:06.419–3:07.387
减少显存碎片
减少显存碎片
3:07.520–3:08.221
再配合一个
再配合一个
3:08.354–3:09.589
continuous batching 就是
continuous batching 就是
3:09.589–3:10.523
连续批处理
连续批处理
3:10.557–3:12.125
非常适合高并发的服务
非常适合高并发的服务
3:12.492–3:13.193
它现在呢也有
它现在呢也有
3:13.193–3:16.596
prefix caching 啊就是可以 把以前算过的前缀直接复用
prefix caching 啊就是可以 把以前算过的前缀直接复用
3:16.896–3:18.798
然后呢就是 SGLang 这个是特别
然后呢就是 SGLang 这个是特别
3:18.798–3:20.333
强调复杂工作流里面的
强调复杂工作流里面的
3:20.333–3:22.068
缓存复用比如说他会去
缓存复用比如说他会去
3:22.068–3:23.836
考虑哪些货物可以共享
考虑哪些货物可以共享
3:23.836–3:25.672
路线啊哪些可以缓存哪
路线啊哪些可以缓存哪
3:25.672–3:28.508
些可以有共同的 prefix 怎么复用这 些状态
些可以有共同的 prefix 怎么复用这 些状态
3:28.708–3:31.544
所以呢它可能就像一个智能物流中心
所以呢它可能就像一个智能物流中心
3:31.744–3:32.679
它很有代表性的技
它很有代表性的技
3:32.679–3:35.281
术叫做 RadixAttention 粗 略理解一下它
术叫做 RadixAttention 粗 略理解一下它
3:35.281–3:38.284
就是把大量的请求的 prefix 组成一 棵树
就是把大量的请求的 prefix 组成一 棵树
3:38.551–3:40.987
然后呢重复的 prefix 它就不重复计 算了
然后呢重复的 prefix 它就不重复计 算了
3:41.354–3:43.289
所以它对于 agent 的 loop 来 讲有很
所以它对于 agent 的 loop 来 讲有很
3:43.289–3:45.158
多东西都是重复的嘛非常有效
多东西都是重复的嘛非常有效
3:45.391–3:47.493
那那最后就是我这回尝试的 NInfer
那那最后就是我这回尝试的 NInfer
3:47.627–3:49.262
它呢就是一辆 F1 赛车
它呢就是一辆 F1 赛车
3:49.395–3:52.532
你赛道就是这一个赛道发动机就这一台发动机
你赛道就是这一个赛道发动机就这一台发动机
3:52.699–3:54.334
轮胎我都是这一组轮胎
轮胎我都是这一组轮胎
3:54.434–3:56.135
变速箱悬挂什么的都不变就
变速箱悬挂什么的都不变就
3:56.135–3:57.971
就连天气啊我都给它固定住了
就连天气啊我都给它固定住了
3:58.037–4:01.040
所有的都是已知条件然后就往死里去刷圈
所有的都是已知条件然后就往死里去刷圈
4:01.407–4:02.442
这样极端优化的
这样极端优化的
4:02.442–4:03.576
结果呢就是我这样
结果呢就是我这样
4:03.576–4:06.145
一张 4090 24GB 的卡 NInfer 可以
一张 4090 24GB 的卡 NInfer 可以
4:06.145–4:09.916
把整个 256K 的模型原生上下文啊全都 塞进去
把整个 256K 的模型原生上下文啊全都 塞进去
4:10.049–4:12.585
而且生成速度可以达到平均一百 tokens 每秒
而且生成速度可以达到平均一百 tokens 每秒
4:12.719–4:14.988
关于速度啊这些测试我后面会再展开讲一下
关于速度啊这些测试我后面会再展开讲一下
4:15.388–4:18.591
啊其实千问 3.8 27B 这个模型它本 身也比较特殊啊它
啊其实千问 3.8 27B 这个模型它本 身也比较特殊啊它
4:18.591–4:20.093
它不是每一层都有巨大
它不是每一层都有巨大
4:20.093–4:22.028
的 KV 缓存它是一个混合架构
的 KV 缓存它是一个混合架构
4:22.128–4:23.863
所以才能在 24GB 级别的卡上
所以才能在 24GB 级别的卡上
4:23.896–4:27.533
把 256K 的上下文给开满就放在以前想 都不敢想
把 256K 的上下文给开满就放在以前想 都不敢想
4:27.867–4:29.302
但这个缓存呢并不是就
但这个缓存呢并不是就
4:29.302–4:34.340
说原始精度而是量化后的 Q4 呃但又不是 普通的 K4V4
说原始精度而是量化后的 Q4 呃但又不是 普通的 K4V4
4:34.340–4:37.010
而是 RK4V4-E8
而是 RK4V4-E8
4:37.176–4:38.378
那这个参数具体是什么
那这个参数具体是什么
4:38.378–4:39.579
意思呢我就不展开讲了
意思呢我就不展开讲了
4:39.579–4:42.515
讲了你也听不懂啊主要是因为呢我也看不懂
讲了你也听不懂啊主要是因为呢我也看不懂
4:42.682–4:44.050
啊反正就是一种比普通
啊反正就是一种比普通
4:44.050–4:45.785
压缩精度要更好一点的
压缩精度要更好一点的
4:45.818–4:49.455
旋转跳跃的压缩方式它前面那个二代表的是 rotate 嘛
旋转跳跃的压缩方式它前面那个二代表的是 rotate 嘛
4:50.023–4:50.056
啊
啊
4:50.256–4:51.557
所以可以在精度损失很
所以可以在精度损失很
4:51.557–4:56.062
小的前提下可以比 Q8 或者 FP16 的 KV 缓存能更省显存
小的前提下可以比 Q8 或者 FP16 的 KV 缓存能更省显存
4:56.396–4:57.530
就它主要的目的其实不
就它主要的目的其实不
4:57.530–5:00.366
是提速啊它反而是比 Q8 要慢一点点
是提速啊它反而是比 Q8 要慢一点点
5:00.466–5:01.834
它主要是为了用尽可能
它主要是为了用尽可能
5:01.834–5:04.103
小的质量代价把 KV 压的更小
小的质量代价把 KV 压的更小
5:04.370–5:07.840
好把完整的 256K 上下文全都塞进 24GB 里面
好把完整的 256K 上下文全都塞进 24GB 里面
5:08.074–5:09.142
所以总结来说啊
所以总结来说啊
5:09.275–5:11.077
别的框架是要模型和
别的框架是要模型和
5:11.110–5:13.880
硬件向框架妥协以获取兼容
硬件向框架妥协以获取兼容
5:14.047–5:17.283
但 NInfer 呢是把自己改成了 千问 3.8 的那个形状
但 NInfer 呢是把自己改成了 千问 3.8 的那个形状
5:17.317–5:21.688
特别是 4090 这个 fork 只为 千问 3.8 27B 一个人服务
特别是 4090 这个 fork 只为 千问 3.8 27B 一个人服务
5:21.854–5:24.123
这是什么样的硬件榨汁儿行为啊
这是什么样的硬件榨汁儿行为啊
5:24.324–5:25.491
所以如果你有对应的九
所以如果你有对应的九
5:25.491–5:27.126
零系列的硬件真的可以去尝试一下
零系列的硬件真的可以去尝试一下
5:27.360–5:31.564
呃我都我想象了一下这个框架用来跑 4090 48GB 哦
呃我都我想象了一下这个框架用来跑 4090 48GB 哦
5:31.731–5:33.900
那那应该是一种天下无双的体验
那那应该是一种天下无双的体验
5:33.966–5:35.368
果如果有优化好的话啊
果如果有优化好的话啊
5:35.368–5:37.970
他我不知道他有没有单独为了 48GB 版 本优化
他我不知道他有没有单独为了 48GB 版 本优化
5:38.004–5:40.740
哎如果有大佬试过的话可以来评论区炫耀一下
哎如果有大佬试过的话可以来评论区炫耀一下
5:41.007–5:42.075
让我长长见识
让我长长见识
5:42.108–5:43.643
那 NInfer 整个部署好之后呢我
那 NInfer 整个部署好之后呢我
5:43.643–5:44.811
首先让它去做了一个小
首先让它去做了一个小
5:44.811–5:47.113
任务去修改我的 A I 本地控制台
任务去修改我的 A I 本地控制台
5:47.280–5:49.148
让他把自己的 profile 给加进去
让他把自己的 profile 给加进去
5:49.315–5:50.683
我是做了这样一个网站
我是做了这样一个网站
5:50.683–5:51.784
部署在我自己的服务器
部署在我自己的服务器
5:51.784–5:53.086
上这样我可以非常简单
上这样我可以非常简单
5:53.086–5:54.687
的去切换各种服务各种
的去切换各种服务各种
5:54.687–5:56.723
模型或者就监控大模型的流量
模型或者就监控大模型的流量
5:57.156–5:58.458
那给我的第一个感受啊
那给我的第一个感受啊
5:58.458–6:01.694
就是它首 token 变慢了就 llama.cpp 里面
就是它首 token 变慢了就 llama.cpp 里面
6:01.694–6:03.463
大概是五秒钟左右就会
大概是五秒钟左右就会
6:03.463–6:06.432
出首 token 它要十二三秒但这
出首 token 它要十二三秒但这
6:06.432–6:07.533
里得说清楚啊我这里拿
里得说清楚啊我这里拿
6:07.533–6:09.535
的是实际 Agent 跑的时候第一
的是实际 Agent 跑的时候第一
6:09.535–6:13.005
轮冷请求看到的 TTFT 也就是首 token 延迟
轮冷请求看到的 TTFT 也就是首 token 延迟
6:13.306–6:14.607
如果我们真的去做那个
如果我们真的去做那个
6:14.607–6:19.112
benchmark 去测试的话呢其实纯 prefill 的吞吐没有慢那么两倍啊
benchmark 去测试的话呢其实纯 prefill 的吞吐没有慢那么两倍啊
6:19.145–6:20.947
大概就是落后个两三成左右
大概就是落后个两三成左右
6:21.214–6:22.749
那主要是这种冷启动的
那主要是这种冷启动的
6:22.749–6:24.417
情况下一次性灌一大堆
情况下一次性灌一大堆
6:24.417–6:26.386
上下文进去的场景它是要慢一点
上下文进去的场景它是要慢一点
6:26.452–6:29.522
后续呢就是缓存命中越来越高之后会越用越低
后续呢就是缓存命中越来越高之后会越用越低
6:29.722–6:32.091
一开始大概十几秒后面就是能达到几秒
一开始大概十几秒后面就是能达到几秒
6:32.225–6:34.293
然后呢就是速度啊用下来之后
然后呢就是速度啊用下来之后
6:34.293–6:37.864
我发现一些小任务能达到 130 tokens/s 左右
我发现一些小任务能达到 130 tokens/s 左右
6:38.030–6:40.066
就我按照以前的体感啊给他派一个任务
就我按照以前的体感啊给他派一个任务
6:40.066–6:41.567
然后我自己切去干别的事情了
然后我自己切去干别的事情了
6:41.701–6:42.702
结果没过一会儿他跟我
结果没过一会儿他跟我
6:42.702–6:44.470
说干好了我就有点不习惯
说干好了我就有点不习惯
6:44.570–6:46.372
就跟我以前的那个体感不太一样
就跟我以前的那个体感不太一样
6:46.539–6:47.974
然后呢长链开发现在是
然后呢长链开发现在是
6:47.974–6:49.976
稳定在一百多一点 tokens 啊这
稳定在一百多一点 tokens 啊这
6:49.976–6:51.310
也是一个非常不错的成绩
也是一个非常不错的成绩
6:51.577–6:52.912
呃因为在上下文稍微长
呃因为在上下文稍微长
6:52.912–6:55.448
一点之后呢 llama.cpp 你是即便 开
一点之后呢 llama.cpp 你是即便 开
6:55.481–6:59.752
MTP 它的速度大概其实也就五六十个 tokens 每秒了
MTP 它的速度大概其实也就五六十个 tokens 每秒了
6:59.786–7:01.320
好一点的情况也只有七十
好一点的情况也只有七十
7:01.587–7:04.190
所以基本上就是一个一点五倍的速度提升
所以基本上就是一个一点五倍的速度提升
7:04.357–7:05.491
然后在这个速度之外还
然后在这个速度之外还
7:05.491–7:06.759
有一点非常牛逼的就是
有一点非常牛逼的就是
7:06.759–7:09.595
呢在 NInfer 框架里面把上下文开到 顶
呢在 NInfer 框架里面把上下文开到 顶
7:09.929–7:11.864
也就是 256K 上下文全都塞进
也就是 256K 上下文全都塞进
7:11.864–7:15.802
去的情况下还剩 1.3GB 左右的显存也 就是说啊
去的情况下还剩 1.3GB 左右的显存也 就是说啊
7:15.802–7:17.970
我们可以把视觉模型也同时给开起来
我们可以把视觉模型也同时给开起来
7:18.204–7:20.306
llama.cpp 呢在我个人的这台机器
llama.cpp 呢在我个人的这台机器
7:20.306–7:23.409
上对最多我是开到 208K 左右的上下文
上对最多我是开到 208K 左右的上下文
7:23.409–7:25.178
然后再开一个视觉基本
然后再开一个视觉基本
7:25.178–7:26.512
上就是你看到那根红线
上就是你看到那根红线
7:26.512–7:29.215
顶着跑了啊跑着跑着就就不太稳定啊
顶着跑了啊跑着跑着就就不太稳定啊
7:29.282–7:30.850
就是命悬一线那种感觉
就是命悬一线那种感觉
7:30.950–7:33.152
就每次发一个请求我菊花都紧紧的
就每次发一个请求我菊花都紧紧的
7:33.386–7:34.487
生怕它直接爆了
生怕它直接爆了
7:34.554–7:36.856
啊但开 NInfer 之后呢我就直接全上 下文
啊但开 NInfer 之后呢我就直接全上 下文
7:36.956–7:38.424
然后视觉模型同时开起来
然后视觉模型同时开起来
7:38.624–7:40.126
呃所以总结下来孩子吃
呃所以总结下来孩子吃
7:40.126–7:41.894
了 NInfer 粉之后呢显存占用更
了 NInfer 粉之后呢显存占用更
7:41.894–7:44.797
少了上下文更长了速度更快了这有三个优点
少了上下文更长了速度更快了这有三个优点
7:44.964–7:48.501
唯一的缺点就是冷 prefill 的速度 要降低百分之二三十
唯一的缺点就是冷 prefill 的速度 要降低百分之二三十
7:48.901–7:51.771
再然后就是关于功耗啊这个非常的重要啊
再然后就是关于功耗啊这个非常的重要啊
7:51.771–7:53.639
因为我这台机器 decode 的时候
因为我这台机器 decode 的时候
7:53.940–7:57.243
整机墙上功耗最高是会到五百三四十瓦
整机墙上功耗最高是会到五百三四十瓦
7:57.543–7:59.245
但是 prefill 的阶段呢就没有那么 高
但是 prefill 的阶段呢就没有那么 高
7:59.478–8:00.847
特别是当缓存命中的时
特别是当缓存命中的时
8:00.847–8:02.648
候有时候大概是两三百瓦这样
候有时候大概是两三百瓦这样
8:02.915–8:04.350
然啊当然这是我说这套
然啊当然这是我说这套
8:04.350–8:07.186
NInfer 再加上 4090 的这个配 置的实测
NInfer 再加上 4090 的这个配 置的实测
8:07.353–8:08.654
并不是说所有的或者你
并不是说所有的或者你
8:08.654–8:10.590
的机器也是这样你自己也可以实测一下
的机器也是这样你自己也可以实测一下
8:10.790–8:14.260
你可以看我这个墙上功耗的实测就是用 llama.cpp 那几天
你可以看我这个墙上功耗的实测就是用 llama.cpp 那几天
8:14.360–8:17.263
token 总量这几天用的都是差不多的都 是一个亿左右
token 总量这几天用的都是差不多的都 是一个亿左右
8:17.363–8:21.968
llama.cpp 还要再少一点啊但是呢 一天下来墙上功耗 llama.cpp 是
llama.cpp 还要再少一点啊但是呢 一天下来墙上功耗 llama.cpp 是
8:22.201–8:23.636
六千瓦到七千瓦之间就
六千瓦到七千瓦之间就
8:23.636–8:26.405
奔着七我感觉它有时候都要破七了
奔着七我感觉它有时候都要破七了
8:26.706–8:28.474
但换成 NInfer 之后呢我这两天
但换成 NInfer 之后呢我这两天
8:28.474–8:30.977
大概就是四点五到五千瓦时之间
大概就是四点五到五千瓦时之间
8:31.110–8:32.712
所以这个就光电费的区
所以这个就光电费的区
8:32.712–8:34.046
别按照我现在的电价来
别按照我现在的电价来
8:34.046–8:36.983
粗算一下年化下来是能省一千块钱
粗算一下年化下来是能省一千块钱
8:37.149–8:38.684
就换了这么个框架而已
就换了这么个框架而已
8:39.051–8:41.654
啊当然目前这个样本还比较少没有办法确定说
啊当然目前这个样本还比较少没有办法确定说
8:41.754–8:44.323
但就我体感而言它的那个发热的量还
但就我体感而言它的那个发热的量还
8:44.357–8:46.459
还有风扇呼啸的时间都是要更少的
还有风扇呼啸的时间都是要更少的
8:46.726–8:48.728
最后啊总结一下我的体
最后啊总结一下我的体
8:48.728–8:52.198
验最开始我用的是 llama.cpp 啊 部署完之后用了一阵子
验最开始我用的是 llama.cpp 啊 部署完之后用了一阵子
8:52.265–8:54.533
跟在线 API 比起来就还是
跟在线 API 比起来就还是
8:54.700–8:56.002
有一点点慢就有一点点
有一点点慢就有一点点
8:56.168–8:58.604
比三点六要好很多了但是就还是
比三点六要好很多了但是就还是
8:58.771–9:00.106
有那么一点点便秘的感觉
有那么一点点便秘的感觉
9:00.239–9:02.308
但换成 NInfer 之后这个一百 token 每
但换成 NInfer 之后这个一百 token 每
9:02.308–9:04.410
秒的速度啊这就相当可用了
秒的速度啊这就相当可用了
9:04.610–9:04.977
呀呃因为之
呀呃因为之
9:04.977–9:06.812
前的 DeepSeek V4 Flash 呃我
前的 DeepSeek V4 Flash 呃我
9:06.812–9:08.447
用 Open Code Go 的那个 plan
用 Open Code Go 的那个 plan
9:08.748–9:11.017
它给到的速度也就是一百到一百五之间
它给到的速度也就是一百到一百五之间
9:11.284–9:12.485
当然你要跟最新的
当然你要跟最新的
9:12.485–9:17.390
DeepSeek V4.1 Flash 这种复写式生成的速度那肯定是没法比的
DeepSeek V4.1 Flash 这种复写式生成的速度那肯定是没法比的
9:17.657–9:19.325
啊但反正啊总之这个优
啊但反正啊总之这个优
9:19.325–9:20.760
化下来我个人是非常非
化下来我个人是非常非
9:20.760–9:22.061
常满意的我现在是直接
常满意的我现在是直接
9:22.061–9:23.996
把整个生产都切换到了 NInfer 上面
把整个生产都切换到了 NInfer 上面
9:24.363–9:25.398
而且用起来非常稳定就
而且用起来非常稳定就
9:25.398–9:28.100
没有触发任何问题也没有觉得质量有下降
没有触发任何问题也没有觉得质量有下降
9:28.301–9:29.902
反而啊至少在我现在
反而啊至少在我现在
9:29.902–9:32.738
这套配置里面 NInfer 是比 llama.cpp 更省心的
这套配置里面 NInfer 是比 llama.cpp 更省心的
9:33.105–9:34.473
因为它很多容量或者设
因为它很多容量或者设
9:34.473–9:35.942
置在启动的时候就已经
置在启动的时候就已经
9:35.975–9:38.744
固定和校验好了超过预算就直接起不来
固定和校验好了超过预算就直接起不来
9:38.811–9:40.746
而不是跑一半突然给你来个 OOM
而不是跑一半突然给你来个 OOM
9:41.080–9:44.483
这个之前我在 llama.cpp 里面经 历过就是在长 session 里面会
这个之前我在 llama.cpp 里面经 历过就是在长 session 里面会
9:44.483–9:46.752
会出现一些显存和 slot 管理上的问题
会出现一些显存和 slot 管理上的问题
9:46.852–9:49.822
因为 llama 如果你默认不去设置 KV slot 你
因为 llama 如果你默认不去设置 KV slot 你
9:49.822–9:52.525
你不把它固定在一的话它现在默认是四
你不把它固定在一的话它现在默认是四
9:52.525–9:54.226
然后用的是 unified KV
然后用的是 unified KV
9:54.293–9:56.562
这个功能概念上很好我很喜欢
这个功能概念上很好我很喜欢
9:56.696–9:58.064
但是那个我目前的配置
但是那个我目前的配置
9:58.064–10:00.633
好像有点硬件啊可能有点水土不服
好像有点硬件啊可能有点水土不服
10:00.900–10:03.269
啊反正就是上下文越长越不稳定最后会崩掉
啊反正就是上下文越长越不稳定最后会崩掉
10:03.569–10:06.372
那么目前啊本地部署对我个人来说
那么目前啊本地部署对我个人来说
10:06.372–10:08.808
我觉得还差最后一个问题就是并发
我觉得还差最后一个问题就是并发
10:09.008–10:10.543
目前呢我个人是不希望
目前呢我个人是不希望
10:10.543–10:12.378
损失上下文去搞并发的啊
损失上下文去搞并发的啊
10:12.378–10:14.447
因为就 4090 单张卡而言我现
因为就 4090 单张卡而言我现
10:14.447–10:17.016
在把上下文开到 256K 个人是
在把上下文开到 256K 个人是
10:17.016–10:19.118
非常舒爽的一个状态特
非常舒爽的一个状态特
10:19.118–10:20.720
别是在 agent 搞长链开发的时
别是在 agent 搞长链开发的时
10:20.720–10:22.722
候呢有的人会觉得说一
候呢有的人会觉得说一
10:22.722–10:24.490
百二十八 k 上下文够用但
百二十八 k 上下文够用但
10:24.490–10:25.925
我个人啊就是觉得有点
我个人啊就是觉得有点
10:25.925–10:27.293
不够我甚至希望再长一点
不够我甚至希望再长一点
10:27.727–10:29.095
然后在保持这个上下文
然后在保持这个上下文
10:29.095–10:32.231
的前提下有办法啊把并发给做起来那是更好
的前提下有办法啊把并发给做起来那是更好
10:32.565–10:33.933
个啊希望有什么框架可
个啊希望有什么框架可
10:33.933–10:35.468
以这个打破一下物理定律
以这个打破一下物理定律
10:35.735–10:38.304
可以让 4090 二十四 G 搞一个啊
可以让 4090 二十四 G 搞一个啊
10:38.304–10:41.707
四个左右吧我也不贪心四个长上下文并发啊
四个左右吧我也不贪心四个长上下文并发啊
10:41.774–10:45.011
上下文在 256K 左右生成速度都维持在 一百左右
上下文在 256K 左右生成速度都维持在 一百左右
10:45.344–10:46.178
的哼宛如做梦
的哼宛如做梦
10:46.479–10:47.947
啊但也不是不可能的我
啊但也不是不可能的我
10:48.014–10:51.217
不是痴人说梦你看现在软件的优化是真的
不是痴人说梦你看现在软件的优化是真的
10:51.217–10:53.119
翻天覆地前几个月同样
翻天覆地前几个月同样
10:53.119–10:54.553
的硬件更弱的模型就
的硬件更弱的模型就
10:54.553–10:56.322
千问 3.6 那个版本嘛我
千问 3.6 那个版本嘛我
10:56.322–10:58.157
是开了 MTP 都只有
是开了 MTP 都只有
10:58.157–11:00.693
40–50 tokens/s 那才过了这 么几个月
40–50 tokens/s 那才过了这 么几个月
11:00.960–11:02.728
更强的三点八模型更快
更强的三点八模型更快
11:02.728–11:05.297
的速度啊原生四五十 MTP 直接破百
的速度啊原生四五十 MTP 直接破百
11:05.431–11:06.799
搞得我上个星期跑了十
搞得我上个星期跑了十
11:06.799–11:09.568
几个小时的矩阵测试啊好不容易定下来的参数
几个小时的矩阵测试啊好不容易定下来的参数
11:09.635–11:10.870
到今天已经没卵用了
到今天已经没卵用了
11:11.070–11:12.071
了啊但没关系啊毕竟我
了啊但没关系啊毕竟我
11:12.071–11:14.206
自己就是非常喜欢折腾这种事情嘛啊多
自己就是非常喜欢折腾这种事情嘛啊多
11:14.273–11:16.375
多折腾一下也有更多的话题可以跟你们聊
多折腾一下也有更多的话题可以跟你们聊
11:16.542–11:18.244
有空欢迎再来听我唠嗑下期再见
有空欢迎再来听我唠嗑下期再见

影片筆記:NInfer + 千问3.8 27b = 1.5倍速@256K上下文(单张4090 24GB)

<!-- VIDEONOTE_PUBLICATION_WARNINGS_BEGIN -->

⚠️ 可先使用,仍有待修正項目

本筆記已完成可閱讀的逐字稿與時間跳轉;下列為待處理問題,建議播放原片確認。

  • 待修正:逐字稿全文快速校讀未完成(已保留自動字幕/原始逐字稿並繼續生成筆記。;未完成的全文速讀項目可在精進模式回聽確認。)

<!-- VIDEONOTE_PUBLICATION_WARNINGS_END -->

一句話總結

講者實測在單張 RTX 4090 (24GB) 顯存上,使用針對千問 3.8 27B 與 NVIDIA 硬體極端優化的 NInfer 框架,成功在 256K 長上下文下實現約 100-130 tokens/s 的生成速度,相比原有使用的 llama.cpp 提升約 1.5 倍,並解決了顯存溢出與穩定性問題,但代價是較高的冷啟動延遲。

核心重點

  1. 性能大幅提升:NInfer 在 256K 上下文場景下,生成速度達 100-130 tokens/s,相較於 llama.cpp 的 50-70 tokens/s,速度提升約 1.5 倍。
  2. 顯存效率與併發能力:NInfer 能在 24GB 顯存內完整容納 256K 原生上下文,並剩餘約 1.3GB 顯存,允許同時運行視覺模型;而 llama.cpp 在 208K 上下文加視覺模型時極易發生 OOM(顯存溢出)。
  3. 極端優化策略:NInfer 並非通用兼容框架,而是從零撰寫的推理引擎,針對特定模型(千問 3.8 家族)與硬體(RTX 4090/3090/5090)進行固定路徑的極致優化,比喻為「F1 賽車」。
  4. 冷啟動延遲較高:NInfer 的首 Token 延遲(TTFT)約需 12-13 秒(因一次性灌入大量上下文),顯著慢於 llama.cpp 的約 5 秒,但隨緩存命中後速度會提升。
  5. 功耗與穩定性優勢:NInfer 日均功耗較低(4.5-5 kWh vs llama.cpp 6-7 kWh),且運行更穩定,避免了 llama.cpp 在長會話中因 KV Slot 管理導致的崩潰問題。

詳細大綱

一、 背景與動機

  • 講者先前使用 llama.cpp 部署 千問 3.8 27B,經過十幾個小時的參數矩陣測試,固定了 200K 上下文,速度約 70-80 tokens/s。
  • 發現 NInfer 框架,社區評價稱速度可翻倍,決定進行測試。
  • 使用 GPT-5.6 Sol 撰寫部署與測試方案,並交由伺服器上的 DeepSeek V4 Flash 執行配置與對比測試,僅花 5 小時即完成最佳配置報告。

二、 NInfer 框架特性解析

  • 核心概念:
  • 非 llama.cpp 或 vLLM 的派生,而是從零撰寫的推理引擎。
  • 極端固定與優化:不追求通用兼容,而是將「模型」與「硬體」路徑固定死。
  • 原版針對 RTX 5090 與千問 3.8 家族;講者使用的是移植至 3090 後再針對 4090 優化的 fork 版本。
  • 比喻說明:
  • llama.cpp:像 Toyota SUV,兼容性好,哪裡都能修,速度尚可,但需妥協。
  • vLLM:像地鐵系統,重視吞吐量(Throughput),使用 PagedAttention 管理 KV 緩存,支援 Continuous Batching。
  • SGLang:像智能物流中心,強調複雜工作流中的緩存複用,使用 RadixAttention 將請求前綴組成樹狀結構以減少重複計算。
  • NInfer:像 F1 賽車,針對單一賽道、單一引擎、單一輪胎進行極致優化,所有條件已知,只為刷圈速。

三、 技術細節:千問 3.8 27B 與顯存管理

  • 混合架構:千問 3.8 27B 並非每一層都有巨大 KV 緩存,採用混合架構,使得在 24GB 顯存上運行 256K 上下文成為可能。
  • 量化技術:
  • 使用 RK4V4-E8 量化方式(非普通 Q4/V4)。
  • 目的非提速,而是以最小質量代價壓縮 KV 緩存,使其比 Q8 或 FP16 更省顯存。
  • 速度可能比 Q8 稍慢,但能將完整 256K 上下文塞入 24GB 顯存。

四、 實測對比結果 (NInfer vs. llama.cpp)

  • 速度表現:
  • NInfer:短任務約 130 tokens/s,長鏈開發穩定在 100+ tokens/s。
  • llama.cpp:即使開啟 MTP,速度約 50-60 tokens/s,好情況 70 tokens/s。
  • 結論:NInfer 速度提升約 1.5 倍。
  • 首 Token 延遲 (TTFT):
  • NInfer:冷請求首 Token 約 12-13 秒(因一次性灌入大量上下文)。
  • llama.cpp:約 5 秒。
  • 註解:純 prefill 吞吐量差異約 20-30%,主要差異在冷啟動場景;隨緩存命中,NInfer 速度會降至幾秒級別。
  • 顯存與併發能力:
  • NInfer:256K 上下文下剩餘 1.3GB 顯存,可同時開啟視覺模型。
  • llama.cpp:208K 上下文加視覺模型時,顯存處於臨界點,易崩潰。
  • 功耗與成本:
  • llama.cpp:日均功耗 6-7 kWh,峰值 530-540W。
  • NInfer:日均功耗 4.5-5 kWh,峰值較低,發熱與風扇噪音較少。
  • 估算:按當前電價,年化可節省約 1000 元。
  • 穩定性:
  • llama.cpp:預設使用 Unified KV 功能,在長會話中易出現顯存與 Slot 管理問題,導致崩潰。
  • NInfer:啟動時已固定參數,超預算直接無法啟動,運行中更穩定,無 OOM 問題。

五、 總結與展望

  • 體驗轉變:從 llama.cpp 的「便秘感」轉變為 NInfer 的「可用且穩定」,速度達 100 tokens/s 已足夠日常 Agent 開發使用。
  • 未來願景:講者希望未來能有框架打破物理定律,在 4090 24GB 顯存上實現 256K 上下文與 4 路併發,且維持 100 tokens/s 速度。
  • 技術迭代感慨:軟體優化進步神速,前幾個月千問 3.6 開 MTP 僅 40-50 tokens/s,如今千問 3.8 原生支援 MTP 即可破百,舊參數測試已失效。

工具 / 模型 / 名詞整理

  • 模型:
  • 千問 3.8 27B (Qwen 3.8 27B)
  • 千問 3.6 (Qwen 3.6)
  • DeepSeek V4 Flash
  • DeepSeek V4.1 Flash
  • 框架/軟體:
  • NInfer
  • llama.cpp
  • vLLM
  • SGLang
  • Open Code Go (提及用於生成 plan 的工具)
  • 硬體/組件:
  • RTX 4090 (24GB)
  • RTX 3090
  • RTX 5090
  • 4090 48GB (提及的硬體版本)
  • 技術/術語:
  • MTP (Multi-Token Prediction)
  • PagedAttention
  • Continuous Batching
  • Prefix Caching
  • RadixAttention
  • KV Cache / KV Slot
  • Unified KV
  • GGUF
  • TTFT (Time To First Token)
  • Prefill / Decode
  • OOM (Out Of Memory)
  • Q4 / Q8 / FP16
  • RK4V4-E8 (量化參數)
  • 256K / 200K / 128K (上下文長度)
  • tokens/s (每秒令牌數)

操作流程整理

  1. 前期準備與測試方案制定:
  • 講者使用 GPT-5.6 Sol 撰寫部署與測試方案。
  • 將方案交由伺服器上的 DeepSeek V4 Flash 執行配置與對比測試。
  • 僅花 5 小時即完成最佳配置報告。
  1. 環境部署與參數設定:
  • 使用移植至 3090 後再針對 4090 優化的 NInfer fork 版本。
  • 設定 千問 3.8 27B 模型,採用 RK4V4-E8 量化方式以壓縮 KV 緩存。
  • 設定上下文長度為 256K。
  1. 實測執行與對比:
  • 執行冷啟動測試,記錄首 Token 延遲(TTFT)。
  • 執行長鏈開發測試,記錄生成速度(tokens/s)。
  • 監控顯存使用情況,確認是否發生 OOM。
  • 監控日均功耗與峰值功耗。
  1. 結果分析與優化:
  • 對比 NInfer 與 llama.cpp 的速度、顯存、功耗與穩定性。
  • 確認 NInfer 在剩餘 1.3GB 顯存下可同時開啟視覺模型。
  • 評估穩定性,確認無 OOM 問題。

值得注意的限制或風險

  1. 冷啟動延遲高:NInfer 的首 Token 延遲(TTFT)約需 12-13 秒,顯著慢於 llama.cpp 的約 5 秒,這是由於一次性灌入大量上下文所致。
  2. 非通用框架:NInfer 針對特定模型與硬體進行極端優化,不追求通用兼容,可能無法直接應用於其他模型或硬體組合。
  3. 量化速度影響:使用 RK4V4-E8 量化方式可能使速度比 Q8 稍慢,但能將完整 256K 上下文塞入 24GB 顯存。
  4. 參數固定限制:NInfer 啟動時已固定參數,若超預算直接無法啟動,缺乏動態調整的靈活性。

逐字稿辨識疑點

  • 千問 3.8 27B:逐字稿中多次提及「千問 3.8」,通常千問系列版本號為 1.5, 2, 2.5 等,「3.8」可能為口誤或特定內部版本,需查證是否為「千問 2.5」或「千問 3」之誤聽,或確實存在該版本。
  • GPT-5.6 Sol:模型名稱「GPT-5.6」與「Sol」組合非常規,可能為聽寫錯誤,實際可能指代某特定模型版本或工具名稱,需查證。
  • RK4V4-E8:此量化參數格式非常見標準命名,可能為講者口述的特定內部參數或聽寫錯誤,需查證是否為某種特定量化格式(如 Q4_K_M 等)的誤讀。
  • Open Code Go:提及使用此工具生成 plan,需查證是否為正確的工具名稱,或為「Open Code」與「Go」語言或其他工具的混雜。
  • 四舍九入:講者口誤說「四舍九入」,後修正為「四舍五入」,筆記中已記錄為口誤。
  • 菊花都紧紧的:俚語,指緊繃狀態,非技術術語。

可延伸追問

  1. NInfer 框架的開源情況如何?是否提供詳細的文檔與使用指南?
  2. RK4V4-E8 量化方式的具體實現原理是什麼?如何平衡質量與顯存佔用?
  3. 對於其他非千問系列的模型,NInfer 是否支持移植與優化?
  4. 在實際生產環境中,NInfer 的長期穩定性表現如何?是否有已知的 Bug 或限制?
  5. 如何進一步優化 NInfer 的冷啟動延遲,以改善用戶體驗?

尚未產生學習筆記

請在 Telegram 指令最後加上「學習」,例如:videonote 網址 英文 雙語 學習