比特派app钱包下载地址|flops

作者: 比特派app钱包下载地址
2024-03-07 18:44:54

CNN 模型所需的计算力flops是什么？怎么计算？ - 知乎

CNN 模型所需的计算力flops是什么？怎么计算？ - 知乎首发于统计与机器学习@量化切换模式写文章登录/注册CNN 模型所需的计算力flops是什么？怎么计算？阿柴本柴写在前面的话最近看到一些文章中有关于模型的计算力消耗问题，也就是flops。论文中通常会比较在差不多的flops上两个模型的差距。比如说DenseNet 中就放出了一张在flops差不多的情况下，其与Resnet的对比图来说明DenseNet所需计算力小而正确率高的优势。那么，flops到底是什么？怎么体现模型所需的计算力消耗的？又是怎么计算的呢？本篇文章总结了以上三个问题，同时给出了计算flops的开源库。一、什么是flops对flops有疑惑，首先得先捋清这个概念：FLOPS：注意全大写，是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度。是一个衡量硬件性能的指标。FLOPs：注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。网上打字很容易全小写，造成混淆，本问题针对模型，应指的是FLOPs。我们知道，通常我们去评价一个模型时，首先看的应该是它的精确度，当你精确度不行的时候，你和别人说我的模型预测的多么多么的快，部署的时候占的内存多么多么的小，都是白搭。但当你模型达到一定的精确度之后，就需要更进一步的评价指标来评价你模型：1）前向传播时所需的计算力，它反应了对硬件如GPU性能要求的高低；2）参数个数，它反应所占内存大小。为什么要加上这两个指标呢？因为这事关你模型算法的落地。比如你要在手机和汽车上部署深度学习模型，对模型大小和计算力就有严格要求。模型参数想必大家都知道是什么怎么算了，而前向传播时所需的计算力可能还会带有一点点疑问。所以这里总计一下前向传播时所需的计算力。它正是由FLOPs体现，那么FLOPs该怎么计算呢？二、如何计算flops我们知道，在一个模型进行前向传播的时候，会进行卷积、池化、BatchNorm、Relu、Upsample等操作。这些操作的进行都会有其对应的计算力消耗产生，其中，卷积所对应的计算力消耗是所占比重最高的。所以，我们这里主要讲一下卷积操作所对应的计算力。我们以下图为例进行讲解：作者：冷月@知乎先说结论：卷积层计算力消耗等于上图中两个立方体 (绿色和橙色) 体积的乘积。即flops = 推导过程：卷积层 wx + b 需要计算两部分，首先考虑前半部分 wx 的计算量：令 :k 表示卷积核大小;c 表示输入 feature map 的数量;则对于输出 feature map 上的单个 Unit 有：k * k * c 次乘法，以及 k * k * c - 1 次加法用上图形象化解释就是：Image大小为 5x5，卷积核大小为 3x3，那么一次3x3的卷积（求右图矩阵一个元素的值）所需运算量：(3x3)个乘法+(3x3-1)个加法 = 17。要得到右图convolved feature （3x3的大小）：17x9 = 153如果输出 feature map 的分辨率是 H * W ，且输出 o 个 feature map，则输出 feature map 包含 Unit的总数就是 H * W * o。因此，该卷积层在计算 wx 时有:k * k * c * H * W * o 次乘法 --（1）

(k * k * c - 1) * H * W * o 次加法 --（2）再考虑偏置项 b 包含的计算量：由于 b 只存在加法运算，输出 feature map 上的每个 Unit 做一次偏置项加法。因此，该卷积层在计算偏置项时总共包含：H * W * o 次加法 --（3）将该卷积层的 wx 和 b 两部分的计算次数累计起来就有：式(1) 次乘法:k * k * c * H * W * o 次乘法式(2) + 式(3) 次加法:(k * k * c - 1) * H * W * o + H * W * o = k * k * c * H * W * o可见，式(2) + 式(3) = 式 (1)对于带偏置项的卷积层，乘法运算和加法运算的次数相等，刚好配对。定义一次加法和乘法表示一个flop，该层的计算力消耗为：k * k * c * H * W * o 刚好等于图中两个立方体（绿色和橙色）体积的乘积。全连接层的算法也是一样。三、计算flops的开源库作者：留德华叫兽@知乎示例代码如下，它求出了VGG16的flops和参数量：可以看到，算上import 和 print（）也仅仅6行代码！不仅输出了整个框架的复杂度，还能输出每一层的复杂度以及该层占整个网络的比重最后贴出常见backbone的flops：相关阅读：【1】【2】【3】欢迎关注公众号，阅读更多深度学习、计算机视觉、图像分割领域论文笔记：发布于 2020-05-01 23:27深度学习（Deep Learning）卷积神经网络（CNN）神经网络赞同 41061 条评论分享喜欢收藏申请转载文章被以下专栏收录统计与机器学习@量化NLP迷路CV仅供个人学习，

训练模型算力的单位：FLOPs、FLOPS、Macs 与估算模型（FC, CNN, LSTM, Transformers&&LLM）的FLOPs - 知乎

训练模型算力的单位：FLOPs、FLOPS、Macs 与估算模型（FC, CNN, LSTM, Transformers&&LLM）的FLOPs - 知乎首发于简单的算法笔记切换模式写文章登录/注册训练模型算力的单位：FLOPs、FLOPS、Macs 与估算模型（FC, CNN, LSTM, Transformers&&LLM）的FLOPsMrYXJ算法(NLP)学习者，欢迎交流～FLOPs、FLOP、MACs的定义FLOPSFLOPS（Floating Point Operations per Second）指每秒浮点运算次数，可以理解为评估计算速度的单位。主要作为用来描述硬件性能的指标，比如评估某型号GPU的计算算力，即能够产生多少算力速度给模型。同时也可以作为描述深度学习模型在GPU上实际运行时速度的单位，即模型在GPU提供多少算力速度下进行训练、推理的任务。如下图，将英伟达A100与H100以及利用NVLink技术将两块H100互连的GPU在进行不同精度运算时算力的对比，使用的算力单位都是TFLPOS(每秒1万亿次运算)：英伟达A100与H100以及利用NVLink技术将两块H100互连的GPU在不同精度下FLOPS的对比FLOPS通常的基本单位还有：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）次的浮点运算。

FLOPsFLOPs（Floating Point Operations）指浮点运算次数，可以理解为描述总计算量的单位。从拼写上容易与FLOPS弄混、注意最后字母是小写s。FLOPs可以用来衡量一个模型/算法的总体复杂度（即所需要计算量），在论文中比较流行的单位是GFLOPs：1 GFLOPs=10^9 FLOPs。比如我们要估算一个卷积神经网络总复杂度时使用的单位就是FLOPs，具体推导方法可见本文章节【深度学习模型、LLM的FLOPs推导】。另外在工业界模型实际部署中，常常使用QPS (queries per second，即每秒处理的个数）作为指标来评估模型每秒能够处理的速度，即QPS可以用来描述一个模型或者服务在GPU尽可能打满的情况下每秒能处理查询的个数，通常作为线上服务或者机器的性能指标。MACsMACs (Multiply ACcumulate operations)指乘加累积操作次数，有时也用MAdds（Multiply-Add operations）表示，是微处理器中的特殊运算。MACs也可以为是描述总计算量的单位，但常常被人们与FLOPs概念混淆(Python第三方包Torchstat、Thop等），实际上一个MACs包含一个乘法操作与一个加法操作，因此1个MACs约等价于2个FLOPs，即 1 MACs = 2 FLOPs ，1GMACs = 10^9 MACs。FLOPs的作用是？当我们训练一个模型时（比如LLM)，通常通过计算它的FLOPs与使用的GPU的FLOPS，大致估算训练时间。那么如何得到一个模型的FLOPs呢？通常可以通过其网络结构估算或者使用第三方包去获取，这里先介绍如何手动估算一个模型FLOPs。深度学习模型、LLM的FLOPs推导与估算：以下推导中主要统计权重矩阵相乘累加的操作需要进行浮点运算，对于激活函数等计算量较小操作是忽略不计（理论上激活层不算进MACC但应该被算进FLOPs)。其中以下FC Layer、CNN Layer LSTM Layer的推导是模拟模型进行单样本的前向推理（Forward）的计算量，公式中不带有Batch_size，Transfomer&&LLM的FLOPs推导中带有Batch_size并考虑了反向传播的计算量。FC Layer一个全连接层的神经网络计算的过程可以看成是两个矩阵进行相乘的操作，忽略掉激活函数（activation）部分的计算，假设输入矩阵是A、矩阵大小是H\times I，全连接层的参数矩阵是B、矩阵大小是I\times W，全连接层矩阵计算过程实际就是：Y =AB结果矩阵Y中的每个元素都是经过 I 次乘法和I-1次加法，因此FC层的FLOPs公式就是：H \times W \times (I + (I -1)) = H \times W \times (2I -1)如果忽略这个常数项或者考虑加入bias，即Y中每一个元素需要额外进行一次加法，则可以将公式中-1去掉：H \times W \times 2I。矩阵乘法中计算量FLOPs与参数量Parameter观察上面FC layer中最终计算量FLOPs公式的结果，同时该层参数量Paramster是I \times W , 输入值大小Input_size是H ，因此看出在矩阵乘法中有:FLOPs = Input\_size \times Parameter \times 2 = 2 \times H \times I \times W。CNN Layer一个卷积神经网络（CNN）进行的计算主要来自卷积层，忽略掉激活函数（activation）部分计算，分析每一层卷积输出结果矩阵中每个值都经过对卷积核的每个元素都进行一次“乘加累积”（MACs）运算操作（等价2倍FLOPs）。因此假设这一层输出的结果矩阵维度是 H \times W、输出通道数（卷积核的个数）是Out\_Chanel，卷积层的卷积核的大小（kernel size）是K，输入卷积层前通道数是In\_Chanle, 则CNN每一层的计算量（FLOPs）有如下公式：H \times W \times Out\_Chanel \times (2 \times K^{2} \times In\_Chanel - 1)为什么括号里是(2 \times K^{2} \times In\_Chanel - 1) 有一个 -1, 是因为仔细分析这里每个卷积核的实际上进行了K^2次乘法，K^2-1次加法操作（n个数相加，进行n-1次加法）。如果忽略这个常数项或者考虑加入bias，则-1去掉后的公式为：H \times W \times Out\_Chanel \times 2 \times K^{2} \times In\_ChanelLSTM Layer对于一个循环神经网络层（LSTM\RNN\GRU），忽略掉激活层等操作只关注矩阵之间计算量，分析一下每层LSTM的计算量（FLOPs），假设词向量的维度（embedding dimension）是E，隐藏层的维度是H（hidden state dimension）、即LSTM层有多少个cell，则计算LSTM层的FLOPs有以下公式：(E+H) \times H \times 4 \times 2公式中的4是指LSTM层的4个非线性变换（3个门+1个tanh）。LLM && TransformersTransformers结构语言模型（LLM）都是以Transformers模型架构为基础，transformer结构（如下图）相比MLP、CNN、LSTM复杂得多。同时推导公式依旧只考虑每层中矩阵乘加法的运算量，对于其他部分（layernorm, activation ）的计算忽略不计，我们首先先简单回顾一下Transformer结构，如下图：Transformers ArchitectureTransformer模型中Encoder和Decoder部分都是由每一层的attention layer组成, 例如标准的transformer的Encoder和Decoder默认都是由6层attention layer。上个时代大名鼎鼎的Bert就是只用了Encoder的部分的12层attention layer构成。进入LLM时代的以GPT系列的模型则以只用了Decoder部分的attention layer。这两部分的attention layer的差别就是Decoder模块里是Mask Multi-Head Attention，mask的作用是将当前输入字符的后面内容统一赋值为0，在实际计算中通过对mask矩阵赋值0、1来实现遮蔽的作用。具体的每一层的attention layer 中的计算全部来自于多头注意力（Multi-Head Attention）和前向传播（Feed Forawrd）中矩阵相乘的操作，其中Multi-Head Attention 操作就是将输入值根据multi-head个数切分成均等大小维度的输入，每个head的输入单独分别乘上三个权重矩阵 V，K, Q。然后再将输入乘以V，K， Q的三个矩阵进行Dot-Product Attention操作，最后将多头的多个输出拼接起来(Concat) 再乘以一个原始维度的矩阵进行一个线性变化（Linear)。Multi-head Attention的整个过程如下图所示：Multi-Head Attention Architecture前向传播层就是一个两层全连接的MLP模块，这里操作是将经过Attention之后维度最后一位为 h 的向量，先经过一层维度是 (h,4h) 的线性变换层将向量最后一位的维度扩大4倍，然后再过一个 (4h, h) 大小线性变换层进行映射将维度大小还原回 h 。Transformer Paramter 分析：正如上面Transformers结构的简单分析，对于每一层attention layer中，参数量来自于 Multi-head Attention模块和 MLP模块。Multi-head Attention模块的模型参数有 Q、K、V的权重矩阵 W_Q、W_K、W_V和最后线性变换的矩阵 W_O以及偏置，4个权重矩阵的形状为 [h,h]，4个偏置的形状为 [h]。因此Multi-head Attention的参数量是： 4h^2+4h。MLP模块中两层线性变换层，第一层权重矩阵形状是[h,4h] ，偏置的形状为 [4h]。第二个线性层权重矩阵的形状为 [4h,h] ，偏置形状为 [h]。因此MLP模块的参数量是： 8h^2+5h。如果考虑Multi-head attention块和MLP块各有一个layer normalization，其包含了2个可训练模型参数：缩放参数 \gamma和平移参数 \beta，形状都是 [h]。这里2个layer normalization的参数量为 4h。因此Transformer每一层attention layer的总参数就是：12h^2+13h另外Transformers模型的词嵌入矩阵的参数量是 Vh，因此当模型的层数是 l 时，Transformers模型的总参数是：l(12h^2+13h)+Vh。在LLM 时代，模型的隐藏层的维度 h 通常较大时可以忽略掉较小的项，即模型参数量近似为12lh^2。（例如llama系列模型的隐藏层维度从7B的4096到70B的8192，相比Bert的768增大不少。）Transformer && LLM FLOPs的估算：Parameter与FLOPs的关系从上面Transformer结构的分析中看出其计算过程中计算量的大头基本来自矩阵相乘的形式。同时参考本文FC Layer 计算矩阵乘法在前向推理的FLOPs：FLOPs = Input_size x Parameter x 2根据反向传播的计算量是前向传播的2倍的结论（来自What’s the backward-forward FLOP ratio for Neural Networks?"）假设模型整个训练过程语料Token数是 T ，可以估算Transfomer的FLOPs 约等于： 6 \times T \times P 。Transfromer && LLM FLOPs 计算公式：这里我直接给出LLM FLOPs的计算公式，公式中字母的含义如下： T是LLM模型的语料的总Token数，P 是模型的参数数量，B 是训练时batch size，Step是训练迭代的次数，V是模型总词表数，s是训练时序列的长度，l是模型中间隐藏层的大小，LLM FLOPs的计算公式如下：\begin{aligned} LLM \quad FLOPs &= (72Bslh^{2}+12Bs^{2}lh+6BshV) \times Step \\ &= 72Bslh^{2}(1+\frac{s}{6h}+\frac{V}{12lh}) \times Step \\ &\gtrsim 72Bslh^{2} \times Step \\ &= 6 Bs \times 12lh^{2} \times Step \\ &\gtrsim 6Bs\times P \times Step\\ &= 6\times BsStep \times P\\ &= 6 \times T \times P \\ \end{aligned}简单解释一下，这里公式第2行到第3行的变化，公式第1行和第2行都有三项，分别来自：第一项来自attention layer中的QKV和FFN中的矩阵乘法，是整个模型权重矩阵的计算量的大头。第二项来自attention 矩阵的计算，当s << 6h 时可以忽略，这里第2行到第3行选择去掉。第三项来自 LM head，当V << 12lh 时可以忽略，这里第2行到第3行选择去掉。以LLaMa-13B举个例子，6 \times h = 6 * 5120 = 30720，通常序列长度 s 为1k左右，30720 >> 1000。同时12lh = 12 * 50 * 5120 = 3072000 >> 32000 。因此公式第2行到第3行选择去掉后两项的计算量。在公式第4行，如上面所分析Transformers&&LLM模型的参数量（不考虑词表、layer normalize的参数）， 12lh^2 带入到公式中。在公式第5行Batch\_size \times seq\_len \times Step\_num 就是整个训练语料的Token的数量T进行替换带入。最终，忽略掉计算量小的项目，Transforemers&&LLM 的 FLOPs = 6TP，与上面估算结论一致。完整的推导过程在文章语言模型的训练时间：从估算到 FLOPs 推导 - Ethan Yan的文章 - 知乎中非常的详细完备。文章中有估算和精算两种推导，其区别就是估算只考虑LLM前向过程中权重矩阵的计算，而精算则考虑FFN层以及最后词表V的计算过程。同时该篇文章在推导过程中引用What’s the backward-forward FLOP ratio for Neural Networks?的结论: 模型反向传播的FLOPs的计算量是前向的两倍。总之，如果感兴趣公式中每一项的推导过程可以看这篇文章，推导过程很顺畅，这里就不再次重复撰写。本文参考VASWANI A, SHAZEER N, PARMAR N, et al. Attention is All you Need[J]. Neural Information Processing Systems,Neural Information Processing Systems, 2017.https://arxiv.org/pdf/1706.03762.pdfThe Illustrated Transformer - Jay Alammar bloghttp://jalammar.github.io/illustrated-transformer/Marius Hobbhahn and Jaime Sevilla (2021), "What’s the backward-forward FLOP ratio for Neural Networks?". Published online at epochai.org. Retrieved from: 'https://epochai.org/blog/backward-forward-FLOP-ratio'揭秘A100、A800、H800、V100在高性能计算与大模型训练中的霸主地位 - 高性能服务器的文章 - 知乎https://zhuanlan.zhihu.com/p/640432767CNN 模型所需的计算力（flops）和参数（parameters）数量是怎么计算的？ - 泓宇的回答 - 知乎https://www.zhihu.com/question/65305385/answer/451060549Transformer-based模型到底要训练多久 - OWNT的文章 - 知乎https://zhuanlan.zhihu.com/p/456046786语言模型的训练时间：从估算到 FLOPs 推导 - Ethan Yan的文章 - 知乎https://zhuanlan.zhihu.com/p/646905171深度学习模型参数量/计算量和推理速度计算 - 龟壳的文章 - 知乎https://zhuanlan.zhihu.com/p/376925457分析transformer模型的参数量、计算量、中间激活、KV cache - 回旋托马斯x的文章 - 知乎 https://zhuanlan.zhihu.com/p/624740065LLM训练指南(二):模型参数、计算量、显存、计算时间计算 - JMXGODLZ的文章 - 知乎 https://zhuanlan.zhihu.com/p/639872915本文使用 Zhihu On VSCode 创作并发布编辑于 2023-09-13 10:37・IP 属地中国香港TransformersGPULLM赞同 846 条评论分享喜欢收藏申请转载文章被以下专栏收录简单的算法笔记最简单方式记录与分享学习、技术笔记。AIWalker欢迎关注公众号AIWalker，速推最新

模型计算力（flops）和参数（parameters） - 知乎

模型计算力（flops）和参数（parameters） - 知乎首发于自动驾驶的挑战和发展切换模式写文章登录/注册模型计算力（flops）和参数（parameters）吱吱勤恳码农提纲：Ø 参数量Ø FLOPS\FLOPs\GFLOPsØ 浮点运算和参数量的区别Ø 不能绝对的用FLOPs作为速度衡量的原因——MAC\并行度\平台参数量：CNN:一个卷积核的参数 = k*k*Cin+1 一个卷积层的参数 = (一个卷积核的参数)*卷积核数目=k*k*Cin*Cout+CoutFLOPS:注意全大写，是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度。是一个衡量硬件性能的指标。FLOPs: 注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。但是关于FLOPs的公式花样百出，不过大致形式都差不多，没有找到特别统一的说法。CNN的FLOPs：(1) 知乎：Ci、Co表示输入和输出通道，K卷积核大小，HW是输出的feature map大小。其中括号中的式子这样理解：左边是乘法运算量，右边是加法运算量,因为n个数字要加n-1次，所以有个-1.这里忽略了bais如果算上bais需要把-1去掉。(2) nvida论文：论文里应该是把n个累加直接当成加n次，还算上了个bais(3)torchstat库简单用代码实验了下，如下图：Flops：44,158,464 = 222*222*(3*3*3+1)*32params：896 = 3*3*3*32推算了下它的公式FLOPs = H*W*(K*K*Cin+1)*Cout （又是不一样的！）FullyConnect的FLOPs：I输入神经元数目，O输出神经元个数。同理，考虑bais没有-1GFLOPs：这其实是一个单位，1GLOPs=10亿次浮点运算。是Paper里比较流行的单位。浮点运算量和参数量的区别：浮点运算量是实际运算过程中的加减乘除计算过程中的计算次数，描述计算力；参数量只是指的模型大小，和输入的图片大小无关，描述需要内存不能只用FLOPs作为网络速度的指标。FLOPs没有考虑几个对速度有相当大影响的重要因素——MAC\并行度\平台1.MAC(Memory Access Cost)比如：MAC(内存访问成本)，计算机在进行计算时候要加载到缓存中，然后再计算，这个加载过程是需要时间的。其中，分组卷积（group convolution）是对MAC消耗比较多的操作（例如AlexNet多GPU）。k*k普通卷积（不算bais）的FLOPs和MAC：FLOPs = 2*h2*w2*k*k*c1*c2 MAC=输入+输出+权重参数=h1*w1*c1+h2*w2*c2+c1*c2*k*k普通卷积和分组卷积的参数量：1*1卷积普通卷积：结论：FLOPs一定时，当且仅当c1=c2，MAC越小。1*1分组卷积：结论：B不变，g越大MAC越大2.并行度第二个对速度有相当大影响的重要因素就是模型的并行度。在相同的FLOPs下，具有高并行度的模型可能比具有低并行度的另一个模型快得多。如果网络的并行度较高，那么速度就会有显著的提升。3.计算平台的不同不同的运行平台，得到的FLOPs也不相同。有的平台会对操作进行优化，比如：cudnn加强了对3×3conv计算的优化。这样一来，不同平台的FLOPs大小确实没有什么说服力。Ref:https://arxiv.org/abs/1611.06440v2https://www.zhihu.com/question/65305385/answer/451060549分享一个FLOPs计算神器——https://www.jianshu.com/p/b1ceaa7effa8https://zhuanlan.zhihu.com/p/67009992https://www.e-learn.cn/topic/3471595https://github.com/Captain1986/CaptainBlackboard/blob/master/D%230023-CNN模型计算量估计/D%230023.mdhttps://blog.csdn.net/weixin_39833897/article/details/105807172C编辑于 2020-06-15 16:46GPU 通用计算深度学习（Deep Learning）浮点运算赞同 15312 条评论分享喜欢收藏申请转载文章被以下专栏收录自动驾驶的挑战和发展自动驾驶相关技术的非公式

深度学习中的FLOPs介绍及计算(注意区分FLOPS)-CSDN博客

深度学习中的FLOPs介绍及计算(注意区分FLOPS)

最新推荐文章于 2024-03-04 18:31:41 发布

__Jupiter__

最新推荐文章于 2024-03-04 18:31:41 发布

阅读量2.3w

171

点赞数

分类专栏：

深度学习基础

文章标签：

深度学习

pytorch

神经网络

本文链接：https://blog.csdn.net/qq_41834400/article/details/120283103

版权

深度学习基础

专栏收录该内容

1 篇文章

2 订阅

订阅专栏

FLOPS与FLOPs

FLOPS：注意全大写，是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度。是一个衡量硬件性能的指标。

FLOPs：注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。

全连接网络中FLOPs的计算

推导

以4个输入神经元和3个输出神经元为例计算一个输出神经元的的计算过程为

∗

y1 = w_{11}*x_1+w_{21}*x_2+w_{31}*x_3+w_{41}*x_4

y1=w11∗x1+w21∗x2+w31∗x3+w41∗x4 所需的计算次数为

4次乘法3次加法

共需4+3=7计算。推广到I个输入神经元O个输出神经元后则计算一个输出神经元所需要的计算次数为

(

−

)

−

I+(I-1)=2I-1

I+(I−1)=2I−1，则总的计算次数为

(

−

)

∗

FLOPs = (2I-1)*O

FLOPs=(2I−1)∗O 考虑bias则为

∗

y1 = w_{11}*x_1+w_{21}*x_2+w_{31}*x_3+w_{41}*x_4+b1

y1=w11∗x1+w21∗x2+w31∗x3+w41∗x4+b1 总的计算次数为

∗

FLOPs = 2I*O

FLOPs=2I∗O

结果

FC（full connected）层FLOPs的计算公式如下(不考虑bias时有-1，有bias时没有-1):

(

−

)

FLOPs = (2 \times I - 1) \times O

FLOPs=(2×I−1)×O 其中:

I = input neuron numbers(输入神经元的数量) O = output neuron numbers(输出神经元的数量)

CNN中FLOPs的计算

以下答案不考虑activation function的运算

推导

对于输入通道数为

C_{in}

Cin,卷积核的大小为K,输出通道数为

C_{out}

Cout,输出特征图的尺寸为

∗

H*W

H∗W

进行一次卷积运算的计算次数为

乘法

C_{in}K^2

CinK2次加法

−

C_{in}K^2-1

CinK2−1次共计

−

C_{in}K^2+C_{in}K^2-1=2C_{in}K^2-1

CinK2+CinK2−1=2CinK2−1次，若考虑bias则再加1次得到一个channel的特征图所需的卷积次数为

∗

H*W

H∗W次共计需得到

C_{out}

Cout个特征图

因此对于CNN中的一个卷积层来说总的计算次数为(不考虑bias时有-1，考虑bias时没有-1):

(

−

)

FLOPs = (2C_{in}K^2-1)HWC_{out}

FLOPs=(2CinK2−1)HWCout

结果

卷积层FLOPs的计算公式如下(不考虑bias时有-1，有bias时没有-1):

(

−

)

FLOPs = (2C_{in}K^2-1)HWC_{out}

FLOPs=(2CinK2−1)HWCout 其中:

C_{in}

Cin = input channelK= kernel sizeH,W = output feature map size

C_{out}

Cout = output channel

计算FLOPs的代码或包

torchstat

from torchstat import stat

import torchvision.models as models

model = models.vgg16()

stat(model, (3, 224, 224))

module name input shape output shape params memory(MB) MAdd Flops MemRead(B) MemWrite(B) duration[%] MemR+W(B)

0 features.0 3 224 224 64 224 224 1792.0 12.25 173,408,256.0 89,915,392.0 609280.0 12845056.0 3.67% 13454336.0

1 features.1 64 224 224 64 224 224 0.0 12.25 3,211,264.0 3,211,264.0 12845056.0 12845056.0 1.83% 25690112.0

2 features.2 64 224 224 64 224 224 36928.0 12.25 3,699,376,128.0 1,852,899,328.0 12992768.0 12845056.0 8.43% 25837824.0

3 features.3 64 224 224 64 224 224 0.0 12.25 3,211,264.0 3,211,264.0 12845056.0 12845056.0 1.45% 25690112.0

4 features.4 64 224 224 64 112 112 0.0 3.06 2,408,448.0 3,211,264.0 12845056.0 3211264.0 11.37% 16056320.0

5 features.5 64 112 112 128 112 112 73856.0 6.12 1,849,688,064.0 926,449,664.0 3506688.0 6422528.0 4.03% 9929216.0

6 features.6 128 112 112 128 112 112 0.0 6.12 1,605,632.0 1,605,632.0 6422528.0 6422528.0 0.73% 12845056.0

7 features.7 128 112 112 128 112 112 147584.0 6.12 3,699,376,128.0 1,851,293,696.0 7012864.0 6422528.0 5.86% 13435392.0

8 features.8 128 112 112 128 112 112 0.0 6.12 1,605,632.0 1,605,632.0 6422528.0 6422528.0 0.37% 12845056.0

9 features.9 128 112 112 128 56 56 0.0 1.53 1,204,224.0 1,605,632.0 6422528.0 1605632.0 7.32% 8028160.0

10 features.10 128 56 56 256 56 56 295168.0 3.06 1,849,688,064.0 925,646,848.0 2786304.0 3211264.0 3.30% 5997568.0

11 features.11 256 56 56 256 56 56 0.0 3.06 802,816.0 802,816.0 3211264.0 3211264.0 0.00% 6422528.0

12 features.12 256 56 56 256 56 56 590080.0 3.06 3,699,376,128.0 1,850,490,880.0 5571584.0 3211264.0 5.13% 8782848.0

13 features.13 256 56 56 256 56 56 0.0 3.06 802,816.0 802,816.0 3211264.0 3211264.0 0.37% 6422528.0

14 features.14 256 56 56 256 56 56 590080.0 3.06 3,699,376,128.0 1,850,490,880.0 5571584.0 3211264.0 4.76% 8782848.0

15 features.15 256 56 56 256 56 56 0.0 3.06 802,816.0 802,816.0 3211264.0 3211264.0 0.37% 6422528.0

16 features.16 256 56 56 256 28 28 0.0 0.77 602,112.0 802,816.0 3211264.0 802816.0 2.56% 4014080.0

17 features.17 256 28 28 512 28 28 1180160.0 1.53 1,849,688,064.0 925,245,440.0 5523456.0 1605632.0 3.66% 7129088.0

18 features.18 512 28 28 512 28 28 0.0 1.53 401,408.0 401,408.0 1605632.0 1605632.0 0.00% 3211264.0

19 features.19 512 28 28 512 28 28 2359808.0 1.53 3,699,376,128.0 1,850,089,472.0 11044864.0 1605632.0 5.50% 12650496.0

20 features.20 512 28 28 512 28 28 0.0 1.53 401,408.0 401,408.0 1605632.0 1605632.0 0.00% 3211264.0

21 features.21 512 28 28 512 28 28 2359808.0 1.53 3,699,376,128.0 1,850,089,472.0 11044864.0 1605632.0 5.49% 12650496.0

22 features.22 512 28 28 512 28 28 0.0 1.53 401,408.0 401,408.0 1605632.0 1605632.0 0.00% 3211264.0

23 features.23 512 28 28 512 14 14 0.0 0.38 301,056.0 401,408.0 1605632.0 401408.0 1.10% 2007040.0

24 features.24 512 14 14 512 14 14 2359808.0 0.38 924,844,032.0 462,522,368.0 9840640.0 401408.0 2.94% 10242048.0

25 features.25 512 14 14 512 14 14 0.0 0.38 100,352.0 100,352.0 401408.0 401408.0 0.00% 802816.0

26 features.26 512 14 14 512 14 14 2359808.0 0.38 924,844,032.0 462,522,368.0 9840640.0 401408.0 2.57% 10242048.0

27 features.27 512 14 14 512 14 14 0.0 0.38 100,352.0 100,352.0 401408.0 401408.0 0.00% 802816.0

28 features.28 512 14 14 512 14 14 2359808.0 0.38 924,844,032.0 462,522,368.0 9840640.0 401408.0 2.19% 10242048.0

29 features.29 512 14 14 512 14 14 0.0 0.38 100,352.0 100,352.0 401408.0 401408.0 0.37% 802816.0

30 features.30 512 14 14 512 7 7 0.0 0.10 75,264.0 100,352.0 401408.0 100352.0 0.37% 501760.0

31 avgpool 512 7 7 512 7 7 0.0 0.10 0.0 0.0 0.0 0.0 0.00% 0.0

32 classifier.0 25088 4096 102764544.0 0.02 205,516,800.0 102,760,448.0 411158528.0 16384.0 10.62% 411174912.0

33 classifier.1 4096 4096 0.0 0.02 4,096.0 4,096.0 16384.0 16384.0 0.00% 32768.0

34 classifier.2 4096 4096 0.0 0.02 0.0 0.0 0.0 0.0 0.37% 0.0

35 classifier.3 4096 4096 16781312.0 0.02 33,550,336.0 16,777,216.0 67141632.0 16384.0 2.20% 67158016.0

36 classifier.4 4096 4096 0.0 0.02 4,096.0 4,096.0 16384.0 16384.0 0.00% 32768.0

37 classifier.5 4096 4096 0.0 0.02 0.0 0.0 0.0 0.0 0.37% 0.0

38 classifier.6 4096 1000 4097000.0 0.00 8,191,000.0 4,096,000.0 16404384.0 4000.0 0.73% 16408384.0

total 138357544.0 109.39 30,958,666,264.0 15,503,489,024.0 16404384.0 4000.0 100.00% 783170624.0

============================================================================================================================================================

Total params: 138,357,544

------------------------------------------------------------------------------------------------------------------------------------------------------------

Total memory: 109.39MB

Total MAdd: 30.96GMAdd

Total Flops: 15.5GFlops

Total MemR+W: 746.89MB

参考资料

CNN 模型所需的计算力（flops）和参数（parameters）数量是怎么计算的？分享一个FLOPs计算神器 CNN Explainer Molchanov P , Tyree S , Karras T , et al. Pruning Convolutional Neural Networks for Resource Efficient Transfer Learning[J]. 2016.

优惠劵

__Jupiter__

关注

踩

171

觉得还不错?

一键收藏

知道了

深度学习中的FLOPs介绍及计算(注意区分FLOPS)

FLOPS与FLOPsFLOPS：注意全大写，是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度。是一个衡量硬件性能的指标。FLOPs：注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。全连接网络中FLOPs的计算推导以4个输入神经元和3个输出神经元为例计算一个输出神经元的的计算过程为y1=w11∗x1+w21∗x2+w31∗x3

复制链接

扫一扫

专栏目录

在Pytorch中计算自己模型的FLOPs方式

09-18

今天小编就为大家分享一篇在Pytorch中计算自己模型的FLOPs方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

faster_rcnn test 浮点运算量

11-05

RCNN, Fast RCNN, Faster RCNN这一系列目标检测算法训练的指导

3 条评论

您还未登录，请先

后发表或查看评论

神经网络的计算量(FLOPs)、参数量(Params)、推理时间（FPS）的定义及实现方法

qq_43307074的博客

11-04

2万+

神经网络的计算量(FLOPs)和参数量(Params)的定义及实现方法

【计算机视觉】GFLOPs、FLOPS和FLOPs的区别和联系（含代码示例）

wzk4869的博客

12-28

2685

【计算机视觉】GFLOPs、FLOPS和FLOPs的区别和联系（含代码示例）

FLOPS表示什么？

weixin_44943389的博客

10-10

601

FLOPS的计算单位可以是“GigaFLOPS”（十亿次浮点运算每秒，GFLOPS）、“TeraFLOPS”（一万亿次浮点运算每秒，TFLOPS）、“PetaFLOPS”（一千万亿次浮点运算每秒，PFLOPS）等，取决于所讨论的计算机或设备的性能水平。FLOPS是一个重要的性能指标，特别对于科学计算、仿真、模拟、深度学习训练等需要大量计算的任务来说，它可以帮助评估一个计算机或设备在处理这类任务时的效率和速度。

关于 FLOPS、FLOPs、参数量的相关计算

乄洛尘

03-30

1万+

最近找到一些计算FLOPs的文章，奈何全是水文，讲都讲不清楚，完完全全的究极缝合怪。因此，这里准备彻底搞懂。

深度学习中FLOPS和FLOPs的区别与计算

一直特立独行的猫

11-08

7071

我们在购买GPU或者计算目标检测模型复杂度的时候，一般会遇到FLOPS和FLOPs这两个指标，在此加以区分。

深度学习中的FLOPs是什么？如何计算的？

CNN 模型所需的计算力（flops）和参数（parameters）数量是怎么计算的？ - 知乎

CNN 模型所需的计算力（flops）和参数（parameters）数量是怎么计算的？ - 知乎首页知乎知学堂发现等你来答切换模式登录/注册算法机器学习深度学习（Deep Learning）卷积神经网络（CNN）CNN 模型所需的计算力（flops）和参数（parameters）数量是怎么计算的？最近看到一些文章中有关于模型的计算力消耗问题，也就是 FLOPs，比如 DenseNet 中的这张图： [图片] 不知道这个 FLOPs 怎么计算出来…显示全部关注者1,669被浏览1,206,011关注问题写回答邀请回答好问题 63添加评论分享25 个回答默认排序泓宇知乎小透明关注看到有人对flops有疑惑，先捋清这个概念。FLOPS：注意全大写，是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度。是一个衡量硬件性能的指标。FLOPs：注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。网上打字很容易全小写，造成混淆，本问题针对模型，应指的是FLOPs。以下答案不考虑activation function的运算。卷积层：(2\times C_{i} \times K^{2}-1)\times H\times W\times C_{o}Ci=input channel, k=kernel size, HW=output feature map size, Co=output channel.2是因为一个MAC算2个operations。不考虑bias时有-1，有bias时没有-1。上面针对一个input feature map，没考虑batch size。理解上面这个公式分两步，括号内是第一步，计算出output feature map的一个pixel，然后再乘以HWCo拓展到整个output feature map。括号内的部分又可以分为两步， (2 \cdot C_{i}\cdot K^{2}-1)=(C_{i}\cdot K^{2})+(C_{i}\cdot K^{2}-1) ，第一项是乘法运算数，第二项是加法运算数，因为n个数相加，要加n-1次，所以不考虑bias，会有一个-1，如果考虑bias，刚好中和掉，括号内变为 2 \cdot C_{i}\cdot K^{2}全联接层： (2\times I-1)\times OI=input neuron numbers, O=output neuron numbers.2是因为一个MAC算2个operations。不考虑bias时有-1，有bias时没有-1。分析同理，括号内是一个输出神经元的计算量，拓展到O了输出神经元。我的答案其实也是参考自 @李珂和 @王艺程所提到的NVDIA的那个paper，只是都不是很完美，所以做个总结。如果有错误/疑问，欢迎讨论。 P.s. NVDIA那个paper公式11有错误吧，H和W应该指output feature map吧。二更：顺便补充LSTM层,RNN/GRU可借鉴计算(E+H)\times H\times 4 \times 2 E是embedding dimension，也就是词向量维度（注意不是时间维度）H是hidden state dimension，也就是LSTM有多少cell4是4 个非线性变换块（3 个门 + 1 个 tanh）2是将MAC数转为FLOPsLSTM里其实还有三个乘法块，一个加法块和非线性部分，计算量占用不大，这里近似忽略。三更:上面是从理论角度分析模型的计算量，实操时可借助工具快速一键获取FLOPs值：tensorflow2pytorch-OpCountertorchstat编辑于 2021-04-08 05:19赞同 110749 条评论分享收藏喜欢收起留德华叫兽海德堡大学交叉学科计算中心离散与组合优化实验室研究员关注0. 深度学习框架复杂度描述一个深度学习框架/模型除了他的精确度通常用Forward Pass计算量和参数个数(#Parameters)来描述复杂度（为啥Care？例如在手机或汽车上部署深度学习，对模型大小和计算力就有严格要求）前者描述了所需的计算力后者描述了所需内存1. 深度学习框架FLOPs的概念Floating point operations即：浮点运算数量Paper里比较流行的单位是GFLOPs1 GFLOPs = 10^9 FLOPs即：10亿次浮点运算2. 深度学习框架FLOPs的组成1. 卷积运算Conv用以下动图中直观的解释：Image大小为 5x5卷积核大小为 3x3那么一次3x3的卷积（求右图矩阵一个元素的值）所需运算量：(3x3)个乘法+(3x3-1)个加法 = 17要得到右图convolved feature （3x3的大小）：17x9 = 153https://towardsdatascience.com/a-comprehensive-guide-to-convolutional-neural-networks-the-eli5-way-3bd2b1164a532. BatchNorm3. ReLu4. Linear5. Upsample6. Poolings其中，Conv所占的比重通常是最大的此外，它和输入图像的大小也有关系而#Parameters和图像大小无关3. 计算FLOPs的代码或包因为无人驾驶车载板子对模型复杂度有要求今天在Github上找了一下午代码（基于Pytorch）终于找到一个既傻瓜又好用的！！！示例代码(以VGG16为例)：https://github.com/sovrasov/flops-counter.pytorch可以看到算上import 和 print（）也仅仅6行代码！不仅输出了整个框架的复杂度Flops: 15.5 x 10^9 次浮点运算Params: 138.36 百万个参数还能输出每一层的复杂度以及该层占整个网络的比重（同时也验证了Conv占比最大）夫复何求！！！（注：工具来源于Github，请自行验证其正确性）4. 常用框架的复杂度https://www.hpcuserforum.com/presentations/Wisconsin2017/HPDLCookbook4HPCUserForum.pdf成文仓促，难免疏漏以上，欢迎指正，欢迎关注 @运筹OR帷幄公号及加入学术群交流～编辑于 2019-04-19 16:48赞同 81182 条评论分享收藏喜欢

如何解读算力 TOPS 和 FLOPS 的关系？ - 知乎

如何解读算力 TOPS 和 FLOPS 的关系？ - 知乎首页知乎知学堂发现等你来答切换模式登录/注册科技关系算力如何解读算力 TOPS 和 FLOPS 的关系？关注者2被浏览24,191关注问题写回答邀请回答好问题添加评论分享1 个回答默认排序GrowthX技术推广行业全域增长专家关注算力（Computational Power）通常用两个指标来衡量：TOPS（Tera Operations Per Second，万亿次运算每秒）和FLOPS（Floating Point Operations Per Second，每秒浮点运算次数）。TOPS是指在每秒钟内执行的总运算次数，其中包括所有类型的运算，包括整数运算、浮点运算、逻辑运算等。TOPS的计算方式是将每个操作的运算次数相加得到总数。TOPS是一种用于衡量计算机系统整体计算能力的指标。FLOPS是指每秒钟执行的浮点运算次数。浮点运算是一种涉及带有小数点的数值计算，例如加法、减法、乘法和除法等。FLOPS通常用于衡量涉及大量浮点计算的应用，如科学计算、人工智能和图形处理等。关于两者的关系，FLOPS可以看作是TOPS中特定类型运算（即浮点运算）的子集。也就是说，计算设备的TOPS值包括了执行各种类型运算的总次数，而其中的一部分是浮点运算，其次数即为FLOPS。因此，在比较计算设备的性能时，可以通过比较它们的FLOPS值来了解其在浮点计算方面的能力。需要注意的是，TOPS和FLOPS仅代表计算能力的一部分，对于评估计算设备的整体性能，还需要考虑其他因素，如内存带宽、存储器容量、并行计算能力等。此外，具体应用场景也会对计算需求产生不同影响，因此最佳的性能指标选择应该根据具体情况进行综合考虑。发布于 2023-08-18 10:26赞同 6添加评论分享收藏喜欢收起写回答1 个回答被折叠（为什

FLOPs小的模型反而推理时间较长这是为什么？ - 知乎

FLOPs小的模型反而推理时间较长这是为什么？ - 知乎首页知乎知学堂发现等你来答切换模式登录/注册深度学习（Deep Learning）卷积神经网络（CNN）PyTorchFLOPs小的模型反而推理时间较长这是为什么？我训练出两个cnn网络A和B，网络中仅有普通的conv、pool、relu、bn层。其中A的FLOPs为200G，B的FLOPs为20G。但是在相同的…显示全部关注者143被浏览117,721关注问题写回答邀请回答好问题 193 条评论分享9 个回答默认排序知乎用户U3JLbR 关注用ShuffleNet_v2的论文来回答一下这个问题吧。前言：目前一些网络模型如MobileNet_v1, v2，ShuffleNet_v1, Xception采用了分组卷积，深度可分离卷积等操作，这些操作在一定程度上大大减少了FLOPs，但FLOPs并不是一个直接衡量模型速度或者大小的指标，它只是通过理论上的计算量来衡量模型，然而在实际设备上，由于各种各样的优化计算操作，导致计算量并不能准确地衡量模型的速度，换言之，相同的FLOPs会有不同的推理速度。这是一篇类似于《Rethinking the Inception Architecture for Computer Vision》（即Inception_v2）的论文，在Inception_v2论文中提出了四条设计卷积网络模型的原则，Inception_v2就是基于这些原则上设计而来。同样，shuffleNet_v2，即《Pratical Guidelines for Efficient CNN Architecture Design》，指出了四个影响模型实际推理速度的操作，并在尽量避免这些操作的基础上提出了ShuffleNet_v2结构。ShuffleNet v2实现了在同样的FLOPs下，速度明显快于其他类似网络。例如，在500MFLOPs，ShuffleNet v2比MobileNet v2快58%，比ShuffleNet v1快63%，比Xception快25%。Direct metrics前面提到FLOPs是通过理论上的计算量来衡量模型速度，这是一个indirect metrics，与direct metrics（如速度）之间是存在一些差异。主要原因一个是FLOPs忽略了一些重要的因素，一个是MAC (memory access cost),即内存访问的时间成本。例如分组卷积，其使得底层使用的一些优化实现算法由于分组后实现性能更低，从而导致，分组数越大，时间成本越高。另一个是并行度，同样FLOPs下，高并行度的模型速度快于低并行度的模型。第二个是不同平台下，同样的FLOPs的模型运行时间不同。例如在最新的CUDNN library中，优化实现的3x3卷积所花费的时间并没有1x1卷积的9倍。如图所示，这是一个模型在GPU上各项操作所花费的时间，FLOPs仅表示了Conv部分的计算量，而实际上Elemwise、Data相关部分也耗费相当大的时间。因此，仅仅使用FLOPs这个indirect metrics来衡量模型速度是不够的。ShuffleNet v2使用实际运行时间来衡量模型。高效设计CNN模型的实际指南ShuffleNet v2进行了四项实验，得出了一些比较耗时的操作，经过原理分析，提出了四条设计原则。1. 卷积层输入输出通道数相同时，MAC最小2. 分组卷积的分组数越大，MAC越大3. 网络支路会降低模型的并行度4. Element-wise操作不可忽视01 卷积层输入输出通道数相同时，MAC最小为简化计算表达式，这里使用1x1卷积来进行理论上的推导。对于空间大小为 h,w的特征图，输入和输出通道数分别为c1和c2,使用1x1卷积, 则FLOPs为B = h x w x c1 x c2。而MAC = hw(c1 + c2 ) + c1 x c2。这里hwc1为输入特征图内存访问成本，hwc2为输出特征图内存访问时间成本，c1xc2x1x1为卷积核内存访问时间成本。将B表达式代入MAC表达式中，并根据不等式定理，可有如下不等式：由此式可知，MAC存在下限，当c1 = c2时，MAC取最小值。因此，第一组实验即为在相同的FLOPs下，取不同的输入输出通道数的比值c1/c2，查看不同c1/c2下模型运行时间。如图所示，理论相当正确。在1：1时模型速度最快。02 分组卷积的分组数越大，MAC越大分组卷积在一方面，使得在相同FLOPs下，分组数越大，在通道上的密集卷积就会越稀疏，模型精度也会增加，在另一方面，更多的分组数导致MAC增加。使用分组卷积的FLOPs表达式为B=h w c1 c2 /g , MAC表达式如下：第二组实验是在相同的FLOPs下，查看不同的分组数对模型的运行速度：因此，分组数需要合理的选择，需要在运行时间和精度上平衡。03 网络支路会降低模型的并行度在GoogLeNet(也就是Inception_v1)系列中，使用了多条支路，最后通过concat的方式拼接。这样的支路不仅提到了精度，但同时也降低了效率，这是因为支路对GPU并行运算来说是不友好的，此外，它还引入了额外的开销，如内核启动与同步。第三组实验是在相同FLOPs情况下，设置四个支路数不同的一个网络，比较它们运行的速度。实验证明，只有一条支路时，运行速度最快。因此，在网络结构中支路数可以提到精度，但也会降低运行速度，从而影响实时性。04 Element-wise操作不可忽视正如上面给的那个图，Element-wise操作在GPU上占的时间是相当多的。Element-wise操作有ReLU, AddTensor, AddBias等。它们都有比较小的FLOPs，却有比较大的MAC。特别地，depthwise conv也可以认为是一个Element-wise操作，因为它有较大的MAC/FLOPs比值。对于第四组实验，使用ResNet中的bottleneck单元（也就是1x1卷积后接3x3卷积，再接1x1卷积，中间使用了ReLU, 另有一个shortcut连接），设置有无shortcut, ReLU四个不同的对比，得出它们的运行时间。实验证明，ReLU,shortcut这些Element-wise会降低运行时间。对此，shuffleNet v1使用多的分组数，违背了第二条原则，使用bottleneck相似的结构违背了第一条原则，MobileNet v2使用倒残差结构违背了第一条，且在通道数较多的feature map上使用了depthwise conv和ReLU违背了第四条，自动生成的结构有较多支路，违背了第三条。注意：这里指的违背了这些原则，并不是说设计不好。以第二条分组数和第三条支路数为例，不能因为它们会降低模型运行时间，就再也不使用支路和分组卷积，毕竟它们对模型精度有较大提升，因此需要选择合适的分组数和支路数，以便在速度上和精度上取得权衡。ShuffleNet v2结构shuffleNet v2是在shuffleNet v1 unit的基础上，根据上面四组实验得出的经验，进行适当的权衡精度与速度而调整的。图a为shuffleNet v1正常Unit, 图b为shuffleNet v1降采样Unit，图c为shuffleNet v2 正常Unit, 图d为shuffleNet v2 降采样Unit.在shuffleNet v2中引入了Channel Split, 将通道数分为c’ 和c - c’，这里c’取c/2。一部分进行卷积操作，另一部分直接进行concat。卷积的那一路的输入和输出相等，这是考虑到第一条原则。两个1x1卷积不再进行分组，一部分原因是第二条原则，另一部分是因为Channel split就相当于是分组了。两路进行concat后，再进行Channel Shuffle，这是为了通道上的信息进行流动。否则，左端那路的一半通道信息将一直进行到后面都没有通过卷积层。对于空间降采样层，这个Unit是没有Channel split，这样可以实现在两路concat后，通道数翻倍。其余改动具体看图更容易理解。本文来源于公众号CV技术指南的模型解读系列。编辑于 2021-05-19 11:33赞同 781 条评论分享收藏喜欢收起风车车车WavePhix Software engineer 关注因为推理时间基本是由计算和访存两方面组成的，而flops只间接反映了计算上的时间首先flops本身就是一个间接指标，明明cudnn用的Winograd计算卷积，但是flops计算大家还是按照传统卷积的方式来算，那这个就不准了；其次flops只反映计算的开销，一些算子比如add，concat之类的本身计算量不大，相比计算而言访存花的时间会更多，而flops压根考虑不到这方面，所以就更加不准了如果题主去对densenet的推理过程做一个profile就会发现卷积计算其实只占了一半不到的时间。。。发布于 2021-11-15 16:41赞同 93 条评论分享收藏喜欢

FLOPS_百度百科

Beta

進入詞條

清除歷史記錄關閉

反饋

複製鏈接

請複製以下鏈接發送給好友

https://baike.baidu.hk/item/FLOPS/989494

複製

複製成功

FLOPS

鎖定

FLOPS（即“每秒浮點運算次數”，“每秒峯值速度”）是“每秒所執行的浮點運算次數”（floating-point operations per second）的縮寫。它常被用來估算電腦的執行效能，尤其是在使用到大量浮點運算的科學計算領域中。正因為FLOPS字尾的那個S，代表秒，而不是複數，所以不能省略掉。在這裏所謂的“浮點運算”，實際上包括了所有涉及小數的運算。這類運算在某類應用軟件中常常出現，而它們也比整數運算更花時間。現今大部分的處理器中，都有一個專門用來處理浮點運算的“浮點運算器”（FPU）。也因此FLOPS所量測的，實際上就是FPU的執行速度。而最常用來測量FLOPS的基準程式（benchmark）之一，就是Linpack。

中文名

每秒所執行的浮點運算次數

外文名

floating-point operations per second

包括了

所有涉及小數的運算

簡稱

FLOPS

評價

換算

其他信息

運算能力

FLOPS評價

許多專家對FLOPS有頗多微詞，認為它並不是一個有意義的量度（measurement），因為FLOPS並不能反應出許多對執行效能有影響的因素。例如：I/O的效能、內存的架構、快取內存一致性（cache coherence）等。這意味着電腦的實際計算容量，與FLOPS的理論峯值間會有一段不小的差距。

FLOPS換算

一個MFLOPS（megaFLOPS）等於每秒一百萬（=10^6）次的浮點運算，一個GFLOPS（gigaFLOPS）等於每秒十億（=10^9）次的浮點運算，一個TFLOPS（teraFLOPS）等於每秒一萬億（=10^12）次的浮點運算，(1太拉)一個PFLOPS（petaFLOPS）等於每秒一千萬億（=10^15）次的浮點運算，一個EFLOPS（exaFLOPS）等於每秒一百京（=10^18）次的浮點運算，一個ZFLOPS（zettaFLOPS）等於每秒十萬京（=10^21）次的浮點運算。

FLOPS其他信息

現今大部分的處理器中，都有一個專門用來處理浮點運算的“浮點單元”(FPU)。也因此 FLOPS 所量測的，實際上就是 FPU 的執行速度。而最常用來測量 FLOPS 的基準程序(benchmark) 之一，就是 Linpack。1GHz 就是每秒十億次運算，如果每次運算能完成兩個浮點操作，就叫 2G FLOPS（每秒二十億次浮點操作）。現在家用的雙核計算機通常都能達到每秒五十億次運算（2*2.5GHz）左右的水平，浮點性能大約是上百億次浮點操作。超級計算機發展得很快，目前劃分超級計算機的門檻是“每秒一萬億次浮點操作”，是家用微機的一百倍以上，幾年以後這個門檻預計會提高到十萬億次。超級計算機幾十、上百萬億次的 FLOPS 也是靠多個處理器（通常還是多核）堆起來的，比如的IBM Roadrunner （走鵑，一種喜歡在地上飛快地走的小鳥）有 6562 個 AMD Opteron雙核處理器，12240 個 PowerX Cell 8i 處理器，其中主要的浮點運算能力是由 Cell 處理器提供的，每個 Cell CPU 包括 8 個浮點處理核心，你可以理解為 8 核。（Cell也是 Sony PS3 遊戲機的處理器，不過用於PS3的比用於超級計算機的要次一等）總體來看，就是 2 * 6562 = 13124 個通用處理器核心； 8 * 12240 = 97920 個專用處理器核心。你説這麼多錢堆出來的這麼十多萬個核心，速度能不快嗎？它的速度是 1.026 P FLOPS，也就是每秒超過一千萬億次浮點操作

FLOPS運算能力

中國的一台叫做「天河2號」的超級計算機，跑出了30.65PFlops的驚人紀錄，比當今世界上最快的那台還要快上 74%！這份成績的驚人之處在與，這是基於Intel平台的天河2號（又稱銀河2號）還沒開足馬力的情況下取得的成績。經過一次5小時的LINPACK測試,動用了16,000個節點中的14,336個，也就是90%的運算節點，測到了前面提到的30.65PFlops（1 petaflop=1千萬億次浮點計算/秒）LINPACK軟件包被用來測試全球500強大型計算機的運算能力。現在的Top1是美國的泰坦，有17.5PFlops的計算速度。天河2號的效能比是1.935GFlops/瓦，略遜於泰坦的2.143GFlops/瓦。天河2號的數據，本週在田納西大學教授Jack Dongarra的論文中被披露，他編寫了LINPACK軟件包，並且負責每年修訂500強排行榜兩次。教授沒有説明，天河2號的戰績是否會正式提交，並被收錄到最新的排行榜中。但不管怎麼樣，新榜單將在6月17日公佈。天河2號計劃今年年底入駐廣州的國家超級計算機中心，天河2號的組裝和測試主要由中國國防科技大學(NUDT)承擔。一旦驗收通過，天河2號將對外開放平台，用於實驗和教育領域。天河2號使用Intel Ivy Bridge和Xeon Phi 處理器，「32,000顆Ivy Bridge的Xeon和48,000顆的Xeon Phi共計2,120,000個內核。」Dongarra寫道。天河2擁有12.4PB的硬盤和1.4PB的內存。NUDT採用自己的分佈式計算技術，Dongarra描述為：「光電混合傳輸技術(optoelectronics hybrid transport technology)，上層採用主幹拓撲結構，通過13個路由，每個路由有576個端口連接。並運行麒麟LINUX系統。」理論上，天河2號具備54.9PFlops的計算能力。但Top500上的機器大多達不到理論值，但如果天河2號開足馬力，還有很大的提升空間。天河2號是天河1號的後續產品，天河1號曾經在2010年11月登上過Top500的頭把交椅，而且長時間排在前8位，運算能力2.57PFlops。[Junius_Lou via Ars]

詞條統計

瀏覽次數：次

編輯次數：38次歷史版本

浮点运算量FLOPs与算力单位FLOPS_flops单位-CSDN博客

浮点运算量FLOPs与算力单位FLOPS

最新推荐文章于 2024-03-04 14:50:33 发布

Joejwu

最新推荐文章于 2024-03-04 14:50:33 发布

阅读量1.4w

点赞数

分类专栏：

单位

文章标签：

深度学习

本文链接：https://blog.csdn.net/Joejwu/article/details/120388938

版权

单位

专栏收录该内容

2 篇文章

1 订阅

订阅专栏

概念

FLOPS：注意全大写，是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度。是一个衡量硬件性能的指标。

FLOPs：注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。

单位换算

1 MFLOPs(mega) = 10^6 FLOPs，即：100万次浮点运算

1 GFLOPs(giga) = 10^9 FLOPs，即：10亿次浮点运算

1 TFLOPs(tera) = 10^12 FLOPs，即：1万亿次浮点运算

常见算力单位

TOPS是Tera Operations Per Second的缩写，1TOPS代表处理器每秒钟可进行一万亿次（10^12）操作。

与此对应的还有GOPS（Giga Operations Per Second），MOPS（Million Operation Per Second）算力单位。

1GOPS代表处理器每秒钟可进行十亿次（10^9）操作，1MOPS代表处理器每秒钟可进行一百万次（10^6）操作。

TOPS同GOPS与MOPS可以换算，都代表每秒钟能处理的次数，单位不同而已。

在某些情况下，还使用 TOPS/W 来作为评价处理器运算能力的一个性能指标，TOPS/W 用于度量在1W功耗的情况下，处理器能进行多少万亿次操作。

优惠劵

Joejwu

关注

踩

觉得还不错?

一键收藏

打赏

知道了

浮点运算量FLOPs与算力单位FLOPS

概念FLOPS：注意全大写，是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度。是一个衡量硬件性能的指标。FLOPs：注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。单位换算1 MFLOPs(mega) = 10^6 FLOPs，即：100万次浮点运算1 GFLOPs(giga) = 10^9 FLOPs，即：10亿次

复制链接

扫一扫

专栏目录

faster-rcnn-vgg16浮点运算次数

06-11

输入图像为768x576。在faster-rcnn中使用vgg16作为分类网络模型。

【计算机视觉】GFLOPs、FLOPS和FLOPs的区别和联系（含代码示例）

wzk4869的博客

12-28

2685

【计算机视觉】GFLOPs、FLOPS和FLOPs的区别和联系（含代码示例）

1 条评论

您还未登录，请先

后发表或查看评论

深度学习中FLOPS和FLOPs的区别与计算

一直特立独行的猫

11-08

7071

我们在购买GPU或者计算目标检测模型复杂度的时候，一般会遇到FLOPS和FLOPs这两个指标，在此加以区分。

【计算FLOPs】GFLOPs、FLOPS和FLOPs的区别和联系（含代码示例）

weixin_44955407的博客

01-19

421

TFLOPS（teraFLOPS）：等于每秒一万亿（= 1 0 12 10^{12} 1012）次的浮点运算，(1太拉)PFLOPS（petaFLOPS）：等于每秒一千万亿（= 1 0 15 10^{15} 1015）次的浮点运算。ZFLOPS（zettaFLOPS）：等于每秒十万京（= 1 0 21 10^{21} 1021）次的浮点运算。EFLOPS（exaFLOPS）：等于每秒一百京（= 1 0 18 10^{18} 1018）次的浮点运算。经过测试，基本上两个可以对齐的，任意选择一个就好。

FLOPS表示什么？

weixin_44943389的博客

10-10

601

FLOPs如何计算

chen的博客

10-30

1545

FLOPs（Floating Point Operations Per Second）是一个用于衡量计算机系统、硬件或算法性能的单位，表示每秒执行的浮点运算次数。FLOPs的计算可以帮助评估机器学习模型或算法的计算复杂度，以确定其在不同硬件上的效率。FLOPs的计算通常取决于模型的结构以及每个层或操作的输入和输出维度。然后，根据该层或操作执行的具体数学运算来计算FLOPs。将所有层或操作的FLOPs相加，以获得整个模型的总FLOPs。输入层没有浮点运算，所以FLOPs为0。

int8，FLOPS，FLOPs，TOPS 等具体含义

ytusdc的博客

01-01

1万+

算力的计量单位FLOPS（Floating-point operations per second），FLOPS表示每秒浮点的运算次数。具体使用时，FLOPS前面还会有一个字母常量，例如TFLOPS、PFLOPS。这个字母T、P代表次数，T代表每秒一万亿次，P代表每秒一千万亿次。除了运算次数，衡量算力水平时还要看算力精度。例如，1000FLOPS的AI计算中心所提供的的算力，与1000FLOPS超级计算机提供的算力，虽然数值相同，但由于精度不同，实际算力水平也是天壤之别。

深度学习中的FLOPs介绍及计算(注意区分FLOPS)

qq_41834400的博客

09-14

2万+

FLOPS与FLOPs

FLOPS：注意全大写，是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度。是一个衡量硬件性能的指标。

FLOPs：注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。

全连接网络中FLOPs的计算

推导

以4个输入神经元和3个输出神经元为例

计算一个输出神经元的的计算过程为

y1=w11∗x1+w21∗x2+w31∗x3

算力单位详解

pangxing6491的博客

09-02

1万+

算力详解

算力单位的解释