华为AI战略的CANN

基于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 sys

home_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 = 0

if 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_index
    

def 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_id

def get_model_data(model_id):
    global model_desc
    model_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_size

def gen_data_buffer(num, des):
    global model_desc
    func = 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_mode
    global 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_list

def _data_interaction_in(dataset):
    global input_data
    temp_data_buffer = input_data
    for 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_data
    if type == "in":    
        temp_dataset = input_data
    else:
        temp_dataset = output_data
    for 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_dataset
    dataset = acl.mdl.create_dataset()
    #print("create data_set  success".format(type))
    if type == "in":    
        load_input_dataset = dataset
    else:
        load_output_dataset = dataset
    create_buffer(dataset, type)

def inference(model_id, _input, _output):
    global load_input_dataset, load_output_dataset
    ret = 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_dataset
    for dataset in [load_input_dataset, load_output_dataset]:
        if not dataset:
            continue
        num = 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_data
    temp_data_buffer = output_data
    if 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, INDEX
    dataset = []
    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+=1
    for 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_data
    ret = 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 = None
    ret = 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.size
        input_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()