pytorch 测量模型运行时间，GPU时间和CPU时间，model.eval()介绍

1. 测量时间的方式

time.time()
time.perf_counter()
time.process_time()

time.time() 和time.perf_counter() 包括sleep()time 可以用作一般的时间测量，time.perf_counter()精度更高一些
time.process_time()当前进程的系统和用户CPU时间总和的值

测试代码：

def show_time():
    print('我是time()方法：{}'.format(time.time()))
    print('我是perf_counter()方法：{}'.format(time.perf_counter()))
    print('我是process_time()方法：{}'.format(time.process_time()))
    t0 = time.time()
    c0 = time.perf_counter()
    p0 = time.process_time()
    r = 0
    for i in range(10000000):
        r += i
    time.sleep(2)
    print(r)
    t1 = time.time()
    c1 = time.perf_counter()
    p1 = time.process_time()
    spend1 = t1 - t0
    spend2 = c1 - c0
    spend3 = p1 - p0
    print("time()方法用时：{}s".format(spend1))
    print("perf_counter()用时：{}s".format(spend2))
    print("process_time()用时：{}s".format(spend3))
    print("测试完毕")

测试结果：

更详细解释参考
Python3.7中time模块的time()、perf_counter()和process_time()的区别

2. model.eval(), model.train(), torch.no_grad()方法介绍

2.1 model.train()和model.eval()

我们知道，在pytorch中，模型有两种模式可以设置，一个是train模式、另一个是eval模式。

model.train()的作用是启用 Batch Normalization 和 Dropout。在train模式，Dropout层会按照设定的参数p设置保留激活单元的概率，如keep_prob=0.8，Batch Normalization层会继续计算数据的mean和var并进行更新。

model.eval()的作用是不启用 Batch Normalization 和 Dropout。在eval模式下，Dropout层会让所有的激活单元都通过，而Batch Normalization层会停止计算和更新mean和var，直接使用在训练阶段已经学出的mean和var值。

在使用model.eval()时就是将模型切换到测试模式，在这里，模型就不会像在训练模式下一样去更新权重。但是需要注意的是model.eval()不会影响各层的梯度计算行为，即会和训练模式一样进行梯度计算和存储，只是不进行反向传播。

2.2 model.eval()和torch.no_grad()

在讲model.eval()时，其实还会提到torch.no_grad()。

torch.no_grad()用于停止autograd的计算，能起到加速和节省显存的作用，但是不会影响Dropout层和Batch Normalization层的行为。

如果不在意显存大小和计算时间的话，仅仅使用model.eval()已足够得到正确的validation的结果；而with torch.zero_grad()则是更进一步加速和节省gpu空间。因为不用计算和存储梯度，从而可以计算得更快，也可以使用更大的batch来运行模型。

3. 模型推理时间方式

在测量时间的时候，与一般测试不同，比如下面的代码不正确：

start = time.time()
result = model(input)
end = time.time()

而应该采用：

torch.cuda.synchronize()
start = time.time()
result = model(input)
torch.cuda.synchronize()
end = time.time()

因为在pytorch里面，程序的执行都是异步的。
如果采用代码1，测试的时间会很短，因为执行完end=time.time()程序就退出了，后台的cu也因为python的退出退出了。
如果采用代码2，代码会同步cu的操作，等待gpu上的操作都完成了再继续成形end = time.time()

4. 一个完整的测试模型推理时间的代码

一般是首先model.eval()不启用 Batch Normalization 和 Dropout, 不启用梯度更新
然后利用mode创建模型，和初始化输入数据（单张图像）

def measure_inference_speed(model, data, max_iter=200, log_interval=50):
    model.eval()

    # the first several iterations may be very slow so skip them
    num_warmup = 5
    pure_inf_time = 0
    fps = 0

    # benchmark with 2000 image and take the average
    for i in range(max_iter):

        torch.cuda.synchronize()
        start_time = time.perf_counter()

        with torch.no_grad():
            model(*data)

        torch.cuda.synchronize()
        elapsed = time.perf_counter() - start_time

        if i >= num_warmup:
            pure_inf_time += elapsed
            if (i + 1) % log_interval == 0:
                fps = (i + 1 - num_warmup) / pure_inf_time
                print(
                    f'Done image [{i + 1:<3}/ {max_iter}], '
                    f'fps: {fps:.1f} img / s, '
                    f'times per image: {1000 / fps:.1f} ms / img',
                    flush=True)

        if (i + 1) == max_iter:
            fps = (i + 1 - num_warmup) / pure_inf_time
            print(
                f'Overall fps: {fps:.1f} img / s, '
                f'times per image: {1000 / fps:.1f} ms / img',
                flush=True)
            break
    return fps
if __name__ == "__main__":
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    # device = 'cpu'
    print(device)
    img_channel = 3
    width = 32

    enc_blks = [2, 2, 4, 8]
    middle_blk_num = 12
    dec_blks = [2, 2, 2, 2]

    width = 16
    enc_blks = [1, 1, 1]
    middle_blk_num = 1
    dec_blks = [1, 1, 1]

    net = NAFNet(img_channel=img_channel, width=width, middle_blk_num=middle_blk_num,
                 enc_blk_nums=enc_blks, dec_blk_nums=dec_blks)
    net = net.to(device)

    data = [torch.rand(1, 3, 256, 256).to(device)]
    fps = measure_inference_speed(net, data)
    print('fps:', fps)

    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    # device = 'cpu'
    print(device)
	
	# sample 2
    net = UNetSeeInDark()
    net = net.to(device)

    data = [torch.rand(1, 4, 400, 400).to(device)]
    fps = measure_inference_speed(net, data)
    print('fps:', fps)

    # gpu : 32ms  cpu: 350ms
    summary(net, input_size=(1, 4, 400, 400), col_names=["kernel_size", "output_size", "num_params", "mult_adds"])
    from ptflops import get_model_complexity_info

    macs, params = get_model_complexity_info(net, (4, 400, 400), verbose=True, print_per_layer_stat=True)
    print(macs, params)

5. 参考：

https://blog.csdn.net/weixin_44317740/article/details/104651434
https://zhuanlan.zhihu.com/p/547033884
https://deci.ai/blog/measure-inference-time-deep-neural-networks/
https://github.com/xinntao/BasicSR