大版和 Flash 版 左边写着 DeepSeek V4 两个版本每个 token 激活的参数：Pro 49B，Flash 13B。右边是两摞叠起来的层，左边一摞又高又宽，右边一摞矮而窄，每层只亮起少数几个专家，旁边一道闪电。 每个 token 激活 Pro49B Flash13B 层 61 → 43 宽 7168 → 4096 专家 384 → 256

打开 Google 的 Gemini 价目表1，同一代模型分成三档：3.1 Pro 每输出一百万个 token 收 12 美元，3.8 Flash 收 3.75 美元，3.1 Flash-Lite 只收 1.5 美元。国内也一样：DeepSeek 有 V4-Pro 和 V4-Flash，智谱有 GLM-4.7 和 GLM-4.7-Flash，小米和阶跃干脆直接把新模型叫 MiMo-V2-Flash、Step-3.5-Flash。

价钱差好几倍，名字只差一个词。于是很自然地会问：Flash 版到底是什么？是把大模型压缩了一下，还是层数少了？它和常听到的 FlashAttention 有没有关系？便宜这么多，丢掉的又是什么？

这篇文章先把名字理清，再从“模型每生成一个字要花什么”出发，看 Flash 版在哪几处下刀，以及每一刀的代价。

一、名字里的 Flash 指什么

和 FlashAttention 没有关系

先排除一个常见的误会。FlashAttention 是 2022 年 Tri Dao 等人发表的一种计算方法2：它把注意力（后面第四节会讲注意力是什么）拆成小块在 GPU 的高速缓存里算完，省掉了来回读写显存的时间。它算出来的结果和普通算法一个数都不差，只是更快、更省显存。今天几乎所有模型，不论大版小版，推理时都在用它或类似的实现。

所以 FlashAttention 是“同一道题换个快的算法”，而模型名里的 Flash 是产品档位，意思是“快、便宜的那一档”。两者同名，不是一回事。

各家 Flash 和大版的关系不一样

既然是档位名，每家怎么做出这一档，就各不相同。把各家公开的材料摆在一起，大致有四种关系：

各家的 Flash 版和它对应的大版
Flash 型号对应的大版两者是什么关系公开到什么程度
闭源：只能看官方怎么说
Gemini 1.5 Flash1.5 Pro从 Pro 在线蒸馏技术报告写明
Gemini 2.5 Flash、Flash-Lite2.5 Pro全家都是稀疏 MoE；Flash 及更小的用蒸馏技术报告写明，参数量不公开
Gemini 3 Flash、3.1 Flash-Lite、3.5–3.8 FlashGemini 3 Pro“based on Gemini 3 Pro”模型卡只有这一句
开源：配置文件可以逐项核对
DeepSeek V4-Flash
284B · 激活 13B		V4-Pro
1.6T · 激活 49B		同一套设计整体缩小，各自独立预训练权重、配置、技术报告
GLM-4.7-Flash
30B · 激活 3B		GLM-4.7
355B · 激活 32B		同代小号，注意力换了一种权重、配置
Qwen3-Coder-Flash
30B · 激活 3B		Qwen3-Coder
480B · 激活 35B		同代小号（Flash 是聊天界面里的名字）权重、配置
MiMo-V2-Flash、Step-3.5-Flash没有Flash 是整个模型的定位：快权重、配置、技术报告

B 表示十亿（billion）个参数，T 表示万亿；“激活”的意思第三节会讲。

表 1 · 同样叫 Flash，各家和大版的关系并不一样

表里有的 Flash 只是个显示名，比如 Qwen3-Coder-Flash 就是开源的 Qwen3-Coder-30B-A3B3。这张表已经回答了一半问题：Flash 不是一种固定的技术，各家用了不同的组合。但这些组合里反复出现几个手法：更少的激活参数、更省的注意力、一次多猜几个 token、蒸馏。要看懂它们分别省的是什么，得先知道一次回答的成本花在了哪。

二、一次回答的成本花在哪

模型是一个字一个字往外吐的

大模型处理的单位叫 token，可以粗略理解成“一个字或半个词”。模型回答问题时并不是一下子写出整段话，而是每次只生成一个 token，把它接到末尾，再生成下一个。一段 500 字的回答，就要这样循环几百次。API 按 token 收钱，也是这个原因。

模型内部是几十层叠起来的计算，每一层主要有两个部件：

  • 注意力：让当前这个 token 回头看前面所有 token，决定该参考谁。
  • 前馈网络：对每个 token 做同样的一串乘法和加法。

这些乘法里用到的系数，就是模型的参数（也叫权重）。比如 y=0.8x1−0.5x2+0.1y = 0.8x_1 - 0.5x_2 + 0.1 里的 0.8、−0.5、0.1 就是三个参数。训练就是把这些系数一点点调对，模型“知道的东西”就存在它们里面。一个大模型有几百亿到上万亿个这样的数。模型里的每个 token 也用一串数字表示，叫向量，这串数字的长度叫模型的宽度。

每生成一个 token，都要把两样东西读一遍

这两个部件决定了生成一个 token 要从显存里读出多少数据：

生成一个 token 要读的两样东西 左边以 Qwen3-32B 为例：每层要读前馈和注意力的权重，以及前文所有 token 的 KV 缓存；64 层加起来，权重约 64 GB，12.8 万 token 前文的 KV 缓存约 32 GB，H100 每秒读 3.35 TB，所以单个用户每秒最多生成约 35 个 token。右边对比四个模型在同样前文下每个 token 要读的权重和 KV 缓存：Qwen3-32B 64 加 32 GB，GLM-4.7 65.8 加 46 GB，GLM-4.7-Flash 7.2 加 6.6 GB，MiMo-V2-Flash 29.6 加 2.8 GB。 Qwen3-32B 生成 1 个 token 每一层要读的 共 64 层 前馈网络的权重3 × 5120 × 25600 注意力的权重约 0.5 亿个参数 KV 缓存（历史）8 头 × 128 × 2 × 前文 64 层加起来 每个数 2 字节 权重320 亿参数 ≈ 64 GB KV 缓存，前文 12.8 万≈ 32 GB H100 每秒能读3.35 TB 单个用户最快约 35 token/秒 权重每个 token 都一样；KV 缓存随前文变长。 多个用户可以共读一次权重，KV 缓存各读各的。 同样 12.8 万 token 前文，每个 token 读多少 Qwen3-32B稠密 权重 64 GB + KV 32 GB GLM-4.7大版 权重 65.8 GB + KV 46 GB GLM-4.7-FlashFlash 权重 7.2 GB + KV 6.6 GB MiMo-V2-FlashFlash 权重 29.6 GB + KV 2.8 GB 权重按每 token 激活的参数算（第三节）。 GLM-4.7-Flash 读的总量约为大版的 1/8。
图 1 · 每生成一个 token，都要把激活的权重和全部历史读一遍；Flash 版在这两样上都少读

一是权重。 每生成一个 token，都要拿用到的全部参数参与一次计算，也就是把它们从显存读到计算单元里。以阿里开源的 Qwen3-32B 为例4，它有 320 亿个参数，每个参数占 2 个字节，生成一个 token 就要读约 64 GB。

二是历史。 注意力要回头看前面所有 token，所以每个 token 算过之后会留下一份“备查资料”存在显存里，叫 KV 缓存（第四节细讲）。上下文越长，这份资料越多。Qwen3-32B 在 12.8 万个 token 的上下文里，KV 缓存有 32 GB，每生成一个新 token 都要把它从头到尾读一遍。

GPU 每秒能读的数据量（叫显存带宽）是有上限的，一块 H100 大约每秒 3.35 TB。一个 token 要读将近 100 GB，单个用户一秒钟最多也就生成三十几个 token。服务商可以把很多用户的请求拼在一起算，让读一次权重服务多个人，但每个人自己那份 KV 缓存还是各读各的。

所以，想让模型又快又便宜，能下刀的地方就是这几处：

  1. 每个 token 少读一点权重；
  2. 每个 token 少读一点历史；
  3. 读一遍能多出几个 token；
  4. 前三刀砍下去模型会变笨，要想办法把本事补回来。

下面四节就按这四个目的来看 Flash 版是怎么做的。

三、少读权重：小一号的骨架和稀疏的专家

不改会怎样

最直接的办法是把模型整体做小：层数少一点，每层窄一点。参数少了，读得就少。问题是模型的知识和能力大体随参数量增长，直接做小，模型就变笨。

那有没有办法让模型“存”的参数多，每个 token“用”的参数少？

稀疏专家：存得多，用得少

这就是混合专家（Mixture of Experts，简称 MoE）5。它把每层的前馈网络拆成很多份小的前馈网络，叫专家；前面放一个小小的路由器，对每个 token 打分，只挑分数最高的几个专家来算，其余专家这一次完全不碰。

于是一个 MoE 模型有两个参数量：总参数（所有专家加起来，决定模型能装多少知识）和激活参数（每个 token 实际用到的，决定每个 token 要读多少）。模型名里的 “30B-A3B” 就是“总共 300 亿、每次激活 30 亿”的意思。

我们用 Python 的数值计算库 numpy 写了一层前馈网络做实验，宽度 2048，比较三种做法每生成一个 token 的耗时：

MoE 每个 token 只读选中的专家 左边：一层宽 2048 的前馈网络，生成一个 token 的耗时。1.5 GB 的稠密网络 42.4 毫秒；同样 1.5 GB 拆成 64 个专家、每次选 4 个的 MoE 3.8 毫秒；0.09 GB 的小稠密网络 2.7 毫秒。右边：一批里 token 越多，用到的专家越多，1 个 token 用 4 个，64 个 token 用到 63 个。 每生成 1 个 token 的耗时（一层前馈，batch=1） 大的稠密 1.5 GB，全读 42.4 ms MoE：64 个专家选 4 个 共 1.5 GB，只读 0.09 GB 3.8 ms 小的稠密 0.09 GB，全读 2.7 ms MoE 存的和大网络一样多，耗时却接近小网络。 一批 token 一共用到几个专家 640 4 1 15 4 44 16 63 64 64 256 一批里的 token 数
图 2 · MoE 的每 token 开销跟着激活参数走；但一批 token 多了，几乎每个专家都会被用到

大的稠密网络有 1.5 GB 参数，每个 token 要 42 毫秒；把同样 1.5 GB 拆成 64 个专家、每次只选 4 个，耗时降到 3.8 毫秒，和只有 0.09 GB 的小稠密网络（2.7 毫秒）差不多。MoE 的每 token 开销跟着激活参数走，而不是总参数。

Google 在 Gemini 2.5 的技术报告里明说，整个 2.5 家族（Pro、Flash、Flash-Lite）都是稀疏 MoE，理由正是“把模型的总容量和每个 token 的计算、服务成本脱钩”6。Gemini 3 Pro 的模型卡也写着稀疏 MoE7。也就是说，MoE 本身不是 Flash 独有的，大版也是 MoE。

Flash 版在 MoE 上再缩一圈

那 Flash 和大版的差别在哪？看开源模型的配置文件就清楚了。下表的数字是我们从 Hugging Face 上的 config.json 逐层数出来的，和官方公布的参数量对得上：

大版和 Flash 版的配置
项目V4-ProV4-FlashGLM-4.7GLM-4.7-Flash
层数61439247
宽度（每个 token 的向量长度）7168409651202048
专家：共几个，每次选几个384 选 6 +1256 选 6 +1160 选 8 +164 选 4 +1
注意力压缩注意力压缩注意力GQAMLA
总参数1.6T284B353B29.9B
每 token 激活参数49B13B32.9B3.6B

“+1”是每个 token 都会用到的共享专家。DeepSeek 的参数量用官方数字；GLM 两列是我们按 config.json 数出来的主干参数（官方写 355B/32B、30B/3B）。

表 2 · Flash 版仍是 MoE，但层数、宽度、专家数都缩了一圈

DeepSeek V4 的两个版本用的是同一套设计：同样的注意力、同样“每个 token 选 6 个专家再加 1 个共享专家”，只是 Flash 层数从 61 降到 43，宽度从 7168 降到 4096，专家从 384 个降到 256 个8。激活参数从 490 亿降到 130 亿，约为四分之一。智谱的 GLM-4.7-Flash 缩得更狠910：层数减半，宽度降到 2048，每次只选 4 个专家，激活参数只剩大版的九分之一左右。

所以第一刀的答案是：Flash 版仍是 MoE，但整体缩小了一号，尤其是激活参数。总参数也跟着缩，这是代价的来源，第六节再讲。

每个参数也可以存得更小

还有一种少读的办法：每个参数少占几个字节。参数本来用 2 个字节（16 位）存，DeepSeek V4 把专家参数压到 4 位（半个字节）、其余压到 8 位8，要读的数据量直接少了一大半。不过 V4-Pro 的配置里专家也是 4 位，这一刀大版小版一起砍，不是 Flash 的区别。

MoE 的省，主要省给单个用户

实验里还有一个现象值得一提。服务商会把很多用户的 token 拼成一批一起算，而不同 token 选中的专家不一样。我们统计了一批 token 一共用到多少个专家：1 个 token 用 4 个，16 个 token 就用到 44 个，64 个 token 几乎把 64 个专家全用上了。批越大，每次要读的权重越接近全部参数，MoE“少读”的优势越小，剩下的主要是“少算”。这也是为什么 Flash 版不只缩专家，还要在下一处——历史——上下功夫：历史是每个用户各读各的，拼批省不掉。

四、少读历史：KV 缓存的几种省法

注意力为什么要存历史

先说注意力在做什么。读到“他把苹果给了她，因为她饿了”，模型要知道“她”指谁，就得回头看前面的字。做法是：每个 token 生成一个“我想找什么”的向量，叫 Q（query，查询）；前面每个 token 各有一个“我是什么”的向量 K（key，键）和一个“我能提供什么”的向量 V（value，值）。Q 和每个 K 比一比相似度，越相似的那个 token，它的 V 就占越大的比重，加权平均后就是注意力的结果。

前面 token 的 K 和 V 不会变，所以算一次就存起来，后面每个新 token 都来查，这就是 KV 缓存。它的大小是：

KV 缓存=层数×上下文长度×(每个 token 每层存的 K、V 数字个数)×每个数字的字节数\text{KV 缓存} = \text{层数} \times \text{上下文长度} \times (\text{每个 token 每层存的 K、V 数字个数}) \times \text{每个数字的字节数}

层数和上下文长度没法随便减，能动的是中间那一项：每个 token 每层存多少，以及要不要真的存“全部”上下文。

第一次尝试：多个头共用一份 K、V

注意力通常分成很多个“头”并行地找不同的东西（有的头找指代、有的头找语法）。最早的做法（多头注意力，MHA）是每个查询头各配一份 K、V。分组查询注意力（GQA）11让几个查询头共用一份 K、V，比如 32 个查询头只配 8 份，KV 缓存就降到四分之一。Qwen3、GLM-4.7、Gemma 3 都用 GQA，它已经是标配，大版小版都有。

但 GQA 只是把常数变小，上下文翻一倍，缓存照样翻一倍。到了几十万、上百万 token 的上下文，还是太大。

再往前：压缩，或者干脆不看那么远

接下来的几种做法，就是 Flash 型号之间拉开差距的地方。我们把四种存法画在一起：

KV 缓存的五种存法 五行分别是 MHA、GQA、MLA、滑动窗口和压缩注意力。MHA 每个 token 每层存 8192 个数；GQA 让 4 个查询头共用一份，存 2048 个；MLA 把 K、V 压成 576 个数；滑动窗口只保留最近一段 token，更早的不存；压缩注意力把几个 token 合成一条存。 每个前文 token 在一层里存什么（12 格代表最近的 12 个 token） MHA每个查询头一份 K、V 32 × 128 × 2 = 8192 个数 GQA4 个查询头共用一份 8 × 128 × 2 = 2048 个数 MLAK、V 压成一个小向量 512 + 64 = 576 个数 滑动窗口只留最近一段 窗口外的 token 不存 压缩注意力几个 token 压成一条 每 4 个（或 128 个）存一条 格子高度代表存的数字多少（示意）；虚线格是窗口外、已经不存的 token。
图 3 · 前三种让每个 token 存得越来越少；后两种让远处的 token 不存或合并着存，缓存不再跟着前文同比例变大
  • 多头潜在注意力（MLA）：DeepSeek-V2 提出12。不直接存 K、V，而是把它们压成一个 512 维的小向量存下来，用的时候再还原。GLM-4.7 用的是 GQA，GLM-4.7-Flash 却换成了 MLA10，这是 Flash 版并非“等比例缩小”的一个例子。
  • 滑动窗口：大部分层只看最近的一小段（MiMo-V2-Flash 是 128 个 token，Step-3.5-Flash 是 512 个），每隔几层才放一层能看全部的“全局层”1314。窗口层的缓存不随上下文增长。谷歌开源的 Gemma 3 也是 5 层窗口配 1 层全局15。
  • 压缩注意力：DeepSeek V4 把远处的历史按 4 个或 128 个 token 一组压成一条，再配一个小窗口保留最近的原样16。官方说，在 100 万 token 的上下文里，V4-Pro 的 KV 缓存只有上一代 V3.2 的 10%。

我们同样用 numpy 测了一层注意力，32 个查询头，看上下文从 1 千涨到 6.5 万时，每生成一个 token 要多久：

注意力的耗时随前文变长 横轴是前文长度，从 1K 到 64K token；纵轴是一层注意力生成一个 token 的耗时，对数刻度。MHA 从 11.7 毫秒涨到 1266 毫秒，GQA-8 从 2.0 涨到 209，GQA-4 从 1.6 涨到 134，5 层滑动窗口加 1 层全局的混合只从 0.44 涨到 21.5 毫秒。 一层注意力，生成 1 个 token 的耗时（毫秒，纵轴每格 10 倍） 0.1 1 10 100 1000 1K 4K 16K 64K 前文长度（token） MHA（32 份 K、V） 1266 ms · 1024 MB GQA（8 份） 209 ms · 256 MB GQA（4 份） 134 ms · 128 MB 5 层窗口 + 1 层全局 22 ms · 22 MB
图 4 · GQA 只是把整条线往下平移；滑动窗口让大部分层不再随前文变慢

MHA 随上下文线性变慢，6.5 万 token 时一层就要 1.3 秒；GQA 把它降到几分之一，但还是线性增长；5:1 的窗口混合（MiMo 的做法）只剩 21 毫秒，因为六层里只有一层的开销随上下文增长。

拿真实模型的配置算一下，差距就更具体了（12.8 万 token 上下文，每个数字 2 字节）：

12.8 万 token 前文时，一个请求的 KV 缓存有多大
模型注意力每个 token（KB）12.8 万 token
大版和稠密模型
Qwen3-32B（稠密）GQA，8 份25632 GB
GLM-4.7GQA，8 份36846 GB
DeepSeek-V3MLA68.68.6 GB
Flash 版和同级小模型
Qwen3-30B-A3BGQA，4 份9612 GB
GLM-4.7-FlashMLA52.96.6 GB
Step-3.5-Flash3 层窗口（512）+ 1 层全局48.56.1 GB
MiMo-V2-Flash5 层窗口（128）+ 1 层全局22.72.8 GB

按 config.json 计算，每个数 2 字节；带窗口的模型按 12.8 万 token 时的平均值算。DeepSeek V4 的压缩注意力结构较复杂，这里没有估，只引官方的相对数字。

表 3 · Flash 型号普遍换了更省的注意力，同样的前文，缓存小到大版的几分之一

同样是三四十亿激活参数，GLM-4.7-Flash 因为用了 MLA，KV 缓存只有 Qwen3-30B-A3B 的一半多；MiMo-V2-Flash 总参数是它们的十倍，靠滑动窗口把缓存压到了 2.8 GB，比 GLM-4.7 大版少了 94%。

代价：远处看得没那么清楚

窗口和压缩都是有损的：窗口层看不到远处，只能指望那几层全局层；压缩层看到的是一组 token 的“摘要”。所以这些模型都不敢把全局层全去掉。代价体现在需要从超长上下文里精确找回信息的任务上：在 DeepSeek 自己公布的 100 万 token 多轮检索测试（MRCR）里，V4-Flash 得 78.7 分，V4-Pro 得 83.5 分8。

五、少走几步：一次猜几个 token

不改会怎样

前两节都是让“每一步”更便宜，但步数没变：500 个 token 的回答还是要走 500 步，而且必须一步接一步，后一步要等前一步的结果。对单个用户来说，等待时间就是步数乘以每步的时间。

先猜后验

多 token 预测（MTP）在模型最后加几层小小的“草稿头”，让模型在生成当前 token 时顺便猜出后面几个。下一步主模型一次性把这几个猜测一起检验：猜对的直接收下，从第一个猜错的地方重新来。这个“先打草稿再一次性验证”的思路叫投机解码17，DeepSeek-V3 把 MTP 做进了模型本身18。

多 token 预测：先猜后验 上面是普通生成：return、a、加号、b 四个 token 分四步生成。下面是多 token 预测：第 1 步生成 return，同时草稿头猜出 a、加号、c；第 2 步一次检验这三个猜测，a 和加号对了直接收下，c 错了改成 b，两步出了四个 token。 普通生成：每读一遍权重，出 1 个 token 第 1 步"return" 第 2 步" a" 第 3 步" +" 第 4 步" b" 4 个 token 走 4 步，每一步都要等上一步出结果。 每一步都把激活的权重完整读一遍。 多 token 预测：先猜后验 第 1 步"return" 草稿头猜： " a" " +" " c" 第 2 步：一次检验 3 个猜测 " a" ✓ " +" ✓ " c" ✗ 改成 " b" 检验 3 个和生成 1 个，读的是同一遍权重。 猜对的直接收下，从第一个猜错处改正。 结果：2 步出了 4 个 token。虚线框是猜错、被丢掉的草稿。
图 5 · 读一遍权重能检验好几个猜测，猜对多少就省下多少步

关键在于：主模型检验 4 个 token 和生成 1 个 token，要读的权重是同样的一遍。猜对得越多，每读一遍权重产出的 token 就越多。

谁在用

DeepSeek V4 的 Pro 和 Flash、GLM-4.7 和 GLM-4.7-Flash 的配置里都带 1 层 MTP，所以这也不是 Flash 独有。把它用得更重的，是那些整个定位就是“快”的型号：MiMo-V2-Flash 带了 3 层 MTP，官方说输出速度约为原来的 3 倍13；Step-3.5-Flash 用 MTP-3 一次前向出 4 个 token，典型速度每秒 100 到 300 个 token14。

代价

草稿头本身要算，猜错的部分白算了。代码、格式化输出这类好猜的内容收益大，开放式写作收益小。还要推理框架支持，比如 Step-3.5-Flash 的模型卡就提到，当时 vLLM 还没完整支持它的 MTP-3。

六、小了还不能太笨：蒸馏

不改会怎样

前三刀砍下去，模型的参数少了、看历史看得粗了。如果小模型和大模型用同样的方法训练，它就是一个普通的小模型，能力差一截。Flash 版要的是“小，但尽量像大版那么聪明”。

让大模型当老师

普通的训练方式是：给模型一段文字，让它猜下一个字，标准答案就是文字里实际出现的那个字，其余字一律算错。

知识蒸馏19换了一种答案：先让大模型（老师）看同一段文字，给出它对下一个字的整个概率分布，比如“猫 60%、狗 25%、兔 8%……”，再让小模型（学生）去学这个分布。这样学生不只知道正确答案是什么，还知道“狗也说得通、兔子勉强、汽车完全不对”。一条训练样本带的信息多了很多。

存整个分布太贵（词表有十几万个词，每个位置都存十几万个概率），所以 Gemini 2.5 只存老师概率最高的 k 个词（k-sparse），代价是训练数据的存储和吞吐变成原来的 k 倍6；Gemma 3 是每个位置采样 256 个词15。

我们做了一个小实验来看蒸馏到底有多大用。设一个“老师”给出 256 个词上的概率分布，让一个容量小得多的“学生”分别用三种答案去学：普通答案（按老师的分布抽一个词当标准答案）、老师前 k 个词的概率、老师的完整分布。然后在没见过的上下文上量学生和老师有多像。衡量的尺子叫 KL 散度：学生给每个词的概率和老师的越接近，它就越小，完全一样时为 0。实验同样用 numpy 写成，学生的“脑容量”故意做得比老师小，模拟 Flash 和大版的关系：

蒸馏：学老师的整个分布 左边是同一个空的三种答案：普通答案只有“狗”一个字；老师前 2 个只保留猫和狗的概率；完整分布给每个字一个概率。右边是实验：横轴训练样本数，纵轴学生和老师的 KL 散度。100 条样本时普通答案 1.74、前 8 个 1.74、完整分布 0.96；300 条样本时普通答案 1.74、前 8 个 1.74、完整分布 0.78；1000 条样本时普通答案 1.74、前 8 个 1.41、完整分布 0.66；3000 条样本时普通答案 1.74、前 8 个 1.02、完整分布 0.61；10000 条样本时普通答案 0.86、前 8 个 0.87、完整分布 0.59；30000 条样本时普通答案 0.67、前 8 个 0.84、完整分布 0.59。 “我家养了一只___”的三种答案（示意） 普通答案语料里实际出现的那个字 猫 狗 兔 鸟 鱼 老师前 2 个只存最大的 k 个，重新归一 猫 狗 兔 鸟 鱼 老师的完整分布每个字都有一个概率 猫 狗 兔 鸟 鱼 完整分布还告诉学生：狗也说得通，鱼不太像。 学生和老师差多少（KL 散度，越小越像） 0 1 2 100 300 1,000 3,000 10,000 30,000 训练样本数 均匀瞎猜 1.72 普通答案 老师前 8 个 完整分布 300 条完整分布（0.78）胜过 10,000 条普通答案（0.86）。
图 6 · 同样多的样本，学老师的完整分布比学普通答案像得多；只存前几个会丢掉一部分好处

用普通答案时，100、300 乃至 3000 条样本，学生都没学到东西：KL 一直停在 1.74，和“每个词概率都一样”的瞎猜没有区别，再往下训只会把训练样本死记下来（这叫过拟合），对没见过的上下文反而更差。要到 1 万条，它才开始像老师。

用老师的完整分布，100 条就降到 0.96；300 条时的 0.78，已经好过普通答案 1 万条时的 0.86。一条带完整分布的样本，抵得上几十条普通样本。

只存前 k 个词的做法介于两者之间。存前 32 个和完整分布差不多；只存前 8 个，样本少时帮助很大，样本多了反而不如普通答案（3 万条时 0.84 对 0.67），因为被截掉的那些小概率词，学生永远学不到。k 取多大，就是在“存储变成 k 倍”和“学得像不像”之间取舍。

谁在蒸馏

Google 写得最明白：Gemini 1.5 Flash 从 1.5 Pro 在线蒸馏而来20，2.5 代“Flash 及更小的模型”都用蒸馏6。Gemini 3 之后的模型卡只写“based on Gemini 3 Pro”21，没有再说怎么来的。

但蒸馏也不是 Flash 专属。DeepSeek V4 的两个版本是各自在 32 万亿以上的 token 上独立预训练的，官方没有说 Flash 是从 Pro 蒸馏出来的；两者后训练都用了“先训几个领域专家模型，再在线蒸馏合成一个”的方法8。小米 MiMo-V2-Flash 的后训练也是多教师在线蒸馏13。

代价：老师教得会推理，教不会记忆

蒸馏能把“怎么想”传下去，但“记住多少事”还是受学生的总参数限制。DeepSeek V4 的跑分很能说明问题：

DeepSeek V4：Flash 和 Pro 的跑分（最高推理档）
测试考什么FlashPro差
推理、数学、代码
MMLU-Pro多学科综合题86.287.51.3
GPQA Diamond研究生难度理科题88.190.12
LiveCodeBench编程竞赛题91.693.51.9
SWE-bench Verified修真实仓库的 bug79.080.61.6
记忆和长任务
SimpleQA-Verified冷门事实问答34.157.923.8
Terminal Bench 2.0自主操作终端完成任务56.967.911
MRCR 1M百万 token 里找回细节78.783.54.8

数字来自 DeepSeek-V4-Flash 模型卡，均为官方自测。

表 4 · 推理题只差一两分，记忆题差了 24 分

推理、数学、代码这类题，Flash 和 Pro 只差一两分；考事实知识的 SimpleQA 却差了 24 分，需要长时间自主操作终端的 Terminal Bench 差了 11 分。总参数从 1.6 万亿降到 2840 亿，丢掉的主要是记忆，而不是推理。

七、Flash 版到底差在哪

回到开头

现在可以回答开头的问题了。Flash 和 FlashAttention 无关；它也不是把大模型“压缩”一下，而是在四个地方各下一刀，每家下刀的位置和深浅不一样：

Flash 版的四刀
下刀处Flash 版的做法大版也用吗代价
少读权重层数、宽度、专家数一起缩：V4 激活 49B → 13B，GLM 32.9B → 3.6BMoE、低精度：大版也用。
整体缩小：Flash 才有		总参数少，记住的东西少
少读历史GLM-4.7-Flash 换 MLA；MiMo 5:1 窗口；Step 3:1 窗口；V4 压缩注意力GQA：大家都用。
V4 大小版同一种压缩		超长前文里精确找回变弱
少走几步MiMo 3 层 MTP；Step 一次出 4 个 tokenV4、GLM 大版也带 1 层猜错白算，收益看内容
补回本事Gemini 1.5、2.5 Flash 从 Pro 蒸馏；MiMo 多教师蒸馏V4 大小版后训练都蒸馏；V4-Flash 是独立预训练的推理传得下去，记忆传不下去
表 5 · Flash 的区别不在某一项独门技术，而在每一处都砍得更深

哪些是官方说的，哪些是推测

开源模型（DeepSeek、GLM、MiMo、Step、Qwen）的架构写在配置文件里，可以逐项核对。闭源的 Gemini 只能看官方公开的几句话：

  • 官方说过的：1.5 Flash 从 1.5 Pro 在线蒸馏，注意力和前馈并行计算；2.5 全家族是稀疏 MoE，Flash 及以下用 k-sparse 蒸馏；3 代 Flash 和 Flash-Lite “based on Gemini 3 Pro”，3 Pro 是稀疏 MoE；3.5 到 3.8 Flash 一代基于一代22。
  • 没说过的：参数量、层数、激活参数、注意力用什么、3 代以后还蒸不蒸馏。网上流传的“Gemini 3 Flash 有 1.2 万亿参数”之类的数字都是第三方猜的。
  • 合理但未经证实的推测：Gemini 的开源兄弟 Gemma 3 用了 5:1 的滑动窗口和全量蒸馏15，Gemini Flash 很可能也用了类似的长上下文省法和蒸馏，但这只是推测。

什么时候用 Flash

从上面的代价倒推，选型就比较清楚了：

  • 用 Flash：量大、要快、上下文不算极长、靠推理多于靠冷知识的活。比如分类、抽取、改写、代码补全、大批量的文档处理，以及 agent 里那些高频的小步骤。
  • 用完整版：需要大量事实知识（冷门问答、专业领域）、需要在几十万 token 里精确找回细节、长链条的自主任务，或者 Flash 已经反复做错的时候。

小结

  1. 模型名里的 Flash 是什么？ 是“快、便宜”的产品档位，不是 FlashAttention。各家做法不同：Google 从 Pro 蒸馏或“基于 Pro”；DeepSeek 同一设计缩小后独立训练；GLM、Qwen 的 Flash 是同代的小号开源模型；MiMo、Step 直接用 Flash 命名整个模型。
  2. 成本花在哪？ 每生成一个 token，都要把激活的权重和全部历史（KV 缓存）读一遍，显存带宽是瓶颈。
  3. 怎么少读权重？ 大小版都是 MoE，Flash 把层数、宽度、专家数整体缩小，激活参数降到大版的四分之一到九分之一。低精度存储大小版一起用。
  4. 怎么少读历史？ GQA 是标配；Flash 型号更多用 MLA、滑动窗口、压缩注意力，把 12.8 万 token 时的 KV 缓存从几十 GB 压到几 GB，代价是超长上下文的精确检索变弱。
  5. 怎么少走几步？ 多 token 预测让读一遍权重多出几个 token，定位为“快”的型号用得最重。
  6. 变小了怎么不变笨？ 蒸馏让学生学老师的整个概率分布，推理能力能传下去，记忆还是受总参数限制，所以 Flash 和大版在知识题上差得最多。

参考资料

Footnotes

  1. Gemini Developer API pricingGoogle AI for Developersai.google.dev ↗2026 年 10 月底查看。3.1 Pro Preview 输出每百万 token 12 美元；3.8 Flash 3.75 美元（2027 年起 7.5 美元）；3.1 Flash-Lite 1.5 美元。https://ai.google.dev/gemini-api/docs/pricing ↩

  2. FlashAttention: Fast and Memory-Efficient Exact Attention with IO-AwarenessTri Dao, Daniel Y. Fu, Stefano Ermon, Atri Rudra, Christopher Ré · NeurIPS 2022 · 2022arxiv.org ↗https://arxiv.org/abs/2205.14135 ↩

  3. Qwen3-Coder-30B-A3B-Instruct 模型卡Hugging Facehuggingface.co ↗在 Qwen Chat 里以 Qwen3-Coder-Flash 的名字出现。https://huggingface.co/Qwen/Qwen3-Coder-30B-A3B-Instruct ↩

  4. Qwen3-32B config.jsonHugging Facehuggingface.co ↗64 层、宽 5120、64 个查询头、8 个 KV 头、head_dim 128。https://huggingface.co/Qwen/Qwen3-32B/blob/main/config.json ↩

  5. Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts LayerNoam Shazeer et al. · ICLR 2017 · 2017arxiv.org ↗https://arxiv.org/abs/1701.06538 ↩

  6. Gemini 2.5: Pushing the Frontier with Advanced Reasoning, Multimodality, Long Context, and Next Generation Agentic CapabilitiesGemini Team, Google · 2025arxiv.org ↗2.1 节：2.5 家族都是稀疏 MoE；Flash 及更小的模型用蒸馏，教师的下一词分布用 k-sparse 近似存储，训练数据吞吐和存储因此变成 k 倍。https://arxiv.org/abs/2507.06261 ↩ ↩2 ↩3

  7. Gemini 3 Pro Model CardGoogle DeepMindstorage.googleapis.com ↗Gemini 3 Pro 是稀疏混合专家（MoE）transformer，原生多模态。https://storage.googleapis.com/deepmind-media/Model-Cards/Gemini-3-Pro-Model-Card.pdf ↩

  8. DeepSeek-V4-Flash 模型卡Hugging Facehuggingface.co ↗284B 总参数、13B 激活，1M 上下文；CSA + HCA 混合注意力；专家权重 FP4、其余 FP8；与 V4-Pro 的跑分对照表。https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash ↩ ↩2 ↩3 ↩4

  9. GLM-4.7 config.jsonHugging Facehuggingface.co ↗92 层、宽 5120、160 个专家选 8 个，num_key_value_heads: 8（GQA）。https://huggingface.co/zai-org/GLM-4.7/blob/main/config.json ↩

  10. GLM-4.7-Flash 模型卡与 config.jsonHugging Facehuggingface.co ↗卡片只写 30B-A3B MoE；config 里 model_type 是 glm4_moe_lite，带 kv_lora_rank: 512，即 MLA。https://huggingface.co/zai-org/GLM-4.7-Flash ↩ ↩2

  11. GQA: Training Generalized Multi-Query Transformer Models from Multi-Head CheckpointsJoshua Ainslie et al. · EMNLP 2023 · 2023arxiv.org ↗https://arxiv.org/abs/2305.13245 ↩

  12. DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language ModelDeepSeek-AI · 2024arxiv.org ↗提出多头潜在注意力（MLA）：把每个 token 的 K、V 压成一个低维向量存下来。https://arxiv.org/abs/2405.04434 ↩

  13. MiMo-V2-Flash 模型卡Hugging Facehuggingface.co ↗309B 总参数、15B 激活；滑动窗口注意力与全局注意力 5:1、窗口 128，KV 缓存约降为 1/6；3 层 MTP，输出速度约 3 倍；后训练用多教师在线蒸馏（MOPD）。https://huggingface.co/XiaomiMiMo/MiMo-V2-Flash ↩ ↩2 ↩3

  14. Step 3.5 Flash 模型卡Hugging Facehuggingface.co ↗196B 总参数、约 11B 激活；滑动窗口与全注意力 3:1；MTP-3 一次前向预测 4 个 token，典型 100–300 token/s。https://huggingface.co/stepfun-ai/Step-3.5-Flash ↩ ↩2

  15. Gemma 3 Technical ReportGemma Team, Google DeepMind · 2025arxiv.org ↗5 层局部注意力（窗口 1024）配 1 层全局注意力，GQA；所有型号都用知识蒸馏训练，预训练时每个 token 按教师概率采样 256 个 logits。https://arxiv.org/abs/2503.19786 ↩ ↩2 ↩3

  16. DeepSeek-V4: Towards Highly Efficient Million-Token Context IntelligenceDeepSeek-AI · 2026arxiv.org ↗V4-Pro 1.6T/49B、V4-Flash 284B/13B，都在 32T 以上 token 上预训练；1M 上下文时 V4-Pro 单 token 计算量是 V3.2 的 27%，KV 缓存是 10%。https://arxiv.org/abs/2606.19348 ↩

  17. Fast Inference from Transformers via Speculative DecodingYaniv Leviathan, Matan Kalman, Yossi Matias · ICML 2023 · 2023arxiv.org ↗https://arxiv.org/abs/2211.17192 ↩

  18. DeepSeek-V3 Technical ReportDeepSeek-AI · 2024arxiv.org ↗多 token 预测（MTP）模块，推理时可当草稿用于投机解码。https://arxiv.org/abs/2412.19437 ↩

  19. Distilling the Knowledge in a Neural NetworkGeoffrey Hinton, Oriol Vinyals, Jeff Dean · 2015arxiv.org ↗https://arxiv.org/abs/1503.02531 ↩

  20. Gemini 1.5: Unlocking multimodal understanding across millions of tokens of contextGemini Team, Google · 2024arxiv.org ↗3.2 节：1.5 Flash 是 transformer decoder，注意力和前馈并行计算，从 1.5 Pro 在线蒸馏；1.5 Pro 是稀疏 MoE。Flash-8B 属于“个位数十亿参数”级别，沿用 Flash 的架构。https://arxiv.org/abs/2403.05530 ↩

  21. Gemini 3 Flash Model CardGoogle DeepMind · 2025-12-17storage.googleapis.com ↗Architecture 一栏只有一句：Gemini 3 Flash is based on Gemini 3 Pro。https://storage.googleapis.com/deepmind-media/Model-Cards/Gemini-3-Flash-Model-Card.pdf ↩

  22. Gemini 3.8 Flash Model CardGoogle DeepMind · 2026-09-02deepmind.google ↗based on Gemini 3.7 Flash；3.7 based on 3.6，3.5 based on 3 Flash。https://deepmind.google/models/model-cards/gemini-3-8-flash/ ↩