把 Q、K、V 拆成 三条独立线性 而不是一个权重乘三次，核心原因是 ‘参数专属 + 梯度解耦’： 一份权重乘三遍 → Q/K/V 被迫共享同一参数空间，梯度累加在同一矩阵，导致： 更新方向被平均，query 要高频、key 要低秩、value 要高熵 的冲突需求互相拉扯； 秩被压缩，多头子空间重叠度↑，注意力退化趋同。 独立线性层 → 各学各的投影，梯度不打架，子空间正交性↑，模型容量直接×3，无需增加深度就能提升表达能力； 训练稳定、收敛更快，这是 Transformer 比单矩阵×3 更深却不难训的关键。

1. FFN阶段本质上是两个矩阵乘计算，token之前互不影响，因此使用kv cache可以将计算量节省为原来的1/S
2. RMSNorm本质是对每一个token的隐状态做归一化，token之间是互相独立的，因此计算量为原来的1/S
3. Attention阶段由于Q和K做gemm，会得到一个shape为[S，S]的向量，在seqlen比较大的情况下，计算复杂度为O(S^2)，使用kv cache之后，Attention计算复杂度变为O(S)，计算Q、K、V的GEMM运算降为GEMV运算，整体计算量为原来的1/S;
4. 其他的Embedding等计算量比较小，大约也为原来计算量的1/S；

以 Qwen2.5-7B 为例（BF16）：
层数：28
隐藏维度：3584
KV头数：4
精度：BF16（2字节）
2×2×28×
28
3584
​
×4=0.5 MB per token

1. 整体结构（左边灰色大框）
   Input → Encoder ×N → Decoder ×N → Output
   论文默认 N=6。
2. Encoder 自身结构（右边虚线框）
   每层 =
   ├─ Multi-Head Self-Attention
   ├─ Add & LayerNorm（残差+归一化）
   ├─ Position-wise FFN（两线性+ReLU）
   └─ 再来一次 Add & LayerNorm
   输出继续喂给下一层 Encoder，同时复制一份给所有 Decoder 层做 cross-attention。

线程 / 多线程 / 协程：

对应代码参考如下：
多线程（20 并发，阻塞 I/O）
with ThreadPoolExecutor(20) as ex: ex.map(requests.get, urls)
协程（20 k 并发，异步 I/O）
await asyncio.gather(*[aiohttp.get(u) for u in urls])

Decoder与Encoder对应差异：

现在常用的是rope，rope好处：

ROPE公式计算
ROPE = 分块对角旋转矩阵 R(m,Θ) 乘以向量 x，这边向量 x 就是多头注意力里某一个头的单条 token 向量。整体保持相对位置信息且零参数。
其中
  Θ_i=10000^(−2i/d)，i=0,1,…,d/2−1
结果：q_m、k_n 分别带上“相对距离”m−n 的旋转角，Attention 内积自然只与相对位置有关，而不再依赖绝对位置

旋转角度怎么来？
每维频率先定好（跟 Sinusoidal 相同）：
θᵢ = 10000^(−2i/d) , i = 0,1,…,d/2−1
位置 m 的旋转角 = m·θᵢ
→ 越靠后的 token 转得越多；同一维度 i 越远转得越快（像时钟秒针）。

它的完整公式是？
注意力内积的魔法
查询 q 在位置 m，键 k 在位置 n，分别做 RoPE 后点积：
RoPE(q,m) · RoPE(k,n)
⇒ 只与相对距离 (m−n) 有关，绝对位置被消掉，天然相对位置编码；

1. 分组：将 n_heads 个查询头 (Query Heads) 分成 g 个组。 2. 共享：每组内的所有查询头共享同一套 K 和 V。 3. 操作： Q 的个数不变（仍是 n_heads）。 K 和 V 的个数减少到 g 个（n_heads >= g）。 如过 g = n_heads，GQA 退化为 MHA。 如果 g = 1，GQA 退化为 MQA（所有头共享一套 K, V），也就是多头查询注意力 (Multi-Query Attention, MQA)

核心概念与架构
一个标准的MoE层主要由两个部分组成：

1. 专家：
   这些专家本身就是一个前馈神经网络，通常是结构相同但参数不共享的小型全连接层。
   每个专家都倾向于在输入数据的某个特定子集或某种特定模式上“专业化”。
   例如，一个专家可能擅长处理数学问题，另一个可能擅长处理文学问题。

2. 门控网络：
   这是一个路由机制，它的职责是“审阅”输入数据。
   根据输入，它会产生一个概率分布，决定将输入发送给哪些专家。
   最终，只有Top-K（通常K=1或2）个得分最高的专家会被激活来处理这个输入。

工作流程：
输入 → 门控网络 → 选择Top-K专家 → 输入被发送给选中的专家 → 专家们分别处理输入 → 门控网络根据得分加权求和专家们的输出 → 得到最终输出。

qwen3 | 掩码类型 | 形状 | 值 | 说明 | | ------------- | ---------------------------- | ---------------- | ------------- | | **默认 Causal** | `(B, 1, L, L)` | 下三角 1，其余 0 | 单条生成时完全自动 | | **序列级 mask** | `(B, L)` → 扩为 `(B, 1, L, L)` | 有效 token=1，pad=0 | 批处理时屏蔽右侧 pad | | **完全自定义** | `(B, 1, L, L)` | 用户任意 Bool | 支持人工控制可见范围 |

- Time To First Token (TTFT): 首 Token 延迟，即从输入到输出第一个 token 的延迟。在在线的流式应用中，TTFT 是最重要的指标，因为它决定了用户体验。 - Time Per Output Token (TPOT)： 每个输出 token 的延迟（不含首个Token）。在离线的批处理应用中，TPOT 是最重要的指标，因为它决定了整个推理过程的时间。 - Latency：延迟，即从输入到输出最后一个 token 的延迟。 Latency = (TTFT) + (TPOT) * (the number of tokens to be generated). Latency 可以转换为 Tokens Per Second (TPS)：TPS = (the number of tokens to be generated) / Latency。 - Throughput：吞吐量，即每秒针对所有请求生成的 token 数。以上三个指标都针对单个请求，而吞吐量是针对所有并发请求的。

我们将 LLM 应用分为两种：

• 在线流式应用：对 TTFT、TPOT、Latency 敏感，需要尽可能快的生成 token。
• 离线批量应用：对 Throughput 敏感，需要在单位时间内尽可能多的生成 token。
  而实际在某种应用（如在线流式应用），我们也应该在Latency 和 Throughput 之间进行权衡，提高 Throughtput 可以提高硬件承担的并发数，从而降低推理成本。

训练前：剪枝 → 裁词表 → 层数减半
↓
训练：蒸馏 + ZeRO + 检查点
↓
推理：量化 → GQA → FlashAttn → Continuous Batch

第一步：准备阶段——搭建师生框架 这个阶段的目标是准备好老师和学生，并确定教学大纲。

训练/选定教师模型：
我们需要一个强大的、已经训练好的复杂模型（如大型BERT、ResNet-50等）作为教师。这个模型在目标任务上要有很高的准确率。初始化学生模型：设计一个更小、更高效的模型作为学生（如小型BERT、TinyBERT、MobileNet等）。

核心思想：学生模型的能力天花板通常低于老师，我们的目标是让它无限逼近这个天花板。

确定蒸馏策略：
明确要蒸馏的知识形式。最经典和常用的是基于输出的蒸馏，即让学生模仿老师最终的输出预测。

第二步：训练阶段
前向传播：
将同一批训练数据分别输入教师模型和学生模型。对教师和学生的输出logits（分数）同时使用高温Softmax（温度T > 1） 进行软化，得到富含信息的“软标签”。

损失计算：
蒸馏损失：计算学生软标签与教师软标签之间的差异。这里通常使用 KL散度，因为它专门用于衡量两个概率分布的相似度。这一步是让学生学习老师的‘暗知识’——即类别间的相似性关系。
学生损失：计算学生模型的标准输出（T=1）与真实标签（硬标签）之间的交叉熵损失。这一步是保证学生不偏离正确的答案。
总损失：将两个损失进行加权合并，公式为：总损失 = α * 蒸馏损失 + (1 - α) * 学生损失。这里的 α 是一个超参数，用于平衡两种知识来源的重要性。

参数更新：只对学生模型进行反向传播，根据总损失更新学生模型的参数。教师模型的参数是冻结的、不更新的。

Q：“温度参数T的作用是什么？”
答：T是一个超参数，用于控制输出概率分布的平滑程度。T越大，分布越平缓，错误类别蕴含的相对信息（暗知识）就越明显。T=1就是标准的Softmax。高的T有助于学生更好地学习类别间的关系，但通常推理时会设回T=1。

Q：“为什么学生模型能学到比直接训练更好的效果？”
答：因为硬标签只提供了“是什么”的单一信息，而教师的软标签提供了“什么像什么”的丰富结构化信息。这相当于一个学生不仅知道了答案，还理解了整个知识体系的内在联系，因此泛化能力更强。

1. PD 分离 + 高 Decode 专用卡
   把 Prefill 与 Decode 部署到不同 GPU，Decode 卡只做自回归，消除 Prefill 抢占，TPOT 立刻平稳 。
2. 连续批处理调大“Decode 池”
   在 vLLM / TensorRT-LLM 里用 MAX_UTILIZATION 策略，保持 32-64 个序列同时解码，单卡 TPOT 随 batch 增大而下降（内存带宽打满即可）。
3. KV-Cache 压缩 + 显存换带宽

• KV-int8/int4 量化：把 KV 头压到 4-8 bit，显存↓50 % → 同显存可放更大 batch → TPOT↓15-30 %（百度云千帆实测多轮对话降 30 % Token 重复计算 ）。
• GQA / MLA：把 KV 头数从 64→8 或 1，同样 batch 下带宽需求线性下降。

4. 投机解码（MTP / Medusa）
   用 1 主 + 1-3 草稿模型并行跑，70 % 接受率下每步可吐 1.7 token；华为云 Ascend 实测 TPOT 从 100 ms→50 ms 。
5. 长输出分段流水 & 前缀缓存
   把 8 k-32 k 生成分成多段，段间 KV 复用；Prefix Cache 命中时首段之后 TTFT≈0，等效 TPOT 再降 20-40 % 。
6. 低比特 GEMM + 算子融合
   W8A8 或 W4A16 让 Decode 的 MatMul 计算量减半；vLLM 的 Marlin/cutlass INT8 kernel + 单步 fused-QKV 投影可把每步延迟再削 5-10 %。

落地顺序（性价比）
PD 分离 → 连续批处理调大 → KV-int8 → GQA/MLA → 投机解码 → 分段流水
按此阶梯，TPOT 通常可从 100 ms 级压到 30-50 ms，长输出越长收益越大。

1. chunked-prefill（必开） 把提示按 512-2048 token 切块，与 Decode 交替进 batch；HBM 读写从 O(n²) 变 O(k·n)，TTFT 线性化，vLLM 默认开启后 128 k 输入 TTFT ↓40-60 %。 2. 长序列专用 Attention 内核 FlashAttention-2 / Flash-Decoding：SRAM 分块 + 并行归约，A100 上 64 k seq 提速 2.2× MLA / GQA：KV 头数 64→1-8，带宽需求同比例下降，TTFT 再减 20-30 %。 3. KV-cache 压缩 + 前缀缓存 KV-int8 / int4 量化：显存↓50 % → 同样卡可放更长序列或更大 batch，128 k 输入 OOM 率从 30 %→0。 Prefix Cache：命中后首段 KV 免算，重复系统提示场景 TTFT 直接 0 ms。 4. 4/8-bit 权重 GEMM W4A16/W8A8 让线性层计算量减半；cutlass/Marlin INT8 kernel 在 Prefill 阶段带宽瓶颈下仍可再削 10-15 % 延迟。 5. 多卡并行策略 - TP+SP（Tensor + Sequence Parallel）：把 128 k 序列按 2k-4k token 切片到多卡，每卡 Attention 降到 (seq/TP)²，TTFT 随卡数线性下降（Megatron-LM 实测 8 卡↓8×）。 - PD 分离（Prefill 专用 4-8 卡，Decode 1 卡）：Prefill 阶段独占高算力，无 Decode 抢占，TTFT 方差 <5 %。

LayerNorm： $\text{LayerNorm}(\mathbf{x}) = \frac{\mathbf{x} - \mu}{\sigma} \odot \mathbf{g} + \mathbf{b}$ 其中 $\mu = \frac{1}{H}\sum_{i=1}^H x_i$, $\sigma = \sqrt{\frac{1}{H}\sum_{i=1}^H (x_i - \mu)^2 + \epsilon}$, $\mathbf{g}$ 和 $\mathbf{b}$ 是可学习的增益和偏置参数。

RMSNorm：
$\text{RMSNorm}(\mathbf{x}) = \frac{\mathbf{x}}{\text{RMS}(\mathbf{x})} \odot \mathbf{g}$
其中 $\text{RMS}(\mathbf{x}) = \sqrt{\frac{1}{H}\sum_{i=1}^H x_i^2 + \epsilon}$， 通常省略偏置 $\mathbf{b}$。

Swiglu原理
SwiGLU的公式是什么？
SwiGLU是Swish激活函数和GLU（Gated Linear Unit）结构的结合。

公式：
$\text{SwiGLU}(x, W, V, b, c) = \text{Swish}(xW + b) \odot (xV + c)$
其中：

• $x$ 是输入
• $W, V$ 是权重矩阵
• $b, c$ 是偏置（可选）
• $\odot$ 是逐元素乘法（Hadamard product）
• $\text{Swish}(x) = x \cdot \sigma(x)$， $\sigma$ 是sigmoid函数。

GLU：这种 (A) ⊙ (B) 的结构被称为“门控线性单元”（Gated Linear Unit）。Swish(xW1) 是“门”，它控制 (xV) 哪些部分可以通过。
在Transformer的FFN层中，通常用SwiGLU取代原来的ReLU激活

相比relu对应优势：

1. 梯度更丝滑
   Swish(x)=x·σ(βx) 全程可导、无硬零断点，反向传播不会“神经元猝死”；ReLU 负半轴恒零，易死区。
2. 表达能力≈2×参数
   把 FFN 切成两条支路（gate 与 up），再做逐元乘：
   y = Swish(W₁x) ⊙ (W₂x)
   相当于给每个神经元配了一个可学习的“开关”，参数量*2，但无任何额外推理成本（合并算子即可）。
3. 实验收益稳定
   同样 FLOPs 下，SwiGLU 在多项语言建模任务上 ppl 平均再降 2–3%；Llama、Qwen、DeepSeek 等开源模型已把它当成“默认激活”。

• Query (Q - 查询)：可以理解为“当前正在关注的 token”发出的一个询问：“与我相关的信息是什么？”
• Key (K - 键)：可以理解为所有 token 提供的一个“标识”，用来匹配 Query。Query 会与所有 Key 进行相似度比较。
• Value (V - 值)：可以理解为每个 token 所包含的“实际信息”或“内容”。一旦通过 Q-K 匹配确定了哪些 token 重要，我们就对这些 token 的 Value 进行加权求和。

实际过程：

1. 线性投影：通过三个权重矩阵 W^Q, W^K, W^V，将输入 X 分别投影到 Q, K, V 空间。
2. Q = X * W^Q, K = X * W^K, V = X * W^V
3. 计算注意力得分：计算 Query 和所有 Key 的点积，得到相似度得分。Score = Q * K^T
4. 缩放：为了防止点积结果过大导致 Softmax 梯度消失，将得分除以 Key 向量维度的平方根。Scaled_Score = Score / √d_k
5. 应用 Softmax：对缩放后的得分应用 Softmax 函数，得到归一化的注意力权重（所有权重和为1）。Attention_Weights = Softmax(Scaled_Score)
6. 加权求和：用注意力权重对 Value 向量进行加权求和，得到最终的输出。Output = Attention_Weights * V

这个输出就包含了当前 token 从序列所有其他 token 那里聚合到的上下文信息。

1. 多头自注意力机制 (Multi-Head Self-Attention)

• “自” (Self) 的含义：输入序列自身内部元素之间进行注意力计算。例如，句子中的每个词都会与句子中的所有词（包括自己）进行关联，从而捕捉词与词之间的语义和语法关系。
• attention核心公式：Attention(Q, K, V) = softmax(QK^T / √d_k) V
• 让模型能够“同时看到”整个序列，并理解每个词在上下文中的真正含义。

1. 前馈神经网络 (Feed-Forward Network, FFN)

• 一个简单的全连接网络，通常包含一个隐藏层和激活函数（如 ReLU）。
• 对自注意力层的输出进行非线性变换和空间映射，增强模型的表达能力。

1. 残差连接 (Add) 和层归一化 (Norm)

• 残差连接 (Residual Connection)：将子层的输入直接加到其输出上（Output = Sublayer(input) + input）。这有效地缓解了深层网络中的梯度消失问题，使得模型可以堆叠得很深。
• 层归一化 (Layer Normalization)：对残差相加后的结果进行归一化，稳定训练过程，加快收敛
  公式表示一个 Encoder Layer：
  EncoderOutput = LayerNorm( SelfAttention(Input) + Input )
  FinalOutput = LayerNorm( FFN(EncoderOutput) + EncoderOutput )

1. 掩码多头自注意力机制 (Masked Multi-Head Self-Attention)

• “掩码” (Masked) 的含义：为了防止在训练时“偷看”未来信息（即解码第 t 个词时只能看到 1 到 t-1 的词），通过一个掩码矩阵将当前位置之后的所有信息屏蔽掉（设置为负无穷，softmax 后变为 0）。

1. 多头交叉注意力机制 (Multi-Head Cross-Attention)

• “交叉” (Cross) 的含义：Decoder 的表示 与 Encoder 的最终输出 进行注意力计算。
• Query (Q) 来自 Masked Self-Attention 的输出。
• Key (K) 和 Value (V) 来自 Encoder 的最终输出。
• 这是 Encoder 和 Decoder 之间信息交互的桥梁，让 Decoder 在生成每一个词时都能有针对性地关注输入序列中最相关的部分。

1. 前馈神经网络 (Feed-Forward Network, FFN)
   每个子层都伴随着残差连接和层归一化。

要“低延迟 + 复杂格式 + 长上下文”——上 SGLang； 要“稳态吞吐 + 多模型兼容 + 社区插件”——继续 vLLM； 也可混部：SGLang 扛在线实时流量，vLLM 扛离线批量任务，成本最优。

SGLang 的 6 个杀手锏特性

1. RadixAttention —— 前缀感知缓存
   用 RadixTree 把不同 Prompt 的公共前缀自动复用，相同系统提示、Few-shot 示例只算一次，长模板场景 TTFT 降低 3×。
2. 零开销 CPU 调度器 —— 纯异步 Python+C++ 双栈
   调度路径全异步，无 GIL 等待；单卡 8B 模型 Median TTFT 31 ms，仅为 vLLM 的 1/3。
3. 预填充-解码分离架构 —— 并行算两个阶段
   预填充（Prompt）与解码（Generation）拆成两条 CUDA Stream，显存-计算重叠，ITL 比 vLLM 快 10×。
4. 原生结构化生成 —— JSON/Regex 语法提前编译
   把 JSON Schema 直接编译成有限状态机，采样空间缩小 2 个数量级，复杂格式任务端到端提速 6×。
5. 智能分页 KVCache —— 动态换入换出
   类似操作系统页表，显存不足时把冷块换到主机内存，单卡可跑 128 k 上下文不 OOM（官方数据，Llama-3.1-70B）[ ^75^ ]。
6. 生产级稳定性 —— 99.95 % MTBF
   高负载崩溃率 0.01 %，低于 vLLM 的 0.5 %；故障恢复 <30 s

- 基于 Token 调度：以 Token 为最小调度单位 - 调度过程：Scheduler 维护 waiting（新请求）、running（正在处理）、swapped（因资源不足被换出的请求）队列。其调度优先级通常是：swapped > waiting > running，优先处理已被换出的请求以避免资源浪费，并在资源足够时从 waiting 队列加入新请求。 - 工作流程： 1. 新请求进入 waiting 队列。 2. Scheduler 根据调度策略（如 FCFS）、当前 running 队列的负载、空闲物理块等因素，决定将哪些 waiting 或 swapped 队列中的请求加入 running 队列以进行下一批计算。 3. Worker 执行 running 队列中请求的推理计算。 4. 生成 Token 后，更新序列状态。若请求完成则释放资源，否则根据情况放回 running 或换出到 swapped 队列。 5. 循环上述过程。

v1 的“更好”主要体现在以下几个方面：

1. 调度模型：从 Iteration 到 Step 的进化
   这是最核心的改进。

v0 (Iteration 模型)：调度单位是一个“迭代”，引擎会一次性解码多个令牌，直到当前批次中所有序列都完成。这对于静态、规整的批处理很有效，但在面对持续到达、长度不一的流式请求时，会导致：
Head-of-Line Blocking（队头阻塞）：一个生成长文本的请求会阻塞后面短请求的返回，增加延迟。
资源利用率不均衡：在迭代末尾，可能只有少数序列还在计算，GPU利用率下降。

v1 (Step 模型)：调度单位是一个“时间步”（每次前向传播只生成一个令牌）。这使得引擎可以实现：
细粒度调度：每个时间步都可以重新评估哪些请求应该被调度、暂停或换出。
真正的连续批处理：新请求可以几乎无延迟地加入下一个时间步，而无需等待当前批次全部完成。这显著降低了尾延迟，提升了用户体验。

2. 架构清晰度：从“引擎全能”到“职责分离”
   v0：核心的 LLMEngine 承担了太多职责，包括调度、执行、内存管理，导致逻辑耦合紧密，难以维护和扩展。
   v1：引入了清晰的角色分离：

Scheduler：专职负责调度决策（哪个请求该 RUNNING，哪个该 WAITING 或 SWAPPED）。
Worker：专职负责执行模型的前向传播。
Executor：作为协调者，驱动 Scheduler 和 Worker 的交互，并决定执行模式（如是否使用CUDA Graph）。

这种分离使得系统更模块化、更易于测试、也更利于未来引入新的调度策略和执行后端。

3. 执行效率：对 CUDA Graph 的深度集成
   v0：虽然也支持 CUDA Graph，但其集成方式在动态调度场景下不够高效。
   v1：将模型执行（特别是预处理、解码、采样）深度编译成一系列CUDA Graph。在执行时，只需要“启动”这些预编译的图，而不是一次次发射单个Kernel。

好处：极大地减少了CPU开销和Kernel启动延迟，实现了 “内核零Python回跳” ，从而在保持调度灵活性的同时，达到了接近极限的GPU利用率。

4. 功能与扩展性
   v1 原生更好地支持了更多高级特性，如：

Chunked Prefill：将长的提示处理（Prefill）阶段切分成多个块，与解码步骤交错进行，进一步减少了队头阻塞。
更好的抢占与恢复：基于新的调度状态，可以更优雅地处理高优先级请求的插队。

总结
如果用一句话概括，v0 到 v1 的演进是 从一个“高效的批处理系统”进化为了一个“高吞吐、低延迟的实时流式服务系统”。

v0 的核心贡献是解决了“内存”问题，证明了分页KV-Cache的巨大价值。

v1 的核心贡献是解决了“调度与执行”问题，通过细粒度的Step级调度、清晰的架构分离和极致的CUDA Graph优化，在保持高吞吐的同时，大幅降低了延迟，使vLLM真正成为生产级LLM服务的首选引擎。

1. 入口层（API & 协议）【6 分】
   “外部请求先进 openai/api_server.py，它把 REST/HTTP 转成内部 SARIF 协议，
   再交给 AsyncLLMEngine 做异步调度，天然支持连续批处理与 streaming 返回。”
2. 调度器（Scheduler）【8 分】
   “Scheduler 维护三重队列：Waiting / Running / Swapped，
   每轮调度先看 GPU 显存水位，再按 prefix-hash 做 APC 匹配，把可复用 KV 块直接挂到 Running 队列，
   剩余 token 数 > max_num_batched_tokens 的切片会推迟到下一轮，保证计算密度。”
3. 执行器（Worker / ModelRunner）【10 分】
   “Worker 里真正跑推理的是 ModelRunner，它把
   ① 输入 token-id → ② embedding lookup → ③ 逐层 TransformerBlock → ④ logits 输出
   全部 compile 成一张 CUDA graph，一次 launch 完成，内核零 Python 回跳；
   每层 TransformerBlock 内部调用 xFormers / FlashAttention / PagedAttention CUDA kernel，实现 KV-Cache 分页管理。”
4. KV-Cache 存储（CacheEngine + BlockTable）【10 分】
   “KV-Cache 以 block_size=16 分页，逻辑块号到物理块号的映射存在 BlockTable；
   CacheEngine 提前 malloc 一整块 GPU memory pool，按 16-token 粒度切页，通过 ref-count 做 LRU 回收；
   APC 模块在 scheduler 阶段把命中页直接挂到 BlockTable，未命中页标记为‘待计算’，推理阶段只做增量填充。”
5. 量化与 Kernel（Quantization + Custom Ops）【8 分】
   “量化层采用‘插件化’方案：compressed-tensors / AWQ / GPTQ / FP8 各自继承 QuantizationScheme，
   在 ModelRunner 里动态替换 Linear 层为 qlinear，kernel 侧一条融合算子完成 dequant+gemm，回写 FP16；
   KV-Cache 支持 C8 动态对称量化，scale 由 kernel 在线 reduce，zero-point 固定 0，输出直接 BF16，零回写。”
6. 分布式（PP + TP + DP）【8 分】
   “30B 以上模型用 Ray 起多节点，PP 把层切到不同节点，TP 把单层权重按 hidden 维度切到 8 卡，
   通信后端统一走 PyTorch NCCL，vLLM 自己包了一层 Pynccl 做 all-gather / reduce-scatter，支持 CUDA graph 内嵌通信 kernel，无 Python GIL；
   DP 靠数据并行扩展 QPS，每份副本独立调度，负载均衡由 proxy 层轮询完成。”
7. 内存与抢占（Swap + Recompute）【6 分】
   “当显存不足时，Scheduler 把 Swapped 队列整块 KV-Cache 通过 cudaMemcpyAsync 换到 CPU DRAM，
   下次调度再提前 async 预取；若仍不够，就砍掉最长序列的尾部 25 % 做 selective recomputation，保证正确性。”
   一句话收尾【4 分】
   “总结：vLLM=‘分页 KV-Cache + 连续批调度 + 融合 CUDA Kernel’ 三件套，把 LLM 推理做成显存可换页、计算可流水、协议可插拔的实时服务。”

DSA解决了NSA什么问题？ DSA（DeepSeek Sparse Attention）主要解决了 NSA（Native Sparse Attention）在稀疏索引学习、计算效率与训练稳定性上的三大痛点，具体改进如下：

1️⃣ 索引学习更准：引入“注意力分数蒸馏”

• NSA 只靠 LM Loss 端到端优化，没有直接监督“选哪些 token”，导致长文检索任务索引学歪。
• DSA 额外加一条 Attn-Score 蒸馏损失，让 Indexer 的 Top-K 结果去拟合真实注意力分布，“选得准”被显式优化，长距离依赖召回率大幅提升。

2️⃣ 计算范式更简：三合一分支 → 单分支

• NSA 维护三套独立 KV-Cache（压缩、选择、滑动），推理时要走三次 Attention，内存占用大、kernel 切换开销高。
• DSA 把“选 token”与“算 attention”解耦：
  ① 闪电索引器一次性产出 Top-K 地址；
  ② 主路径用同一套 KV 做 MQA 即可。
  → 单分支、单缓存、零额外参数，Prefill/Decode 全链路 kernel 融合更彻底，A100 上 Prefill 提速 2.1×、Decode 提速 2.3×。

3️⃣ 稀疏粒度更细：Block-level → Token-level

• NSA 以“块”为最小单位，块内冗余计算无法避免。
• DSA 直接在 token 粒度挑重点，Top-K 索引精度更高，短文本可无缝回退到稠密模式，零性能回退；长文本保持相同模型参数即可扩展到 128 K。

一句话总结：
DSA 用“注意力蒸馏 + 单分支 MQA + Token-level 稀疏”三板斧，把 NSA 的“多缓存、粗粒度、难训练”问题一次性解决，在同等模型尺寸下实现训练更快、推理更省、长文更准。

一、总体流程（两阶段） 阶段 1 Lightning Indexer（海选） 低维投影：把高维 Q、K 先压到 128 维（可学习线性层），再量化为 FP8。 快速打分：执行一次小矩阵乘 index_score = ReLU(Q_index · K_index^T)；ReLU 只取正相关，避免 Softmax 全局归一化开销。 跨头聚合：把多个 query head 的分数求和，得到每个查询 token 对所有历史 token 的“相关性向量” Iₜ。

阶段 2 Top-k 选择 + 稀疏 MLA（精算）
4. 选 Top-k：对 Iₜ 取 Top-2048 索引（训练固定 k=2048）。
5. 构造稀疏 KV：只把这些位置的主 KV 从缓存里 gather 出来（连续块访问，GPU 友好）。
6. 执行注意力：在筛后的 2048 个 KV 上算标准 MQA，输出上下文向量。

二、与 MLA 的耦合
采用 MQA 模式：所有 query head 共享同一组 KV，因此只需一次 Top-k 筛选即可服务全部头，避免重复存储与计算。
位置编码：仅对索引向量及主 KV 施加 RoPE，兼顾位置感知与效率。
持续训练：在 DeepSeek-V3.1-Terminus Checkpoint 上做两阶段继续训练——密集热身 → 稀疏微调，保证模型适应稀疏分布。

DSA = “FP8 低维 ReLU 海选” + “Top-k 稀疏 MLA”；
在 MLA 的 MQA 模式下，用一次轻量索引完成所有 query head 的候选筛选，
把平方复杂度压到线性，长文本 128 K 场景几乎无损精度，推理成本砍半

相关文章：https://mp.weixin.qq.com/s/-dBxaYyisXwIvPNRFZCrCQ

GQA（Grouped-Query Attention）
把 Q 头分成 G 组，每组共享 1 份 K/V 头；组数 G 是“质量-速度”滑杆：G=1 等价于 MQA，G=H 退回到 MHA
效果：KV-Cache 内存带宽 ∝ G/H，推理时解码层只需加载 G 组键值，远小于原来 H 组。
SWA（Sliding-Window Attention / Stochastic-Weight-Averaging 两义）
在“层内混合稀疏”语境下一般取 Sliding-Window Attention（NSA 论文用法）：
对每个 token 只计算附近 W 个位置的注意力，形成固定宽度窗口，复杂度从 O(n²) 降到 O(nW)；跨层错位窗口后即可覆盖长距依赖，实现“局部密集 + 全局稀疏”的混合模式 。
另一义 Stochastic-Weight-Averaging 为优化器技巧，与稀疏无关，此处不展开。
SSM（State-Space Model，以 S4/S5 为代表）
把序列建模成线性时不变系统：
h′ = Ah + Bx, y = Ch + Dx
通过 HiPPO 初始化 A 并推导长卷积核，可在线性时间 O(n) 并行计算；既能像 CNN 一样全局卷积，又能像 RNN 一样逐步递归，因而被拿来替换部分注意力头，形成“注意力+SSM”的线性混合稀疏结构 。

它将 KV Cache 中的信息分为两类：

骨干序列：一组稀疏的、具有代表性的 Key-Value 对。它们构成了当前上下文的“骨架”或“概要”，负责捕捉和保留整个序列的核心语义信息。
最近序列：最近生成的几个 token 的完整的 Key-Value 对。它们负责捕捉局部的、细粒度的语言模式和连贯性。

“分离” 就体现在这里：模型在推理时，会动态地、有选择地更新和维护 骨干序列，而 最近序列 则像滑动窗口一样固定不变。

具体步骤的话：

步骤 1：计算相似度并选择骨干
当一个新的 token 被生成并其 KV 向量准备加入缓存时，SepLLM 不会直接将其加入骨干序列。相反，它会执行以下操作：

• 计算相似度：将新 token 的 Key 向量与当前 骨干序列 中所有已有的 Key 向量进行相似度比较（通常使用余弦相似度）。
• 选择策略：

如果新 token 的 Key 与骨干序列中任何一个现有 Key 的相似度高于某个预设阈值，则认为这个新 token 的语义信息已经被现有的骨干节点所“代表”。此时，不将其加入骨干序列，从而避免了冗余。
如果新 token 的 Key 与所有骨干 Key 的相似度都低于阈值，则认为它带来了新的、独特的语义信息。此时，将其加入骨干序列，作为新的骨干节点。

通过这个动态选择过程，骨干序列只保留那些信息量最大、最具代表性的 token，形成了一个高度压缩的上下文概要。

步骤 2：构建混合 KV Cache 进行注意力计算
在计算注意力时，SepLLM 使用的是混合的 KV Cache：

混合KV Cache = 骨干序列 + 最近序列

• 骨干序列：代表了从序列开始到现在的全局、压缩的语义上下文。
• 最近序列：一个固定大小（例如 128 或 256）的滑动窗口，包含了最近生成的 token，保证了局部语言的流畅性和连贯性。

模型在计算注意力时，Query 会同时与这个混合 Cache 中的 Key 进行交互。这样，模型既能把握全局的语义脉络（通过骨干序列），又能确保下一个生成的词在语法和局部语境上是准确的（通过最近序列）。

步骤 3：维护与更新

• 最近序列：像一个 FIFO（先进先出）队列，新的 token 加入，最老的 token 被移出（如果它不在骨干序列中）。
• 骨干序列：根据上述相似度阈值策略动态增长。为了防止其无限膨胀，也可以设置一个最大骨干数量。当超过时，可以基于一些启发式方法（如最久未使用）合并或移除最不重要的骨干。