用 C++ 写推理代码性能好，但开发效率低。调试一个 Buffer 越界问题可能要编译运行好几轮。Python 开发快，但直接调用底层 CANN API 需要封装。

pyasc 是 CANN 的 Python 绑定层——把 AscendCL 的 C API 封装成 Python 可调用的接口。想快速验证一个模型在昇腾 NPU 上的推理效果，用 pyasc 写几行 Python 代码就行。

---

pyasc 是什么

pyasc 不是单独的推理框架——它是 CANN Toolkit 自带的 Python 模块。安装 CANN Toolkit 后可以通过 import pyasc 直接使用：

import pyasc as pa

# 初始化
pa.init()
device = pa.set_device(0)

# 加载模型
model = pa.load_model("model.om")

# 创建输入
input_tensor = pa.Tensor(data, dtype=pa.float16)

# 推理
output = model.execute([input_tensor])

# 拿结果
result = output[0].to_numpy()

每个 pa.* 调用底层调的都是 AscendCL 的 C API。pa.load_model 内部调 aclmdlLoadFromFile，model.execute 内部调 aclmdlExecute。不新增抽象层，Python 代码直接映射到 C API。

---

环境配置

安装 CANN Toolkit 后配置 Python 环境：

# 设置 Python 路径
export PYTHONPATH=/usr/local/Ascend/ascend-toolkit/latest/python/site-packages:$PYTHONPATH

# 验证
python -c "import pyasc; print(pyasc.__version__)"
# 输出: 8.0.0.alpha001

如果 import 失败，检查 LD_LIBRARY_PATH 是否包含 CANN 的 lib64 目录——pyasc 的 .so 文件依赖 libascendcl.so。

常见问题：Python 版本不兼容。CANN 8.0 的 pyasc 支持 Python 3.8-3.10。Python 3.11+ 需要用源码重新编译 pyasc。

---

推理示例代码

用 pyasc 做一个完整的推理链路：

import pyasc as pa
import numpy as np

class ModelInfer:
    def __init__(self, model_path):
        pa.init()
        self.device = pa.set_device(0)
        self.context = pa.create_context(self.device)
        self.model = pa.load_model(model_path)
        
        # 获取模型输入输出信息
        self.input_shape = self.model.input_shape(0)
        self.output_shape = self.model.output_shape(0)
    
    def preprocess(self, image_path):
        # 用 NumPy 做预处理
        import cv2
        img = cv2.imread(image_path)
        img = cv2.resize(img, (self.input_shape[2], self.input_shape[3]))
        img = img.astype(np.float32) / 255.0
        img = img.transpose(2, 0, 1)  # HWC → CHW
        img = np.expand_dims(img, axis=0)  # → NCHW
        return img
    
    def infer(self, input_data):
        # 创建 NPU Tensor
        input_tensor = pa.Tensor(input_data, dtype=pa.float32)
        
        # 推理
        output_tensors = self.model.execute([input_tensor])
        
        # 转回 NumPy
        return output_tensors[0].to_numpy()
    
    def close(self):
        self.model.unload()
        pa.reset_device(self.device)
        pa.finalize()

# 使用
model = ModelInfer("yolov8n.om")
input_data = model.preprocess("test.jpg")
output = model.infer(input_data)
print(f"Output shape: {output.shape}")
model.close()

pa.Tensor 的构造方法接受 NumPy ndarray，自动分配 Device 显存并拷贝数据。to_numpy() 把结果从 Device 拷回 CPU。

---

常见问题分析

OOM 错误。 每次 pa.Tensor 都在 NPU 显存上分配。如果不及时释放，显存在连续推理中会被耗尽。pyasc 的 Tensor 在 Python 引用计数归零时自动释放，但推理循环中的临时 Tensor 如果被持久引用就会累积。建议在不需要时显式 del tensor 或 tensor.free()。

Runtime 未初始化。 在子进程中（如多进程推理）使用 pyasc 时，每个子进程必须独立调用 pa.init()。父进程 pa.init() 创建的上下文不会自动继承给子进程。

设备号超出范围。 pa.set_device(device_id) 时如果 device_id 大于实际 NPU 卡数，返回 pa.ERROR_INVALID_DEVICE。建议在初始化时先调用 pa.get_device_count() 检查可用设备数。

Tensor 数据类型不匹配。 模型的 ONNX/OM 输入规格是 float32 而传入 pa.float16 数据，推理结果全错。必须在创建 pa.Tensor 前检查模型的输入数据类型。

pyasc 与 AscendCL 的对应关系

pyasc API	底层 AscendCL C API
pa.init()	aclInit
pa.set_device(0)	aclrtSetDevice
pa.load_model("model.om")	aclmdlLoadFromFile
model.execute([tensor])	aclmdlExecute
Tensor(data, dtype=pa.float16)	aclrtMalloc + aclrtMemcpy
tensor.to_numpy()	aclrtMemcpy(D2H)

每个 pyasc API 直接映射到一条 C API，不经过额外的 Python 封装层。这意味着 pyasc 的性能跟 C 版本几乎没有差距——调用链是 Python → C 扩展 → CANN Runtime，没有额外抽象。

pyasc 的多线程使用

pyasc 支持多线程推理，但需要注意每个线程必须管理自己的 Context。推荐的做法是每个推理线程初始化自己的 Context：

def worker(device_id):
    pa.init()
    pa.set_device(device_id)
    context = pa.create_context(device_id)
    model = pa.load_model("model.om")
    # 推理...
    pa.finalize()

参考仓库

pyasc Python 绑定的仓库

AscendCL C API 文档