想玩转GPT3这样的超大规模模型(例如175billion parameters=1750亿),那就有必要详细了解一下multi-node(多机) multi-gpu(多卡)的工作原理和细节。
通过对Megatron的学习,期望掌握的是:
- Transformer如何通过multi-node, multi-GPU实现,例如其中的multi-head attention layer, point-wise feed-forward network;
- 如何实现三种并行:数据并行(mini-batch),Tensor并行(把一个张量切成若干部分),和Pipeline并行(把一个网络的多个层进行按层切割),以及这三种并行的综合使用;
- 训练,重训,fine-tuning,多语言扩展等方面的具体的应用。
一、预置知识
1、intra-layer model parallel approach和inter-layer model parallel approach的区别。
猛一看,这两个的中文翻译都是“层内模型并行方法”。其实它们是有区别的:
image.png
即,inter-layer 并行,对应的是pipeline并行。例如上图右上方的6层网络,前三层给一个GPU,后三层给另外一个GPU。
而另外一个是intra-layer并行,对应的是tensor并行。例如上图右下方的6层网络,横向切一刀,即一个tensor张量,会被分配到不同的GPU上面。
2、orthogonal and complimentary 正交和互补
这个概念我看第一遍论文的时候,完全不理解。其实就是上面的两个图,竖向切了一刀vs.横向切了一刀,那么这两个切法,就是“正交的”(夹角90度)。而且这两个方法可以同时在一个代码中实现,具有“互补”的关系,即:
image.png
3、scaling efficiency的计算公式
76%这个数字在论文中出现了若干次,具体是怎么计算出来的呢?
前提条件:
条件一:512个GPU;通过Megatron的提案并行方法,达到的实际的整体算力是:15.1 PetaFLOPs per second(即,15.1*1000 TeraFLOPs);
条件二:单个NVIDIA V100 32GB GPU,训练1.2 billion参数的模型的时候,算力为39 TeraFLOPs;
所以计算公式是:
image.png
。这个类似于衡量在多机多卡并行的时候,GPU的“利用率”的度量。
二、Model Parallel Transformers
直接看最核心的地方:
Model Parallel Transformers (模型并行Transformers,特别指的是Tensor Parallel,即Intra-layer)
Transformer中有两类比较重要的sublayers,一个是MLP(即双层线性层,张量的最后一个dimension从h到4h,然后再从4h回到h);而另外一个是multi-head attention layer(多头注意力层)。
问题:怎么把这两种sublayers给切开到不同的GPU卡上?
三、MLP的多GPU实现
1、先看一个简单的问题,如何用多GPU来计算两个张量的乘积?(并行线性层)
假设公式为Y = XW,这里X是输入,W是权重,Y是输出;这是最简单的一个线性层。我们侧重看权重W被怎么切,因为这个是一个矩阵,其负责对张量X的最后一个维度进行“变形”。显然,我们可以:
或者,纵向切W,得到W=[W1, W2]。
image.png
这里有意思的地方在于,
当横向切分W,得到上下两个W1, W2子矩阵的时候,为了保证XW的运算结果,我们只能是对X进行纵向切割,并要求:
X1的最后一个维度=W1的最前一个维度;
X2的最后一个维度=W2的最前一个维度。
这样的话,我们就可以把X1和W1放到一个GPU上;把X2和W2放到另外一个GPU上。它们都计算完毕之后,再相加(一个同步点),然后把相加的结果,回传给这两个GPU(如果有必要的话)
image.png
上面是直观的示例,能不能拔高一些,来点更具有概括性的,有格调的?
当然可以,首先需要对X纵向切分,我们需要一个函数f来做这个事情,输入是X,而输出是X1, X2,且X=[X1, X2]。
这个函数,前向forward的时候,是对X进行切割split,(最后一个维度),例如(32, 100, 1024)被切割为两个(32, 100, 512)的形状的张量。那backward的时候呢?直观考虑,应该是切割的反操作,即拼接,我们就是要按照最后一列对“梯度”拼接了,类似于:
image.png
之后,我们还需要一个函数g,来对X1W1和X2W2相加。这个函数,前向forward是负责相加(每个gpu上的运算结果相加到一起,会涉及到gpu的wait,即一个gpu运行完毕之后,需要等待),这个可以通过pytorch的all-reduce函数实现;而backward的时候,鉴于X1W1和X2W2的形状相同,那么就是把相加之后的张量的梯度,原封不动的传递给每个gpu,继续反向传播的过程。即
image.png
使用一个图形来表示这个所谓“row parallel linear layer”,我们就有:
image.png
而,当纵向切分W,得到左右W1, W2两个子矩阵的时候,鉴于W1, W2的第一个维度(行数)都没有变化,那么X的最后一个维度也不能边,从而有:
image.png
这样的话,同样的,我们可以把X和W1的乘积运算放一个GPU上;把X和W2的乘积运算放另外一个GPU上。
image.png
类似于前面的"row parallel lineary layer",这里,纵刀流,我们称为“column parallel linear layer",而其中我们也需要自定义两个函数,来实现多gpu并行下实现:
f函数,前向forward,因为每个gpu都是直接拿到X,所以forward就是identity function,相当于分发X到不同的gpu;
而backward的时候,每个gpu上的关于X的梯度,会相加得到新的关于X的梯度,即需要的是pytorch的all-reduce函数:总结即:
image.png
image.png
使用图形示例就是:
image.png
也就是说,我们有上面两种方法来实现一个最简单的“线性层”。
2、MLP的多GPU实现
先看MLP的部分:
在原始的Transformer中,MLP,即point-wise feed forward sublayer,是包括了两个线性层的,实现了hidden.size -> 4*hidden.size -> hidden.size的这样的变换的神经网络。
具体为:
XA -> RELU -> Dropout -> XB
XA -> RELU -> Dropout -> XB
(这里的A和B分别是线性层中的变换矩阵)
对应的超级简化后的代码为:
"Implements FFN equation."
def __init__(self, d_model, d_ff, dropout=0.1):
# d_model = 512
# d_ff = 2048 = 512*4
super(PositionwiseFeedForward, self).__init__()
self.w_1 = nn.Linear(d_model, d_ff)
# 构建第一个全连接层,(512, 2048),其中有两种可训练参数:
# weights矩阵,(512, 2048),以及
# biases偏移向量, (2048)
self.w_2 = nn.Linear(d_ff, d_model)
# 构建第二个全连接层, (2048, 512),两种可训练参数:
# weights矩阵,(2048, 512),以及
# biases偏移向量, (512)
self.dropout = nn.Dropout(dropout)
def forward(self, x):
# x shape = (batch.size, sequence.len, 512)
# 例如, (30, 10, 512)
return self.w_2(self.dropout(F.relu(self.w_1(x))))
# x (30, 10, 512) -> self.w_1 -> (30, 10, 2048)
# -> relu -> (30, 10, 2048)
# -> dropout -> (30, 10, 2048)
# -> self.w_2 -> (30, 10, 512)是输出的shape
上面的代码中,给定输入张量x,其shape为(batch.size, sequence.length, hidden.size),然后首先经历self.w_1,之后是relu这个非线性函数,再走dropout,最后扔给的是第二个线性层,即self.w_2。
怎么安排XA和XB这两个线性层的并行性?是用“横刀流”,还是“纵刀流”?我们用笨方法思考,大不了四个组合形式了:横横,横纵,纵横,纵纵。
第一个线性层上:
按照对横刀流的思考,如果横向切割A,那么必须要纵向切割X,并且为了保证XA的完整性,需要X1A1+X2A2,即:
image.png
这就是说,横向切割权重A,必然需要一个同步点,如果这个同步点后面遇到的是线性函数,那当然可以把线性函数放这个同步点的前面,例如假设线性函数是y=ax,那么可以在X1A1和X2A2相加之前,先执行y=ax,并分别得到:aX1A1和aX2A2这两个分别的结果,然后它们再相加,也不影响最后的结果。
但是,relu或者bert中的gelu都是非线性函数,那么我们无法先执行这个非线性函数,然后再相加,即gelu(X1A1)+gelu(X2A2) != gelu(X1A1+X2A2)。即需要在gelu之前,设置一个同步点,从而让不同的gpu之间交互信息。
结论是什么?
如果第一个线性层,使用横刀流,则需要在gelu之前加一个”同步点“(gpu停下手中的计算任务,把数据交换了再说,如果有结束的早的gpu,那就wait到其他的gpu的结果计算出来为止。。。这会导致一定程度的gpu浪费)。
反过来看第一个线性层y=XA,如果使用纵刀流,结果会怎样呢?
image.png
鉴于XA1和XA2是通过最后一个维度拼接的,那么我们当然可以先计算gelu(XA1)和gelu(XA2),然后把gelu(XA1)和gelu(XA2)拼接,这不影响最终的结果。这个就有意思了,可以看到为了计算gelu这个非线性函数,我们不需要设置一个同步点了!
所以,第一层线性层,我们优先选择纵刀流(纵向切割权重A)。
第二个线性层呢?
现在看看,当第一个线性层选了纵刀流的时候,结果就是传递给第二个线性层的X'是已经纵向切割的了,我们当然可以对B继续使用纵刀流,分别对XA1和XA2进行处理,这个时候就需要对B切三刀,得到四块了,有些琐碎。还有一个方法,就是对B使用横刀流,类似于:
这样,可以继续在gpu1上运行(XA1)B1,以及在GPU2上运行(XA2)B2。只有到最后计算完毕之后,才需要一个同步点,把两个gpu上分别的计算结果加在一起。
所以,第二层线性层,我们优先选择横刀流(横向切割权重B)。
总结起来,得到论文中的下图:
MLP的概要图,f和g是两个关键的函数,其中f来自“纵刀流”的f;而g来自“横刀流”的g
上图中:
一,X,表示输入张量,例如其shape为(batch.size, sequence.length, hidden.size),例如取值为(32, 100, 1024);
二,f,自定义的激活函数,forward就是identity 函数,即X传播到不同的GPU上面(copy-style),而其backward则是类似于:
image.png
这样的all_reduce函数(pytorch自己带的);
这个函数,使用了前面讲述的"column parallel linear layer"的f函数!即:
image.png
三,XA1, XA2,即通过对A纵向一刀,得到的在两个gpu上运行的结果。当然,如果不是只切一刀,那当然可以使用更多的gpu来分别计算XA1, XA2, XA3, XA4...
四,GELU,非线性激活函数,Y1=GeLU(XA1);Y2=GeLU(XA2);
五,Y1B1和Y2B2,即通过对B横向一刀,得到的在两个gpu上运行的结果。当然可以切很多刀,把更小的块,扔给一个个gpu。
六:g,自定义的激活函数,前向forward的时候,是需要按照最后一个维度把Z1和Z2相加起来,即Z=Z1 + Z2,pytorch中的all_reduce函数可以实现这个“归约”操作;
而后向backward的时候,是类似identity的操作,即把一个完整的梯度张量,直接分发给各个gpu
image.png
这个函数,使用了前面讲述的"row parallel linear layer"的g函数!即:
只要横刀流的g函数
把两个图放一起,更加直观一些:
image.png
3、MLP的pytorch代码实现
这样的话,我们看看MLP的代码实现。
显然,MLP先是使用了"column parallel linear layer"(纵刀流线性层),其次使用了"row parallel linear layer"(横刀流线性层)。
我们先看看column parallel linear layer的forward函数的代码实现:
(megatron/mpu/layers.py)
def forward(self, input_):
# Set up backprop all-reduce. 输入的是整体h,输出的是4h/p被按照gpu分割之后的!
input_parallel = copy_to_tensor_model_parallel_region(input_)
# 前向复制identity,后向全归约all-reduce(论文中的Figure 3.a中的f)
# 原因:X在多个GPU上被简单复制(没有进行任何切割),类似X -> f -> [X, X, ..., X]
# 这样的话,反向的时候,就是多个gpu上的X的整体,
# 通过all_reduce合并到一起
#(例如相加然后平均,或者直接element-wise相加 -> 这里是使用element-wise相加)
# Matrix multiply.
bias = self.bias if not self.skip_bias_add else None
# 当不“忽略bias”的时候,带上self.bias
output_parallel = F.linear(input_parallel, self.weight, bias)
# import torch.nn.functional as F
# X * A_i^T = (b, s, h) * (h, 4h/p) = (b, s, 4h/p) = output_parallel
if self.gather_output:
# 作为独立的'column parallel linear layer'所需要的g函数,
# 即forward使用all-gather:
# All-gather across the partitions.
output = gather_from_tensor_model_parallel_region(output_parallel)
# 前向拼凑,后向切割
# 前向把各个GPU上的Y_i,进行拼凑,得到Y;
# 即,从(b, s, 4h/p)拼凑到(b, s, 4h)的过程。
# 后向的时候,把Y按照GPU的数量,进行切割,
# 并送回到各个GPU。即,从(b, s, 4h)切割到(b, s, 4h/p)的过程。
else:
output = output_parallel
# 当前的'column parallel linear layer'
# 作为GPU并行Transformer中的MLP的一部分的时候的用法:
# TODO 注意,如果不gather,则实际在这里输出的是4h/p,
# 是一个gpu上的结果!而不是整体的4h!
# 这个部分非常重要,有助于理解selfattention中的每个tensor的维度!
output_bias = self.bias if self.skip_bias_add else None
return output, output_bias
或者使用下图示意:
image.png
下面继续看row parallel lineary layer的forward函数部分(横刀流的线性层):(megatron/mpu/layers.py)
def forward(self, input_):
# Set up backprop all-reduce. 输入的tensor是被分割到每个gpu的,
# 输出的tensor是整体all-reduce之后的!
if self.input_is_parallel: # Transformer's MLP使用这个部分:
input_parallel = input_
else: # 作为独立的row parallel线性层,使用这个部分:
input_parallel = scatter_to_tensor_model_parallel_region(input_)
# 前向切割,后向拼凑
# 如果有必要,先把输入inputs_=X按照?(应该是最后一列,即4h -> 4h/p)切割,
# 按照gpu的数量。
# 得到的是X_1, ..., X_p这样的,shape是?
# (batch, seq, 4*hidden/p) 或者(seq, batch, 4*hidden/p)
# Matrix multiply. [Y1*B1] to [Yi*Bi] in Figure 3(a):
output_parallel = F.linear(input_parallel, self.weight)
# 注意,输入是X_i,而且经历的weight是A_i
# 从4h/p -> h的linear (是对tensor的最后一列进行变换的!
# 至于mini-batch方面,则是data-parallel的问题,这里不考虑!)
# 相当于从X_i=(b, s, 4h/p) * A_i^T=(4h/p, h) -> (b, s, h)这样的结果。
# 可以看到X按照最后一个维度被切割成了p份(gpu的数量);
# 然后经过线性层,从4h/p维度,被映射成了h维度。所以,最后的输出是(b, s, h).
# All-reduce across all the partitions. [g function in Figure 3(a)]
output_ = reduce_from_tensor_model_parallel_region(output_parallel)
# 前向全归约,后向复制(Figure 3(a) right-hand-side)
# 对每个gpu上的(b, s, h)进行all_reduce,叠加(求平均),
# 然后得到的是(b, s, h),每个gpu上面都保持了最新的结果。
if not self.skip_bias_add: # add:
output = output_ + self.bias if self.bias is not None else output_
# 把bias加到output_上
output_bias = None
else: # not add:
output = output_
output_bias = self.bias
return output, output_bias
使用图示表示,即:
image.png
最后看看MLP(class ParallelMLP)中的forward函数:
(megatron/model/transformer.py)
def forward(self, hidden_states):
# [s, b, 4hp] (序列长度,批大小,4*一个划分上的隐层维度hp)? TODO-okay
# 这里应该是一个整体的隐层维度大小(所有gpu的整体)[s, b, 4*h]
# -> NO, is [s, b, 4h/p] for one gpu!
intermediate_parallel, bias_parallel = self.dense_h_to_4h(hidden_states)
if self.bias_gelu_fusion:
intermediate_parallel = \
bias_gelu_impl(intermediate_parallel, bias_parallel) # TODO
else:
intermediate_parallel = \
self.activation_func(intermediate_parallel + bias_parallel)
# [s, b, h] (序列长度,皮大小,隐层整体维度?!居然不是hp? TODO-okay)
# -> 应该不是hp; 应该是4hp -> h
# RowParallelLinear : 负责对整体的hidden size,按照gpu进行切割处理
output, output_bias = self.dense_4h_to_h(intermediate_parallel)
# is from [s, b, 4hp] to [s, b, h] (入分,出和)
return output, output_bias
使用图示即:
(特别需要注意的是,首先使用的是“纵刀流”的f函数;其次使用的是“横刀流”的g函数):
MLP的forward函数的代码截图
小结:
其一,在column parallel linear layer中,考虑了这个线性层独立使用,或者作为MLP的前半部分使用的情况;
其二,同样的,在row parallel linear layer中,考虑了这个线性层独立使用,或者作为MLP的后半部分使用的情况。
其三,ParallelMLP,就是把上面的两个线性层给“连起来”。图示为:
image.png这里的f,来自column parallel linear layer;(纵刀流)
g,来自row parallel linear layer。(横刀流)。
4、 Multi-head self-attention sublayer的实现
分析清楚了MLP的多gpu的实现之后,multi-head self-attention sublayer就相对简单一些了,因为其中的四个线性层,都可以复用已有的column/row parallel linear layers。
论文中的思想是每个head的计算,独立到一个gpu上面,类似于下面的示意:
image.png
上图的左边是通过f,先把X分发到多个GPU上(直接copy)。然后每个head相关的三个线性层转换Q, K, V,这三个都是用的“纵刀流linear layer”。在代码中,可以是使用一个h到3h的linear layer,最后再按照最后一个维度三等分,得到Q, K, V。
之后,计算QTK1,之后扔给softmax,再给dropout,之后就是V1和这个attention score进行乘积。得到Y1,再走一个“横刀流”的linear layer。
当然,实际在代码实现的时候,不一定是一个head占一个gpu,也可以是一个gpu上有若干head,然后每个head的hidden.size和gpu中head的数量,合在一起,进行linear layers和multi-head self-attention的计算。
下面是相对详细的代码部分:
def forward(self, hidden_states, attention_mask, layer_past=None,
get_key_value=False):
# hidden_states: [sq, b, h]
# =====================
# 1. Query, Key, and Value
# =====================
# Attention heads [sq, b, h] --> [sq, b, (np * 3 * hn)],
# np=每个gpu上head的数量, hn=每个head的隐层维度,np*3*hn=3h/p是一个gpu上的!
# 不应该在这里的啊!这里的应该是3h作为输出的维度 TODO-okay(这里是“总调度”,
# 不是各个gpu上的并行)
# n/p * 3 * h/n = 3h/p finally
# (is actually for one gpu's hidden dimension!)
# 纵刀流:三个linear layer都是纵刀流
mixed_x_layer, _ = self.query_key_value(hidden_states)
# from h to 3h,这里还是整体的变换(非也,是h -> 3h/p)
# ...
# [sq, b, np, 3 * hn] --> 3 [sq, b, np, hn],
# 每个gpu上的head的个数,之后是每个head对应的隐层的维度
# 也就是说,head的数量,应该>= GPU的数量!
(query_layer,
key_layer,
value_layer) = mpu.split_tensor_along_last_dim(mixed_x_layer, 3)
# 按照最后一列维度,三等分
# ...
# ===================================
# 2. Raw attention scores. [b, np, s, s] 完成的是Q*K^T的运算!
# ===================================
# [b, np, sq, sk]
output_size = (query_layer.size(1),
query_layer.size(2),
query_layer.size(0), # sq = sequench length of q
key_layer.size(0)) # sk = sequence length of k
# [sq, b, np, hn] -> [sq, b * np, hn]
# batch * num_head_per_gpu -> 相乘之后,类似于组成了新的batch!
query_layer = query_layer.view(output_size[2],
output_size[0] * output_size[1], -1)
# [sq, b*np, hn]
key_layer = key_layer.view(output_size[3],
output_size[0] * output_size[1], -1)
# [sk, b*np, hn]
# preallocating result tensor: [b * np, sq, sk]
matmul_result = torch.empty(
output_size[0]*output_size[1],
output_size[2],
output_size[3],
dtype=query_layer.dtype,
device=torch.cuda.current_device())
# Raw attention scores. matmul_result's shape=[b*np, sq, sk]
matmul_result = torch.baddbmm(matmul_result,
query_layer.transpose(0, 1), # from [sq, b*np, hn] to [b*np, sq, hn]
key_layer.transpose(0,1).transpose(1, 2),
# from [sk, b*np, hn] to [b*np, sk, hn] and to [b*np, hn, sk]
beta=0.0, alpha=(1.0/self.norm_factor))
# 得到的结果是: [b*np, sq, hn] * [b*np, hn, sk] -> [b*np, sq, sk]
# change view to [b, np, sq, sk]
attention_scores = matmul_result.view(*output_size)
# ...
# ===========================
# 3. Attention probs and dropout
# ===========================
# attention scores and attention mask [b, np, sq, sk]
attention_probs = self.scale_mask_softmax(attention_scores,
attention_mask)
# This is actually dropping out entire tokens to attend to, which might
# seem a bit unusual, but is taken from the original Transformer paper.
# TODO where? to confirm?
with mpu.get_cuda_rng_tracker().fork():
attention_probs = self.attention_dropout(attention_probs)
# =========================
# 4. Context layer. [sq, b, hp]
# =========================
# value_layer -> context layer.
# [sk, b, np, hn] --> [b, np, sq, hn]
# context layer shape: [b, np, sq, hn]
output_size = (value_layer.size(1),
value_layer.size(2),
query_layer.size(0),
value_layer.size(3))
# change view [sk, b * np, hn]
value_layer = value_layer.view(value_layer.size(0),
output_size[0] * output_size[1], -1)
# change view [b * np, sq, sk]
attention_probs = attention_probs.view(output_size[0] * output_size[1],
output_size[2], -1)
# matmul: [b*np, sq, sk] * [b*np, sk, hn] -> [b * np, sq, hn]
context_layer = torch.bmm(attention_probs, value_layer.transpose(0,1))
# =================
# 5. Output. [sq, b, h], sq=sequence length of q, b=batch size,
# h=hidden size
# =================
# 也就是说,这里扔给self.dense的时候的,
# context_layer是已经被切割之后的了!所以其最后一个维度是hp=h/p,而不是h!
output, bias = self.dense(context_layer)
# h-> h 的线性映射,RowParallelLinear
if get_key_value:
output = [output, present]
return output, bias
如果把上面的代码进一步简化,其实是如下五步:
一,mixed_x_layer, _ = self.query_key_value(hidden_states) # h->3h的纵刀流;然后按照最后一个维度切割成三份:
(query_layer, key_layer, value_layer)=mpu.split_tensor_along_last_dim(mixed_x_layer,3)
二,Query和Key的attention score的计算:
matmul_result = torch.baddbmm(matmul_result,
query_layer.transpose(0,1), # from [sq, bnp, hn] to [bnp, sq, hn]
key_layer.transpose(0,1).transpose(1,2), # from [sk, bnp, hn] to [bnp, sk, hn] and to [b*np, hn, sk]
beta=0.0, alpha=(1.0/self.norm_factor)) # 得到的结果是: [bnp, sq, hn] * [bnp, hn, sk] -> [b*np, sq, sk]
三,attention mask和dropout的计算:
attention_probs = self.scale_mask_softmax(attention_scores, attention_mask) # This is actually dropping out entire tokens to attend to,
with mpu.get_cuda_rng_tracker().fork():
attention_probs = self.attention_dropout(attention_probs)
四,attention score和value.tensor的乘积:
context_layer = torch.bmm(attention_probs, value_layer.transpose(0,1))
五,输出的时候,最后加一个row parallel linear layer:
output, bias = self.dense(context_layer)# h-> h 的线性映射,RowParallelLinear
5、一个Transformer Layer的代码实现
即class ParallelTransformerLayer里面的代码分析:
在init函数里面有如下若干object:
self.input_layernorm = LayerNorm(
args.hidden_size,
eps=args.layernorm_epsilon)
# self attention:
self.attention = ParallelSelfAttention(attention_mask_func, init_method,
output_layer_init_method,
layer_number)
self.post_attention_layernorm = LayerNorm(
args.hidden_size,
eps=args.layernorm_epsilon)
# MLP, h->4h->h
self.mlp = ParallelMLP(init_method,
output_layer_init_method)
https://zhuanlan.zhihu.com/p/366906920
https://zhuanlan.zhihu.com/p/388830967
https://zhuanlan.zhihu.com/p/405883984
https://zhuanlan.zhihu.com/p/407094090
网友评论