接下来要分别概述以下内容：

１　首先什么是参数量，什么是计算量

２　如何计算　参数量，如何统计　计算量

３　换算参数量，把他换算成我们常用的单位，比如:mb

４　对于各个经典网络，论述他们是计算量大还是参数量，有什么好处

５　计算量，参数量分别对显存，芯片提出什么要求，我们又是怎么权衡

深度学习中模型参数量和计算量的理解与计算

  • 1 首先什么是计算量，什么是参数量
  • 2 如何计算：参数量，计算量
    • （１）针对于卷积层的
    • （２）针对于池化层：
    • （３）针对于全连接层：
    • （4）以 AlexNet为例，详解计算网络参数过程
      • 1-网络结构
        • 1.1-输入层（Input layer）
        • 1.2-卷积层（C1）
        • 1.3-卷积层（C2）
        • 1.4-卷积层（C3）
        • 1.5-卷积层（C4）
        • 1.6-卷积层（C5）
        • 1.7-全连接层（FC6）
        • 1.8-全连接层（FC7）
        • 1.9-输出层（Output layer）
      • 2-网络参数
        • 2.1-AlexNet神经元数量
        • 2.2-AlexNet参数数量
        • 2.3-FLOPs
  • 3 对于换算计算量
  • 4 对于各个经典网络：
    • (1)换算
    • (2)为什么模型之间差距这么大
    • (3)计算量
  • 5 计算量与参数量对于硬件要求
  • 6 计算量(FLOPs)和参数量(Params)
    • 6.1 第一种方法：thop
    • 6.2 第二种方法：ptflops
    • 6.3 第三种方法：pytorch_model_summary
    • 6.4 第四种方法：参数总量和可训练参数总量
  • 7 输入数据对模型的参数量和计算量的影响

1 首先什么是计算量，什么是参数量

计算量对应我们之前的时间复杂度，参数量对应于我们之前的空间复杂度，这么说就很明显了

也就是计算量要看网络执行时间的长短，参数量要看占用显存的量

其中最重要的衡量CNN 模型所需的计算力就是flops：

  • FLOPS： 注意全大写，是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度。是一个衡量硬件性能的指标。
  • FLOPs： 注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。

我们知道，通常我们去评价一个模型时，首先看的应该是它的精确度，当你精确度不行的时候，你和别人说我的模型预测的多么多么的快，部署的时候占的内存多么多么的小，都是白搭。但当你模型达到一定的精确度之后，就需要更进一步的评价指标来评价你模型：1）前向传播时所需的计算力，它反应了对硬件如GPU性能要求的高低；2）参数个数，它反应所占内存大小。为什么要加上这两个指标呢？因为这事关你模型算法的落地。比如你要在手机和汽车上部署深度学习模型，对模型大小和计算力就有严格要求。模型参数想必大家都知道是什么怎么算了，而前向传播时所需的计算力可能还会带有一点点疑问。所以这里总计一下前向传播时所需的计算力

2 如何计算：参数量，计算量

（１）针对于卷积层的


其中上面的公式是计算时间复杂度(计算量)，而下面的公式是计算空间复杂度(参数量)

对于卷积层：

（a）参数量就是

(kernel*kernel) *channel_input*channel_outputkernel*kernel 就是 weight * weight其中kernel*kernel ＝ 1个feature的参数量

（b）计算量就是

(kernel*kernel*map*map) *channel_input*channel_outputkernel*kernel 就是weight*weightmap*map是下个featuremap的大小，也就是上个weight*weight到底做了多少次运算其中kernel*kernel*map*map＝　1个feature的计算量

详细解释：

先说结论：卷积层 计算力消耗 等于上图中两个立方体 (绿色和橙色) 体积的乘积。即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

刚好等于图中两个立方体（绿色和橙色）体积的乘积。全连接层的算法也是一样。

（２）针对于池化层：

无参数

（３）针对于全连接层：

参数量＝计算量＝weight_in*weight_out

（4）以 AlexNet为例，详解计算网络参数过程

1-网络结构

AlexNet整体的网络结构包括：1个输入层（input layer）、5个卷积层（C1、C2、C3、C4、C5）、2个全连接层（FC6、FC7）和1个输出层（output layer）。下面对网络结构详细介绍。


上面这张图就是AlexNet的网络结构。初看这张图有的读者可能会觉得有个疑问：网络上部分是不是没有画完？其实不是的。鉴于当时的硬件资源限制，由于AlexNet结构复杂、参数很庞大，难以在单个GPU上进行训练。因此AlexNet采用两路GTX 580 3GB GPU并行训练。也就是说把原先的卷积层平分成两部分FeatureMap分别在两块GPU上进行训练（例如卷积层55x55x96分成两个FeatureMap：55x55x48）。上图中上部分和下部分是对称的，所以上半部分没有完全画出来。

值得一提的是，卷积层 C2、C4、C5中的卷积核只和位于同一GPU的上一层的FeatureMap相连，C3的卷积核与两个GPU的上一层的FeautureMap都连接。

1.1-输入层（Input layer）

原论文中，AlexNet的输入图像尺寸是224x224x3。但是实际图像尺寸为227x227x3。据说224x224可能是写paper时候的手误？还是后来对网络又做了调整？

1.2-卷积层（C1）

该层的处理流程是：卷积–>ReLU–>局部响应归一化（LRN）–>池化。

卷积：输入是227x227x3，使用96个11x11x3的卷积核进行卷积，padding=0，stride=4，根据公式：(input_size + 2 * padding - kernel_size) / stride + 1=(227+2*0-11)/4+1=55，得到输出是55x55x96。

ReLU： 将卷积层输出的FeatureMap输入到ReLU函数中。

局部响应归一化： 局部响应归一化层简称LRN，是在深度学习中提高准确度的技术方法。一般是在激活、池化后进行。LRN对局部神经元的活动创建竞争机制，使得其中响应比较大的值变得相对更大，并抑制其他反馈较小的神经元，增强了模型的泛化能力。

LRN的公式如下：

a为归一化之前的神经元，b为归一化之后的神经元；N是卷积核的个数，也就是生成的FeatureMap的个数；k，α，β，n是超参数，论文中使用的值是k=2，n=5，α=0.0001，β=0.75。

局部响应归一化的输出仍然是55x55x96。将其分成两组，每组大小是55x55x48，分别位于单个GPU上。

**池化：**使用3x3，stride=2的池化单元进行最大池化操作（max pooling）。注意这里使用的是重叠池化，即stride小于池化单元的边长。根据公式：(55+2*0-3)/2+1=27，每组得到的输出为27x27x48。

1.3-卷积层（C2）


该层的处理流程是：卷积–>ReLU–>局部响应归一化（LRN）–>池化。

卷积： 两组输入均是27x27x48，各组分别使用128个5x5x48的卷积核进行卷积，padding=2，stride=1，根据公式：(input_size + 2 * padding - kernel_size) / stride + 1=(27+2*2-5)/1+1=27，得到每组输出是27x27x128。

ReLU： 将卷积层输出的FeatureMap输入到ReLU函数中。

局部响应归一化： 使用参数k=2，n=5，α=0.0001，β=0.75进行归一化。每组输出仍然是27x27x128。

池化： 使用3x3，stride=2的池化单元进行最大池化操作（max pooling）。注意这里使用的是重叠池化，即stride小于池化单元的边长。根据公式：(27+2*0-3)/2+1=13，每组得到的输出为13x13x128。

1.4-卷积层（C3）


该层的处理流程是： 卷积–>ReLU

卷积：输入是13x13x256，使用384个3x3x256的卷积核进行卷积，padding=1，stride=1，根据公式：(input_size + 2 * padding - kernel_size) / stride + 1=(13+2*1-3)/1+1=13，得到输出是13x13x384。

ReLU：将卷积层输出的FeatureMap输入到ReLU函数中。将输出其分成两组，每组FeatureMap大小是13x13x192，分别位于单个GPU上。

1.5-卷积层（C4）


该层的处理流程是：卷积–>ReLU

卷积： 两组输入均是13x13x192，各组分别使用192个3x3x192的卷积核进行卷积，padding=1，stride=1，根据公式：(input_size + 2 * padding - kernel_size) / stride + 1=(13+2*1-3)/1+1=13，得到每组FeatureMap输出是13x13x192。

ReLU： 将卷积层输出的FeatureMap输入到ReLU函数中。

1.6-卷积层（C5）

该层的处理流程是：卷积–>ReLU–>池化

卷积： 两组输入均是13x13x192，各组分别使用128个3x3x192的卷积核进行卷积，padding=1，stride=1，根据公式：(input_size + 2 * padding - kernel_size) / stride + 1=(13+2*1-3)/1+1=13，得到每组FeatureMap输出是13x13x128。

ReLU： 将卷积层输出的FeatureMap输入到ReLU函数中。

池化：使用3x3，stride=2的池化单元进行最大池化操作（max pooling）。注意这里使用的是重叠池化，即stride小于池化单元的边长。根据公式：(13+2*0-3)/2+1=6，每组得到的输出为6x6x128。

1.7-全连接层（FC6）

该层的流程为：（卷积）全连接 -->ReLU -->Dropout （卷积）

全连接：输入为6×6×256，使用4096个6×6×256的卷积核进行卷积，由于卷积核尺寸与输入的尺寸完全相同，即卷积核中的每个系数只与输入尺寸的一个像素值相乘一一对应，根据公式：(input_size + 2 * padding - kernel_size) / stride + 1=(6+2*0-6)/1+1=1，得到输出是1x1x4096。既有4096个神经元，该层被称为全连接层。

ReLU： 这4096个神经元的运算结果通过ReLU激活函数中。

Dropout： 随机的断开全连接层某些神经元的连接，通过不激活某些神经元的方式防止过拟合。4096个神经元也被均分到两块GPU上进行运算。

1.8-全连接层（FC7）


该层的流程为：（卷积）全连接 -->ReLU -->Dropout

全连接： 输入为4096个神经元，输出也是4096个神经元（作者设定的）。

ReLU： 这4096个神经元的运算结果通过ReLU激活函数中。

Dropout： 随机的断开全连接层某些神经元的连接，通过不激活某些神经元的方式防止过拟合。

4096个神经元也被均分到两块GPU上进行运算。

1.9-输出层（Output layer）

该层的流程为：（卷积）全连接 -->Softmax

全连接： 输入为4096个神经元，输出是1000个神经元。这1000个神经元即对应1000个检测类别。

Softmax： 这1000个神经元的运算结果通过Softmax函数中，输出1000个类别对应的预测概率值。

2-网络参数

2.1-AlexNet神经元数量


整个AlexNet网络包含的神经元个数为：

290400 + 186624 + 64896 + 64896 + 43264 + 4096 + 4096 + 1000 = 659272

大约65万个神经元。

2.2-AlexNet参数数量


整个AlexNet网络包含的参数数量为：

34944 + 307456 + 885120 + 663936 + 442624 + 37752832 + 16781312 + 4096000 = 60964224

大约6千万个参数。

设定每个参数是32位浮点数，每个浮点数4个字节。这样参数占用的空间为：

60964224 x 4 = 243856896(Byte) = 238141.5(Kb) = 232.56(Mb)

参数共占用了大约232Mb的空间。

2.3-FLOPs

FLOPS（即“每秒浮点运算次数”，“每秒峰值速度”），是“每秒所执行的浮点运算次数”（floating-point operations per second）的缩写。它常被用来估算电脑的执行效能，尤其是在使用到大量浮点运算的科学计算领域中。正因为FLOPS字尾的那个S，代表秒，而不是复数，所以不能省略掉。
FLOPS， 即每秒浮点运算次数, 是每秒所执行的浮点运算次数（Floating-point operations per second；缩写：FLOPS）的简称，被用来评估电脑效能.

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

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

一个MFLOPS（megaFLOPS）等于每秒一佰万（=10^6）次的浮点运算，一个GFLOPS（gigaFLOPS）等于每秒十亿（=10^9）次的浮点运算，一个TFLOPS（teraFLOPS）等于每秒一万亿（=10^12）次的浮点运算，(1太拉)一个PFLOPS（petaFLOPS）等于每秒一千万亿（=10^15）次的浮点运算，一个EFLOPS（exaFLOPS）等于每秒一佰京（=10^18）次的浮点运算。

在AlexNet网络中，对于卷积层，FLOPS=num_params∗(H∗W)。其中num_params为参数数量，H*W为卷积层的高和宽。对于全连接层，FLOPS=num_params。


AlexNet整体的网络结构，包含各层参数个数、FLOPS如下图所示：

3 对于换算计算量

  • 一般一个参数是值一个float，也就是４个字节

  • 1kb=1024字节

4 对于各个经典网络：

(1)换算

以alexnet为例：

参数量：6000万

设每个参数都是float,也就是一个参数是4字节，

总的字节数是24000万字节

24000万字节= 24000万/1024/1024=228mb

(2)为什么模型之间差距这么大

这个关乎于模型的设计了，其中模型里面最费参数的就是全连接层，这个可以看alex和vgg,

alex,vgg有很多fc(全连接层)

resnet就一个fc

inceptionv1(googlenet)也是就一个fc

(3)计算量

densenet其实这个模型不大，也就是参数量不大，因为就1个fc

但是他的计算量确实很大，因为每一次都把上一个feature加进来，所以计算量真的很大

5 计算量与参数量对于硬件要求

计算量，参数量对于硬件的要求是不同的

计算量的要求是在于芯片的floaps（指的是gpu的运算能力）

参数量取决于显存大小

6 计算量(FLOPs)和参数量(Params)

6.1 第一种方法：thop

详见GitHub开源：https://github.com/Lyken17/pytorch-OpCounter

计算量：
FLOPs，FLOP时指浮点运算次数，s是指秒，即每秒浮点运算次数的意思，考量一个网络模型的计算量的标准。

参数量：
Params，是指网络模型中需要训练的参数总数。

使用说明：

  • 第一步：安装模块
pip install thop
  • 第二步：计算
# -- coding: utf-8 --
import torch
import torchvision
from thop import profile# Model
print('==> Building model..')
model = torchvision.models.alexnet(pretrained=False)dummy_input = torch.randn(1, 3, 224, 224)
flops, params = profile(model, (dummy_input,))
print('flops: ', flops, 'params: ', params)
print('flops: %.2f M, params: %.2f M' % (flops / 1000000.0, params / 1000000.0))

或者：

from torchvision.models import resnet18
from thop import profile
model = resnet18()
input = torch.randn(1, 3, 224, 224) #模型输入的形状,batch_size=1
flops, params = profile(model, inputs=(input, ))
print(flops/1e9,params/1e6) #flops单位G，para单位M

结果:

注意：

输入input的第一维度是批量(batch size)，批量的大小不回影响参数量， 计算量是batch_size=1的倍数
profile(net, (inputs,))的 (inputs,)中必须加上逗号，否者会报错

6.2 第二种方法：ptflops

# -- coding: utf-8 --
import torchvision
from ptflops import get_model_complexity_infomodel = torchvision.models.alexnet(pretrained=False)
flops, params = get_model_complexity_info(model, (3, 224, 224), as_strings=True, print_per_layer_stat=True)
print('flops: ', flops, 'params: ', params)

结果：

AlexNet(61.101 M, 100.000% Params, 0.716 GMac, 100.000% MACs, (features): Sequential(2.47 M, 4.042% Params, 0.657 GMac, 91.804% MACs, (0): Conv2d(0.023 M, 0.038% Params, 0.07 GMac, 9.848% MACs, 3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))(1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.027% MACs, inplace=True)(2): MaxPool2d(0.0 M, 0.000% Params, 0.0 GMac, 0.027% MACs, kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)(3): Conv2d(0.307 M, 0.503% Params, 0.224 GMac, 31.316% MACs, 64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))(4): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.020% MACs, inplace=True)(5): MaxPool2d(0.0 M, 0.000% Params, 0.0 GMac, 0.020% MACs, kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)(6): Conv2d(0.664 M, 1.087% Params, 0.112 GMac, 15.681% MACs, 192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(7): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.009% MACs, inplace=True)(8): Conv2d(0.885 M, 1.448% Params, 0.15 GMac, 20.902% MACs, 384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(9): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.006% MACs, inplace=True)(10): Conv2d(0.59 M, 0.966% Params, 0.1 GMac, 13.936% MACs, 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(11): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.006% MACs, inplace=True)(12): MaxPool2d(0.0 M, 0.000% Params, 0.0 GMac, 0.006% MACs, kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False))(avgpool): AdaptiveAvgPool2d(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, output_size=(6, 6))(classifier): Sequential(58.631 M, 95.958% Params, 0.059 GMac, 8.195% MACs, (0): Dropout(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, p=0.5, inplace=False)(1): Linear(37.753 M, 61.788% Params, 0.038 GMac, 5.276% MACs, in_features=9216, out_features=4096, bias=True)(2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)(3): Dropout(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, p=0.5, inplace=False)(4): Linear(16.781 M, 27.465% Params, 0.017 GMac, 2.345% MACs, in_features=4096, out_features=4096, bias=True)(5): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)(6): Linear(4.097 M, 6.705% Params, 0.004 GMac, 0.573% MACs, in_features=4096, out_features=1000, bias=True))
)
flops:  0.72 GMac params:  61.1 M

6.3 第三种方法：pytorch_model_summary

import torch
import torchvision
from pytorch_model_summary import summary# Model
print('==> Building model..')
model = torchvision.models.alexnet(pretrained=False)dummy_input = torch.randn(1, 3, 224, 224)
print(summary(model, dummy_input, show_input=False, show_hierarchical=False))

结果：

==> Building model..
-----------------------------------------------------------------------------Layer (type)         Output Shape         Param #     Tr. Param #
=============================================================================Conv2d-1      [1, 64, 55, 55]          23,296          23,296ReLU-2      [1, 64, 55, 55]               0               0MaxPool2d-3      [1, 64, 27, 27]               0               0Conv2d-4     [1, 192, 27, 27]         307,392         307,392ReLU-5     [1, 192, 27, 27]               0               0MaxPool2d-6     [1, 192, 13, 13]               0               0Conv2d-7     [1, 384, 13, 13]         663,936         663,936ReLU-8     [1, 384, 13, 13]               0               0Conv2d-9     [1, 256, 13, 13]         884,992         884,992ReLU-10     [1, 256, 13, 13]               0               0Conv2d-11     [1, 256, 13, 13]         590,080         590,080ReLU-12     [1, 256, 13, 13]               0               0MaxPool2d-13       [1, 256, 6, 6]               0               0AdaptiveAvgPool2d-14       [1, 256, 6, 6]               0               0Dropout-15            [1, 9216]               0               0Linear-16            [1, 4096]      37,752,832      37,752,832ReLU-17            [1, 4096]               0               0Dropout-18            [1, 4096]               0               0Linear-19            [1, 4096]      16,781,312      16,781,312ReLU-20            [1, 4096]               0               0Linear-21            [1, 1000]       4,097,000       4,097,000
=============================================================================
Total params: 61,100,840
Trainable params: 61,100,840
Non-trainable params: 0
-----------------------------------------------------------------------------

6.4 第四种方法：参数总量和可训练参数总量

import torch
import torchvision
from pytorch_model_summary import summary# Model
print('==> Building model..')
model = torchvision.models.alexnet(pretrained=False)pytorch_total_params = sum(p.numel() for p in model.parameters())
trainable_pytorch_total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)print('Total - ', pytorch_total_params)
print('Trainable - ', trainable_pytorch_total_params)

结果：

7 输入数据对模型的参数量和计算量的影响

# -- coding: utf-8 --
import torch
import torchvision
from thop import profile# Model
print('==> Building model..')
model = torchvision.models.alexnet(pretrained=False)dummy_input = torch.randn(1, 3, 224, 224)
flops, params = profile(model, (dummy_input,))
print('flops: ', flops, 'params: ', params)
print('flops: %.2f M, params: %.2f M' % (flops / 1000000.0, params / 1000000.0))
  • 输入数据：(1, 3, 224, 224)，一张224*224的RGB图像

  • 输入数据：(1, 3, 512, 512)，一张512*512的RGB图像

  • 输入数据：(8, 3, 224, 224)，八张224*224的RGB图像

【深度学习】深度学习中模型计算量(FLOPs)和参数量(Params)等的理解以及四种在python应用的计算方法总结相关推荐

  1. 卷积层计算量(FLOPS)和参数量的计算

    1.卷积参数量的计算,若卷积层的输入featuremap的维度为Cin×Hin×Win,卷积核的大小为K1×K2, padding=P1×P2, stride=S1×S2,卷积核(filter)的数量 ...

  2. 神经网络学习小记录37——Keras实现GRU与GRU参数量详解

    神经网络学习小记录37--Keras实现GRU与GRU参数量详解 学习前言 什么是GRU 1.GRU单元的输入与输出 2.GRU的门结构 3.GRU的参数量计算 a.更新门 b.重置门 c.全部参数量 ...

  3. 模型计算量(FLOPs)和参数量(Params)的理解

    (1)换算 以alexnet为例: 参数量:6000万 设每个参数都是float,也就是一个参数是4字节, 总的字节数是24000万字节 24000万字节= 24000万/1024/1024=228m ...

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

    目录 1. 定义 2. 实现方法 2.1. 计算参数量 2.2. 计算参数量和FLOPs 2.3. 计算推理时间(FPS) 3. 数据大小对参数量和FLOPs的影响 4. 参数量和FLOPs对于硬件要 ...

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

    关于 FLOPS.FLOPs.参数量的相关计算 一.FLOPS 二.FLOPs 2.1 2D 卷积运算 FLOPs Parameters 2.2 全连接层 FLOPs Parameters 2.3 B ...

  6. 模型的显存和参数量计算

    写在前面:以此记录关于模型显存和参数量的一些理解和计算. 首先是"运算量"和"参数量"两个概念: 参数量:这个比较好理解,例如卷积层中的卷积核c_i*k*k*n ...

  7. 【读点论文】A ConvNet for the 2020s，结合swin transformer的结构设计和训练技巧调整resnet网络，在类似的FLOPs和参数量取得更好一点的效果

    A ConvNet for the 2020s Abstract 视觉识别的"咆哮的20年代"始于视觉transformer(ViTs)的问世,它迅速取代ConvNets成为最先进 ...

  8. 预产期计算器在线计算生男生女计算机,预产期计算器生男生女的四种算法

    预产期计算器生男生女可以提前算出宝宝是男孩还是女孩,那么预测生男生女计算公式是怎么样的?计算的方法有下面的四种.有想要早点了解宝宝是男是女的准妈妈们就用生男生女计算器来算一下吧. 1. 口诀计算法 6 ...

  9. Caffe学习系列(17)：模型各层数据和参数可视化

    先用caffe对cifar10进行训练,将训练的结果模型进行保存,得到一个caffemodel,然后从测试图片中选出一张进行测试,并进行可视化. In [1]: #加载必要的库 import nump ...

最新文章

  1. 编码过程中的问题总结
  2. 我用代码来给你们分析一个赚钱的技巧
  3. 安卓的java无法访问网络_Android网络访问的基本方法
  4. java json float_java – Json解析问题(值自动更改为float)
  5. python生存曲线_Python从零开始第五章生物信息学⑤生存分析(log-rank)
  6. 人脸识别管理系统php源码,完整的人脸识别系统源代码
  7. python 漏洞扫描器_自动扫描全网漏洞的扫描器
  8. LittleVGL--07lv_obj基础对象介绍、API 接口、例程演示
  9. Android:根据阳历日期获取农历日期
  10. 太平洋电信首批通过SD-WAN Ready 2.0服务认证
  11. 《华尔街》观后笔记8——明暗创新
  12. 索尼美能达50微-版本区别及实拍测评（sony/minolta）50 f2.8 macro
  13. 中国最大–深圳企业列表
  14. 数学通道的应用(十五)-电阻的测量
  15. 管理会计中关于成本的几个概念
  16. Python合并两个列表的方法
  17. Spring框架的介绍以及搭建
  18. docker Swarm简介 新旧版本操作不一样docker run --rm swarm create和docker swarm --init
  19. 程序员薪资,如何分配，如何增长？？？
  20. h5---新增的结构性元素(header、footer、nav、article、section、aside、time、progress和meter元素进度条）

热门文章

  1. 苹果高调入局中低端市场，国产手机如何“坚守”与“转身”？
  2. 在HashSet集合中添加三个Person对象，把姓名相同的人当作同一个人，禁止重复添加。 提示：Person类中定义name和age属性，重写hashCode()方法和equals()方法，针对Pe
  3. 网游行业联合运营问题研究
  4. bgp整机柜租用有什么好处？
  5. 搭建企业级工单系统Jira8.x版本
  6. SEO黑帽技术 - 3天关键词快速上首页
  7. Chained row
  8. 【Windows】Window中的常用快捷键
  9. C：通过三边判断三角形种类
  10. Parsing error: No Babel config file detected for xxx Either disable config file checking...报错解决方法