基于TVM的华为昇腾体系中——
异构计算架构（CANN）是对标英伟达的CUDA + CuDNN的核心软件层，向上支持多种AI框架，向下服务AI处理器，发挥承上启下的关键作用，是提升昇腾AI处理器计算效率的关键平台

主要包括有各种引擎、编译器、执行器、算子库等。

之所以叫异构软件，是因为承载计算的底层硬件包括AI芯片和通用芯片，自然就需要有一层软件来负责算子的调度、加速和执行，最后自动分配到对应的硬件上（CPU或NPU，注：昇腾处理器一般也叫NPU），因此叫异构。

AI框架：
AI框架层主要包括自研框架MindSpore（昇思）和第三方框架（PyTorch、TensorFlow等），其中MindSpore完全由华为自主研发，第三方框架华为只是做了适配和优化，让PyTorch和TensorFlow等框架编写的模型可以高效的跑在昇腾芯片上。

以PyTorch为例，华为的框架研发人员会将其做好适配，然后把适配后的PyTorch源码发布出来，想要在昇腾上用PyTorch的开发者，下载该源码自行编译安装即可。

在安装PyTorch昇腾版后，如果想要把一个开源的PyTorch模型跑起来，只需要对模型源码做简单的适配即可，相关教程可以参考PyTorch训练模型迁移至昇腾完整教程。

对于MindSpore框架，用户直接按照MindSpore官网的教程安装即可，用MindSpore框架编写的模型既可以跑在昇腾上，也支持跑在GPU等其它第三方芯片上。

CANN 3.0如何实现的计算资源智能分配？

神经网络可看作一张张的图，过去大部分图在HostCPU执行，如今昇腾的图编译器，实现了整图下沉，图和算子均可在Device侧执行，减少了芯片与Host CPU的交互时间，从而更充分地发挥昇腾芯片的算力。

像TF搭建的神经网络都是一张张计算图，过去这些图都在HostCPU中执行，资源允许的时候整个图都在HostCPU中执行效率是很高的，但是资源有限的情况就需要Device侧协同处理，也就是昇腾加速卡中，通过把整张图下沉到Device中，可以高效协同CPU完成计算。

根据图的特点和计算资源的分配情况，CANN可以自动进行图的拆分和融合，尽量减少和HostCPU的交互，交互少了，计算资源就能持续保持高强度运转。

数据Pipeline智能优化极大提升了数据资源处理效率，通过人工智能实现数据的自动切分与智能分配流水，以最大化个体计算单元的使用率，从而提高计算效率。

除了图自动编译和图的拆分融合优化，CANN 3.0的1000+算子库让你的神经网络「瞬时」加速。

强如英伟达，cuDNN也只有一百多个算子，CANN 3.0不仅包括了常用的Caffe 及 TF 算子，还独立提供各种加速库，这些加速库可通过 ACL统一编程接口实现，如矩阵乘接口等。

CANN 3.0现在的架构功能十分完善，对外提供适配不同硬件、不同 OS 的驱动，支持GPU+CPU异构通信，对内可实现Stream、内存等底层管理，丰富的加速库支持算子/标量/向量等通用计算，能高效完成图像和视频数据的预处理，执行引擎为深度神经网络计算提供了执行上的保障。

有了CANN 3.0保驾护航，在主流推理场景，昇腾AI推理卡Atlas 300I性能得到大幅提升。

要验证推理性能，多路高清视频分析的场景再合适不过了，高清视频本身流量大，加上多路融合更考验计算平台的并发处理能力，实测表明单张Atlas 300I推理卡可同时处理80路1080p、25FPS的高清视频，是当前市面上同类推理卡路数的2倍。

对交通、安防等场景来说，需要同时处理的视频路数就更多了，少则几百，多则上万，如果单卡能处理更多的任务，规模化应用时成本优势就会扩大，而且硬件数量少了更容易部署。所以很多人工智能厂商，正基于昇腾AI推理卡打造极致性能的高路数视频分析解决方案。

CANN 3.0不仅降低了各个领域使用昇腾芯片开发应用的难度，还提供了很多优秀的中间件和基础库使能各个厂商，但面对谷歌、英伟达、英特尔等国际巨头的强力竞争，想要生存下去，还是要构建一个完整的生态，为学术界和产业界贡献更多算力，为合作伙伴创造更多价值。

import argparse
import numpy as np
import struct
import acl
import os
from PIL import Image
import syshome_path = get_ipython().getoutput(echo $HOME)
sys.path.append(os.path.join(home_path[0] , "jupyter-notebook/"))
print(System init success.)from src.acl_dvpp import Dvpp
import src.constants as const
from src.acl_image import AclImage
from src.image_net_classes import get_image_net_class
WORK_DIR = os.getcwd()
ACL_MEM_MALLOC_HUGE_FIRST = 0
ACL_MEMCPY_HOST_TO_DEVICE = 1
ACL_MEMCPY_DEVICE_TO_HOST = 2
ACL_ERROR_NONE = 0
MODEL_WIDTH = 224
MODEL_HEIGHT = 224
IMG_EXT = [.jpg, .JPG, .png, .PNG, .bmp, .BMP, .jpeg, .JPEG]ret = acl.init()# GLOBAL
load_input_dataset = None
load_output_dataset = None
input_data = []
output_data = []
_output_info = []
images_list = []
model_desc = 0
run_mode = 0
INDEX = 0if WORK_DIR.find("src") == -1:MODEL_PATH = WORK_DIR + "/src/model/googlenet_yuv.om"DATA_PATH = WORK_DIR + "/src/data"
else:MODEL_PATH = WORK_DIR + "/model/googlenet_yuv.om"DATA_PATH = WORK_DIR + "/data"buffer_method = "in": acl.mdl.get_input_size_by_index,"out": acl.mdl.get_output_size_by_indexdef check_ret(message, ret):if ret != ACL_ERROR_NONE:raise Exception(" failed ret=".format(message, ret))
def init():ret = acl.init()check_ret("acl.init", ret)print("init success")
def allocate_res(device_id):   ret = acl.rt.set_device(device_id)check_ret("acl.rt.set_device", ret)context, ret = acl.rt.create_context(device_id)check_ret("acl.rt.create_context", ret)print("allocate_res success")return context
def load_model(model_path):model_id, ret = acl.mdl.load_from_file(model_path)check_ret("acl.mdl.load_from_file", ret)print("load_model success")return model_iddef get_model_data(model_id):global model_descmodel_desc = acl.mdl.create_desc()ret = acl.mdl.get_desc(model_desc, model_id)check_ret("acl.mdl.get_desc", ret)input_size = acl.mdl.get_num_inputs(model_desc)output_size = acl.mdl.get_num_outputs(model_desc)print("get_model_data success")return input_size, output_sizedef gen_data_buffer(num, des):global model_descfunc = buffer_method[des]for i in range(num):#temp_buffer_size = (model_desc, i)temp_buffer_size  = acl.mdl.get_output_size_by_index(model_desc, i)temp_buffer, ret = acl.rt.malloc(temp_buffer_size,const.ACL_MEM_MALLOC_NORMAL_ONLY)check_ret("acl.rt.malloc", ret)if des == "in":input_data.append("buffer": temp_buffer,"size": temp_buffer_size)elif des == "out":output_data.append("buffer": temp_buffer,"size": temp_buffer_size)
def malloc_device(input_num, output_num):gen_data_buffer(input_num, des="in")gen_data_buffer(output_num, des="out")
def image_process_dvpp(dvpp):global run_modeglobal images_list   # _dvpp.init_resource()IMG_EXT = [.jpg, .JPG, .png, .PNG, .bmp, .BMP, .jpeg, .JPEG]images_list = [os.path.join(DATA_PATH, img)for img in os.listdir(DATA_PATH)if os.path.splitext(img)[1] in IMG_EXT]img_list = []for image_file in images_list:#读入图片image = AclImage(image_file)image_input = image.copy_to_dvpp()#对图片预处理yuv_image = dvpp.jpegd(image_input)resized_image = dvpp.resize(yuv_image, MODEL_WIDTH, MODEL_HEIGHT)img_list.append(resized_image)print("dvpp_process image:  success".format(image_file))return img_listdef _data_interaction_in(dataset):global input_datatemp_data_buffer = input_datafor i in range(len(temp_data_buffer)):item = temp_data_buffer[i]ptr = acl.util.numpy_to_ptr(dataset)ret = acl.rt.memcpy(item["buffer"],item["size"],ptr,item["size"],ACL_MEMCPY_HOST_TO_DEVICE)check_ret("acl.rt.memcpy", ret)print("data_interaction_in success")def create_buffer(dataset, type="in"):global input_data, output_dataif type == "in":    temp_dataset = input_dataelse:temp_dataset = output_datafor i in range(len(temp_dataset)):item = temp_dataset[i]data = acl.create_data_buffer(item["buffer"], item["size"])if data is None:ret = acl.destroy_data_buffer(dataset)check_ret("acl.destroy_data_buffer", ret)_, ret = acl.mdl.add_dataset_buffer(dataset, data)if ret != ACL_ERROR_NONE:ret = acl.destroy_data_buffer(dataset)check_ret("acl.destroy_data_buffer", ret)#print("create data_buffer  success".format(type))def _gen_dataset(type="in"):global load_input_dataset, load_output_datasetdataset = acl.mdl.create_dataset()#print("create data_set  success".format(type))if type == "in":    load_input_dataset = datasetelse:load_output_dataset = datasetcreate_buffer(dataset, type)def inference(model_id, _input, _output):global load_input_dataset, load_output_datasetret = acl.mdl.execute(model_id,load_input_dataset,load_output_dataset)check_ret("acl.mdl.execute", ret)
def _destroy_data_set_buffer():global load_input_dataset, load_output_datasetfor dataset in [load_input_dataset, load_output_dataset]:if not dataset:continuenum = acl.mdl.get_dataset_num_buffers(dataset)for i in range(num):data_buf = acl.mdl.get_dataset_buffer(dataset, i)if data_buf:ret = acl.destroy_data_buffer(data_buf)check_ret("acl.destroy_data_buffer", ret)ret = acl.mdl.destroy_dataset(dataset)check_ret("acl.mdl.destroy_dataset", ret)def _data_interaction_out(dataset):global output_datatemp_data_buffer = output_dataif len(dataset) == 0:for item in output_data:temp, ret = acl.rt.malloc_host(item["size"])if ret != 0:raise Exception("cant malloc_host ret=".format(ret))dataset.append("size": item["size"], "buffer": temp)for i in range(len(temp_data_buffer)):item = temp_data_buffer[i]ptr = dataset[i]["buffer"]ret = acl.rt.memcpy(ptr,item["size"],item["buffer"],item["size"],ACL_MEMCPY_DEVICE_TO_HOST)check_ret("acl.rt.memcpy", ret)def print_result(result):global images_list, INDEXdataset = []for i in range(len(result)):temp = result[i]size = temp["size"]ptr = temp["buffer"]data = acl.util.ptr_to_numpy(ptr, (size,), 1)dataset.append(data)st = struct.unpack("1000f", bytearray(dataset[0]))vals = np.array(st).flatten()top_k = vals.argsort()[-1:-6:-1]print()print("======== image:  =============".format(images_list[INDEX]))print("======== top5 inference results: =============")INDEX+=1for n in top_k:object_class = get_image_net_class(n)print("label:%d  confidence: %f, class: %s" % (n, vals[n], object_class))def release(model_id, context):global input_data, output_dataret = acl.mdl.unload(model_id)check_ret("acl.mdl.unload", ret)while input_data:item = input_data.pop()ret = acl.rt.free(item["buffer"])check_ret("acl.rt.free", ret)while output_data:item = output_data.pop()ret = acl.rt.free(item["buffer"])check_ret("acl.rt.free", ret)if context:ret = acl.rt.destroy_context(context)check_ret("acl.rt.destroy_context", ret)context = Noneret = acl.rt.reset_device(0)check_ret("acl.rt.reset_device", ret)print(release source success)
def main():global input_data #init()context = allocate_res(0)model_id = load_model(MODEL_PATH)input_num, output_num = get_model_data(model_id)malloc_device(input_num, output_num) dvpp = Dvpp()img_list = image_process_dvpp(dvpp)for image  in img_list:image_data = "buffer":image.data(), "size":image.sizeinput_data[0] = image_data_gen_dataset("in")_gen_dataset("out")inference(model_id, load_input_dataset, load_output_dataset)_destroy_data_set_buffer()res = []_data_interaction_out(res)print_result(res)release(model_id,context)if __name__ == __main__:main()