行并行（Row Parallel）原理

可视化演示

动态演示行并行Row Paralle的核心机制，通过总览/传输/转换/输出四种模式展示关键概念与交互流程。

1. 行切分原理

想象你走进音乐厅，看到一支大型合唱团正在排练《欢乐颂》。作曲家把总谱写成厚厚一叠——这就是权重矩阵 W，每一行都是一条旋律线。为了让女高音、女中音、男高音、男低音四个声部同时开唱，指挥拿起剪刀，把总谱按声部拆成四份，每份只含几行旋律。这个动作，就是行并行的核心直觉：把权重矩阵按行切开。

不过，光切歌谱还不够。每位歌手要唱，手里还得有对应的歌词；歌词来自输入 X。既然歌谱按行切了，歌词也得跟着按列切成四句，每个声部拿一句。于是输入矩阵 X 被切成 X₁、X₂、……、Xₚ，连同权重分片一起分给各台 GPU。

用数学语言说：设权重 W 的形状是 (k, n)，输入 X 的形状是 (b, k)。行并行把 W 沿行方向切成 p 块，每块 Wᵢ 的形状是 (k/p, n)；同时把 X 沿列方向切成 p 块，每块 Xᵢ 的形状是 (b, k/p)。设备 i 拿着 (Xᵢ, Wᵢ) 这对数据，在本地做矩阵乘法。虽然每台设备手里的“谱子”变小了，但 p 块拼在一起，参数总量和切分前分毫不差。

每个声部歌手手里只有几行谱子和一句歌词，但他们知道自己唱的是整首歌的一部分。这些“部分”如何变成完整的和声？答案就在下一节的前向传播。

2. 前向传播流程

演出时刻到了。指挥的手一抬，四个声部同时开口——女高音唱出明亮的高音区旋律，男低音托起沉稳的低音线。单独听任何一声部，都只是碎片；但当所有声音在大厅中叠加，观众听到的是一首完整的《欢乐颂》。这个“声音叠加”的过程，对应行并行的 All-Reduce 汇聚。

技术上的 All-Reduce 不是在空气中传播声音，而是把各设备算出的局部结果 Yᵢ 做逐元素相加。为什么是加法而不是拼接？因为矩阵分块乘法告诉我们：输入按列切、权重按行切后，整体乘积等于各局部乘积之和。每一个局部乘积只是“部分和”，所有部分和加起来才是正确答案。

完整的前向流程分三步：第一步，每台设备用本地数据算 Yᵢ = XᵢWᵢ；第二步，执行一次 All-Reduce（归约操作为加法），把 p 个 Yᵢ 加起来；第三步，每台设备都拿到完整的输出 Y，交给下一层。注意，这里每台设备都持有完整 Y，而知道 Y 的梯度 dY 也是完整共享的——这为反向传播“零通信”埋下了伏笔。

合唱的魅力正在于此：每个声部只发出 1/p 的声音，观众听到的却是完整旋律；每台设备只算了 1/p 的活，下一层拿到的 Y 与串行计算结果完全一致。声音叠加是瞬时的，但 All-Reduce 要花通信时间——这个代价留到第五节细算。

3. 反向传播特性

演出结束，指挥没有让大家集合复盘，而是说：“今晚表现不错，各声部自己回去练自己的部分就好了。”为什么可以各练各的？因为每个声部的问题只和自己的谱子与歌词有关。行并行的反向传播正是这样：不需要任何跨卡通信。

数学上，损失 L 对输出 Y 的梯度 dY 由上层反向传来，对每台设备来说它都是已知的。由于 Y = ΣYᵢ，而求和运算的梯度就是“广播”——∂L/∂Yᵢ = ∂L/∂Y = dY，所以每台设备手里的 dY 可以直接用于本地计算，不需要等任何人。

于是两个梯度都在本地完成：权重梯度 dWᵢ = Xᵢᵀ · dY，只需要自己的输入分片和全局输出的梯度；输入梯度 dXᵢ = dY · Wᵢᵀ，只需要全局输出梯度和自己的权重分片。其中 dXᵢ 恰好就是完整输入梯度 dX 的第 i 列块，天然按位置存放，不需要 All-Gather 拼接。这与列并行恰好对称：列并行是“前向 All-Gather、反向 All-Reduce”，行并行是“前向 All-Reduce、反向零通信”。

每个声部回家自己练声，互不打扰。这份“静音”的优雅，在与列并行组合时体现得淋漓尽致——列并行负责反向的 All-Reduce 通信，行并行负责前向的 All-Reduce 通信，两队声部交错发声，谁都不抢谁的麦。

4. 与列并行组合

合唱团里通常分“高声部组”和“低声部组”，两组既要独立训练，又要默契配合。列并行与行并行正是这样一对黄金搭档：一个按“列”切矩阵，一个按“行”切矩阵，在 Transformer 的 MLP 层中配合得天衣无缝。

Megatron-LM 的 MLP 包含两个线性层，中间夹一个激活函数。设计者的安排是：第一层用列并行（权重 W₁ 按列切），第二层用行并行（权重 W₂ 按行切）。为什么这么配？关键在输出与输入的“咬合”——列并行算出的激活输出在特征维度上天然是切分的，而行并行恰好要求输入按列切分。两者一拼，中间根本不需要把激活值拼接完整再分发。

具体流程是：设备 i 持有 W₁ 的第 i 个列块 W₁,ᵢ 和 W₂ 的第 i 个行块 W₂,ᵢ。前向时，设备 i 先算出 Uᵢ = XW₁,ᵢ（列并行局部输出，不需要通信），接着就地过激活函数得到 Yᵢ = σ(Uᵢ)，然后直接做行并行的局部乘法 Zᵢ = YᵢW₂,ᵢ，最后 All-Reduce 得到完整 Z。全程 Y 从未被拼成完整矩阵，省掉了一次 All-Gather 加一次切分的通信开销。

高声部组把旋律劈开分给组员（列并行），低声部组在同一时间接力竖切和声（行并行），两组之间不需要停下来把声音合一遍再重新分工。这种“中间状态零拼接”的配合，正是大模型训练中省通信的精妙设计。

5. 通信开销分析

和声虽美，但把几十个声部的声音汇聚起来是有代价的——团员们得移动位置、对齐节奏。在多卡训练中，通信比计算更昂贵。所以我们需要精确地知道：一次 All-Reduce 到底搬了多少数据？

行并行前向只有一次 All-Reduce，它的通信量由输出矩阵 Y 的大小决定。设批大小为 B，输出特征维度为 N，每台设备的局部结果 Yᵢ 就是一个 B×N 的矩阵。All-Reduce 要在 p 台设备之间把这个矩阵的所有局部版本归约成一份。

一次 All-Reduce 的通信量怎么算？理想化的环形归约中，每台设备总共发送和接收各约 (p-1)/p 份数据。因此单次通信的流量（以元素个数计）约为 2BN(p-1)/p。这个数字与模型参数量无关，只和输出形状及设备数挂钩——当 N 很大时，通信占比会明显上升，这也是为什么张量并行一般只在单机多卡（NVLink 高速互联）内使用。

合唱团人越多，每个团员需要和其他人对齐的比例反而越高（(p-1)/p 趋向 1）。但妙的是，列并行把类似的开销放在了反向，行并行把它放在前向——两个声部组交错发声，通信高峰被削平，整体训练更顺畅。

6. 工程实现要点

成熟的合唱团靠纪律保证演出质量：谱子怎么分、谁领唱、座位怎么排，都有讲究。工程上落地行并行同样有几条“排练纪律”，稍不留神就会跑调。

首先是权重初始化。由于每台设备只持有一块 Wᵢ，初始化随机种子必须按分片对齐，使得所有分片拼接后整体分布与不切分的权重一致。否则可能出现某些设备初始化过大，模型训练直接发散。出于同样的道理，优化器状态（如 Adam 的一阶/二阶动量）也应随分片存放在各设备上，显存自然均摊。

其次是偏置处理。行并行的输出是求和得到的，偏置 b 的形状与输出维度一致，不能按设备切分。如果每台设备都把 b 加在各自的局部结果上，再 All-Reduce，最终偏置会被放大 p 倍。正确做法是：All-Reduce 之后再统一加一次 b；或让某台设备加 b，借 All-Reduce 自然广播。还有一点是显存负载均衡：输入按列切分后，各设备存储的激活量与特征分片成正比，与列并行配对的层必须保证特征维度对齐，避免某块 GPU 变成“显存热点”。

分谱清晰（初始化对齐）、领唱明确（偏置只加一次）、座位合理（负载均衡）——把这些纪律执行到位，行并行才能真正发挥“人多力量大”的优势。Megatron-LM、TensorRT-LLM 等框架正是靠这些细节，让千万亿参数的模型训练成为可能。

AI 应用场景

Python 演示

import numpy as np  def row_parallel_forward(X, W, p=2):    """Simulate row-parallel forward with p devices."""    batch, in_f, out_f = X.shape[0], W.shape[0], W.shape[1]    chunk = in_f // p     # 1. split weight by rows, split input by columns    W_chunks = [W[i * chunk:(i + 1) * chunk, :] for i in range(p)]    X_chunks = [X[:, i * chunk:(i + 1) * chunk] for i in range(p)]     # 2. each device computes local product    local_out = [X_chunks[i] @ W_chunks[i] for i in range(p)]     # 3. All-Reduce: sum all local outputs    Y_parallel = local_out[0]    for i in range(1, p):        Y_parallel = Y_parallel + local_out[i]    return Y_parallel  def row_parallel_backward(dY, X, W, p=2):    """Simulate row-parallel backward: zero cross-device communication."""    batch, in_f, out_f = X.shape[0], W.shape[0], W.shape[1]    chunk = in_f // p    W_chunks = [W[i * chunk:(i + 1) * chunk, :] for i in range(p)]    X_chunks = [X[:, i * chunk:(i + 1) * chunk] for i in range(p)]     # local gradients, no communication needed    dW_chunks = [X_chunks[i].T @ dY for i in range(p)]    dX_chunks = [dY @ W_chunks[i].T for i in range(p)]    return dW_chunks, dX_chunks  if __name__ == "__main__":    rng = np.random.default_rng(42)    batch, in_f, out_f = 8, 6, 4    X = rng.normal(size=(batch, in_f))    W = rng.normal(size=(in_f, out_f))    dY = rng.normal(size=(batch, out_f))     # forward: compare with reference    Y_ref = X @ W    Y_row = row_parallel_forward(X, W, p=2)    print("Forward match:", np.allclose(Y_ref, Y_row))     # backward: compare gradients    dW_ref, dX_ref = X.T @ dY, dY @ W.T    dW_parts, dX_parts = row_parallel_backward(dY, X, W, p=2)    dW_cat = np.concatenate(dW_parts, axis=0)   # stack row chunks    dX_cat = np.concatenate(dX_parts, axis=1)   # stack column chunks    print("dW match:", np.allclose(dW_ref, dW_cat))    print("dX match:", np.allclose(dX_ref, dX_cat))

1. W_chunks = [W[i * chunk:(i + 1) * chunk, :] for i in range(p)]把权重矩阵按行切成 p 块，每台设备拿一块。
2. X_chunks = [X[:, i * chunk:(i + 1) * chunk] for i in range(p)]把输入按列切成 p 块，与行块配对。
3. local_out = [X_chunks[i] @ W_chunks[i] for i in range(p)]每台设备只做自己的局部矩阵乘法。
4. Y_parallel = Y_parallel + local_out[i]模拟 All-Reduce 的求和归约过程。
5. dW_chunks = [X_chunks[i].T @ dY for i in range(p)]权重梯度只用本地输入分片计算，不跨卡。
6. dX_chunks = [dY @ W_chunks[i].T for i in range(p)]输入梯度也在本地算，天然按列分片存放。
7. np.allclose(Y_ref, Y_row)验证并行结果与串行参考结果完全一致。

常见误区

面试题