一文揭秘｜预训练一个72b模型需要多久？
阿里妹导读
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。
大模型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: Longformerand "Generating Long Sequences with Sparse Transformers"."""def __init__(self, config: Qwen2Config, layer_idx: Optional[int] = None):super().__init__()self.config = configself.layer_idx = layer_idxif 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_sizeself.num_heads = config.num_attention_headsself.head_dim = self.hidden_size // self.num_headsself.num_key_value_heads = config.num_key_value_headsself.num_key_value_groups = self.num_heads // self.num_key_value_headsself.max_position_embeddings = config.max_position_embeddingsself.rope_theta = config.rope_thetaself.is_causal = Trueself.attention_dropout = config.attention_dropoutif (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 modelskey_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_headskey_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 itcausal_mask = attention_mask[:, :, :, : key_states.shape[-2]]attn_weights = attn_weights + causal_mask# upcast attention to fp32attn_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)if not output_attentions:attn_weights = Nonereturn 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->Qwen2class Qwen2MLP(nn.Module):def __init__(self, config):super().__init__()self.hidden_size = config.hidden_sizeself.intermediate_size = config.intermediate_sizeself.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->Qwen2class 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 = epsdef forward(self, hidden_states):input_dtype = hidden_states.dtypehidden_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模型。和上面结论基本一致。
参考链接：
4.https://www.databricks.com/blog/llm-inference-performance-engineering-best-practices
移动开发秘籍：云上高效构建App
本方案使用阿里云多端低代码开发平台魔笔低代码快速搭建适配于微信、支付宝等多平台的小程序，帮助您提升开发效率、降低维护成本。
点击阅读原文查看详情。
微信扫码关注该文公众号作者