深度学习-模型转换_所需算力相关

模型转换相关

tensflow转onnx

python -m tf2onnx.convert  \

--graphdef /root/autodl-tmp/warren/text-detection-ctpn/data/ctpn.pb  \

--output ./model.onnx  --inputs Placeholder:0 --outputs Reshape_2:0,rpn_bbox_pred/Reshape_1:0

pytorch转onnx

#!/usr/bin/env python3

import torch

from simple_net import SimpleModel

# Load the pretrained model and export it as onnx

model = SimpleModel()

model.eval()

checkpoint = torch.load("weight.pth", map_location="cpu")

model.load_state_dict(checkpoint)


# Prepare input tensor

input = torch.randn(1, 1, 28, 28, requires_grad=True)#batch size-1 input cahnne-1 image size 28*28


# Export the torch model as onnx

torch.onnx.export(model,

            input,

            'model.onnx', # name of the exported onnx model

            opset_version=11,

            export_params=True,

            do_constant_folding=True)

模型所需算力测算

手动测算

网络代码

class SimpleModel(nn.Module):

    def __init__(self):

        super(SimpleModel, self).__init__()

        self.conv1 = nn.Conv2d(1,10,5) #1 input channel 10 outchannel 5 kernel size

        self.conv2 = nn.Conv2d(10,20,3) #same as above

        self.fc1   = nn.Linear(20*10*10,500) #in / out

        self.fc2   = nn.Linear(500,10) #same as above


    def forward(self, x):

        input_size = x.size(0)

        x = self.conv1(x) #in batch*1*28*28 out batch*10*24*24(28-5+1)

        x = F.relu(x)     #keep shape not change  out batch*10*24*24

        x = F.max_pool2d(x,2,2) #in batch*10*10*24 out batch*10*12*12(24/2)

        x = self.conv2(x) #in batch*10*12*12 out:batch 20*10*10(12-3+1)

        x = F.relu(x)

        x = x.view(input_size,-1)  #flatten -1:caculate dimens autoly 20*10*10

        x = self.fc1(x)# in :batch*2000 out batch*500

        x = F.relu(x) #keep sahpe not change

        x = self.fc2(x) #in 500 out 10

        output = F.log_softmax(x,dim=1) #caculate possibility

        #print("------------------------------output is ",output)

        return output

计算过程:

参数量

conv1层:1 input channel * 10 output channels * 5 * 5 kernel size + 10 bias = 260 个参数

conv2层:10 input channels * 20 output channels * 3 * 3 kernel size + 20 bias= 1820 个参数

fc1全连接层:20 * 10 * 10 (20个通道,每个通道大小为10*10) * 500 (输出大小) + 500 bias = 1000500 个参数

fc2全连接层:500 (输入大小) * 10 (输出大小) + 10 bias = 5010 个参数

总参数量为:260 + 1820 + 1000500 + 5010 = 1010120 个参数

Macs

1)conv1 层的FLOPs计算:

conv1 层是一个卷积层,输入大小为 batch * 1 * 28 * 28(假设batch大小为B,输入通道数为1,高度为28,宽度为28),输出大小为 batch * 10 * 24 * 24(输出通道数为10,高度为24,宽度为24)。在卷积操作中,每个输出位置需要进行一个 5 * 5 的卷积操作。因此,计算FLOPs的公式为:

其中,B为batch大小为1

FLOPs_conv1 = B * 10 * 24 * 24 * 5 * 5=14400

 2)conv2 层的FLOPs计算:

conv2 层也是一个卷积层,输入大小为 batch * 10 * 12 * 12,输出大小为 batch * 20 * 10 * 10。在卷积操作中,每个输出位置需要进行一个 3 * 3 的卷积操作。因此,计算FLOPs的公式为:

FLOPs_conv2 = B * 20 * 10 * 10 * 3 * 3

3)fc1 全连接层的FLOPs计算:

fc1 全连接层将二维的特征图展平为一维向量,并进行全连接操作。输入大小为 batch * (20 * 10 * 10)(即展平后的大小),输出大小为 batch * 500。在全连接操作中,每个输出位置需要进行一个乘法和一个加法操作。因此,计算FLOPs的公式为:

FLOPs_fc1 = B * (20 * 10 * 10) * 500 * 2

4)fc2 全连接层的FLOPs计算:

fc2 全连接层将输出大小从 500 减少到 10。输入大小为 batch * 500,输出大小为 batch * 10。在全连接操作中,每个输出位置需要进行一个乘法和一个加法操作。因此,计算FLOPs的公式为:

FLOPs_fc2 = B * 500 * 10 * 2

5)现在我们将这四层的FLOPs相加得到总体的FLOPs

总体FLOPs = FLOPs_conv1 + FLOPs_conv2 + FLOPs_fc1 + FLOPs_fc2

总体FLOPs = B * 10 * 24 * 24 * 5 * 5 + B * 20 * 10 * 10 * 3 * 3 + B * (20 * 10 * 10) * 500 * 2 + B * 500 * 10 * 2

由于模型的参数量不依赖于batch大小B,所以FLOPs也不依赖于batch大小B。因此,我们可以直接将batch大小B忽略,得到最终的总体FLOPs:

总体FLOPs = 10 * 24 * 24 * 5 * 5 + 20 * 10 * 10 * 3 * 3 + (20 * 10 * 10) * 500 * 2 + 500 * 10 * 2

总体FLOPs ≈ 149760 + 182000 + 1000000 + 5010 = 1342770 个 FLOPs

6)因此,这个 "SimpleModel" 模型的总体FLOPs为 1342770 个 FLOPs,也就是 1.34 MMac(1.34百万次乘加运算)。

测试代码

'''

Author: warren

Date: 2023-08-01 16:22:02

LastEditors: warren

LastEditTime: 2023-08-01 16:26:45

FilePath: /wzw/MNIST/cal_flops.py

Description:


Copyright (c) 2023 by ${git_name_email}, All Rights Reserved.

'''

#!/usr/bin/env python3

import torchvision.models as models

import torch 

from simple_net import SimpleModel

from ptflops import get_model_complexity_info

DEVICE     = torch.device("cuda" if torch.cuda.is_available() else "cpu")

 

with torch.cuda.device(0):

    model     = SimpleModel().to(DEVICE)

    input_data = torch.randn(1, 1, 28, 28)

    macs, params = get_model_complexity_info(model, (1, 28, 28), as_strings=True,

                                           print_per_layer_stat=True, verbose=True)

   

print('{:<30}  {:<8}'.format('Computational complexity: ', macs))

print('{:<30}  {:<8}'.format('Number of parameters: ', params))

结果

SimpleModel(

  1.01 M, 100.000% Params, 1.34 MMac, 100.000% MACs,

  (conv1): Conv2d(260, 0.026% Params, 149.76 KMac, 11.199% MACs, 1, 10, kernel_size=(5, 5), stride=(1, 1))

  (conv2): Conv2d(1.82 k, 0.181% Params, 182.0 KMac, 13.610% MACs, 10, 20, kernel_size=(3, 3), stride=(1, 1))

  (fc1): Linear(1.0 M, 99.296% Params, 1.0 MMac, 74.817% MACs, in_features=2000, out_features=500, bias=True)

  (fc2): Linear(5.01 k, 0.497% Params, 5.01 KMac, 0.375% MACs, in_features=500, out_features=10, bias=True)

)

Computational complexity:       1.34 MMac

Number of parameters:           1.01 M

参数解释

Params 参数量 Mac乘加运算总数

总参数量:1.01 M(1,010,000个参数),占100.000%。

总浮点运算量(MACs):1.34 MMac(1,340,000次乘加运算),占100.000%。

各层的详细信息:

conv1层

参数量:0.026%(大约260个参数)

MACs:11.199%(大约149.76 KMac,即149,760次乘加运算)

conv2层

参数量:0.181%(大约1.82 k个参数)

MACs:13.610%(大约182.0 KMac,即182,000次乘加运算)

fc1全连接层

参数量:99.296%(大约1.0 M个参数)

MACs:74.817%(大约1.0 MMac,即1,000,000次乘加运算)

fc2全连接层

参数量:0.497%(大约5.01 k个参数)

MACs:0.375%(大约5.01 KMac,即5,010次乘加运算)

总体计算复杂度:1.34 MMac(1,340,000次乘加运算)。

总参数量:1.01 M(1,010,000个参数)。

你可能感兴趣的:(深度学习,人工智能,服务器,神经网络,cnn)