update:qwen2公布了技术报告[1]。和本文里依赖的基础信息的基本没差。但训练数据集变成7t了。笔者已经在文章中修正。另外训练语料的长度也是在最后阶段才从4096拓展到32768。所以本文预估的算力需求会有一定程度高估,但不到一倍。
让我们想象一个场景,假如说某一天,上面哪个大老板突然拉着你进一个会议,会上一群人问你:假如给你一个千卡集群,你训一个qwen/百灵/凤凰/chatglm/chatgpt出来,能不能搞?有什么困难?需要多久?
此时肯定是结论先行:能训。此时此刻,非我莫属。
但第二个问题怎么回答呢?需要一堆数据,需要多少T,需要多少人力?需要一个工程组来搞定千卡架构的问题,需要一些算法hc,招人嘛。
那就剩下第三个问题了,需要多久才能训好一个大模型?日常算法训练一般是直接拉上去先跑着,从tqdm进度条和loss曲线大概预估下。但开着会,总不能说先让我把数据,工程组准备好,我先跑几个step试试?
本文就是回答这个核心问题。预训练一个模型,需要多久。
1.预训练一个qwen2-72b,给定7T tokens数据集,6000张A100,一个完整epoch需要最多30天。训练语料的长度是在预训练最后阶段才从4096拓展到32768(但笔者没找到这个时间点)。所以本文预估的算力需求会有一定程度高估,但不会超过1.6倍。
2.计算量需求公式为3*T(2.6e6*s + 2P),其中T为数据集token数量,P为模型参数量,s表示序列长度。在序列长度较短时退化为6TP。若使用了全部重计算技术,则系数由3变成4。
3.大模型计算量只和“矩阵乘法”有关。且反向传播过程是正向的2倍。不同优化器影响不大。
4.attention对seq长度的平方复杂度,拉到32768长度对总算力需求也就是增加0.6倍。
5.batch size对计算量没有影响。在超过某个阈值后对训练时间没有影响。
FLOPS
定义:floating point operations per second,每秒浮点运算次数。即常规理解中,硬件的性能(计算速度/算力)。
注1:GPU的算力正常是打不满的。涉及到各种框架、并行、木桶原理、通信、调度、内存的概念。可以出100道面试八股文,淹死一整个算法工程团队。正常记住几个结论对算法就够用了:
A100,单卡单精度,利用率MFU一般在25到75%之间(FlashAttention2能拉到上限),取个居中的50%,约等于300 T FLOPS。
H100,算力是A100的三倍多一点,利用率MFU需要最新出的FlashhAttention3才能拉到上限,一般可取1000 TFLOPS。
注2:即使是同一个gpu,对不同精度的运算,性能也是不一样的。这个涉及到硬件设计的架构实现,以及各种精度运算的硬件实现。这里不赘述。
详细原因可参考:
不同产品的计算能力:https://developer.nvidia.com/cuda-gpus
计算能力解释:https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#compute-capability-9-0
英伟达A100与H100以及利用NVLink技术将两块H100互连的GPU在不同精度下FLOPS的对比。这里一个T就是10^12。
FLOPs
定义:floating point operations,浮点运算数量,即常规理解中,训练一个大模型需要的算力。可以用来衡量算法/模型的复杂度。乘法和加法混同看待。
1 MFLOPS(megaFLOPS)等于每秒一百万(=10^6)次的浮点运算。
1 GFLOPS = 10^3 MFLOPS(gigaFLOPS)等于每秒十亿(=10^9)次的浮点运算。
1 TFLOPS = 10^3 GFLOPS(teraFLOPS)等于每秒一万亿(=10^12)次的浮点运算,(1太拉)。
1 PFLOPS = 10^3 TFLOPS(petaFLOPS)等于每秒一千万亿(=10^15)次的浮点运算。
1 EFLOPS = 10^3 PFLOPS(exaFLOPS)等于每秒一百京(=10^18)次的浮点运算。
1 ZFLOPS = 10^3 EFLOPS(zettaFLOPS)等于每秒十万京(=10^21)次的浮点运算。
也是本文的主要内容。
MACs
定义:Multiply-Accumulate Operations,乘法加法累积操作次数。是深度学习领域最常见的计算的一种抽象。即将两个数相乘,并将乘积累加到一个累加器上。
也是描述(训练一个大模型需要的)算力的一种单位。
按照定义,1MACs ≈ 2FLOPs。
MACs用的不算多。根本原因在于正常大模型计算中,乘法和加法就是一比一的。导致没必要单独算这个。
一比一的原因可以继续看下面的分析。
硬件上矩阵乘法的算力需求
假设我们有个矩阵A : a1 * a2,有个矩阵B : b1 * b2。我们需要计算C = A * B
首先根据定义,a2 = b1,不妨设他们等于h。最终输出的矩阵C : a1 * b2。
如果记不得矩阵乘法的定义,可以参考这张图:
从C反推,a1 * b2个元素中。每一个元素都需要经历h次乘法,和h次加法。即,2h FLOPs = 1hMACs。
注:这里之所以不是h-1次加法,是因为硬件计算加法的本质是需要放到累加器里。所以哪怕是初始第一次乘法结果也得做一次加法。
即,A * B的矩阵计算,需要的算力为 2 * h * a1 * b2 FLOPs,即 2 * h * 输出矩阵参数量 FLOPs。
这里先摆一个qwen2-72b模型架构图。
放一下参数:
{ "architectures": [ "Qwen2ForCausalLM" ], "attention_dropout": 0.0, "bos_token_id": 151643, "eos_token_id": 151645, "hidden_act": "silu", "hidden_size": 8192, "initializer_range": 0.02, "intermediate_size": 29568, "max_position_embeddings": 32768, "max_window_layers": 80, "model_type": "qwen2", "num_attention_heads": 64, "num_hidden_layers": 80, "num_key_value_heads": 8, "rms_norm_eps": 1e-06, "rope_theta": 1000000.0, "sliding_window": 131072, "tie_word_embeddings": false, "torch_dtype": "bfloat16", "transformers_version": "4.40.1", "use_cache": true, "use_sliding_window": false, "vocab_size": 152064}
放一下模型运算py文件:
https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2/modeling_qwen2.py
前向计算过程
结论
大模型的算力需求基本只看矩阵乘法。
抽取出需要的参数:
vocab_size词表大小:152064
Embedding层(参数量占比1.7%,算力需求占比0%)
输出:[batch size, seq length, hidden size]
这层需要将输入的token序列映射为对应的embedding序列。
即,需要look up每一个输入token在词表中的embedding。
这里会涉及到一些position embedding的计算,例如输入序列长度超过:
会临时计算新的position embedding。不超过就直接取计算过的缓存等等。
但因为计算量实在太小,可忽略不计。
Transformer层(参数量占比96.6%,计算量占99%)
单个Transformer主要包括一个Attention块和一个FFN块,还有其他杂项,分别计算。
单个Attention块(参数量占比16%,计算量占48%)
class Qwen2Attention(nn.Module):
"""
Multi-headed attention from 'Attention Is All You Need' paper. Modified to use sliding window attention: Longformer
and "Generating Long Sequences with Sparse Transformers".
"""
def __init__(self, config: Qwen2Config, layer_idx: Optional[int] = None):
super().__init__()
self.config = config
self.layer_idx = layer_idx
if layer_idx is None:
logger.warning_once(
f"Instantiating {self.__class__.__name__} without passing `layer_idx` is not recommended and will "
"to errors during the forward call, if caching is used. Please make sure to provide a `layer_idx` "
"when creating this class."
)
self.hidden_size = config.hidden_size
self.num_heads = config.num_attention_heads
self.head_dim = self.hidden_size // self.num_heads
self.num_key_value_heads = config.num_key_value_heads
self.num_key_value_groups = self.num_heads // self.num_key_value_heads
self.max_position_embeddings = config.max_position_embeddings
self.rope_theta = config.rope_theta
self.is_causal = True
self.attention_dropout = config.attention_dropout
if (self.head_dim * self.num_heads) != self.hidden_size:
raise ValueError(
f"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}"
f" and `num_heads`: {self.num_heads})."
)
self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=True)
self.k_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=True)
self.v_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=True)
self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=False)
self.rotary_emb = Qwen2RotaryEmbedding(
self.head_dim,
max_position_embeddings=self.max_position_embeddings,
base=self.rope_theta,
)
def forward(
self,
hidden_states: torch.Tensor,
attention_mask: Optional[torch.Tensor] = None,
position_ids: Optional[torch.LongTensor] = None,
past_key_value: Optional[Cache] = None,
output_attentions: bool = False,
use_cache: bool = False,
cache_position: Optional[torch.LongTensor] = None,
) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
bsz, q_len, _ = hidden_states.size()
query_states = self.q_proj(hidden_states)
key_states = self.k_proj(hidden_states)
value_states = self.v_proj(hidden_states)
query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
kv_seq_len = key_states.shape[-2]
if past_key_value is not None:
if self.layer_idx is None:
raise ValueError(
f"The cache structure has changed since version v4.36. If you are using {self.__class__.__name__} "
"for auto-regressive decoding with k/v caching, please make sure to initialize the attention class "
"with a layer index."
)
kv_seq_len += past_key_value.get_usable_length(kv_seq_len, self.layer_idx)
cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)
query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids)
if past_key_value is not None:
cache_kwargs = {"sin": sin, "cos": cos, "cache_position": cache_position} # Specific to RoPE models
key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs)
# repeat k/v heads if n_kv_heads < n_heads
key_states = repeat_kv(key_states, self.num_key_value_groups)
value_states = repeat_kv(value_states, self.num_key_value_groups)
attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim)
if attn_weights.size() != (bsz, self.num_heads, q_len, kv_seq_len):
raise ValueError(
f"Attention weights should be of size {(bsz, self.num_heads, q_len, kv_seq_len)}, but is"
f" {attn_weights.size()}"
)
if attention_mask is not None: # no matter the length, we just slice it
causal_mask = attention_mask[:, :, :, : key_states.shape[-2]]
attn_weights = attn_weights + causal_mask
# upcast attention to fp32
attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)
attn_weights = nn.functional.dropout(attn_weights, p=self.attention_dropout, training=self.training)
attn_output = torch.matmul(attn_weights, value_states)
if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim):
raise ValueError(
f"`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is"
f" {attn_output.size()}"
)
attn_output = attn_output.transpose(1, 2).contiguous()
attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)
attn_output = self.o_proj(attn_output)
ifnot output_attentions:
attn_weights = None
return attn_output, attn_weights, past_key_value
输出:[batch size, seq length, hidden size]
挨个拆解步骤:
a.Q:q_proj * hidden_states,计算量 2 * hidden_size * num_heads * head_dim * batch size * seq length = 17,592,186,044,416 ≈ 17.6 TFLOPs;
b.K计算量减少num_attention_heads / num_key_value_heads倍,即2.2 TFLOPs;
c.V同k,2.2 TFLOPs;
2.应用旋转向量。计算量很小。
3.K、V矩阵拓展到num_attention_heads个头,放大num_attention_heads / num_key_value_heads倍。计算量很小。
a.此时Q矩阵和K矩阵形状一样,大小都是[batch size, seq length, hidden size];
b.上面这条算的是错误的。为什么错,多头注意力的多头计算就在这里要展开了;
a.实际做了指数计算、加法计算、矩阵标量除法计算;
a.注意力矩阵大小:[batch size, num_heads, seq length, seq length];
b.V矩阵大小:[batch size, num_heads, seq length, head_dim];
c.矩阵乘法结果矩阵大小:[batch size, num_heads, seq length, head_dim];
a.上一步矩阵大小:[batch size, num_heads, seq length, head_dim];
b.线性层矩阵大小:[hidden_size, num_heads, head_dim];
c.结果矩阵大小:[batch size, seq length, hidden_size];
综上,Attention块的算力需求约为 80层 * (17.6 TFLOPs + 2*2.2 TFLOPs + 70 TFLOPs + 0.25 TFLOPs + 3 * 0.25 TFLOPs + 70 TFLOPs + 17.6 TFLOPs) ≈ 14 PFLOPs。
计算公式可以化简为:num_hidden_layers * batch size * seq length * hidden size * (4.5 * hidden size + 4 * seq length)。
单个FFN块(参数量占比80%,计算量占51%)
# Copied from transformers.models.mistral.modeling_mistral.MistralMLP with Mistral->Qwen2
class Qwen2MLP(nn.Module):
def __init__(self, config):
super().__init__()
self.hidden_size = config.hidden_size
self.intermediate_size = config.intermediate_size
self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
self.act_fn = ACT2FN[config.hidden_act]
def forward(self, hidden_state):
return self.down_proj(self.act_fn(self.gate_proj(hidden_state)) * self.up_proj(hidden_state))
输入:[batch size, seq length, hidden size]
输出:[batch size, seq length, hidden size]
实际上涉及到计算量的就一行代码,三次矩阵乘法,一次过激活函数,一次矩阵点乘。
拆解分析:
1.输入矩阵 * up_proj矩阵,结果矩阵大小[batch size, seq length, intermediate_size]。计算量2 * batch size * seq length * hidden size * intermediate_size = 63,496,796,504,064 ≈ 63 TFLOPs;
2.输入矩阵 * gate_proj矩阵,同第一步,63 TFLOPs;
3.上一步的结果过激活函数。几乎不需要算力;
5.上一步的结果矩阵 * down_proj矩阵,同第一步,63 TFLOPs。
综上,FFN层的算力需求约 80层 * (3 * 63 TFLOPs + 7 * c GLOPs) ≈ 15 PFLOPs。
计算公式可以简化为6 * batch size * seq length * hidden size * intermediate_size * num_hidden_layers。
其他杂项(参数量占比0%*80,计算量占0%)
# Copied from transformers.models.llama.modeling_llama.LlamaRMSNorm with Llama->Qwen2
class Qwen2RMSNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-6):
"""
Qwen2RMSNorm is equivalent to T5LayerNorm
"""
super().__init__()
self.weight = nn.Parameter(torch.ones(hidden_size))
self.variance_epsilon = eps
def forward(self, hidden_states):
input_dtype = hidden_states.dtype
hidden_states = hidden_states.to(torch.float32)
variance = hidden_states.pow(2).mean(-1, keepdim=True)
hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
return self.weight * hidden_states.to(input_dtype)
输入:[batch size, seq length, hidden size]
输出:[batch size, seq length, hidden size]
输入的正则化和Attention块结果的正则化,本质都是RMSNorm计算。
qwen2的RMSNorm粗略可以理解为做了以下几步:
- 将数据转为双精度。
-
计算整个层所有输出向量的平方平均值向量variance。
这里k主要是涉及到平方、均值等运算的底层实现方式,我个人估测大概是10以内。
-
对所有向量乘以向量variance的平方根倒数在加上个eps。
计算量:2 * batch size * seq length * hidden size ≈ 2 * 10e9 FLOPs
- 将数据转回原始精度。
计算量大约是80*2* ( k + 2 ) GFLOPs。代入k=10,粗略估算得这里计算量约 1 TFLOPs。
输出层/分类头/Embedding逆映射(参数量占比1.7%,计算量占1%)
这里先Norm一下,( k + 2 ) GFLOPs
再转输出解码。
隐藏层状态 * [hidden size * vocab_size]
计算量:2 * hidden size * batch size * seq length * vocab_size = 326,554,953,449,472 ≈ 0.3 PFLOPs
公式推导
算力主要是attention、FFN、解码过程产生。
算力合计汇总:
batch size * seq length * hidden size * (2 * vocab_size + num_hidden_layers * (4.5 * hidden size + 4 * seq length + 6 * intermediate_size))
代入到本文的例子,qwen2-72b。4 * 32768 * 8192 * (2 * 152064 + 80 * (4.5 * 8192 + 4 * 32768 + 6 * 29568)) = 29,991,378,670,845,952 ≈ 30 PFLOPs
注:启用GQA后kv cache技术在继续生成阶段约能节约0.3PFLOPs的计算量,1%左右。影响不大。
另,为了简化公式方便理解,将其转变为:
bs*s*h(2V+L(4.5h+4s+6is))
其中,简写含义如下表所示。对于一个已经训好的模型,用户能够干涉的只有batch size和seq length,且按照经验,intermediate_size一般会和hidden size存在一定倍数关系。
进一步化简:bs * s,假设只过一轮epoch,就是全部数据的token数量。
由之前文章分析可得,一个大模型绝大部分参数都在输入输出两个embedding层加transformer层。具体来说,就是attention块和FFN块,和两个词汇映射矩阵。以qwen2为例,加起来共计需要 2*h*V+h*L*(3 is+2.25h)。
代入公式,得正向传播过程总计算量为 2T(2hLs+P) = T(2.6M*s + 144 B),其中T为数据集token数量,P为模型参数量。M表示1e6,B表示1e9
注1:这里公式里的s,就是八股文经常背的,attention原生的平方复杂度影响。也可以看出,只有当s长度超过三位数时,才会对大模型的执行时间产生明显影响。
注2:从中也可以看出,seq长度对大模型的影响并没有那么大。以wen2为例,seq就是拉到32768,对比seql长度为1,总的算力需求也就扩大1.6倍。没那么夸张。
数据验证
官方给出的部署效率(https://huggingface.co/Qwen/Qwen-72B-Chat)如下图所示:
两张A100,BF16,理论算力1248TFLOPS。大模型正向传播需要的算力代入公式:bs*s*(2.6M*s + 144 B),bs取1,s取1000token。则算出来一次正向输出需要0.115秒gpu时长。即输出速度为 8.67qps。和图片中8.48qps基本一致。
拓展八股文:为什么扩大batch size,大模型输出速度先提高后不变
a.结论是:卡内存带宽了。
b.gpu处理数据在一个完整的batch分两个部分,数据转移,数据计算。其中数据转移部分吃内存带宽,需要转移完整的模型参数和一个batch的数据参数。计算部分吃gpu算力,和待计算数据量正相关。
c.小batch下之所以卡在内存带宽,是因为每次转移完整的模型参数这步的处理时间是固定的。而转移batch数据,计算batch数据都和数据量正相关。导致batch越小,转移完整模型参数这步的带宽占比就越大。gpu处理每个batch时,如果batch size过小,数据计算会特别快的完成,但是还需要等待固定时间的模型数据转移完成,导致计算单元空置,算力利用率MFU自适应降低。
2.batch size达到一定大小,能完全发挥gpu算力时,调用大模型的训练时间已经和batch size无关了。公式里并没有bs。
反向传播过程
结论:反向传播的算力需求一般是前向传播的2倍。
实验证据:
图片来源自笔者之前几篇文章的实验部分。
理论计算:
注:这里其实也可以出一道八股文。为什么反向传播时,正向的矩阵乘法需要2次反向过程的矩阵乘法。
由于大模型算力需求核心在矩阵乘法。因此只考虑涉及到矩阵乘法的反向传播梯度计算。
假设我们有这样的简化模型流程,需要进行一次反向传播:
L = loss(Yo,y)
我们通过整个模型的输出Yo计算出了loss L,对loss进行梯度下降。
首先我们需要计算在Yo输出层,承担的对loss梯度。即当前节点/层对最终输出承担多少责任。
也就是计算 △ Yo = d L / d Yo。这个计算根据loss函数的性质来,但计算量不大。(或者说正是因为计算量不大,才会被选为loss函数。)
然后,就可以计算出,W2权重矩阵需要承担多少责任。即,计算个d L / d W2 = △ Yo * Y1。这里是第一次矩阵计算,且每一层都需要算一次。
但这一步还没结束。因为模型是多层模型,需要进一步往前推导。即,需要判断一下W1的责任。而这需要走一步的中介,即先判定Y1的责任。
所以这时需要计算 △ Y1 = d L / d Y1 = W2 * △ Yo。这里是第二次矩阵计算。且除了第一层,每一层都需要计算一次。
这两次矩阵计算和原来的计算矩阵大小相等。所以算力需求一致。由于大模型层数都比较多,所以虽然第二个矩阵计算在第一层不用做,但影响不大。
实际上就是一次矩阵计算(Yo = W2 * Y1)会对应两次反向的矩阵计算(d L / d W2 = △ Yo * Y1)和(△ Y1 = d L / d Y1 = W2 * △ Yo),也就是两倍关系。
梯度更新过程
梯度更新过程需要的计算量,会根据优化器的不同而有所差别。例如随机梯度下降,会对所有的参数,计算一次梯度乘学习率,再计算一次结果加到参数权重。也就是每个参数需要2FLOPs。整个大模型一次更新需要2 * 72b FLOPs。这个数看着很大,但对比前向传播的计算量,也就是忽略不计。
如果是Adam这种,带二阶动量,计算公式比较复杂的,计算量需求又会有所不同。
如上图所示,会经过5次公式。每个公式又有多次计算。但总的来说,一个参数更新一次的计算量需求也是常数级别的。对比前向传播的计算量,也就是忽略不计。
数据验证
官方给出的T数据集大小为7T tokens,seq最长32768。假设大集群的算力利用率MFU为50%。代入公式,得:
也就是6k张卡,30天能完成一轮完整训练。
注:训练语料的长度也是在最后阶段才从4096拓展到32768。所以本文预估的算力需求会有一定程度高估,不超过1.6倍。但由于笔者也没找到这个预训练后阶段是什么切分点,所以就按照上限预估了。
而对比llama2时的训练过程(qwen2的模型架构和llama2很相似,可以近似类比)。meta用了1720320卡小时,上下文长度4096,2T数据集(https://llama.meta.com/llama2/)训练一版70B模型。和上面结论基本一致。
来源:阿里云开发者