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

在NPU上做深度学习算法

场景和功能说明
系统信息查询
- 1、场景一：非NPU上训练的模型推理
- - [1.1 执行方案](#1.1 执行方案)
  - [1.2 学习案例](#1.2 学习案例)
  - [1.3 onnx转om](#1.3 onnx转om)
  - [1.4 om推理](#1.4 om推理)

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

场景和功能说明

第一种：在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 <npu id> [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_data, keep=False):
# 创建会话，用于推理
'''
这里 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()
# input_name = inputs[0].name
```
  # bert基础模型设置:定义模型的输入{"input":numpys数组-不是tensor}和输出 ["output"]
  (token_ids, padding_mask), input_names = build_data(dummy_data, keep=keep, need_type="numpy.NDArray")

  assert len(inputs) == len(input_names), f"onnx模型输入需要{len(inputs)}个参数，与实际提供的参数{input_names}不符！"
  ort_inputs = {
  			inputs[0].name: token_ids,
              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(input_names, dynamic=False):
'''
:param input_names: 模型输入层所需参数
:param dynamic: 是否支持动态维度
:return: dynamic_axes指定模型中哪些轴的维度是动态的（即，可以改变的）的。
'''
dynamic_axes = {}
# output_names = ["out"]
output_names = ["logits"]
if dynamic:
# 原始模型微调时使用的shape(attention_mask)=(batch_size, src_len), 其他输入参数是(src_len, batch_size)。以下也要按实际shape指定。
for name in input_names + output_names:
if name == "attention_mask":
dynamic_axes[name] = {0: "batch_size", 1: "src_len"} # 表示当前name下第0维和第1维都可以动态变化，且分别给对应维度自定义命名为batch_size、src_len。注意这里的名字是可以随便写的，但为了后续理解方便，建议还是能见名知意。
else:
dynamic_axes[name] = {0: "src_len", 1: "batch_size"}
return output_names, dynamic_axes

def build_data(dummy_data, keep=True, need_type="torch.tensor"):
if need_type == "torch.tensor":
token_ids = torch.from_numpy(dummy_data).to(device) # numpy.ndarray转torch.tensor
padding_mask = (token_ids == model_config.data_loader.PAD_IDX).transpose(0, 1)
elif need_type == "numpy.NDArray":
token_ids = dummy_data
padding_mask = np.transpose((dummy_data == model_config.data_loader.PAD_IDX))
else:
raise ValueError(f"不支持的need_type={need_type}, 仅支持['torch.tensor', 'numpy.NDArray']")
if keep:
input_data = (
token_ids,
padding_mask,
token_ids
)
input_names = ["input_ids", "attention_mask", "token_type_ids"]
else:
input_data = (
token_ids,
padding_mask
)
input_names = ["input_ids", "attention_mask"]
return input_data, input_names

def torch2onnx(dummy_data, keep, dynamic):
'''
```
  :param dummy_data:
  :param keep: 是否手动生成token_type_ids
  :param dynamic: 是否存在动态维度
  :return:
  '''
  # 1、加载原始模型
  torch_model = load_torch_model(model_path)

  # 2、build data
  input_data, input_names = build_data(dummy_data, keep=keep, need_type="torch.tensor")
  # todo 因为本次微调的模型只有一个序列，所以token_type_ids可省略
  #   方案一：设置dynamic=True 测试动态shape（这是输入的shape(input_data)可以随意指定）-- 注意：NPU机器是Atlas 200/500 A2推理产品，不支持动态shape
  #   方案二：设置dynamic=Flase 测试固定shape（这是输入的shape(input_data)也是固定的）
  output_names, dynamic_axes = export_config(input_names, dynamic=dynamic)

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

  # 4、onnx模型合理性验证
  # 模型加载
  onnx_model = onnx.load(onnx_path)
  # 检查onnx模型转换是否合理
  onnx.checker.check_model(onnx_model)
```
def onnx_predict(dummy_data, onnx_path, keep=False):
# 1、torch模型加载和推理
origin_model = load_torch_model(model_path)
(token_ids, padding_mask), _ = build_data(dummy_data, keep=keep, need_type="torch.tensor")
torch_out = origin_model(input_ids=token_ids, # [src_len, batch_size]
attention_mask=padding_mask) # [batch_size,src_len]
torch_out = torch_out.detach().numpy()
# 2、onnx模型加载和推理
ort_outs = onnx_model_predict(onnx_path, dummy_data, keep=keep)
# 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、获取当前设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# 2、给onnx的input_data设置shape
# todo Atlas 200/500 A2推理产品不支持动态Shape输入（设置Shape范围）。详见官方文档 https://www.hiascend.com/document/detail/zh/canncommercial/70RC1/inferapplicationdev/aclpythondevg/aclpythondevg_0060.html
# 但NPU机器是Atlas 200/500 A2推理产品，不支持动态shape，所以这里先固定，在推理时也要改成固定。
dynamic = False # 是否支持动态维度
keep = False # 是否保留token_type_ids
# todo 注意本次使用的bert微调代码中shape(input_shape) =（src_len, batch_size），不是（batch_size，src_len）
# todo 训练时，input_shape有多种选择，具体见E:\1pythonwork\mindstudio-test\invoice_ner\utils\data_helpers.py下的BertForTokenClassification类描述。
if dynamic:
# （1）动态shape
input_shape = (np.random.randint(10, 513), 1)
# todo 本次训练使用的input_shape=(src_len,batch_size),src_len是当前批次中的最大长度，不是固定的512.
model_path = 'E:\3gitwork\extract_invoice_info\invoice_ner\result\ner_model_epoch1_steps1000.pt'
# todo dynamic_shape_model/old/xx下的文件是旧的转换结果，当时的转换脚本写的还有一定问题，但先保留着。
onnx_path = "dynamic_shape_model/ner_model_bert.onnx" # todo 定义onnx模型保存地址。当max_len=None时，默认token_id的shape等于"每一批次中文本的最大长度"，是个动态变化的参数
else:
# （2）固定shape
input_shape = (512, 1)
model_path = 'E:\opencode\13-02-BertWithPretrained-main\cache1\ner_model_epoch1_steps1000.pt'
onnx_path = "fixed_shape_model/ner_model_bert.onnx" # todo 定义onnx模型保存地址。固定max_len=512
# 3、按shape生成dummy_data，以便后续以此为基础构建onnx模型的样本输入数据input_data，这是为了让转换器知道模型的输入形状
# #（方案1）随机型：在测试转换前后的误差时，需要传递同一输入值
# dummy_data = np.random.randn(*input_shape).astype(np.long)
# # （方案2）固定值型
dummy_data = np.ones(input_shape).astype(np.long)
```
  onnx_file = Path(onnx_path)
  if not onnx_file.is_file():
      # keep: 是否保留token_type_ids
      torch2onnx(dummy_data, keep=keep, dynamic=dynamic)

  onnx_predict(dummy_data, onnx_path, keep=keep)
```

1.3 onnx转om

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