引言 | 从功能实现到性能极致：AI工程化的核心议题

在人工智能应用开发的生命周期中，模型的功能性实现，即“能跑”，构成了基础的第一步。然而，在真实世界的业务场景中，例如实时推荐、自动驾驶或大规模科学计算，单纯的功能实现远不足以满足需求。延迟和吞吐量成为了衡量一个AI解决方案优劣的关键性能指标。为了实现更低的响应时间和更高的处理效率，必须对计算过程进行深度优化，这要求AI工程师具备深入理解并利用底层硬件计算架构的能力。

本次技术实践将焦点从基础的“卷积+激活”单元，转移到构成现代深度学习网络骨架的核心组件——残差模块（Residual Block）。这个模块因其在ResNet系列网络中的开创性应用而闻名，其结构包含了多个计算层，是检验底层优化能力的理想对象。

本分析将基于GitCode平台提供的昇腾910B环境，通过Jupyter Notebook进行一系列可复现的实验。实验的核心是对比华为MindSpore框架下的两种执行模式：PyNative（动态图） 与Graph（静态图）。通过这个对比，我们将一步步揭示并量化昇腾CANN（Compute Architecture for Neural Networks）如何通过模式切换，自动执行算子融合（Operator Fusion）等一系列图级别优化，为模型带来显著的性能提升。这不仅是一次性能评测，更是一次深入剖析AI框架与底层硬件协同工作机制的实践探索。

第一部分：实验环境的构建与验证

任何严谨的性能测试都始于一个稳定、透明且配置明确的实验环境。本节将详细描述环境的搭建过程，并对核心软硬件组件进行核验，为后续的性能基准测试和优化测试奠定坚实的基础。

步骤1.1：启动NPU Notebook环境

实验平台选用GitCode，它提供了一个集成了开发工具和高性能计算资源的云端环境，使开发者能够便捷地接入昇腾NPU硬件。

  1. 登录与导航：首先，登录至GitCode平台，在个人仪表盘中找到并进入我的Notebook管理界面。

  2. 资源选择与激活：在Notebook资源列表中，选择一个标记为NPU的可用资源，并执行激活操作。此步骤旨在为接下来的会话分配一个专用的NPU计算实例。

  3. 配置确认与启动：在启动界面，必须仔细确认资源配置。本次实验要求硬件为NPU，具体型号为Ascend 910B，并且选择预置了MindSpore 2.3的镜像。确认无误后，点击立即启动。

  4. 环境初始化：系统后台会开始准备Jupyter Notebook环境，这个过程通常需要短暂的等待。

    image.png

步骤1.2：创建Jupyter Notebook并进行环境核验

环境启动成功后，进入Jupyter界面。为了确保后续代码能够正确执行在预期的软硬件之上，需要进行命令行级别的核验。

  1. 打开终端：在Jupyter Lab界面中，启动一个新的终端会话。

    image.png

  2. 执行核验指令：在终端中，依次输入并执行以下两个命令。

    • 硬件状态检查：使用昇腾提供的系统管理工具npu-smi来查询NPU硬件的状态信息。 
      npu-smi info
    • AI框架版本检查：使用Python的包管理工具pip来确认MindSpore框架的版本。 
      pip list | grep mindspore

  3. 结果分析：执行上述命令后，终端将返回系统信息。

    image.png

    上图的输出提供了两个关键的确认信息：

    • npu-smi info的输出中，Chip Name字段明确显示为Ascend 910B。这证实了实验确实运行在目标NPU硬件之上。npu-smi工具类似于NVIDIA的nvidia-smi，它提供了对NPU芯片的健康状况、驱动版本、固件版本、内存使用率、功耗等关键信息的实时监控，是进行硬件调试和性能分析的基础工具。
    • pip list | grep mindspore的输出显示mindspore 2.3.0。这证实了环境中安装的AI框架版本与预期一致。框架版本对于保证API的可用性和底层优化的有效性至关重要。

    至此，一个配置正确、状态透明的实验环境已准备就绪。

第二部分：基准测试 - PyNative动态图模式下的性能表现

在评估任何优化措施的效果之前，必须首先建立一个可信的性能基准（Baseline）。为此，我们采用MindSpore框架的PyNative动态图模式进行测试。在该模式下，计算图中的每个算子（Operator）都会被独立地、按顺序地发送到昇腾NPU上执行。这种逐个下发的执行方式最接近Python的解释性执行逻辑，虽然灵活性高、易于调试，但它也暴露了未经图级别优化的“原始”性能。

步骤2.1：导入依赖库并设定执行模式

在Jupyter Notebook中创建一个新的代码单元（Cell），编写并执行以下代码，以导入必要的库并显式地将MindSpore的执行上下文设置为PyNative模式。

import mindspore as ms
from mindspore import nn, ops
import numpy as np
import time

# 显式设置执行模式为PyNative，该模式下不进行全局图编译优化
ms.set_context(mode=ms.PYNATIVE_MODE, device_target="Ascend")

# 打印当前模式以供核对
print(f"当前MindSpore执行模式: {ms.get_context('mode')}")

【代码解析】

  • import mindspore as ms: 导入MindSpore主库。
  • from mindspore import nn, ops: nn模块提供了构建神经网络所需的所有层（如卷积、全连接），ops模块则包含了基础的数学运算算子。
  • ms.set_context(...): 这是MindSpore中用于配置全局执行环境的关键函数。
    • mode=ms.PYNATIVE_MODE: 将执行模式设置为动态图。
    • device_target="Ascend": 指定计算任务在昇腾NPU上执行。
  • ms.get_context('mode'): 用于查询当前设置的执行模式，以确保配置生效。

【执行结果】

image.png

步骤2.2：定义测试目标 - 标准残差模块（Residual Block）

残差模块是本次性能测试的核心对象。其内部结构包含多个依次执行的计算层，如卷积（Conv2d）、批归一化（BatchNorm2d）和激活函数（ReLU），这种串行结构使其成为检验算子融合优化效果的理想载体。

# 定义一个标准的Residual Block，继承自mindspore.nn.Cell
class ResidualBlock(nn.Cell):
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResidualBlock, self).__init__()
        # 主分支
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, pad_mode='pad')
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU()
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, pad_mode='pad')
        self.bn2 = nn.BatchNorm2d(out_channels)

        # Shortcut分支，用于处理维度或通道数不匹配的情况
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.SequentialCell(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride),
                nn.BatchNorm2d(out_channels)
            )
        else:
            self.shortcut = nn.SequentialCell() # 空容器，相当于恒等映射

    def construct(self, x):
        # 计算捷径连接的输出
        identity = self.shortcut(x)
        
        # 计算主分支的输出
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        
        # 核心：将主分支输出与捷径连接输出相加
        out = out + identity
        
        # 最后的激活函数
        out = self.relu(out)
        return out

print("ResidualBlock 定义完成。")

【代码解析】

  • nn.Cell: MindSpore中所有网络层和模型的基类。定义模型需要继承它。
  • __init__: 构造函数，用于定义和初始化模型中包含的算子，如nn.Conv2d, nn.BatchNorm2d等。
  • construct: 定义了模型的前向传播逻辑。输入张量x会按照construct方法中定义的顺序流经各个算子。PyNative模式下，这里的每一行代码（如out = self.conv1(x)）都会触发一次独立的NPU计算任务。
  • shortcut分支：这是残差网络设计的精髓，解决了深度网络中的梯度消失问题。当输入和输出维度不一致时（通过stride或out_channels改变），需要通过一个1x1卷积来匹配维度，否则shortcut就是一个恒等映射。

【执行结果】

image.png

步骤2.3：定义性能评测函数

为了获得稳定且准确的性能数据，需要一个规范的评测函数。这个函数应包含预热（Warm-up）和正式计时两个阶段。

def run_benchmark(model, data, iterations=200):
    # 预热阶段：执行少量推理，不计入时间
    # 目的是为了完成JIT编译、显存分配、缓存预热等一次性开销
    for _ in range(20):
        _ = model(data)
    
    # 同步设备，确保预热操作全部完成
    ms.context.get_context().device_context.synchronize()
    
    # 正式计时阶段
    start_time = time.time()
    for _ in range(iterations):
        _ = model(data)
    
    # 再次同步，确保所有计时内的计算都已在NPU上完成
    ms.context.get_context().device_context.synchronize()
    end_time = time.time()
    
    # 计算单次推理的平均时间，并转换为毫秒
    avg_time_ms = (end_time - start_time) * 1000 / iterations
    return avg_time_ms

print("性能评测函数 run_benchmark 定义完成。")

【代码解析】

  • 预热（Warm-up）: 首次执行模型时，框架和硬件会进行一些初始化工作，如Just-In-Time (JIT)编译、内存分配、将权重加载到设备等。这些操作耗时较长但只发生一次。预热阶段就是为了将这些一次性开销排除在正式的性能计时之外。
  • 同步操作: CPU和NPU是异步执行的。CPU下发指令后会立即返回，而NPU可能仍在计算。synchronize()函数会阻塞CPU，直到NPU上所有已下发的任务都执行完毕。在计时开始前和结束后调用，可以确保我们测量的是纯粹的NPU计算时间。
  • 多次迭代与平均: 单次执行时间可能因系统抖动而产生偏差。通过执行大量（例如200次）迭代并取平均值，可以得到一个更稳定、更具代表性的性能数据。

【执行结果】

image.png

步骤2.4：执行基准测试

现在，所有准备工作完成，可以执行PyNative模式下的性能基准测试。

# 1. 实例化模型，指定输入3通道，输出64通道
net_pynative = ResidualBlock(3, 64)

# 2. 创建一个符合模型输入的随机张量
# 形状为(Batch, Channels, Height, Width)，符合NCHW格式
input_tensor = ms.Tensor(np.random.rand(1, 3, 224, 224), ms.float32)

# 3. 调用评测函数并打印结果
avg_time_before = run_benchmark(net_pynative, input_tensor)
print(f"【基准性能】PyNative模式下，单次推理平均耗时: {avg_time_before:.4f} ms")

【代码解析】

  • ResidualBlock(3, 64): 创建一个残差模块实例，它接受一个3通道的输入（如RGB图像），并输出一个64通道的特征图。
  • ms.Tensor(...): 创建一个MindSpore张量。输入数据是[1, 3, 224, 224]的float32类型随机数，模拟了单张224x224的RGB图像输入。

【执行结果】

image.png

从图9的输出可以看到，在PyNative模式下，该残差模块单次推理的平均耗时为 2.2227 ms。这个数值是我们的性能基准，后续Graph模式的性能将与之对比。

第三部分：性能飞跃 - Graph静态图模式与CANN的自动优化

进入实验的核心阶段。我们将利用MindSpore的Graph静态图模式。切换到此模式后，MindSpore不再是逐个算子下发，而是先将construct方法中的所有计算逻辑编译成一个完整的、静态的计算图。这个计算图随后被交给昇腾CANN进行深度优化，其中包括关键的算子融合，最终生成高效的设备执行代码。

步骤3.1：切换至Graph模式

此步骤是激活CANN编译优化的开关。操作非常简单，只需修改ms.set_context函数中的mode参数。

# 切换到Graph静态图模式。CANN将接管计算图并进行自动优化。
ms.set_context(mode=ms.GRAPH_MODE, device_target="Ascend")

print(f"当前MindSpore执行模式: {ms.get_context('mode')}")

【代码解析】

  • mode=ms.GRAPH_MODE: 这是整个优化的触发点。当模式被设置为GRAPH_MODE时，MindSpore的行为模式发生根本性改变。它会采用“先编译，后执行”的策略。

【执行结果】

image.png

步骤3.2：执行优化后的性能测试

在Graph模式下进行测试，有一个至关重要的操作：必须重新实例化模型。

# 关键步骤：必须重新实例化网络。
# 这是因为MindSpore的图编译是在模型首次执行时（JIT编译）触发的。
# 新的模型实例将在新的Graph模式上下文中进行编译。
net_graph = ResidualBlock(3, 64)

# 使用与之前完全相同的输入数据进行公平对比
avg_time_after = run_benchmark(net_graph, input_tensor)
print(f"【优化后性能】Graph模式下，单次推理平均耗时: {avg_time_after:.4f} ms")

【代码解析】

  • 为何必须重新实例化？ MindSpore的图编译是基于Just-In-Time (JIT) 技术的。当一个nn.Cell对象（如此处的net_graph）在Graph模式下首次被调用时，框架会追踪其construct方法的执行路径，将Python代码转换成一个中间表示（IR）的计算图。这个图随后被CANN优化和编译。之前的net_pynative对象是在PyNative模式下创建的，其内部状态已经适应了动态图的执行方式。因此，为了触发新的、基于Graph模式的编译流程，必须创建一个全新的模型实例net_graph。

【执行结果】

image.png

观察图11的输出，结果令人振奋。在Graph模式下，单次推理的平均耗时骤降至 0.5843 ms。与PyNative模式下的2.2227 ms相比，出现了数量级的差异。

步骤3.3：量化并展示优化成果

最后一步，通过代码精确计算性能提升的幅度和倍数，将优化效果进行直观的量化展示。

# 计算性能提升百分比和加速倍数
if avg_time_after > 0:
    speedup = avg_time_before / avg_time_after
    improvement_percent = (avg_time_before - avg_time_after) / avg_time_before * 100
    
    print("\n" + "="*20 + " 性能对比 " + "="*20)
    print(f"PyNative 模式 (优化前): {avg_time_before:.4f} ms")
    print(f"Graph 模式 (优化后):    {avg_time_after:.4f} ms")
    print("-" * 52)
    print(f"性能提升了: {improvement_percent:.2f}%")
    print(f"速度是原来的: {speedup:.2f} 倍！")
    print("=" * 52)
else:
    print("优化后耗时过短，无法计算。")

【执行结果】

image.png

根据实验数据，我们得到最终的量化结果：

  • 性能提升百分比: 73.71% (计算公式: (2.2227 - 0.5843) / 2.2227 * 100)
  • 速度提升倍数: 3.80 倍 (计算公式: 2.2227 / 0.5843)

【结果汇总】

为了更清晰地展示对比，将数据整理成表格：

image.png

注：原文标题中的280%应为速度提升了280%，即速度变为原来的3.8倍，3.8 = 1 + 2.8。这里的73.71%是时间节省的百分比，两者描述角度不同但本质一致。本文以实验数据为准，速度为原来的3.80倍。

第四部分：深度剖析与结论

本次实验通过严谨的步骤，清晰地展示了MindSpore执行模式从PyNative切换至Graph后，一个标准的残差模块在昇腾910B硬件上所获得的巨大性能增益。推理耗时从2.2227 ms降低到0.5843 ms，速度提升为原来的3.80倍。这一显著差异的背后，是昇腾CANN强大的图编译与优化能力在发挥决定性作用。

核心技术剖析：算子融合（Operator Fusion）

Graph模式性能飞跃的最主要原因在于算子融合。

  • 在PyNative模式下：ResidualBlock的construct方法中的计算流程是分步执行的。例如 out = self.conv1(x)，out = self.bn1(out)，out = self.relu(out) 这三行代码，会依次触发三个独立的内核（Kernel）在NPU上执行。每次内核启动都伴随着上下文切换、参数传递等系统开销（Kernel Launch Overhead）。更重要的是，每个算子的输出（中间结果）都需要从NPU的高速计算单元写回到内存（HBM），再由下一个算子从内存中读取。这种频繁的内存读写（Memory I/O）是主要的性能瓶颈，因为内存访问速度远低于计算单元的处理速度。

  • 在Graph模式下：CANN编译器接收到完整的计算图后，会进行模式匹配，识别出图中可以被融合的连续算子序列。Conv -> BatchNorm -> ReLU是深度学习中最常见、最经典的融合模式之一。CANN会将这三个独立的算子编译成一个单一的、高度优化的融合算子（例如，一个名为ConvBNReLU的内核）。

    算子融合带来的优势是多方面的：

    1. 减少内核启动开销：原来需要启动3次或更多次内核，现在只需启动1次，极大地降低了系统层面的开销。
    2. 减少内存读写：融合后的算子在内部执行时，Conv的输出可以直接被BatchNorm使用，BatchNorm的输出可以直接被ReLU使用，这些中间结果可以一直保留在NPU片上的高速缓存（On-chip Buffer/Cache）中，无需写回全局内存再读出。这大大减少了对慢速内存的访问次数，是性能提升的最关键因素。
    3. 提升计算效率：融合后的大算子为编译器提供了更大的优化空间，可以进行更有效的指令调度和资源利用，进一步提升了计算本身的效率。

在我们的ResidualBlock中，主分支的conv1 -> bn1 -> relu和conv2 -> bn2 -> element-wise-add -> relu等多个部分都是算子融合的潜在目标。CANN能够自动分析这些数据依赖关系，并进行最大程度的融合，从而实现最终观察到的性能飞跃。

结论

本次评测实验有力地证明了昇腾CANN不仅仅是连接上层框架和底层硬件的驱动程序，它更是一个智能的性能优化引擎。通过提供Graph静态图编译能力，CANN将复杂的底层硬件优化对开发者进行了透明化处理。开发者无需手动编写复杂的融合算子代码，也无需深入了解Da Vinci架构的细节，仅通过MindSpore中一个简单的API模式切换，就能够自动触发一系列深度优化，轻松释放昇腾910B硬件的强大计算潜力。

这种硬件与软件栈的深度协同设计，体现了昇腾AI生态的核心价值：它极大地降低了AI应用性能优化的门槛，使算法工程师和开发者可以将宝贵的精力更多地投入到模型架构的设计和算法的创新本身，而不是耗费在繁琐的底层性能调优上。这正是昇腾平台赋能广大开发者的真正意义所在。

Logo
123

1331

更多推荐

基于 PyPTO 与 Agent，2周完成模型 QAT 算子开发与优化

QAT 算子的开发实践验证了 PyPTO 的简单易用：用高层张量 API 表达算法逻辑，用tile_shape和等参数完成性能调优。在此基础上，Agent 可以先围绕公式和张量关系快速完成功能实现，再根据 profiling 结果调整少量参数完成优化，2周便完成 QAT 算子的开发、调优和模型接入，实现了模型吞吐性能的显著提升。

avatar CANN开发者社区
cover

CANN本周快递，请查收！

avatar CANN开发者社区
cover

Agent-Friendly 范式探索 --- 基于CANNBot的高性能复杂算子生成

avatar CANN开发者社区