實際影片長度:12:02.000。原文、繁中、雙語可點擊句子跳轉影片。
0:00.000–0:00.640
enHello,
0:00.640–0:01.140
zh大家好,
0:01.140–0:01.920
zh我是Tommy。
0:01.920–0:03.840
zh今天很高興跟大家分享最新的前置內容。
0:04.100–0:07.196
zh那上一次我們講過Deepseek V4.1 Flash,
0:07.196–0:09.220
zh怎麼降低KP Cache的存儲開銷。
0:09.220–0:13.320
zh那麼這一次我們繼續看它怎麼減少脫離計算和緩存成本。
0:13.560–0:19.460
zh那核心呢就兩件事。第一個就是重新計算上下文的時候呢,只計算前一半的層。
0:19.460–0:22.520
zh那麼後面一半是直接附用已有的結果。
0:22.780–0:28.920
zh那第二個呢就是一部分短期緩存不再長期保存,而是在需要時重新計算。
0:28.920–0:29.880
zh那最终呢
0:29.880–0:31.660
zh计算量降低约一半
0:31.660–0:34.020
zh持久化缓存降到原来的1%
0:34.020–0:36.300
zh同时性能基本不受影响
0:36.300–0:37.200
zh那么这里呢
0:37.200–0:38.860
zh最关键的是两个问题
0:38.860–0:39.860
zh那第一个就是
0:39.860–0:42.640
zh为什么只计算一半的层就够了
0:42.640–0:43.580
zh第二个呢
0:43.580–0:45.000
zh为什么重新计算
0:45.000–0:47.800
zh反而比把缓存一直存下来更划算
0:47.800–0:50.520
zh那下面我们就直接来看它的具体设计
0:50.520–0:52.720
zh上一集那个编码agent
0:52.720–0:54.240
zh修一个仓库里的bug
0:54.240–0:55.200
zh跑了三个小时
0:55.200–0:56.920
zh上下文堆到50万token
0:56.920–0:59.200
zh上一集算的是它要存多少
0:59.200–1:01.580
zh40层只存4份KV
1:01.580–1:03.220
zh每个Token890字节
1:03.220–1:05.320
zh这一集算的是它要读多少
1:05.320–1:06.980
zh上一集结尾留了一句
1:06.980–1:08.860
zh4份里解码器那一份
1:08.860–1:11.000
zh还是从编码器投影来的
1:11.000–1:12.860
zh这意味着读入新内容时
1:12.860–1:14.300
zh只用跑前20层
1:14.300–1:15.520
zh后20层不用算
1:15.520–1:17.100
zh这一招叫CED
1:17.100–1:19.200
zh全称因果编码器解码器
1:19.200–1:20.600
zh这一集就讲它
1:20.600–1:23.020
zh它把40层分成前后两半
1:23.020–1:24.620
zh前20层叫编码器
1:24.620–1:26.060
zh负责读上下文
1:26.060–1:28.860
zh后20层叫解码器负责生成
1:28.860–1:30.640
zh解码器要用的KV
1:30.640–1:32.760
zh从编码器的输出投影出来
1:32.760–1:34.000
zh所以读入的时候
1:34.000–1:35.340
zh后20层可以不跑
1:35.340–1:36.660
zh为什么能这么干
1:36.660–1:37.760
zh代价是什么
1:37.760–1:39.220
zh就是这一集的内容
1:39.220–1:41.540
zh先看读入这一步为什么贵
1:41.540–1:43.360
zhAgent每掉一次工具
1:43.360–1:46.060
zh工具的返回都要接到上下文后面
1:46.060–1:47.840
zh模型再把新内容读一遍
1:47.840–1:49.820
zh也就是上一集说过的prefill
1:49.820–1:51.420
zh有缓存的时候
1:51.420–1:53.040
zh只读新增的那一段
1:53.040–1:54.700
zh缓存一旦没命中
1:54.700–1:56.520
zh整段50万都要重算
1:56.520–1:58.880
zh一次任务几十次工具调用
1:58.880–2:00.240
zh就是几十次读入
2:00.240–2:01.100
zh读一次
2:01.100–2:02.880
zh40层每一层都要算
2:02.880–2:04.080
zh上下文越长
2:04.080–2:05.260
zh这比算力越大
2:05.260–2:07.020
zh这还只是算力
2:07.020–2:09.440
zh50万token的KV还得留着
2:09.440–2:10.280
zh等下一轮
2:10.280–2:12.360
zh甚至等第二天用户回来接着聊
2:12.360–2:14.760
zh所以它要从显存落到硬盘上
2:14.760–2:16.260
zhV4的线上部署里
2:16.260–2:19.180
zh这份缓存要在硬盘上留72小时以上
2:19.180–2:21.060
zh显存装不装的下
2:21.060–2:22.500
zh硬盘存不存的起
2:22.500–2:23.920
zh机器之间搬不搬的动
2:23.920–2:25.360
zh三处都是压力
2:25.360–2:27.600
zh算力和硬盘两笔成本
2:27.600–2:28.540
zh问题来了
2:28.540–2:29.520
zh独入这一步
2:29.520–2:31.840
zhV4.1凭什么算力砍一半
2:31.840–2:32.920
zh硬盘砍到1%
2:32.920–2:34.120
zh先说算力
2:34.120–2:36.120
zh2024年有篇论文叫Yoko
2:36.120–2:37.880
zh意思是你只缓存一次
2:37.880–2:40.200
zh它把模型前后两半分开
2:40.200–2:42.400
zh后半层不再各自算KV
2:42.400–2:44.640
zh直接用前半层算好的那一份
2:44.640–2:46.440
zh后半层在独入阶段
2:46.440–2:47.640
zh就可以整个跳过
2:47.640–2:50.320
zh代价是后半层共用同一份KV
2:50.320–2:52.140
zh每一层没法有自己的一份
2:52.140–2:53.840
zh能存的信息就少了
2:53.920–2:56.360
zhCD顺着这个思路改了两处
2:56.360–2:58.380
zh解码器要用的全局KV
2:58.380–3:00.660
zh拿编码器第20层的输出
3:00.660–3:02.400
zh乘一个投影矩阵得到
3:02.400–3:03.440
zh第一处改动
3:03.440–3:05.380
zh投影矩阵可以逐层不同
3:05.380–3:07.260
zh每层能有自己的一份KV
3:07.260–3:09.340
zh容量比YOKO共用一份大
3:09.340–3:10.240
zh第二处
3:10.240–3:12.100
zh滑动窗口那条局部分支
3:12.100–3:12.700
zh不投影
3:12.700–3:14.140
zh每一层还是自己算
3:14.140–3:16.320
zh局部信息的计算深度保住了
3:16.320–3:17.800
zh在V4.1里
3:17.800–3:19.400
zh配合上一集讲的共用
3:19.400–3:22.040
zh真正做投影的是解码器那一个负层
3:22.040–3:23.320
zh其余层沿用它
3:23.320–3:25.820
zh独入阶段编码器20层算完
3:25.820–3:28.520
zh解码器要的全局KV顺手投影出来
3:28.520–3:30.240
zh后20层根本不用跑
3:30.240–3:32.340
zh算力从40层变20层
3:32.340–3:34.920
zh激活参数从160亿降到80亿
3:34.920–3:37.160
zh生成阶段才用满160亿
3:37.160–3:38.580
zh这里有个缺口要补
3:38.580–3:40.980
zh滑动窗口KV每一层自己算
3:40.980–3:43.180
zh可独入阶段解码器根本没跑
3:43.180–3:46.300
zh解码器20层的滑动窗口KV就是空的
3:46.300–3:47.800
zh生成第一个Token时
3:47.800–3:51.200
zh解码器要用到前面128个Token的窗口KV
3:51.200–3:52.360
zh手里却是空的
3:52.360–3:53.820
zh想精确补上
3:53.820–3:54.800
zh就得让解码器
3:54.800–3:57.340
zh把前面那些token重新算一遍
3:57.340–3:57.840
zh算多少
3:57.840–3:59.820
zh窗口是一层套一层的
3:59.820–4:01.760
zh解码器第一层的一个位置
4:01.760–4:03.620
zh只看它前面128个
4:03.620–4:05.240
zh第二层的同一个位置
4:05.240–4:07.900
zh看的是第一层算出的那128个
4:07.900–4:09.200
zh而那128个
4:09.200–4:11.500
zh各自又看过更前面的128个
4:11.500–4:14.720
zh所以第二层实际牵扯到前面256个
4:14.720–4:16.560
zh一层多128个
4:16.560–4:19.120
zh到第二层就是20乘128
4:19.120–4:20.480
zh2560个
4:20.480–4:21.540
zh也就是说
4:21.540–4:24.020
zh要把第20层的窗口KV算准
4:24.020–4:26.500
zh得从2560个Token之前开始
4:26.500–4:28.300
zh把解码器重新跑一遍
4:28.300–4:30.540
zhAgent的场景是多轮短消息
4:30.540–4:32.740
zh每轮新内容可能就几百个Token
4:32.740–4:35.260
zh为了补窗口再多跑2560个
4:35.260–4:36.340
zh这比开销不小
4:36.340–4:37.900
zh这个版本的做法叫
4:37.900–4:39.800
zh滑动窗口有界回放
4:39.800–4:41.920
zh不回退2560个
4:41.920–4:43.940
zh只回退末尾128个
4:43.940–4:46.500
zh把这128个Token的编码器输出
4:46.500–4:47.980
zh送进解码器跑一遍
4:47.980–4:50.700
zh开销是128个Token乘20层
4:50.700–4:52.380
zh跟50万笔可以忽略
4:52.380–4:55.340
zh窗口也只在这128个里面看
4:55.340–4:56.940
zh再往前的一律不看
4:56.940–4:59.360
zh因为再往前的token没经过解码器
4:59.360–5:00.320
zh没有东西可看
5:00.320–5:02.280
zh回放段里的第一个token
5:02.280–5:03.780
zh窗口里就只有他自己
5:03.780–5:05.680
zh越往后能看到的越多
5:05.680–5:08.200
zh到末尾正好是完整的128个
5:08.200–5:11.340
zh算出来的滑动窗口KV只拿来生成
5:11.340–5:12.380
zh不存进缓存
5:12.380–5:13.520
zh为什么敢
5:13.520–5:16.540
zh因为窗口的有效视野远比理论知晓
5:16.540–5:19.720
zh有篇叫PowerAttention的工作专门测过这件事
5:19.720–5:21.580
zh理论上第20层的视野
5:21.580–5:23.680
zh能到2560个token之外
5:23.680–5:25.260
zh实际上远处的信息
5:25.260–5:26.300
zh一层一层传过来
5:26.300–5:27.980
zh早就衰减到可以忽略
5:27.980–5:29.060
zh远处的东西
5:29.060–5:30.740
zh本来就归全局分支管
5:30.740–5:32.600
zh窗口只负责眼前这一段
5:32.600–5:34.040
zh这样补出来的KV
5:34.040–5:35.340
zh和完整跑一遍
5:35.340–5:36.160
zh不完全一样
5:36.160–5:38.100
zh报告说实测几乎不掉点
5:38.100–5:39.120
zh为了保险
5:39.120–5:40.020
zh后训练时
5:40.020–5:41.760
zh把同样的回放模拟进去
5:41.760–5:44.180
zh模型是在这种近似下练出来的
5:44.180–5:45.440
zh顺便说一句
5:45.440–5:47.580
zh这两集提到的前变量
5:47.580–5:48.520
zh稀疏注意力
5:48.520–5:50.360
zh后训练里的这种训练感知
5:50.360–5:52.520
zh都出自DeepSeek这套技术战
5:52.520–5:55.040
zh我做了一门DeepSeek专题的实战课
5:55.040–5:58.860
zh从MLA MOE ROPE这些核心机制
5:58.860–6:00.820
zh讲到GRPO对齐训练
6:00.820–6:03.300
zh再到VLLM SGLAN固鼓鼠
6:03.300–6:05.380
zh共计11张配项目代码
6:05.380–6:07.480
zh想把这两集背后的底子补齐
6:07.480–6:09.780
zh链接在简介和置顶评论里
6:09.780–6:11.020
zh算力说完
6:11.020–6:11.740
zh说硬盘
6:11.740–6:13.400
zh这一半省得更巧
6:13.400–6:15.520
zh先看V4是怎么存的
6:15.520–6:17.340
zh落到硬盘的缓存
6:17.340–6:18.640
zh叫持久化缓存
6:18.640–6:19.500
zh分两类
6:19.500–6:21.540
zh全局KV整段存
6:21.540–6:24.380
zh只要新请求的开头和缓存里的一样
6:24.380–6:25.600
zh就整段复用
6:25.600–6:27.880
zh滑动窗口KV不整段存
6:27.880–6:30.320
zh只在两个位置各存128个
6:30.320–6:31.980
zh一段提示词的末尾
6:31.980–6:33.300
zh一段回答的末尾
6:33.300–6:35.700
zh为的是重新生成和多轮接续
6:35.700–6:37.120
zh两类各自淘汰
6:37.120–6:38.900
zh最久没被用到的先删
6:38.900–6:40.380
zh硬盘配的够大
6:40.380–6:42.440
zh两类都能留72小时以上
6:42.440–6:43.300
zh就这样
6:43.300–6:46.940
zh滑动窗口KV还是占了持久化缓存将近一半
6:46.940–6:48.060
zh它没有压缩
6:48.060–6:49.940
zh每个位置128个Token
6:49.940–6:52.740
zh每一层各一份的8比特KV原样存
6:52.740–6:55.120
zh多轮对话每轮都要存一份
6:55.120–6:57.940
zh轮次多每轮短分数就多
6:57.940–6:59.960
zh问题处在访问模式
6:59.960–7:02.180
zh全局KV是常委复用
7:02.180–7:04.520
zh一天以后用户回来还会命中
7:04.520–7:07.100
zh滑动窗口KV只在一次绘画里
7:07.100–7:08.680
zh几分钟之内被用到
7:08.680–7:10.960
zh绘画一结束或者进到下一轮
7:10.960–7:12.460
zh它就再也不会被用到
7:12.460–7:16.660
zh把一份分钟级的东西放进保留72小时的缓存
7:16.660–7:17.900
zh又贵又没用
7:17.900–7:20.320
zhV4的报告提过干脆不存
7:20.320–7:21.260
zh要用再算
7:21.260–7:24.020
zh叫做Zero SWA Catching
7:24.020–7:25.000
zh可精确重算
7:25.000–7:28.420
zh要按层数乘128个token跑一遍完整前向
7:28.420–7:29.580
zh线上扛不住
7:29.580–7:31.440
zh这个版本改了两条
7:31.440–7:32.460
zh第一条
7:32.460–7:34.560
zh滑动窗口KV不再进硬盘
7:34.560–7:36.100
zh改放进一个内存池
7:36.100–7:40.100
zh所有机器各拿出10%的内存拼成一个池子
7:40.100–7:42.600
zh注意是机器的内存不是显存
7:42.600–7:44.780
zh池子总量比硬盘小得多
7:44.780–7:46.320
zh但有效期只有几分钟
7:46.320–7:48.160
zh过期立刻腾给新绘画
7:48.160–7:50.860
zh真实负载下这种高周转
7:50.860–7:52.980
zh够服务绝大多数正在进行的绘画
7:52.980–7:55.160
zh全局KV照旧流硬盘
7:55.160–7:56.500
zh保证72小时
7:56.500–8:00.000
zh第二条池子小必然有未命中
8:00.000–8:03.480
zh未命中指的是全局KV硬盘上还在
8:03.480–8:06.360
zh滑动窗口KV在池子里已经过期
8:21.753–8:23.173
zh编码器也是20层
8:23.173–8:26.073
zh精确补齐同样要2560个
8:26.073–8:28.333
zh现在只回放128个
8:28.333–8:31.053
zh补出来的窗口KV是近似的
8:31.053–8:32.333
zh缓存到哪里为止
8:32.333–8:34.173
zh回放就从哪里开始
8:34.173–8:35.373
zh起点不同
8:35.373–8:37.353
zh补出来的KV就略有不同
8:37.353–8:40.373
zh报告说这对回答质量几乎没有影响
8:40.373–8:41.833
zh还用了一个说法
8:41.833–8:43.713
zh把灾难性的未命中
8:43.713–8:46.053
zh变成了优雅又便宜的降级
8:46.053–8:47.893
zh正因为兜底便宜
8:47.893–8:50.753
zh才敢把滑动窗口KV从硬盘上拿掉
8:50.753–8:52.673
zh两种回放别混
8:52.673–8:55.013
zh解码器回放每次独入都做
8:55.013–8:57.073
zh补的是解码器的窗口KV
8:57.073–8:59.193
zh因为解码器从来不跑独入
8:59.193–9:01.753
zh编码器回放只在未命中识做
9:01.753–9:03.653
zh补的是编码器的窗口KV
9:03.653–9:05.333
zh因为硬盘上不再存它
9:05.333–9:08.073
zh两个都只回放末尾128个
9:08.073–9:09.453
zh都基于同一个判断
9:09.453–9:10.973
zh窗口的记忆很短
9:10.973–9:13.533
zh1%就是这么算出来的
9:13.533–9:15.033
zh不存滑动窗口KV
9:15.033–9:16.613
zh19化缓存少一半
9:16.613–9:18.433
zh剩下的全局KV
9:18.433–9:19.393
zh上一集讲过
9:19.393–9:21.073
zh是上一代的四分之一
9:21.073–9:22.853
zh二分之一乘四分之一
9:22.853–9:24.113
zh八分之一
9:24.113–9:26.673
zh把三层存储放在一起看就清楚了
9:26.673–9:29.273
zh显存里放正在用的全局KV
9:29.273–9:31.373
zh每个Token890字节
9:31.373–9:34.093
zh机器内存里放几分钟内会用的
9:34.093–9:35.113
zh滑动窗口KV
9:35.113–9:35.973
zh过期就扔
9:35.973–9:39.253
zh硬盘上放几天内可能会用的全局KV
9:39.253–9:40.433
zh留72小时
9:40.433–9:42.733
zh三层各管一个时间尺度
9:42.733–9:44.613
zh每一层只存它该存的
9:44.613–9:46.853
zh回到那个50万Token的绘画
9:46.853–9:47.853
zh看两个时刻
9:47.853–9:48.913
zh第一个时刻
9:48.913–9:50.933
zh工具返回一段新内容
9:50.933–9:53.293
zh读入直跑编码器20层
9:53.293–9:54.813
zh激活80亿参数
9:54.813–9:57.973
zh解码器要的全局KV顺手投影出来
9:57.973–10:00.193
zh滑动窗口回放128个
10:00.193–10:01.113
zh开始生成
10:01.113–10:02.213
zh第二个时刻
10:02.213–10:03.973
zh第二天用户回来接着聊
10:03.973–10:07.433
zh硬盘上取出来的只有全局KV400多兆
10:07.433–10:10.753
zh滑动窗口那份现算还是128个
10:10.753–10:11.973
zh两处近似
10:11.973–10:14.893
zh报告给的结论是性能与基线相当
10:14.893–10:16.613
zh读入的计算量减半
10:16.613–10:21.273
zh部署上还把视觉编码读入生成分成三段
10:21.273–10:22.573
zh各自扩缩容
10:22.573–10:25.573
zh读入密集的agent负载可以单独加机器
10:25.573–10:27.453
zh多轮短消息的agent绘画
10:27.453–10:29.713
zh就是报告点名要服务的场景
10:29.713–10:31.253
zh局限一共三条
10:31.253–10:32.173
zh第一条
10:32.173–10:33.933
zh有界回放是近似
10:33.933–10:36.653
zh尤其是缓存和新内容接缝的地方
10:36.653–10:38.833
zh报告承认还没充分验证
10:38.833–10:40.593
zh接下来要加压力测试
10:40.593–10:42.733
zh也要在真实负载里继续观察
10:42.733–10:44.773
zh后两条是我自己的判断
10:44.773–10:45.773
zh第二条
10:45.773–10:47.533
zh收益跟场景绑定
10:47.533–10:50.953
zh多轮每轮短的agent绘画收益最大
10:50.953–10:53.933
zh一次性为一份几十万token的长文档
10:53.933–10:55.893
zh省的主要是算力那一半
10:55.893–10:58.193
zh硬盘那一半的好处基本用不上
10:58.193–10:59.333
zh第三条
10:59.333–11:01.033
zh10%的内存池
11:01.033–11:02.513
zh几分钟的有效期
11:02.513–11:04.353
zh72小时的硬盘保留
11:04.353–11:07.753
zh都是按Deepseek自家的线上负载掉出来的
11:07.753–11:09.073
zh换一种负载分布
11:09.073–11:11.793
zh未命中率和回放开销都要重新测
11:11.793–11:13.753
zh回到开头的问题
11:13.753–11:14.913
zh算力砍一半
11:14.913–11:17.633
zh靠CED解码器的全局KV
11:17.633–11:18.873
zh从编码器投影
11:18.873–11:20.313
zh独入只跑20层
11:20.313–11:21.793
zh硬盘砍到1%
11:21.793–11:23.633
zh靠不存滑动窗口KV
11:23.633–11:25.973
zh为民众就回放128个补出来
11:25.973–11:28.853
zh再乘上上一集全局KV的1%
11:28.853–11:31.193
zh两件事背后是同一个判断
11:31.193–11:32.933
zh滑动窗口的记忆很短
11:32.933–11:34.353
zh短到可以现算
11:34.353–11:35.693
zh上一集的共用
11:35.693–11:37.193
zh加上这一集的回放
11:37.193–11:40.253
zh长上下文的存和算一起压了下来
11:40.253–11:41.253
zh成绩还没有掉
11:41.253–11:43.393
zh如果这一集让你有点收获
11:43.393–11:44.873
zh欢迎点赞转发
11:44.873–11:45.373
zh关注
11:45.373–11:46.773
zh评论区也聊聊
11:46.773–11:47.813
zh换你来做部署
11:47.813–11:48.913
zh滑动窗口KV
11:48.913–11:50.693
zh你会存硬盘保命中率
11:50.693–11:51.533
zh还是不存
11:51.533–11:53.053
zh靠回放节省硬盘
11:53.053–11:53.713
zh好
11:53.713–11:54.933
zh我们下期继续
0:00.000–0:00.640
Hello,
0:00.640–0:01.140
大家好,
0:01.140–0:01.920
我是Tommy。
0:01.920–0:03.840
今天很高興跟大家分享最新的前置內容。
0:04.100–0:07.196
那上一次我們講過Deepseek V4.1 Flash,
0:07.196–0:09.220
怎麼降低KP Cache的存儲開銷。
0:09.220–0:13.320
那麼這一次我們繼續看它怎麼減少脫離計算和緩存成本。
0:13.560–0:19.460
那核心呢就兩件事。第一個就是重新計算上下文的時候呢,只計算前一半的層。
0:19.460–0:22.520
那麼後面一半是直接附用已有的結果。
0:22.780–0:28.920
那第二個呢就是一部分短期緩存不再長期保存,而是在需要時重新計算。
0:28.920–0:29.880
那最终呢
0:29.880–0:31.660
计算量降低约一半
0:31.660–0:34.020
持久化缓存降到原来的1%
0:34.020–0:36.300
同时性能基本不受影响
0:36.300–0:37.200
那么这里呢
0:37.200–0:38.860
最关键的是两个问题
0:38.860–0:39.860
那第一个就是
0:39.860–0:42.640
为什么只计算一半的层就够了
0:42.640–0:43.580
第二个呢
0:43.580–0:45.000
为什么重新计算
0:45.000–0:47.800
反而比把缓存一直存下来更划算
0:47.800–0:50.520
那下面我们就直接来看它的具体设计
0:50.520–0:52.720
上一集那个编码agent
0:52.720–0:54.240
修一个仓库里的bug
0:54.240–0:55.200
跑了三个小时
0:55.200–0:56.920
上下文堆到50万token
0:56.920–0:59.200
上一集算的是它要存多少
0:59.200–1:01.580
40层只存4份KV
1:01.580–1:03.220
每个Token890字节
1:03.220–1:05.320
这一集算的是它要读多少
1:05.320–1:06.980
上一集结尾留了一句
1:06.980–1:08.860
4份里解码器那一份
1:08.860–1:11.000
还是从编码器投影来的
1:11.000–1:12.860
这意味着读入新内容时
1:12.860–1:14.300
只用跑前20层
1:14.300–1:15.520
后20层不用算
1:15.520–1:17.100
这一招叫CED
1:17.100–1:19.200
全称因果编码器解码器
1:19.200–1:20.600
这一集就讲它
1:20.600–1:23.020
它把40层分成前后两半
1:23.020–1:24.620
前20层叫编码器
1:24.620–1:26.060
负责读上下文
1:26.060–1:28.860
后20层叫解码器负责生成
1:28.860–1:30.640
解码器要用的KV
1:30.640–1:32.760
从编码器的输出投影出来
1:32.760–1:34.000
所以读入的时候
1:34.000–1:35.340
后20层可以不跑
1:35.340–1:36.660
为什么能这么干
1:36.660–1:37.760
代价是什么
1:37.760–1:39.220
就是这一集的内容
1:39.220–1:41.540
先看读入这一步为什么贵
1:41.540–1:43.360
Agent每掉一次工具
1:43.360–1:46.060
工具的返回都要接到上下文后面
1:46.060–1:47.840
模型再把新内容读一遍
1:47.840–1:49.820
也就是上一集说过的prefill
1:49.820–1:51.420
有缓存的时候
1:51.420–1:53.040
只读新增的那一段
1:53.040–1:54.700
缓存一旦没命中
1:54.700–1:56.520
整段50万都要重算
1:56.520–1:58.880
一次任务几十次工具调用
1:58.880–2:00.240
就是几十次读入
2:00.240–2:01.100
读一次
2:01.100–2:02.880
40层每一层都要算
2:02.880–2:04.080
上下文越长
2:04.080–2:05.260
这比算力越大
2:05.260–2:07.020
这还只是算力
2:07.020–2:09.440
50万token的KV还得留着
2:09.440–2:10.280
等下一轮
2:10.280–2:12.360
甚至等第二天用户回来接着聊
2:12.360–2:14.760
所以它要从显存落到硬盘上
2:14.760–2:16.260
V4的线上部署里
2:16.260–2:19.180
这份缓存要在硬盘上留72小时以上
2:19.180–2:21.060
显存装不装的下
2:21.060–2:22.500
硬盘存不存的起
2:22.500–2:23.920
机器之间搬不搬的动
2:23.920–2:25.360
三处都是压力
2:25.360–2:27.600
算力和硬盘两笔成本
2:27.600–2:28.540
问题来了
2:28.540–2:29.520
独入这一步
2:29.520–2:31.840
V4.1凭什么算力砍一半
2:31.840–2:32.920
硬盘砍到1%
2:32.920–2:34.120
先说算力
2:34.120–2:36.120
2024年有篇论文叫Yoko
2:36.120–2:37.880
意思是你只缓存一次
2:37.880–2:40.200
它把模型前后两半分开
2:40.200–2:42.400
后半层不再各自算KV
2:42.400–2:44.640
直接用前半层算好的那一份
2:44.640–2:46.440
后半层在独入阶段
2:46.440–2:47.640
就可以整个跳过
2:47.640–2:50.320
代价是后半层共用同一份KV
2:50.320–2:52.140
每一层没法有自己的一份
2:52.140–2:53.840
能存的信息就少了
2:53.920–2:56.360
CD顺着这个思路改了两处
2:56.360–2:58.380
解码器要用的全局KV
2:58.380–3:00.660
拿编码器第20层的输出
3:00.660–3:02.400
乘一个投影矩阵得到
3:02.400–3:03.440
第一处改动
3:03.440–3:05.380
投影矩阵可以逐层不同
3:05.380–3:07.260
每层能有自己的一份KV
3:07.260–3:09.340
容量比YOKO共用一份大
3:09.340–3:10.240
第二处
3:10.240–3:12.100
滑动窗口那条局部分支
3:12.100–3:12.700
不投影
3:12.700–3:14.140
每一层还是自己算
3:14.140–3:16.320
局部信息的计算深度保住了
3:16.320–3:17.800
在V4.1里
3:17.800–3:19.400
配合上一集讲的共用
3:19.400–3:22.040
真正做投影的是解码器那一个负层
3:22.040–3:23.320
其余层沿用它
3:23.320–3:25.820
独入阶段编码器20层算完
3:25.820–3:28.520
解码器要的全局KV顺手投影出来
3:28.520–3:30.240
后20层根本不用跑
3:30.240–3:32.340
算力从40层变20层
3:32.340–3:34.920
激活参数从160亿降到80亿
3:34.920–3:37.160
生成阶段才用满160亿
3:37.160–3:38.580
这里有个缺口要补
3:38.580–3:40.980
滑动窗口KV每一层自己算
3:40.980–3:43.180
可独入阶段解码器根本没跑
3:43.180–3:46.300
解码器20层的滑动窗口KV就是空的
3:46.300–3:47.800
生成第一个Token时
3:47.800–3:51.200
解码器要用到前面128个Token的窗口KV
3:51.200–3:52.360
手里却是空的
3:52.360–3:53.820
想精确补上
3:53.820–3:54.800
就得让解码器
3:54.800–3:57.340
把前面那些token重新算一遍
3:57.340–3:57.840
算多少
3:57.840–3:59.820
窗口是一层套一层的
3:59.820–4:01.760
解码器第一层的一个位置
4:01.760–4:03.620
只看它前面128个
4:03.620–4:05.240
第二层的同一个位置
4:05.240–4:07.900
看的是第一层算出的那128个
4:07.900–4:09.200
而那128个
4:09.200–4:11.500
各自又看过更前面的128个
4:11.500–4:14.720
所以第二层实际牵扯到前面256个
4:14.720–4:16.560
一层多128个
4:16.560–4:19.120
到第二层就是20乘128
4:19.120–4:20.480
2560个
4:20.480–4:21.540
也就是说
4:21.540–4:24.020
要把第20层的窗口KV算准
4:24.020–4:26.500
得从2560个Token之前开始
4:26.500–4:28.300
把解码器重新跑一遍
4:28.300–4:30.540
Agent的场景是多轮短消息
4:30.540–4:32.740
每轮新内容可能就几百个Token
4:32.740–4:35.260
为了补窗口再多跑2560个
4:35.260–4:36.340
这比开销不小
4:36.340–4:37.900
这个版本的做法叫
4:37.900–4:39.800
滑动窗口有界回放
4:39.800–4:41.920
不回退2560个
4:41.920–4:43.940
只回退末尾128个
4:43.940–4:46.500
把这128个Token的编码器输出
4:46.500–4:47.980
送进解码器跑一遍
4:47.980–4:50.700
开销是128个Token乘20层
4:50.700–4:52.380
跟50万笔可以忽略
4:52.380–4:55.340
窗口也只在这128个里面看
4:55.340–4:56.940
再往前的一律不看
4:56.940–4:59.360
因为再往前的token没经过解码器
4:59.360–5:00.320
没有东西可看
5:00.320–5:02.280
回放段里的第一个token
5:02.280–5:03.780
窗口里就只有他自己
5:03.780–5:05.680
越往后能看到的越多
5:05.680–5:08.200
到末尾正好是完整的128个
5:08.200–5:11.340
算出来的滑动窗口KV只拿来生成
5:11.340–5:12.380
不存进缓存
5:12.380–5:13.520
为什么敢
5:13.520–5:16.540
因为窗口的有效视野远比理论知晓
5:16.540–5:19.720
有篇叫PowerAttention的工作专门测过这件事
5:19.720–5:21.580
理论上第20层的视野
5:21.580–5:23.680
能到2560个token之外
5:23.680–5:25.260
实际上远处的信息
5:25.260–5:26.300
一层一层传过来
5:26.300–5:27.980
早就衰减到可以忽略
5:27.980–5:29.060
远处的东西
5:29.060–5:30.740
本来就归全局分支管
5:30.740–5:32.600
窗口只负责眼前这一段
5:32.600–5:34.040
这样补出来的KV
5:34.040–5:35.340
和完整跑一遍
5:35.340–5:36.160
不完全一样
5:36.160–5:38.100
报告说实测几乎不掉点
5:38.100–5:39.120
为了保险
5:39.120–5:40.020
后训练时
5:40.020–5:41.760
把同样的回放模拟进去
5:41.760–5:44.180
模型是在这种近似下练出来的
5:44.180–5:45.440
顺便说一句
5:45.440–5:47.580
这两集提到的前变量
5:47.580–5:48.520
稀疏注意力
5:48.520–5:50.360
后训练里的这种训练感知
5:50.360–5:52.520
都出自DeepSeek这套技术战
5:52.520–5:55.040
我做了一门DeepSeek专题的实战课
5:55.040–5:58.860
从MLA MOE ROPE这些核心机制
5:58.860–6:00.820
讲到GRPO对齐训练
6:00.820–6:03.300
再到VLLM SGLAN固鼓鼠
6:03.300–6:05.380
共计11张配项目代码
6:05.380–6:07.480
想把这两集背后的底子补齐
6:07.480–6:09.780
链接在简介和置顶评论里
6:09.780–6:11.020
算力说完
6:11.020–6:11.740
说硬盘
6:11.740–6:13.400
这一半省得更巧
6:13.400–6:15.520
先看V4是怎么存的
6:15.520–6:17.340
落到硬盘的缓存
6:17.340–6:18.640
叫持久化缓存
6:18.640–6:19.500
分两类
6:19.500–6:21.540
全局KV整段存
6:21.540–6:24.380
只要新请求的开头和缓存里的一样
6:24.380–6:25.600
就整段复用
6:25.600–6:27.880
滑动窗口KV不整段存
6:27.880–6:30.320
只在两个位置各存128个
6:30.320–6:31.980
一段提示词的末尾
6:31.980–6:33.300
一段回答的末尾
6:33.300–6:35.700
为的是重新生成和多轮接续
6:35.700–6:37.120
两类各自淘汰
6:37.120–6:38.900
最久没被用到的先删
6:38.900–6:40.380
硬盘配的够大
6:40.380–6:42.440
两类都能留72小时以上
6:42.440–6:43.300
就这样
6:43.300–6:46.940
滑动窗口KV还是占了持久化缓存将近一半
6:46.940–6:48.060
它没有压缩
6:48.060–6:49.940
每个位置128个Token
6:49.940–6:52.740
每一层各一份的8比特KV原样存
6:52.740–6:55.120
多轮对话每轮都要存一份
6:55.120–6:57.940
轮次多每轮短分数就多
6:57.940–6:59.960
问题处在访问模式
6:59.960–7:02.180
全局KV是常委复用
7:02.180–7:04.520
一天以后用户回来还会命中
7:04.520–7:07.100
滑动窗口KV只在一次绘画里
7:07.100–7:08.680
几分钟之内被用到
7:08.680–7:10.960
绘画一结束或者进到下一轮
7:10.960–7:12.460
它就再也不会被用到
7:12.460–7:16.660
把一份分钟级的东西放进保留72小时的缓存
7:16.660–7:17.900
又贵又没用
7:17.900–7:20.320
V4的报告提过干脆不存
7:20.320–7:21.260
要用再算
7:21.260–7:24.020
叫做Zero SWA Catching
7:24.020–7:25.000
可精确重算
7:25.000–7:28.420
要按层数乘128个token跑一遍完整前向
7:28.420–7:29.580
线上扛不住
7:29.580–7:31.440
这个版本改了两条
7:31.440–7:32.460
第一条
7:32.460–7:34.560
滑动窗口KV不再进硬盘
7:34.560–7:36.100
改放进一个内存池
7:36.100–7:40.100
所有机器各拿出10%的内存拼成一个池子
7:40.100–7:42.600
注意是机器的内存不是显存
7:42.600–7:44.780
池子总量比硬盘小得多
7:44.780–7:46.320
但有效期只有几分钟
7:46.320–7:48.160
过期立刻腾给新绘画
7:48.160–7:50.860
真实负载下这种高周转
7:50.860–7:52.980
够服务绝大多数正在进行的绘画
7:52.980–7:55.160
全局KV照旧流硬盘
7:55.160–7:56.500
保证72小时
7:56.500–8:00.000
第二条池子小必然有未命中
8:00.000–8:03.480
未命中指的是全局KV硬盘上还在
8:03.480–8:06.360
滑动窗口KV在池子里已经过期
8:21.753–8:23.173
编码器也是20层
8:23.173–8:26.073
精确补齐同样要2560个
8:26.073–8:28.333
现在只回放128个
8:28.333–8:31.053
补出来的窗口KV是近似的
8:31.053–8:32.333
缓存到哪里为止
8:32.333–8:34.173
回放就从哪里开始
8:34.173–8:35.373
起点不同
8:35.373–8:37.353
补出来的KV就略有不同
8:37.353–8:40.373
报告说这对回答质量几乎没有影响
8:40.373–8:41.833
还用了一个说法
8:41.833–8:43.713
把灾难性的未命中
8:43.713–8:46.053
变成了优雅又便宜的降级
8:46.053–8:47.893
正因为兜底便宜
8:47.893–8:50.753
才敢把滑动窗口KV从硬盘上拿掉
8:50.753–8:52.673
两种回放别混
8:52.673–8:55.013
解码器回放每次独入都做
8:55.013–8:57.073
补的是解码器的窗口KV
8:57.073–8:59.193
因为解码器从来不跑独入
8:59.193–9:01.753
编码器回放只在未命中识做
9:01.753–9:03.653
补的是编码器的窗口KV
9:03.653–9:05.333
因为硬盘上不再存它
9:05.333–9:08.073
两个都只回放末尾128个
9:08.073–9:09.453
都基于同一个判断
9:09.453–9:10.973
窗口的记忆很短
9:10.973–9:13.533
1%就是这么算出来的
9:13.533–9:15.033
不存滑动窗口KV
9:15.033–9:16.613
19化缓存少一半
9:16.613–9:18.433
剩下的全局KV
9:18.433–9:19.393
上一集讲过
9:19.393–9:21.073
是上一代的四分之一
9:21.073–9:22.853
二分之一乘四分之一
9:22.853–9:24.113
八分之一
9:24.113–9:26.673
把三层存储放在一起看就清楚了
9:26.673–9:29.273
显存里放正在用的全局KV
9:29.273–9:31.373
每个Token890字节
9:31.373–9:34.093
机器内存里放几分钟内会用的
9:34.093–9:35.113
滑动窗口KV
9:35.113–9:35.973
过期就扔
9:35.973–9:39.253
硬盘上放几天内可能会用的全局KV
9:39.253–9:40.433
留72小时
9:40.433–9:42.733
三层各管一个时间尺度
9:42.733–9:44.613
每一层只存它该存的
9:44.613–9:46.853
回到那个50万Token的绘画
9:46.853–9:47.853
看两个时刻
9:47.853–9:48.913
第一个时刻
9:48.913–9:50.933
工具返回一段新内容
9:50.933–9:53.293
读入直跑编码器20层
9:53.293–9:54.813
激活80亿参数
9:54.813–9:57.973
解码器要的全局KV顺手投影出来
9:57.973–10:00.193
滑动窗口回放128个
10:00.193–10:01.113
开始生成
10:01.113–10:02.213
第二个时刻
10:02.213–10:03.973
第二天用户回来接着聊
10:03.973–10:07.433
硬盘上取出来的只有全局KV400多兆
10:07.433–10:10.753
滑动窗口那份现算还是128个
10:10.753–10:11.973
两处近似
10:11.973–10:14.893
报告给的结论是性能与基线相当
10:14.893–10:16.613
读入的计算量减半
10:16.613–10:21.273
部署上还把视觉编码读入生成分成三段
10:21.273–10:22.573
各自扩缩容
10:22.573–10:25.573
读入密集的agent负载可以单独加机器
10:25.573–10:27.453
多轮短消息的agent绘画
10:27.453–10:29.713
就是报告点名要服务的场景
10:29.713–10:31.253
局限一共三条
10:31.253–10:32.173
第一条
10:32.173–10:33.933
有界回放是近似
10:33.933–10:36.653
尤其是缓存和新内容接缝的地方
10:36.653–10:38.833
报告承认还没充分验证
10:38.833–10:40.593
接下来要加压力测试
10:40.593–10:42.733
也要在真实负载里继续观察
10:42.733–10:44.773
后两条是我自己的判断
10:44.773–10:45.773
第二条
10:45.773–10:47.533
收益跟场景绑定
10:47.533–10:50.953
多轮每轮短的agent绘画收益最大
10:50.953–10:53.933
一次性为一份几十万token的长文档
10:53.933–10:55.893
省的主要是算力那一半
10:55.893–10:58.193
硬盘那一半的好处基本用不上
10:58.193–10:59.333
第三条
10:59.333–11:01.033
10%的内存池
11:01.033–11:02.513
几分钟的有效期
11:02.513–11:04.353
72小时的硬盘保留
11:04.353–11:07.753
都是按Deepseek自家的线上负载掉出来的
11:07.753–11:09.073
换一种负载分布
11:09.073–11:11.793
未命中率和回放开销都要重新测
11:11.793–11:13.753
回到开头的问题
11:13.753–11:14.913
算力砍一半
11:14.913–11:17.633
靠CED解码器的全局KV
11:17.633–11:18.873
从编码器投影
11:18.873–11:20.313
独入只跑20层
11:20.313–11:21.793
硬盘砍到1%
11:21.793–11:23.633
靠不存滑动窗口KV
11:23.633–11:25.973
为民众就回放128个补出来
11:25.973–11:28.853
再乘上上一集全局KV的1%
11:28.853–11:31.193
两件事背后是同一个判断
11:31.193–11:32.933
滑动窗口的记忆很短
11:32.933–11:34.353
短到可以现算
11:34.353–11:35.693
上一集的共用
11:35.693–11:37.193
加上这一集的回放
11:37.193–11:40.253
长上下文的存和算一起压了下来
11:40.253–11:41.253
成绩还没有掉
11:41.253–11:43.393
如果这一集让你有点收获
11:43.393–11:44.873
欢迎点赞转发
11:44.873–11:45.373
关注
11:45.373–11:46.773
评论区也聊聊
11:46.773–11:47.813
换你来做部署
11:47.813–11:48.913
滑动窗口KV
11:48.913–11:50.693
你会存硬盘保命中率
11:50.693–11:51.533
还是不存
11:51.533–11:53.053
靠回放节省硬盘
11:53.053–11:53.713
好
11:53.713–11:54.933
我们下期继续
0:00.000–0:00.640
enHello,
Hello,
0:00.640–0:01.140
zh大家好,
大家好,
0:01.140–0:01.920
zh我是Tommy。
我是Tommy。
0:01.920–0:03.840
zh今天很高興跟大家分享最新的前置內容。
今天很高興跟大家分享最新的前置內容。
0:04.100–0:07.196
zh那上一次我們講過Deepseek V4.1 Flash,
那上一次我們講過Deepseek V4.1 Flash,
0:07.196–0:09.220
zh怎麼降低KP Cache的存儲開銷。
怎麼降低KP Cache的存儲開銷。
0:09.220–0:13.320
zh那麼這一次我們繼續看它怎麼減少脫離計算和緩存成本。
那麼這一次我們繼續看它怎麼減少脫離計算和緩存成本。
0:13.560–0:19.460
zh那核心呢就兩件事。第一個就是重新計算上下文的時候呢,只計算前一半的層。
那核心呢就兩件事。第一個就是重新計算上下文的時候呢,只計算前一半的層。
0:19.460–0:22.520
zh那麼後面一半是直接附用已有的結果。
那麼後面一半是直接附用已有的結果。
0:22.780–0:28.920
zh那第二個呢就是一部分短期緩存不再長期保存,而是在需要時重新計算。
那第二個呢就是一部分短期緩存不再長期保存,而是在需要時重新計算。
0:28.920–0:29.880
zh那最终呢
那最终呢
0:29.880–0:31.660
zh计算量降低约一半
计算量降低约一半
0:31.660–0:34.020
zh持久化缓存降到原来的1%
持久化缓存降到原来的1%
0:34.020–0:36.300
zh同时性能基本不受影响
同时性能基本不受影响
0:36.300–0:37.200
zh那么这里呢
那么这里呢
0:37.200–0:38.860
zh最关键的是两个问题
最关键的是两个问题
0:38.860–0:39.860
zh那第一个就是
那第一个就是
0:39.860–0:42.640
zh为什么只计算一半的层就够了
为什么只计算一半的层就够了
0:42.640–0:43.580
zh第二个呢
第二个呢
0:43.580–0:45.000
zh为什么重新计算
为什么重新计算
0:45.000–0:47.800
zh反而比把缓存一直存下来更划算
反而比把缓存一直存下来更划算
0:47.800–0:50.520
zh那下面我们就直接来看它的具体设计
那下面我们就直接来看它的具体设计
0:50.520–0:52.720
zh上一集那个编码agent
上一集那个编码agent
0:52.720–0:54.240
zh修一个仓库里的bug
修一个仓库里的bug
0:54.240–0:55.200
zh跑了三个小时
跑了三个小时
0:55.200–0:56.920
zh上下文堆到50万token
上下文堆到50万token
0:56.920–0:59.200
zh上一集算的是它要存多少
上一集算的是它要存多少
0:59.200–1:01.580
zh40层只存4份KV
40层只存4份KV
1:01.580–1:03.220
zh每个Token890字节
每个Token890字节
1:03.220–1:05.320
zh这一集算的是它要读多少
这一集算的是它要读多少
1:05.320–1:06.980
zh上一集结尾留了一句
上一集结尾留了一句
1:06.980–1:08.860
zh4份里解码器那一份
4份里解码器那一份
1:08.860–1:11.000
zh还是从编码器投影来的
还是从编码器投影来的
1:11.000–1:12.860
zh这意味着读入新内容时
这意味着读入新内容时
1:12.860–1:14.300
zh只用跑前20层
只用跑前20层
1:14.300–1:15.520
zh后20层不用算
后20层不用算
1:15.520–1:17.100
zh这一招叫CED
这一招叫CED
1:17.100–1:19.200
zh全称因果编码器解码器
全称因果编码器解码器
1:19.200–1:20.600
zh这一集就讲它
这一集就讲它
1:20.600–1:23.020
zh它把40层分成前后两半
它把40层分成前后两半
1:23.020–1:24.620
zh前20层叫编码器
前20层叫编码器
1:24.620–1:26.060
zh负责读上下文
负责读上下文
1:26.060–1:28.860
zh后20层叫解码器负责生成
后20层叫解码器负责生成
1:28.860–1:30.640
zh解码器要用的KV
解码器要用的KV
1:30.640–1:32.760
zh从编码器的输出投影出来
从编码器的输出投影出来
1:32.760–1:34.000
zh所以读入的时候
所以读入的时候
1:34.000–1:35.340
zh后20层可以不跑
后20层可以不跑
1:35.340–1:36.660
zh为什么能这么干
为什么能这么干
1:36.660–1:37.760
zh代价是什么
代价是什么
1:37.760–1:39.220
zh就是这一集的内容
就是这一集的内容
1:39.220–1:41.540
zh先看读入这一步为什么贵
先看读入这一步为什么贵
1:41.540–1:43.360
zhAgent每掉一次工具
Agent每掉一次工具
1:43.360–1:46.060
zh工具的返回都要接到上下文后面
工具的返回都要接到上下文后面
1:46.060–1:47.840
zh模型再把新内容读一遍
模型再把新内容读一遍
1:47.840–1:49.820
zh也就是上一集说过的prefill
也就是上一集说过的prefill
1:49.820–1:51.420
zh有缓存的时候
有缓存的时候
1:51.420–1:53.040
zh只读新增的那一段
只读新增的那一段
1:53.040–1:54.700
zh缓存一旦没命中
缓存一旦没命中
1:54.700–1:56.520
zh整段50万都要重算
整段50万都要重算
1:56.520–1:58.880
zh一次任务几十次工具调用
一次任务几十次工具调用
1:58.880–2:00.240
zh就是几十次读入
就是几十次读入
2:00.240–2:01.100
zh读一次
读一次
2:01.100–2:02.880
zh40层每一层都要算
40层每一层都要算
2:02.880–2:04.080
zh上下文越长
上下文越长
2:04.080–2:05.260
zh这比算力越大
这比算力越大
2:05.260–2:07.020
zh这还只是算力
这还只是算力
2:07.020–2:09.440
zh50万token的KV还得留着
50万token的KV还得留着
2:09.440–2:10.280
zh等下一轮
等下一轮
2:10.280–2:12.360
zh甚至等第二天用户回来接着聊
甚至等第二天用户回来接着聊
2:12.360–2:14.760
zh所以它要从显存落到硬盘上
所以它要从显存落到硬盘上
2:14.760–2:16.260
zhV4的线上部署里
V4的线上部署里
2:16.260–2:19.180
zh这份缓存要在硬盘上留72小时以上
这份缓存要在硬盘上留72小时以上
2:19.180–2:21.060
zh显存装不装的下
显存装不装的下
2:21.060–2:22.500
zh硬盘存不存的起
硬盘存不存的起
2:22.500–2:23.920
zh机器之间搬不搬的动
机器之间搬不搬的动
2:23.920–2:25.360
zh三处都是压力
三处都是压力
2:25.360–2:27.600
zh算力和硬盘两笔成本
算力和硬盘两笔成本
2:27.600–2:28.540
zh问题来了
问题来了
2:28.540–2:29.520
zh独入这一步
独入这一步
2:29.520–2:31.840
zhV4.1凭什么算力砍一半
V4.1凭什么算力砍一半
2:31.840–2:32.920
zh硬盘砍到1%
硬盘砍到1%
2:32.920–2:34.120
zh先说算力
先说算力
2:34.120–2:36.120
zh2024年有篇论文叫Yoko
2024年有篇论文叫Yoko
2:36.120–2:37.880
zh意思是你只缓存一次
意思是你只缓存一次
2:37.880–2:40.200
zh它把模型前后两半分开
它把模型前后两半分开
2:40.200–2:42.400
zh后半层不再各自算KV
后半层不再各自算KV
2:42.400–2:44.640
zh直接用前半层算好的那一份
直接用前半层算好的那一份
2:44.640–2:46.440
zh后半层在独入阶段
后半层在独入阶段
2:46.440–2:47.640
zh就可以整个跳过
就可以整个跳过
2:47.640–2:50.320
zh代价是后半层共用同一份KV
代价是后半层共用同一份KV
2:50.320–2:52.140
zh每一层没法有自己的一份
每一层没法有自己的一份
2:52.140–2:53.840
zh能存的信息就少了
能存的信息就少了
2:53.920–2:56.360
zhCD顺着这个思路改了两处
CD顺着这个思路改了两处
2:56.360–2:58.380
zh解码器要用的全局KV
解码器要用的全局KV
2:58.380–3:00.660
zh拿编码器第20层的输出
拿编码器第20层的输出
3:00.660–3:02.400
zh乘一个投影矩阵得到
乘一个投影矩阵得到
3:02.400–3:03.440
zh第一处改动
第一处改动
3:03.440–3:05.380
zh投影矩阵可以逐层不同
投影矩阵可以逐层不同
3:05.380–3:07.260
zh每层能有自己的一份KV
每层能有自己的一份KV
3:07.260–3:09.340
zh容量比YOKO共用一份大
容量比YOKO共用一份大
3:09.340–3:10.240
zh第二处
第二处
3:10.240–3:12.100
zh滑动窗口那条局部分支
滑动窗口那条局部分支
3:12.100–3:12.700
zh不投影
不投影
3:12.700–3:14.140
zh每一层还是自己算
每一层还是自己算
3:14.140–3:16.320
zh局部信息的计算深度保住了
局部信息的计算深度保住了
3:16.320–3:17.800
zh在V4.1里
在V4.1里
3:17.800–3:19.400
zh配合上一集讲的共用
配合上一集讲的共用
3:19.400–3:22.040
zh真正做投影的是解码器那一个负层
真正做投影的是解码器那一个负层
3:22.040–3:23.320
zh其余层沿用它
其余层沿用它
3:23.320–3:25.820
zh独入阶段编码器20层算完
独入阶段编码器20层算完
3:25.820–3:28.520
zh解码器要的全局KV顺手投影出来
解码器要的全局KV顺手投影出来
3:28.520–3:30.240
zh后20层根本不用跑
后20层根本不用跑
3:30.240–3:32.340
zh算力从40层变20层
算力从40层变20层
3:32.340–3:34.920
zh激活参数从160亿降到80亿
激活参数从160亿降到80亿
3:34.920–3:37.160
zh生成阶段才用满160亿
生成阶段才用满160亿
3:37.160–3:38.580
zh这里有个缺口要补
这里有个缺口要补
3:38.580–3:40.980
zh滑动窗口KV每一层自己算
滑动窗口KV每一层自己算
3:40.980–3:43.180
zh可独入阶段解码器根本没跑
可独入阶段解码器根本没跑
3:43.180–3:46.300
zh解码器20层的滑动窗口KV就是空的
解码器20层的滑动窗口KV就是空的
3:46.300–3:47.800
zh生成第一个Token时
生成第一个Token时
3:47.800–3:51.200
zh解码器要用到前面128个Token的窗口KV
解码器要用到前面128个Token的窗口KV
3:51.200–3:52.360
zh手里却是空的
手里却是空的
3:52.360–3:53.820
zh想精确补上
想精确补上
3:53.820–3:54.800
zh就得让解码器
就得让解码器
3:54.800–3:57.340
zh把前面那些token重新算一遍
把前面那些token重新算一遍
3:57.340–3:57.840
zh算多少
算多少
3:57.840–3:59.820
zh窗口是一层套一层的
窗口是一层套一层的
3:59.820–4:01.760
zh解码器第一层的一个位置
解码器第一层的一个位置
4:01.760–4:03.620
zh只看它前面128个
只看它前面128个
4:03.620–4:05.240
zh第二层的同一个位置
第二层的同一个位置
4:05.240–4:07.900
zh看的是第一层算出的那128个
看的是第一层算出的那128个
4:07.900–4:09.200
zh而那128个
而那128个
4:09.200–4:11.500
zh各自又看过更前面的128个
各自又看过更前面的128个
4:11.500–4:14.720
zh所以第二层实际牵扯到前面256个
所以第二层实际牵扯到前面256个
4:14.720–4:16.560
zh一层多128个
一层多128个
4:16.560–4:19.120
zh到第二层就是20乘128
到第二层就是20乘128
4:19.120–4:20.480
zh2560个
2560个
4:20.480–4:21.540
zh也就是说
也就是说
4:21.540–4:24.020
zh要把第20层的窗口KV算准
要把第20层的窗口KV算准
4:24.020–4:26.500
zh得从2560个Token之前开始
得从2560个Token之前开始
4:26.500–4:28.300
zh把解码器重新跑一遍
把解码器重新跑一遍
4:28.300–4:30.540
zhAgent的场景是多轮短消息
Agent的场景是多轮短消息
4:30.540–4:32.740
zh每轮新内容可能就几百个Token
每轮新内容可能就几百个Token
4:32.740–4:35.260
zh为了补窗口再多跑2560个
为了补窗口再多跑2560个
4:35.260–4:36.340
zh这比开销不小
这比开销不小
4:36.340–4:37.900
zh这个版本的做法叫
这个版本的做法叫
4:37.900–4:39.800
zh滑动窗口有界回放
滑动窗口有界回放
4:39.800–4:41.920
zh不回退2560个
不回退2560个
4:41.920–4:43.940
zh只回退末尾128个
只回退末尾128个
4:43.940–4:46.500
zh把这128个Token的编码器输出
把这128个Token的编码器输出
4:46.500–4:47.980
zh送进解码器跑一遍
送进解码器跑一遍
4:47.980–4:50.700
zh开销是128个Token乘20层
开销是128个Token乘20层
4:50.700–4:52.380
zh跟50万笔可以忽略
跟50万笔可以忽略
4:52.380–4:55.340
zh窗口也只在这128个里面看
窗口也只在这128个里面看
4:55.340–4:56.940
zh再往前的一律不看
再往前的一律不看
4:56.940–4:59.360
zh因为再往前的token没经过解码器
因为再往前的token没经过解码器
4:59.360–5:00.320
zh没有东西可看
没有东西可看
5:00.320–5:02.280
zh回放段里的第一个token
回放段里的第一个token
5:02.280–5:03.780
zh窗口里就只有他自己
窗口里就只有他自己
5:03.780–5:05.680
zh越往后能看到的越多
越往后能看到的越多
5:05.680–5:08.200
zh到末尾正好是完整的128个
到末尾正好是完整的128个
5:08.200–5:11.340
zh算出来的滑动窗口KV只拿来生成
算出来的滑动窗口KV只拿来生成
5:11.340–5:12.380
zh不存进缓存
不存进缓存
5:12.380–5:13.520
zh为什么敢
为什么敢
5:13.520–5:16.540
zh因为窗口的有效视野远比理论知晓
因为窗口的有效视野远比理论知晓
5:16.540–5:19.720
zh有篇叫PowerAttention的工作专门测过这件事
有篇叫PowerAttention的工作专门测过这件事
5:19.720–5:21.580
zh理论上第20层的视野
理论上第20层的视野
5:21.580–5:23.680
zh能到2560个token之外
能到2560个token之外
5:23.680–5:25.260
zh实际上远处的信息
实际上远处的信息
5:25.260–5:26.300
zh一层一层传过来
一层一层传过来
5:26.300–5:27.980
zh早就衰减到可以忽略
早就衰减到可以忽略
5:27.980–5:29.060
zh远处的东西
远处的东西
5:29.060–5:30.740
zh本来就归全局分支管
本来就归全局分支管
5:30.740–5:32.600
zh窗口只负责眼前这一段
窗口只负责眼前这一段
5:32.600–5:34.040
zh这样补出来的KV
这样补出来的KV
5:34.040–5:35.340
zh和完整跑一遍
和完整跑一遍
5:35.340–5:36.160
zh不完全一样
不完全一样
5:36.160–5:38.100
zh报告说实测几乎不掉点
报告说实测几乎不掉点
5:38.100–5:39.120
zh为了保险
为了保险
5:39.120–5:40.020
zh后训练时
后训练时
5:40.020–5:41.760
zh把同样的回放模拟进去
把同样的回放模拟进去
5:41.760–5:44.180
zh模型是在这种近似下练出来的
模型是在这种近似下练出来的
5:44.180–5:45.440
zh顺便说一句
顺便说一句
5:45.440–5:47.580
zh这两集提到的前变量
这两集提到的前变量
5:47.580–5:48.520
zh稀疏注意力
稀疏注意力
5:48.520–5:50.360
zh后训练里的这种训练感知
后训练里的这种训练感知
5:50.360–5:52.520
zh都出自DeepSeek这套技术战
都出自DeepSeek这套技术战
5:52.520–5:55.040
zh我做了一门DeepSeek专题的实战课
我做了一门DeepSeek专题的实战课
5:55.040–5:58.860
zh从MLA MOE ROPE这些核心机制
从MLA MOE ROPE这些核心机制
5:58.860–6:00.820
zh讲到GRPO对齐训练
讲到GRPO对齐训练
6:00.820–6:03.300
zh再到VLLM SGLAN固鼓鼠
再到VLLM SGLAN固鼓鼠
6:03.300–6:05.380
zh共计11张配项目代码
共计11张配项目代码
6:05.380–6:07.480
zh想把这两集背后的底子补齐
想把这两集背后的底子补齐
6:07.480–6:09.780
zh链接在简介和置顶评论里
链接在简介和置顶评论里
6:09.780–6:11.020
zh算力说完
算力说完
6:11.020–6:11.740
zh说硬盘
说硬盘
6:11.740–6:13.400
zh这一半省得更巧
这一半省得更巧
6:13.400–6:15.520
zh先看V4是怎么存的
先看V4是怎么存的
6:15.520–6:17.340
zh落到硬盘的缓存
落到硬盘的缓存
6:17.340–6:18.640
zh叫持久化缓存
叫持久化缓存
6:18.640–6:19.500
zh分两类
分两类
6:19.500–6:21.540
zh全局KV整段存
全局KV整段存
6:21.540–6:24.380
zh只要新请求的开头和缓存里的一样
只要新请求的开头和缓存里的一样
6:24.380–6:25.600
zh就整段复用
就整段复用
6:25.600–6:27.880
zh滑动窗口KV不整段存
滑动窗口KV不整段存
6:27.880–6:30.320
zh只在两个位置各存128个
只在两个位置各存128个
6:30.320–6:31.980
zh一段提示词的末尾
一段提示词的末尾
6:31.980–6:33.300
zh一段回答的末尾
一段回答的末尾
6:33.300–6:35.700
zh为的是重新生成和多轮接续
为的是重新生成和多轮接续
6:35.700–6:37.120
zh两类各自淘汰
两类各自淘汰
6:37.120–6:38.900
zh最久没被用到的先删
最久没被用到的先删
6:38.900–6:40.380
zh硬盘配的够大
硬盘配的够大
6:40.380–6:42.440
zh两类都能留72小时以上
两类都能留72小时以上
6:42.440–6:43.300
zh就这样
就这样
6:43.300–6:46.940
zh滑动窗口KV还是占了持久化缓存将近一半
滑动窗口KV还是占了持久化缓存将近一半
6:46.940–6:48.060
zh它没有压缩
它没有压缩
6:48.060–6:49.940
zh每个位置128个Token
每个位置128个Token
6:49.940–6:52.740
zh每一层各一份的8比特KV原样存
每一层各一份的8比特KV原样存
6:52.740–6:55.120
zh多轮对话每轮都要存一份
多轮对话每轮都要存一份
6:55.120–6:57.940
zh轮次多每轮短分数就多
轮次多每轮短分数就多
6:57.940–6:59.960
zh问题处在访问模式
问题处在访问模式
6:59.960–7:02.180
zh全局KV是常委复用
全局KV是常委复用
7:02.180–7:04.520
zh一天以后用户回来还会命中
一天以后用户回来还会命中
7:04.520–7:07.100
zh滑动窗口KV只在一次绘画里
滑动窗口KV只在一次绘画里
7:07.100–7:08.680
zh几分钟之内被用到
几分钟之内被用到
7:08.680–7:10.960
zh绘画一结束或者进到下一轮
绘画一结束或者进到下一轮
7:10.960–7:12.460
zh它就再也不会被用到
它就再也不会被用到
7:12.460–7:16.660
zh把一份分钟级的东西放进保留72小时的缓存
把一份分钟级的东西放进保留72小时的缓存
7:16.660–7:17.900
zh又贵又没用
又贵又没用
7:17.900–7:20.320
zhV4的报告提过干脆不存
V4的报告提过干脆不存
7:20.320–7:21.260
zh要用再算
要用再算
7:21.260–7:24.020
zh叫做Zero SWA Catching
叫做Zero SWA Catching
7:24.020–7:25.000
zh可精确重算
可精确重算
7:25.000–7:28.420
zh要按层数乘128个token跑一遍完整前向
要按层数乘128个token跑一遍完整前向
7:28.420–7:29.580
zh线上扛不住
线上扛不住
7:29.580–7:31.440
zh这个版本改了两条
这个版本改了两条
7:31.440–7:32.460
zh第一条
第一条
7:32.460–7:34.560
zh滑动窗口KV不再进硬盘
滑动窗口KV不再进硬盘
7:34.560–7:36.100
zh改放进一个内存池
改放进一个内存池
7:36.100–7:40.100
zh所有机器各拿出10%的内存拼成一个池子
所有机器各拿出10%的内存拼成一个池子
7:40.100–7:42.600
zh注意是机器的内存不是显存
注意是机器的内存不是显存
7:42.600–7:44.780
zh池子总量比硬盘小得多
池子总量比硬盘小得多
7:44.780–7:46.320
zh但有效期只有几分钟
但有效期只有几分钟
7:46.320–7:48.160
zh过期立刻腾给新绘画
过期立刻腾给新绘画
7:48.160–7:50.860
zh真实负载下这种高周转
真实负载下这种高周转
7:50.860–7:52.980
zh够服务绝大多数正在进行的绘画
够服务绝大多数正在进行的绘画
7:52.980–7:55.160
zh全局KV照旧流硬盘
全局KV照旧流硬盘
7:55.160–7:56.500
zh保证72小时
保证72小时
7:56.500–8:00.000
zh第二条池子小必然有未命中
第二条池子小必然有未命中
8:00.000–8:03.480
zh未命中指的是全局KV硬盘上还在
未命中指的是全局KV硬盘上还在
8:03.480–8:06.360
zh滑动窗口KV在池子里已经过期
滑动窗口KV在池子里已经过期
8:21.753–8:23.173
zh编码器也是20层
编码器也是20层
8:23.173–8:26.073
zh精确补齐同样要2560个
精确补齐同样要2560个
8:26.073–8:28.333
zh现在只回放128个
现在只回放128个
8:28.333–8:31.053
zh补出来的窗口KV是近似的
补出来的窗口KV是近似的
8:31.053–8:32.333
zh缓存到哪里为止
缓存到哪里为止
8:32.333–8:34.173
zh回放就从哪里开始
回放就从哪里开始
8:34.173–8:35.373
zh起点不同
起点不同
8:35.373–8:37.353
zh补出来的KV就略有不同
补出来的KV就略有不同
8:37.353–8:40.373
zh报告说这对回答质量几乎没有影响
报告说这对回答质量几乎没有影响
8:40.373–8:41.833
zh还用了一个说法
还用了一个说法
8:41.833–8:43.713
zh把灾难性的未命中
把灾难性的未命中
8:43.713–8:46.053
zh变成了优雅又便宜的降级
变成了优雅又便宜的降级
8:46.053–8:47.893
zh正因为兜底便宜
正因为兜底便宜
8:47.893–8:50.753
zh才敢把滑动窗口KV从硬盘上拿掉
才敢把滑动窗口KV从硬盘上拿掉
8:50.753–8:52.673
zh两种回放别混
两种回放别混
8:52.673–8:55.013
zh解码器回放每次独入都做
解码器回放每次独入都做
8:55.013–8:57.073
zh补的是解码器的窗口KV
补的是解码器的窗口KV
8:57.073–8:59.193
zh因为解码器从来不跑独入
因为解码器从来不跑独入
8:59.193–9:01.753
zh编码器回放只在未命中识做
编码器回放只在未命中识做
9:01.753–9:03.653
zh补的是编码器的窗口KV
补的是编码器的窗口KV
9:03.653–9:05.333
zh因为硬盘上不再存它
因为硬盘上不再存它
9:05.333–9:08.073
zh两个都只回放末尾128个
两个都只回放末尾128个
9:08.073–9:09.453
zh都基于同一个判断
都基于同一个判断
9:09.453–9:10.973
zh窗口的记忆很短
窗口的记忆很短
9:10.973–9:13.533
zh1%就是这么算出来的
1%就是这么算出来的
9:13.533–9:15.033
zh不存滑动窗口KV
不存滑动窗口KV
9:15.033–9:16.613
zh19化缓存少一半
19化缓存少一半
9:16.613–9:18.433
zh剩下的全局KV
剩下的全局KV
9:18.433–9:19.393
zh上一集讲过
上一集讲过
9:19.393–9:21.073
zh是上一代的四分之一
是上一代的四分之一
9:21.073–9:22.853
zh二分之一乘四分之一
二分之一乘四分之一
9:22.853–9:24.113
zh八分之一
八分之一
9:24.113–9:26.673
zh把三层存储放在一起看就清楚了
把三层存储放在一起看就清楚了
9:26.673–9:29.273
zh显存里放正在用的全局KV
显存里放正在用的全局KV
9:29.273–9:31.373
zh每个Token890字节
每个Token890字节
9:31.373–9:34.093
zh机器内存里放几分钟内会用的
机器内存里放几分钟内会用的
9:34.093–9:35.113
zh滑动窗口KV
滑动窗口KV
9:35.113–9:35.973
zh过期就扔
过期就扔
9:35.973–9:39.253
zh硬盘上放几天内可能会用的全局KV
硬盘上放几天内可能会用的全局KV
9:39.253–9:40.433
zh留72小时
留72小时
9:40.433–9:42.733
zh三层各管一个时间尺度
三层各管一个时间尺度
9:42.733–9:44.613
zh每一层只存它该存的
每一层只存它该存的
9:44.613–9:46.853
zh回到那个50万Token的绘画
回到那个50万Token的绘画
9:46.853–9:47.853
zh看两个时刻
看两个时刻
9:47.853–9:48.913
zh第一个时刻
第一个时刻
9:48.913–9:50.933
zh工具返回一段新内容
工具返回一段新内容
9:50.933–9:53.293
zh读入直跑编码器20层
读入直跑编码器20层
9:53.293–9:54.813
zh激活80亿参数
激活80亿参数
9:54.813–9:57.973
zh解码器要的全局KV顺手投影出来
解码器要的全局KV顺手投影出来
9:57.973–10:00.193
zh滑动窗口回放128个
滑动窗口回放128个
10:00.193–10:01.113
zh开始生成
开始生成
10:01.113–10:02.213
zh第二个时刻
第二个时刻
10:02.213–10:03.973
zh第二天用户回来接着聊
第二天用户回来接着聊
10:03.973–10:07.433
zh硬盘上取出来的只有全局KV400多兆
硬盘上取出来的只有全局KV400多兆
10:07.433–10:10.753
zh滑动窗口那份现算还是128个
滑动窗口那份现算还是128个
10:10.753–10:11.973
zh两处近似
两处近似
10:11.973–10:14.893
zh报告给的结论是性能与基线相当
报告给的结论是性能与基线相当
10:14.893–10:16.613
zh读入的计算量减半
读入的计算量减半
10:16.613–10:21.273
zh部署上还把视觉编码读入生成分成三段
部署上还把视觉编码读入生成分成三段
10:21.273–10:22.573
zh各自扩缩容
各自扩缩容
10:22.573–10:25.573
zh读入密集的agent负载可以单独加机器
读入密集的agent负载可以单独加机器
10:25.573–10:27.453
zh多轮短消息的agent绘画
多轮短消息的agent绘画
10:27.453–10:29.713
zh就是报告点名要服务的场景
就是报告点名要服务的场景
10:29.713–10:31.253
zh局限一共三条
局限一共三条
10:31.253–10:32.173
zh第一条
第一条
10:32.173–10:33.933
zh有界回放是近似
有界回放是近似
10:33.933–10:36.653
zh尤其是缓存和新内容接缝的地方
尤其是缓存和新内容接缝的地方
10:36.653–10:38.833
zh报告承认还没充分验证
报告承认还没充分验证
10:38.833–10:40.593
zh接下来要加压力测试
接下来要加压力测试
10:40.593–10:42.733
zh也要在真实负载里继续观察
也要在真实负载里继续观察
10:42.733–10:44.773
zh后两条是我自己的判断
后两条是我自己的判断
10:44.773–10:45.773
zh第二条
第二条
10:45.773–10:47.533
zh收益跟场景绑定
收益跟场景绑定
10:47.533–10:50.953
zh多轮每轮短的agent绘画收益最大
多轮每轮短的agent绘画收益最大
10:50.953–10:53.933
zh一次性为一份几十万token的长文档
一次性为一份几十万token的长文档
10:53.933–10:55.893
zh省的主要是算力那一半
省的主要是算力那一半
10:55.893–10:58.193
zh硬盘那一半的好处基本用不上
硬盘那一半的好处基本用不上
10:58.193–10:59.333
zh第三条
第三条
10:59.333–11:01.033
zh10%的内存池
10%的内存池
11:01.033–11:02.513
zh几分钟的有效期
几分钟的有效期
11:02.513–11:04.353
zh72小时的硬盘保留
72小时的硬盘保留
11:04.353–11:07.753
zh都是按Deepseek自家的线上负载掉出来的
都是按Deepseek自家的线上负载掉出来的
11:07.753–11:09.073
zh换一种负载分布
换一种负载分布
11:09.073–11:11.793
zh未命中率和回放开销都要重新测
未命中率和回放开销都要重新测
11:11.793–11:13.753
zh回到开头的问题
回到开头的问题
11:13.753–11:14.913
zh算力砍一半
算力砍一半
11:14.913–11:17.633
zh靠CED解码器的全局KV
靠CED解码器的全局KV
11:17.633–11:18.873
zh从编码器投影
从编码器投影
11:18.873–11:20.313
zh独入只跑20层
独入只跑20层
11:20.313–11:21.793
zh硬盘砍到1%
硬盘砍到1%
11:21.793–11:23.633
zh靠不存滑动窗口KV
靠不存滑动窗口KV
11:23.633–11:25.973
zh为民众就回放128个补出来
为民众就回放128个补出来
11:25.973–11:28.853
zh再乘上上一集全局KV的1%
再乘上上一集全局KV的1%
11:28.853–11:31.193
zh两件事背后是同一个判断
两件事背后是同一个判断
11:31.193–11:32.933
zh滑动窗口的记忆很短
滑动窗口的记忆很短
11:32.933–11:34.353
zh短到可以现算
短到可以现算
11:34.353–11:35.693
zh上一集的共用
上一集的共用
11:35.693–11:37.193
zh加上这一集的回放
加上这一集的回放
11:37.193–11:40.253
zh长上下文的存和算一起压了下来
长上下文的存和算一起压了下来
11:40.253–11:41.253
zh成绩还没有掉
成绩还没有掉
11:41.253–11:43.393
zh如果这一集让你有点收获
如果这一集让你有点收获
11:43.393–11:44.873
zh欢迎点赞转发
欢迎点赞转发
11:44.873–11:45.373
zh关注
关注
11:45.373–11:46.773
zh评论区也聊聊
评论区也聊聊
11:46.773–11:47.813
zh换你来做部署
换你来做部署
11:47.813–11:48.913
zh滑动窗口KV
滑动窗口KV
11:48.913–11:50.693
zh你会存硬盘保命中率
你会存硬盘保命中率
11:50.693–11:51.533
zh还是不存
还是不存
11:51.533–11:53.053
zh靠回放节省硬盘
靠回放节省硬盘
11:53.053–11:53.713
zh好
好
11:53.713–11:54.933
zh我们下期继续
我们下期继续

影片筆記:DeepSeek V4.1:40层模型,读入只跑20层?CED架构与KV Cache优化

<!-- VIDEONOTE_PUBLICATION_WARNINGS_BEGIN -->

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

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

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

<!-- VIDEONOTE_PUBLICATION_WARNINGS_END -->

一句話總結

DeepSeek V4.1 Flash 透過引入 CED(因果編碼器-解碼器)架構,在讀入階段僅計算前 20 層,後 20 層直接投影生成 KV 緩存,將計算量減半;同時結合「有界回放」機制與三層存儲架構,將滑動窗口 KV 從硬碟移至短暫記憶體池,使持久化緩存成本降至原來的 1%,在維持性能的前提下大幅降低算力與存儲開銷。

核心重點

  1. 計算優化(CED 技術):
  • 將 40 層模型分為前 20 層(編碼器)與後 20 層(解碼器)。
  • 讀入上下文(Prefill)時,僅計算前 20 層。
  • 後 20 層的 KV 緩存直接由前 20 層的輸出經投影矩陣投影而來,跳過後 20 層的計算,激活參數從 160 億降至 80 億。
  • 生成階段才使用完整 160 億參數。
  1. 存儲優化(有界回放與三層存儲):
  • 問題:舊版將滑動窗口 KV 存於硬碟,成本高且利用率低(短時間高頻後不再使用)。
  • 新架構:
  • 顯存:存放正在使用的「全局 KV」。
  • 機器記憶體池:所有機器拿出 10% 記憶體拼成池子,存放「滑動窗口 KV」,有效期僅幾分鐘,過期立即騰出。
  • 硬碟:僅存放「全局 KV」,保留 72 小時以上供長期對話。
  • 未命中處理:若記憶體池未命中,執行「有界回放」,僅回放末尾 128 個 Token 進行近似計算,而非完整重算。
  1. 成效:
  • 計算量降低約一半。
  • 持久化緩存降至原來的 1%。
  • 性能基本不受影響,特別適合 Agent 多輪短消息場景。

詳細大綱

一、 核心問題與目標

  • 背景:承接上一集關於 DeepSeek V4.1 Flash 降低 KV Cache 存儲開銷的討論。
  • 目標:減少「脫離計算」(Prefill/讀入階段)與「緩存成本」。
  • 核心手段:
  1. 重新計算上下文時,只計算前一半層數,後一半直接套用已有結果。
  2. 部分短期緩存不再長期保存,改為需要時重新計算。
  • 預期成果:
  • 計算量降低約一半。
  • 持久化緩存降至原來的 1%。
  • 性能基本不受影響。

二、 為什麼只計算一半層數足夠?(CED 技術解析)

  • 場景痛點:
  • Agent 修補 Bug 時,上下文堆積至 50 萬 Token。
  • 每次工具調用返回結果接入上下文,模型需重新讀入(Prefill)。
  • 若緩存未命中,整段 50 萬 Token 需重算 40 層,算力與存儲壓力巨大。
  • CED (Causal Encoder-Decoder) 設計:
  • 將 40 層模型分為前後兩半:
  • 前 20 層(編碼器):負責讀入上下文。
  • 後 20 層(解碼器):負責生成。
  • 關鍵機制:解碼器所需的 KV 緩存,直接從編碼器的輸出經過「投影矩陣」投影而來。
  • 優勢:讀入新內容時,後 20 層無需計算,直接投影得到全局 KV。
  • 與 Yoko 論文的区别:
  • Yoko 論文:後半層共用同一份 KV,信息容量少。
  • V4.1 改進:
  1. 投影矩陣可逐層不同,每層擁有獨立 KV,容量更大。
  2. 滑動窗口部分不投影,每層自行計算,保留局部信息深度。
  • 計算節省:
  • 讀入階段:僅跑前 20 層,激活參數從 160 億降至 80 億。
  • 生成階段:才使用完整的 160 億參數。

三、 為什麼重新計算比一直存緩存更划算?(滑動窗口處理)

  • 問題來源:
  • 解碼器在讀入階段未運行,導致其「滑動窗口 KV」為空。
  • 生成第一個 Token 時,需使用前 128 個 Token 的窗口 KV。
  • 若精確補齊,需回溯至第 20 層對應的 2560 個 Token 前開始重算(因層層疊加視野)。
  • 對 Agent 多輪短消息場景,回溯 2560 個 Token 開銷過大。
  • 解決方案:滑動窗口有界回放 (Bounded Replay)
  • 策略:不回退 2560 個,僅回退末尾 128 個 Token。
  • 執行:將這 128 個 Token 的編碼器輸出送進解碼器跑一遍。
  • 開銷:128 個 Token × 20 層,相較於 50 萬 Token 可忽略不計。
  • 視野限制:窗口僅在 128 個 Token 內查看,更遠處信息由全局分支處理。
  • 有效性驗證:
  • 參考 *PowerAttention* 研究:遠處信息經層層傳遞已衰減至可忽略,窗口僅負責眼前段。
  • 後訓練階段已模擬此近似行為,實測幾乎不掉點。

四、 硬碟緩存成本為何降至 1%?

  • V4 舊版存儲模式:
  • 全局 KV:整段存儲,若新請求開頭匹配則整段復用。
  • 滑動窗口 KV:不整段存,僅存提示詞末尾與回答末尾各 128 個 Token。
  • 淘汰機制:最久未使用先刪除。
  • 問題:滑動窗口 KV 佔持久化緩存近一半,且訪問模式為「短時間高頻使用後不再使用」,存入保留 72 小時的硬碟中「又貴又沒用」。
  • V4.1 新存儲架構(三層存儲):
  1. 顯存:存放正在使用的「全局 KV」(每 Token 890 字節)。
  2. 機器記憶體池:
  • 所有機器拿出 10% 記憶體拼成池子(非顯存)。
  • 存放「滑動窗口 KV」。
  • 有效期僅幾分鐘,過期立即騰出服務新繪畫。
  • 處理高周轉負載,服務大多數進行中的繪畫。
  1. 硬碟:
  • 僅存放「全局 KV」。
  • 保留 72 小時以上,供多日後用戶回來繼續對話。
  • 未命中處理:
  • 若記憶體池未命中(滑動窗口已過期),執行「有界回放」。
  • 僅回放末尾 128 個 Token 補齊窗口 KV。
  • 報告稱此近似對回答質量影響極小,將「災難性未命中」轉化為「優雅且便宜的降級」。

五、 總結與局限

  • 成本計算邏輯:
  • 滑動窗口 KV 不存硬碟 → 持久化緩存減少一半。
  • 剩餘全局 KV 為上一代的 1/4(基於上一集共用機制)。
  • 總持久化緩存 = 1/2 × 1/4 = 1/8(約 12.5%,報告稱降至 1% 可能包含其他壓縮或特定定義,但筆記依逐字稿記錄為「降到原来的1%」與「八分之一」的推導)。
  • 場景適配:
  • 收益最大於「多輪每輪短」的 Agent 繪畫場景。
  • 對於一次性幾十萬 Token 的長文檔,僅節省算力一半,硬碟節省效益有限。
  • 局限性:
  1. 有界回放是近似值,尤其在緩存與新內容接縫處,尚需壓力測試與真實負載觀察。
  2. 收益與場景綁定,長文檔場景硬碟節省效益低。
  3. 記憶體池比例(10%)、有效期(幾分鐘)、硬碟保留(72小時)均基於 DeepSeek 自家線上負載調優,換其他負載分布需重新測試未命中率與回放开銷。

工具 / 模型 / 名詞整理

  • 模型/版本:DeepSeek V4.1 Flash、DeepSeek V4、DeepSeek
  • 技術/機制名稱:
  • KV Cache (KV 緩存)
  • Prefill (脫離計算/讀入階段)
  • CED (Causal Encoder-Decoder,因果編碼器-解碼器)
  • Yoko (2024年論文名稱)
  • PowerAttention (研究/工作名稱)
  • 滑動窗口 (Sliding Window)
  • 全局分支 / 局部分支
  • 有界回放 (Bounded Replay)
  • Zero SWA Catching (V4 報告提及的概念)
  • 後訓練 (Post-training)
  • 稀疏注意力 (Sparse Attention)
  • MLA、MOE、ROPE、GRPO、VLLM、SGLAN (提及的相關技術或工具)
  • 其他專有名詞:
  • Agent
  • Token
  • 顯存 (VRAM)
  • 硬碟 (Hard Disk)
  • 記憶體池 (Memory Pool)

操作流程整理

  1. 讀入階段 (Prefill):
  • 輸入上下文(如 50 萬 Token)。
  • 僅計算前 20 層(編碼器)。
  • 將前 20 層輸出經投影矩陣投影,直接生成後 20 層(解碼器)所需的 KV 緩存。
  • 跳過後 20 層的實際計算,降低激活參數需求。
  1. 生成階段:
  • 使用完整的 160 億參數模型進行生成。
  • 若為新請求且無緩存命中,執行上述讀入流程。
  1. 緩存管理與未命中處理:
  • 全局 KV:存於顯存(使用中)或硬碟(長期保留 >72小時)。
  • 滑動窗口 KV:
  • 優先從機器記憶體池(10% 總記憶體)讀取,有效期僅幾分鐘。
  • 若記憶體池未命中(過期):
  • 執行「有界回放」:僅回放末尾 128 個 Token 的編碼器輸出。
  • 將這 128 個 Token 送進解碼器跑一遍,補齊窗口 KV。
  • 此操作開銷極小,視為對回答質量影響極小的近似降級。

值得注意的限制或風險

  1. 近似計算的準確性:有界回放僅回放末尾 128 個 Token,屬於近似值。尤其在緩存與新內容接縫處,尚需壓力測試與真實負載觀察以確認是否影響回答質量。
  2. 場景綁定性:該架構收益最大於「多輪每輪短」的 Agent 場景。對於一次性幾十萬 Token 的長文檔,僅節省算力一半,硬碟節省效益有限。
  3. 參數調優依賴:記憶體池比例(10%)、有效期(幾分鐘)、硬碟保留(72小時)均基於 DeepSeek 自家線上負載調優。若換其他負載分布,需重新測試未命中率與回放开銷。
  4. 數值一致性疑點:筆記中記錄報告稱持久化緩存降至 1%,但推導邏輯為 1/2 × 1/4 = 1/8 (12.5%),兩者存在顯著數值差異,需確認是否包含其他壓縮機制或定義差異。

逐字稿辨識疑點

  • SGLAN / 固鼓鼠:逐字稿中提到「VLLM SGLAN 固鼓鼠」,聽寫可能為「SGLang」或其他工具名稱,但依規則標為疑點,不自行更正。
  • 獨入:逐字稿多次使用「獨入」,結合上下文應指「讀入」或「Prefill」,但依規則保留原詞或標註為聽寫疑點。
  • 繪畫:逐字稿中多次出現「繪畫」(如「正在進行的繪畫」、「多輪短消息的 agent 繪畫」),結合 Agent 與上下文場景,疑為「對話」或「會話」的聽寫錯誤,但依規則標為疑點。
  • 負層:逐字稿提到「真正做投影的是解碼器那一個負層」,疑為「最後一層」或「特定層」的聽寫錯誤,標為疑點。
  • 1% 與 八分之一:逐字稿結論提到「持久化缓存降到原来的1%」,但後文推導為「二分之一乘四分之一 八分之一」。若 1/8 等於 12.5%,則與 1% 有顯著數值差異,此處依規則僅記錄原文,不判斷是否為口誤。

可延伸追問

  1. CED 架構中,投影矩陣逐層不同的具體訓練方法為何?如何確保投影後的 KV 與直接計算的 KV 足夠接近?
  2. 「有界回放」中,僅回放 128 個 Token 的理論依據是什麼?若上下文長度遠超此範圍,衰減效應是否仍成立?
  3. 機器記憶體池的 10% 比例是如何確定的?若負載模式改變(如長文本比例增加),該比例是否需要動態調整?
  4. 報告中提到的 1% 緩存成本與推導的 1/8 (12.5%) 之間的差異具體來自哪些壓縮技術或定義調整?

尚未產生學習筆記

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