zy_destiny
zy_destiny

【MMEngine】用MMEngine自带函数get_model_complexity_info计算模型每层参数量、参数总量和计算量

目录

参数定义

定义模型

统计计算量和参数量

以表格形式显示每层输出

输出

以网络结构形式显示每层输出

输出

输出总计算量

输出

输出总参数量 

输出

其他函数包计算参数量和计算量

1.thop

结果

2.ptflops

结果

3.torchsummary

结果

4.torchsummary计算参数总量和可训练参数总量

结果

参数定义

  • 计算量对应时间复杂度，参数量对应空间复杂度。
  • 计算量要看网络执行时间的长短，参数量要看占用显存的量。

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

  • FLOPS：（floating-point operations per second）的缩写。“每秒浮点运算次数”，“每秒峰值速度”是“每秒所执行的浮点运算次数”。它常被用来估算电脑的执行效能，尤其是在使用到大量浮点运算的科学计算领域中。正因为FLOPS字尾的那个S，代表秒，而不是复数，所以不能省略掉。
  • activations：所有卷积层的输出feature map的尺寸，用于度量网络的复杂度，虽然activations不是衡量网络复杂性的通用标准，但activations可能会严重影响内存受限硬件加速器(例如GPU、TPU)上的运行时间，activations与推理时间的正相关性比FLOPs更强。

定义模型

        以resnet50为例，首先定义模型，python代码如下：

import torch.nn.functional as F
import torchvision
from mmengine.model import BaseModel

class MMResNet50(BaseModel):
    def __init__(self):
        super().__init__()
        self.resnet = torchvision.models.resnet50()

    def forward(self, imgs, labels=None, mode='tensor'):
        x = self.resnet(imgs)
        if mode == 'loss':
            return {'loss': F.cross_entropy(x, labels)}
        elif mode == 'predict':
            return x, labels
        elif mode == 'tensor':
            return x

统计计算量和参数量

        使用mmengine自带的get_model_complexity_info函数即可实现统计模型计算量和参数量的目的。python代码如下：

from mmengine.analysis import get_model_complexity_info

input_shape = (3, 224, 224)
model = MMResNet50()
analysis_results = get_model_complexity_info(model, input_shape)

以表格形式显示每层输出

        可以选择以表格形式和模型结构两种形式进行计算量和参数量的输出，首先以表格形式展示，python代码如下：

print(analysis_results['out_table'])

输出

        可以看到resnet50模型总的参数量为25.557M，计算量flops为4.145G，网络复杂度为11.115M。

+------------------------+----------------------+------------+--------------+
| module                 | #parameters or shape | #flops     | #activations |
+------------------------+----------------------+------------+--------------+
| resnet                 | 25.557M              | 4.145G     | 11.115M      |
|  conv1                 |  9.408K              |  0.118G    |  0.803M      |
|   conv1.weight         |   (64, 3, 7, 7)      |            |              |
|  bn1                   |  0.128K              |  4.014M    |  0           |
|   bn1.weight           |   (64,)              |            |              |
|   bn1.bias             |   (64,)              |            |              |
|  layer1                |  0.216M              |  0.69G     |  4.415M      |
|   layer1.0             |   75.008K            |   0.241G   |   2.007M     |
|    layer1.0.conv1      |    4.096K            |    12.845M |    0.201M    |
|    layer1.0.bn1        |    0.128K            |    1.004M  |    0         |
|    layer1.0.conv2      |    36.864K           |    0.116G  |    0.201M    |
|    layer1.0.bn2        |    0.128K            |    1.004M  |    0         |
|    layer1.0.conv3      |    16.384K           |    51.38M  |    0.803M    |
|    layer1.0.bn3        |    0.512K            |    4.014M  |    0         |
|    layer1.0.downsample |    16.896K           |    55.394M |    0.803M    |
|   layer1.1             |   70.4K              |   0.224G   |   1.204M     |
|    layer1.1.conv1      |    16.384K           |    51.38M  |    0.201M    |
|    layer1.1.bn1        |    0.128K            |    1.004M  |    0         |
|    layer1.1.conv2      |    36.864K           |    0.116G  |    0.201M    |
|    layer1.1.bn2        |    0.128K            |    1.004M  |    0         |
|    layer1.1.conv3      |    16.384K           |    51.38M  |    0.803M    |
|    layer1.1.bn3        |    0.512K            |    4.014M  |    0         |
|   layer1.2             |   70.4K              |   0.224G   |   1.204M     |
|    layer1.2.conv1      |    16.384K           |    51.38M  |    0.201M    |
|    layer1.2.bn1        |    0.128K            |    1.004M  |    0         |
|    layer1.2.conv2      |    36.864K           |    0.116G  |    0.201M    |
|    layer1.2.bn2        |    0.128K            |    1.004M  |    0         |
|    layer1.2.conv3      |    16.384K           |    51.38M  |    0.803M    |
|    layer1.2.bn3        |    0.512K            |    4.014M  |    0         |
|  layer2                |  1.22M               |  1.043G    |  3.111M      |
|   layer2.0             |   0.379M             |   0.379G   |   1.305M     |
|    layer2.0.conv1      |    32.768K           |    0.103G  |    0.401M    |
|    layer2.0.bn1        |    0.256K            |    2.007M  |    0         |
|    layer2.0.conv2      |    0.147M            |    0.116G  |    0.1M      |
|    layer2.0.bn2        |    0.256K            |    0.502M  |    0         |
|    layer2.0.conv3      |    65.536K           |    51.38M  |    0.401M    |
|    layer2.0.bn3        |    1.024K            |    2.007M  |    0         |
|    layer2.0.downsample |    0.132M            |    0.105G  |    0.401M    |
|   layer2.1             |   0.28M              |   0.221G   |   0.602M     |
|    layer2.1.conv1      |    65.536K           |    51.38M  |    0.1M      |
|    layer2.1.bn1        |    0.256K            |    0.502M  |    0         |
|    layer2.1.conv2      |    0.147M            |    0.116G  |    0.1M      |
|    layer2.1.bn2        |    0.256K            |    0.502M  |    0         |
|    layer2.1.conv3      |    65.536K           |    51.38M  |    0.401M    |
|    layer2.1.bn3        |    1.024K            |    2.007M  |    0         |
|   layer2.2             |   0.28M              |   0.221G   |   0.602M     |
|    layer2.2.conv1      |    65.536K           |    51.38M  |    0.1M      |
|    layer2.2.bn1        |    0.256K            |    0.502M  |    0         |
|    layer2.2.conv2      |    0.147M            |    0.116G  |    0.1M      |
|    layer2.2.bn2        |    0.256K            |    0.502M  |    0         |
|    layer2.2.conv3      |    65.536K           |    51.38M  |    0.401M    |
|    layer2.2.bn3        |    1.024K            |    2.007M  |    0         |
|   layer2.3             |   0.28M              |   0.221G   |   0.602M     |
|    layer2.3.conv1      |    65.536K           |    51.38M  |    0.1M      |
|    layer2.3.bn1        |    0.256K            |    0.502M  |    0         |
|    layer2.3.conv2      |    0.147M            |    0.116G  |    0.1M      |
|    layer2.3.bn2        |    0.256K            |    0.502M  |    0         |
|    layer2.3.conv3      |    65.536K           |    51.38M  |    0.401M    |
|    layer2.3.bn3        |    1.024K            |    2.007M  |    0         |
|  layer3                |  7.098M              |  1.475G    |  2.158M      |
|   layer3.0             |   1.512M             |   0.376G   |   0.652M     |
|    layer3.0.conv1      |    0.131M            |    0.103G  |    0.201M    |
|    layer3.0.bn1        |    0.512K            |    1.004M  |    0         |
|    layer3.0.conv2      |    0.59M             |    0.116G  |    50.176K   |
|    layer3.0.bn2        |    0.512K            |    0.251M  |    0         |
|    layer3.0.conv3      |    0.262M            |    51.38M  |    0.201M    |
|    layer3.0.bn3        |    2.048K            |    1.004M  |    0         |
|    layer3.0.downsample |    0.526M            |    0.104G  |    0.201M    |
|   layer3.1             |   1.117M             |   0.22G    |   0.301M     |
|    layer3.1.conv1      |    0.262M            |    51.38M  |    50.176K   |
|    layer3.1.bn1        |    0.512K            |    0.251M  |    0         |
|    layer3.1.conv2      |    0.59M             |    0.116G  |    50.176K   |
|    layer3.1.bn2        |    0.512K            |    0.251M  |    0         |
|    layer3.1.conv3      |    0.262M            |    51.38M  |    0.201M    |
|    layer3.1.bn3        |    2.048K            |    1.004M  |    0         |
|   layer3.2             |   1.117M             |   0.22G    |   0.301M     |
|    layer3.2.conv1      |    0.262M            |    51.38M  |    50.176K   |
|    layer3.2.bn1        |    0.512K            |    0.251M  |    0         |
|    layer3.2.conv2      |    0.59M             |    0.116G  |    50.176K   |
|    layer3.2.bn2        |    0.512K            |    0.251M  |    0         |
|    layer3.2.conv3      |    0.262M            |    51.38M  |    0.201M    |
|    layer3.2.bn3        |    2.048K            |    1.004M  |    0         |
|   layer3.3             |   1.117M             |   0.22G    |   0.301M     |
|    layer3.3.conv1      |    0.262M            |    51.38M  |    50.176K   |
|    layer3.3.bn1        |    0.512K            |    0.251M  |    0         |
|    layer3.3.conv2      |    0.59M             |    0.116G  |    50.176K   |
|    layer3.3.bn2        |    0.512K            |    0.251M  |    0         |
|    layer3.3.conv3      |    0.262M            |    51.38M  |    0.201M    |
|    layer3.3.bn3        |    2.048K            |    1.004M  |    0         |
|   layer3.4             |   1.117M             |   0.22G    |   0.301M     |
|    layer3.4.conv1      |    0.262M            |    51.38M  |    50.176K   |
|    layer3.4.bn1        |    0.512K            |    0.251M  |    0         |
|    layer3.4.conv2      |    0.59M             |    0.116G  |    50.176K   |
|    layer3.4.bn2        |    0.512K            |    0.251M  |    0         |
|    layer3.4.conv3      |    0.262M            |    51.38M  |    0.201M    |
|    layer3.4.bn3        |    2.048K            |    1.004M  |    0         |
|   layer3.5             |   1.117M             |   0.22G    |   0.301M     |
|    layer3.5.conv1      |    0.262M            |    51.38M  |    50.176K   |
|    layer3.5.bn1        |    0.512K            |    0.251M  |    0         |
|    layer3.5.conv2      |    0.59M             |    0.116G  |    50.176K   |
|    layer3.5.bn2        |    0.512K            |    0.251M  |    0         |
|    layer3.5.conv3      |    0.262M            |    51.38M  |    0.201M    |
|    layer3.5.bn3        |    2.048K            |    1.004M  |    0         |
|  layer4                |  14.965M             |  0.812G    |  0.627M      |
|   layer4.0             |   6.04M              |   0.374G   |   0.326M     |
|    layer4.0.conv1      |    0.524M            |    0.103G  |    0.1M      |
|    layer4.0.bn1        |    1.024K            |    0.502M  |    0         |
|    layer4.0.conv2      |    2.359M            |    0.116G  |    25.088K   |
|    layer4.0.bn2        |    1.024K            |    0.125M  |    0         |
|    layer4.0.conv3      |    1.049M            |    51.38M  |    0.1M      |
|    layer4.0.bn3        |    4.096K            |    0.502M  |    0         |
|    layer4.0.downsample |    2.101M            |    0.103G  |    0.1M      |
|   layer4.1             |   4.463M             |   0.219G   |   0.151M     |
|    layer4.1.conv1      |    1.049M            |    51.38M  |    25.088K   |
|    layer4.1.bn1        |    1.024K            |    0.125M  |    0         |
|    layer4.1.conv2      |    2.359M            |    0.116G  |    25.088K   |
|    layer4.1.bn2        |    1.024K            |    0.125M  |    0         |
|    layer4.1.conv3      |    1.049M            |    51.38M  |    0.1M      |
|    layer4.1.bn3        |    4.096K            |    0.502M  |    0         |
|   layer4.2             |   4.463M             |   0.219G   |   0.151M     |
|    layer4.2.conv1      |    1.049M            |    51.38M  |    25.088K   |
|    layer4.2.bn1        |    1.024K            |    0.125M  |    0         |
|    layer4.2.conv2      |    2.359M            |    0.116G  |    25.088K   |
|    layer4.2.bn2        |    1.024K            |    0.125M  |    0         |
|    layer4.2.conv3      |    1.049M            |    51.38M  |    0.1M      |
|    layer4.2.bn3        |    4.096K            |    0.502M  |    0         |
|  fc                    |  2.049M              |  2.048M    |  1K          |
|   fc.weight            |   (1000, 2048)       |            |              |
|   fc.bias              |   (1000,)            |            |              |
|  avgpool               |                      |  0.1M      |  0           |
+------------------------+----------------------+------------+--------------+

以网络结构形式显示每层输出

        mmengine支持表格形式和模型结构两种形式进行计算量和参数量的输出，以网络结构形式输出的python代码如下：

print(analysis_results['out_arch'])

输出

MMResNet50(
#params: 25.56M, #flops: 4.14G, #acts: 11.11M
(data_preprocessor): BaseDataPreprocessor(#params: 0, #flops: N/A, #acts: N/A)
(resnet): ResNet(
    #params: 25.56M, #flops: 4.14G, #acts: 11.11M
    (conv1): Conv2d(
    3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False
    #params: 9.41K, #flops: 0.12G, #acts: 0.8M
    )
    (bn1): BatchNorm2d(
    64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
    #params: 0.13K, #flops: 4.01M, #acts: 0
    )
    (relu): ReLU(inplace=True)
    (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
    (layer1): Sequential(
    #params: 0.22M, #flops: 0.69G, #acts: 4.42M
    (0): Bottleneck(
        #params: 75.01K, #flops: 0.24G, #acts: 2.01M
        (conv1): Conv2d(
        64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 4.1K, #flops: 12.85M, #acts: 0.2M
        )
        (bn1): BatchNorm2d(
        64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.13K, #flops: 1M, #acts: 0
        )
        (conv2): Conv2d(
        64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
        #params: 36.86K, #flops: 0.12G, #acts: 0.2M
        )
        (bn2): BatchNorm2d(
        64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.13K, #flops: 1M, #acts: 0
        )
        (conv3): Conv2d(
        64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 16.38K, #flops: 51.38M, #acts: 0.8M
        )
        (bn3): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 4.01M, #acts: 0
        )
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
        #params: 16.9K, #flops: 55.39M, #acts: 0.8M
        (0): Conv2d(
            64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
            #params: 16.38K, #flops: 51.38M, #acts: 0.8M
        )
        (1): BatchNorm2d(
            256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
            #params: 0.51K, #flops: 4.01M, #acts: 0
        )
        )
    )
    (1): Bottleneck(
        #params: 70.4K, #flops: 0.22G, #acts: 1.2M
        (conv1): Conv2d(
        256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 16.38K, #flops: 51.38M, #acts: 0.2M
        )
        (bn1): BatchNorm2d(
        64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.13K, #flops: 1M, #acts: 0
        )
        (conv2): Conv2d(
        64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
        #params: 36.86K, #flops: 0.12G, #acts: 0.2M
        )
        (bn2): BatchNorm2d(
        64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.13K, #flops: 1M, #acts: 0
        )
        (conv3): Conv2d(
        64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 16.38K, #flops: 51.38M, #acts: 0.8M
        )
        (bn3): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 4.01M, #acts: 0
        )
        (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
        #params: 70.4K, #flops: 0.22G, #acts: 1.2M
        (conv1): Conv2d(
        256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 16.38K, #flops: 51.38M, #acts: 0.2M
        )
        (bn1): BatchNorm2d(
        64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.13K, #flops: 1M, #acts: 0
        )
        (conv2): Conv2d(
        64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
        #params: 36.86K, #flops: 0.12G, #acts: 0.2M
        )
        (bn2): BatchNorm2d(
        64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.13K, #flops: 1M, #acts: 0
        )
        (conv3): Conv2d(
        64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 16.38K, #flops: 51.38M, #acts: 0.8M
        )
        (bn3): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 4.01M, #acts: 0
        )
        (relu): ReLU(inplace=True)
    )
    )
    (layer2): Sequential(
    #params: 1.22M, #flops: 1.04G, #acts: 3.11M
    (0): Bottleneck(
        #params: 0.38M, #flops: 0.38G, #acts: 1.3M
        (conv1): Conv2d(
        256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 32.77K, #flops: 0.1G, #acts: 0.4M
        )
        (bn1): BatchNorm2d(
        128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.26K, #flops: 2.01M, #acts: 0
        )
        (conv2): Conv2d(
        128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False
        #params: 0.15M, #flops: 0.12G, #acts: 0.1M
        )
        (bn2): BatchNorm2d(
        128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.26K, #flops: 0.5M, #acts: 0
        )
        (conv3): Conv2d(
        128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 65.54K, #flops: 51.38M, #acts: 0.4M
        )
        (bn3): BatchNorm2d(
        512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 1.02K, #flops: 2.01M, #acts: 0
        )
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
        #params: 0.13M, #flops: 0.1G, #acts: 0.4M
        (0): Conv2d(
            256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False
            #params: 0.13M, #flops: 0.1G, #acts: 0.4M
        )
        (1): BatchNorm2d(
            512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
            #params: 1.02K, #flops: 2.01M, #acts: 0
        )
        )
    )
    (1): Bottleneck(
        #params: 0.28M, #flops: 0.22G, #acts: 0.6M
        (conv1): Conv2d(
        512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 65.54K, #flops: 51.38M, #acts: 0.1M
        )
        (bn1): BatchNorm2d(
        128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.26K, #flops: 0.5M, #acts: 0
        )
        (conv2): Conv2d(
        128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
        #params: 0.15M, #flops: 0.12G, #acts: 0.1M
        )
        (bn2): BatchNorm2d(
        128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.26K, #flops: 0.5M, #acts: 0
        )
        (conv3): Conv2d(
        128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 65.54K, #flops: 51.38M, #acts: 0.4M
        )
        (bn3): BatchNorm2d(
        512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 1.02K, #flops: 2.01M, #acts: 0
        )
        (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
        #params: 0.28M, #flops: 0.22G, #acts: 0.6M
        (conv1): Conv2d(
        512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 65.54K, #flops: 51.38M, #acts: 0.1M
        )
        (bn1): BatchNorm2d(
        128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.26K, #flops: 0.5M, #acts: 0
        )
        (conv2): Conv2d(
        128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
        #params: 0.15M, #flops: 0.12G, #acts: 0.1M
        )
        (bn2): BatchNorm2d(
        128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.26K, #flops: 0.5M, #acts: 0
        )
        (conv3): Conv2d(
        128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 65.54K, #flops: 51.38M, #acts: 0.4M
        )
        (bn3): BatchNorm2d(
        512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 1.02K, #flops: 2.01M, #acts: 0
        )
        (relu): ReLU(inplace=True)
    )
    (3): Bottleneck(
        #params: 0.28M, #flops: 0.22G, #acts: 0.6M
        (conv1): Conv2d(
        512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 65.54K, #flops: 51.38M, #acts: 0.1M
        )
        (bn1): BatchNorm2d(
        128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.26K, #flops: 0.5M, #acts: 0
        )
        (conv2): Conv2d(
        128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
        #params: 0.15M, #flops: 0.12G, #acts: 0.1M
        )
        (bn2): BatchNorm2d(
        128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.26K, #flops: 0.5M, #acts: 0
        )
        (conv3): Conv2d(
        128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 65.54K, #flops: 51.38M, #acts: 0.4M
        )
        (bn3): BatchNorm2d(
        512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 1.02K, #flops: 2.01M, #acts: 0
        )
        (relu): ReLU(inplace=True)
    )
    )
    (layer3): Sequential(
    #params: 7.1M, #flops: 1.48G, #acts: 2.16M
    (0): Bottleneck(
        #params: 1.51M, #flops: 0.38G, #acts: 0.65M
        (conv1): Conv2d(
        512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 0.13M, #flops: 0.1G, #acts: 0.2M
        )
        (bn1): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 1M, #acts: 0
        )
        (conv2): Conv2d(
        256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False
        #params: 0.59M, #flops: 0.12G, #acts: 50.18K
        )
        (bn2): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 0.25M, #acts: 0
        )
        (conv3): Conv2d(
        256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 0.26M, #flops: 51.38M, #acts: 0.2M
        )
        (bn3): BatchNorm2d(
        1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 2.05K, #flops: 1M, #acts: 0
        )
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
        #params: 0.53M, #flops: 0.1G, #acts: 0.2M
        (0): Conv2d(
            512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False
            #params: 0.52M, #flops: 0.1G, #acts: 0.2M
        )
        (1): BatchNorm2d(
            1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
            #params: 2.05K, #flops: 1M, #acts: 0
        )
        )
    )
    (1): Bottleneck(
        #params: 1.12M, #flops: 0.22G, #acts: 0.3M
        (conv1): Conv2d(
        1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 0.26M, #flops: 51.38M, #acts: 50.18K
        )
        (bn1): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 0.25M, #acts: 0
        )
        (conv2): Conv2d(
        256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
        #params: 0.59M, #flops: 0.12G, #acts: 50.18K
        )
        (bn2): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 0.25M, #acts: 0
        )
        (conv3): Conv2d(
        256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 0.26M, #flops: 51.38M, #acts: 0.2M
        )
        (bn3): BatchNorm2d(
        1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 2.05K, #flops: 1M, #acts: 0
        )
        (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
        #params: 1.12M, #flops: 0.22G, #acts: 0.3M
        (conv1): Conv2d(
        1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 0.26M, #flops: 51.38M, #acts: 50.18K
        )
        (bn1): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 0.25M, #acts: 0
        )
        (conv2): Conv2d(
        256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
        #params: 0.59M, #flops: 0.12G, #acts: 50.18K
        )
        (bn2): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 0.25M, #acts: 0
        )
        (conv3): Conv2d(
        256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 0.26M, #flops: 51.38M, #acts: 0.2M
        )
        (bn3): BatchNorm2d(
        1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 2.05K, #flops: 1M, #acts: 0
        )
        (relu): ReLU(inplace=True)
    )
    (3): Bottleneck(
        #params: 1.12M, #flops: 0.22G, #acts: 0.3M
        (conv1): Conv2d(
        1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 0.26M, #flops: 51.38M, #acts: 50.18K
        )
        (bn1): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 0.25M, #acts: 0
        )
        (conv2): Conv2d(
        256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
        #params: 0.59M, #flops: 0.12G, #acts: 50.18K
        )
        (bn2): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 0.25M, #acts: 0
        )
        (conv3): Conv2d(
        256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 0.26M, #flops: 51.38M, #acts: 0.2M
        )
        (bn3): BatchNorm2d(
        1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 2.05K, #flops: 1M, #acts: 0
        )
        (relu): ReLU(inplace=True)
    )
    (4): Bottleneck(
        #params: 1.12M, #flops: 0.22G, #acts: 0.3M
        (conv1): Conv2d(
        1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 0.26M, #flops: 51.38M, #acts: 50.18K
        )
        (bn1): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 0.25M, #acts: 0
        )
        (conv2): Conv2d(
        256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
        #params: 0.59M, #flops: 0.12G, #acts: 50.18K
        )
        (bn2): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 0.25M, #acts: 0
        )
        (conv3): Conv2d(
        256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 0.26M, #flops: 51.38M, #acts: 0.2M
        )
        (bn3): BatchNorm2d(
        1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 2.05K, #flops: 1M, #acts: 0
        )
        (relu): ReLU(inplace=True)
    )
    (5): Bottleneck(
        #params: 1.12M, #flops: 0.22G, #acts: 0.3M
        (conv1): Conv2d(
        1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 0.26M, #flops: 51.38M, #acts: 50.18K
        )
        (bn1): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 0.25M, #acts: 0
        )
        (conv2): Conv2d(
        256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
        #params: 0.59M, #flops: 0.12G, #acts: 50.18K
        )
        (bn2): BatchNorm2d(
        256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 0.51K, #flops: 0.25M, #acts: 0
        )
        (conv3): Conv2d(
        256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 0.26M, #flops: 51.38M, #acts: 0.2M
        )
        (bn3): BatchNorm2d(
        1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 2.05K, #flops: 1M, #acts: 0
        )
        (relu): ReLU(inplace=True)
    )
    )
    (layer4): Sequential(
    #params: 14.96M, #flops: 0.81G, #acts: 0.63M
    (0): Bottleneck(
        #params: 6.04M, #flops: 0.37G, #acts: 0.33M
        (conv1): Conv2d(
        1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 0.52M, #flops: 0.1G, #acts: 0.1M
        )
        (bn1): BatchNorm2d(
        512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 1.02K, #flops: 0.5M, #acts: 0
        )
        (conv2): Conv2d(
        512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False
        #params: 2.36M, #flops: 0.12G, #acts: 25.09K
        )
        (bn2): BatchNorm2d(
        512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 1.02K, #flops: 0.13M, #acts: 0
        )
        (conv3): Conv2d(
        512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 1.05M, #flops: 51.38M, #acts: 0.1M
        )
        (bn3): BatchNorm2d(
        2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 4.1K, #flops: 0.5M, #acts: 0
        )
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
        #params: 2.1M, #flops: 0.1G, #acts: 0.1M
        (0): Conv2d(
            1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False
            #params: 2.1M, #flops: 0.1G, #acts: 0.1M
        )
        (1): BatchNorm2d(
            2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
            #params: 4.1K, #flops: 0.5M, #acts: 0
        )
        )
    )
    (1): Bottleneck(
        #params: 4.46M, #flops: 0.22G, #acts: 0.15M
        (conv1): Conv2d(
        2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 1.05M, #flops: 51.38M, #acts: 25.09K
        )
        (bn1): BatchNorm2d(
        512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 1.02K, #flops: 0.13M, #acts: 0
        )
        (conv2): Conv2d(
        512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
        #params: 2.36M, #flops: 0.12G, #acts: 25.09K
        )
        (bn2): BatchNorm2d(
        512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 1.02K, #flops: 0.13M, #acts: 0
        )
        (conv3): Conv2d(
        512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 1.05M, #flops: 51.38M, #acts: 0.1M
        )
        (bn3): BatchNorm2d(
        2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 4.1K, #flops: 0.5M, #acts: 0
        )
        (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
        #params: 4.46M, #flops: 0.22G, #acts: 0.15M
        (conv1): Conv2d(
        2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 1.05M, #flops: 51.38M, #acts: 25.09K
        )
        (bn1): BatchNorm2d(
        512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 1.02K, #flops: 0.13M, #acts: 0
        )
        (conv2): Conv2d(
        512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
        #params: 2.36M, #flops: 0.12G, #acts: 25.09K
        )
        (bn2): BatchNorm2d(
        512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 1.02K, #flops: 0.13M, #acts: 0
        )
        (conv3): Conv2d(
        512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False
        #params: 1.05M, #flops: 51.38M, #acts: 0.1M
        )
        (bn3): BatchNorm2d(
        2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True
        #params: 4.1K, #flops: 0.5M, #acts: 0
        )
        (relu): ReLU(inplace=True)
    )
    )
    (avgpool): AdaptiveAvgPool2d(
    output_size=(1, 1)
    #params: 0, #flops: 0.1M, #acts: 0
    )
    (fc): Linear(
    in_features=2048, out_features=1000, bias=True
    #params: 2.05M, #flops: 2.05M, #acts: 1K
    )
)
)

输出总计算量

print("Model Flops:{}".format(analysis_results['flops_str']))

输出

Model Flops:4.145G

输出总参数量 

print("Model Parameters:{}".format(analysis_results['params_str']))

输出

Model Parameters:25.557M

​​​​​​​​​​​​​​​​​​​​​其他函数包计算参数量和计算量

1.thop

  • 第一步：安装模块
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

结果

==> Building model..
[INFO] Register count_convNd() for .
[INFO] Register zero_ops() for .
[INFO] Register zero_ops() for .
[INFO] Register zero_ops() for .
[INFO] Register count_adap_avgpool() for .
[INFO] Register zero_ops() for .
[INFO] Register count_linear() for .
flops:  714206912.0 params:  61100840.0
flops: 714.21 M, params: 61.10 M

注意：profile(net, (inputs,))的 (inputs,)中必须加上逗号，否者会报错

2.ptflops

  • 第一步：安装模块
pip install ptflops
  • 第二步：计算
import torchvision
from ptflops import get_model_complexity_info

model = 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

3.torchsummary

  • 第一步：安装模块
pip install torch
  • 第二步：计算
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))

 注意：新版本的torch导入summary包时，需要用：

from torchsummary import summary

结果

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

4.torchsummary计算参数总量和可训练参数总量

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)

结果

==> Building model..
Total -  61100840
Trainable -  61100840

整理不易，欢迎一键三连！！！

送你们一条美丽的--分割线--


⛵⛵⭐⭐

你可能感兴趣的:(Python,基本知识,MMEngine,python,深度学习,人工智能,计算机视觉,机器视觉,参数量,torch)

  • 【Python】一文详细介绍 py格式 文件 高斯小哥 Python基础【高质量合集】python新手入门学习
    【Python】一文详细介绍py格式文件个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文章目录一、py格式文件简介二、如何创建和编辑py格式文件三、如何运行py
  • python抓包与解包_Python—网络抓包与解包（pcap、dpkt） weixin_39691055 python抓包与解包
    pcap安装[root@localhost~]#pipinstallpypcap抓包与解包#-*-coding:utf-8-*-importpcap,dpktimportre,threading,requests__black_ip=['103.224.249.123','203.66.1.212']#抓包：param1eth_name网卡名，如：eth0,eth3。param2p_type日志捕
  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++） 华为OD题库 华为od链表java
    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
  • python 推导式(派生、衍生) sanduo112 人工智能pythonwindows开发语言
    python推导式一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。2.列表(list)推导式3.字典(dict)推导式4.集合(set)推导式5.元组(tuple)推导式二、代码概述一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。Python支持各种数
  • 数据挖掘|数据预处理|基于Python的数据标准化方法 皖山文武 数据挖掘数据建模与分析python数据挖掘开发语言
    基于Python的数据标准化方法1.z-score方法2.极差标准化方法3.最大绝对值标准化方法在数据分析之前，通常需要先将数据标准化（Standardization），利用标准化后的数据进行数据分析，以避免属性之间不同度量和取值范围差异造成数据对分析结果的影响。1.z-score方法Z-score方法是基于原始数据的均值和标准差来进行数据标准化的，处理后的数据均值为0，方差为1，符合标准正态分布
  • CSV指南：Python程序获取大型CSV文件行数 孤独打铁匠Julian 笔记经验分享python
    本指南提供了几种使用Python来获取大型CSV文件行数的方法，并解释了每种方法的适用场景。方法1:使用csv.reader处理复杂CSV文件当你的CSV文件中包含多行字段（即某些字段的值中包含换行符）时，使用csv.reader是一个可靠的选择，因为它能够正确处理这些复杂情况。这个方法适用于大多数大小的CSV文件，但是对于非常大的文件，读取整个文件可能会占用较多的时间和内存。对于极大的文件，考虑
  • 谷歌浏览器驱动Chromedriver（114-120版本）文件以及驱动下载教程 pigerr杨 Pythonpythonchromedrivers
    ChromeDriver官方网站GitHub||GoogleChromeLabs/chrome-for-testingChromeDriver113-125_JSONChromeforTestingavailability123-125zip白月黑羽Python基础|进阶|Qt图形界面|Django|自动化测试|性能测试|JS语言|JS前端|原理与安装
  • 大创项目推荐 深度学习 opencv python 公式识别(图像识别 机器视觉) laafeer python
    文章目录0前言1课题说明2效果展示3具体实现4关键代码实现5算法综合效果6最后0前言优质竞赛项目系列，今天要分享的是基于深度学习的数学公式识别算法实现该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：4分创新点：4分更多资料,项目分享：https://gitee.com/dancheng-senior/postgraduate1课题
  • lodash插件 吃我一锅 一些插件
    安装npminstalllodash引入importorderByfrom'lodash/orderBy'使用orderBy(要排序的变量，要排序的字段，升序还是降序)//例如，评论按照点赞数量排序orderBy(lilst,'like','desc')
  • Ai插件脚本合集安装包，免费教程视频网盘分享 全网优惠分享君
    随着人工智能技术的不断发展，越来越多的插件脚本涌现出来，为我们的生活和工作带来了便利。然而，如何快速、方便地获取和使用这些插件脚本呢？今天，我将为大家分享一个非常实用的资源——AI插件脚本合集安装包，以及免费教程视频网盘分享。首先，让我们来了解一下这个AI插件脚本合集安装包。它是一个集合了众多AI插件脚本的资源包，涵盖了各种领域，如数据分析、自动化办公、智能客服等等。通过这个安装包，用户可以轻松地
  • 过去一年，这16本好书不容错过 m0_54050778 perl
    编者按：2023年在动荡与希望中收尾，2023年注定会被载入史册。疫情寒冬结束，ChatGPT横空出世，带动了人工智能技术的飞速发展；淄博烧烤、天津大爷、尔滨之旅等充满感动与幸福。但与此同时，2023年又是动荡与不安的一年，俄乌冲突的延宕，新一轮的巴以冲突，极端天气频发。在这个大环境下，有一些经典的书籍著作诞生。本文将分享2023年最值得一读的16本书籍，文章来自翻译，希望对你有所启示。关于202
  • [数据集][图像分类]河道污染分类数据集1923张4类别 FL1623863129 数据集分类数据挖掘人工智能
    数据集类型：图像分类用，不可用于目标检测无标注文件数据集格式：仅仅包含jpg图片，每个类别文件夹下面存放着对应图片图片数量(jpg文件个数)：1922分类类别数：4类别名称:["lianghao","qingwei","yanzhong","zhongdu"]每个类别图片数：lianghao图片数：435qingwei图片数：423yanzhong图片数：577zhongdu图片数：487重要说明
  • python转码 Desamond python开发语言
    转码在许多场景中都有应用，以下是一些常见的场景：网页开发：当用户在网页上输入文本时，可能需要将特殊字符（如空格、引号、特殊符号等）进行转码，以防止这些字符对URL或HTML代码产生干扰。文件名处理：在处理文件名时，可能需要将特殊字符进行转码，以避免文件名被错误地解析或显示。数据传输：在数据传输过程中，为了确保数据的完整性和正确性，可能需要将数据中的特殊字符进行转码。数据存储：在数据库或数据存储中，
  • 排序算法太多？常用排序都在这了，一篇文章总结和实现所有面试会考的排序算法（基于Python实现） 宇宙之一粟 不归路之Python#IT面试题收集与总结数据结构与算法算法数据结构排序算法pythonjava
    文章目录排序算法1.常见的排序算法1.1选择排序1.1.1思想1.1.2实现**1.1.3选择排序分析**1.2冒泡排序**1.2.1思想****1.2.2实现****1.2.3冒泡排序分析**1.3插入排序**1.3.1思想****1.3.2实现****1.3.3插入排序分析**1.4归并排序☆☆★**1.4.1思想****1.4.2实现****1.4.3归并排序分析**1.5快速排序☆★★**
  • 27.Python从入门到精通—Python异常处理 抛出异常 用户自定义异常 定义清理行为 预定义的清理行为 以山河作礼。 #Python基础入门—详解版pythonjava服务器
    27.从入门到精通：Python异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为异常处理在Python中，异常处理是一种处理程序在执行期间可能遇到的错误的方法。当Python解释器遇到错误时，它会引发异常。异常是一种Python对象，它包含有关错误的信息，例如错误类型和错误位置。为了处理异常，您可以使用try-except语句。在
  • python清华大学出版社答案_Python机器学习及实践 weixin_39805119 python清华大学出版社答案
    第1章机器学习的基础知识1.1何谓机器学习1.1.1传感器和海量数据1.1.2机器学习的重要性1.1.3机器学习的表现1.1.4机器学习的主要任务1.1.5选择合适的算法1.1.6机器学习程序的步骤1.2综合分类1.3推荐系统和深度学习1.3.1推荐系统1.3.2深度学习1.4何为Python1.4.1使用Python软件的由来1.4.2为什么使用Python1.4.3Python设计定位1.4.
  • Python | Redis工具类 -拟墨画扇- Pythonredis数据库缓存python
    一、需求自动连接Redis数据库，通过连接池处理数据对输出结果进行Log打印并保存到文件二、代码Utils.redisUtils.py#!/usr/bin/envpython#-*-coding:utf-8-*-importredisfromUtils.loggerimportlog"""Redis数据格式(1)字符串|存储形式:key-value:str-存储二进制数据:可以存储任意类型的数据，
  • Python dict字符串转json对象，小数精度丢失问题 朝如青丝 暮成雪 jsonpython
    一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
  • 富格林：重视平台挑选阻挠虚假 fgl100 金融
    富格林悉知，在金融市场中，现货黄金一直被视为避险资产和投资保值的选择之一，吸引了众多投资者的关注。越来越多投资者也开始重视交易平台的挑选，毕竟虚假平台对我们的交易百害无一利。因此，我们要学会阻挠虚假平台选择正规可信平台。下面富格林将给大家总结一些阻挠虚假平台的挑选细则。注意平台的口碑评价是否优质。现货黄金交易市场巨大，平台数量众多，平台质量参差不齐，因此要挑选出优质平台，投资者需要了解平台的口碑评
  • Python+Requests模拟发送GET请求 爱学习的执念 自动化测试软件测试技术分享python开发语言
    模拟发送GET请求前置条件：导入requests库一、发送不带参数的get请求代码如下：以百度首页为例importrequests#发送get请求response=requests.get(url="http://www.baidu.com")print(response.content.decode("utf-8"))#以utf-8的编码输出内容二、发送带参数的get请求发送带参数的get请求有
  • Python极速入门：五分钟开启实战之旅！ 知白守黑V Python编程语言系统运维python编程语言python开发python学习python入门python数据分析
    1.Python基础语法和结构：了解Python的基本语法，包括变量、数据类型、运算符、注释等。控制流：掌握条件语句（if-elif-else）、循环（for和while）及其控制（break和continue）。函数：学习如何定义和使用函数，包括参数传递、返回值、作用域和闭包。模块和包：理解如何导入和使用模块，以及如何创建和使用自己的包。2.数据处理列表、元组和集合：学习这些序列类型的操作和方法
  • Python Flask 使用数据库 安果移不动 pythonflask开发语言
    pipinstallflask_sqlalchemy官方文档：Flask-SQLAlchemy—Flask-SQLAlchemyDocumentation(3.1.x)为了不报错也需要导入另外两个库#pipinstallflask_sqlalchemy#pipinstallmysqlclient完整代码importosfromflaskimportFlaskfromflask_sqlalchemy
  • 深度学习项目-基于深度学习的股票价格预测研究 雅致教育 计算机毕业设计深度学习人工智能
    概要  随着经济的发展，中国股票市场的规模持续扩大，早已成为金融投资的重要部分，掌握股票市场的变化规律无论是对监管者还是投资者都具有极其重要的意义。正因如此，人们不断探索着股票市场的变化规律，其中使用深度学习预测股价是当前国内国际研究与应用的热点。  本文首先从有效市场假说和分形市场假说两个角度讨论了中国股票市场的有效性，说明股票市场具有复杂的非线性特征。其次，结合股票市场特征对比了当前的预测方法
  • PaperWeekly sapienst PapersPaperwithCodeGeneralML
    1.Python软件包解决DL在未见过的数据分布下性能差的问题：（1）神经网络和损失分离的模块化设计（2）强大便捷的基准测试能力（3）易于使用但难以修改（4）github:https://github.com/marrlab/domainlabTrainer和Models之间是什么关系Trainer和Models是DomainLab中的两个核心概念。Trainer是一个用于指导数据流向模型并计算S
  • 如何在Win10系统下统计某目录下所有文件的数量 xiaofengxuan892 开发日常windows
    有些情况下需要统计Win10系统下某些目录中所有文件的数量，可以直接在该目录下打开cmd窗口，也可以使用cd命令跳转到指定目录：只统计文件夹数量：统计该目录下文件夹的数量——只是一级目录：dir/b/ad|find/v/c"::"统计该目录下所有文件夹的数量——该目录下所有文件夹，包含子目录下的文件夹：dir/b/s/ad|find/v/c"::"只统计文件数量：统计该目录下文件的数量——只是本目
  • 使用Python读取Excel文件并计算平均分 嘻嘻爱编码 Python从入门到放弃pythonexcel开发语言
    在这篇博客中，我们将探讨如何使用Python的pandas库来读取Excel文件，并计算其中数据的平均分。pandas是一个强大的数据分析工具，它允许我们以简单直观的方式处理表格数据。安装必要的库在开始之前，确保你的环境中安装了pandas和openpyxl库。可以使用以下命令进行安装：pipinstallpandasopenpyxl读取Excel文件首先，我们需要读取Excel文件。假设我们有一
  • python项目练习——7.网站访问日志分析器 F—— python项目练习python信息可视化数据分析数据挖掘开发语言学习
    项目功能分析：这个项目可以读取网站的访问日志文件，统计访问量、独立访客数、访问来源等信息，并以图表或表格的形式展示出来。这个项目涉及到文件操作、数据处理、数据可视化等方面的技术。示例代码：importrefromcollectionsimportCounterimportmatplotlib.pyplotaspltdefparse_log_file(log_file):#读取日志文件内容witho
  • python的while双重循环九九乘法表 Jinm_R python开发语言
    a=1whilea<=9:b=1#乘数每次需要从1开始whileb<=a:print(f"{a}*{b}={a*b}\t",end='')#\t为制表符使乘法表整齐end=''代表用空格代替换行b+=1a+=1print()#乘数每加一换行
  • ChatGPT技巧大揭秘：AI写代码新境界 2401_83550420 chatgpt4.0chatgptchatgpt人工智能AI写作
    ChatGPT无限次数:点击直达ChatGPT技巧大揭秘：AI写代码新境界随着人工智能技术的不断进步，开发人员现在有了更多有趣的工具来提高他们的工作效率。其中，ChatGPT作为一种基于深度学习的自然语言处理模型，已经成为许多开发者的新宠。在本文中，我们将揭秘使用ChatGPT来帮助编写代码的技巧，探索AI在编程领域的新境界。ChatGPT简介ChatGPT是一种基于大型神经网络的对话生成模型，它
  • ChatGPT：AI合作伙伴助你成为论文写作高手 2401_83550420 chatgptchatgpt人工智能AI写作
    ChatGPT无限次数:点击直达摘要：本文将介绍ChatGPT3.5Turbo（以下简称ChatGPT），一款强大的AI合作伙伴，能够助你成为一名论文写作高手。我们将深入探讨ChatGPT的特点、优势，并提供多个示例，展示ChatGPT在论文写作中的应用。无论是开展研究、撰写论文、还是与ChatGPT进行互动交流，都能够帮助你提升写作效率和质量。引言：随着人工智能的发展，聊天型语言模型在各个领域都
  • ztree异步加载 3213213333332132 JavaScriptAjaxjsonWebztree
    相信新手用ztree的时候,对异步加载会有些困惑，我开始的时候也是看了API花了些时间才搞定了异步加载，在这里分享给大家。 我后台代码生成的是json格式的数据，数据大家按各自的需求生成，这里只给出前端的代码。 设置setting，这里只关注async属性的配置 var setting = { //异步加载配置
  • thirft rpc 具体调用流程 BlueSkator 中间件rpcthrift
    Thrift调用过程中，Thrift客户端和服务器之间主要用到传输层类、协议层类和处理类三个主要的核心类，这三个类的相互协作共同完成rpc的整个调用过程。在调用过程中将按照以下顺序进行协同工作：         （1）     将客户端程序调用的函数名和参数传递给协议层（TProtocol），协议
  • 异或运算推导, 交换数据 dcj3sjt126com PHP异或^
    /* * 5 0101 * 9 1010 * * 5 ^ 5 * 0101 * 0101 * ----- * 0000 * 得出第一个规律: 相同的数进行异或, 结果是0 * * 9 ^ 5 ^ 6 * 1010 * 0101 * ---- * 1111 * * 1111 * 0110 * ---- * 1001
  • 事件源对象 周华华 JavaScript
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • MySql配置及相关命令 g21121 mysql
            MySQL安装完毕后我们需要对它进行一些设置及性能优化，主要包括字符集设置，启动设置，连接优化，表优化，分区优化等等。           一 修改MySQL密码及用户      
  • [简单]poi删除excel 2007超链接 53873039oycg Excel
          采用解析sheet.xml方式删除超链接，缺点是要打开文件2次,代码如下:      public void removeExcel2007AllHyperLink(String filePath) throws Exception { OPCPackage ocPkg = OPCPac
  • Struts2添加 open flash chart 云端月影
    准备以下开源项目： 1. Struts 2.1.6 2. Open Flash Chart 2 Version 2 Lug Wyrm Charmer (28th, July 2009) 3. jofc2，这东西不知道是没做好还是什么意思，好像和ofc2不怎么匹配，最好下源码，有什么问题直接改。 4. log4j 用eclipse新建动态网站，取名OFC2Demo，将Struts2 l
  • spring包详解 aijuans spring
    下载的spring包中文件及各种包众多，在项目中往往只有部分是我们必须的，如果不清楚什么时候需要什么包的话，看看下面就知道了。 aspectj目录下是在Spring框架下使用aspectj的源代码和测试程序文件。Aspectj是java最早的提供AOP的应用框架。 dist 目录下是Spring 的发布包，关于发布包下面会详细进行说明。 docs&nb
  • 网站推广之seo概念 antonyup_2006 算法Web应用服务器搜索引擎Google
       持续开发一年多的b2c网站终于在08年10月23日上线了。作为开发人员的我在修改bug的同时，准备了解下网站的推广分析策略。     所谓网站推广，目的在于让尽可能多的潜在用户了解并访问网站，通过网站获得有关产品和服务等信息，为最终形成购买决策提供支持。     网站推广策略有很多，seo，email，adv
  • 单例模式,sql注入,序列 百合不是茶 单例模式序列sql注入预编译
      序列在前面写过有关的博客,也有过总结,但是今天在做一个JDBC操作数据库的相关内容时 需要使用序列创建一个自增长的字段  居然不会了,所以将序列写在本篇的前面    1,序列是一个保存数据连续的增长的一种方式; 序列的创建; CREATE SEQUENCE seq_pro 2 INCREMENT BY 1 -- 每次加几个 3
  • Mockito单元测试实例 bijian1013 单元测试mockito
    Mockito单元测试实例： public class SettingServiceTest { private List<PersonDTO> personList = new ArrayList<PersonDTO>(); @InjectMocks private SettingPojoService settin
  • 精通Oracle10编程SQL(9)使用游标 bijian1013 oracle数据库plsql
    /* *使用游标 */ --显示游标 --在显式游标中使用FETCH...INTO语句 DECLARE CURSOR emp_cursor is select ename,sal from emp where deptno=1; v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; begin ope
  • 【Java语言】动态代理 bit1129 java语言
      JDK接口动态代理 JDK自带的动态代理通过动态的根据接口生成字节码(实现接口的一个具体类)的方式，为接口的实现类提供代理。被代理的对象和代理对象通过InvocationHandler建立关联   package com.tom; import com.tom.model.User; import com.tom.service.IUserService;
  • Java通信之URL通信基础 白糖_ javajdkwebservice网络协议ITeye
    java对网络通信以及提供了比较全面的jdk支持，java.net包能让程序员直接在程序中实现网络通信。 在技术日新月异的现在，我们能通过很多方式实现数据通信，比如webservice、url通信、socket通信等等，今天简单介绍下URL通信。 学习准备：建议首先学习java的IO基础知识   URL是统一资源定位器的简写，URL可以访问Internet和www，可以通过url
  • 博弈Java讲义 - Java线程同步 (1) boyitech java多线程同步锁
      在并发编程中经常会碰到多个执行线程共享资源的问题。例如多个线程同时读写文件，共用数据库连接，全局的计数器等。如果不处理好多线程之间的同步问题很容易引起状态不一致或者其他的错误。    同步不仅可以阻止一个线程看到对象处于不一致的状态，它还可以保证进入同步方法或者块的每个线程，都看到由同一锁保护的之前所有的修改结果。处理同步的关键就是要正确的识别临界条件（cri
  • java-给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 bylijinnan java
    public class DeleteExtraSpace { /** * 题目：给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 * 方法1.用已有的String类的trim和replaceAll方法 * 方法2.全部用正则表达式，这个我不熟 * 方法3.“重新发明轮子”，从头遍历一次 */ public static v
  • An error has occurred.See the log file错误解决！ Kai_Ge MyEclipse
    今天早上打开MyEclipse时，自动关闭！弹出An error has occurred.See the log file错误提示！ 很郁闷昨天启动和关闭还好着！！！打开几次依然报此错误，确定不是眼花了！ 打开日志文件！找到当日错误文件内容： --------------------------------------------------------------------------
  • [矿业与工业]修建一个空间矿床开采站要多少钱? comsci
           地球上的钛金属矿藏已经接近枯竭...........        我们在冥王星的一颗卫星上面发现一些具有开采价值的矿床.....        那么,现在要编制一个预算,提交给财政部门..
  • 解析Google Map Routes dai_lm google api
    为了获得从A点到B点的路劲，经常会使用Google提供的API，例如 [url] http://maps.googleapis.com/maps/api/directions/json?origin=40.7144,-74.0060&destination=47.6063,-122.3204&sensor=false [/url] 从返回的结果上，大致可以了解应该怎么走，但
  • SQL还有多少“理所应当”？ datamachine sql
    转贴存档，原帖地址：http://blog.chinaunix.net/uid-29242841-id-3968998.html、http://blog.chinaunix.net/uid-29242841-id-3971046.html！ ------------------------------------华丽的分割线--------------------------------
  • Yii使用Ajax验证时，如何设置某些字段不需要验证 dcj3sjt126com Ajaxyii
    经常像你注册页面,你可能非常希望只需要Ajax去验证用户名和Email,而不需要使用Ajax再去验证密码,默认如果你使用Yii 内置的ajax验证Form,例如: $form=$this->beginWidget('CActiveForm', array(        'id'=>'usuario-form',&
  • 使用git同步网站代码 dcj3sjt126com crontabgit
    转自:http://ued.ctrip.com/blog/?p=3646?tn=gongxinjun.com   管理一网站，最开始使用的虚拟空间，采用提供商支持的ftp上传网站文件，后换用vps，vps可以自己搭建ftp的，但是懒得搞，直接使用scp传输文件到服务器，现在需要更新文件到服务器，使用scp真的很烦。发现本人就职的公司，采用的git+rsync的方式来管理、同步代码，遂
  • sql基本操作 蕃薯耀 sqlsql基本操作sql常用操作
    sql基本操作 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:30:33 星期一     &
  • Spring4+Hibernate4+Atomikos3.3多数据源事务管理 hanqunfeng Hibernate4
    Spring3+后不再对JTOM提供支持，所以可以改用Atomikos管理多数据源事务。Spring2.5+Hibernate3+JTOM参考：http://hanqunfeng.iteye.com/blog/1554251Atomikos官网网站：http://www.atomikos.com/   一.pom.xml <dependency> <
  • jquery中两个值得注意的方法one()和trigger()方法 jackyrong trigger
      在jquery中，有两个值得注意但容易忽视的方法，分别是one()方法和trigger()方法,这是从国内作者<<jquery权威指南》一书中看到不错的介绍 1） one方法     one方法的功能是让所选定的元素绑定一个仅触发一次的处理函数，格式为    one(type,${data},fn) &nb
  • 拿工资不仅仅是让你写代码的 lampcy 工作面试咨询
    这是我对团队每个新进员工说的第一件事情。这句话的意思是，我并不关心你是如何快速完成任务的，哪怕代码很差，只要它像救生艇通气门一样管用就行。这句话也是我最喜欢的座右铭之一。 这个说法其实很合理：我们的工作是思考客户提出的问题，然后制定解决方案。思考第一，代码第二，公司请我们的最终目的不是写代码，而是想出解决方案。 话粗理不粗。 付你薪水不是让你来思考的，也不是让你来写代码的，你的目的是交付产品
  • 架构师之对象操作----------对象的效率复制和判断是否全为空 nannan408 架构师
    1.前言。   如题。 2.代码。 (1)对象的复制，比spring的beanCopier在大并发下效率要高，利用net.sf.cglib.beans.BeanCopier Src src=new Src(); BeanCopier beanCopier = BeanCopier.create(Src.class, Des.class, false);
  • ajax 被缓存的解决方案 Rainbow702 JavaScriptjqueryAjaxcache缓存
    使用jquery的ajax来发送请求进行局部刷新画面，各位可能都做过。 今天碰到一个奇怪的现象，就是，同一个ajax请求，在chrome中，不论发送多少次，都可以发送至服务器端，而不会被缓存。但是，换成在IE下的时候，发现，同一个ajax请求，会发生被缓存的情况，只有第一次才会被发送至服务器端，之后的不会再被发送。郁闷。 解决方法如下： ① 直接使用 JQuery提供的 “cache”参数，
  • 修改date.toLocaleString()的警告 tntxia String
      我们在写程序的时候，经常要查看时间，所以我们经常会用到date.toLocaleString()，但是date.toLocaleString()是一个过时 的API，代替的方法如下：   package com.tntxia.htmlmaker.util; import java.text.SimpleDateFormat; import java.util.
  • 项目完成后的小总结 xiaomiya js总结项目
    项目完成了，突然想做个总结但是有点无从下手了。 做之前对于客户端给的接口很模式。然而定义好了格式要求就如此的愉快了。 先说说项目主要实现的功能吧 1，按键精灵 2，获取行情数据 3，各种input输入条件判断 4，发送数据（有json格式和string格式） 5，获取预警条件列表和预警结果列表， 6，排序， 7，预警结果分页获取 8，导出文件（excel，text等） 9，修
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他