关于pytorch:PyTorch模型推理及多任务通用范式-课程3-作业

Course

PyTorch 模型推理及多任务通用范式 课程 3:

1. pytorch 模型推理的三板斧：数据预处理、数据进网络、数据后处理。其中

   • 数据预处理要向训练时的预处理形式对齐；
   • 模型网络次要是加载预训练权重；
   • 数据后处理要向模型 head 构造和 loss 设计对齐。
2. 以 MobileNet-v2 为例，从头写了把模型推理。

Assignment

必做题

1. 把模型改为 resnet18，加载相应的模型权重（Lesson2 的物料包中有），跑一下 0.jpg 和 1.jpg，看一下输入后果。官网 torchvision 训练 mobilenet 和训练 resnet 的形式是一样的，所以数据预处理和数据后处理局部完全相同。
2. 本人找 2 张其余图，用 resnet18 做下推理。

思考题

1. 以 ResNet18 为例，用 time 模块和 for 循环，对”./images/0.jpg”间断推理 100 次，统计工夫开销，比方：

    import time
    model_classify=ModelPipline() 
    image=cv2.imread("./images/0.jpg")
    t_all=0
    for i in range(100):    
        t_start=time.time()    
        result=model_classify.predict(image)    
        t_end=time.time()    
        t_all+=t_end - t_start
    print(t_all) 

   有 CUDA 的同学，改下代码：

    self.device=torch.device('cuda')。

   用上述雷同办法测试工夫开销。

2. 在数据预处理和数据后处理的代码实现中，到处在用 numpy, opencv, torch 对数组做相应变换，大家至多要把课程中呈现的函数们给了解。

Solutions

Code

import torch
import torchvision.models as models
import numpy as np
import cv2
import time

class ModelPipline(object):
    def __init__(self, device=torch.device('cpu')):
        # 进入模型的图片大小：为数据预处理和后处理做筹备
        self.inputs_size = (224, 224)
        # Add input parameter device
        self.device = device
        # 载入模型构造和模型权重
        self.model = self.get_model()
        # 载入标签，为数据后处理做筹备
        label_names = open('./labels/imagenet_label.txt', 'r').readlines()
        self.label_names = [line.strip('\n') for line in label_names]

    def predict(self, image):
        # 数据预处理
        inputs = self.preprocess(image)
        # 数据进网络
        outputs = self.model(inputs)
        # 数据后处理
        results = self.postprocess(outputs)
        return results

    def get_model(self):
        # modified to load pytorch official weight
        model = models.resnet18(pretrained=True)
        model.to(self.device)
        model.eval()
        return model

    def preprocess(self, image):
        # opencv 默认读入是 BGR，须要转为 RGB，和训练时保持一致
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        # resize 成模型输出的大小，和训练时保持一致
        image = cv2.resize(image, dsize=self.inputs_size)
        # 归一化和标准化，和训练时保持一致
        inputs = image / 255
        inputs = (inputs - np.array([0.485, 0.456, 0.406])) / np.array([0.229, 0.224, 0.225])
        ## 以下是图像工作的通用解决
        # (H,W,C) ——> (C,H,W)
        inputs = inputs.transpose(2, 0, 1)
        # (C,H,W) ——> (1,C,H,W)
        inputs = inputs[np.newaxis, :, :, :]
        # NumpyArray ——> Tensor
        inputs = torch.from_numpy(inputs)
        # dtype float32
        inputs = inputs.type(torch.float32)
        # 与 self.model 放在雷同硬件上
        inputs = inputs.to(self.device)
        return inputs

    def postprocess(self, outputs):
        # 取 softmax 失去每个类别的置信度
        outputs = torch.softmax(outputs, dim=1)
        # 取最高置信度的类别和分数
        score, label_id = torch.max(outputs, dim=1)
        # Tensor ——> float
        score, label_id = score.item(), label_id.item()
        # 查找标签名称
        label_name = self.label_names[label_id]
        return label_name, score


if __name__ == '__main__':
    # config device
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    model_classify = ModelPipline(device)

    image = cv2.imread('./images/0.jpg')
    result = model_classify.predict(image)
    print(result)

    image = cv2.imread('./images/1.jpg')
    result = model_classify.predict(image)
    print(result)

    image = cv2.imread('./images/2.jpg')
    result = model_classify.predict(image)
    print(result)

    image = cv2.imread('./images/3.jpg')
    result = model_classify.predict(image)
    print(result)

    # CPU: predict image 0.jpg 100 times
    image=cv2.imread("./images/0.jpg")

    device = torch.device('cpu')
    model_classify = ModelPipline(device)
    t_all=0
    for i in range(100):
        t_start=time.time()
        result=model_classify.predict(image)
        t_end=time.time()
        t_all+=t_end - t_start
    print('CPU 100 time lapse: {:.4f} seconds.'.format(t_all))

    # GPU: predict image 0.jpg 100 times
    device = torch.device('cuda')
    model_classify = ModelPipline(device)
    t_all=0
    for i in range(100):
        t_start=time.time()
        result=model_classify.predict(image)
        t_end=time.time()
        t_all+=t_end - t_start
    print('GPU 100 time lapse: {:.4f} seconds.'.format(t_all))

必做题

1. 提交下推理的输入后果（标签和置信度）。
   
   (‘umbrella’, 0.9995710253715515)
   
   (‘peacock’, 0.9999837875366211)

2. 提交下找的 2 张图片，以及推理的输入后果。
   
   (‘geyser’, 0.9999121427536011)
   
   (‘snorkel’, 0.96727454662323)

   思考题

3. CPU 推理和 CUDA 推理，各自的工夫开销。
   CPU 100 time lapse: 7.7344 seconds.
   GPU 100 time lapse: 1.9687 seconds.
4. 无

学习心得

对矩阵和张量的操作须要进一步相熟，尤其对维度的操作，如 dim=0，dim=1，到底是什么意思。