Pytorch项目打包和部署（3）——代码——flask+onnx

爱被打了一巴掌 2023-02-26 02:13 59阅读 0赞

### 文章目录 ###

*  一、Flask部署
 *   *  1.1 httpserver.py
     *  1.2 clinet.html
 *  二、传图片
 *   *  2.1 clinet.html
     *  2.2 httpserver.py
 *  三、返回json格式
 *   *  3.1 clinet.html
     *  3.2 httpserver.py
 *  四、官网实例转JSON
 *   *  4.1 httpserver2.py
     *  4.2 clinet2.html
 *  五、导出与调用onnx（跨平台使用）
 *   *  5.1 导出onnx
     *  5.2 检查onnx
     *   *  5.2.1 onnxruntime评测模型精度不一致问题排查
     *  5.3 调用onnx

# 一、Flask部署 #

## 1.1 httpserver.py ##

from flask import Flask,request
    app = Flask(__name__)#确保Flask调用的是当前模块
    
    
    @app.route('/')# 每个服务定义成一个函数，此为服务器的请求路径
    def hello():
        return 'Hello World!'
    
    @app.route('/lolanni',)
    def new():
        print(request.args.get("name"))# 上传参数与接收参数
        # 网址输入http://127.0.0.1:5000/lolanni?name=okok 返回值为okok
        return 'I am lol yasuo!'
    
    if __name__ == '__main__':
        app.run()
        """
        浏览器发出http请求，服务器处理完返回给浏览器输出
        
        网址输入错误就是404错误，右键可以检查，返回为200即没出错
        """

**示意图：**  
网页：  
![在这里插入图片描述][20200713175425109.png]  
![在这里插入图片描述][20200713175448540.png]  
Pycharm：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ_size_16_color_FFFFFF_t_70]

## 1.2 clinet.html ##

改一下上面的代码，修改的内容为：**print(request.form.get(“name”))**

新建一个html文件，在body下建一个form表单，输入下面的代码：

用chrome打开，随意填一个名称提交，得到的结果就是“I am lol yasuo!”  
![在这里插入图片描述][20200713180622900.png]  
![在这里插入图片描述][20200713180715334.png]  
这个时候，Pycharm返回的就是我们刚刚提交的名字“lol”  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ_size_16_color_FFFFFF_t_70 1]

# 二、传图片 #

## 2.1 clinet.html ##

仅加了enctype=“multipart/form-data”

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <form action="http://127.0.0.1:5000/lolanni" method="post" enctype="multipart/form-data">
            <input type="file" name="file">
            <input name="name" value="">
            <input type="submit" value="submit">
    
        </form>
    </body>
    </html>

## 2.2 httpserver.py ##

from flask import Flask,request
    from PIL import Image
    import io
    app = Flask(__name__)#确保Flask调用的是当前模块
    
    @app.route('/')# 每个服务定义成一个函数，此为服务器的请求路径
    def hello():
        return 'Hello World!'
    
    @app.route('/lolanni',methods=["POST"])
    # methods可以用POST和GET，默认GET，浏览器知道我们的输入，不安全，所以选POST
    # 这样下面网址输入lolanni?name=okok，网页会返回"Method Not Allowed"
    def new():
        print(request.form.get("name"))# 上传参数与接收参数
        # 网址输入http://127.0.0.1:5000/lolanni?name=okok 返回值为okok
        file = request.files.get("file")
        img_bytes =file.read()# 读成字节码
        image = Image.open(io.BytesIO(img_bytes))# 转PIL格式
        image.show()
        return 'I am lol yasuo!'
    
    if __name__ == '__main__':
        app.run()

![在这里插入图片描述][20200713182105660.png]  
选择一张图片，选择提交人名，网页会返回一张显示的图像，下面是我自己提交的：  
![在这里插入图片描述][2020071318540981.jpg]

# 三、返回json格式 #

rest规范：过去的数据是表单或GET方式，返回的数据应该是json格式。  
json格式：首先一个花括号\{\}，整个代表一个对象，同时里面是一种Key-Value的存储形式，它还有不同的数据类型来区分  
（1）Object  
\{key:value,key:value…\}  
key：string类型  
value：任何基本类型或数据结构  
（2）Array  
\[value,value…\]  
value：任何基本类型或数据结构。  
比如：\{“name”:“李广”, “values”:\[1,2,45,“你好”\] \}

## 3.1 clinet.html ##

## 3.2 httpserver.py ##

from flask import Flask,request,jsonify
    from PIL import Image
    import io
    app = Flask(__name__)#确保Flask调用的是当前模块
    
    
    @app.route('/')# 每个服务定义成一个函数，此为服务器的请求路径
    def hello():
        return 'Hello World!'
    
    @app.route('/lolanni',methods=["POST"])
    # methods可以用POST和GET，默认GET，浏览器知道我们的输入，不安全，所以选POST
    # 这样下面网址输入lolanni?name=okok，网页会返回"Method Not Allowed"
    def new():
        name = request.form.get("name")# 上传参数与接收参数
        # 网址输入http://127.0.0.1:5000/lolanni?name=okok 返回值为okok
        file = request.files.get("file")
        img_bytes =file.read()# 读成字节码
        return jsonify({
        "name": name,"filelen": len(img_bytes)})
    
    if __name__ == '__main__':
        app.run()

提交后，得到的就是json格式的信息：  
![在这里插入图片描述][20200713183717970.png]

# 四、官网实例转JSON #

## 4.1 httpserver2.py ##

import io
    import json
    
    from torchvision import models
    import torchvision.transforms as transforms
    from PIL import Image
    from flask import Flask, jsonify, request
    
    
    app = Flask(__name__)
    imagenet_class_index = json.load(open('imagenet_class_index.json'))
    model = models.densenet121(pretrained=True)
    model.eval()
    
    
    def transform_image(image_bytes):
        my_transforms = transforms.Compose([transforms.Resize(255),
                                            transforms.CenterCrop(224),
                                            transforms.ToTensor(),
                                            transforms.Normalize(
                                                [0.485, 0.456, 0.406],
                                                [0.229, 0.224, 0.225])])
        image = Image.open(io.BytesIO(image_bytes))
        return my_transforms(image).unsqueeze(0)
    
    
    def get_prediction(image_bytes):
        tensor = transform_image(image_bytes=image_bytes)
        outputs = model.forward(tensor)
        _, y_hat = outputs.max(1)
        predicted_idx = str(y_hat.item())
        return imagenet_class_index[predicted_idx]
    
    
    @app.route('/predict', methods=['POST'])
    def predict():
        if request.method == 'POST':
            file = request.files['file']
            img_bytes = file.read()
            class_id, class_name = get_prediction(image_bytes=img_bytes)
            return jsonify({
        'class_id': class_id, 'class_name': class_name})
    
    
    if __name__ == '__main__':
        app.run()

## 4.2 clinet2.html ##

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <form action="http://127.0.0.1:5000/predict" method="post" enctype="multipart/form-data">
            <input type="file" name="file">
            <input name="name" value="">
            <input type="submit" value="submit">
    
        </form>
    </body>
    </html>

提交猫咪的图片，得到的结果如下：  
![在这里插入图片描述][20200713190209439.png]

# 五、导出与调用onnx（跨平台使用） #

## 5.1 导出onnx ##

import io
    import numpy as np
    
    from torch import nn
    import torch.utils.model_zoo as model_zoo
    import torch.onnx
    
    # Super Resolution model definition in PyTorch
    import torch.nn as nn
    import torch.nn.init as init
    
    
    class SuperResolutionNet(nn.Module):
        def __init__(self, upscale_factor, inplace=False):
            super(SuperResolutionNet, self).__init__()
    
            self.relu = nn.ReLU(inplace=inplace)
            self.conv1 = nn.Conv2d(1, 64, (5, 5), (1, 1), (2, 2))
            self.conv2 = nn.Conv2d(64, 64, (3, 3), (1, 1), (1, 1))
            self.conv3 = nn.Conv2d(64, 32, (3, 3), (1, 1), (1, 1))
            self.conv4 = nn.Conv2d(32, upscale_factor ** 2, (3, 3), (1, 1), (1, 1))
            self.pixel_shuffle = nn.PixelShuffle(upscale_factor)
    
            self._initialize_weights()
    
        def forward(self, x):
            x = self.relu(self.conv1(x))
            x = self.relu(self.conv2(x))
            x = self.relu(self.conv3(x))
            x = self.pixel_shuffle(self.conv4(x))
            return x
    
        def _initialize_weights(self):
            init.orthogonal_(self.conv1.weight, init.calculate_gain('relu'))
            init.orthogonal_(self.conv2.weight, init.calculate_gain('relu'))
            init.orthogonal_(self.conv3.weight, init.calculate_gain('relu'))
            init.orthogonal_(self.conv4.weight)
    
    # Create the super-resolution model by using the above model definition.
    torch_model = SuperResolutionNet(upscale_factor=3)
    
    # model_url = 'https://s3.amazonaws.com/pytorch/test_data/export/superres_epoch100-44c6958e.pth'
    model_name = "superres_epoch100-44c6958e.pth"
    
    batch_size = 1    # just a random number
    
    # Initialize model with the pretrained weights
    map_location = lambda storage, loc: storage
    if torch.cuda.is_available():
        map_location = None
    # torch_model.load_state_dict(model_zoo.load_url(model_url, map_location=map_location))
    torch_model.load_state_dict(torch.load(model_name))
    
    # set the model to inference mode
    torch_model.eval()
    
    # Input to the model
    x = torch.randn(batch_size, 1, 224, 224, requires_grad=True)# 模拟输入
    torch_out = torch_model(x)# 输入做前向运算
    
    # Export the model导出onnx模型
    torch.onnx.export(torch_model,               # model being run
                      x,                         # model input (or a tuple for multiple inputs)
                      "super_resolution.onnx",   # where to save the model (can be a file or file-like object)
                      export_params=True,        # store the trained parameter weights inside the model file
                      opset_version=10,          # （版本号）the ONNX version to export the model to
                      do_constant_folding=True,  # （onnx正常情况下无法训练，导出的模型要带权重）whether to execute constant folding for optimization
                      input_names = ['input'],   # the model's input names
                      output_names = ['output'], # the model's output names
                      dynamic_axes={
        'input' : {
        0 : 'batch_size'},    # variable lenght axes
                                    'output' : {
        0 : 'batch_size'}})

结果：导出了onnx文件  
![在这里插入图片描述][2020071319304765.png]

## 5.2 检查onnx ##

cannot import name 'get\_all\_providers’的问题  
报错就把onnxruntime降版本到1.2.0

pip install onnxruntime==1.2.0

import onnx
    onnx_model = onnx.load("super_resolution.onnx")
    print(onnx.checker.check_model(onnx_model))# 检测onnx模型

"""
    硬件的精度与PC的精度不一致，原因可能是精度支持的位数不一致
    误差会有累加
    """
    import onnxruntime
    
    ort_session = onnxruntime.InferenceSession("super_resolution.onnx")# 创建会话
    
    def to_numpy(tensor):
        return tensor.detach().cpu().numpy() if tensor.requires_grad else tensor.cpu().numpy()
    
    # compute ONNX Runtime output prediction
    ort_inputs = {
        ort_session.get_inputs()[0].name: to_numpy(x)}# 模拟输入
    ort_outs = ort_session.run(None, ort_inputs)
    
    # compare ONNX Runtime and PyTorch results检测输入输出是否满足精度
    np.testing.assert_allclose(to_numpy(torch_out), ort_outs[0], rtol=1e-03, atol=1e-05)
    
    print("Exported model has been tested with ONNXRuntime, and the result looks good!")

### 5.2.1 onnxruntime评测模型精度不一致问题排查 ###

在做模型转换相关工作，但是最近发现转换后的模型精度评测的时候会出现两次评测精度不一致, 模型转换是从caffe转换成量化后的onnx模型，中间会有几个临时模型，分别为original\_onnx, 这个是直接转换的模型，一个optimized\_onnx，是对原onnx模型进行结构优化/整合后的模型，另一个为quantized\_onnx模型，既量化后的模型，我们发现对量化后对模型进行精度评测的时候，多次评测的结果不同，而且是同样的转换代码的情况下，同样的评测图片集，最终评测结果不一致，在以百分比现实的精度结果的小数点后一两位就开始有差别，即误差会达到千分之一以上。

首先说明下这个问题排查的重要性，千分之一，看似不多，实则在深度学习领域，不算少了，能通过对模型对一番更改，某些场景下提升千分之几的精度，已经可以发论文了，不过这不是重点，重点是我们想通过定期精度评测来评估转换代码对精度对影响，既然是评估影响，那么就要排除干扰，显然对统一模型同样数据集进行评测后对精度不一致是一种干扰项，我们必须找到这种不一致的原因，以排除其影响。

1.精度问题首先在一个评测脚本里被发现，而这个脚本会同时执行多个模型的评测任务，自然想到执行单个的模型任务排除干扰，也降低复现开销，由于工程里已经有另外一套单个模型的评测脚本，自然就直接用了那个脚本进行评测，发现用那个单个脚本多次评测并未出现精度不一致的问题。

2.考虑到评测是对一系列批次的图片进行推理，然后对每批次对图片计算结果的吻合度，想到是不是评测集（我们用对imagenet，5万张）对加载顺序不一致导致对，经过排查，我们的评测集图片始终是相同的，而且评测的顺序也是保证一致的。

3.基于2，如果评测结果有异常，那么对同一张图片推理的结果也应该有异常，于是又实验了对同一张图，推理若干次，几万次吧，因为最初观察到对每次评测都会复现精度不一致，而每次评测图片数量5万，那么推理5万是能达到这个量级的。结果没有复现。

4.那会不会是某些图片造成的呢。我们随机选取了一些图片重复3的实验，没有复现。

5.综上，目前有问题的是多模型评测的时候出现问题，而单模型评测没复现，考虑到这两者的差异，因为多模型评测脚本是顺序执行，不存在模型之间的干扰，而二者有一个区别是，单模型评测是基于已经转换后的模型进行评测，而多模型评测脚本每次评测的时候会从caffe模型转换开始，转换然后评测，那么往前回溯一下，会不会是转换过程引入的不一致。经过对比生成的几个模型的md5值，发现确实转换出的模型就有差异，浮点模型没有差异，但是定点模型有差异，那么精度不一致的问题很可能出现在模型定点化的过程中，而这个过程中最有可能是校准过程。

6.要分析校准过程中的问题，先要弄清校准过程。由于模型在量化过程中数值分布会发生变化，浮点模型中对分布范围很随意，从前一个节点到后一个节点对传递过程中都基本能保持仍在合法对浮点范围内，不会溢出或者截断，但是量化模型，比如INT8的量化模型，所有数值范围都是-128~127，很容易在某些节点的运算后发生数值溢出和截断，而这种行为是对模型执行精度有很大影响，因而我们希望通过校准过程，在那些能改变输入数值分布的节点前（比如conv) 插入校准节点以对该节点的输入数据分布进行统计，根据统计结果对原节点的+bias和\*scale参数做修改，或者另外添加参数（可能需要修改节点实现），如此在量化模型执行过程中，通过该节点的计算将对数据分布进行改变，以期不显著降低精度。校准过程中会通过校准图片（最好和后续推理和评测同分布的图片）进行推理，在推理的过程中，校准图片会更新自身参数，比如最简单的是max校准方法，统计出流经该节点的输入数值的最大值。

7.基于6，后面的过程就比较清晰了，把所有节点的输出dump出来，然后比对，看是从哪个节点开始计算结果不一致。在比对前，我们怀疑过，某个节点的实现造成（比较有可能的是校准和卷积，求和节点）（这种计算问题浮点数并行计算然后求和，由于浮点值的表示范围有限，当求和顺序不一致会导致结果不一致（因为中间结果存在溢出和精度截断可能）），c++到python的浮点数传递/转换可能有问题（不清楚具体传递和转换机制，只是怀疑正好遇到了某临界值，或者c++的值传递过程中遭遇溢出将随机值填入尾部等等），为了排除后者，我们直接比对c++部分的节点输出值的二进制表示，发现是某一个conv的节点起计算输出的值会有差异，而之后的节点会将差异传递最终导致结果的不一致。

8.再分析该conv节点，将该conv节点的input以及其他参数属性都dump出来观察，发现出问题的conv节点的输入和属性都是一样的，但是输出不一样，并且输出的值的差异会按一定概率分布在几个值上，差异并不是完全随机的。

9.仔细查看该conv节点的计算实现，是onnxruntime的实现，onnxruntime/onnxruntime/core/providers/cuda/nn/conv.cc，将其中影响计算的一些参数dump并比对，最终发现是每次执行的时候gpu卡的卷积算法选择不同导致的。每当节点的输入shape或者weight的shape改变，conv都会重新执行  
cudnnFindConvolutionForwardAlgorithmEx搜寻高效的卷积算法，具体说明参见  
[https://docs.nvidia.com/deeplearning/sdk/cudnn-api/index.html\#cudnnFindConvolutionForwardAlgorithmEx][https_docs.nvidia.com_deeplearning_sdk_cudnn-api_index.html_cudnnFindConvolutionForwardAlgorithmEx]  
可搜索的卷积计算算法类型有[https://docs.nvidia.com/deeplearning/sdk/cudnn-api/index.html\#cudnnConvolutionFwdAlgo\_t][https_docs.nvidia.com_deeplearning_sdk_cudnn-api_index.html_cudnnConvolutionFwdAlgo_t]  
其中几种会导致计算结果的不一致，具体原因和gpu架构设计有关，工作内容的原因，暂没有继续深究了。所以要解决精度不一致的问题，有两种办法，一种是将算法选择限定在保证一致性的算法范围内，另一种直接屏蔽算法选择，用默认的

CUDNN\_CONVOLUTION\_FWD\_ALGO\_IMPLICIT\_GEMM算法，显然这两种都会导致推理评测性能的损失，不过经过测试，性能损失在5%以内，可以接受。若要追求高性能，可以在精度评测需要保证一致性的时候将算法选择限制住，在推理的时候将算法选择打开，不过我们的应用场景内没有这种需求，所以就粗暴的限制了算法的选择。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ_size_16_color_FFFFFF_t_70 2]

## 5.3 调用onnx ##

from SuperResolution import torch_model,batch_size
    import numpy as np
    """
    硬件的精度与PC的精度不一致，原因可能是精度支持的位数不一致
    误差会有累加
    """
    import onnxruntime
    import torch
    x = torch.randn(batch_size, 1, 224, 224, requires_grad=True)# 模拟输入
    torch_out = torch_model(x)# 输入做前向运算
    ort_session = onnxruntime.InferenceSession("super_resolution.onnx")# 创建会话
    
    def to_numpy(tensor):
        return tensor.detach().cpu().numpy() if tensor.requires_grad else tensor.cpu().numpy()
    
    from PIL import Image
    import torchvision.transforms as transforms
    
    img = Image.open("cat_224x224.jpg")
    
    resize = transforms.Resize([224, 224])
    img = resize(img)
    
    img_ycbcr = img.convert('YCbCr')
    img_y, img_cb, img_cr = img_ycbcr.split()
    
    to_tensor = transforms.ToTensor()
    img_y = to_tensor(img_y)
    img_y.unsqueeze_(0)
    
    ort_inputs = {
        ort_session.get_inputs()[0].name: to_numpy(img_y)}
    ort_outs = ort_session.run(None, ort_inputs)
    img_out_y = ort_outs[0]
    
    img_out_y = Image.fromarray(np.uint8((img_out_y[0] * 255.0).clip(0, 255)[0]), mode='L')
    
    # get the output image follow post-processing step from PyTorch implementation
    final_img = Image.merge(
        "YCbCr", [
            img_out_y,
            img_cb.resize(img_out_y.size, Image.BICUBIC),
            img_cr.resize(img_out_y.size, Image.BICUBIC),
        ]).convert("RGB")
    
    # Save the image, we will compare this with the output image from mobile device
    final_img.save("cat_superres_with_ort.jpg")

导出的结果是：（超分辨率重建，这个效果一般）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ_size_16_color_FFFFFF_t_70 3]  
参考：[onnxruntime评测模型精度不一致问题排查][onnxruntime]

[20200713175425109.png]: /images/20230209/ccc4acf3b9144058bbaf67af31d7aa1a.png
[20200713175448540.png]: https://img-blog.csdnimg.cn/20200713175448540.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200713175534344.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ==,size_16,color_FFFFFF,t_70
[20200713180622900.png]: https://img-blog.csdnimg.cn/20200713180622900.png
[20200713180715334.png]: https://img-blog.csdnimg.cn/20200713180715334.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200713181040164.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ==,size_16,color_FFFFFF,t_70
[20200713182105660.png]: https://img-blog.csdnimg.cn/20200713182105660.png
[2020071318540981.jpg]: https://img-blog.csdnimg.cn/2020071318540981.jpg
[20200713183717970.png]: https://img-blog.csdnimg.cn/20200713183717970.png
[20200713190209439.png]: https://img-blog.csdnimg.cn/20200713190209439.png
[2020071319304765.png]: https://img-blog.csdnimg.cn/2020071319304765.png
[https_docs.nvidia.com_deeplearning_sdk_cudnn-api_index.html_cudnnFindConvolutionForwardAlgorithmEx]: https://docs.nvidia.com/deeplearning/sdk/cudnn-api/index.html#cudnnFindConvolutionForwardAlgorithmEx
[https_docs.nvidia.com_deeplearning_sdk_cudnn-api_index.html_cudnnConvolutionFwdAlgo_t]: https://docs.nvidia.com/deeplearning/sdk/cudnn-api/index.html#cudnnConvolutionFwdAlgo_t
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200713200230442.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2020071320132779.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ==,size_16,color_FFFFFF,t_70
[onnxruntime]: https://blog.csdn.net/atp1992/article/details/107102863/