浅析计算GMAC和GFLOPS（gmsc计算公式）

25-03-06 17

此处将为大家介绍关于浅析计算GMAC和GFLOPS的详细内容，并且为您解答有关gmsc计算公式的相关问题，此外，我们还将为您介绍关于(转载)CNN模型所需的计算力（FLOPs）和参数（paramete

此处将为大家介绍关于浅析计算GMAC和GFLOPS的详细内容，并且为您解答有关gmsc计算公式的相关问题，此外，我们还将为您介绍关于(转载)CNN 模型所需的计算力（FLOPs）和参数（parameters）数量计算、android – MarshMallow gmaps权限、Bigflow 为什么要使用 Bigflow? 分布式计算框架、CPU TFLOPS 计算的有用信息。

本文目录一览：

浅析计算GMAC和GFLOPS（gmsc计算公式）
(转载)CNN 模型所需的计算力（FLOPs）和参数（parameters）数量计算
android – MarshMallow gmaps权限
Bigflow 为什么要使用 Bigflow? 分布式计算框架
CPU TFLOPS 计算

浅析计算GMAC和GFLOPS（gmsc计算公式）

gmac 代表“giga multiply-add operations per second”（每秒千兆乘法累加运算），是用于衡量深度学习模型计算效率的指标。该指标用每秒十亿个乘加运算的形式表示模型的计算速度。

浅析计算GMAC和GFLOPS

乘法累加 (MAC) 运算是许多数学计算中的基本运算，包括矩阵乘法、卷积和深度学习中常用的其他张量运算。每个 MAC 操作都涉及将两个数字相乘并将结果添加到累加器。

可以使用以下公式计算 GMAC 指标：

GMAC =（乘法累加运算次数）/（10⁹）

登录后复制

乘加运算的数量通常通过分析网络架构和模型参数的维度来确定，例如权重和偏差。

通过 GMAC 指标，研究人员和从业者可以就模型选择、硬件要求和优化策略做出明智的决策，以实现高效且有效的深度学习计算。

浅析计算GMAC和GFLOPS

GFLOPS是计算机系统或特定运算计算性能的衡量指标，代表每秒可执行十亿次浮点运算。它是每秒钟浮点运算的数量，用十亿 (giga) 表示。

浮点运算是指进行以 IEEE 754 浮点格式表示的实数进行算术计算。这些运算通常包括加法、减法、乘法、除法和其他数学运算。

GFLOPS 通常用于高性能计算 (HPC) 和基准测试，特别是在需要繁重计算任务的领域，例如科学模拟、数据分析和深度学习。

计算 GFLOPS公式如下：

GFLOPS =（浮点运算次数）/（以秒为单位的运行时间）/ (10⁹)

登录后复制

GFLOPS是一项有效的测量不同计算机系统、处理器或特定操作的计算能力的指标。它有助于评估执行浮点计算的硬件或算法的速度和效率。GFLOPS 是衡量理论峰值性能的指标，可能无法反映实际场景中实现的实际性能，因为它没有考虑内存访问、并行化和其他系统限制等因素。

GMAC 和 GFLOPS 之间的关系

1 GFLOP = 2 GMAC

登录后复制

如果我们想计算这两个指标，手动写代码的话会比较麻烦，但是Python已经有现成的库让我们使用：

ptflops 库就可以计算 GMAC 和 GFLOPs

pip install ptflops

登录后复制

使用也非常简单：

import torchvision.models as models import torch from ptflops import get_model_complexity_info import re  #Model thats already available net = models.densenet161() macs, params = get_model_complexity_info(net, (3, 224, 224), as_strings=True, print_per_layer_stat=True, verbose=True) # Extract the numerical value flops = eval(re.findall(r''([\d.]+)'', macs)[0])*2 # Extract the unit flops_unit = re.findall(r''([A-Za-z]+)'', macs)[0][0]  print(''Computational complexity: {:<p>结果如下：</p><pre>Computational complexity: 7.82 GMac Computational complexity: 15.64 GFlops Number of parameters: 28.68 M

登录后复制

我们可以自定义一个模型来看看结果是否正确：

import os import torch from torch import nn  class NeuralNetwork(nn.Module): def __init__(self): super().__init__() self.flatten = nn.Flatten() self.linear_relu_stack = nn.Sequential( nn.Linear(28*28, 512), nn.ReLU(), nn.Linear(512, 512), nn.ReLU(), nn.Linear(512, 10),)  def forward(self, x): x = self.flatten(x) logits = self.linear_relu_stack(x) return logits  custom_net = NeuralNetwork()  macs, params = get_model_complexity_info(custom_net, (28, 28), as_strings=True, print_per_layer_stat=True, verbose=True) # Extract the numerical value flops = eval(re.findall(r''([\d.]+)'', macs)[0])*2  # Extract the unit flops_unit = re.findall(r''([A-Za-z]+)'', macs)[0][0] print(''Computational complexity: {:<p>结果如下：</p><pre>Computational complexity: 670.73 KMac Computational complexity: 1341.46 KFlops Number of parameters: 669.71 k

登录后复制

为了方便演示，我们只编写全连接层代码来手动计算GMAC。遍历模型权重参数并计算乘法和加法操作数量的形状取决于权重参数，这是计算GMAC的关键。计算GMAC所需的全连接层权重的公式为2 x （输入维度 x 输出维度）。总的GMAC值是通过将每个线性层的权重参数的形状相乘并累加而得出的，这一过程基于模型的结构。

import torch import torch.nn as nn  def compute_gmac(model): gmac_count = 0 for param in model.parameters(): shape = param.shape if len(shape) == 2:# 全连接层的权重 gmac_count += shape[0] * shape[1] * 2 gmac_count = gmac_count / 1e9# 转换为十亿为单位 return gmac_count

登录后复制

根据上面给定的模型，计算GMAC的结果如下：

0.66972288

登录后复制

由于GMAC的结果以十亿为单位，因此与我们上面使用类库计算的结果相差不大。最后再说一下，计算卷积的GMAC稍微有些复杂，公式为 ((输入通道 x 卷积核高度 x 卷积核宽度) x 输出通道) x 2，这里给一个简单的代码，不一定完全正确，供参考

def compute_gmac(model): gmac_count = 0 for param in model.parameters(): shape = param.shape if len(shape) == 2:# 全连接层的权重 gmac_count += shape[0] * shape[1] * 2 elif len(shape) == 4:# 卷积层的权重 gmac_count += shape[0] * shape[1] * shape[2] * shape[3] * 2 gmac_count = gmac_count / 1e9# 转换为十亿为单位 return gmac_count

登录后复制

以上就是浅析计算GMAC和GFLOPS的详细内容，更多请关注php中文网其它相关文章！

(转载)CNN 模型所需的计算力（FLOPs）和参数（parameters）数量计算

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 O$

I=input neuron numbers, O=output neuron numbers.

2是因为一个MAC算2个operations。

不考虑bias时有-1，有bias时没有-1。

分析同理，括号内是一个输出神经元的计算量，拓展到O了输出神经元。

参考：chen liu

对于一个卷积层，假设其大小为 $h \times w \times c \times n$ （其中c为#input channel, n为#output channel），输出的feature map尺寸为 $H'' \times W''$ ，则该卷积层的

#paras = $n \times (h \times w \times c + 1)$
#FLOPS= $H'' \times W'' \times n \times(h \times w \times c + 1)$

即#FLOPS= $H'' \times W'' \times$ #paras

参考：李珂

Model_size = 4*params 模型大小为参数量的4倍

附：Pytorch计算FLOPs的代码：

http://link.zhihu.com/?target=https%3A//github.com/Lyken17/pytorch-OpCounter

https://github.com/sovrasov/flops-counter.pytorch

神器（pytorch）：

pytorch-OpCounter 用法：（pytorch版本>=1.0）

from torchvision.models import resnet50
from thop import profile
model = resnet50()
flops, params = profile(model, input_size=(1, 3, 224,224))

torchstat 用法:

from torchstat import stat
import torchvision.models as models

model = model.alexnet()
stat(model, (3, 224, 224))

flopth 用法：

from flopth import flopth
print(flopth(net, in_size=[3,112,112]))

ptflops用法：

from ptflops import get_model_complexity_info
flops, params = get_model_complexity_info(net, (3, 224, 224), as_strings=True, print_per_layer_stat=True)
print(''Flops:  '' + flops)
print(''Params: '' + params)

自己计算参数量：

print(''Total params: %.2fM'' % (sum(p.numel() for p in net.parameters())/1000000.0))

需要注意的是：params只与你定义的网络结构有关，和forward的任何操作无关。即定义好了网络结构，参数就已经决定了。FLOPs和不同的层运算结构有关。如果forward时在同一层（同一名字命名的层）多次运算，FLOPs不会增加。

参考：

轻量级神经网络“巡礼”（一）—— ShuffleNetV2

android – MarshMallow gmaps权限

如果gmaps需要此权限：

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

>我应该向requestPermissions的用户索要每个人吗？
>我检查了几次,它只是崩溃说用户没有给android.permission.ACCESS_FINE_LOCATION但不是其他人的权限,为什么？

解决方法

should I ask for each one to the user with requestPermissions ?

首先何时使用requestPermission？

当此方法未返回PERMISSION_GRANTED时,requestPermission仅在checkSelfPermission之后调用.

你可以在运行时找到android M需要的list of permission.这些权限中的每一个都是权限组的一部分. WRITE_EXTERNAL_PERMISSION来自android.permission-group.STORAGE,ACCESS_COARSE_LOCATION / ACCESS_FINE_LOCATION来自android.permission-group.LOCATION.

如果用户允许访问权限 – 例如ACCESS_COARSE_LOCATION-,则android将自动授予此权限组-i.e的访问权限.许可的group.LOCATION-.因此,如果您稍后检查ACelf_FINE_LOCATION的SelfPermission,则应该收到PackageManager.PERMISSION_GRANTED.

如果您的应用程序崩溃,则表示您在向用户请求权限组位置之前尝试调用,例如LocationServices.FusedLocationApi.requestLocationUpdates.

编辑：

不要忘记requestPermission是异步的.因此,请勿在requestPermission之后调用需要权限的方法.要调用需要权限的方法,您应该覆盖onRequestPermissionsResult,它会为您提供权限列表及其状态-granted / denied-.

Bigflow 为什么要使用 Bigflow? 分布式计算框架

Bigflow 为什么要使用 Bigflow? 介绍

Bigflow 是百度的一套计算框架，它致力于提供一套简单易用的接口来描述用户的计算任务，并使同一套代码可以运行在不同的执行引擎之上。

它的设计中有许多思想借鉴自 Google
FlumeJava以及
Google Cloud
Dataflow，另有部分接口设计借鉴自
Apache Spark。

用户基本可以不去关心 Bigflow 的计算真正运行在哪里，可以像写一个单机的程序一样写出自己的逻辑， Bigflow
会将这些计算分发到相应的执行引擎之上执行。

Bigflow 的目标是: 使分布式程序写起来更简单，测起来更方便，跑起来更高效，维护起来更容易，迁移起来成本更小。

目前 Bigflow 在百度公司内部对接了公司内部的批量计算引擎 DCE（与社区 Tez 比较类似），迭代引擎 Spark，以及公司内部的流式计算引擎
gemini。

在开源版本中，目前仅开放了Bigflow on Spark。

为什么要使用 Bigflow?

高性能 Bigflow 的接口设计使得 Bigflow 可以感知更多的用户需求的细节属性，并且 Bigflow 会根据计算的属性进行作业的优化；另其执行层使用 C 实现，用户的一些代码逻辑会被翻译为 C 执行，有较大的性能提升。在公司内部的实际业务测试来看，其性能远高于用户手写的作业。根据一些从现有业务改写过来的作业平均来看，其性能都比原用户代码提升了 100%+。开源版本的 benchmark 正在准备中。
简单易用 Bigflow 的接口表面看起来很像 Spark，但实际实用之后会发现 Bigflow 使用一些独特的设计使得 Bigflow 的代码更像是单机程序，例如，屏蔽了 partitioner 的概念，支持嵌套的分布式数据集等，使得其接口更加易于理解，并且拥有更强的代码可复用性。特别的，在许多需要优化的场景中，因为 Bigflow 可以进行自动的性能以及内存占用优化，所以用户可以避免许多因 OOM 或性能不足而必须进行的优化工作，降低用户的使用成本。
在这里，Python 是一等公民 我们目前原生支持的语言是 Python。使用 PySpark 时，有不少用户都困扰于 PySpark 的低效，或困扰于其不支持某些 cpython 库，或困扰于一些仅功能仅仅在 Scala 和 Java 中可用，在 PySpark 中暂时处于不可用状态。而在 Bigflow 中，Python 是一等公民（毕竟当前我们仅仅支持 Python），以上问题在 Bigflow 中都不是问题，性能、功能、易用性都对 Python 用户比较友好。

Bigflow 为什么要使用 Bigflow? 官网

http://bigflow.cloud/zh/index.html

CPU TFLOPS 计算

姚伟峰
yaoweifeng0301@126.com]
http://www.cnblogs.com/Matrix_Yao/

深度学习任务是一个计算密集型任务，所以很关注计算设备的算力指标，因为目前深度学习还是以float32为主流，所以落实到具体指标，就变成了大家都很关心TFLOPS(Tera FLoat point OPerations per Second)，这里，浮点操作指的就是浮点乘法和加法操作。这个在GPU上是明码写在spec里可以查的，但CPU目前并不会在spec中暴露TFLOPS指标。一种方法可以通过跑BLAS的benchmark来测量的，但这个一是需要一定的操作成本，二是受软件优化的影响（所以，如果出了问题就容易不知道这是硬件能力不行还是软件优化没到位）。需要一个对硬件能力的直接估计。
在深度学习任务中，计算量的绝大部分是由协处理器(co-processor)来完成的(如SSE，AVX2，AVX-512)，更具体地，是由FMA(Fused Multiply-Add)单元完成的。所以对CPU的TFLOPS估计一般可以通过以下公式来达成：

FMA做了啥?
FMA指令里做了以下操作。这里这些向量的长度由AVX寄存器长度决定，比如AVX-512就是16个float。 FMA每个clock可以做完一个以下操作，这里，，和都是长度为16的向量。

举个栗子
Xeon Skylake 8180，一个socket有28个core，每个core有一个AVX-512协处理器，每个AVX-512协处理器配有2个FMA，每个FMA每clock可以处理个单精度浮点乘加操作。所以：

frequency可以通过查spec得到，如下：

Alt text
所以单socket的峰值TFLOPS为：

所以一个dual-socket Skylake 8180的node的峰值TFLOPS应为：。

今天的关于浅析计算GMAC和GFLOPS和gmsc计算公式的分享已经结束，谢谢您的关注，如果想了解更多关于(转载)CNN 模型所需的计算力（FLOPs）和参数（parameters）数量计算、android – MarshMallow gmaps权限、Bigflow 为什么要使用 Bigflow? 分布式计算框架、CPU TFLOPS 计算的相关知识，请在本站进行查询。

本文标签：