Skip to main content

Documentation Index

Fetch the complete documentation index at: https://se7en.mintlify.app/llms.txt

Use this file to discover all available pages before exploring further.

​
本章概要

2024 年底，中国初创公司 DeepSeek 用 2048 块受出口管制限制的 H800 GPU，训练出了 671B 总参数、每个 token 激活 37B 参数的 MoE 模型 DeepSeek-V3。根据其技术报告，DeepSeek-V3 在语言理解、阅读理解和推理等多项标准化测试上接近甚至部分超过 GPT-4，而完整训练仅需 278.8 万 H800 GPU 小时。假设 H800 的租赁价格为每小时 2 美元，总训练成本仅为 557.6 万美元（该数字仅包含正式训练，不含前期架构探索和消融实验）。 随后推出的推理模型 DeepSeek-R1 进一步逼近 OpenAI o1 的水平。消息一出，NVIDIA 股价单日跌了约 17%，据 路透社报道市值蒸发近 5930 亿美元，创下华尔街单只股票单日最大市值损失纪录。 作为对比，训练 GPT-4 估计花了约 1 亿美元，训练 Gemini Ultra 估计花了约 1.9 亿美元。在这个规模上，系统效率每提高一点，省下来的就不是小数目。而 DeepSeek 在硬件更受限的条件下，用不到 GPT-4 训练成本 1/18 的预算达到了相近效果，靠的正是硬件、软件和算法的协同设计。 本章先从 DeepSeek 在 H800 约束下的模型与系统优化讲起，包括 MoE 架构、DeepSeek-R1 以及 FlashMLA、DeepGEMM、DeepEP、3FS 等工程创新；再把视角扩展到万亿到百万亿参数模型面临的计算与内存瓶颈，以及 GB200、Vera Rubin 等机架式 AI 超级计算机如何提供系统级支撑；最后通过 FlashAttention、MLA 和低精度量化这些例子，说明大模型性能和成本的上限并不只取决于单个算法或单代 GPU，而取决于硬件、软件和算法能否围绕同一组瓶颈协同演进。

​
章节详解

​
1. DeepSeek：硬件受限下的极致优化

2024 年底，中国初创公司 DeepSeek 在没有最新 NVIDIA GPU 的情况下，训练出了接近前沿水平的大语言模型，震动了整个 AI 社区。

​
1.1 硬件约束

由于美国出口管制，DeepSeek 无法获得顶级的 Blackwell（B200、B300）或完整版 Hopper（H100、H200）GPU，只能使用出口合规的 H800。下面这张表可以看出 H800 和其他型号的差距：
指标H800 SXMH100 SXMH200 SXMB200B300
架构HopperHopperHopperBlackwellBlackwell
FP641 TFLOPS34 TFLOPS34 TFLOPS37 TFLOPS1.2 TFLOPS
FP64 Tensor Core1 TFLOPS67 TFLOPS67 TFLOPS37 TFLOPS1.2 TFLOPS
FP3267 TFLOPS67 TFLOPS67 TFLOPS75 TFLOPS75 TFLOPS
TF32 Tensor Core989 TFLOPS989 TFLOPS989 TFLOPS2,250 TFLOPS2,250 TFLOPS
FP16 Tensor Core1,979 TFLOPS1,979 TFLOPS1,979 TFLOPS4,500 TFLOPS4,500 TFLOPS
BF16 Tensor Core1,979 TFLOPS1,979 TFLOPS1,979 TFLOPS4,500 TFLOPS4,500 TFLOPS
FP8 Tensor Core3,958 TFLOPS3,958 TFLOPS3,958 TFLOPS9,000 TFLOPS9,000 TFLOPS
INT8 Tensor Core3,958 TOPS3,958 TOPS3,958 TOPS9,000 TOPS307 TOPS
FP4 Tensor Core———18,000 TFLOPS18,000 TFLOPS
GPU Memory80 GB80 GB141 GB180 GB270 GB
GPU Memory Bandwidth3.35 TB/s3.35 TB/s4.8 TB/s7.7 TB/s7.7 TB/s
Multi-Instance GPU77777
InterconnectNVLink: 400 GB/s, PCIe Gen5: 128 GB/sNVLink: 900 GB/s, PCIe Gen5: 128 GB/sNVLink: 900 GB/s, PCIe Gen5: 128 GB/sNVLink: 1.8 TB/s, PCIe Gen5: 128 GB/sNVLink: 1.8 TB/s, PCIe Gen6: 256 GB/s
H800 在算力上与 H100 接近，但 NVLink 互连带宽被砍到不到一半（400 vs 900 GB/s）。与 B300 相比差距更为悬殊：NVLink 带宽差 4.5 倍（400 GB/s vs 1.8 TB/s），显存容量差 3.4 倍（80 vs 270 GB），显存带宽差 2.3 倍（3.35 vs 7.7 TB/s），FP8 和 FP16 Tensor Core 算力差 2.3 倍。
TFLOPS = Tera Floating-Point Operations Per Second，即每秒万亿次浮点运算。
  • T（Tera）= 101210^{12}
  • FL（Floating-Point）= 浮点
  • OPS（Operations Per Second）= 每秒运算次数
例如 H100 的 FP16 Tensor Core 峰值算力 1,979 TFLOPS，即每秒最多执行约 1.979×10151.979 \times 10^{15} 次 FP16 浮点运算。表格中 INT8 行用的是 TOPS（Tera Operations Per Second），因为整数运算不属于浮点运算，去掉了 FL。

​
精度格式一览

GPU 规格表里会出现多种数值精度格式，它们决定了每个数字占多少位、能表示多大范围和多高精度。位数越少，每个周期能算的数越多，TFLOPS 越高，但精度越低。
格式位数（符号+指数+尾数）首次广泛使用应用场景
FP6464（1+11+52）通用计算时代科学计算（HPC），AI 训练中几乎不用
FP3232（1+8+23）通用计算时代早期深度学习默认精度；现在优化器（AdamW）状态仍保持 FP32
FP1616（1+5+10）2017（混合精度训练）早期混合精度训练和推理，逐渐被 BF16 取代
BF1616（1+8+7）2018（Google TPU）当前最主流的训练精度，Llama 3 等均使用 BF16 训练
TF3219（1+8+10）2020（NVIDIA Ampere）Tensor Core 自动用 TF32 加速 FP32 矩阵乘法，无需改代码
INT882020（推理量化）训练完成后将权重从浮点压缩为整数以节省显存和加速推理，vLLM、SGLang、TensorRT-LLM 等主流推理框架均支持。在 Hopper 及之后的 GPU 上逐渐被 FP8 取代
FP88（E4M3: 1+4+3；E5M2: 1+5+2）2022（NVIDIA Hopper）DeepSeek-V3 用 FP8 训练，Hopper 开始原生支持
FP44（1+2+1）2024（NVIDIA Blackwell）Blackwell 开始支持训练和推理

​
浮点数的存储结构

浮点数的存储结构与科学计数法相同，由 符号位、指数 (exponent) 和 尾数 (mantissa) 三部分组成：(-1)^符号位 × 1.尾数 × 2^指数
  • 指数位越多 → 能表示的数值范围越大，但不影响精度
  • 尾数位越多 → 有效数字越多、精度越高，但不影响范围
以 FP32 存储 4.8125 为例：
符号（1 bit）指数（8 bit）尾数（23 bit）
01000000100110100000000000000000
  • 符号位 = 0：表示这个数是正数。
  • 指数位 = 10000001₂ = 129：FP32 存的不是“真实指数”，而是“真实指数 + 偏移量（bias）”。FP32 的指数有 8 位，所以偏移量是 28−1−1=1272^{8-1} - 1 = 127。因此这里的真实指数 = 129 - 127 = 2。这样设计的好处是，指数即使有正有负，存进硬件后也始终是非负整数，便于存储和比较。其他格式同理：如果指数位为 nn，偏移量通常是 2n−1−12^{n-1} - 1。
  • 尾数位 = 0011010...：这里只存小数部分，前面的 1. 默认省略不写（称为“隐含前导 1”）。所以完整尾数其实是 1.001101₂，换成十进制约为 1.203125。
  • 最终值 = (+1)×1.203125×22(+1) \times 1.203125 \times 2^{2} = 4.8125。

​
低精度格式的缩放机制

低精度格式（FP8、FP4）的刻度很粗，需要 scaling factor 来补偿。
Comparison of FP8, MXFP8, and NVFP4 low-precision formats
用称重类比：秤的刻度很粗，要称一批大小差别很大的物品——
  • 传统 FP8：所有物品共用一个秤（per-tensor scaling），量程必须覆盖最重的东西，因此称很轻的物品时精度会明显变差
  • MXFP8：把物品分成很多小组（通常每 32 个一组），每组发一个秤，量程根据这组物品的大小单独调（per-block scaling）。重的一组用大量程，轻的一组用小量程，因此每组内部都能称得更准
  • NVFP4：秤的刻度更粗了（4 bit），只靠一个秤已经不够，所以要用两层秤：先给每个小组一个局部秤调组内相对大小（per-block E4M3 scaling），再给整批物品一个总秤校正整体范围（per-tensor FP32 scaling）
精度越低，越需要更细粒度的缩放机制来补偿。参考资料
上面表格中 Tensor Core 峰值算力均为启用 sparse 加速后的数值，dense 模式下性能减半。 A100 是第一款在 Tensor Core 中内置硬件级 2:4 结构化稀疏支持的 GPU：它将权重矩阵按每 4 个连续元素分组，每组只保留 2 个非零值。哪些值被置零由剪枝或稀疏训练算法决定，常见做法是保留绝对值较大的两个，再将绝对值较小的两个置零并通过微调恢复精度；Tensor Core 负责利用这种固定的稀疏模式跳过零值计算，从而实现约 2 倍的矩阵乘法吞吐量提升。Dense GEMM 是标准矩阵乘法 C=A×BC = A \times B，A（M×K）和 B（K×N）的所有元素都参与乘累加运算。Sparse GEMM 利用 2:4 稀疏格式对 A 矩阵进行压缩：
  • 只存储非零元素（数据量减半，K → K/2）以及一组 2-bit 索引记录非零元素在原始 4 个位置中的偏移。
  • Tensor Core 根据索引从 B 矩阵的 K 个元素中选出对应的 K/2 个元素，只对它们做乘累加。
Illustration of 2:4 (sparse) matrix multiplication on NVIDIA GPUs
参考资料
SXM：物理封装形态SXM 是 NVIDIA 的高带宽插座式 GPU 模块封装。它不走标准 PCIe 插槽，而是把 GPU 直接安装到 HGX / DGX 底板上。在这类系统里，SXM GPU 通常配合 NVLink 和 NVSwitch 使用，因此往往有更高的供电、更强的散热，以及更高的 GPU 间互连带宽。HGX：服务器主板 / 平台HGX 是 NVIDIA 的多 GPU 服务器参考平台。常见的 HGX H100 / HGX H200 底板会集成 8 块 SXM GPU，并通过 NVSwitch 把它们全互连。Dell、HPE、浪潮等厂商通常在 HGX 底板之外再配上 CPU、内存和网卡，组装成完整的 AI 服务器。NVL：NVLink 互连版本NVL 代表 NVLink，H100 NVL 是把两块 H100 通过 NVLink 桥接焊在同一张 PCIe 大卡上，对外表现为单张卡。 这样做的好处是：不需要安装专用 HGX 主板就能拿到 NVLink 互连和更大的显存（两张合计 188 GB HBM3），适合快速部署在现有服务器基础设施上，尤其适合 LLM 推理场景。 NVL 版的核心性能接近 SXM，但 NVLink 带宽略低（600 GB/s vs SXM 的 900 GB/s）。

​
1.2 DeepSeek-V3 的 MoE 架构

DeepSeek‑V3 是一个约 671B 参数的混合专家（MoE）模型，但每个输入 token 只会激活约 37B 参数：每层包含 1 个共享专家和 256 个路由专家，每个 token 从中选出 8 个路由专家，再加上共享专家，一共使用 9 个活跃专家。这样一来，激活参数量约占总参数的 5.5%，在保持大模型容量的同时显著降低了单 token 的实际计算开销。
MoE 架构的核心优势：总参数量决定模型容量（“模型能学到多少知识”），而活跃参数量决定推理成本（“每次推理需要多少计算”）。这种解耦让 MoE 在相同计算预算下能训练出更大、更强的模型。

​
1.3 DeepSeek-R1：推理模型

在 DeepSeek-V3 基础上，团队进一步构建了专门的推理模型 DeepSeek-R1，路线接近 OpenAI 的 o1/o3 系列。与依赖大量人工反馈做后训练不同，R1 采用了 DeepSeek 开创的“冷启动”策略：只使用少量监督数据，把重点放在强化学习上，直接将思维链推理能力嵌入模型。这种做法同时压低了训练成本和训练时间，也说明软件和算法设计足够聪明时，可以在相当程度上弥补硬件瓶颈。

​
1.4 DeepSeek 工程创新

DeepSeek 的工程团队几乎把整条系统栈都做了针对 H800 约束的重优化：从 attention kernel、FP8 矩阵乘法和 MoE 通信，到专家负载均衡、双向流水线并行，再到底层文件系统。
项目简介
FlashMLA用 CUDA/CUDA C++ 实现的高性能 MLA attention kernel 库，针对 Multi-Head Latent Attention 优化解码计算和 KV cache 访问路径
DeepGEMM轻量级 FP8 优化矩阵乘法库，在多种矩阵形状和小 batch 场景下，性能可与基于 CUTLASS 等深度调优实现持平甚至更优
DeepEP为 MoE/专家并行定制的高性能通信库，重点优化专家的 dispatch/combine all-to-all 通信，缓解专家并行通信瓶颈
EPLB基于冗余专家策略的负载均衡组件，通过复制高负载专家并分布到多块 GPU，上下两级调度缓解 MoE 训练中的负载不均
DualPipe双向流水线并行算法，通过同时重叠前向/反向计算与跨节点通信，显著减少 pipeline bubble、提高大模型训练吞吐
3FS高性能分布式文件系统，为训练数据读取、checkpoint 及大规模 KV cache 提供统一的高吞吐存储 I/O 基础设施
这些项目全部来自 DeepSeek 2025 年 2 月的 Open Source Week，汇总在 open-infra-index 仓库中。下面逐个展开。

​
2. 迈向百万亿参数模型

模型规模正在从千亿向万亿参数迈进。以下是 2026 年主流开源 LLM 中的千亿至万亿级模型（均为 MoE 架构）：
模型公司总参数活跃参数
Kimi-K2.5Moonshot AI1T32B
GLM-5智谱744B40B
DeepSeek-V3.2DeepSeek671B37B
Qwen3.5-397B阿里397B17B
MiMo-V2-Flash小米309B15B
gpt-oss-120bOpenAI117B5.1B

​
2.1 计算挑战

一个 dense 的 100 万亿参数模型，在约 29 万亿 token 上训练，需要约 1.2 × 10²⁹ FLOPS。这是一个天文数字——即使是 exascale 系统也需要数千年的 GPU 时间来完成一次训练。
Exascale 系统指算力达到 101810^{18} FLOPS（1 exaFLOPS）的超级计算机。目前已有多台投入运行：
系统机构峰值算力年份
Frontier美国橡树岭国家实验室~1.1 exaFLOPS2022
Aurora美国阿贡国家实验室~2 exaFLOPS2024
El Capitan美国劳伦斯利弗莫尔国家实验室~2 exaFLOPS2024

​
2.2 内存挑战

以 FP16（每参数 2 字节）存储 100 万亿参数，仅模型权重就需要约 182 TB 显存。单块 B200 GPU 有 192 GB HBM3e，仅加载模型就需要约 1,000 块 B200（约 125 个 8-GPU 节点）。若使用 B300（288 GB），则需约 700 块。这还只是模型权重——不包括激活值内存、优化器状态和输入数据，实际需求更大。
前面规格表里的 B200 / B300 采用的是 HGX B200 / HGX B300 的单 GPU 口径，因此显存写成 180 GB 和 270 GB；这里这句沿用原书引用的 DGX B200 / DGX B300 口径，因此写成 192 GB 和 288 GB。两者对应的是不同系统形态下的规格，所以数字不完全一致。可参考 Blackwell Ultra Datasheet 和 NVIDIA DGX B300 Datasheet。

​
2.3 MoE 是关键路径

LLM 的基本架构是 Transformer，由一系列 Transformer 模块像搭积木一样堆叠而成。每个模块内部有两个核心组件：
  • Attention：负责词与词之间的相互关联（“这句话里哪些词和当前词有关”）
  • FFN（Feed-Forward Network）：负责对每个词本身的深度理解（“这个词在当前语境下是什么意思”）
Dense 模型（如早期 GPT 系列）对每个 token 使用全部 FFN 参数，计算成本随参数量线性增长。在 LLM 中，FFN 的参数量占了模型的约八成。如果能让 FFN 稀疏化 10 倍，同等计算量下模型总参数就能翻约 8 倍。 MoE 的核心做法是把每层的 FFN 替换为 N 个并列的独立 FFN（每个叫一个”专家”），由路由器（gating network）为每个 token 选出少量专家执行，将它们的输出加权合并后传入下一层，其余专家不参与计算。 每个 token 只需经过少量专家的计算，而模型整体因为拥有 N 个专家，总知识容量远超同等计算量的 dense 模型。
MoE sparse model illustration showing only one expert activated out of four
LLM 由多层 Transformer 堆叠而成，每一层都有自己独立的一组专家和路由器。一个 token 从输入到输出会逐层经过所有层，每层的路由器独立为它选择不同的专家：
MoE layers showing different experts activated at each layer
2.3.1 从 Switch Transformer 到 DeepSeek MoE
Switch Transformer（Google, 2021）是最早的大规模实践，采用 top-1 路由（每个 token 只选 1 个专家），训练速度达到同等 dense 模型的 7 倍。但它有一个缺陷：每个专家都要各自学一遍通用能力（语义理解、语法处理等），大量参数容量浪费在重复学习上。 DeepSeek MoE 的改进是两个：
  1. 共享专家：划出一部分专家，所有 token 都经过它们，专门学习通用能力。其余专家只需在通用能力的基础上各自深耕专业领域。
  2. 细粒度专家：把每个专家的粒度做细、数量做多（DeepSeek-V3 用 256 个 routed expert 选 8 个），让专业分工更精细。
Comparison of dense architecture vs DeepSeek V3/R1 MoE architecture
2.3.2 MoE 推理优化
1. 算子效率：更快的 CUDA kernel 通用的 NCCL collective 对 MoE 的 all-to-all 通信模式并非最优。DeepSeek 的 DeepEP 提供了专门为 MoE 优化的高效 all-to-all 通信 kernel。Perplexity 开源的 pplx-kernels 同样针对 MoE expert parallelism 场景，支持 NVLink、IBGDA、IBRC 等多种传输层，并在 kernel 层面提供通信与计算重叠的底层能力。
都是 InfiniBand 网络上 GPU 间的通信方式：
  • IBGDA（InfiniBand GPU-Direct Async）：GPU 直接向网卡发起 RDMA 操作，完全绕过 CPU，延迟最低
  • IBRC（InfiniBand Reliable Connection）：传统模式，需要 CPU 代理线程协调 GPU 和网卡之间的通信，延迟较高
2. 通信与计算并行（Dual Batch Overlap） GPU 内部的计算单元（SM，Streaming Multiprocessor）和网络硬件（NIC 网卡、NVLink/InfiniBand 链路）是独立的——SM 在执行 CUDA kernel 做矩阵乘法时，NIC 可以同时通过 DMA/RDMA 在 GPU 之间搬运数据，互不占用对方资源。 例如 vLLM 的 Dual Batch Overlap（DBO） 利用这一点，将 batch 拆成两组 micro-batch 交替执行：一组的 token 在 SM 上做前向计算时，另一组的 token 正通过 NIC 做 MoE all-to-all 通信，让计算单元和网络通道同时满载。 下面是一段 DeepSeek decode workload 的 profiling trace。未启用 DBO 时，MoE Dispatch/Combine 部分占据了大量时间，尽管实际计算负载很小。
GPU profiling trace before DBO showing sequential execution with idle GPU during MoE communication
启用 DBO 后，两个 micro-batch 线程交替执行：
  • 线程 0 完成 dispatch（send + recv）后立刻让出给线程 1
  • 线程 1 开始自己的 dispatch 通信，同时线程 0 收到的 token 在 SM 上做专家计算
  • 线程 1 完成 dispatch 后让回给线程 0 做 combine
  • 线程 0 完成 combine 后让出给线程 1 做 combine，如此交替
在通信开销较高的场景（如 Wide EP 部署）中，这种交替执行显著提升了 GPU 利用率。
GPU profiling trace after DBO showing interleaved execution of two microbatches with overlapped communication and computation
当专家分布在多块 GPU 上时，每一层的 MoE 计算都需要经过 dispatch → 专家计算 → combine 三个阶段。其中 dispatch 和 combine 属于通信操作（通过 NIC/NVLink 在 GPU 间搬运数据），共四步：
步骤作用
dispatch send根据路由结果，把 token 发送到持有对应专家的 GPU
dispatch recv接收其他 GPU 发来的 token
（专家计算）本地 GPU 上的专家对收到的 token 做前向计算
combine send把专家计算结果发回给 token 的来源 GPU
combine recv接收专家计算结果，加权求和得到最终输出
下图展示了两个 DP group 和 4 个专家之间的完整 dispatch → 专家计算 → combine 流程：
MoE dispatch and combine flow across two DP groups and four experts
  • 左侧 DISPATCH：DP #0 有 3 个 token（0, 1, 2），DP #1 有 2 个 token（0, 1）。根据路由结果，token 被分发到 4 个专家（E #0 ~ E #3），一个 token 可能被发给多个专家
  • 中间 专家计算：每个专家收到各自的 token 后独立做前向计算
  • 右侧 COMBINE：专家计算结果沿箭头发回各自的来源 DP rank，⊕ 表示加权求和——同一个 token 被多个专家处理后，按路由权重合并为最终结果
如果所有专家在同一块 GPU 上，就不需要这些通信。但大模型的专家太多（如 DeepSeek-V3 的 256 个），必须分散到多块 GPU，这四步通信不可避免。DBO 的作用就是通过交替执行两组 micro-batch 来隐藏这些通信延迟。
3. Wide-EP Expert Parallelism（EP）将 MoE 模型中的专家分配到多块 GPU 上，利用各设备的综合计算能力和内存带宽。小规模 EP 在每块 GPU 上部署多个专家，但 decode 阶段每个 token 只激活少量专家，大部分专家每次只服务很少的 token，读一次权重却只做很少计算，算术强度低。 Wide EP 将 EP 与 DP（Data Parallelism）结合，把专家分布到数十甚至上百块 GPU 上，每块 GPU 只持有少量专家。来自多个 DP group 的 token 都路由到这些专家，每个专家服务更多 token，读一次权重服务更多计算，算术强度提升。
Comparison of small scale EP with multiple experts per GPU vs large scale Wide EP with fewer experts distributed across more GPUs
实测数据：NVIDIA 在 GB200 NVL72 上的基准测试显示，EP32 比 EP8 的每 GPU 吞吐量提升 1.8 倍。 4. EPLB（Expert Parallel Load Balancing） Wide EP 下，某些 EP rank 可能空闲，而其他 rank 在处理大量 token。为此，vLLM 集成了 DeepSeek 的 EPLB 的分层和全局负载均衡策略。 工作方式：每次 MoE 前向传播记录每个 token 的负载分布，通过滑动窗口在各 EP rank 之间聚合统计数据。当达到重新均衡间隔时，负载均衡器计算新的逻辑-物理专家映射，并执行权重迁移（weight shuffle），使新的分配方案生效，无需重启模型。对于被频繁选中的热门专家（hot expert），EPLB 会将其 clone 到多个 rank 上，让多块 GPU 共同分担该专家的负载。
Expert Parallel Load Balancing animation showing expert distribution across 4 ranks with All2All communication

​
2.4 开源 MoE 模型一览

模型公司总参数活跃参数Routed ExpertShared Expert每 token 激活 Routed Expert年份
Mixtral 8x7BMistral46.7B12.9B8022023
DeepSeek-V3.2DeepSeek671B37B256182025
gpt-oss-120bOpenAI117B5.1B128042025
MiMo-V2-Flash小米309B15B256082026
Kimi-K2.5Moonshot AI1T32B384182026
GLM-5智谱744B40B256182026
Qwen3.5-397B阿里397B17B5121102026
参考资料

​
3. 机架式 AI 超级计算机

NVIDIA 正在将 AI 基础设施从单块 GPU、单台服务器演进为机架级系统和 POD 级超级计算机。

​
3.1 GB200 NVL72 (2024)

GB200 NVL72 是基于 Blackwell 架构的机架级 AI 超级计算系统，在单机架内提供 exaFLOP 级算力。它将 36 颗 Grace CPU 和 72 块 Blackwell GPU 整合在一个液冷机柜中，72 GPU 组成一个 NVLink 域，如同一块巨型 GPU。其核心构建单元是 GB200 Grace Blackwell Superchip——通过 NVLink-C2C 将两块 Blackwell Tensor Core GPU 与一颗 Grace CPU 互连。
NVIDIA GB200 NVL72 rack front and back view showing compute trays and NVLink cable spine
72 个通过 NVLink 连接的 Blackwell GPU 与 30 TB 统一内存集成在 130 TB/s 的计算架构中，在单个机架内构成一台 exaFLOP 级 AI 超级计算机。
相比上一代 H100，GB200 NVL72 在推理、训练、能效和数据处理上都有代际提升：
场景vs H100说明
LLM 推理30×第二代 Transformer Engine 支持 FP4，新一代 Tensor Core 引入 microscaling 格式，配合第五代 NVLink 将万亿参数语言模型的推理性能提升 30 倍
LLM 训练4×第二代 Transformer Engine 支持 FP8，配合第五代 NVLink（1.8 TB/s GPU 间互连）、InfiniBand 和 Magnum IO 实现大规模 LLM 训练 4 倍加速
能效25×液冷提升计算密度、减少占地面积，并支持大规模 NVLink 域的高带宽低延迟 GPU 通信。同等功耗下性能 25 倍，同时减少水资源消耗
数据处理18× vs CPU利用高带宽内存、NVLink-C2C 和 Blackwell 专用解压引擎加速数据库查询
测试条件：TPOT 50 ms，TTFT 5,000 ms，输入 32,768 tokens，输出 1,024 tokens。对比方案：9 台 8 卡 HGX H100（风冷，400 Gb IB）vs 18 块 GB200 Superchip（液冷，NVL72），per GPU 性能对比。

​
3.2 GB300 NVL72 (2025)

GB300 NVL72（Blackwell Ultra）在同一机柜架构上升级：显存从 192 GB 增至 288 GB HBM3e，FP4 Tensor Core 密度提升 1.5 倍，Attention 性能提升 2 倍。
指标GB200（Blackwell）GB300（Blackwell Ultra）
制程TSMC 4NPTSMC 4NP
晶体管208B208B
NVFP4 dense / sparse10 / 20 PFLOPS15 / 20 PFLOPS
FP8 dense / sparse5 / 10 PFLOPS5 / 10 PFLOPS
Attention 加速（SFU EX2）5 TeraExponentials/s10.7 TeraExponentials/s
HBM 容量192 GB HBM3e288 GB HBM3e
HBM 带宽8 TB/s8 TB/s
NVLink 带宽1.8 TB/s1.8 TB/s
最大功耗（TGP）1,200W1,400W

​
3.3 Vera Rubin NVL72 (2026)

Vera Rubin NVL72 整合了 72 块 Rubin GPU、36 颗 Vera CPU、ConnectX-9 SuperNIC 和 BlueField-4 DPU。通过 NVLink 6 实现机架内 scale-up，通过 Quantum-X800 InfiniBand 或 Spectrum-X Ethernet 实现跨机架 scale-out。 Vera Rubin NVL72 基于第三代 MGX 机架设计，可从上一代 Blackwell 平滑过渡。相比 Blackwell，训练仅需 1/4 的 GPU 数量，推理每百万 token 成本降至 1/10。
MGX（Modular GPU Accelerated）是 NVIDIA 的开放标准化机架架构，定义了机柜的机械尺寸、电源、冷却和线缆的统一规范。2024 年 NVIDIA 将 GB200 NVL72 的设计贡献给了 Open Compute Project（OCP）。所有 NVL72 机柜（GB200、GB300、Vera Rubin）都基于 MGX 架构，共用相同的电源、冷却和机械规格，由 80+ 全球合作伙伴的供应链支撑。这意味着数据中心可以在不重新设计基础设施的前提下跨代升级——从 Blackwell 到 Vera Rubin 只需更换计算托盘，机柜外壳、冷却管路和电源母线保持不变。

​
3.4 Vera Rubin POD (2026)

现代 Agentic AI 系统需要规划任务、调用工具、执行代码、检索数据，并在多个 AI Agent 之间协调连续的多步工作流。这些交互会产生大量推理 token、扩展 KV cache，并需要基于 CPU 的沙箱环境来测试和验证加速计算系统生成的结果，对 GPU、CPU、scale-up 域、scale-out 网络和存储都提出了低延迟、高吞吐的要求。 Vera Rubin POD 通过横跨计算、网络和存储的 7 种芯片极致协同设计，构建了最先进的 POD 级 AI 平台：40 个机柜、1.2 × 10¹⁵ 个晶体管、近 20,000 块 NVIDIA 芯片、1,152 块 Rubin GPU、60 exaFLOPS、10 PB/s 总 scale-up 带宽。
NVIDIA Vera Rubin POD consisting of 40 racks forming one AI supercomputer
Vera Rubin POD 引入了 5 种全新的专用机架级系统，面向需要高吞吐、极低延迟推理、密集 CPU 沙箱和大规模上下文内存存储的 Agentic AI 工作负载。
Five rack types in Vera Rubin POD: NVL72, Groq 3 LPX, Vera CPU, BlueField-4 STX, Spectrum-6 SPX
NVIDIA Vera Rubin NVL72：核心计算引擎 Vera Rubin NVL72 是最新 AI 工厂的核心机架级计算引擎。72 块 Rubin GPU 和 36 颗 Vera CPU 通过大规模 NVLink 铜缆脊柱互连，如同一块巨型 GPU。它针对 AI 的四种 scaling law 设计：预训练、后训练、test-time scaling 和 agentic scaling，可针对复杂的 MoE 路由以及 AI 推理中计算密集型的上下文阶段进行优化。相比 Blackwell，训练性能提升 4 倍，推理性能/瓦提升 10 倍，每百万 token 成本降至 1/10。 NVIDIA Groq 3 LPX：低延迟推理加速 NVIDIA Groq 3 LPX 与 NVIDIA Vera Rubin 平台协同设计，旨在满足智能体 AI 对海量上下文和低延迟的需求，每个机架配备 256 个语言处理单元（LPU）。它与 Vera Rubin NVL72 搭配使用，消除了高速交互性与吞吐量之间的权衡。通过将高带宽、仅采用 SRAM 的 LPU 与拥有大容量 HBM 的 Rubin GPU 融合，系统在长上下文长度下实现了低延迟和高吞吐，在不牺牲系统吞吐量的前提下，大幅增强了万亿参数模型的用户交互体验。相较于 Blackwell，Vera Rubin NVL72 加 LPX 可为万亿参数模型带来高达 35 倍的 token 产出和高达 10 倍的收入机会。欲了解更多信息，请参见 Inside NVIDIA Groq 3 LPX。 NVIDIA Vera CPU Rack：大规模智能体 AI 与强化学习 NVIDIA Vera CPU Rack 在高密度液冷机架中集成了最多 256 颗 NVIDIA Vera CPU，提供可扩展且高能效的容量。单个机架可支持超过 22,500 个并发强化学习（RL）或智能体沙箱环境，从而最大化可用于测试、执行和验证 Vera Rubin NVL72 与 LPX 机架输出结果的环境数量。Vera CPU Rack 为大规模智能体 AI 与强化学习提供基础，相比传统机架级 CPU，效率提升 2 倍，速度提升 50%。欲进一步了解 Vera CPU 如何为 AI 工厂提供高性能带宽和高效率，详见 NVIDIA Vera CPU Delivers High Performance, Bandwidth, and Efficiency for AI Factories。 NVIDIA BlueField-4 STX：AI 原生存储 NVIDIA BlueField-4 STX 机架基于 NVIDIA BlueField-4 处理器构建，该处理器结合了 Vera CPU 与 ConnectX-9 SuperNIC，并通过 Spectrum-X Ethernet 网络实现横向扩展。 它承载 NVIDIA CMX 上下文内存存储平台。这是一类全新的 AI 原生存储基础设施，可在整个 POD 内无缝扩展 GPU 上下文容量，并通过将 KV cache 卸载到专用高带宽存储层来加速推理。CMX 针对海量上下文内存（KV cache）的存储与服务进行了优化，将临时推理上下文视为一种 AI 原生的共享数据类型，可在回合、会话和 Agent 之间重复使用。与传统存储方案相比，这可带来高达 5 倍的每秒 token 产出和高达 5 倍的能效提升。 NVIDIA Spectrum-6 SPX：网络机架 NVIDIA Spectrum-6 SPX 网络机架将整个 POD 连接成一台超级计算机。Spectrum-6 SPX 网络机架专为加速 AI 工厂内的东西向与南北向流量而设计。它可配置为 Spectrum-X Ethernet 或 NVIDIA Quantum-X800 InfiniBand 交换机，在大规模部署下提供低延迟、高吞吐的机架间连接。 Spectrum-6 SPX 机架现集成了 102.4 Tb/s 的 Spectrum-6 交换机，该交换机提供 512 通道，并在单芯片和多芯片交换机形态中采用 200 Gb/s 的共封装光学（CPO）方案。这种硅光集成取代了可插拔光模块，在保证 AI 工作负载在计算与存储环境之间保持高度同步的同时，提供了最高的能效与可靠性、极低的时延和抖动，以及几乎完美的有效带宽。
Spectrum‑X Ethernet 面向 AI 云和企业数据中心，是“为 AI 优化的以太网”。它在保留以太网开放生态（TCP/IP、RoCEv2 等）的前提下，针对大模型训练和推理做了拥塞控制、流量调度和端到端优化，优势是兼容现有基础设施、部署灵活，也更适合多租户场景。NVIDIA Quantum‑X800 InfiniBand 面向极致性能需求的 800G InfiniBand 平台，主要服务于万亿参数级模型训练、HPC 和超大规模 AI 工厂。它强调超低时延、网络内计算（In-Network Computing）和强集体通信能力，更适合追求训练规模与性能上限的场景。

​
3.5 Vera Rubin Ultra (2027)

Vera Rubin Ultra 引入了一种全新的两层全互连 NVLink 拓扑，使开发者能够将 scale-up 扩展到 576 块 GPU。Vera Rubin Ultra NVL576 将由 8 个独立的 MGX NVL 机柜组成，每个机柜配备 72 块 Rubin Ultra GPU，并通过铜缆和直连光互连构成一个统一的 576-GPU NVLink 域。它将基于同一套 MGX 机架级生态系统构建，以实现最快的产品落地速度。 作为这一大规模多机柜 NVLink 拓扑的演示系统，Polyphe 是 NVIDIA 内部一个基于 GB200 的全功能原型，用于验证多机柜 NVL576 scale-up 架构。
NVIDIA Polyphe 原型，多机柜 NVL576 scale-up 系统

​
3.6 Feynman (2028)

为了扩展到 NVL576 之上，NVIDIA 将引入一款新的 MGX 机柜：NVIDIA Kyber。NVIDIA Kyber 是下一代 MGX NVL 机柜设计，可将每个机柜内的 NVLink 域规模翻倍，容纳 144 块 GPU。
NVIDIA Kyber NVL1152 机架架构示意图
NVIDIA Kyber 将使用类似的机柜间直连光互连，扩展为大规模全互连的 NVL1152 超级计算机。Kyber 为基于 NVIDIA Feynman 的下一代极致 scale-up AI 计算奠定基础。 Kyber 将首先随 Vera Rubin Ultra 以独立 NVL144 系统的形式推出，为客户提供 Vera Rubin Ultra NVLink scale-up 域的三种选择：NVL72、NVL144 和旗舰 NVL576。 参考资料

​
4. 协同设计（Co-design）

在计算领域，协同设计指的是编写对底层硬件特性有深刻认知的软件。在 AI 背景下，它更具体地意味着让算法、软件与硬件能力协同设计，以最大化性能；FlashAttention、MLA 和低精度量化正是三个典型例子。

​
4.1 FlashAttention

真实系统里的经验反复说明，哪怕只是 GPU kernel 或内存访问模式上的小改动，也可能带来远超直觉的收益。FlashAttention 就是一个经典例子：它没有改变 Transformer 注意力的数学定义，而是以一种更贴近硬件的方式重写 attention 计算。它的核心做法是把 GPU 上的计算切成 tile，尽量减少对显存的读写次数，从而显著降低数据搬运开销并加快 attention 计算。 FlashAttention-1（2022） 首次把 attention 明确地当成一个 I/O 问题来处理。 要理解 FlashAttention 在优化什么，先看 GPU 内部的数据流动方式。
GPU 有两级存储：HBM（High Bandwidth Memory）容量大（A100 为 40 GB）但带宽相对有限（1.5 TB/s）；SRAM（片上共享内存）容量很小（A100 约 20 MB）但带宽极高（19 TB/s）。每个 CUDA kernel 的执行流程都是：从 HBM 读入数据 → 搬到 SRAM 计算 → 把结果写回 HBM。计算本身很快，瓶颈往往在 HBM 的读写上。 标准 attention 的 I/O 瓶颈
这张图上半部分展示的是标准 attention 的核心计算流程 O=softmax(QKT)VO = softmax(QK^T)V。按图中的执行顺序，可以把标准 attention 理解成下面几步：
  • 第 1 步：从 HBM 读入 Q 和 K。
  • 第 2 步：在 SRAM 中做一次矩阵乘法，计算 S=Q⋅KTS = Q \cdot K^T。
  • 第 3 步：把中间矩阵 SS 写回 HBM。
  • 第 4 步：再把 SS 从 HBM 读回。
  • 第 5 步：在 SRAM 中计算 P=Softmax(S)P = Softmax(S)。
  • 第 6 步：把中间矩阵 PP 写回 HBM。
  • 第 7 步：再把 PP 和 V 从 HBM 读回。
  • 第 8 步：在 SRAM 中做第二次矩阵乘法，计算 O=P⋅VO = P \cdot V。
  • 第 9 步：把输出矩阵 OO 写回 HBM。
问题在于，中间的 N×NN \times N 矩阵 SS 和 PP 都会被先写入 HBM、再从 HBM 读回。计算本身并不慢，真正昂贵的是这些大矩阵在 HBM 和 SRAM 之间来回搬运。
Attention matrix shapes showing Q, K, V, O as N by d and S, P as N by N
在 attention 的核心计算流程里，我们真正需要的输入和输出都是 N×dN \times d 的矩阵（Q、K、V、O），但中间会额外产生两个 N×NN \times N 的矩阵：分数矩阵 SS 和概率矩阵 PP。NN 是序列长度，dd 是单个 attention head 的维度（通常为 64 或 128；例如 hidden size = 4096、num heads = 32 时，dhead=4096/32=128d_{head} = 4096 / 32 = 128）。当 NN 远大于 dd 时，这两个中间矩阵会比输入输出大得多：
序列长度 NN单个 N×NN \times N 矩阵元素数输入 N×dN \times d（d=128d=128）元素数
4,0961,600 万52 万
65,53643 亿838 万
最直接的优化思路是 kernel fusion：把原本分开的 matmul、softmax、matmul 尽量融合起来，中间结果留在 SRAM 里，HBM 只做首尾两趟读写。 但直接融合有一个核心障碍：softmax 无法分块计算。
Softmax 是按行计算的：每个元素 pijp_{ij} 的分母 ∑jesij\sum_j e^{s_{ij}} 需要该行所有元素。 这意味着 softmax kernel 需要一次读到整行数据，无法像 matmul 那样用 block tiling 分块处理。Matmul 每次只需要一小块数据就能算出部分结果，softmax 却必须看到整行，两个 kernel 需要的数据粒度不同，所以无法直接融合。
在 attention 中，Q⋅KTQ \cdot K^T 算出的 score 矩阵 SS 只是原始的相似度分数，数值范围不固定，可正可负。Softmax 的作用是把每一行转换成概率分布：所有值变为正数且加起来等于 1，表示当前 token 对其他各 token 的关注程度。以一行 score s=[2,4,1,3]s = [2, 4, 1, 3] 为例：
步骤 1：对每个元素取 exp
  exp(2)=7.39, exp(4)=54.60, exp(1)=2.72, exp(3)=20.09

步骤 2：求和（这就是分母，需要整行数据）
  sum = 7.39 + 54.60 + 2.72 + 20.09 = 84.79

步骤 3：每个 exp 值除以 sum
  softmax = [7.39/84.79, 54.60/84.79, 2.72/84.79, 20.09/84.79]
          = [0.087, 0.644, 0.032, 0.237]
结果表明：当前 token 把 64.4% 的注意力放在第 2 个 token 上，23.7% 放在第 4 个，其余两个各占不到 10%。关键问题在步骤 2：分母需要整行所有元素的 exp 之和。如果只看到一半数据（比如 block tiling 只载入了 [2,4][2, 4]），算出的分母是 7.39+54.60=61.997.39 + 54.60 = 61.99，和完整分母 84.7984.79 不同，结果就是错的。这就是 softmax 阻止 kernel fusion 的根本原因。实际实现中还有一个数值稳定性技巧：先减去最大值再取 exp（即算 exi−max⁡(x)e^{x_i - \max(x)}），防止 exie^{x_i} 在 xix_i 很大时溢出。这个最大值同样需要看到整行数据。
FlashAttention 的解法 — Online softmax 核心是把 softmax 分解成可递推的形式。 假设向量 xx 被分成两块 x(1)x^{(1)} 和 x(2)x^{(2)}，标准 softmax 需要一次看到所有元素，但 online softmax 可以先算第一块、再用第二块修正： m(1)=max⁡(x(1)),ℓ(1)=∑iexi(1)−m(1)m^{(1)} = \max(x^{(1)}), \quad \ell^{(1)} = \sum_i e^{x^{(1)}_i - m^{(1)}} m(2)=max⁡(m(1), max⁡(x(2))),ℓ(2)=em(1)−m(2)ℓ(1)+∑iexi(2)−m(2)m^{(2)} = \max(m^{(1)},\, \max(x^{(2)})), \quad \ell^{(2)} = e^{m^{(1)} - m^{(2)}} \ell^{(1)} + \sum_i e^{x^{(2)}_i - m^{(2)}} mm 跟踪全局最大值（数值稳定），ℓ\ell 跟踪 exp 求和（softmax 分母）。每来一块新数据，用 emold−mnewe^{m_{old} - m_{new}} 修正旧的 ℓ\ell，再累加新块的 exp。 输出 OO 也做同样的 rescaling： O(2)=ℓ(1)em(1)−m(2)ℓ(2)⋅O(1)+1ℓ(2)⋅P~(2)V(2)O^{(2)} = \frac{\ell^{(1)} e^{m^{(1)} - m^{(2)}}}{\ell^{(2)}} \cdot O^{(1)} + \frac{1}{\ell^{(2)}} \cdot \tilde{P}^{(2)} V^{(2)} 其中 P~(2)\tilde{P}^{(2)} 是第二块的未归一化 attention 权重，V(2)V^{(2)} 是与这块权重对应的 value 子矩阵。前面的 em(1)−m(2)e^{m^{(1)} - m^{(2)}} 是显式的 rescaling 因子：如果第二块引入了更大的最大值，就要先把第一块的输出缩放到新的基准上；只有当 m(2)=m(1)m^{(2)} = m^{(1)} 时，这一项才会退化为 1。 这个递推可以扩展到任意多块，每次只需要一小块数据在 SRAM 里就能推进，数学上与标准 softmax 完全等价。这样 softmax 就能和 matmul 在相同的 block tile 上融合执行。
用 score 向量 [2,4,1,3][2, 4, 1, 3] 分两块处理来说明。处理第一块 [2,4][2, 4]
m₁ = 4（当前最大值，用于数值稳定）
ℓ₁ = exp(2-4) + exp(4-4) = 0.135 + 1 = 1.135
用这个局部 softmax 权重乘以 V 的第一块（即前两个 token 对应的 value 向量 v1,v2v_1, v_2），得到临时输出 O1O_1。此时 O1O_1 只按第一块做了归一化，对应的 softmax 分母还是局部的 ℓ1=1.135\ell_1 = 1.135，还不是看到全部 token 后的最终答案。处理第二块 [1,3][1, 3]
m₂ = max(4, 3) = 4（全局最大值没变）
ℓ₂ = ℓ₁ + exp(1-4) + exp(3-4) = 1.135 + 0.050 + 0.368 = 1.553
分母从 1.135 变成了 1.553。之前的 O1O_1 是按旧分母 1.135 算的，现在需要修正：
O₂ = (ℓ₁/ℓ₂) × O₁ + 新块的贡献
   = (1.135/1.553) × O₁ + ...
   = 0.731 × O₁ + ...
ℓ1/ℓ2=0.731\ell_1 / \ell_2 = 0.731 是这个例子里的 rescaling 系数。它把 O1O_1 等比缩小，补偿”分母变大了”这个事实，再加上第二块 token 的贡献。这里第二块的局部最大值是 3，但全局最大值仍然是 4，所以 m2=max⁡(4,3)=4m_2 = \max(4, 3) = 4，em1−m2=e4−4=1e^{m_1-m_2} = e^{4-4} = 1；rescaling 不再来自 max 基准的变化，而只来自 softmax 分母从 ℓ1=1.135\ell_1 = 1.135 扩大到 ℓ2=1.553\ell_2 = 1.553。对每个 query block，只维护一个当前输出块 OiO_i，并在 SRAM 中原地更新。 每处理完一块新的 K/V 数据，就先用 rescaling 系数 (ℓoldemold−mnew)/ℓnew\left(\ell_{old} e^{m_{old}-m_{new}}\right)/\ell_{new} 修正旧输出，再加上当前块带来的局部贡献。等所有块遍历完成后，OiO_i 就是该 query block 的最终输出。
算法流程
Forward pass 用两层嵌套循环：外层遍历 K、V 的分块（索引 jj），内层遍历 Q 的分块（索引 ii）。每次迭代在 SRAM 内完成局部 QKTQK^T、softmax、PVPV 的融合计算，滚动更新输出 OO 和统计量 mm、ℓ\ell。全程不把任何 N×NN \times N 矩阵写到 HBM，最终只写回 OO（N×dN \times d）和两个长度为 NN 的向量。
因为 SRAM 放不下完整的 Q、K、V。一个完整的 attention 要求每个 Q 行都和所有 K 列算 score，再对所有 V 行加权求和。如果只遍历 Q 的分块，每次处理一块 Q 时仍然需要把完整的 K 和 V 放在 SRAM 里 — 放不下。所以用两层循环：外层每次换一块 K、V，内层让所有 Q 块都和当前这块 K 算一次局部 score：
for j in range(K 的块数):      # 外层：每次换一块 K_j, V_j
    载入 K_j, V_j 到 SRAM
    for i in range(Q 的块数):  # 内层：每块 Q_i 都和当前 K_j 算一次
        载入 Q_i 到 SRAM
        局部 score = Q_i · K_j^T
        局部 softmax + rescaling
        O_i += 局部权重 · V_j   # 滚动更新输出
任意时刻 SRAM 里只有一块 Q_i（Br×dB_r \times d）、一块 K_j（Bc×dB_c \times d）、一块 V_j（Bc×dB_c \times d）和对应的小块中间结果，远小于 N×NN \times N。当外层循环走完所有 K 块后，每个 O_i 都已经和全部 K 算过、被 rescaling 到了正确值。
性能结果
FlashAttention 带来的收益非常直接：
  • 同样的模型训练更快
  • 同样的模型可以用更大的 batch size
  • 同样的预算可以训练更大（通常也更好）的模型
  • 可以训练更长上下文窗口的模型
  • 可以在更小的 GPU 上训练模型
以 OpenWebText 数据集为例，GPT-2 small 在 8×A100 上的训练时间从 9.5 天缩短到 2.7 天，GPT-2 medium 从 21.0 天缩短到 6.9 天。
FlashAttention-1 到 FlashAttention-4 的概览如下：
版本年份关键改进性能备注
FlashAttention-12022引入 I/O-aware 分块 attention；融合 softmax 与 matmul kernel；避免物化完整 attention 矩阵attention 速度提升 2-4 倍；显存占用最高降低 10 倍第一版；支持实用长上下文；exact attention（非近似）
FlashAttention-22023改进 warp / thread block 并行与 work partitioning；减少 non-matmul FLOPs相比 FA-1 再快约 2 倍，长序列下更明显支撑了很多长上下文 LLM；已广泛集成到训练和推理框架
FlashAttention-32024Tensor Core 加速（FP8/BF16）；针对 Hopper GPU（如 H100）优化相比 FA-2 最高再快 2 倍；H100 达到 740 TFLOPS（75% 利用率）；FP8 误差降低 2.6 倍面向 Hopper 的专门优化版本；把 WGMMA、TMA、FP8 等硬件能力真正用起来
FlashAttention-42026针对 Blackwell 重写 pipeline；fully asynchronous MMA；减少 non-matmul 和 backward pass 流量B200 BF16 达到 1613 TFLOPS（71% 利用率）；相较 cuDNN 最高快 1.3 倍；相较 Triton 最高快 2.7 倍面向 Blackwell；基于 CuTe-DSL 实现，继续针对新硬件重排瓶颈
参考资料

​
4.2 DeepSeek MLA

DeepSeek 的 MLA 算法以 NVIDIA GPU kernel 的形式实现，并于 2025 年开源，是软硬件协同设计的另一个例子。与 FlashAttention 类似，MLA 重新组织了 attention 计算，以更好地利用 NVIDIA 的内存层级和专用的 GPU Tensor Cores。这些优化使 MLA 能够更充分地利用受限的 H800 GPU 架构，以更低的成本实现更高的吞吐量，甚至在同样的 H800 系统上超过了 FlashAttention 的性能。
Comparison of MHA, GQA, MQA, and MLA showing different KV cache organizations during inference
MHA (Multi-Head Attention) 是标准 Transformer 里的注意力形式。每个 head 都有独立的 W_Q^(i)、W_K^(i)、W_V^(i)，每个头各自计算注意力，最后把所有头的输出拼接再投影回去。它的表达能力最完整，但 decode 阶段也必须为每个 head 缓存完整 K/V，因此 KV cache 最大。 MQA (Multi-Query Attention) 保留多个 query heads，但所有 heads 共享同一组 K/V。这样 KV cache 从 h 份降到 1 份，显著减轻显存占用和 HBM 读流量，推理速度通常更高；代价是不同 heads 看到的是同一套 K/V，表达能力往往弱于 MHA。 GQA (Grouped-Query Attention) 是 MHA 和 MQA 之间的折中。它把 h 个 query heads 分成 g 组，每组共享一套 K/V，因此总共有 g 份 K/V。它保留了更多头间差异，因此表达能力通常强于 MQA，但仍弱于每个 head 都独立持有 K/V 的 MHA。 MLA（Multi‑Head Latent Attention） 先把所有头的 K/V 合在一起做一次低维压缩，只把这个共享的 latent 表示写进 KV cache，然后在算注意力时，各个头再用自己的变换从同一个 latent 里解码出各自的 K/V。这样既大幅缩小了 KV cache 的体积，又保留了不同注意力头之间的差异，不像 MQA/GQA 那样只是简单地共用同一套 K/V。
机制KV cache 大小推理效率表达能力核心操作
MHA最大，随 head 数线性增加基线最高每个 head 独立 Q/K/V
MQA最小，只有 1 份 K/V最快或接近最快通常弱于 MHA所有 query heads 共享同一组 K/V
GQA中等，有 g 份 K/V比 MHA 快通常介于 MHA 和 MQA 之间query heads 分组，组内共享 K/V
MLA显著减少，缓存低维 latent实践中通常快于 MHA，接近 GQA/MQA在 DeepSeek 实验中可接近甚至超过 MHAK/V 低秩联合压缩 + head-specific 上投影

​
4.3 低精度量化

低精度量化 也是协同设计的典型体现。Transformer 的普及和 FP8、FP4 这类低精度格式的兴起，推动 NVIDIA 增加了 Transformer Engine、面向低精度计算的 Tensor Core、FP4 支持和 microscaling；而这些硬件能力又反过来让研究者可以探索新的数值优化器和神经网络结构，形成持续迭代的正反馈。

​
FAQ

MoE 的价值不是”比原来的小模型更省计算”，而是用”同样的计算量，换来了大得多的模型”。 例如 DeepSeek-V3 有 671B 总参数，但每 token 只需 37B 的计算量；如果用 dense 架构达到同样的知识容量，每 token 需要 671B 的计算量，MoE 省了 18 倍。
FlashAttention 降到 O(N)O(N) 的是 HBM 内存占用，不是计算量。Attention 本身就是每个 token 和所有 token 算 score，O(N2)O(N^2) 的计算是省不掉的。
计算量HBM 内存HBM I/O
标准 attentionO(N2⋅d)O(N^2 \cdot d)O(N2)O(N^2)O(N2)O(N^2)
FlashAttentionO(N2⋅d)O(N^2 \cdot d)（没变）O(N)O(N)O(N⋅d)O(N \cdot d)
标准实现把整个 N×NN \times N 的中间矩阵物化到 HBM，内存 O(N2)O(N^2)。FlashAttention 虽然两层循环遍历了所有 N2N^2 个 score，但任意时刻 SRAM 里只有一小块，算完就丢，HBM 里始终只存 Q、K、V、O（各 N×dN \times d）和统计量 mm、ℓ\ell（各长度 NN），所以内存是 O(N)O(N)。速度提升来自 I/O 减少（少搬了大量数据），不是因为算得少了。