学习笔记：在华为昇腾NPU上进行深度学习项目【未完待续】

昇腾社区链接： 昇腾社区-官网丨昇腾万里 让智能无所不及

场景和功能说明

• 第一种：在cpu或gpu上训练的模型，但要在NPU上执行模型推理；
• 第二种：在NPU上同步训练、推理。

系统信息查询

中括号里的为查询结果示例。
– 查看系统架构：uname -a [aarch64，也称arm64]
– 查看操作系统版本：lsb_release -a [Ubuntu 22.04.3 LTS]
– 查看npu芯片型号：npu-smi info [Ascend310B4]
– 查看npu id：npu-smi info -l
– 查看Atlas产品型号：npu-smi info -t product -i [Atlas 200I A2]

1、场景一：非NPU上训练的模型推理

此种使用场景下，cpu或gpu上训练的模型无法直接在nup上执行推理，需要先把训练好的模型转换成.om离线模型，才可以在NPU上执行后续的推理。

1.1 执行方案

step1：在已安装CANN开发环境的机器上，把cpu或gpu上训练的模型转换成.onnx格式 或 pd格式
step2：在安装CANN运行环境的机器上，把onnx格式转om格式。
对应CANN开发环境、运行环境的区别、安装方法见官方文档：CANN软件安装

1.2 学习案例

① 官方gitee项目-支持tensorflow、pytorch的模型转换 这里已经集成了多种开源模型从初始模型 —> onnx模型 —> om模型的转换操作步骤和对应代码。

• 第一阶段：模型转onnx需要写代码完成；
• 第二阶段：.onnx转.om使用atc命令完成，无须写代码。

② 仅onnx模型 —> om模型的转换案例：昇腾社区简单ATC转换案例
③ om模型的推理应用案例 这里的快速链接是昇腾社区下pytorch的应用案例，昇腾社区也集成了其他训练框架的应用案例，可自行查看。
④ 其他网友的分享：[推理部署]ONNX推理加速技术文档-杂记

以下是基于 bert_base_chinese预训练模型转.onnx模型 脚本改写的代码：

• 源文件：基于bert_base_chinese模型微调后的.pt模型文件
• 目标：把.pt转换成.onnx

import torch
import onnx
import numpy as np
import onnxruntime
from init.init_config import ModelConfig

'''
1、pth文件转onnx：pytorch框架中集成了onnx模块，属于官方支持，onnx也覆盖了pytorch框架中的大部分算子。因此将pth模型文件转换为onnx文件非常简单。
    参考：https://zhuanlan.zhihu.com/p/524023964?utm_id=0
2、.pth转.onnx可以在任意机器上执行，只要有python 且 安装了对应依赖包（r如onnx相关依赖，不包括atc）即可，既可以是普通windows x86_64 gpu/cpu，也可以是linux Ascend310B4(昇腾 310B4 npu卡)
3、本文件中：
① 使用的是“基于bert-base-chinese微调的模型”，微调时的输入样本只有一个序列，所以训练时把token_type_ids也省略了；
② 和原始bert-base-chinese预训练模型input_shape=(batch_size,max_len)不同，微调训练使用的input_shape=(src_len,batch_size), attention_mask_shape=(batch_size,src_len), src_len是固定的512。
注意：Atlas 200/500 A2推理产品不支持动态Shape输入（设置Shape范围）。 详见官方文档 https://www.hiascend.com/document/detail/zh/canncommercial/70RC1/inferapplicationdev/aclpythondevg/aclpythondevg_0060.html
'''

model_path = 'E:\\opencode\\13-02-BertWithPretrained-main\\cache1\\ner_model_epoch1_steps1000.pt'  # 微调后的模型文件
onnx_path = "./ner_model_bert.onnx"  # 定义onnx模型保存地址。固定max_len=512
# 注意token_id的shape=（src_len, batch_size）
input_shape = (512, 1)

# todo 这里和原始模型在CPU或GPU上的加载方式保持一样。这里代码省略。。。。
model_config = ModelConfig()


def load_torch_model():
    invoice_model = model_config.model
    # 在导出模型之前必须调用 model.eval() 或 model.train(False)，因为这会将模型设置为“推理模式”。 这是必需的，因为 dropout 或 batchnorm 等运算符在推理和训练模式下的行为有所不同。
    invoice_model.eval()
    return invoice_model


def onnx_model_predict(onnx_path, dummy_input):
    # 创建会话，用于推理
    '''
    这里 onnxruntime.InferenceSession(model_path) 就是加载模型的步骤，ONNX Runtime 会在内部执行模型的验证。
    如果模型有问题，ONNX Runtime 将在加载过程中引发异常。
    因此，在使用 ONNX Runtime 进行推理时，你通常不需要显式地调用 onnx.load(onnx_path) 和 onnx.checker.check_model(onnx_model)。 
    # 模型加载
    onnx_model = onnx.load(onnx_path)
    onnx.checker.check_model(onnx_model)
    '''
    ort_session = onnxruntime.InferenceSession(onnx_path)
    # 获取模型的输入"input"
    inputs = ort_session.get_inputs()

    # bert基础模型设置:定义模型的输入{"input":numpys数组-不是tensor}和输出 ["output"]
    padding_mask = np.transpose((dummy_input == 0))

    # 省略token_type_ids的写法，和源模型转onnx时的input保持一致！
    ort_inputs = {
        inputs[0].name: dummy_input,
        inputs[1].name: padding_mask
    }
    outputs = ort_session.get_outputs()
    output_name = [outputs[0].name]
    # 模型推理
    ort_outs = ort_session.run(output_name, ort_inputs)
    return ort_outs


def export_config(token_ids, padding_mask, keep=True):
    '''
       使用的是bert-base-chinese模型，常规输入包含input_ids、attention_mask、token_type_ids
    :param token_ids: 句子输入编码
    :param padding_mask: 掩码
    :param keep: 是否保留token_type_ids
    :return:
    '''
    output_names = ["out"]
    if keep:
        input_data = (
            token_ids,
            padding_mask,
            token_ids
        )
        input_names = ["input_ids", "attention_mask", "token_type_ids"]

        dynamic_axes = {
            "input_ids": {0: "B"},
            "attention_mask": {0: "B"},
            "token_type_ids": {0: "B"},
            "out": {0: "B"}
        }
    else:
        input_data = (
            token_ids,
            padding_mask
        )
        input_names = ["input_ids", "attention_mask"]

        dynamic_axes = {
            "input_ids": {0: "B"},
            "attention_mask": {0: "B"},
            "out": {0: "B"}
        }
    return input_data, input_names, output_names, dynamic_axes


def torch2onnx(dummy_input):
    torch_model = load_torch_model(model_path)
    token_ids = torch.from_numpy(dummy_input)  # numpy.ndarray转torch.tensor
    # bert基础模型设置
    padding_mask = (token_ids == 0).transpose(0, 1)
    # build data
    # 因为这里使用的是“基于bert-base-chinese微调的模型”，微调时的输入样本只有一个序列，所以token_type_ids可省略
    input_data, input_names, output_names, dynamic_axes = export_config(token_ids, padding_mask, keep=False)

    # onnx模型导出：verbose--是否打印日志
    torch.onnx.export(
        torch_model, input_data, onnx_path,
        verbose=True,
        opset_version=11,
        dynamic_axes=dynamic_axes,
        input_names=input_names,
        output_names=output_names
    )

    # 测试模型是否合理
    # 模型加载
    onnx_model = onnx.load(onnx_path)
    # 检查onnx模型转换是否合理
    onnx.checker.check_model(onnx_model)


def onnx_predict(dummy_input, onnx_path):
    # 1、原始torch模型加载和推理
    origin_model = load_torch_model(model_path)
    input_sample_tensor = dummy_input
    if isinstance(dummy_input, np.ndarray):
        input_sample_tensor = torch.from_numpy(dummy_input).to(device)
    torch_out = origin_model(input_sample_tensor).detach().numpy()
    # 2、onnx模型加载和推理
    ort_outs = onnx_model_predict(onnx_path, dummy_input)
    # 3、结果对比
    # todo 使用numpy的测试工具，检查两个数组是否在给定的相对和绝对误差范围内相等。np.testing.assert_allclose是一个测试断言语句，如果检查失败（即输出不在指定误差范围内），将引发 AssertionError，从而提示测试失败。
    #  （1）检查形状：确保 torch_out 和 ort_outs[0] 的形状相同。 （2）检查数值相等性： 对每个对应的元素，检查其数值是否在相对误差 (rtol) 和绝对误差 (atol) 允许的范围内。
    np.testing.assert_allclose(torch_out, ort_outs[0], rtol=1e-01, atol=1e-5)
    print(torch_out[:10])
    print(ort_outs[0][:10])
    print("convert success")


if __name__ == "__main__":
    # #（方案1）随机型：在测试转换前后的误差时，需要传递同一输入值
    # dummy_input = np.random.randn(*input_shape).astype(np.long)

    # # （方案2）固定值型
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    dummy_input = np.ones(input_shape).astype(np.long)

    # 普通模型转onnx
    torch2onnx(dummy_input)
    # 简单测试转换前后的精度差异
    onnx_predict(dummy_input, onnx_path)

1.3 onnx转om

具体指令参考 昇腾社区简单ATC转换案例

1.4 om推理