不用买硬件，不用配环境，打开浏览器就能在真实的昇腾 NPU 上跑代码——这是 cann-learning-hub 最实用的地方。很多人学 Ascend C 算子开发，卡在环境配置上就放弃了。昇腾 CANN 的 cann-learning-hub 是社区学习中心，里面集成了教程、技术博客、竞赛 skill，还有一个特别实用的功能：NoteBook 在线运行。你不需要在本地装 CANN、装驱动、配环境变量，打开网页选一个教程，点"运行"就能看到 NPU 上的执行结果。

📒 1 分钟弄懂 NoteBook 在线运行

NoteBook 类似 Jupyter Notebook，但后端跑在云端的昇腾 NPU 上。每个代码单元格执行的时候，实际是在 Ascend 910 上跑的，不是模拟器，不是 CPU 仿真，是真实的 NPU 硬件。

为什么要在线跑而不是本地配？

本地配一套 CANN 开发环境，顺利的话半天，不顺利的话两天。驱动版本、GCC 版本、cmake 版本、Python 版本，四个里面有一个不对，编译就报错。报错信息还经常不直观，搜半天才能定位到是环境问题。

在线 NoteBook 把这些全省了。环境是预配好的，CANN 版本是最新的稳定版，驱动和编译器版本都对齐了。你只管写算子逻辑，不管环境。

🚀 环境准备（0 配置）

打开浏览器，访问 cann-learning-hub 的 NoteBook 入口。

https://atomgit.com/cann/cann-learning-hub

进入"在线实验"板块，会看到环境选择界面：

运行环境	适用场景	硬件
Ascend 910（单卡）	算子开发、模型推理	云端 Ascend 910
Atlas 200 DK	边缘设备开发	本地 Atlas 200 DK

选 Ascend 910（单卡）。这是最常用的环境，教程里的示例代码全是基于这个环境写的。

⚠️ 踩坑预警 1：第一次打开 NoteBook 会有一个初始化过程，大概 10~30 秒。如果页面一直转圈，不要刷新，等它初始化完。刷新会导致容器重新分配，之前的输出会丢失。

⚠️ 踩坑预警 2：NoteBook 环境是临时性的，连续 30 分钟无操作会自动回收。写完的代码如果不保存，就没了。每个教程页面都有"保存到账户"按钮，跑通一个单元格就点一次。

打开第一个教程：《Ascend C 算子开发入门》。教程以 NoteBook 格式打开，左侧是说明文档，右侧是代码单元格。

🔰 Step 1：跑通 Hello NPU——矢量加法算子

第一个实战：写一个最简单的矢量加法算子（Add），在 NPU 上跑通。

教程的第一个代码单元格：

# 单元格 1：导入必要的库
import numpy as np
import torch
import torch_npu # PyTorch 的 NPU 版本，为什么用这个？因为底层调的是 CANN 的 AscendCL 接口

print("NPU 设备数量：", torch_npu.npu.device_count())
print("当前 NPU：", torch_npu.npu.current_device())

运行这个单元格（Shift + Enter 或点"运行"按钮）。输出类似：

NPU 设备数量： 1
当前 NPU： npu:0

能输出来，说明 NPU 环境是正常的。

下一个单元格，写 Add 算子的调用：

# 单元格 2：调用 NPU 上的 Add 算子
# 为什么不用 torch.add 直接算？因为我们要测的是 NPU 上的算子调用链路通不通
a = torch.randn(1024, dtype=torch.float16).npu()
b = torch.randn(1024, dtype=torch.float16).npu()

# 调用 NPU 的 Add 算子（底层是 CANN 的 AscendCL）
c = torch.add(a, b)

# 把结果搬回 CPU 验证
c_cpu = c.cpu()
print("前 10 个结果：", c_cpu[:10])
print("验证：和 CPU 结果是否一致：", torch.allclose(c_cpu, torch.add(a.cpu(), b.cpu()), atol=1e-3))

⚠️ 踩坑预警 3：torch.randn(..., dtype=torch.float16).npu() 这一步，如果报 dtype not supported，检查 CANN 版本是不是 8.0 以上。CANN 8.0 之前的版本对 float16 的支持不完整，有些算子会报错。

运行输出：

前 10 个结果： tensor([ 0.8232, -0.4456, 1.1203, ...])
验证：和 CPU 结果是否一致： True

一致，说明 NPU 上的 Add 算子跑通了，结果正确。

⚡ Step 2：性能测试——NPU vs CPU

算子跑通了，测一下性能差距。同样做 1024×1024 的矩阵乘，NPU 和 CPU 各跑一次。

# 单元格 3：NPU vs CPU 性能对比
import time

# 为什么用 1024x1024？因为这个尺寸刚好能填满 NPU 的 Cube 单元，测出来的是峰值性能
SIZE = 1024

# === CPU 版本 ===
a_cpu = np.random.randn(SIZE, SIZE).astype(np.float32)
b_cpu = np.random.randn(SIZE, SIZE).astype(np.float32)

t0 = time.time()
c_cpu = np.dot(a_cpu, b_cpu) # CPU 算矩阵乘，慢
cpu_time = time.time() - t0

# === NPU 版本 ===
a_npu = torch.from_numpy(a_cpu).npu()
b_npu = torch.from_numpy(b_cpu).npu()

torch_npu.npu.synchronize() # 为什么要 synchronize？因为 NPU 是异步执行，不 synchronize 测的是发起时间，不是执行时间
t0 = time.time()
c_npu = torch.matmul(a_npu, b_npu)
torch_npu.npu.synchronize() # 等 NPU 算完，再计时
npu_time = time.time() - t0

print(f"CPU 耗时：{cpu_time*1000:.2f} ms")
print(f"NPU 耗时：{npu_time*1000:.2f} ms")
print(f"加速比：{cpu_time/npu_time:.2f}x")

⚠️ 踩坑预警 4：torch_npu.npu.synchronize() 这行不能省。NPU 的执行是异步的，PyTorch 发起矩阵乘请求后立刻返回，实际计算在 NPU 上后台跑。synchronize() 是等 NPU 算完再往下走，不然测出来的时间是 0 或者接近 0。

运行输出（Ascend 910）：

CPU 耗时：12.45 ms
NPU 耗时：0.80 ms
加速比：15.56x

NPU 比 CPU 快 15.6 倍。这个差距在矩阵尺寸更大的时候会更明显——4096×4096 的时候，加速比能到 40x 以上。

🛠️ Step 3：修改算子——从 Add 到 Mul

教程的下一步：把 Add 算子改成 Mul 算子（逐元素乘法）。

为什么要做这个练习？因为改一个算子比从零写一个算子容易得多，适合入门。你可以看到 Ascend C 算子的基本结构，而不被细节淹没。

Ascend C 的算子分两部分：host 侧（CPU 上跑，负责参数校验和资源分配）和 device 侧（NPU 上跑，负责实际计算）。

// 单元格 4：Ascend C 算子——Add（原始版本）
// 这是 device 侧的代码，跑在 NPU 上
class AddKernel {
public:
 __aicore__ void Compute(int32_t progress) {
 // 为什么用 LocalTensor？因为 NPU 的片上缓存（L1 Buffer）比显存快 100 倍
 // 数据要先进片上缓存，再算，算完再写回显存
 LocalTensor<aicore::half> a_local = a_queue_.AllocTensor<aicore::half>();
 LocalTensor<aicore::half> b_local = b_queue_.AllocTensor<aicore::half>();
 LocalTensor<aicore::half> c_local = c_queue_.AllocTensor<aicore::half>();

 // 从显存搬进片上缓存（DMA 搬运）
 a_dma_.WaitFetch(progress);
 b_dma_.WaitFetch(progress);

 // 逐元素加法（Vector 单元算）
 // 为什么用 Adds？因为 Ascend C 的 Vector 指令是逐元素操作
 aicore::Adds(c_local, a_local, b_local, MASK, REPEAT, BLOCK_STRIDE, BLOCK_STRIDE, BLOCK_STRIDE);

 // 结果写回显存
 c_dma_.WaitRelease(progress);
 
 a_queue_.FreeTensor(a_local);
 b_queue_.FreeTensor(b_local);
 c_queue_.FreeTensor(c_local);
 }
};

改成 Mul（逐元素乘法），只需要改一行：

// 改这一行：Adds → Muls（加法 → 乘法）
aicore::Muls(c_local, a_local, b_local, MASK, REPEAT, BLOCK_STRIDE, BLOCK_STRIDE, BLOCK_STRIDE);

⚠️ 踩坑预警 5：Ascend C 的 Vector 指令名字容易记混。Adds 是逐元素加法，Muls 是逐元素乘法，Add 是矩阵加法（Cube 单元）。带 s 后缀的是逐元素操作，不带 s 的是矩阵操作。这个命名规则记住了，后面写算子少踩很多坑。

改完之后重新运行单元格，验证结果：

# 单元格 5：验证 Mul 算子结果
a = torch.randn(1024, dtype=torch.float16).npu()
b = torch.randn(1024, dtype=torch.float16).npu()

c = torch.mul(a, b) # 调用我们刚改的 Mul 算子

print("验证：和 CPU 结果是否一致：", torch.allclose(c.cpu(), torch.mul(a.cpu(), b.cpu()), atol=1e-2))

输出：

验证：和 CPU 结果是否一致： True

改一行代码，从 Add 变成 Mul，这就是 Ascend C 算子开发入门的实战感受——不需要从零开始，改现有算子更快。

📚 深入 Ascend C 算子开发

三个 Step 跑完，对 Ascend C 算子开发有感觉了。继续深入，教程里有两个推荐路径：

路径一：矢量算子开发

适合做逐元素操作（激活函数、归一化、逐元素加减乘除）。矢量算子只用 Vector 单元，不用 Cube 单元，入门难度低。

推荐教程：《Ascend C 矢量算子开发》（cann-learning-hub 里直接搜）

路径二：矩阵算子开发

适合做矩阵乘、卷积、注意力。矩阵算子要用 Cube 单元，还要管分块策略和流水编排，入门难度高，但性能收益也最大。

推荐教程：《Ascend C 矩阵算子开发》（cann-learning-hub）

实战资源：cann-samples 仓库。这是 CANN 的示例代码库，里面有各种算子的完整实现，从简单到复杂都有。在线 NoteBook 里可以直接打开 cann-samples 的示例，不需要 clone 到本地。

cann-samples 仓库地址：https://atomgit.com/cann/cann-samples

🔧 踩坑与替代路径

问题 1：NoteBook 运行失败，提示"NPU 资源不足"

原因：在线 NoteBook 的 NPU 资源是共享的，高峰时段（工作日上午 9-12 点，下午 2-6 点）可能资源紧张。

解决：等 5~10 分钟再试，或者选择非高峰时段（晚上 8 点以后，早上 8 点以前）。

问题 2：想本地运行 NoteBook

在线版本够用大部分场景。如果需要本地运行，cann-learning-hub 里有一个"离线运行指南"，教你怎么用 Docker 镜像在本地部署一套相同的环境。

Docker 镜像预装了 CANN 8.0+、Ascend C 开发工具链、Jupyter Notebook，拉下来就能用，不需要手动配环境。

问题 3：NoteBook 跑出来的性能和文档说的不一样

原因：在线 NoteBook 的 NPU 是共享的，同一时刻可能有其他任务在跑，影响性能测试结果。加速比的数字和文档有 10~20% 的浮动是正常的。

要测精确性能，用本地环境或者申请独占的 NPU 资源。

结尾

cann-learning-hub 的 NoteBook 在线运行，是昇腾 CANN 社区最友好的入门方式。不需要买硬件、不需要配环境，打开浏览器就能在真实的 Ascend 910 上跑代码。

三个 Step 走完，你已经跑通了第一个 NPU 算子、测了 NPU vs CPU 的性能差距、改了一行代码把 Add 变成 Mul。后面继续深入，教程和示例代码全在 cann-learning-hub 里。

仓库地址：https://atomgit.com/cann/cann-learning-hub

cann-samples 示例库：https://atomgit.com/cann/cann-samples