cnn中关于FLOPS的理解及计算

最新推荐文章于 2024-09-06 00:57:10 发布
最新推荐文章于 2024-09-06 00:57:10 发布
阅读量2.5k 收藏 10
点赞数
分类专栏： onnx 文章标签： ncnn cnn 卷积神经网络 flops
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tbl1234567/article/details/109240855
版权
相关概念

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

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

MACs：乘加运算（Multiplication and Accumulation），相当于2次浮点运算，硬件支持乘加指令可加快计算速度。

OP的计算
1. conv 计算
def compute_conv2d_flops(mod, input_shape = None, output_shape = None, macs = False):
    _, cin, _, _ = input_shape
    _, _, h, w, = output_shape
    
    w_cout, w_cin, w_h, w_w =  mod.weight.data.shape

    if mod.groups != 1:
        input_channels = 1
    else:
        assert cin == w_cin
        input_channels = w_cin

    output_channels = w_cout
    stride = mod.stride[0]
#     flops = h * w * output_channels * input_channels * w_h * w_w / (stride**2)
    flops = h * w * output_channels * input_channels * w_h * w_w

    
    if not macs:
        flops_bias = output_shape[1:].numel() if mod.bias is not None else 0
        flops = 2 * flops + flops_bias
        
    return int(flops)
2. fc 计算
def compute_fc_flops(mod, input_shape = None, output_shape = None, macs = False):
    ft_in, ft_out =  mod.weight.data.shape
    flops = ft_in * ft_out
    
    if not macs:
        flops_bias = ft_out if mod.bias is not None else 0
        flops = 2 * flops + flops_bias
        
    return int(flops)

def compute_bn2d_flops(mod, input_shape = None, output_shape = None, macs = False):
    # subtract, divide, gamma, beta
    flops = 2 * input_shape[1:].numel()
    
    if not macs:
        flops *= 2
    
    return int(flops)
3. relu 计算
def compute_relu_flops(mod, input_shape = None, output_shape = None, macs = False):
    
    flops = 0
    if not macs:
        flops = input_shape[1:].numel()

    return int(flops)
4. maxpool 计算
def compute_maxpool2d_flops(mod, input_shape = None, output_shape = None, macs = False):

    flops = 0
    if not macs:
        flops = mod.kernel_size**2 * output_shape[1:].numel()

    return flops
5. averagepool 计算
def compute_avgpool2d_flops(mod, input_shape = None, output_shape = None, macs = False):

    flops = 0
    if not macs:
        flops = mod.kernel_size**2 * output_shape[1:].numel()

    return flops
6. softmax 计算
def compute_softmax_flops(mod, input_shape = None, output_shape = None, macs = False):
    
    nfeatures = input_shape[1:].numel()
    
    total_exp = nfeatures # https://stackoverflow.com/questions/3979942/what-is-the-complexity-real-cost-of-exp-in-cmath-compared-to-a-flop
    total_add = nfeatures - 1
    total_div = nfeatures
    
    flops = total_div + total_exp
    
    if not macs:
        flops += total_add
        
    return flops
另一种计算方法–感觉更合理
'''
A simplified 3-D Tensor (channels, height, weight) for convolutional neural networks.
'''
class Tensor(object):
    def __init__(self, c, h, w):
        self.c = c
        self.h = h
        self.w = w


    def equals(self, other):
        return self.c == other.c and self.h == other.h and self.w == other.w


    def broadcastable(self, other):
        return (self.c % other.c == 0 or other.c % self.c == 0) and \
               (self.h % other.h == 0 or other.h % self.h == 0) and \
               (self.w % other.w == 0 or other.w % self.w == 0)


'''
Calculate the single-sample inference-time params and FLOPs of a convolutional
neural network with PyTorch-like APIs.
To calculate the params and FLOPs of certain network architecture, CNNCalculator
needs to be inherited and the network needs to be defined as in PyTorch.
For convenience, some basic operators are pre-defined and other modules can be
defined in a similar way. Parameters and FLOPs in Batch Normalization and other
types of layers are also computed. If only Convolutional and Linear layers are
considered, please modify the code.
Refer to `MobileNet.py` for details.
'''
class CNNCalculator(object):
    def __init__(self, only_mac=False):
        self.params = 0
        self.flops = 0
        self.only_mac = only_mac


    def calculate(self, *inputs):
        raise NotImplementedError


    def Conv2d(self, tensor, out_c, size, stride=1, padding=0, groups=1, bias=True, name='conv'):
        if type(size) == int:
            size = (size, size)
        if type(stride) == int:
            stride = (stride, stride)
        if type(padding) == int:
            padding = (padding, padding)
        assert type(size) == tuple and len(size) == 2, 'illegal size parameters'
        assert type(stride) == tuple and len(stride) == 2, 'illegal stride parameters'
        assert type(padding) == tuple and len(padding) == 2, 'illegal padding parameters'
        size_h, size_w = size
        stride_h, stride_w = stride
        padding_h, padding_w = padding

        in_c = tensor.c
        out_h = (tensor.h - size_h + 2 * padding_h) // stride_h + 1
        out_w = (tensor.w - size_w + 2 * padding_w) // stride_w + 1
        assert in_c % groups == 0 and out_c % groups == 0, 'in_c and out_c must be divisible by groups'

        self.params += out_c * in_c // groups * size_h * size_w
        self.flops += out_c * out_h * out_w * in_c // groups * size_h * size_w
        if bias:
            self.params += out_c
            self.flops += out_c * out_w * out_h

        return Tensor(out_c, out_h, out_w)


    def BatchNorm2d(self, tensor, name='batch_norm'):
        return tensor
        # Batch normalization can be combined with the preceding convolution, so there are no FLOPs.
        # out_c = tensor.c
        # out_h = tensor.h
        # out_w = tensor.w

        # if self.only_mac:
            # self.params += 4 * out_c
            # self.flops += out_c * out_h * out_w
        # return Tensor(out_c, out_h, out_w)


    def ReLU(self, tensor, name='relu'):
        out_c = tensor.c
        out_h = tensor.h
        out_w = tensor.w

        if not self.only_mac:
            self.flops += out_c * out_h * out_w
        return Tensor(out_c, out_h, out_w)


    def Sigmoid(self, tensor, name='relu'):
        out_c = tensor.c
        out_h = tensor.h
        out_w = tensor.w

        if not self.only_mac:
            self.flops += out_c * out_h * out_w
        return Tensor(out_c, out_h, out_w)


    def Pool2d(self, tensor, size, stride=1, padding=0, name='pool'):
        if type(size) == int:
            size = (size, size)
        if type(stride) == int:
            stride = (stride, stride)
        if type(padding) == int:
            padding = (padding, padding)
        assert type(size) == tuple and len(size) == 2, 'illegal size parameters'
        assert type(stride) == tuple and len(stride) == 2, 'illegal stride parameters'
        assert type(padding) == tuple and len(padding) == 2, 'illegal padding parameters'
        size_h, size_w = size
        stride_h, stride_w = stride
        padding_h, padding_w = padding

        out_c = tensor.c
        out_h = (tensor.h - size_h + 2 * padding_h) // stride_h + 1
        out_w = (tensor.w - size_w + 2 * padding_w) // stride_w + 1
        if not self.only_mac:
            self.flops += out_c * out_h * out_w * size_h * size_w
        return Tensor(out_c, out_h, out_w)


    def AvgPool2d(self, tensor, size, stride=1, padding=0, name='avg_pool'):
        return self.Pool2d(tensor, size, stride=stride, padding=padding, name=name)


    def MaxPool2d(self, tensor, size, stride=1, padding=0, name='max_pool'):
        return self.Pool2d(tensor, size, stride=stride, padding=padding, name=name)


    def GlobalAvgPool2d(self, tensor, name='global_avg_pool'):
        size = (tensor.h, tensor.w)
        return self.AvgPool2d(tensor, size)


    def GlobalMaxPool2d(self, tensor, name='global_max_pool'):
        size = (tensor.h, tensor.w)
        return self.MaxPool2d(tensor, size)


    def Linear(self, tensor, out_c, name='fully_connected'):
        in_c = tensor.c
        out_h = tensor.h
        out_w = tensor.w
        assert out_h == 1 and out_w == 1, 'out_h or out_w is greater than 1 in Linear layer.'
        self.params += in_c * out_c
        self.flops += in_c * out_c
        return Tensor(out_c, out_h, out_w)


    def Concat(self, tensors, name='concat'):
        out_c = 0
        out_h = tensors[0].h
        out_w = tensors[0].w
        for tensor in tensors:
            assert tensor.h == out_h and tensor.w == out_w, 'tensor dimensions mismatch in Concat layer.'
            out_c += tensor.c
        return Tensor(out_c, out_h, out_w)


    def MultiAdd(self, tensor, other, name='multi_add'):
        assert tensor.broadcastable(other), 'tensor dimensions mismatch in Add layer.'
        out_c = tensor.c
        out_h = tensor.h
        out_w = tensor.w
        if not self.only_mac:
            self.flops += out_c * out_h * out_w
        return Tensor(out_c, out_h, out_w)


    def Add(self, tensor, other, name='add'):
        return self.MultiAdd(tensor, other, name=name)


    def Multi(self, tensor, other, name='multi'):
        return self.MultiAdd(tensor, other, name=name)


    def SplitBySize(self, tensor, sizes, name='split_by_size'):
        assert sum(sizes) == tensor.c, 'sizes and tensor.c do not match.'
        return [Tensor(c, tensor.h, tensor.w) for c in sizes]

转载请注明出处:https://blog.csdn.net/tbl1234567.作者:陶表犁

陶表犁
关注
专栏目录
计算机视觉 | 面试题：13、CNN网络各种层的FLOPs和参数量paras计算
Mrrunsen的博客
09-09 399
FLOPs 这里先注意一下FLOPs的写法，不要弄混了： FLOPS(全大写)：是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度，是一个衡量硬件性能的指标。 FLOPs(s小写)：，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量，可以用来衡量算法/模型的复杂度，也就是我们这里要讨论的。 标准卷积层的FLOPs 考虑bias：(2∗Cint∗k2)∗Cout∗H∗W(2*C_{int
CNN网络各种层的FLOPs和参数量paras计算
YeeKo的博客
05-04 3900
目录FLOPs标准卷积层的FLOPs深度可分离卷积的FLOPs池化层的FLOPS全局池化一般池化全连接层的FLOPs激活层的FLOPsReLUsigmoid参数量卷积层的参数量深度可分离卷积的参数量池化层的参数量全连接层的参数量参考资料 FLOPs 这里先注意一下FLOPs的写法，不要弄混了： FLOPS(全大写)：是floating point operations per second的缩写...
关于CNN FLOPs的计算
calvinpaean的博客
07-16 933
在评估一个CNN的计算复杂度时，浮点数计算是一个常用的衡量指标。注意本文介绍的主要是MAC(memory access cost)，即乘加法操作，在一些论文中是仅仅考虑乘法操作的。 在常规计算中，通常不考虑非线性函数的计算量，对于卷积操作（带bias）： FLOPs=2×(HWCinK2+1)Cout=2(HWK2CinCout+Cout)FLOPs = 2\times (HWC_{in}K^2 ...
概念|FLOPs、FLOPS还是MACs？
最新发布
weixin_43833206的博客
09-06 488
如何区分FLOPs、FLOPS还是MACs？
如何计算CNN的FLOPs
David糖的博客
05-10 495
不要把 FLOPS 和 FLOPs 搞混，FLOPS是硬件的计算速度单位，本质是一个速度单位。而 FLOPs 是一个数量单位，描述的是神经网络的计算量。 需要注意的是 FLOPs 不区分运算精度，它单纯的统计乘法和加法的次数。而且只包含测试阶段的运算量，不包含训练过程中的反响传播计算量。
CNN中FLOPs的计算
急流勇进
02-27 944
看到有人对flops有疑惑，先捋清这个概念。FLOPS：注意全大写，是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度。是一个衡量硬件性能的指标。FLOPs：注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。网上打字很容易全小写，造成混...
CNN中FLOPs计算
何进的博客
04-17 4099
转载地址：https://blog.csdn.net/sinat_34460960/article/details/84779219 在这之前我们先看一下CNN的前向传播计算公式，便于理解什么是parameters和FLOPs，这里参考Andrew老师课堂上的课件，如下： 前向传播过程其实就是将输入或上层输出左乘以一个W，然后加上一个b，最后使用合适的\sigma函数进行激活的过程，...
CNN 模型的参数（parameters）数量和浮点运算数量（FLOPs）是怎么计算的
求真、务实
11-26 8396
CNN 模型所需的计算力（flops）和参数（parameters）数量是怎么计算的？ #1 首先说明一下概念 1、FLOPS FLOPS：注意全大写，是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度（。是一个衡量硬件性能的指标。 2、FLOPs FLOPs：注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。 #FLOPS FLOPS：即“每秒
22_CNN网络各种层的FLOPs和参数量paras计算1
08-03
理解和计算CNN的FLOPs（Floating Point Operations）和参数量对于优化模型性能、减小计算资源需求至关重要。本文将详细介绍如何计算CNN各层的FLOPs和参数量。 首先，FLOPs是一个衡量计算复杂度的指标，它表示的是每...
深度学习中parameters个数和FLOPS计算（以CNN中经典的AlexNet网络结构为例）
Never-Giveup的博客
01-30 2万+
面试时遇到过计算神经网路的参数个数以及FLOPS计算，当时对FLOPS计算比较蒙圈，这两天又看到了美团发布的技术博客对深度学习计算量的解决方案中又出现了FLOPS相关概念，所以通过查阅好多大佬的博客把FLOPS的计算问题理解清楚。 前言 深度学习的计算量 上表列举了，ImageNet图像识别中常见算法的模型大小以及单张图片一次训练（One Pass）所需要的计算量。 自2012年，Hinton的...
CNN中参数量和FLOPs计算
weixin_42615068的博客
08-07 795
对于一个卷积层，假设其大小为h×w×cin×couth×w×c_{in}×c_{out}h×w×cin​×cout​（其中cinc_{in}cin​为input channel, coutc_{out}cout​为output channel），输出的feature map尺寸为 H′×W′H^{'}×W^{'}H′×W′，则该卷积层的 paras=h×w×ci...
【指标原理】CNN和ViT的FLOPs、参数量计算
cjy_colorful0806的博客
03-14 2354
FLOPs（Floating Point Operations）是浮点运算次数的缩写，其计算包括所有的浮点数加法、减法、乘法和除法运算。在深度学习领域，FLOPs特别用来量化一个神经网络模型进行一次前向传播所需的浮点运算数量，这对于评估模型的计算效率和资源需求非常有用。
CNN中计算量FLOPs的计算
wmzjzwlzs的专栏
05-05 999
转自：CNN中计算量FLOPs的计算 - outthinker - 博客园 1、FLOPs的概念：全称是floating point operations per second，意指每秒浮点运算次数，即用来衡量硬件的计算性能；在CNN中用来指浮点运算次数； 2、计算过程： 如上，根据上图来计算第一层卷积层的FLOPs： 对于某个卷积层，它的FLOPs数量为：，其中表示该层参数的数目。 这里AlexNet网络第一卷积层为例，它的FLOPs数目为：。 ...
卷积神经网络CNN中FLOPs的概念和计算
学无止境、积少成多、厚积薄发
07-15 4711
1.什么是FLOPs？ FLOPs全称：floating point operation per second 意思是每秒浮点运算次数，理解为计算速度，是一个用来衡量硬件计算性能的指标。 在CNN中用来指浮点运算次数； 2.如何计算？ 在AlexNet中某一次卷积过程中， 输入特征图大小：[C_in, H_in, W_in] = 3 * 224 * 224 卷积核大小：[C_in, K_H, K_...
CNN卷积神经网络模型的参数量、计算量计算方法（概念版）
IT菜鸟
10-30 9031
CNN卷积神经网络模型的参数量、计算量计算方法（概念版）
ConvTranspose2d（逆卷积）的原理和计算
AI浩
02-09 1万+
原理 解释什么是逆卷积，先得明白什么是卷积。 先说卷积：对于一个图片A，设定它的高度和宽度分别为Height，Width，通道数为Channels。 然后我们用卷积核（kernel * kernel）去做卷积，（这里设定卷积核为正方形，实际长方形也可以类推，相信我，不会很难），步长为stride(同样的，不区分高宽方向)，做padding。卷积后得到B。 重复上面的话就是利用一个卷积操作将A变成B。 那么，在这个前提下，逆卷积就是将B变成A。 那么怎么规定卷积核这些参数呢，这些又是什么意思？ 对于
深度学习中的FLOPs是什么？如何计算的？
热门推荐
种花家的奋斗兔的博客
03-16 2万+
1.区分FLOPs和FLOPS FLOPS：注意全大写，是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度。是一个衡量硬件性能的指标。 FLOPs：注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。 注意在深度学习中，我们用的是F...
FLOPS 与 FLOPs 的区别解析
SimpleLearning
03-21 1929
概念不同：FLOPS 表示每秒浮点运算次数，是计算设备的计算性能指标；而 FLOPs 表示模型中的浮点运算操作总数，是模型计算复杂度的指标。应用不同：FLOPS 用于评估计算设备的处理能力和性能；FLOPs 用于衡量模型的计算复杂度和计算量。单位不同：FLOPS 的单位是每秒浮点运算次数（如 TFLOPS、GFLOPS）；FLOPs 的单位是浮点运算操作总数（如 MFLOPs、GFLOPs）。水平有限，有问题随时联系；
pytorch中FLOP FLOPS FLOPs的计算程序
04-29
在PyTorch中，可以使用`torch.flops`函数来计算模型的浮点运算量（FLOPS）。 以下是一个使用`torch.flops`函数计算FLOPS的示例程序： ```python import torch import torch.nn as nn class MyModel(nn.Module): ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值