大模型3D并行：DP+TP+PP层叠策略全解

可视化演示

动态演示大模型3D并行的核心机制，通过概览/流程/对比/趋势四种模式展示关键概念与交互流程。

并行基础概念：为什么单卡练不动千亿模型

一个人做满汉全席，会撞上两堵墙：厨房案板放不下几十道菜的食材，一双手也来不及在开席前做完。训练超大模型也一模一样——“显存墙”和“算力墙”。一块顶配的 H100 显卡只有 80GB 显存，而一个 100B 参数的模型仅权重就要约 200GB（FP16），直接塞不进去；就算硬塞，单卡训练也要跑上几百年。想翻墙，唯一的办法是“把活分出去”。

怎么分？业界总结出三条基本路子：数据并行（DP）复制整套模型、把数据切块分给各副本；张量并行（TP）把每一层的权重矩阵切成几块分给多卡；流水线并行（PP）把模型按层切成若干连续阶段。用工厂语言说：先分车间（PP），再给车间配多名分工的工人（TP），最后复制一整条生产线（DP）。

三层叠加，就是 3D 并行。三个维度互相垂直，GPU 总数恰好是三者乘积：

回到小作坊的比喻：只复制生产线（DP）解决不了单条线放不下零件的问题；只分工（TP）解决不了要同时处理海量订单的问题；只分车间（PP）每个环节仍然太慢。三层错落叠加，才把“装不下”和“跑得慢”一起攻破——显存墙靠 TP 拆权重、PP 拆层数，算力墙靠 DP 多线并行。

数据并行DP：复制整条生产线

蛋糕店接到一万个订单，一个师傅做到天亮也做不完。最简单的办法是什么？复制十套“师傅+烤箱+配方”，每套认领不同的原料批次去烤，最后大家把成品摆到一起卖。数据并行就是这个思路：每张 GPU 都保存一份完整模型，训练时把一次迭代的数据批平均切成 \( N \) 份，每卡领一份做前向和反向传播。各卡算出的梯度方向略有差异，所以需要在 DP 组内“对齐口径”——把所有梯度求和取平均，再统一更新。

这个对齐动作就是经典的 AllReduce，公式非常朴素：

DP 最大的优点是好实现、扩展性强；但两个特点必须记牢：一是每张卡都要装下完整模型加优化器状态，显存一点没省；二是每一轮迭代都要同步一次全量梯度，通信量与参数量成正比。所以 DP 适合“模型单卡放得下、数据量大得吓人”的场景；一旦模型大到单卡放不下，就得靠 TP 和 PP 来给显存“减负”。

回到蛋糕店：复制十条生产线解决的是“量”的问题，但每套厨房还是得备齐全部烤箱和食材。当一套设备本身大到一间屋子都塞不下时，光复制没用——下面轮到 TP 出场。

张量并行TP：车间里围着半成品分工

巨型钢板要加工成精密零件，一台机床塞不下。老师傅的做法是：把钢板画上格子切开，几个师傅各磨一块，最后严丝合缝拼起来。张量并行 TP 干的就是这事——把神经网络每一层的权重矩阵切成若干块，分散到多张 GPU 上，每卡只算自己那一块，算完再拼回完整输出。

以全连接层 \( Y = XW \) 为例：把权重 \( W \) 按行切成上下两块，输入 \( X \) 相应地按列切，两张卡各算局部乘积，最后用 AllReduce 把两部分相加，精确还原出完整 \( Y \)：

TP 在 Transformer 上的应用同样直接：Attention 的 Q、K、V 权重可以按“头”切分，每个 GPU 只负责几个注意力头；MLP 的两层大矩阵则按行列切分。代价是每一层前向和反向都要做一次集体通信，通信量在三种并行里最密集，必须依赖 NVLink 这类卡间高速互联；收益是权重和优化器状态被均分到多卡，显存压力大幅下降。所以实践中有一个铁律：TP 组必须放在同一台物理节点内，贴着 NVLink 交换机，别让数据“绕远路走网络”。

回到车间：围着大工件分工的师傅们，每道工序之间都要互相递工具、对尺寸，所以必须站得近、喊得应——这就是 TP 必须绑在 NVLink 高速互连环上的原因。

流水线并行PP：把厂房改成流水线

菜太多一道一道炒来不及，聪明的后厨把工序拆开：第一组只管洗菜切菜，第二组只管下锅颠勺，第三组只管装盘出菜。模型训练也一样，把几十上百层网络按连续层切成多个阶段（stage），每个阶段由一组 GPU 负责。数据像半成品一样依次流过所有阶段，这就是流水线并行 PP。

但流水线有个天生的毛病：开工时后半段车间空等原料，收工时前半段车间空等下游。这段浪费叫“气泡”（bubble）。怎么治？把一个大 batch 拆成 \( m \) 个微批次（micro-batch），像传送带上多放几件半成品，让前后车间的等待被摊薄。气泡占比有明确的公式：

PP 的显存收益很明显：每卡只保存一部分层。但它也有自己的通信需求——阶段边界要传递“半成品”（激活值和梯度），跨节点传输依赖高速网络。为了进一步压气泡，工程上还有 1F1B 调度（一个前向紧跟一个反向）、虚拟流水线（把阶段再微切）等进阶招数。

回到比喻：流水线段数越多，工人分工越细，但最后车间等原料等得越久；在传送带上多放几件半成品（增大微批 \( m \)），气泡自然被摊薄。不过要小心：微批太多，激活显存也会水涨船高。

层叠配置策略：三层工厂怎么盖

三层工厂的施工图有讲究：不是随便复制几条线、切几刀就能高效运转。布局顺序、通信管道、显存负担三件事都得算清楚。

先说规模：GPU 总数 = DP × TP × PP。总卡数固定时，三个维度怎么分配直接决定通信模式。再看物理拓扑：TP 通信最密集，必须放进同一节点 NVLink 域；PP 次之，跨节点但要高速网络（IB 或高带宽以太网）；DP 通信最稀，每迭代才同步一次，可以放心跨节点跨可用区。通信量排序大约是 TP > PP > DP，谁的网络占用高，谁就要离高速互联更近。

显存也要三块一起规划：权重和优化器状态被 TP 均分，激活则被 PP 按段摊薄。单卡显存的粗略估算公式：

实际配置有个通行口诀：TP 先喂满节点内 NVLink，PP 分出阶段控制层深，DP 收尾复制吃数据吞吐。比如 8 卡一台的节点，可以先定 TP=8 占满单节点 NVLink，再定 PP 跨 8 个节点，最后用 DP 乘一个倍数把整个集群铺满。

回到比喻：车间怎么排工位（TP）、车间之间传送带怎么连（PP）、一共复制几条产线（DP），是施工图上三件套。排错了，工人们大半时间在等料，而不是干活。

调优部署经验：盯住堵点再调参

三层工厂投产之后，活儿还没完：今天这条线堵料、明天那台机器罢工，都得有章法地应对。大模型训练的调优也一样在细节里。

第一招，Profiling 定位瓶颈。用 Nsight、NCCL 等工具看每个 GPU 的计算利用率、通信等待时间和显存水位。发现 TP 通信占比超过 30%，就减少 TP、把算力预算让给 PP 或 DP；发现流水线气泡大，就增加微批次数。别拍脑袋调参，让数据说话。

第二招，梯度累积配合。DP 通信太频繁拖慢训练时，可以攒几轮梯度再统一 AllReduce，等效训练批量随之变大：

第三招，混合精度叠算：3D 并行中普遍开启 FP16/BF16，权重和激活显存再省一半，但要注意 TP 组内的通信量也要按半精度重新核对带宽。第四招，容错检查点：每训练一段保存完整检查点，TP/PP 任一卡掉线时，从最近检查点整体恢复——毕竟 3D 并行是全集群协同作战，一个钉子坏一辆车，没有检查点就全盘重来。

回到比喻：好厂长不靠蛮干，而是盯仪表盘（Profiling）、错峰攒货（梯度累积）、轻装上阵（混合精度）、备好预案（检查点）——训练集群持续高效运转，靠的正是这套“开厂经验”。

---

AI 应用场景

Python 演示

class ParallelConfig:    def __init__(self, dp, tp, pp):        self.dp = dp        self.tp = tp        self.pp = pp        self.total_gpus = dp * tp * pp     def rank_to_coord(self, rank):        """把全局GPU编号映射到(DP, PP, TP)三维坐标"""        tp = rank % self.tp        pp = (rank // self.tp) % self.pp        dp = rank // (self.tp * self.pp)        return (dp, pp, tp)     def allreduce_group(self, rank):        """返回与该卡共享DP梯度同步组的所有GPU编号"""        coord = self.rank_to_coord(rank)        return [d * self.tp * self.pp + coord[1] * self.tp + coord[2]                for d in range(self.dp)]     def pp_downstream(self, rank):        """返回流水线下游阶段的GPU编号（最后一阶段返回None）"""        coord = self.rank_to_coord(rank)        if coord[1] == self.pp - 1:            return None        return coord[0] * self.tp * self.pp + (coord[1] + 1) * self.tp + coord[2]  def simulate_3d_parallel(config, num_microbatches=4):    print("=== 3D并行模拟：DP=%d × TP=%d × PP=%d ===" % (        config.dp, config.tp, config.pp))    print("总GPU数：%d" % config.total_gpus)    print()    for rank in range(config.total_gpus):        coord = config.rank_to_coord(rank)        group = config.allreduce_group(rank)        downstream = config.pp_downstream(rank)        dest = str(downstream) if downstream is not None else "无(最后一阶段)"        print("GPU%d 坐标(DP=%d, PP=%d, TP=%d)" % (            rank, coord[0], coord[1], coord[2]))        print("  梯度同步组：%s" % group)        print("  流水线下游：%s" % dest)    print()    print("--- 流水线调度（按时间步观察活跃GPU）---")    for step in range(num_microbatches + config.pp - 1):        active = []        for rank in range(config.total_gpus):            coord = config.rank_to_coord(rank)            mb_id = step - coord[1]            if 0 <= mb_id < num_microbatches:                active.append(rank)        print("时间步%d：活跃GPU=%s" % (step, active))  if __name__ == "__main__":    config = ParallelConfig(dp=2, tp=2, pp=2)    simulate_3d_parallel(config, num_microbatches=4)

1. self.total_gpus = dp * tp * ppGPU 总数等于三个并行度相乘，这是配置的总约束
2. rank_to_coord把全局 GPU 编号拆成 (DP, PP, TP) 三维坐标，对应三条正交的并行轴
3. tp = rank % self.tp先取 TP 坐标：维度最低，组内卡号连续
4. pp = (rank // self.tp) % self.pp再取 PP 坐标：按 TP 大小跳号取段
5. dp = rank // (self.tp * self.pp)最后取 DP 坐标：每跨一个副本，编号平移整个 PP×TP 块
6. allreduce_group返回同一 DP 坐标下、PP 和 TP 坐标相同的所有卡，它们组成梯度同步组
7. pp_downstream返回同 DP、同 TP 坐标的下一 PP 阶段卡号，最后一阶段返回 None
8. for step in range(num_microbatches + config.pp - 1)时间步从流水线启动覆盖到排空，共 m+p-1 步
9. mb_id = step - coord[1]当前时间步该阶段应处理第几个微批，像传送带上走到的半成品序号
10. if 0 <= mb_id < num_microbatches只有微批落在有效区间内的 GPU 才处于活跃状态

常见误区

面试题