【CANN】-初识

子非鱼eva

105人浏览 · 2026-06-25 15:31:51

子非鱼eva · 2026-06-25 15:31:51 发布

【CANN】-初识

适用: 刚开始接触昇腾的开发者, 有 AI 训练 / 推理基础, 知道 PyTorch / MindSpore, 但不清楚 CANN 在哪里
当前版本: CANN 8.0+ (主) / 6.0.1+ (历史)
关联博客: 《【CANN】-Ascend C 算子开发》 (算子层深入) / 《【昇腾训练】-MindSpeed 开发入门》 / 《【昇腾推理】-MindIE 极速入门》

一、CANN 的定义

CANN = Compute Architecture for Neural Networks, 昇腾的异构计算架构. 是一套让上层 AI 框架 (PyTorch / MindSpore) 能跑在昇腾 NPU 芯片上的完整软件栈, 不是单个库或单个工具.

CANN 包含 3 个核心交付物

交付物	角色	何时用
CANN Toolkit	开发套件 (编译器 / Runtime / 调试器)	装一次, 所有 NPU 程序都依赖它
CANN Ops 算子包	算子库 (内置高性能算子)	装一次, 提供基础算子实现
NNAL 加速库 (可选)	Transformer / 信号处理专用加速	按需装, 特定场景加速

关键洞察: 多数新人把 CANN 当 “NPU 的 CUDA”, 但 CANN 比 CUDA 范围更广. CUDA = 驱动 + Runtime + cuDNN (库) + nvcc (编译器); CANN = 驱动 + 运行时 + 算子库 + 通信库 + 图引擎 + 领域加速库 + 框架适配 + 编程语言 + 编译器 (毕昇 Bisheng) + AscendC / PyPTO. CANN 是端到端的, 从硬件到 AI 框架全覆盖.

二、CANN 在昇腾栈中的位置

CANN 是昇腾生态的**“中间层”**: 上接 AI 框架 (PyTorch / MindSpore), 下接 NPU 硬件.

在这里插入图片描述

昇腾技术栈层次 (自上而下)

层级	组件	角色
7. 应用层	MindSpeed / MindIE / 用户应用	业务代码
6. 框架层	PyTorch / MindSpore / vLLM	训练 / 推理框架
5. 适配层	torch_npu / torch_npu.npu	PyTorch NPU 桥接
4. CANN 核心 (9 层)	框架适配 / 算子库 / 通信库 / 图引擎 / 领域加速库 / 编程语言 / 编译器 / 运行时 / 驱动	昇腾软件栈 (本博客主角)
3. 驱动	npu driver (kernel module)	硬件资源管理
2. 固件	npu firmware	板级固件
1. 硬件	NPU 芯片 (910B3 / 310P)	计算芯片

关键洞察: CANN 是个**“基础设施层”**: 它不直接面向业务, 但所有业务都跑在它上面. 类比: PyTorch 对 GPU, CANN 对 NPU. 类比: 数据库对应用, CANN 对 AI 框架. 这个"中间层"定位决定了 CANN 的核心特征: 稳定 + 兼容 + 性能, 不变在前沿.

三、CANN 的作用: 解决 3 大问题

CANN 的存在是为了解决"AI 框架 + NPU 硬件"之间 3 个具体问题. 理解这 3 个问题, 就理解了 CANN 存在的理由.

3 大问题与 CANN 对应方案

#	问题	CANN 方案
1	AI 框架不认识 NPU (PyTorch 只认 CUDA)	框架适配层 (torch_npu) 把 PyTorch 的 `cuda()` 调用翻译成 NPU 调用
2	NPU 算子能力未公开 (硬件 AI Core / Vector Core 怎么用)	算子库 (ops-math / ops-nn / ops-cv / ops-transformer) + 编程语言 (AscendC / PyPTO), 把硬件能力封装成可调用的算子
3	计算图在 NPU 上跑不快 (算子单独能跑, 组合起来慢)	图引擎 (GE) 整网优化 + 运行时调度 (Continuous Batching / 多核并行)

关键洞察: 3 个问题对应 3 类用户: 框架开发者 (用框架适配层 torch_npu) / 算子开发者 (用编程语言 AscendC + 编译器毕昇 Bisheng) / 性能调优者 (用图引擎 GE + 运行时配置). 一个完整的昇腾项目里, 这 3 类用户会同时存在, 各自用 CANN 的不同层.

四、CANN 内部架构: 9 层软件栈

CANN 由 9 个核心组件层 组成, 顺序按"从应用层向下到硬件"排列: 框架适配 → 算子库 → 通信库 → 图引擎 → 领域加速库 → 编程语言 → 编译器 → 运行时 → 驱动. 每层向下抽象硬件细节, 向上提供更高级的 API. 应用层 (PyTorch / MindSpore) 站在 CANN 之上, 不算 CANN 的层.

在这里插入图片描述

CANN 9 层架构

顺序	层次	组件	一句话职责
1	框架适配层	torch_npu 等	让 PyTorch 代码一行改动就能跑在 NPU 上
2	算子库	ops-math / ops-nn / ops-cv / ops-transformer 等	提供海量预置算子, 覆盖主流 AI 场景
3	通信库	HCCL / HIXL	多卡分布式训练/推理的通信保障
4	图引擎	GE	整网图优化 (融合/内存/流水), 最大化性能
5	领域加速库	FFT / BLAS 等	特定领域的算子+算法组合, 提供极致加速
6	编程语言	Ascend C / PyPTO 等	算子编程语言, 开发算子
7	编译器	毕昇 Bisheng	把算子源码编译成 NPU 可执行指令
8	运行时	Runtime	管理 NPU 设备/内存/任务调度
9	驱动	Driver	与 NPU 硬件直接交互的最底层软件

┌─────────────────────────────────────────┐
│  (应用层  PyTorch / MindSpore  不算 CANN 层) │
├─────────────────────────────────────────┤
│ 1. 框架适配层    torch_npu 等               │
├─────────────────────────────────────────┤
│ 2. 算子库        ops-math / ops-nn / ...   │
├─────────────────────────────────────────┤
│ 3. 通信库        HCCL / HIXL              │
├─────────────────────────────────────────┤
│ 4. 图引擎        GE (整网图优化)           │
├─────────────────────────────────────────┤
│ 5. 领域加速库    FFT / BLAS 等             │
├─────────────────────────────────────────┤
│ 6. 编程语言      Ascend C / PyPTO 等      │
├─────────────────────────────────────────┤
│ 7. 编译器        毕昇 Bisheng             │
├─────────────────────────────────────────┤
│ 8. 运行时        Runtime                   │
├─────────────────────────────────────────┤
│ 9. 驱动          Driver                    │
└─────────────────────────────────────────┘

关键洞察: 这 9 层是从应用层向下到硬件的视角. 多数 AI 应用开发者只需关心层 1 (框架适配层, torch_npu) 就能跑通; 算子开发者关心层 2 + 5 + 6 + 7 (用算子库的预置算子 / 领域加速库 / Ascend C PyPTO 编程 / Bisheng 编译); 分布式 / 大规模部署者关心层 3 + 8 (HCCL 通信 + Runtime 调度). 了解你在哪一层, 决定你该深入学什么.

五、内部层级简介: 各层职责

9 层里应用层 (PyTorch / MindSpore) 在 CANN 之上, 不算 CANN 本身. 下面按"应用层向下到硬件"顺序介绍 9 个 CANN 层.

5.0 应用层 (PyTorch / MindSpore): 站在 CANN 之上

职责: 提供用户熟悉的 AI 编程接口. 应用层不算 CANN 内部层, 但所有应用都通过层 1 (框架适配层) 与 CANN 衔接.

接口	适用
PyTorch + torch_npu	90% 开发者用这个, 与 GPU 体验几乎一致
MindSpore	华为自研框架, 端到端优化更彻底

5.1 框架适配层 (torch_npu 等)

职责: 让 PyTorch 代码一行改动就能跑在 NPU 上: 把 cuda() / cuda.is_available() 翻译成 npu() / npu.is_available(), 把上层 AI 框架的"算子调用 / tensor 分配"翻译成 CANN 内部调用.

组件	职责
torch_npu	PyTorch 的 NPU 适配, 一行改动即用 (如 `model.to('cuda')` → `model.to('npu')`)
MindSpore Adapter	MindSpore 内部直接对接 CANN (无需独立适配包)

关键洞察: 多数人以为"装 torch_npu = 装 CANN", 实际 torch_npu 只是 CANN 的"PyTorch 入口". 装 torch_npu 时, CANN 也会被依赖拉起来, 但 CANN 是独立组件, 可单独装.

5.2 算子库 (ops-math / ops-nn / ops-cv / ops-transformer 等)

职责: 提供海量预置算子, 覆盖主流 AI 场景: 把 NPU 的 AI Core / Vector Core 算力封装成可调用的算子, 让上层 (应用层 / 领域加速库) 直接用, 不用每个模型都自己写算子.

算子库	覆盖场景	典型算子
ops-math	数学基础	Add / Mul / MatMul / Reduce
ops-nn	神经网络基础	Conv / Pooling / LayerNorm / Activation
ops-cv	计算机视觉	Resize / Crop / NMS / ROIAlign
ops-transformer	Transformer	FlashAttention / RotaryEmbedding / PagedAttention

关键洞察: 算子库是CANN 性能的基础: 上层 (ATB / 应用层) 调用的算子, 90% 来自算子库. 算子库覆盖度直接决定 NPU 支持的模型范围. 装 CANN 时必须装算子库, 缺它等于没装 CANN.

5.3 通信库 (HCCL / HIXL)

职责: 多卡分布式训练/推理的通信保障: 提供多卡 / 多机通信能力, 是分布式训练和大规模推理的底座.

库	职责	适用
HCCL (Huawei Collective Communication Library)	集合通信 (AllReduce / AllGather / Broadcast / ReduceScatter)	多卡 / 多机训练 + 推理
HIXL (Huawei one-sided communIcation Library)	单边通信 (跨节点直接读写)	大模型推理 KV Cache 跨节点共享

关键洞察: HCCL 是昇腾版的 NCCL, API 高度对齐. MindSpeed / MindIE-LLM 的多卡能力都依赖 HCCL. HIXL 是推理专属 (训练用不到), 用于大模型推理的 KV Cache 跨节点共享, 显著降低首 token 延迟.

5.4 图引擎 (GE / Graph Engine)

职责: 整网图优化 (融合/内存/流水), 最大化性能: 在算子级别优化之上, 进一步在网络级别做整体优化, 让模型在 NPU 上跑得最快.

优化	作用
算子融合	把多个小算子合成 1 个 (如 Conv + BN + ReLU 合一)
常量折叠	提前计算图中的常量, 减少运行期计算
内存规划	算子间内存复用, 降低峰值显存
硬件亲和改写	把通用算子重写为 NPU 高效版本
流水并行	大模型按层切分, 多核并行执行

关键洞察: GE 是性能差距的核心: 同样一个模型, 跑在 GPU 上 vs 跑在 NPU + GE 优化后, 性能可能差 2-3 倍. GE 在算子库 (层 2) 提供的"零件"之上做"整网装配优化", 这是单算子优化做不到的.

5.5 领域加速库 (FFT / BLAS 等)

职责: 特定领域的算子+算法组合, 提供极致加速: 在通用算子库 (层 2) 之上, 把算子组合成"特定领域的高性能算法", 给最常见场景开小灶.

加速库	职责	适用
FFT (Fast Fourier Transform)	快速傅里叶变换, 高性能实现	信号处理 / 频域分析
BLAS (Basic Linear Algebra Subprograms)	基础线性代数子程序, 高性能 GEMM	矩阵乘 / 深度学习核心算子
ATB (Transformer Boost)	Transformer 类模型的高性能算子组合	LLM 推理 (Attention / MLP / Norm)
NNAL	NN 加速库 (信号处理)	Transformer / 信号处理场景

关键洞察: 领域加速库是"在通用算子之上, 拼出更高效的复合算法". 例如 BLAS 不是单独算子, 是把"矩阵乘 + 优化内存访问 + SIMD"组合成高性能 GEMM, 这是 LLM 训练 / 推理最热的算子. 领域加速库是"为最热场景预留的快车道".

5.6 编程语言 (Ascend C / PyPTO 等)

职责: 算子编程语言, 开发算子: 提供面向昇腾 NPU 的专用编程语言, 让算子开发者能用高级语言写自定义算子, 不用手写汇编.

语言	特点	适用
Ascend C	算子开发专用语言 (C++ 风格), CopyIn → Compute → CopyOut 三段式	面向 AI Core 写自定义算子
PyPTO	Python 风格算子编程 (PTO = Parallel Tensor Operation)	快速原型 / Python 生态集成
ACL Python API	Python 调 CANN 的高级 API, 不用写算子	应用开发者调现成算子

关键洞察: 90% 的应用开发者用不到 Ascend C / PyPTO, 用 torch_npu + Python + 算子库就够了. Ascend C 是给算子开发者的, PyPTO 是给"想用 Python 写算子"的, ACL Python 是给"用 Python 调算子但不写算子"的.

5.7 编译器 (毕昇 Bisheng)

职责: 把算子源码编译成 NPU 可执行指令: 算子开发者用 Ascend C / PyPTO 写的算子源码, 需要编译器翻译成 NPU 能跑的目标码.

工具	职责
毕昇 Bisheng (CANN 编译器)	算子源码 → NPU 可执行指令, 含优化

关键洞察: Bisheng 是"算子层的 GCC": 算子开发者写 Ascend C 源码, Bisheng 把它编译成 NPU 指令. Bisheng 与图引擎 (层 4 GE) 的区别: Bisheng 编译单个算子, GE 优化整网图, 两者协同工作 (Bisheng 出高效算子, GE 出高效整网).

5.8 运行时 (Runtime)

职责: 管理 NPU 设备/内存/任务调度: 应用运行时, Runtime 负责设备初始化 / 内存分配 / 任务下发 / 同步等.

子模块	职责
设备管理	NPU 设备初始化, 多卡识别
内存管理	申请 / 释放 NPU 显存 (HBM), 内存池管理
流队列 (Stream)	任务并发执行, 不同流独立
事件同步 (Event)	跨流同步机制
任务调度	算子下发到 NPU 的调度器

关键洞察: 运行时是性能问题的多发地: OOM / 死锁 / 同步等待 90% 出在这一层. 调优者多数时间在这一层调参数 (内存分配策略 / 流并发数 / 同步点).

5.9 驱动 (Driver)

职责: 与 NPU 硬件直接交互的最底层软件: 操作系统与 NPU 硬件之间的接口, 负责 PCIe 设备管理 / 内存映射 / 中断处理.

子模块	职责
PCIe 设备管理	NPU 设备的发现 / 初始化 / 中断
HCCS 链路	NPU 之间的片间高速互联
HBM 内存	显存物理地址管理
固件通信	与 NPU 板载固件的通信协议

关键洞察: 驱动层通常不需要用户调, 但装 CANN 时装好驱动是前提 (npu-smi info 能看到 NPU 卡, 就是驱动在干活). 驱动是整条软件栈的"接地"层: 它直接与 NPU 硬件对话, 上面所有层都通过它最终落到硬件.

六、代码演示: Python 端到端例子

核心目的: 让你看到 9 层中最常用层 1 (框架适配层) 的端到端 demo, 用 Python 跑通真实模型, 不需要 C++. 这一节聚焦层 1 (torch_npu) + 层 2 (算子库) + 层 5 (BLAS) + 层 6 (AscendC 间接) 的协同, 其他层 (通信库 / 图引擎 / 领域加速库 / 编译器 / 运行时 / 驱动) 都在背后默默工作.

6.1 准备 (装 CANN + 验证)

# 1. 装 CANN (以 .run 包方式, 8.0 为例)
chmod +x Ascend-cann-toolkit_8.0.0_linux-$(arch).run
./Ascend-cann-toolkit_8.0.0_linux-$(arch).run --install

# 2. 激活环境 (装驱动后才需要, 含 ASCEND_HOME 等变量)
source /usr/local/Ascend/ascend-toolkit/set_env.sh

# 3. 装 torch_npu (层 1 框架适配层, Python 包装)
pip install torch torch_npu

# 4. 验证 (层 9 驱动 + 层 1 框架适配层 协同)
npu-smi info
# 期望看到 N 张 NPU 卡, Health: OK

python -c "import torch, torch_npu; print(torch.npu.is_available())"
# 期望: True

6.2 PyTorch 端到端 demo (层 1 + 层 2 + 层 5 协同)

90% 开发者只需要用 Python, 用 torch_npu 就够了. 这个 demo 是"端到端跑通一个真实模型"的最短路径, 体现 CANN 的核心价值: 让 GPU 开发者无缝迁到 NPU, 上层代码完全不改.

import torch
import torch_npu
import torchvision.models as models

# 1. 设备 (层 1 框架适配层: torch_npu 把 cuda 调用翻译成 CANN 调用)
device = torch.device("npu:0")

# 2. 模型 / 数据 (应用层)
model = models.resnet50(weights=models.ResNet50_Weights.DEFAULT)
model = model.to(device).eval()
x = torch.randn(1, 3, 224, 224).to(device)

# 3. 推理 (实际触发: 算子库层 2 的 Conv/MatMul + 领域加速库层 5 的 BLAS + 运行时层 8 调度 + 驱动层 9 执行)
with torch.no_grad():
    y = model(x)
    pred = y.argmax(dim=1).item()

print(f"Predicted class: {pred}")
# 期望: 输出 0-999 的 ImageNet 类别, 无报错

关键洞察: PyTorch 写法与 GPU 完全一致: model.to(device) / x.to(device). 这是 CANN 设计的核心成就: 让 GPU 开发者无缝迁到 NPU, 上层代码完全不改. 不需要 C++, 也不需要 ACL API.

6.3 模型编译为离线 OM (层 3 编译器 + 层 4 图引擎协同)

想脱 PyTorch 部署, 可用层 3 编译器 (毕昇 Bisheng) 把模型编译为离线 .om 文件, 直接被 Runtime 加载 (常见于生产部署). 这一步调用层 4 图引擎做算子融合 / 内存规划等优化.

# 1. 导出 ONNX (用 PyTorch 的 torch.onnx.export)
python export_onnx.py  # 你的模型导出脚本, 输出 model.onnx

# 2. 用 ATC (层 3 编译器入口) 编译为 NPU 离线模型
atc --model=model.onnx \
    --framework=5 \
    --output=model_om \
    --soc_version=Ascend910B3

# 3. 启动后, 用 ACL Python 加载 (不需要 C++)
python -c "
import acl
ret = acl.init()
print('ACL init:', ret)
model_id, _ = acl.mdl.load_from_file('model_om/model.om')
print('Model loaded:', model_id)
"

关键洞察: 即使是"脱 PyTorch"部署, 加载 OM 模型也不需要 C++: ACL 提供 Python 绑定 (python -c "import acl; ..."). 90% 的部署场景能用 Python + Bash 解决, 不用碰 C++. 这一节用 3 个 demo 覆盖了 9 层中的层 1 / 层 2 / 层 3 / 层 4 / 层 5 协同, 剩下层 6 / 层 7 / 层 8 / 层 9 在 PyTorch 训练 + NPU 执行时被自动调用, 不需要用户写代码.

七、与 CUDA 的对照 (参考)

不是要论证"哪个更好", 而是让你快速映射已有的 GPU 知识到 NPU 概念.

GPU / CUDA 概念	昇腾 CANN 对应	备注
CUDA Toolkit	CANN Toolkit	都是底层 SDK
cuDNN / cuBLAS	算子库 (ops-math/nn/cv/transformer) + 领域加速库 (BLAS)	高性能算子实现
nvcc (编译器)	毕昇 Bisheng (CANN 编译器)	算子编译
CUDA Runtime	CANN Runtime	内存 / 流 / 同步
GPU Driver	npu driver	硬件驱动
TensorRT	MindIE-LLM / vLLM-Ascend	推理引擎 (不是 CANN 自带)
Nsight	msprof	性能分析工具

关键洞察: CANN 比 CUDA 多一层 GE (Graph Engine): 这是图编译优化, 让你在 ONNX → NPU 模型的转换中拿到算子融合 / 内存规划等优化. CUDA 用户需要 TensorRT 才能拿到类似的图优化, CANN 是内置的.

八、4 个常见踩坑 (CANN 入门)

#	现象	根因	解决
1	`npu-smi info` 找不到卡	驱动没装 / 用户无权限	装驱动 + `usermod -aG HwHiAiUser $USER`
2	`import torch_npu` 报 “找不到版本匹配的 torch”	torch 与 torch_npu 不匹配	严格按 `torch==X.Y.Z + torch-npu==X.Y.Z.postN` 装
3	`torch.npu.is_available()` 返回 False	驱动没装 / CANN 环境没 source	`source /usr/local/Ascend/cann/set_env.sh`
4	`acl` C++ demo 编译失败	头文件路径 / 库路径不对	编译时加 `-I$ASCEND_HOME/include -L$ASCEND_HOME/lib64 -lascendcl`

避坑心法: 装错 / 跑不起来 90% 是版本配套问题. 装之前先在昇腾文档站查驱动 + CANN + torch_npu + Python 4 件套的版本配套表, 别凭印象装.

九、关联资源

资源	链接
CANN 官方文档	https://www.hiascend.com/document
CANN 8.0+ 下载	https://www.hiascend.com/developer/download/community/result?module=ie%2Bpt%2Bcann
昇腾开发者社区	https://www.hiascend.com/forum
torch_npu 官方	https://gitee.com/ascend/pytorch
ATC 用户指南	https://www.hiascend.com/document (CANN 文档站 → ATC 章节)
msprof 用户指南	https://www.hiascend.com/document (CANN 文档站 → 性能调优 → profiler)
关联博客	《【CANN】-Ascend C 算子开发》 (算子层深入) / 《【昇腾训练】-MindSpeed 开发入门》/ 《【昇腾推理】-MindIE 极速入门》

总结

CANN = 昇腾 AI 处理器的端到端异构计算架构, 由 5 层软件组成 (应用 / GE / ATB / Runtime / Driver), 解决 3 大问题 (框架不认识 NPU / 算子能力未公开 / 计算图跑不快). 多数 AI 开发者只需关心层 1-2 (PyTorch + torch_npu), 算子开发者关心层 3 (AscendC), 性能调优者关心层 2+4 (GE + Runtime).

三个关键事实

CANN 是中间层, 不是单一工具: 包含 Toolkit / Ops / NNAL 3 大交付物, 加驱动 + 运行时 + 算子库 + 图编译 + 加速库
5 层架构 + 3 类用户: 应用开发者用层 1-2 / 算子开发者用层 3 / 调优者用层 2+4; 知道你在哪一层, 决定你该学什么
与 CUDA 90% 概念对应 + 10% 增强: 多数概念都能映射, CANN 多一层 GE (图编译) 是内置的, 不需要 TensorRT 之类的外部图优化

一句话给新人: CANN 不是单个库, 是昇腾 NPU 的"完整软件栈": 装好 CANN 之后, PyTorch 一行 model.to("npu:0") 就能跑, 这就是 CANN 设计的目标, 让 GPU 开发者无缝迁过来.