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)        if not 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->Qwen2class 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->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 = 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模型。和上面结论基本一致。



参考链接：

4.https://www.databricks.com/blog/llm-inference-performance-engineering-best-practices