卷积神经网络参数量计算及显存占用

最新推荐文章于 2024-05-16 18:10:54 发布
最新推荐文章于 2024-05-16 18:10:54 发布
阅读量2.6k 收藏 20
点赞数 4
分类专栏： 深度学习

参数量的计算

卷积神经网络的参数位于卷积层和全连接层，其中一个全连接层要比卷积层多好多参数。

显存占用

显存占用主要是模型(卷积层和全连接层的参数所占的显存)和各层的输出所占的显存。

下面以VGG16为例来讲解。
在这里插入图片描述
各层的具体情况如下

网络层（操作）输入filterstridepadding输出参数量计算公式参数量显存占用
Input224x224x3224x224x30224x224x3
Conv3-64224x224x33x3x6411224x224x643x3x3x64 (+ 64)(括号里面是bias项）1728(1792)224x224x64
Conv3-64224x224x643x3x6411224x224x643x3x64x64 (+ 64)36864(36928)224x224x64
MaxPool2224x224x642x220112x112x640112x112x64
Conv3-128112x112x643x3x12811112x112x1283x3x64x128 (+ 128)73728(73856)112x112x128
Conv3-128112x112x1283x3x12811112x112x1283x3x128x128 (+ 128)147456(147584)112x112x128
MaxPool2112x112x1282x22056x56x128056x56x128
Conv3-25656x56x1283x3x2561156x56x2563x3x128x256 (+ 256)294912(295168)56x56x256
Conv3-25656x56x2563x3x2561156x56x2563x3x256x256 (+ 256)589824(590080)56x56x256
Conv3-25656x56x2563x3x2561156x56x2563x3x256x256 (+ 256)589824(590080)56x56x256
MaxPool256x56x2562x22028x28x256028x28x256
Conv3-51228x28x2563x3x5121128x28x5123x3x256x512 (+ 512)1179648(1180160)28x28x512
Conv3-51228x28x5123x3x5121128x28x5123x3x512x512 (+ 512)2359296(2359808)28x28x512
Conv3-51228x28x5123x3x5121128x28x5123x3x512x512 (+ 512)2359296(2359808)28x28x512
MaxPool228x28x5122x22014x14x512014x14x512
Conv3-51214x14x5123x3x5121114x14x5123x3x512x512 (+ 512)2359296(2359808)14x14x512
Conv3-51214x14x5123x3x5121114x14x5123x3x512x512 (+ 512)2359296(2359808)14x14x512
Conv3-51214x14x5123x3x5121114x14x5123x3x512x512 (+ 512)2359296(2359808)14x14x512
MaxPool214x14x5122x2207x7x51207x7x512
FC17x7x51240967x7x512x4096 (+ 4096)102760448(102764544)4096
FC2409640964096*4096 (+ 4096)16777216(16781312)4096
FC3409610004096*1000 (+ 1000)4096000(4097000)1000

总共参数量
138,344,128(138357544)

占用显存

参数占用显存
138344128 *4 /1024 /1024 = 527.74MB ~ 528MB(一共有138344128个参数，每个都是float32类型的，即一个占用32位=4bytes)

模型占用显存
15,237,608 *4 /1024 /1024 = 58.12MB / image

在这里插入图片描述
128 * 58.12 MB * 2（这里乘以2，因为forward和backward）

验证代码

# bias = False
import torch
import torch.nn as nn

class VGG(nn.Module):
    def __init__(self, vgg_name, cfg, num_classes=10, bn=False):
        super(VGG, self).__init__()
        self.vgg_base = self.make_layer(cfg, bn)

        if vgg_name == 'vgg16_C':
            self.fc1 = nn.Sequential(nn.Linear(512 * 8 * 8, 4096),
                                     nn.ReLU(inplace=True),
                                     nn.Dropout())
        else:
            self.fc1 = nn.Sequential(nn.Linear(512 * 7 * 7, 4096, bias= False), # 这里的4096只是一个经验值，当然可以变为别的数，但不要小于要预测的类别数
                                     nn.ReLU(inplace=True),
                                     nn.Dropout())
        self.fc2 = nn.Sequential(nn.Linear(4096, 4096,bias= False),
                                 nn.ReLU(inplace=True),
                                 nn.Dropout())
        self.fc3 = nn.Linear(4096, num_classes,bias= False)

    def make_layer(self, cfg, bn=False):
        layers = []
        in_channels = 3
        for v in cfg:
            if v == 'M':
                layers += [nn.MaxPool2d((2, 2), stride=2)]
            else:
                out_channels, s = v.strip().split('_') # 例如512  3
                out_channels, s = int(out_channels), int(s)

                if bn:
                    layers += [nn.Conv2d(in_channels, out_channels, (s, s), padding=1, bias= False),
                               nn.BatchNorm2d(out_channels),
                               nn.ReLU(inplace=True)]  # nn.Conv2d bias默认是true
                else:
                    layers += [nn.Conv2d(in_channels, out_channels, (s, s), padding=1, bias= False),
                               nn.ReLU(inplace=True)]
                in_channels = out_channels
        return nn.Sequential(*layers)

    def forward(self, x):
        batch_size = x.size()[0]
        x = self.vgg_base(x)
        print (x.shape) # [1,512,7,7]
        x = x.view(batch_size, -1)
        x = self.fc1(x)
        x = self.fc2(x)
        x = self.fc3(x)
        return x


cfg = {
    'vgg11_A': ['64_3', 'M',
                '128_3', 'M',
                '256_3', '256_3', 'M',
                '512_3', '512_3', 'M',
                '512_3', '512_3', 'M'],
    'vgg13_B': ['64_3', '64_3', 'M',
                '128_3', '128_3', 'M',
                '256_3', '256_3', 'M',
                '512_3', '512_3', 'M',
                '512_3', '512_3', 'M'],
    'vgg16_C': ['64_3', '64_3', 'M',
                '128_3', '128_3', 'M',
                '256_3', '256_3', '256_1', 'M',
                '512_3', '512_3', '512_1', 'M',
                '512_3', '512_3', '512_1', 'M'],
    'vgg16_D': ['64_3', '64_3', 'M',
                '128_3', '128_3', 'M',
                '256_3', '256_3', '256_3', 'M',
                '512_3', '512_3', '512_3', 'M',
                '512_3', '512_3', '512_3', 'M'],
    'vgg19_E': ['64_3', '64_3', 'M',
                '128_3', '128_3', 'M',
                '256_3', '256_3', '256_3', '256_3', 'M',
                '512_3', '512_3', '512_3', '512_3', 'M',
                '512_3', '512_3', '512_3', '512_3', 'M'],
}

if __name__ == '__main__':
    input_tensor = torch.randn((1, 3, 224, 224))
    input_var = torch.autograd.Variable(input_tensor)

    vgg_name = 'vgg16_D'
    model = VGG(vgg_name, cfg[vgg_name], num_classes=1000)
    output = model(input_var)
    print (output.shape)
    print(output.dtype)
    print('total_parameter_num:', sum(param.numel() for param in model.parameters()))

# bias=True
import torch
import torch.nn as nn

class VGG(nn.Module):
    def __init__(self, vgg_name, cfg, num_classes=10, bn=False):
        super(VGG, self).__init__()
        self.vgg_base = self.make_layer(cfg, bn)

        if vgg_name == 'vgg16_C':
            self.fc1 = nn.Sequential(nn.Linear(512 * 8 * 8, 4096),
                                     nn.ReLU(inplace=True),
                                     nn.Dropout())
        else:
            self.fc1 = nn.Sequential(nn.Linear(512 * 7 * 7, 4096), # 这里的4096只是一个经验值，当然可以变为别的数，但不要小于要预测的类别数
                                     nn.ReLU(inplace=True),
                                     nn.Dropout())
        self.fc2 = nn.Sequential(nn.Linear(4096, 4096),
                                 nn.ReLU(inplace=True),
                                 nn.Dropout())
        self.fc3 = nn.Linear(4096, num_classes)

    def make_layer(self, cfg, bn=False):
        layers = []
        in_channels = 3
        for v in cfg:
            if v == 'M':
                layers += [nn.MaxPool2d((2, 2), stride=2)]
            else:
                out_channels, s = v.strip().split('_') # 例如512  3
                out_channels, s = int(out_channels), int(s)

                if bn:
                    layers += [nn.Conv2d(in_channels, out_channels, (s, s), padding=1),
                               nn.BatchNorm2d(out_channels),
                               nn.ReLU(inplace=True)]  # nn.Conv2d bias默认是true
                else:
                    layers += [nn.Conv2d(in_channels, out_channels, (s, s), padding=1),
                               nn.ReLU(inplace=True)]
                in_channels = out_channels
        return nn.Sequential(*layers)

    def forward(self, x):
        batch_size = x.size()[0]
        x = self.vgg_base(x)
        print (x.shape) # [1,512,7,7]
        x = x.view(batch_size, -1)
        x = self.fc1(x)
        x = self.fc2(x)
        x = self.fc3(x)
        return x


cfg = {
    'vgg11_A': ['64_3', 'M',
                '128_3', 'M',
                '256_3', '256_3', 'M',
                '512_3', '512_3', 'M',
                '512_3', '512_3', 'M'],
    'vgg13_B': ['64_3', '64_3', 'M',
                '128_3', '128_3', 'M',
                '256_3', '256_3', 'M',
                '512_3', '512_3', 'M',
                '512_3', '512_3', 'M'],
    'vgg16_C': ['64_3', '64_3', 'M',
                '128_3', '128_3', 'M',
                '256_3', '256_3', '256_1', 'M',
                '512_3', '512_3', '512_1', 'M',
                '512_3', '512_3', '512_1', 'M'],
    'vgg16_D': ['64_3', '64_3', 'M',
                '128_3', '128_3', 'M',
                '256_3', '256_3', '256_3', 'M',
                '512_3', '512_3', '512_3', 'M',
                '512_3', '512_3', '512_3', 'M'],
    'vgg19_E': ['64_3', '64_3', 'M',
                '128_3', '128_3', 'M',
                '256_3', '256_3', '256_3', '256_3', 'M',
                '512_3', '512_3', '512_3', '512_3', 'M',
                '512_3', '512_3', '512_3', '512_3', 'M'],
}

if __name__ == '__main__':
    input_tensor = torch.randn((1, 3, 224, 224))
    input_var = torch.autograd.Variable(input_tensor)

    vgg_name = 'vgg16_D'
    model = VGG(vgg_name, cfg[vgg_name], num_classes=1000)
    output = model(input_var)
    print (output.shape)
    print(output.dtype)
    print('total_parameter_num:', sum(param.numel() for param in model.parameters()))

参考
https://blog.csdn.net/qq_38262728/article/details/89813503
https://blog.csdn.net/qian99/article/details/79008053

qq_29631521
关注
  • 4
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
显存与数据大小的关系
juluwangriyue的博客
10-22 456
研究显存与数据大小的关系的意义在于，我们能够确定自己的网络在给定的显卡上是否跑得起来。 以下是一个测试程序，用来测试数据占用显存的。 import math import torch import numpy as np import torch.nn.functional as F def gradient_loss(s, penalty='l2'): dy = torch.abs(s[:, :, 1:, :, :] - s[:, :, :-1, :, :]) dx = torch.a
卷积神经网络并行训练的优化研究.pdf
09-26
卷积神经网络是深度学习中的一种常用模型，但由于其结构复杂、计算量大，实际应用中一般采用多GPU的方式对其进行并行训练，以快速完成卷积神经网络的训练。然而，在并行训练中存在两个主要问题：一是参数通讯缓慢，...
【深度学习】参数量、模型大小、显存
热门推荐
叶子的博客
06-08 1万+
【深度学习】参数量、模型大小、显存对于一个深度学习神经网络来说，其通常包含很多卷积层，用于不断提取目标的特征，或对目标进行最终定位或者分类。 1 数据存储精度与存储空间 在深度学习神经网络中，最常见的数据格式是float32，占4个字节（Byte）。类似地，float16，占2个字节。1024个字节为1KB，1024x1024个字节为1MB。那么存储10000个参数需要的内存大小为10000x4 Bytes，约为39KB。存储100万个参数需要的内存大小为39x100/......
机器学习中的GPU和显存
最新发布
m0_73776435的博客
05-16 836
nvidia-smi是Nvidia显卡命令行管理套件，基于NVML库，旨在管理和监控Nvidia GPU设备。nvidia-smi的输出这是nvidia-smi命令的输出，其中最重要的两个指标：显存占用GPU利用率显存占用和GPU利用率是两个不一样的东西，显卡是由GPU计算单元和显存等组成的，显存和GPU的关系有点类似于内存和CPU的关系。gpustat,直接即可安装，gpustat基于nvidia-smi，可以提供更美观简洁的展示，结合watch命令，可以动态实时监控GPU的使用情况。
卷积神经网络参数量和计算量内存计算
bblingbbling的博客
11-17 4322
神经网络常用模型参数量一级目录二级目录 一级目录 二级目录
卷积神经网络中参数量的计算与模型占用显存的计算
weixin_43143419的博客
06-07 2193
感谢分享https://oldpan.me/archives/pytorch-gpu-memory-usage-track 如何计算模型以及中间变量的显存占用大小 前言 前面我们已经介绍过如何计算模型以及数据等如何计算其占用的显存大小。 亲，显存炸了，你的显卡快冒烟了！ torch.FatalError: cuda runtime error (2) : out of memory at /opt/conda/conda-bld/pytorch_1524590031827/work/aten/src/THC
基于卷积神经网络的铁路信号灯识别方法.pdf
09-25
实验环境与参数初始化方面，本文使用Ubuntu16.04操作系统，Inter Core i3-2370M CPU，主频2.40GHz，8GB内存，主硬盘SV300S37A120G，显卡AMD Radeon HD 6370M/7370M，显存1 GB；使用软件Python2.7。卷积层网络初始...
卷积神经网络余震自动识别及在中国地震台网地震检测中的应用.pdf
09-26
卷积神经网络在余震自动识别和中国地震台网地震检测中的应用 卷积神经网络（CNN）是一种深度学习方法，近年来在多个领域取得了优秀的成果。随着地震网络在全球范围的部署，每天产生的大量连续波形记录对数据处理...
基于体素模型与卷积神经网络的三维模型分类算法.pdf
09-25
《基于体素模型与卷积神经网络的三维模型分类算法》 三维模型分类是计算机图形学和机器学习领域中的一个重要研究方向，它在CAD设计、虚拟现实、自动驾驶等多个领域都有广泛应用。传统三维模型分类算法面临的主要...
卷积神经网络参数数量的计算和占用显存的比例
四个菜
05-04 3607
1 计算参数的数量 2 GPU显存使用图示 3 GPU显存使用计算
模型的显存和参数量计算
weixin_49305813的博客
07-28 7641
写在前面：以此记录关于模型显存和参数量的一些理解和计算。 显存 参数的显存占用：只有有参数的层，才会有显存占用。这部分的显存占用和输入无关，模型加载完成之后就会占用。 有参数的层主要包括：卷积、全连接、BatchNorm、Embedding等等 无参数的层主要包括：多数的激活层(Sigmoid/ReLU)、池化层、Dropout等等 具体来说，模型参数数目(不考虑偏置b)： Linear(M->N)：M×N Conv2d(Cin，Cout，K)：Cin×Cout×k×k BatchNorm(N)：2
CNN模型的计算量、参数、显存占用
NODIECANFLY
11-01 1万+
经典CNN模型的计算量、参数、显存占用 文章目录经典CNN模型的计算量、参数、显存占用1. 深度学习复杂度2. FLOPS概念3.参数量计算4. 输出特征图尺寸5. 常用模型的FlOPs和参数量6. 参数量和占用GPU显存的关系1.基础知识：2. 显存去哪了3. 优化器和动量4. 模型中各层对显存的占用5. 额外的显存6.如何优化7.参考引用 1. 深度学习复杂度 通常用Forward Pass计...
如何分析H5游戏的显存
feking2的博客
04-21 2642
分析H5游戏的显存，也适用于微信小游戏。 避免H5游戏闪退崩溃黑屏。
CNN卷积神经网络模型的GPU显存占用分析
IT菜鸟
11-01 846
CNN卷积神经网络模型的GPU显存占用分析
CNN卷积神经网络模型的参数量、计算量计算方法（概念版）
IT菜鸟
10-30 7515
CNN卷积神经网络模型的参数量、计算量计算方法（概念版）
以VGG为例，分析深度网络的计算量和参数量
pandamax的博客
03-19 2134
以VGG为例，分析深度网络的计算量和参数量
神经网络GPU显存与计算力分析
本文主要讨论了神经网络的参数数量、计算量以及如何分析CPU和显存的使用情况，尤其关注GPU的性能指标，如利用率、显存占用和计算单元。通过nvidia-smi工具可以监测GPU的状态，包括显存占用、温度和计算利用率。显存...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值