class ACL_inference(object):
        def __init__(self, device_id):
            import acl
            self.acl = acl
            self.device_id = device_id
            ret = self.acl.init()
            print('初始化', ret)
            self.acl.rt.set_device(self.device_id)
            self.context = None
            self.model_id = None
            self.model_desc = None
            self.load_input_dataset = None
            self.load_output_dataset = None
            self.input_data = []
            self.output_data = []
            self.ACL_MEMCPY_HOST_TO_DEVICE = 1
            self.ACL_MEMCPY_DEVICE_TO_HOST = 2
            self.ACL_MEM_MALLOC_HUGE_ONLY = 0

        def init(self, model_path):
            # 创建独立上下文
            self.context, _ = self.acl.rt.create_context(self.device_id)
            self.model_id, _ = self.acl.mdl.load_from_file(model_path)
            self.model_desc = self.acl.mdl.create_desc()
            self.acl.mdl.get_desc(self.model_desc, self.model_id)
            self.gen_input_dataset()
            self.gen_output_dataset()

        def gen_input_dataset(self):
            self.load_input_dataset = self.acl.mdl.create_dataset()
            input_size = self.acl.mdl.get_num_inputs(self.model_desc)
            for i in range(input_size):
                buffer_size = self.acl.mdl.get_input_size_by_index(self.model_desc, i)
                buffer, ret = self.acl.rt.malloc(buffer_size, self.ACL_MEM_MALLOC_HUGE_ONLY)
                data = self.acl.create_data_buffer(buffer, buffer_size)
                _, ret = self.acl.mdl.add_dataset_buffer(self.load_input_dataset, data)
                self.input_data.append({"buffer": buffer, "size": buffer_size})

        def gen_output_dataset(self):
            self.load_output_dataset = self.acl.mdl.create_dataset()
            output_size = self.acl.mdl.get_num_outputs(self.model_desc)
            for i in range(output_size):
                buffer_size = self.acl.mdl.get_output_size_by_index(self.model_desc, i)
                buffer, ret = self.acl.rt.malloc(buffer_size, self.ACL_MEM_MALLOC_HUGE_ONLY)
                data = self.acl.create_data_buffer(buffer, buffer_size)
                _, ret = self.acl.mdl.add_dataset_buffer(self.load_output_dataset, data)
                self.output_data.append({"buffer": buffer, "size": buffer_size})

        def load_input_data(self, img):
            bytes_data = img.tobytes()
            np_ptr = self.acl.util.bytes_to_ptr(bytes_data)
            self.acl.rt.memcpy(self.input_data[0]["buffer"], self.input_data[0]["size"], np_ptr,
                               self.input_data[0]["size"], self.ACL_MEMCPY_HOST_TO_DEVICE)

        def process_output(self):
            inference_result = []
            for i, item in enumerate(self.output_data):
                dims = self.acl.mdl.get_output_dims(self.model_desc, i)
                shape = tuple(dims[i]["dims"])
                buffer_host, ret = self.acl.rt.malloc_host(self.output_data[i]["size"])

                self.acl.rt.memcpy(buffer_host, self.output_data[i]["size"], self.output_data[i]["buffer"],
                                   self.output_data[i]["size"], self.ACL_MEMCPY_DEVICE_TO_HOST)
                bytes_out = self.acl.util.ptr_to_bytes(buffer_host, self.output_data[i]["size"])
                data = np.frombuffer(bytes_out, dtype=np.float32).reshape(shape)
                inference_result.append(data)
                self.acl.rt.free_host(buffer_host)
            return inference_result

        def execute(self):
            self.acl.mdl.execute(self.model_id, self.load_input_dataset, self.load_output_dataset)

        def destory(self):
            # 销毁模型和上下文
            self.acl.mdl.unload(self.model_id)
            self.acl.rt.destroy_context(self.context)
            self.acl.rt.reset_device(self.device_id)
            self.acl.finalize()