devbox
天景科技苑
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用PyTorch构建神经网络，并使用thop计算参数和FLOPs

作者：天景科技苑 | 2024-08-13 10:08:28

赞

踩

使用PyTorch构建神经网络，并使用thop计算参数和FLOPs

文章目录

使用PyTorch构建神经网络，并使用thop计算参数和FLOPs

在这里插入图片描述

FLOPs和FLOPS区别

FLOPs（floating point operations）是指浮点运算次数，通常用来评估一个计算机算法或者模型的计算复杂度。在机器学习中，FLOPs通常用来衡量神经网络的计算复杂度，因为神经网络的计算主要由矩阵乘法和卷积操作组成，而这些操作都可以转化为浮点运算次数的形式进行计算。

FLOPS（floating point operations per second）是指每秒钟可以执行的浮点运算次数，通常用来评估一个计算机系统的计算能力。在机器学习中，FLOPS也可以用来衡量计算机系统的性能，因为神经网络的训练和推断需要大量的浮点运算，计算机系统的FLOPS越高，就越能够快速地完成神经网络的计算任务。

需要注意的是，FLOPs和FLOPS都是衡量计算复杂度和计算能力的指标，但它们的单位不同，FLOPs的单位是次，而FLOPS的单位是次/秒。FLOPs和FLOPS是两个不同的概念，FLOPs是指浮点运算次数，而FLOPS是指每秒钟可以执行的浮点运算次数。在实际应用中，我们通常会同时考虑这两个指标，以评估计算机算法或者模型在不同的计算机系统上的表现。

使用PyTorch搭建神经网络

整体代码
import torch
import torch.nn as nn
from torchsummary import summary
from thop import profile, clever_format


device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
class MyNet(nn.Module):
    def __init__(self, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
        self.relu1 = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)
        self.relu2 = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)
        self.relu3 = nn.ReLU(inplace=True)
        self.conv4 = nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1)
        self.relu4 = nn.ReLU(inplace=True)
        self.fc1 = nn.Linear(128*8*8, 1024)
        self.relu5 = nn.ReLU(inplace=True)
        self.fc2 = nn.Linear(1024, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.relu1(x)
        x = self.conv2(x)
        x = self.relu2(x)
        x = self.maxpool(x)
        x = self.conv3(x)
        x = self.relu3(x)
        x = self.conv4(x)
        x = self.relu4(x)
        x = x.view(-1, 128*8*8)
        x = self.fc1(x)
        x = self.relu5(x)
        x = self.fc2(x)
        return x
    
net = MyNet().to(device)
input_shape = (3, 224, 224)
summary(net, input_shape)

input_tensor = torch.randn(1, *input_shape).to(device)
flops, params = profile(net, inputs=(input_tensor,))
flops, params = clever_format([flops, params], "%.3f")
print("FLOPs: %s" %(flops))
print("params: %s" %(params))

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

这段代码是一个使用PyTorch实现的卷积神经网络。下面是一步一步的教程：

1. 导入必要的库
import torch
import torch.nn as nn
from torchsummary import summary
from thop import profile, clever_format

  • 1
  • 2
  • 3
  • 4

其中，torch是PyTorch深度学习框架的核心库，torch.nn是PyTorch中神经网络相关的模块，torchsummary是用于打印网络结构的库，thop是用于计算网络FLOPs和参数数量的库。

2. 定义神经网络模型
class MyNet(nn.Module):
    def __init__(self, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
        self.relu1 = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)
        self.relu2 = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)
        self.relu3 = nn.ReLU(inplace=True)
        self.conv4 = nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1)
        self.relu4 = nn.ReLU(inplace=True)
        self.fc1 = nn.Linear(128*8*8, 1024)
        self.relu5 = nn.ReLU(inplace=True)
        self.fc2 = nn.Linear(1024, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.relu1(x)
        x = self.conv2(x)
        x = self.relu2(x)
        x = self.maxpool(x)
        x = self.conv3(x)
        x = self.relu3(x)
        x = self.conv4(x)
        x = self.relu4(x)
        x = x.view(-1, 128*8*8)
        x = self.fc1(x)
        x = self.relu5(x)
        x = self.fc2(x)
        return x

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

这个网络模型包括了4个卷积层、2个全连接层和ReLU激活函数。其中，nn.Conv2d是PyTorch中的二维卷积层，nn.ReLU是ReLU激活函数层，nn.MaxPool2d是最大池化层，nn.Linear是全连接层。这个模型的输入是一个3通道、224x224大小的图像，输出是一个10维的向量，分别表示输入图像属于10个不同的类别的概率。

3. 打印网络结构
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
net = MyNet().to(device)
input_shape = (3, 224, 224)
summary(net, input_shape)

  • 1
  • 2
  • 3
  • 4

这里我们首先根据设备是否支持CUDA来选择使用CPU或GPU，然后将模型实例化为net并将其放到设备上。接着，我们定义输入图像的形状为(3, 224, 224)，然后使用summary函数打印网络的结构信息，包括每一层的输入和输出形状、参数数量等。

4. 计算网络FLOPs和参数数量
input_tensor = torch.randn(1, *input_shape).to(device)
flops, params = profile(net, inputs=(input_tensor,))
flops, params = clever_format([flops, params], "%.3f")
print("FLOPs: %s" %(flops))
print("params: %s" %(params))

  • 1
  • 2
  • 3
  • 4
  • 5

这里我们使用随机生成的输入图像进行前向传播，然后使用profile函数计算网络的FLOPs和参数数量。inputs参数接受一个元组，其中包含了网络的输入，这里我们将随机生成的输入图像封装成一个元组传入。计算完成后，使用clever_format函数将FLOPs和参数数量格式化成易读的字符串形式，最后打印出来。

5. 结果如下

在这里插入图片描述

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 224, 224]           1,792
              ReLU-2         [-1, 64, 224, 224]               0
            Conv2d-3         [-1, 64, 224, 224]          36,928
              ReLU-4         [-1, 64, 224, 224]               0
         MaxPool2d-5         [-1, 64, 112, 112]               0
            Conv2d-6        [-1, 128, 112, 112]          73,856
              ReLU-7        [-1, 128, 112, 112]               0
            Conv2d-8        [-1, 128, 112, 112]         147,584
              ReLU-9        [-1, 128, 112, 112]               0
           Linear-10                 [-1, 1024]       8,389,632
             ReLU-11                 [-1, 1024]               0
           Linear-12                   [-1, 10]          10,250
================================================================
Total params: 8,660,042
Trainable params: 8,660,042
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 153.14
Params size (MB): 33.04
Estimated Total Size (MB): 186.75
----------------------------------------------------------------
[INFO] Register count_convNd() for <class 'torch.nn.modules.conv.Conv2d'>.
[INFO] Register zero_ops() for <class 'torch.nn.modules.activation.ReLU'>.
[INFO] Register zero_ops() for <class 'torch.nn.modules.pooling.MaxPool2d'>.
[INFO] Register count_linear() for <class 'torch.nn.modules.linear.Linear'>.
FLOPs: 6.357G
params: 8.660M

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

这段代码定义了一个简单的卷积神经网络模型，然后使用thop库计算模型的FLOPs（浮点运算次数）和参数数量。

手动计算params

好的，这里是每一层的参数计算公式：

  • Conv2d层：参数数量 = (输入通道数 x 卷积核高度 x 卷积核宽度 x 输出通道数) + 输出通道数
  • Linear层：参数数量 = 输入大小 x 输出大小 + 输出大小
  • 没有参数的层（如ReLU和MaxPool）不需要计算参数数量。

具体来说，在这个神经网络中，每一层的参数计算公式和参数数量如下：

  • Conv2d-1：(3 x 3 x 3 x 64) + 64 = 1,792
  • ReLU-2：没有参数
  • Conv2d-3：(3 x 3 x 64 x 64) + 64 = 36,928
  • ReLU-4：没有参数
  • MaxPool2d-5：没有参数
  • Conv2d-6：(3 x 3 x 64 x 128) + 128 = 73,856
  • ReLU-7：没有参数
  • Conv2d-8：(3 x 3 x 128 x 128) + 128 = 147,584
  • ReLU-9：没有参数
  • Linear-10：(128 x 56 x 56 x 1024) + 1024 = 8,389,632
  • ReLU-11：没有参数
  • Linear-12：(1024 x 10) + 10 = 10,250

总参数数为8,660,042个。

手动计算FLOPs

Thop（PyTorch-OpCounter）是一个用于计算PyTorch模型浮点运算量（FLOPs）的库，它可以自动计算模型中每个操作的FLOPs，包括卷积层、池化层、全连接层等。

在Thop中，FLOPs的计算基于每个操作的输入张量大小、输出张量大小以及操作的参数数量。具体地，对于一个卷积层，FLOPs的计算公式为：

F L O P s = 2 × k 2 × C i n × C o u t × H o u t × W o u t s t r i d e 2 FLOPs = 2 \times k^2 \times C_{in} \times C_{out} \times \frac{H_{out} \times W_{out}}{stride^2} FLOPs=2×k2×Cin​×Cout​×stride2Hout​×Wout​​

其中， k k k 是卷积核大小， C i n C_{in} Cin​ 是输入通道数， C o u t C_{out} Cout​ 是输出通道数， H o u t H_{out} Hout​ 和 W o u t W_{out} Wout​ 是输出特征图的高度和宽度， s t r i d e stride stride 是步幅。这个公式中的常数2表示每个卷积操作需要2次乘法（一个是卷积核和输入的卷积，另一个是卷积结果和偏置的加法），因此需要乘以2。

对于其他层类型，Thop使用不同的公式计算FLOPs。例如，对于全连接层，FLOPs的计算公式为：

F L O P s = 2 × C i n × C o u t FLOPs = 2 \times C_{in} \times C_{out} FLOPs=2×Cin​×Cout​

其中， C i n C_{in} Cin​ 和 C o u t C_{out} Cout​ 分别是输入和输出的特征数量。

通过使用Thop库，您可以方便地计算模型的总体FLOPs，以评估模型的计算复杂度和性能。

池化层和ReLU层的计算复杂度相对简单，可以用以下公式进行计算：

对于池化层，假设输入特征图大小为 W 1 × H 1 W_1\times H_1 W1​×H1​，池化尺寸为 k × k k\times k k×k，步幅为 s s s，则池化层的FLOPs计算公式为：

F L O P s = W 2 × H 2 × C × k 2 FLOPs = W_2\times H_2\times C\times k^2 FLOPs=W2​×H2​×C×k2

其中， W 2 = ⌊ ( W 1 − k ) / s ⌋ + 1 W_2=\lfloor(W_1-k)/s\rfloor+1 W2​=⌊(W1​−k)/s⌋+1， H 2 = ⌊ ( H 1 − k ) / s ⌋ + 1 H_2=\lfloor(H_1-k)/s\rfloor+1 H2​=⌊(H1​−k)/s⌋+1， C C C 是输入特征图的通道数。这个公式中的常数 k 2 k^2 k2表示每个池化操作需要 k × k k\times k k×k次取最大值。

对于ReLU层，假设输入特征图大小为 W × H × C W\times H\times C W×H×C，ReLU层的计算量可以近似为：

F L O P s = W × H × C FLOPs = W\times H\times C FLOPs=W×H×C

这是因为ReLU激活函数的计算本身非常简单，只需要比较输入数据与0，然后保留大于0的值即可，因此单个ReLU激活函数的计算量可以视为常数。

需要注意的是，这些公式只是近似计算，实际的计算复杂度可能会因为不同实现方式、硬件平台等因素而有所不同。对于更准确的计算，可以使用一些工具库（如Thop）来进行计算。

为了解释为什么得到的FLOPs是6.357G，我们需要逐层分析模型中的计算量。以下是计算步骤（不考虑relu和pool层）：

  1. conv1: (3 × 3 × 3) × 64 × 224 × 224 = 86,704,128 FLOPs
  2. relu1: 0 FLOPs（ReLU激活函数的计算量通常不计入FLOPs） # 3211264
  3. conv2: (3 × 3 × 64) × 64 × 224 × 224 = 1,849,688,064 FLOPs
  4. relu2: 0 FLOPs # 3211264
  5. maxpool: 0 FLOPs（池化操作的计算量通常不计入FLOPs） # 32111254
  6. conv3: (3 × 3 × 64) × 128 × 112 × 112 = 924,844,032 FLOPs
  7. relu3: 0 FLOPs 128112112=1605632
  8. conv4: (3 × 3 × 128) × 128 × 112 × 112 = 1,849,688,064 FLOPs
  9. relu4: 0 FLOPs # 1605632
  10. fc1: 128 × 8 × 8 × 1024 = 8,388,608 FLOPs
  11. relu5: 0 FLOPs # 这个计算FLOPs我懵了。按20480吧
  12. fc2: 1024 × 10 = 10,240 FLOPs

将各层的FLOPs相加，得到总的FLOPs：

86,704,128 + 1,849,688,064 + 924,844,032 + 1,849,688,064 + 8,388,608 + 10240 = 4,719,323,136 FLOPs

然后将FLOPs转换为GigaFLOPs（10^9 FLOPs）：

4,719,323,136 / 10^9 ≈ 4.719 GigaFLOPs

4.719远远不等于6.357啊！

如果按照全部乘以2，又变成9点多了，又远远超过6.357了。

听说profile算出来的FLOPs也需要乘以2。按照这么想的话，咱们手动计算的结果不乘2应该和thop计算出来的相当。但是结果相当打脸，远远不等。

所以relu层和pool层肯定带入FLOPs了。

加粗样式
为了计算方便和准确性，实际并没有多大意义。你可太会说话了。

恩。。。怎么说呢

注意

显然，结果与代码中计算得到的6.357G不符。这就有点奇怪了？

消失的1.638G去哪里了？

就是把relu层和池化层的全部加上也不够啊！加上relu和池化层的结果如下。

86,704,128 + 3211264 + 1,849,688,064 + 3211254 + 32111254 + 924,844,032 + 1605632 + 1,849,688,064 + 1605632 + 8,388,608 + 10240 + 10240 = 4,761,078,412 FLOPs

relu和maxpool再怎么套公式，也算不上去了，加不了那么多。算了。。。。以后有时间再慢慢算吧，谁和thop计算的一样可以留言公式，我去学习一下。

G去哪里了？

就是把relu层和池化层的全部加上也不够啊！加上relu和池化层的结果如下。

86,704,128 + 3211264 + 1,849,688,064 + 3211254 + 32111254 + 924,844,032 + 1605632 + 1,849,688,064 + 1605632 + 8,388,608 + 10240 + 10240 = 4,761,078,412 FLOPs

relu和maxpool再怎么套公式，也算不上去了，加不了那么多。算了。。。。以后有时间再慢慢算吧，谁和thop计算的一样可以留言公式，我去学习一下。

**可能原因：**这可能是因为thop库在计算FLOPs时考虑了一些其他因素，relu和pool也计算进去了，而且占比还挺多，莫名增加了1.638G。因此，实际计算得到的FLOPs可能会与手动计算的结果有所不同。即使如此，手动计算的结果可以帮助我们理解FLOPs的大致数量级。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/天景科技苑/article/detail/974322
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号