中 #Distributed Training#Pipeline Parallelism

GPipe：微批次流水线并行的大规模模型训练 — 深度阅读笔记

阅读笔记：流水线并行如何让巨型神经网络训练成为可能

作者： Zhongzhu Zhou
日期： 2026-04-02
论文标题： GPipe: Easy Scaling with Micro-Batch Pipeline Parallelism
原作者： Yanping Huang, Youlong Cheng, Ankur Bapna, Orhan Firat, Dehao Chen, Mia Xu Chen, HyoukJoong Lee, Jiquan Ngiam, Quoc V. Le, Yonghui Wu, Zhifeng Chen
机构： Google Brain

ArXiv ID： 1811.06965

核心摘要与贡献

2019 年，Google Brain 团队发表了 GPipe 这篇论文，解决了深度学习领域一个极为关键的工程问题：当一个神经网络模型大到单张 GPU/TPU 装不下时，怎样才能在多张加速卡上高效地训练它？

在 GPipe 出现之前，跨设备训练大模型需要针对每种网络架构编写专用的分布式代码，这既费时又容易出错。GPipe 提出了一种通用的流水线并行方案，适用于任何可以表示为层序列的神经网络，从根本上降低了训练巨型模型的工程门槛。

GPipe 的核心贡献包括：

  1. 微批次流水线并行算法：将小批量（mini-batch）拆分成更小的微批次（micro-batch），在多张加速卡之间形成流水线执行，接近线性加速。
  1. 同步梯度更新保证：与 PipeDream 等异步方案不同，GPipe 在所有微批次完成后才统一更新参数，确保训练结果与单卡训练完全一致——无近似、无权重过时问题。
  2. 内置激活检查点（Re-materialization）技术：显著降低峰值激活内存占用，使得在有限显存下能容纳远超预期的大模型。
  3. 大规模实验验证：5.57 亿参数的 AmoebaNet 在 ImageNet 上达到 84.4% top-1 准确率；60 亿参数的 Transformer 实现 100+ 语言的多语言翻译。

这篇论文是 ML Systems 领域的奠基之作。后来的 Megatron-LM、DeepSpeed、PyTorch 的流水线并行 API 等核心系统，都直接继承了 GPipe 的设计思想。

预备知识：从零理解 GPipe

在深入 GPipe 的技术细节之前，我们需要先建立一些基础概念。这部分面向可能从未接触过分布式训练的读者，力求用最通俗的方式解释清楚每个关键概念。

1. 为什么模型越大效果越好？

GPipe 论文的出发点非常直观：更大的模型通常能取得更好的性能。 论文用两组强有力的实验数据来支撑这一观点：

  • 图像分类（论文图 1a）：从 2014 年到 2019 年，ImageNet 分类准确率从约 74% 提升到 84%，与此同时模型规模增长了 36 倍。每一次准确率的重大飞跃都伴随着模型规模的重大飞跃。
  • 机器翻译（论文图 1b）：翻译质量（用 BLEU 分数衡量）随着 Transformer 模型从 4 亿参数扩大到 60 亿参数而持续提升。

这不是简单的统计巧合。从理论上讲，更大的模型拥有更强的函数表达能力：它能编码更多知识、捕捉更复杂的模式、在合适的正则化下实现更好的泛化。问题纯粹是实践层面的：你怎么训练这么大的模型？

2. "显存墙"问题：为什么单卡装不下大模型？

训练一个神经网络时，加速器（GPU 或 TPU）的内存需要同时存储多种数据：

模型参数（ww）： 网络中所有可学习的权重。一个 10 亿参数的模型仅参数本身就需要约 4 GB（32 位浮点数）。

优化器状态： 像 Adam 或 RMSProp 这样的优化器需要为每个参数维护额外的状态信息（动量、方差等）。这通常让参数内存翻 2-3 倍。GPipe 论文中提到，使用 RMSProp 时每个参数需要约 12 字节。

激活值（Activations）： 前向传播过程中，每一层的中间输出都需要缓存下来，因为反向传播时计算梯度要用到它们。对于深度网络和大批量数据，激活内存往往远超参数内存。

梯度： 反向传播过程中计算出的每个参数的梯度值。

举一个论文中的具体例子：一个 8200 万参数的 AmoebaNet 模型，参数本身只占 1.05 GB，但训练时的激活值却占了 6.26 GB——激活内存是参数内存的 6 倍！这就是为什么"显存能装下参数"远远不等于"显存能训练这个模型"。

当总内存需求超过单张加速卡的容量时，就必须使用并行策略。

3. 数据并行：简单但有天花板

数据并行（Data Parallelism）是最常见的分布式训练方法，理解它有助于理解为什么我们还需要 GPipe：

工作原理：

  1. 在每张加速卡上都复制一份完整的模型。
  2. 将训练数据的小批量（mini-batch）分到各卡上——每张卡处理不同的数据子集。
  3. 前向和反向传播后，用 AllReduce 操作在所有卡之间同步梯度。
  4. 每张卡应用相同的梯度更新。

优点： 实现简单、吞吐量接近线性扩展，PyTorch DDP、tf.distribute 等框架都有很好的支持。

致命缺点： 每张卡必须持有完整模型的副本。如果你的模型需要 32 GB 显存，而你的 GPU 只有 16 GB，再多的数据并行也救不了你。数据并行解决的是"训练速度"问题，而不是"模型装不下"的问题。

4. 模型并行：将模型本身拆开

模型并行（Model Parallelism）的核心思路是把模型拆分到多张设备上。根据拆分方式的不同，主要有两大流派：

4a. 张量并行（Tensor Parallelism / SPMD / 层内并行）

张量并行将单个运算（如矩阵乘法）拆分到多张卡上。例如，一个线性层的权重矩阵 W∈R4096×4096W \in \mathbb{R}^{4096 \times 4096} 可以按列拆成 4 份，每张卡持有 4096×10244096 \times 1024 的切片并计算部分输出。

优点： 能处理单层就非常大的情况。

缺点：

  • 每次拆分运算后都需要跨卡通信（AllReduce），通信开销极高。
  • 只有在高带宽互联（NVLink、TPU 互联）下才实用。
  • 对架构有限制——拆分卷积层远比拆分全连接层困难。

这就是 Mesh-TensorFlow（Shazeer 等，2018）采用的方案。

4b. 流水线并行（Pipeline Parallelism / 层间并行）

流水线并行按层拆分模型：前几层放在设备 0，接下来几层放在设备 1，以此类推。数据像流水线上的产品一样依次通过各设备。

优点： 设备间通信量极小——只需在分区边界传递激活张量。

朴素版本的致命缺点： 严重的设备利用率低下。在朴素实现中，当设备 kk 在计算第 kk 组层的前向传播时，其他所有设备都在空闲等待。这就是所谓的"气泡"（bubble）问题，它让朴素流水线并行几乎毫无实用价值。

GPipe 的创新正是解决了气泡问题——通过微批次流水线调度。

5. 激活检查点技术（Re-materialization）

这是 Chen 等人（2016）提出的内存优化技术：在前向传播时不缓存所有层的激活值，只在特定"检查点"（如分区边界）保存激活值。反向传播时从最近的检查点重新计算中间激活值。

本质是用计算换内存： 少存东西，需要时重新算。典型的代价是增加约 33% 的计算量。

GPipe 整合了这一技术，将峰值激活内存从 O(N×L)O(N \times L) 降低到 O(N+LK×NM)O(N + \frac{L}{K} \times \frac{N}{M})，其中 NN 是批量大小、LL 是层数、KK 是分区数、MM 是微批次数。这个公式的直觉是：每张卡只需要存储自己负责的 L/KL/K 层的激活值，而且每次只处理大小为 N/MN/M 的微批次。

6. 同步 vs. 异步梯度更新

这是理解 GPipe 与 PipeDream 区别的关键概念：

同步更新（GPipe 采用）： 所有微批次的梯度先累加，然后一次性更新参数。等价于在单卡上用完整 mini-batch 训练——数学上完全一致。

异步更新（PipeDream 采用）： 不同微批次可以用不同版本的参数来计算梯度，梯度到了就立即更新。好处是设备利用率更高，坏处是引入"权重过时"（weight staleness）——你用旧参数算的梯度去更新新参数，训练一致性无法保证。

GPipe 算法详解

极简接口设计

GPipe 的接口设计体现了"把复杂留给系统，把简单留给用户"的原则。用户只需指定三样东西：

  1. KK：模型分区数（= 使用的加速卡数）。
  2. MM：每个小批量拆分成多少个微批次。
  3. LL 层的定义：将神经网络定义为一个层的序列，每层包含前向函数 fif_i、参数 wiw_i，以及可选的计算成本估算函数 cic_i。

GPipe 自动完成以下工作：

  • 将连续的层分成 KK 个单元（cell），将第 kk 个单元放到第 kk 张加速卡上。
  • 在分区边界自动插入通信原语。
  • 通过最小化各分区估算成本的方差来平衡负载。

流水线执行的完整流程

以 K=4K = 4 张加速卡和 M=8M = 8 个微批次为例，详细走一遍训练的一个步骤（参考论文图 2c）：

第一阶段：前向传播

  1. 大小为 NN 的小批量被拆成 8 个大小为 N/8N/8 的微批次。
  2. 微批次 1 进入加速卡 0（负责第 1 到第 L/4L/4 层）。加速卡 0 完成这些层的前向计算后，将输出激活发送给加速卡 1。
  3. 加速卡 1 处理微批次 1 的同时，加速卡 0 同时开始处理微批次 2。
  4. 流水线持续运行：在稳态下，4 张卡同时在处理不同的微批次——这就是效率的来源。
  5. 每张卡只保存分区边界的激活值，中间层的激活值被丢弃（激活检查点）。

第二阶段：反向传播

  1. 当微批次 1 的前向传播通过全部 4 张卡后，加速卡 3 开始对微批次 1 进行反向传播。
  2. 反向传播时，每张卡需要重新计算自己负责层的前向传播，以恢复被丢弃的中间激活值。这就是激活检查点的"还债"环节。
  3. 每个微批次的梯度被累加（注意：不是立即应用），等全部微批次完成。

第三阶段：参数更新

  1. 全部 MM 个微批次的前向和反向传播完成后，累加的梯度一次性应用于所有加速卡的参数更新。
  2. 这保证了梯度更新在数学上等价于在单设备上处理完整 mini-batch——没有任何近似或信息损失。

气泡开销的定量分析

"气泡"是每个训练步骤开始和结束时部分加速卡空闲的时间。论文推导出气泡占总计算时间的比例为：

气泡比例=O(K−1M+K−1)\text{气泡比例} = O\left(\frac{K - 1}{M + K - 1}\right)

这个公式告诉我们关键的设计准则：

  • 当 M=KM = K 时：气泡约占 50%，效率很低。
  • 当 M=4KM = 4K 时：气泡约占 K−15K−1≈20%\frac{K-1}{5K-1} \approx 20\%，已经相当不错。
  • 当 M=32M = 32、K=4K = 4 时：气泡约 335≈8.6%\frac{3}{35} \approx 8.6\%，非常高效。

论文指出，M≥4KM \geq 4K 是实践中的最低要求。此外，反向传播阶段的重计算可以提前调度（填充部分气泡时间），实际开销比理论值更小。

Batch Normalization 的特殊处理

一个容易被忽视但很重要的细节：Batch Normalization 层需要在整个 batch 上计算统计量（均值和方差）。微批次拆分后，每个微批次独立计算自己的统计量用于训练。为了评估（inference）的正确性，GPipe 在训练过程中追踪整个 mini-batch 的移动平均统计量。

这也是为什么现代 Transformer 普遍使用 LayerNorm 而非 BatchNorm 的原因之一：LayerNorm 在每个样本内部计算统计量，天然适配微批次/流水线并行。

实验结果深度分析

实验一：模型规模扩展能力（表 1）

这是 GPipe 最核心的实验——展示它能让你训练多大的模型。

AmoebaNet 在 GPU（每卡 8 GB）上的表现：

配置 参数量 参数内存 峰值激活内存
无 GPipe（1 GPU） 8200 万 1.05 GB 6.26 GB
GPipe，1 GPU（仅激活检查点） 3.18 亿 3.8 GB 3.46 GB
GPipe，2 GPUs 5.42 亿 6.45 GB 8.11 GB
GPipe，4 GPUs 10.5 亿 12.53 GB 15.21 GB
GPipe，8 GPUs 18 亿 24.62 GB 26.24 GB

深入解读：

  • 仅使用激活检查点（Pipeline-1），激活内存从 6.26 GB 降到 3.46 GB，在同一张 GPU 上就能训练 3.9 倍大的模型。
  • 8 卡流水线支撑 18 亿参数——比无 GPipe 的单卡大 22 倍。
  • AmoebaNet 的扩展是亚线性的，因为其不同层的参数分布不均匀。

Transformer 在 TPU（每卡 16 GB）上的表现：

配置 层数 参数量
无 GPipe（1 TPU） 3 2.82 亿
GPipe，1 TPU 13 7.86 亿
GPipe，8 TPUs 103 53 亿
GPipe，32 TPUs 415 210 亿
GPipe，128 TPUs 1,663 839 亿

Transformer 的扩展完美线性——因为所有层结构和大小完全相同。128 张 TPU 下，GPipe 支持高达 839 亿参数，是单 TPU 的 298 倍。

实验二：训练吞吐量（表 2）

吞吐量实验验证了气泡开销的理论分析：

Transformer 模型：

微批次数 (MM) 2 分区 4 分区 8 分区
M=1M = 1 1.0× 1.07× 1.3×
M=4M = 4 1.7× 3.2× 4.8×
M=32M = 32 1.8× 3.4× 6.3×

M=32M = 32、8 分区时，Transformer 达到 6.3 倍吞吐量——接近理想的 8 倍线性加速。当 M=1M = 1（无流水线）时，增加设备几乎没有帮助，因为同一时刻只有一张卡在工作——这就是朴素模型并行的问题。

AmoebaNet 的加速是亚线性的（8 分区 M=32M = 32 时仅 3.48 倍），原因是各层计算量不均衡。这揭示了一个重要实践教训：流水线并行在各层计算成本均匀时效果最好。

实验三：低带宽互联下的性能（表 3）

一个关键实验：在没有 NVLink 的 NVIDIA P100 GPU 上运行（只有 PCI-E 互联，带宽远低于 NVLink）：

配置 2 GPUs 4 GPUs 8 GPUs
AmoebaNet 1.0× 1.7× 2.7×
Transformer 1.0× 1.8× 3.3×

即使在慢速互联下仍然接近线性扩展！这证明了流水线并行的通信优势：不像张量并行需要在每个操作后进行 AllReduce，流水线并行只在分区边界传输激活张量——通信量小得多。

实验四：ImageNet 图像分类（表 4）

5.57 亿参数的 AmoebaNet-B (18, 512) 用 GPipe 训练后取得：

  • 84.4% top-1 准确率（单裁剪，ImageNet-2012）
  • 97.0% top-5 准确率

这在发表时是 ImageNet 的最先进结果（排除使用非公开 Instagram 数据预训练的方法）。模型在 480 × 480 输入图像上训练，跨 4 个分区。

迁移学习效果同样出色：

数据集 GPipe 结果 此前最优
CIFAR-10 99.0% 98.5%
CIFAR-100 91.3% 89.3%
Stanford Cars 94.6% 94.8%
Oxford Pets 95.9% 93.8%
Food-101 93.0% 90.4%

这些结果验证了 Kornblith 等人（2018）的发现："更好的 ImageNet 模型迁移更好"。

实验五：大规模多语言机器翻译

这可能是 GPipe 最令人印象深刻的展示。一个 60 亿参数、128 层的 Transformer 被训练来同时翻译 102 种语言到英语。

模型规模扩展：

模型 参数量 分区数
T(6, 8192, 16) 4 亿 1
T(12, 16384, 32) 13 亿（宽型） 2
T(24, 8192, 16) 13 亿（深型） 4
T(32, 16384, 32) 30 亿 8
T(64, 16384, 32) 60 亿 16

核心发现：

发现一：规模扩大持续提升质量。 从 4 亿到 60 亿参数，所有 102 种语言的翻译质量都在提升。

发现二：深度 vs. 宽度的权衡。 同为 13 亿参数，深型模型 T(24, 8192, 16) 在低资源语言上显著优于宽型模型 T(12, 16384, 32)，而在高资源语言上两者表现接近。这表明深度有利于泛化和知识迁移，而宽度主要增加单任务容量。

发现三：低资源语言受益最大。 60 亿参数的单一多语言模型在所有 100+ 语言对上都超过了单独训练的 3.5 亿参数双语模型。低资源语言从高资源语言的正向迁移中获益最多。

发现四：大批量训练有益。 批量大小从 26 万 token 增加到 400 万 token，BLEU 从 30.92 提升到 32.71，NLL 损失从 2.58 降到 2.46（表 5）。

深层模型的训练稳定性挑战

论文坦诚地讨论了训练非常深的模型时遇到的不稳定性问题，这对实践者极有价值：

问题一：尖锐的激活值。 训练几千步后，模型预测变得极度"尖锐"（高置信度、低熵），使模型对噪声非常脆弱。

问题二：梯度爆炸。 尖锐的预测导致巨大或非有限的梯度，最终破坏训练进度。

解决方案：

  • 缩放初始化（Zhang 等，2019）：将前馈层的初始化按层数 LL 缩小。
  • Logit 裁剪：当 softmax 前的激活值超过阈值时进行裁剪。

这些实践经验对于任何训练深层 Transformer 的人都非常宝贵。

与其他方案的详细对比

GPipe vs. Mesh-TensorFlow（SPMD）

维度 GPipe Mesh-TF
并行类型 流水线（层间） 张量（层内）
通信量 低（仅边界激活） 高（每个操作后 AllReduce）
互联要求 PCI-E 即可 需要高速互联（NVLink/TPU mesh）
架构通用性 任何顺序网络 需要操作可拆分
扩展维度 模型深度（更多层） 层宽度（更大矩阵）
实现复杂度 简单（指定 K、M、层） 复杂（定义 mesh 拆分方案）

GPipe vs. PipeDream

维度 GPipe PipeDream
梯度更新 同步 异步
权重过时 无 存在（通过版本控制缓解）
额外内存开销 激活检查点减少内存 需存储多版本权重
训练一致性 保证与单卡一致 因异步而近似
气泡处理 微批次流水线（M≫KM \gg K） 交错前向/反向传播

GPipe 的同步方案用略多的气泡时间换取了训练正确性的绝对保证。PipeDream 的异步方案利用率更高，但引入的梯度过时需要小心处理。

GPipe vs. 数据并行

维度 GPipe 数据并行
扩展什么？ 模型规模 训练吞吐量
能否突破单卡内存？ 能 不能
通信量 小（边界激活） 大（所有梯度 AllReduce）
可组合？ 是——两者可以组合 是——两者可以组合

在现代实践中，Megatron-LM 和 DeepSpeed 等系统将三者结合：数据并行 + 张量并行 + 流水线并行 = "3D 并行"范式。

局限性、边界条件与批判分析

1. 单层内存约束

GPipe 假设每一层都能装进单张加速卡的内存。如果单层有 200 亿参数（参数 + 优化器状态需要约 240 GB），GPipe 无法单独处理，必须借助张量并行来拆分这一层。这就是为什么现代系统需要同时使用流水线并行和张量并行。

2. 气泡问题并未完全解决

虽然 M≥4KM \geq 4K 时气泡可控，但这一约束可能带来限制：

  • 全局批量大小必须至少为 4K4K 乘以单个微批次的大小，对于某些收敛性对批量大小敏感的任务，这会是个问题。
  • 气泡随 KK 线性增长，非常深的流水线（如 K=32K = 32）需要极大的 MM。
  • 后续工作（Megatron-LM 的 1F1B 调度、交错式虚拟流水线等）已提出更优调度策略来进一步减少气泡。

3. 负载不均衡

论文承认 AmoebaNet 的亚线性扩展源于各层计算量不均。GPipe 基于成本估算的分区是启发式的，可能无法完美平衡实际运行时间。现实网络中常见的不均衡来源：

  • 嵌入层与注意力层的计算量差异大
  • 注意力层的成本随序列长度变化
  • 混合专家（MoE）层的专家激活率不固定

更优的分区算法仍然是开放问题。

4. 微批次大小与 Batch Normalization 的冲突

拆成很多微批次意味着每个微批次很小。对于 Batch Normalization 来说，在小微批次上计算的统计量可能噪声很大，影响模型质量。这也是现代大模型普遍使用 LayerNorm（在每个样本内部计算统计量，不受批量大小影响）而非 BatchNorm 的原因之一。

5. 内存节省 vs. 计算成本

激活检查点用重计算换内存，典型开销约增加 33% 的计算时间。论文未精确量化这一开销，但在流水线并行中，部分重计算可以填充气泡时间，实际代价比理论值更小。

6. 容错缺失

论文未讨论容错问题。在 128 张 TPU 的规模下，加速器故障是现实威胁。同步训练意味着任何一张设备故障都会阻塞整条流水线。后续系统如 DeepSpeed 通过检查点和弹性训练来应对这个问题。

历史影响与遗产

GPipe 对 ML Systems 领域的影响是巨大的：

  1. Megatron-LM（2020-2021）：将流水线并行（受 GPipe 启发）与张量并行、数据并行结合为"3D 并行"——这是训练 GPT-3、LLaMA 等大模型的标准方案。

  2. DeepSpeed ZeRO（2020）：虽然主攻数据并行的内存优化，但其流水线并行模块直接建立在 GPipe 的理念之上。

  3. PyTorch Pipe（torch.distributed.pipeline）：PyTorch 官方流水线并行 API 就是 GPipe 设计的直接后代。

  4. 1F1B 调度（PipeDream-2BW，2020）：改进了 GPipe 的调度，通过交错前向和反向传播来减少激活累积导致的峰值内存。

  5. 虚拟流水线并行（Narayanan 等，2021）：通过给每张卡分配多个不连续的层组来进一步减少气泡。

从 GPipe → Megatron-LM → 现代训练框架的演进脉络非常清晰，正是这条技术路线催生了基础模型（GPT-3、PaLM、LLaMA 等）的时代。

可复现性评估

可复现性：中等

有利因素：

  • 算法描述清晰、相对简单、易于实现。
  • 在 Lingvo 框架下开源。
  • 关键超参数（模型架构、批量大小、分区数）都有明确说明。

挑战：

  • ImageNet 实验需要 4+ 张 TPU 和大量计算时间。
  • 多语言 NMT 实验使用的是 Google 内部私有语料库（25B 样本，102 种语言），公众无法访问。
  • 部分训练配置细节在补充材料中，但仍依赖内部基础设施。

对实践者的建议：算法本身从论文描述即可实现。PyTorch 的 torch.distributed.pipeline.sync 本质上就是 GPipe，可以免费使用。

给从业者的核心建议

  1. 流水线并行是扩展模型深度的首选：当模型超出单卡内存时，它比张量并行更简单、通信需求更低。

  2. 微批次数要足够：M≥4KM \geq 4K 是实践准则。微批次太少 = 气泡浪费严重。

  3. 与其他策略组合使用：现代实践中，流水线并行很少独立使用。与数据并行（提速）和张量并行（处理超大单层）组合才是正道。

  4. 偏好均匀层架构：流水线并行在各层计算成本相近时效果最好。Transformer 是理想选择；异构架构如 AmoebaNet 更难平衡。

  5. 激活检查点几乎是"免费"的：内存节省巨大，计算开销（约 33%）通常可以接受。对于流水线并行，它几乎是必备的。

  6. 不要害怕慢速互联：与张量并行不同，流水线并行在分区边界传输小型激活张量，即使没有 NVLink 也能高效运行。

总结

GPipe 是那种回头看起来很简单的论文——把 mini-batch 拆成微批次、在模型分区间形成流水线、同步累加梯度——但它产生的实际影响是巨大的。它提供了第一个通用的、架构无关的流水线并行方案，在 128 张 TPU 上训练多达 839 亿参数的模型，且接近线性加速。

论文的清晰表述、对局限性的诚实讨论（负载不均、Batch Normalization、训练不稳定性）、以及多样的实验验证（图像分类 + 多语言 NMT）使其成为应用型 ML Systems 研究的典范。此后每一个大模型训练系统——Megatron-LM、DeepSpeed、FairScale、PyTorch FSDP——都携带着 GPipe 的基因。

对于任何从事分布式训练系统的研究者和工程师来说，理解 GPipe 不是可选的，而是必修的。它是现代 3D 并行体系的基石。

参考文献

  1. Huang, Y., Cheng, Y., Bapna, A., et al. "GPipe: Easy Scaling with Micro-Batch Pipeline Parallelism." NeurIPS 2019. arXiv:1811.06965.
  2. Shazeer, N., et al. "Mesh-TensorFlow: Deep Learning for Supercomputers." NeurIPS 2018.
  3. Harlap, A., et al. "PipeDream: Fast and Efficient Pipeline Parallel DNN Training." arXiv:1806.03377.
  4. Narayanan, D., et al. "Efficient Large-Scale Language Model Training on GPU Clusters Using Megatron-LM." SC 2021.
  5. Rajbhandari, S., et al. "ZeRO: Memory Optimizations Toward Training Trillion Parameter Models." SC 2020.
  6. Chen, T., et al. "Training Deep Nets with Sublinear Memory Cost." arXiv:1604.06174.
  7. Vaswani, A., et al. "Attention Is All You Need." NeurIPS 2017.
  8. Real, E., et al. "Regularized Evolution for Image Classifier Architecture Search." AAAI 2019.
  9. Narayanan, D., et al. "Memory-Efficient Pipeline-Parallel DNN Training." ICML 2021 (PipeDream-2BW).
  10. Zhang, H., Dauphin, Y.N., Ma, T. "Fixup Initialization: Residual Learning Without Normalization." ICLR 2019.