GPU 与多卡基础

大模型的训练和推理离不开 GPU——动辄数十亿到万亿参数的模型，单靠一颗 GPU 远远不够，必须跨多张卡甚至多台机器协同计算。本页梳理 GPU 硬件基础、CUDA 编程模型、多卡并行范式与通信原语，帮助你理解 LLM 模型部署和 CV 模型部署背后的算力基础设施。关于推理侧的量化加速，参见量化与加速。

核心直觉

GPU 与 CPU 设计哲学的根本区别：CPU 追求单线程极致性能（深流水线、大缓存、复杂分支预测），GPU 追求海量线程的吞吐量（数千核心、简单控制逻辑、显式管理缓存）。

想象你在管理一个工厂：

CPU 是一位超级工程师——什么都能做，能处理复杂的工艺流程（分支逻辑），但只有几个这样的工程师，遇到简单但海量的重复任务时效率低。
GPU 是一支一万人的流水线工人队伍——每个人只会做简单的操作（乘加运算），但一万人同时干活，处理矩阵乘法这种”大规模重复计算”时碾压超级工程师。

深度学习的核心运算——矩阵乘法（GEMM）、卷积——恰好是”大规模简单重复计算”，所以 GPU 天生适合。一次前向传播中 90% 以上的浮点运算都是矩阵乘法，这正是 GPU 擅长的。

为什么不用 CPU 训练？ 一张 224×224 图片经过 ResNet-50 前向传播需要约 4 GFLOPs（40 亿次浮点运算）。一个 batch=256 的训练步骤需要约 1 TFLOP。顶级 CPU（如 AMD EPYC）双精度峰值约 1 TFLOPS，做一轮训练要 1 秒；而 NVIDIA H100 的 FP16 峰值约 2000 TFLOPS，同样一轮只需 0.5 毫秒——快 2000 倍。这就是 GPU 成为深度学习标配的根本原因。

CPU vs GPU 架构对比

维度	CPU	GPU
核心数量	8–128 个复杂核心	数千个简单核心（如 H100 有 16896 个 CUDA 核心）
单线程性能	极强（深流水线、大缓存、高主频）	较弱（简单控制、低主频）
并行模式	MIMD（每核心独立指令流）	SIMT（多线程执行同一指令）
缓存	大（L3 缓存可达数百 MB）	小且显式（L2 共享，程序员管理共享内存）
内存带宽	50–200 GB/s（DDR5）	1000–4000 GB/s（HBM3）
擅长任务	复杂控制流、串行逻辑、低延迟响应	大规模数据并行计算（矩阵乘、卷积）
典型功耗	200–400 W	350–700 W（数据中心级）

**SIMT（Single Instruction, Multiple Threads）**是 NVIDIA 的执行模型：32 个线程组成一个 warp，在同一时钟周期执行相同的指令，但各自操作不同的数据。如果你的代码出现分支分歧（warp 内部分线程走 if、部分走 else），这些线程会串行执行两条路径，性能减半。因此 GPU 编程要尽量减少分支分歧。

原理详解

GPU 内存层次

GPU 的内存是一个金字塔式的层次结构，从慢到快、从大到小：

从上到下：容量越来越小，但速度越来越快——寄存器访问仅需 1 个时钟周期，而全局内存需要 200–400 个周期。GPU 编程优化的核心就是尽量让数据留在离计算单元更近的高速存储中。

关键指标：算术强度（Arithmetic Intensity），即每字节内存访问执行的浮点运算次数（FLOP/Byte）。一个计算任务如果算术强度低（大量访存、少量计算），就是带宽受限（bandwidth-bound）；反之则是计算受限（compute-bound）。矩阵乘法是典型的计算受限操作，而 element-wise 操作（如激活函数、逐元素加法）是典型的带宽受限操作——这也是为什么大模型推理时逐元素操作成为瓶颈的原因。

Roofline 模型

Roofline 模型用一条折线直观描述 GPU 上某操作的可达性能上限：

\text{Attained FLOPS} = \min\left(\text{Peak FLOPS},\ \text{Arithmetic Intensity} \times \text{Memory Bandwidth}\right)

其中算术强度 $AI = \frac{\text{FLOPs}}{\text{Bytes}}$ 。在拐点之前（ $AI < AI^*$ ），性能受限于内存带宽；在拐点之后，性能受限于峰值算力。拐点处的算术强度为：

AI^* = \frac{\text{Peak FLOPS}}{\text{Memory Bandwidth}}

以 H100（SXM5）为例：FP16 峰值约 1979 TFLOPS，HBM3 带宽约 3.35 TB/s，则 $AI^* \approx 590$ FLOP/Byte。这意味着矩阵乘法的算术强度必须高于 590 才能跑满峰值——这也是 cuBLAS、cuDNN 等库通过分块（tiling）和共享内存复用来提升局部计算密度的原因。

在大模型推理场景中，解码阶段每次只生成一个 token，矩阵乘法退化为矩阵-向量乘（GEMV），算术强度极低（约 1–2 FLOP/Byte），完全受限于显存带宽。这就是为什么推理优化的重心不在算力而在带宽——KV Cache 压缩、PagedAttention、量化（将权重压缩到 INT8/FP8 以减少读取字节数）本质上都是在降低带宽压力。

CUDA 编程模型

CUDA（Compute Unified Device Architecture）是 NVIDIA 的并行计算平台和编程模型。它的核心抽象是网格-块-线程三级层次：

Grid（网格）：一次 kernel 启动的所有线程集合。
Thread Block（线程块）：一组协作的线程，在同一个 SM（Streaming Multiprocessor）上执行，可以共享内存和做块内同步。
Thread（线程）：最小执行单元，每个线程有唯一的 (blockIdx, threadIdx) 坐标。

**SM（Streaming Multiprocessor）**是 GPU 的基本计算单元，类似 CPU 的核心。一个 SM 内部包含若干 CUDA 核心、Tensor 核心、寄存器文件和共享内存。H100 有 132 个 SM。一个线程块在同一个 SM 上执行，多个块可以分配到不同 SM 上并行运行。

Tensor Core 与矩阵乘加速

现代 GPU 的矩阵乘法性能主要来自 Tensor Core（张量核心）——一种专门做小型矩阵乘加的硬件单元。一个 Tensor Core 在一个时钟周期内完成一个 $D = A \times B + C$ 运算，其中 $A$ 是 $16 \times 8$ 、 $B$ 是 $8 \times 8$ 、 $D$ 是 $16 \times 8$ 的矩阵（以 FP16 为例）。

D_{16 \times 8} = A_{16 \times 8} \times B_{8 \times 8} + C_{16 \times 8}

H100 的第四代 Tensor Core 支持 FP8、FP16、BF16、TF32、INT8、INT4 等多种精度，还支持稀疏计算（Structured Sparsity）——利用 2:4 结构化稀疏模式（每 4 个非零值中最多 2 个为零），在精度几乎无损的情况下把吞吐量翻倍。

GPU 架构	代表产品	Tensor Core 代际	关键精度	稀疏支持
Volta (2017)	V100	第一代	FP16	无
Ampere (2020)	A100	第三代	FP16/TF32/INT8/BF64	2:4 结构化稀疏
Hopper (2022)	H100	第四代	FP8/FP16/BF16/TF32	2:4 结构化稀疏
Blackwell (2024)	B200	第五代	FP4/FP8/FP16	2:4 + 细粒度稀疏

多卡并行范式

当模型或数据规模超出单卡容量时，必须使用多 GPU 并行。四种经典范式：

数据并行（Data Parallelism, DP）

最简单也最常用的范式。每张卡持有完整的模型副本，各自处理不同的数据子集，反向传播后通过 AllReduce 同步梯度。

g_{\text{global}} = \frac{1}{N}\sum_{i=0}^{N-1} g_i

其中 $g_i$ 是第 $i$ 张卡上计算的梯度， $N$ 是 GPU 数量。所有卡拿到相同的全局梯度后，各自做相同的参数更新，保持模型一致。

优点：实现简单（PyTorch 的 DistributedDataParallel 几行代码搞定），线性加速比好。缺点：模型必须放进单卡显存——对于参数量超过单卡显存的模型（如 70B 模型需要约 140 GB FP16 权重，超过 H100 的 80 GB），数据并行无能为力。

张量并行（Tensor Parallelism, TP）

将单个层的权重矩阵沿行或列切分到多张卡上，每张卡只持有权重的一部分。以线性层 $Y = XW$ 为例，列切分把 $W$ 按列拆成 $[W_1, W_2]$ ：

Y = X[W_1, W_2] = [XW_1,\ XW_2]

每张卡计算自己负责的列块，结果通过 AllGather 拼接成完整的 $Y$ 。行切分则把 $W$ 按行拆开，每张卡做部分乘加后通过 AllReduce 求和。

# 张量并行：列切分（Megatron-LM 风格）
import torch.nn as nn

class ColumnParallelLinear(nn.Module):
    """将权重 W 按列切分到 world_size 张卡上"""
    def __init__(self, in_features, out_features, world_size):
        super().__init__()
        assert out_features % world_size == 0
        self.local_out = out_features // world_size  # 每卡负责的输出维度
        self.weight = nn.Parameter(torch.empty(self.local_out, in_features))
        self.bias = nn.Parameter(torch.empty(self.local_out))

    def forward(self, x):
        # 每卡只算自己那份输出：x @ W_i^T
        output = nn.functional.linear(x, self.weight, self.bias)
        # 此处需要 AllGather 拼接所有卡的输出（通信原语）
        return all_gather(output, dim=-1)

张量并行在 Transformer 的注意力层和前馈网络（FFN）中尤为高效。Megatron-LM 的核心贡献就是设计了 GEMM 级别的切分方案，让每层只需 2 次通信（forward 的 AllReduce / AllGather + backward 的一次），通信开销极小。张量并行通常在机内使用（NVLink 互联），跨机通信开销过大。

流水线并行（Pipeline Parallelism, PP）

将模型按层划分为若干阶段（stage），每个阶段放在不同的 GPU 上。数据像流水线上的产品一样依次经过各阶段。以 4 卡、4 层为例：

朴素流水线的问题是气泡（bubble）——后面的 GPU 在等待前面阶段的结果时处于空闲状态。解决方案是 微批（Micro-batching）：把一个 batch 拆成多个 micro-batch，让多个 micro-batch 像流水线上的产品一样同时在各阶段流动，填满气泡。

设总 micro-batch 数为 $M$ 、阶段数为 $P$ ，则流水线气泡占总时间的比例为：

\text{Bubble Fraction} = \frac{P - 1}{M + P - 1}

当 $M \gg P$ 时气泡接近 0，但 $M$ 太小（如 $M = P$ ）时气泡占比很大（约 $\frac{P-1}{2P-1} \approx 50\%$ ）。常见的 1F1B（一个前向一个后向交错）和 Interleaved Pipeline 调度就是用来进一步压缩气泡的技术。

零气泡（Zero Bubble）：2024 年微软提出的 ZB-H1 / ZB-H2 调度策略，通过在流水线中插入独立的反向计算来”填满”气泡，理论上气泡率可降至接近 0，是当前流水线调度研究的前沿方向。

三维混合并行

大规模训练（如 LLM 预训练）通常组合使用三种并行：

并行维度	切分对象	典型规模	通信特征
数据并行（DP/DP）	Batch / 梯度	数百到数千卡	AllReduce（大消息，跨节点）
张量并行（TP）	权重矩阵内部	2–8 卡（机内）	AllReduce / AllGather（小消息，NVLink）
流水线并行（PP）	层的分段	数十阶段	点到点（activation 传递）

三者组合（如 3D Parallelism / Megatron-LM / DeepSpeed）可以将万亿参数模型的训练分布到数千张 GPU 上。总 GPU 数 = $N_{DP} \times N_{TP} \times N_{PP}$ 。

通信原语与 NCCL

多卡并行的效率瓶颈往往不在计算而在通信。NVIDIA 的 **NCCL（NVIDIA Collective Communications Library）**是事实标准库，封装了 GPU 间的集合通信原语：

原语	操作	典型用途
AllReduce	所有卡将数据求和后，每张卡拿到相同的汇总结果	数据并行梯度同步
AllGather	每张卡收集所有卡的数据，拼接成完整结果	张量并行前向输出拼接
ReduceScatter	求和 + 分散：将求和结果按分片分发给各卡	ZeRO 优化器的梯度分片
Broadcast	一张卡的数据广播到所有卡	参数初始化同步
All-to-All	每张卡向其他每张卡发送不同的数据	专家路由（MoE）

Ring AllReduce：AllReduce 最经典的实现算法。将 $N$ 张卡组成一个逻辑环，数据分 $N$ 块沿环传递，经过 $2(N-1)$ 步完成。总通信量为 $\frac{2(N-1)}{N} \times \text{DataSize}$ ，与 GPU 数量 $N$ 几乎无关——这正是数据并行能线性扩展的理论基础。但当 $N$ 极大（数千卡）时，环太长导致延迟叠加，需要采用层次化（hierarchical）通信或树形（tree）算法。

动手实践：PyTorch 多卡训练

DistributedDataParallel（DDP）

DDP 是 PyTorch 官方的数据并行方案，每个进程持有一份完整模型副本，通过 NCCL 在反向传播时自动同步梯度：

import os
import torch
import torch.distributed as dist
import torch.multiprocessing as mp
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.data import DataLoader, DistributedSampler

def train(rank, world_size):
    # 1. 初始化进程组（NCCL 后端用于 GPU 通信）
    os.environ["MASTER_ADDR"] = "localhost"
    os.environ["MASTER_PORT"] = "12355"
    dist.init_process_group("nccl", rank=rank, world_size=world_size)
    torch.cuda.set_device(rank)

    # 2. 模型：每卡一份完整副本
    model = MyModel().cuda(rank)
    model = DDP(model, device_ids=[rank])

    # 3. 数据：DistributedSampler 自动按卡切分数据
    sampler = DistributedSampler(dataset, shuffle=True)
    loader = DataLoader(dataset, batch_size=32, sampler=sampler)

    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)

    for epoch in range(num_epochs):
        sampler.set_epoch(epoch)  # 重要！确保每轮 shuffle 不同
        for batch in loader:
            loss = model(batch)
            loss.backward()        # DDP 自动在反向传播时做 AllReduce 梯度同步
            optimizer.step()
            optimizer.zero_grad()

    dist.destroy_process_group()

if __name__ == "__main__":
    world_size = torch.cuda.device_count()
    mp.spawn(train, args=(world_size,), nprocs=world_size)

DDP 的关键优化：梯度同步与反向传播重叠（overlap）。当某层的梯度计算完成后，DDP 立即在后台启动该层的 AllReduce，同时继续做下一层的反向传播——通信被计算”藏”了起来，对端到端时间几乎零开销。要启用此优化，需保证模型足够大（每层通信量相对于计算量足够小）。

用 torchrun 启动（推荐）

实际项目中不需要手动 mp.spawn，推荐用 PyTorch 的 torchrun 启动器：

# 单机 4 卡
torchrun --nproc_per_node=4 train.py

# 双机 8 卡（每机 4 卡）
# 机器 0：
torchrun --nnodes=2 --nproc_per_node=4 \
    --rdzv_backend=c10d --rdzv_endpoint=192.168.1.1:29500 train.py
# 机器 1：
torchrun --nnodes=2 --nproc_per_node=4 \
    --rdzv_backend=c10d --rdzv_endpoint=192.168.1.1:29500 train.py

torchrun 会自动设置环境变量（RANK、WORLD_SIZE、MASTER_ADDR 等）、处理进程容错（某卡崩溃自动重启）和弹性训练，是生产环境的标准做法。

实践要点与最佳实践

优先用 DDP：如果模型放得进单卡，DDP 几乎总是最佳选择——线性加速比好、代码改动小、调试容易。不要过早引入张量/流水线并行。
batch size 要够大：多卡训练的通信开销是固定的（与 batch 大小无关）。batch 太小会导致计算/通信比过低，GPU 利用率低。一般要求每卡 batch × 卡数后的总 batch 足够大（如 256+）才能摊薄通信成本。
混合精度训练（AMP）：用 FP16 或 BF16 做前向/反向，FP32 维护主权重。通信量减半、计算快 2–3 倍、显存省一半，精度几乎无损。用 torch.cuda.amp.autocast 几行代码搞定。
梯度累积（Gradient Accumulation）：显存不够开大 batch 时，分多次小 batch 前向/反向、累积梯度后再更新。数学上等价于大 batch，代价是训练速度略降。
ZeRO 优化器（DeepSpeed）：当 DDP 的”每卡完整模型副本”成为显存瓶颈时，ZeRO 将优化器状态 / 梯度 / 参数分片到各卡，根据阶段（ZeRO-1/2/3）可大幅降低单卡显存。ZeRO-3 本质上是更灵活的数据并行 + 参数分片，不需要改模型代码。
张量并行放在机内：TP 通信频繁、延迟敏感，务必用 NVLink/NVSwitch 连接的同一节点内的 GPU。跨节点 TP 性能急剧下降。
流水线并行放在层间：PP 通信是点到点的（传递 activation），跨节点开销相对可控，适合跨机器切分超大模型。
通信后端选 NCCL：GPU 之间始终用 NCCL（nccl 后端），CPU 之间用 Gloo（gloo 后端）。混合 CPU+GPU 时主通信走 NCCL。
梯度裁剪（Gradient Clipping）：大模型多卡训练中梯度范数波动大，用 torch.nn.utils.clip_grad_norm_ 防止梯度爆炸，裁剪阈值一般设 1.0。
监控通信开销：用 torch.proiler 的 NCCL trace 查看通信占比。如果通信时间超过总时间的 30%，说明并行策略需要调整（增加计算/通信比或换用更高效的并行方案）。
节点内拓扑感知：多机训练时确保 NCCL 利用 NVLink / NVSwitch 进行机内通信，InfiniBand 用于跨机通信。nccl-tests 工具可以验证实际带宽和延迟。
容错与断点续训：大规模训练中硬件故障是常态。务必定期保存 checkpoint（包括优化器状态、数据迭代位置、随机种子），用 torch.distributed.checkpoint 做分布式保存（避免单卡瓶颈）。

GPU 互联技术

多卡协同的效率严重依赖卡间互联带宽，不同连接方式差异巨大：

互联方式	带宽（单向）	典型延迟	适用场景
PCIe 4.0 x16	~32 GB/s	~5 μs	入门级多卡，消费级主板
PCIe 5.0 x16	~64 GB/s	~3 μs	新一代服务器平台
NVLink 4.0（H100）	900 GB/s（双向）	~1 μs	数据中心，同节点 8 卡全互联
NVLink 5.0（B200）	1800 GB/s（双向）	< 1 μs	最新 Blackwell 架构
InfiniBand HDR	200 Gb/s (25 GB/s)	~1 μs	跨节点高速互联
InfiniBand NDR	400 Gb/s (50 GB/s)	< 1 μs	最新大规模集群
RoCE v2（以太网）	200–400 Gb/s	~2 μs	基于 Ethernet 的 RDMA 方案

NVLink 与 PCIe 的差距是数量级的：NVLink 4.0 的双向带宽是 PCIe 4.0 的近 28 倍。这也是为什么张量并行（需要极频繁的卡间通信）只能在 NVLink 互联的机内使用，而跨机一般留给对带宽需求相对较低的流水线/数据并行。

2025–2026 最新进展

Blackwell 架构与 FP4 推理

2024 年发布的 NVIDIA Blackwell（B200/GB200）将数据中心 GPU 推向新高度：

第五代 Tensor Core：原生支持 FP4（4 位浮点）精度，推理吞吐量比 H100 FP8 高约 30 倍。FP4 在保持可接受精度损失的前提下，把权重和激活的内存占用再砍半。
GB200 NVL72：72 颗 B200 通过 NVLink 全互联组成的”超级芯片”，可部署超 13 万亿参数的模型推理，单机架替代此前需要数十台服务器的集群。
RAS 引擎与可靠性：内置遥测和自修复机制，大规模训练的 MTBF（平均无故障时间）显著改善。

AMD MI300X 挑战 NVIDIA

AMD 的 MI300X（2023 年底发布）以 192 GB HBM3 显存对标 H100 的 80 GB，成为大模型推理的有力竞争者：

显存是 H100 的 2.4 倍，单卡可放下 70B 模型的权重 + 上下文，无需切分。
ROCm 6.x 生态持续完善，PyTorch 原生支持日趋成熟。
2025 年 MI325X / MI350 系列进一步将显存推到 256 GB / 288 GB，FP8 算力追平甚至超过同期 NVIDIA 产品。

国产 GPU 生态崛起

2024–2026 年，受地缘因素驱动，中国国产 AI 加速芯片生态加速发展：

华为昇腾（Ascend）910B/910C：算力对标 A100/H100，CANN 软件栈逐步成熟，MindSpore + PyTorch 双轨支持，已在多个万卡集群中用于大模型训练。
寒武纪思元（MLU）590/690：支持 INT8/FP16/BF16 多精度推理与训练。
摩尔线程、壁仞、燧原等厂商在推理侧切入，逐步建立 CUDA 兼容层（如摩尔线程 MUSA），降低迁移门槛。

国产 GPU 的核心挑战仍在软件生态：CUDA 的护城河不仅仅是硬件性能，而是十几年来积累的库（cuBLAS、cuDNN、NCCL）、工具链（Nsight、PyTorch/CUDA kernel）和开发者社区。2025–2026 年各家正全力补齐这一层。

通信与网络的新范式

Ultra Ethernet Consortium（UEC）：由 Meta、Google、AMD、Intel 等牵头，目标是打造比 InfiniBand 更开放、更可扩展的超大规模 AI 网络标准。2025 年首批 UEC 兼容产品上市，有望降低超大集群的网络成本。
CXL（Compute Express Link）：允许 GPU 与 CPU 共享内存池，未来可能实现”显存外溢到 host 内存”的透明扩展，缓解大模型推理的 KV Cache 瓶颈。
光学互联（Optical Interconnect）：NVIDIA Silicon Photonics、Ayar Labs 等推动在 GPU 互联中引入光路，将跨机带宽从电互联的几十 GB/s 推向 TB/s 级别。

弹性训练与容错

万卡以上规模训练的故障率逼近每小时数次，容错成为核心工程问题：

弹性数据并行：PyTorch 2.x 的 Elastic Agent 支持运行时动态增减 GPU，某节点故障时自动缩容继续训练，恢复后自动扩容。
异步 Checkpoint：将 checkpoint 保存与训练重叠，借助 torch.distributed.checkpoint 的异步写入把保存开销从分钟级降到秒级。
冗余计算：部分关键层在多卡上冗余计算，保证单卡故障时不中断，牺牲少量算力换取更高的可用性。

典型类库与工具

类库 / 工具	语言	说明
PyTorch DDP	Python	PyTorch 官方数据并行，`torch.nn.parallel.DistributedDataParallel`
DeepSpeed	Python	微软开源分布式训练框架，ZeRO 优化器 + 混合精度 + 流水线
Megatron-LM	Python	NVIDIA 开源的大模型张量并行 / 流水线并行框架
FSDP	Python	PyTorch 官方 Fully Sharded Data Parallel，对标 DeepSpeed ZeRO-3
NCCL	C++/CUDA	NVIDIA 集合通信库，AllReduce/AllGather 等底层原语
torchrun	Python	PyTorch 内置分布式启动器，支持多机多卡 + 弹性容错
NVIDIA Nsight	C++/GUI	GPU 性能分析工具（Nsight Systems / Compute），定位瓶颈
nccl-tests	C++/CUDA	NCCL 带宽/延迟基准测试工具

术语表

术语	英文	解释
图形处理器	GPU (Graphics Processing Unit)	大规模并行计算芯片，深度学习的主要算力来源
流多处理器	SM (Streaming Multiprocessor)	GPU 的基本计算单元，包含多个 CUDA 核心和 Tensor Core
张量核心	Tensor Core	GPU 内部专门做小型矩阵乘加的硬件单元，矩阵运算性能的核心来源
算术强度	Arithmetic Intensity	每字节内存访问执行的浮点运算次数（FLOP/Byte），决定计算是带宽还是算力受限
Roofline 模型	Roofline Model	用算术强度和内存带宽折线描述硬件性能上限的模型
数据并行	Data Parallelism (DP)	每卡持有完整模型副本，各自处理不同数据，反向传播后 AllReduce 同步梯度
张量并行	Tensor Parallelism (TP)	将单层权重矩阵沿行/列切分到多卡，卡间通过 AllReduce/AllGather 协作
流水线并行	Pipeline Parallelism (PP)	将模型按层切分为多个阶段，各阶段在不同 GPU 上流水线执行
集合通信	Collective Communication	多个进程间的通信模式，如 AllReduce、AllGather、Broadcast
AllReduce	AllReduce	所有进程的数据求和后每进程拿到相同结果的核心通信原语
气泡	Pipeline Bubble	流水线中 GPU 空闲等待数据的时间段，微批调度用来压缩气泡
ZeRO 优化器	Zero Redundancy Optimizer	DeepSpeed 的显存优化技术，分片优化器状态/梯度/参数以降低单卡显存
NVLink	NVLink	NVIDIA 的高速 GPU 互联技术，带宽远超 PCIe，张量并行的物理基础
InfiniBand	InfiniBand	高速低延迟网络标准，大规模跨节点训练的骨干网络
稀疏计算	Structured Sparsity	利用 2:4 等结构化稀疏模式，在不损失精度的前提下翻倍矩阵乘吞吐
混合精度训练	Mixed Precision Training (AMP)	用 FP16/BF16 计算加 FP32 主权重，降低显存、加速训练、精度几乎无损
梯度累积	Gradient Accumulation	多次小 batch 反向传播累积梯度后统一更新，模拟大 batch 效果