Transformer-FLOPs推导过程

已于 2022-04-21 09:21:27 修改
阅读量4.3k 收藏 13
点赞数 2
文章标签： transformer 深度学习
于 2021-10-12 21:32:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/unamable/article/details/120731376
版权

1.Encoder

(1)input_embeding

 Input假设是一个维度为vocab的向量，

通过Input_embeding部分变成 vocab*d_model的矩阵：即

（vocab*1）@（1*d_model)=vocab*d_model次乘法。

再乘上d_model ** 0.5 所以 Input_embeding的FLOPs = vocab*d_model*2

(2)Positional Encoding

 采用公式

构建position encoding，即每个位置是5个运算，并最后将position encoding与input_embeding相加，所以每个位置进行6个运算。

所以：position encoding的FLOPs是   vocab * d_model  * 6

（3）sublayer1

 LayerNorm的输入是（vocab*d_model)

首先会对每个词向量算均值：

vocab * （d_model - 1 )次加法 + vocab次乘法 = vocab * d_model次运算

再算方差：(d_model + d_model + d_model - 1 +2) * vocab = vocab * (3d_model + 1)次运算

所以总共有：FLOPs = vocab * （4d_model + 1）次运算。

self_attention:

1.映射

 Q,K,V的维度都是vocab * d_model

W^{Q},W^{K}的维度是 d_model * dk

W^{V}的维度是d_model * dv

论文里面设定的是dk  = dv ，所以统一采用dk

所以映射产生的FLOPs = （2d_model-1)*vocab*3dk

2.过Attention函数

FLOPs = (2dk - 1) * vocab * vocab + vocab*vocab + 2vocab*vocab + vocab * （vocab -1）+（2vocab - 1）*vocab *dv = vocab * vocab *（4dk + 3 ）- vocab - vocab*dk

3.因为有h个头，所以总FLOPs = h * （（（2d_model-1)*vocab*3dk + vocab * vocab *（4dk + 3 ）- vocab - vocab*dk）

4.最后再过一个线性层FLOPs = （2d_model - 1) * vocab * d_model

综上sublayer1的FLOPs = h * （（（2d_model-1)*vocab*3dk + vocab * vocab *（4dk + 3 ）- vocab - vocab*dk）+（2d_model - 1) * vocab * d_model +  vocab * （4d_model + 1）

=4 * vocab *d_model + h * (6*d_model*vocab*d_k - 4*v*d_k + 4*d_k*vocab*vocab + 3*vocab*vocab - vocab) +2 * vocab * d_model *d_model - vocab * d_model + vocab

(4)sublayer2

 相加FLOPs = vocab * d_model

 由前可知：Layernorm的FLOPs = vocab * （4d_model + 1）

feed_forward层根据代码

 可知：

FLOPs = （2d_model-1）* vocab * d_ff + vocab * d_ff + (2 * d_ff -1) * vocab * d_ model

            = vocab * d_model(4d_ff - 1)

所以：sublayer2的FLOPs = vocab * d_model + vocab * （4d_model + 1）+ vocab * d_model(4d_ff - 1)

 综上：EncoderLayer的FLOPs =  vocab*d_model*2 +  vocab * d_model  * 6 + h * （（（2d_model-1)*vocab*3dk + vocab * vocab *（4dk + 3 ）- vocab - vocab*dk）+（2d_model - 1) * vocab * d_model +  vocab * （4d_model + 1）+ vocab * d_model + vocab * （4d_model + 1）+ vocab * d_model(4d_ff - 1)

=16* vocab *d_model + h * (6*d_model*vocab*d_k - 4*v*d_k + 4*d_k*vocab*vocab + 3*vocab*vocab - vocab) +2 * vocab * d_model *d_model - vocab * d_model + 2 * vocab + 4 * vocab * d_model *d_ff

所以Encoder的FLOPs = 6 * (16* vocab *d_model + h * (6*d_model*vocab*d_k - 4*v*d_k + 4*d_k*vocab*vocab + 3*vocab*vocab - vocab) +2 * vocab * d_model *d_model - vocab * d_model + 2 * vocab + 4 * vocab * d_model *d_ff)

(5)LayerNorm

最后还有一层LayerNorm  FLOPs = vocab * （4d_model + 1）

6 * (16* vocab *d_model + h * (6*d_model*vocab*d_k - 4*v*d_k + 4*d_k*vocab*vocab + 3*vocab*vocab - vocab) +2 * vocab * d_model *d_model - vocab * d_model + 2 * vocab + 4 * vocab * d_model *d_ff) + 4 * vocab *d_model +vocab

2.Decoder

decoder部分和encoder部分的FLOPs计算基本一致，直接给出FLOPs计算结果。

tips：Multi_Attention那里有从Encoder处来的memory输入。

（1）

output假设是一个 d_out， 通过embeding变成d_out * d_model的矩阵

Input_embeding的FLOPs = d_out*d_model*2

position encoding的FLOPs是   d_out * d_model  * 6

加法 FLOPs d_out*d_model

总共FLOPs = 9 * d_out*d_model

（2）sublayer1

h * （（（2d_model-1)*d_out*3dk + d_out * d_out *（4dk + 3 ）- d_out - d_out*dk）+（2d_model - 1) * d_out * d_model +  d_out * （4d_model + 1）

（3）sublayer2

加法的FLOPs = d_out * d_model

LayerNorm FLOPs = vocab * （4d_model + 1）

Multihead_Attention

1.映射

 Q的维度是d_out * d_model

K,V的维度都是vocab * d_model

W^{Q},W^{K}的维度是 d_model * dk

W^{V}的维度是d_model * dv

论文里面设定的是dk  = dv ，所以统一采用dk

所以映射产生的FLOPs = （2d_model-1)*vocab*2dk + (2d_model - 1) * d_out * dk

2.过Attention函数

FLOPs =(2dk -1)*d_out * vocab + d_out * vocab +2*d_out*vocab + d_out * (vocab -1 ) +

(2vocab -1) * d_out * dk

3.因为有h个头，所以总FLOPs = h * (（2d_model-1)*vocab*2dk + (2d_model - 1) * d_out * dk + (2dk -1)*d_out * vocab + d_out * vocab +2*d_out*vocab + d_out * (vocab -1 ) +

(2vocab -1) * d_out * dk)

4.最后再过一个线性层FLOPs = （2d_model - 1) * d_out * d_model

所以sublayer2的FLOPs = d_out * d_model + vocab * （4d_model + 1）+ h * (（2d_model-1)*vocab*2dk + (2d_model - 1) * d_out * dk + (2dk -1)*d_out * vocab + d_out * vocab +2*d_out*vocab + d_out * (vocab -1 ) +(2vocab -1) * d_out * dk) + （2d_model - 1) * d_out * d_model

（4）sublayer3

 FLOPs = d_out * d_model + d_out * （4d_model + 1）+ d_out * d_model(4d_ff - 1)

（5）LayerNorm

最后还有一层LayerNorm

d_out * （4d_model + 1）

模型右半部分的最终FLOPs = LayerNorm + 6*Decoder = 

d_out * （4d_model + 1）+ 6 *（d_out * d_model + d_out * （4d_model + 1）+ d_out * d_model(4d_ff - 1) + d_out * d_model + vocab * （4d_model + 1）+ h * (（2d_model-1)*vocab*2dk + (2d_model - 1) * d_out * dk + (2dk -1)*d_out * vocab + d_out * vocab +2*d_out*vocab + d_out * (vocab -1 ) +(2vocab -1) * d_out * dk) + （2d_model - 1) * d_out * d_model + h * （（（2d_model-1)*d_out*3dk + d_out * d_out *（4dk + 3 ）- d_out - vd_out*dk）+（2d_model - 1) * d_out * d_model +  d_out * （4d_model + 1））

=d_out * ( 4 * d_model +1) + 6 * (16 * d_out *d_model + 2 * d_out * d_model * d_model + 4*d_model*d_out*d_ff + 4 * d_model * vocab + vocab +2 * d_model * d_model * d_out + h * (8 * d_model * d_out * d_k - 6 * d_k + 4 * d_k * d_out * d_out + 3 * d_out * d_out - 2 * d_out +4 * d_model * vocab * d_k - 2 * d_k * vocab + 4 * d_k * d_out * vocab + 3 * vocab * d_out))

3.Generator

 线性层 ： d_out * d_model @ d_model * tgt _vocab 结果是一个d_out * tgt_vocab的矩阵

FLOPs = (2d_model -1) * d_out * tgt_vocab

softmax的FLOPs = 2d_out*tgt_vocab + d_out * (tgt_vocab -1)

generatorFLOPs = 2 * tgt_vocab * d_out - d_out + 2 * d_model * tgt_vocab * d_out

4.总结：

论文里所给得参数值：

vocab = 10 # vocab可以调整
d_model=512 
d_ff=2048 
h=8 
d_k=64
d_out = 1
tgt_vocab = 10000
encoder = 4 * vocab *d_model +vocab + 6 * (16* vocab *d_model + h * (6*d_model*vocab*d_k - 4*vocab*d_k + 4*d_k*vocab*vocab + 3*vocab*vocab - vocab) +2 * vocab * d_model *d_model - vocab * d_model + 2 * vocab + 4 * vocab * d_model *d_ff)
decoder = d_out * ( 4 * d_model +1) + 6 * (16 * d_out *d_model + 2 * d_out * d_model * d_model + 4*d_model*d_out*d_ff + 4 * d_model * vocab + vocab +2 * d_model * d_model * d_out + h * (8 * d_model * d_out * d_k - 6 * d_k + 4 * d_k * d_out * d_out + 3 * d_out * d_out - 2 * d_out +4 * d_model * vocab * d_k - 2 * d_k * vocab + 4 * d_k * d_out * vocab + 3 * vocab * d_out))
generator = 2 * tgt_vocab * d_out - d_out + 2 * d_model * tgt_vocab * d_out

result = (encoder + decoder + generator) / 1e9
名称FLOPs(GFLOPs）Latency（ms）
VGG1615.4838620161791.4
resnet181.819066368190.82
resnet343.671263232408.05
resnet504.111514624445.56
resnet15211.5588372481362.19
GoogleNet1.504879712180.35
vit_tiny_patch16_384>49.35 2463.74
vit_tiny_patch16_224>16.85712.19

Triton安
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Transformer 基础系03：手推计算量FLOPS和训练时间
u013250861的博客
11-28 1061
一句话省流太长不看版：浮点计算次数 FLOPS 和参数量、Token 数目关系约为 FLOPS \approx 6 \Phi N_{token} ，开了activation checkpoint 计算一般为 FLOPS = 8 \Phi N_{token} ，训练时间 时间 = \frac{总训练计算量}{总算力} = \frac{K \times tokens \times \Phi}{N_{GPU} \times F_{A100} \times discount}。
Transformer-XL模型代码
06-22
Transformer-XL模型代码
神经网络模型的参数量和FlOPS
qq_52053775的博客
01-10 4081
FLOPS：注意S是大写，是 “每秒所执行的浮点运算次数”（floating-point operations per second）的缩写。它常被用来估算电脑的执行效能，尤其是在使用到大量浮点运算的科学计算领域中。正因为FLOPS字尾的那个S，代表秒，而不是复数，所以不能省略掉。FLOPs：注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。
transformer系列4---transformer结构计算量统计
lansebingxuan的专栏
10-03 937
假设Transformer的输入每个词向量维度d_model(d) ，词表大小为vocab_size(v)，输入句子最大长度为src_max_len(s)，batchsize为 batch(b)，head头数为head(h)。矩阵乘法的输入形状[b, h, s, d] × [b, h, s, d]，输出形状为 [b, h, s, s]，h维度是concat，没有计算量，因此该步骤的计算量为。矩阵乘法输入形状为[b, s, d] × [d, v]，输出形状为[b, s, v]，计算量。
发表博客之：transformer 架构 推理时候运算流程详细讲解，以及变长推理支持，小白都可以看得懂，AI推理工程师必备技能！
最新发布
fgh123的博客
05-04 1214
推理时候，transformer block的运算流程到底是啥样子呢？
（2024，FLOPs 动态分配，MoD，MoDE，top-k 路由，块丢弃）在基于 Transformer 的语言模型中动态分配计算
qq_44681809的博客
04-12 1116
Transformers 可以学习动态地分配计算给序列中的特定位置。该方法通过路由器为不同的 token 计算权重，从而决定哪些 token 要参与块的计算（自注意力和 MLP），哪些 token 要绕过块，以此来限制总计算预算。
FLOPs计算
kking_edc的博客
10-05 1419
一、概念 FLOPS：注意全大写，是floating point operation per second的缩写，意指每秒浮点运算次数，理解为计算速度。是一个衡量硬件性能的指标。 FLOPs：注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度 计算： 参考 ...
Pytorch-Mobile: FLOPs的计算
unamable的博客
10-09 292
一、定义 区分FLOPS和FLOPs： • FLOPS 注意全部大写 是floating point of per second的缩写，意指每秒浮点运算次数。可以理解为计算速度，用来衡量硬件的性能。 • FLOPs 是floating point of operations的缩写，是浮点运算次数，理解为计算量，可以用来衡量算法/模型复杂度。（ps:FLOPs 是模型推理时间的一个参考量，但并不能百分百表示该模型推理时间的长短，因为乘法和加法计算不一样，乘法的时间一般是加法时间的四倍，但现在有很多优化卷
Transformer 在计算机视觉领域疯狂“内卷”
我爱计算机视觉
06-11 3554
继『Transformer 杀疯了，图像去雨、人脸幻构、风格迁移、语义分割等通通上分』之后，Transformer 在计算机视觉领域继续疯狂“内卷”。 01 CAT: ...
Transformer
qqywm的博客
05-11 1829
神经机器翻译 之 谷歌 transformer 模型 96 涛涛江水向坡流 1.7 2018.08.06 19:09* 字数 2471 阅读 14639评论 7喜欢 26 声明：转载请在标题标明转载，并添加原文链接。 简介 这篇博客的主要内容是对谷歌提出的transformer 进行论文解读，包含算法复杂度的分析。对应的论文是 “Attention is all you need", 链接如下 h...
Chinese-Transformer-XL
03-12
模型的结构与GPT-3 2.7B（32层，隐示尺寸2560 ，，每层32个关注头）的基本相同，因为Transformer-XL的结构尺寸，模型参数增加到了29亿。 结果 为了验证模型的生成能力，我们在中文的开放域长文问答上进行的评价。...
ts-transformer-keys:TypeScript自定义转换器，可以获取给定类型的键
03-30
ts-transformer-keys TypeScript自定义转换器，可以获取给定类型的键。 要求 打字稿> = 2.4.1 如何使用此套件 该软件包导出2个函数。 一个是keys ，其在打字稿码用于获得给定类型的键，而另一个是用于编译一个打字...
transformer-xl
05-03
Transformer-XL：超出固定长度上下文的注意力语言模型该存储库包含本文的PyTorch和TensorFlow中的代码戴子行*，杨治林*，杨一鸣，Jaime Carbonell，Quoc V.Le，Ruslan Salakhutdinov（*：平等贡献） 预印本2018...
automapper-transformer-plugin：用于@nartcautomapper的Typescript变压器插件
02-23
AutoMapper变压器插件 该插件支持 ，以通过减少样板代码来增强DX。 怎么运行的 class Profile { bio : string ; age : number ; } class User { firstName : string ;... 我们需要使用@AutoMap()装饰field ...
Transformer模型的基础演算
OneFlow深度学习框架
05-12 6049
Transformer语言模型的许多基本重要信息可以通过简单计算得出。不幸的是，这些计算公式在自然语言处理（NLP）社区中并不广为人知。AI非营利研究组织EleutherAI收集整理这些公式，并介绍这些公式的来源和重要性。注：本文主要关注显...
分析transformer模型的参数量、计算量、中间激活、KV cache、bf16、fp16、混合精度训练
taoqick的专栏
07-30 4983
计算端到端训练的GPU利用率时，不仅要考虑前向传递和后向传递的计算时间，还要考虑CPU加载数据、优化器更新、多卡通信和记录日志的时间。上文讲到一次前向传递中，对于每个token，每个模型参数，进行2次浮点数计算。前向计算过程中产生的中间激活，中间激活值与输入数据的大小（批次大小b和序列长度 l）是成正相关的，随着批次大小b和序列长度l的增大，中间激活占用的显存会同步增大。我们可以近似认为：在一次前向传递中，对于每个token，每个模型参数，需要进行2次浮点数运算，即一次乘法法运算和一次加法运算。
端侧softmax优化
爱CV
12-08 311
当前我们在做端侧的AI处理的时候，很难百分百的将整个网络的推理过程做到一个graph里面。于是我们将AI在端侧的推理过程一般化，可以分成如下三个过程：（1）网络预处理（2）网络主体推理（3）网络后处理。我们取常见的几个AI任务进行分析，第一个我们先看看分类任务。还是套用上述的三个过程：（1）网络预处理：减均值除方差，数据白化等（2）网络主体推理：graph-inference（resnet、mobilenet、shufflenet等等）（3）网络后处理：softmax、sigmoid第二个我们可以看看检测任
一文窥探近期大火的Transformer以及在图像分类领域的应用
热门推荐
果菌药的博客
02-07 2万+
本文首先将简要介绍Transformer的原理与其各个组成部分、Transformer在自然语言处理（NLP）领域的应用；接下来文章从图片分类与目标检测的角度介绍相应Transformer的应用；最后本文将介绍Transformer在应用到CV领域时依然存在的不足以及未来可能的研究方向。
bert模型参数量params与复杂度flops的计算
Chrsitina_S的博客
10-17 1738
params：1.28GMac，99.95M 表示总的计算复杂度为1.28GMac，模型参数量为99.95M，M表示百万量级。（1，15）：模型输入的size，这里的输入必须是一个tensor。flops：能够输出bert网络的结构，包括各层的参数和计算复杂度。model：就是构建的模型。具体的计算过程，可以查看。
Transformer-Unet
01-31
Transformer-Unet是一种结合了Transformer和Unet的神经网络架构，用于图像分割任务。它是基于Transformer的自注意力机制和Unet的编码-解码结构进行了改进和融合。 在传统的Unet中，编码器部分通过卷积层逐渐提取图像的特征，并将特征信息传递给解码器部分进行分割。而Transformer-Unet则引入了Transformer的自注意力机制，用于替代Unet中的卷积操作。自注意力机制能够捕捉全局上下文信息，有助于更好地理解图像中的语义信息。 具体来说，Transformer-Unet的编码器部分由多个Transformer编码器堆叠而成，每个编码器包含多头自注意力机制和前馈神经网络。这样可以在不同层次上提取图像的特征，并保留全局上下文信息。 解码器部分则类似于传统的Unet，通过上采样和卷积操作将编码器部分提取到的特征进行逐步恢复和重建，最终得到分割结果。 Transformer-Unet的优点在于能够同时利用Transformer和Unet的优势，既能够捕捉全局上下文信息，又能够保留细节特征。这使得它在图像分割任务中具有较好的性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值