Pytorch骨干网络性能测试

Pytorch骨干网络性能测试

测试平台:

• Intel® Core™ i7-8700 CPU @ 3.20GHz × 12
• GeForce RTX 2070/PCIe/SSE2

backbone	input size	output size	run time /ms	GPU/MiB
mobilenet_v2	[1,3,112,112]	512	4.743	910
reset18	[1,3,112,112]	512	2.372	960
resnet34	[1,3,112,112]	512	3.974	1010
vgg16	[1,3,112,112]	512	3.844	1460
squeezenet1_0	[1,3,112,112]	512	2.103	897
squeezenet1_1	[1,3,112,112]	512	2.095	891
mnasnet1_0	[1,3,112,112]	512	4.248	909
shufflenet_v2_x1_0	[1,3,112,112]	512	5.449	891
inception_v3	[1,3,112,112]	512	12.341	1203
googlenet	[1,3,112,112]	512	5.752	935
MixNet_S	[1,3,112,112]	512	8.260	930
MixNet_M	[1,3,112,112]	512	9.914	960
MixNet_L	[1,3,112,112]	512	10.020	990

测试代码:

# -*-coding: utf-8 -*-
"""
    @Project: pytorch-learning-tutorials
    @File   : main.py
    @Author : panjq
    @E-mail : [email protected]
    @Date   : 2019-06-27 13:46:20
"""
import torch
from torchvision import models
from utils import debug
import performance.core.mixnet as mixnet

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# device = 'cpu'
print("-----device:{}".format(device))
print("-----Pytorch version:{}".format(torch.__version__))


# @debug.run_time_decorator()
def model_forward(model, input_tensor):
    T0 = debug.TIME()
    out = model(input_tensor)
    torch.cuda.synchronize()
    T1 = debug.TIME()
    time = debug.RUN_TIME(T1 - T0)
    return out, time


def iter_model(model, input_tensor, iter):
    out, time = model_forward(model, input_tensor)
    all_time = 0
    for i in range(iter):
        out, time = model_forward(model, input_tensor)
        all_time += time
    return all_time


def squeezenet1_0(input_tensor, out_features, iter=10):
    model = models.squeezenet.squeezenet1_0(pretrained=False, num_classes=out_features).to(device)
    model.eval()
    all_time = iter_model(model, input_tensor, iter)
    print("squeezenet1_0,mean run time :{:.3f}".format(all_time / iter))


def squeezenet1_1(input_tensor, out_features, iter=10):
    model = models.squeezenet.squeezenet1_1(pretrained=False, num_classes=out_features).to(device)
    model.eval()
    all_time = iter_model(model, input_tensor, iter)
    print("squeezenet1_1,mean run time :{:.3f}".format(all_time / iter))


def mnasnet1_0(input_tensor, out_features, iter=10):
    model = models.mnasnet.mnasnet1_0(pretrained=False, num_classes=out_features).to(device)
    model.eval()
    all_time = iter_model(model, input_tensor, iter)
    print("mnasnet1_0,mean run time :{:.3f}".format(all_time / iter))


def shufflenet_v2_x1_0(input_tensor, out_features, iter=10):
    model = models.shufflenetv2.shufflenet_v2_x1_0(pretrained=False, num_classes=out_features).to(device)
    model.eval()
    all_time = iter_model(model, input_tensor, iter)
    print("shufflenet_v2_x1_0,mean run time :{:.3f}".format(all_time / iter))


def mobilenet_v2(input_tensor, out_features, iter=10):
    model = models.mobilenet_v2(pretrained=False, num_classes=out_features).to(device)
    model.eval()
    all_time = iter_model(model, input_tensor, iter)
    print("mobilenet_v2,mean run time :{:.3f}".format(all_time / iter))


def resnet18(input_tensor, out_features, iter=10):
    model = models.resnet18(pretrained=False, num_classes=out_features).to(device)
    model.eval()
    all_time = iter_model(model, input_tensor, iter)
    print("reset18,mean run time :{:.3f}".format(all_time / iter))


def resnet34(input_tensor, out_features, iter=10):
    model = models.resnet34(pretrained=False, num_classes=out_features).to(device)
    model.eval()
    all_time = iter_model(model, input_tensor, iter)
    print("resnet34,mean run time :{:.3f}".format(all_time / iter))


def vgg16(input_tensor, out_features, iter=10):
    model = models.vgg16(pretrained=False, num_classes=out_features).to(device)
    model.eval()
    all_time = iter_model(model, input_tensor, iter)
    print("vgg16,mean run time :{:.3f}".format(all_time / iter))


def MixNet_L(input_tensor, input_size, out_features, iter=10):
    model = mixnet.MixNet_L(input_size, out_features).to(device)
    model.eval()
    all_time = iter_model(model, input_tensor, iter)
    print("MixNet_L,mean run time :{:.3f}".format(all_time / iter))


def MixNet_M(input_tensor, input_size, out_features, iter=10):
    model = mixnet.MixNet_M(input_size, out_features).to(device)
    model.eval()
    all_time = iter_model(model, input_tensor, iter)
    print("MixNet_M,mean run time :{:.3f}".format(all_time / iter))


def MixNet_S(input_tensor, input_size, out_features, iter=10):
    model = mixnet.MixNet_S(input_size, out_features).to(device)
    model.eval()
    all_time = iter_model(model, input_tensor, iter)
    print("MixNet_S,mean run time :{:.3f}".format(all_time / iter))


def inception_v3(input_tensor, out_features, iter=10):
    model = models.inception.inception_v3(pretrained=False, num_classes=out_features).to(device)
    model.eval()
    all_time = iter_model(model, input_tensor, iter)
    print("inception_v3,mean run time :{:.3f}".format(all_time / iter))

def googlenet(input_tensor, out_features, iter=10):
    model = models.googlenet(pretrained=False, num_classes=out_features).to(device)
    model.eval()
    all_time = iter_model(model, input_tensor, iter)
    print("googlenet,mean run time :{:.3f}".format(all_time / iter))

if __name__ == "__main__":
    input_size = [112, 112]
    out_features = 512
    input_tensor = torch.randn(1, 3, input_size[0], input_size[1]).to(device)
    print('input_tensor:', input_tensor.shape)
    iter = 10000
    # mobilenet_v2(input_tensor, out_features, iter)
    # resnet18(input_tensor, out_features, iter)
    # resnet34(input_tensor, out_features, iter)
    # vgg16(input_tensor, out_features, iter)
    # squeezenet1_0(input_tensor, out_features, iter)
    # squeezenet1_1(input_tensor, out_features, iter)
    # inception_v3(input_tensor, out_features, iter)
    googlenet(input_tensor, out_features, iter)

    # mnasnet1_0(input_tensor, out_features, iter)
    # shufflenet_v2_x1_0(input_tensor, out_features, iter)
    # MixNet_S(input_tensor, input_size, out_features, iter)
    # MixNet_M(input_tensor, input_size, out_features, iter)
    # MixNet_L(input_tensor, input_size, out_features, iter)