Atlas800昇腾服务器（型号：3000）—SwinTransformer等NPU推理【图像分类】（九）

服务器配置如下：

CPU/NPU：鲲鹏 CPU（ARM64）+A300I pro推理卡
系统：Kylin V10 SP1【下载链接】【安装链接】
驱动与固件版本版本：
Ascend-hdk-310p-npu-driver_23.0.1_linux-aarch64.run【下载链接】
Ascend-hdk-310p-npu-firmware_7.1.0.4.220.run【下载链接】
MCU版本：Ascend-hdk-310p-mcu_23.2.3【下载链接】
CANN开发套件：版本7.0.1【Toolkit下载链接】【Kernels下载链接】

测试om模型环境如下：

Python：版本3.8.11
推理工具：ais_bench
测试图像分类算法：
（1）ShuffleNetv2
（2）DenseNet
（3）EfficientNet
（4）MobileNetv2
（5）MobileNetv3
（6）ResNet
（7）SE-ResNet
（8）Vision Transformer
（9）SwinTransformer

专栏其他文章：
Atlas800昇腾服务器（型号：3000）—驱动与固件安装（一）
Atlas800昇腾服务器（型号：3000）—CANN安装（二）
Atlas800昇腾服务器（型号：3000）—YOLO全系列om模型转换测试（三）
Atlas800昇腾服务器（型号：3000）—AIPP加速前处理（四）
Atlas800昇腾服务器（型号：3000）—YOLO全系列NPU推理【检测】（五）
Atlas800昇腾服务器（型号：3000）—YOLO全系列NPU推理【实例分割】（六）
Atlas800昇腾服务器（型号：3000）—YOLO全系列NPU推理【关键点】（七）
Atlas800昇腾服务器（型号：3000）—YOLO全系列NPU推理【跟踪】（八）

1 mmcls安装

目的：mmcls图像分类模型库丰富，涵盖最新的图像分类算法，且安装一个环境，可用一个脚本转onnx模型！
链接：https://github.com/open-mmlab/mmpretrain

1.1 CUDA与cudnn安装

详情见：https://blog.csdn.net/weixin_45679938/article/details/138770542?spm=1001.2014.3001.5501

1.2 mmcls环境安装

mmcls版本：v0.25.0

（1）创建环境和安装pytorch

conda create -n open-mmlab python=3.8 pytorch=1.10 cudatoolkit=11.3 torchvision==0.11.0 -c pytorch -y
conda activate open-mmlab
pip3 install openmim
mim install mmcv-full

（2）下载mmcls=0.25.0版本，解压安装

# 对下载压缩包解压，不要用git，避免下载到最新版本
unzip XXX.zip
cd mmclassification
pip3 install -e .

1.3 pth转onnx

运行代码路径：./mmclassification-master/tools/deployment/pytorch2onnx.py

# pth转onnx命令示例-shufflenet_v2
python tools/deployment/pytorch2onnx.py configs/shufflenet_v2/shufflenet-v2-1x_16xb64_in1k.py --checkpoint checkpoints/shufflenet_v2.pth --output-file shufflenet_v2.onnx

生成的静态ONNX模型输入和输出可视化：

2 onnx转om模型

# onnx转om命令示例-shufflenet_v2
atc --framework=5 --model=onnx/shufflenet_v2.onnx --input_format=NCHW --input_shape="input:1,3,224,224" --output_type=FP32 --output=om/shufflenet_v2 --soc_version=Ascend310P3

结果由下可见，测试的图像分类模型均能成功生成om模型文件：

3 基于ais_bench推理工具推理

3.1 构建推理代码

新建一个om_infer.py脚本，内容如下：
其中，imagenet_classes.txt下载链接

import argparse
import time 
import cv2
import numpy as np
import os

from ais_bench.infer.interface import InferSession

class Image_Classfication:

    def __init__(self, om_model, imgsz=(224, 224), device_id=0, model_ndtype=np.single, mode="static", aipp=False):
        """
        Initialization.

        Args:
            om_model (str): Path to the om model.
        """
        
        # 构建ais_bench推理引擎
        self.session = InferSession(device_id=device_id, model_path=om_model)
        
        # Numpy dtype: support both FP32(np.single) and FP16(np.half) om model
        self.ndtype = model_ndtype
        self.mode = mode
        self.aipp = aipp  
       
        self.model_height, self.model_width = imgsz[0], imgsz[1]  # 图像resize大小
     

    def __call__(self, im0):
        """
        The whole pipeline: pre-process -> inference -> post-process.

        Args:
            im0 (Numpy.ndarray): original input image.

        Returns:
            index: 预测类别概率最大值的索引.
        """
        # 前处理Pre-process
        t1 = time.time()
        im = self.preprocess(im0)
        pre_time = round(time.time() - t1, 3)
        
        # 推理 inference
        t2 = time.time()
        preds = self.session.infer([im], mode=self.mode)  # mode有动态"dymshape"和静态"static"等
        infer_time = round(time.time() - t2, 3)
        
        # 后处理Post-process
        t3 = time.time()
        index = self.postprocess(preds)
        post_time = round(time.time() - t3, 3)

        return index, (pre_time, infer_time, post_time)
        
    # 前处理，包括：resize, 其中HWC to CHW，BGR to RGB，归一化，增加维度CHW -> BCHW可选择是否开启AIPP加速处理
    def preprocess(self, image):
        img = cv2.resize(image, (self.model_width, self.model_height), interpolation=cv2.INTER_LINEAR)

        # 是否开启aipp加速预处理，需atc中完成
        if self.aipp:
            return img
        
        input = img[:,:,::-1].transpose(2,0,1)  #BGR2RGB和HWC2CHW
        input = input.astype(dtype=np.single)
        input[0,:] = (input[0,:] - 123.675) / 58.395   
        input[1,:] = (input[1,:] - 116.28) / 57.12
        input[2,:] = (input[2,:] - 103.53) / 57.375
        img = np.expand_dims(input, axis=0)
        return img
    
    # 后处理推理结果
    def postprocess(self, perds):
        prob = perds[0]
        max_index = np.argmax(prob)     # 获得最大值的索引
        return max_index
    
    # 加载标签文件获得分类标签
    def read_class_names(self, file_path="./imagenet_classes.txt"):
        class_names = []
        try:
            with open(file_path, 'r') as fp:
                for line in fp:
                    name = line.strip()
                    if name:
                        class_names.append(name)
        except IOError:
            print("Could not open imagenet_classes.txt file...")
            import sys
            sys.exit(-1)
        return class_names
    
        
if __name__ == '__main__':
    # Create an argument parser to handle command-line arguments
    parser = argparse.ArgumentParser()
    parser.add_argument('--model_path', type=str, default=r"weights/shufflenet_v2.om", help='Path to OM model')
    parser.add_argument('--source', type=str, default=r'images', help='Path to input image')
    parser.add_argument('--out_path', type=str, default=r'results', help='结果保存文件夹')
    parser.add_argument('--imgsz_size', type=tuple, default=(224, 224), help='Image input size')
    parser.add_argument('--classes_path', type=str, default='imagenet_classes.txt', help='类别文件txt路径')
    parser.add_argument('--device_id', type=int, default=0, help='device id')
    parser.add_argument('--mode', default='static', help='om是动态dymshape或静态static')
    parser.add_argument('--model_ndtype', default=np.single, help='om是fp32或fp16')
    parser.add_argument('--aipp', default=False, action='store_true', help='是否开启aipp加速YOLO预处理, 需atc中完成om集成')
    args = parser.parse_args()

    # 创建结果保存文件夹
    if not os.path.exists(args.out_path):
        os.mkdir(args.out_path)
    
    print('开始运行：')
    # Build model
    cls_model = Image_Classfication(args.model_path, args.imgsz_size, args.device_id, args.model_ndtype, args.mode, args.aipp)
    classes_label = cls_model.read_class_names(args.classes_path)

    for i, img_name in enumerate(os.listdir(args.source)):
        try:
            # Read image by OpenCV
            img = cv2.imread(os.path.join(args.source, img_name))

            # 检测Inference
            index, (pre_time, infer_time, post_time) = cls_model(img)
            label_text = classes_label[index]
            print('{}/{} ==>预测id:{}, 类别: {}, 预处理耗时: {:.3f}s, 推理耗时: {:.3f}s, 后处理耗时: {:.3f}s'.format(i+1, len(os.listdir(args.source)), index, label_text, pre_time, infer_time, post_time))

            # Draw rectangles
            cv2.putText(img, label_text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255), 2, 8)
                
            cv2.imwrite(os.path.join(args.out_path, img_name), img)
            
        except Exception as e:
            print(e)      

3.2 预测分类结果

预测输入图如下：

预测及推理耗时结果如下：
（1）ShuffleNetv2【运行成功】

（2）DenseNet【运行成功】

（3）EfficientNet【运行成功】

（4）MobileNetv2【运行成功】

（5）MobileNetv3【运行成功】

（6）ResNet【运行成功】

（7）SE-ResNet【运行成功】

（8）Vision Transformer【运行成功】

（9）SwinTransformer【运行成功】

综上可知，常见的图像分类算法包括Transformer等均能适配该系列昇腾产品！