CANN OPS-Transformer：Ascend AI 处理器上的高性能 Transformer 算子库

CANN 组织链接 ： https://atomgit.com/cann
ops-transformer 仓库链接 ： https://atomgit.com/cann/ops-transformer

在深度学习领域，Transformer 架构凭借其强大的并行处理能力和卓越的特征捕获机制，彻底改变了自然语言处理（NLP）乃至计算机视觉（CV）等多个领域。从 BERT、GPT 系列到 ViT，Transformer 模型已成为构建大规模预训练模型的基石。然而，Transformer 模型通常拥有庞大的参数量和复杂的计算图，例如多头自注意力机制和前馈网络，这些都对底层硬件算力提出了极高的要求。为了在专用 AI 处理器上高效运行这些模型，一套高度优化、硬件感知的 Transformer 算子库变得不可或缺。

CANN ops-transformer 仓库，作为 CANN (Compute Architecture for Neural Networks) 软件栈的关键组成部分，正是华为 Ascend AI 处理器上高性能 Transformer 算子的集合。它提供了一系列经过深度优化，能够充分利用 Ascend AI 处理器计算特性和内存带宽的 Transformer 相关算子。

ops-transformer 的核心价值在于：

极致性能：通过与 Ascend AI 处理器底层硬件的深度融合，实现 Transformer 核心计算的硬件加速，提供卓越的推理和训练性能。
模型兼容性：为上层框架和应用提供标准化、高效率的 Transformer 算子实现，确保主流 Transformer 模型能够无缝迁移和高效运行。
易用性与标准化：封装底层硬件复杂性，为开发者提供统一且易于调用的 API 接口，加速 Transformer 应用的开发和部署。

本文将深入探讨 ops-transformer 的核心构成、其性能优化策略、如何与 CANN 生态其他组件协同工作，以及它在推动 Ascend AI 处理器上大规模 AI 模型发展中的关键作用。

一、 Transformer 模型的核心地位与计算挑战

Transformer 架构已成为现代 AI 模型的主流，但其计算特性也带来了显著挑战。

1.1 Transformer 模型的核心地位

自 2017 年 Google 提出 Transformer 以来，它凭借"注意力就是你所需要的一切"（Attention Is All You Need）的核心思想，迅速席卷了整个 AI 领域。

并行计算优势：完全摒弃了 RNN 固有的序列依赖，使得模型能够并行处理序列中的所有元素，极大提升了训练效率。
长距离依赖捕获：注意力机制允许模型直接建模输入序列中任意两个位置之间的依赖关系，有效解决了传统 RNN 在长序列上信息丢失的问题。
跨领域应用：从最初的 NLP 任务（机器翻译、文本生成），扩展到计算机视觉（Vision Transformer, ViT）、语音识别等多个领域，展现出强大的通用性。

1.2 Transformer 模型的计算挑战

尽管 Transformer 架构强大，但也伴随着巨大的计算复杂度：

多头自注意力机制：这是 Transformer 的核心，涉及到大量的矩阵乘法（点积注意力）、Softmax 操作以及多头并行计算，计算量巨大。
前馈网络 (FFN)：每个 Transformer 块都包含一个 FFN，通常由两个全连接层组成，也贡献了大量的矩阵乘法运算。
内存消耗：中间结果（如注意力权重）以及模型参数（特别是大规模模型）会占用大量内存，对设备的内存容量和带宽提出严峻考验。

1.3 OPS-Transformer 的核心价值与定位

ops-transformer 应运而生，旨在解决 Ascend AI 处理器上运行 Transformer 模型时遇到的性能瓶颈。

针对性优化：它专注于 Transformer 架构中的核心计算模式，提供比通用算子更优化的实现。
硬件亲和性：算子设计充分考虑 Ascend AI 处理器内部的张量计算单元、矢量计算单元的特点，最大化利用硬件资源。
加速大规模模型部署：为训练和推理千亿、万亿参数级别的 Transformer 模型提供坚实的高性能算子基础。

二、 OPS-Transformer 的核心算子解析：构建模型的基础模块

ops-transformer 库中包含了 Transformer 架构中各个关键部分的优化算子，它们是构建高效 Transformer 模型的基石。

2.1 注意力机制算子：多头自注意力 (Multi-Head Attention)

多头自注意力机制是 Transformer 的灵魂，ops-transformer 对其进行了高度优化。

QKV 矩阵乘：高效实现 Query (Q), Key (K), Value (V) 矩阵与输入张量的乘法，这是注意力计算的第一步。
Scaled Dot-Product Attention：优化了 Q 与 K 的点积、尺度缩放、Softmax 激活以及与 V 的乘法过程，确保这些计算在硬件上并行高效执行。
多头并行处理：将多个"头"的注意力计算进行并行调度，并最终将所有头的输出拼接并线性变换，充分利用处理器多核并行能力。

2.2 前馈网络与层归一化：提升模型表达力与稳定性

除了注意力，前馈网络和层归一化也是 Transformer 不可或缺的组成部分。

前馈网络 (Feed-Forward Networks)：优化了由两个线性变换和一个激活函数（如 GELU）组成的 FFN，主要涉及密集矩阵乘法和逐元素运算。
层归一化 (Layer Normalization)：高效实现对每个样本在所有特征维度上的归一化操作，有助于模型训练的稳定性和收敛速度。
残差连接 ：虽然残差连接本身是结构而非独立算子，但 ops-transformer 算子的实现会考虑与其前后算子的融合，以减少数据传输。

2.3 位置编码与其它辅助算子：支撑序列信息处理

为了让模型感知序列中元素的位置信息，并支持整体架构的构建，ops-transformer 还提供了辅助算子。

位置编码 (Positional Encoding)：高效生成并添加到输入 Embedding 中，无论是正弦余弦位置编码还是可学习的位置编码，都需要高效的加法运算。
Embedding 层：优化了大规模词表 Embedding 查找操作，这在 NLP 任务中是Transformer模型输入端的关键算子。
输出线性层与 Softmax：在模型输出端，优化了将 Transformer 编码器或解码器输出转换为最终预测（如词表概率）的线性层和 Softmax 操作。

三、性能优化揭秘：OPS-Transformer 如何挖掘硬件潜力

ops-transformer 的高性能并非偶然，它得益于与 Ascend AI 处理器底层硬件的深度融合和精巧的算法设计。

3.1 深度融合张量计算单元 (Tensor Cores)

Ascend AI 处理器内置的张量计算单元是加速 Transformer 模型的关键。

矩阵乘优化 ：Transformer 的核心运算是大量的矩阵乘法（例如 QK^T、AV、FFN 中的线性层），ops-transformer 算子能够将这些操作映射到张量计算单元，实现高吞吐量的低精度（如 FP16）矩阵乘累加。
数据类型适配：支持 FP16、INT8 等低精度数据类型进行计算，在保证精度的前提下，显著提升计算速度和降低内存带宽需求。
指令级优化：算子的实现直接面向处理器硬件指令集进行优化，消除不必要的内存访问和计算冗余。

3.2 内存访问优化与数据流管理

高效的内存管理对于处理 Transformer 模型的庞大中间数据至关重要。

数据排布优化：根据 Ascend AI 处理器内存访问模式（如 NHWC 或 NCHW），优化张量数据的存储排布，确保数据访问的连续性，提高缓存命中率。
片上缓存利用：最大化利用处理器的片上高速缓存（如 Shared Memory），减少对片外高带宽内存的访问，降低延迟。
内存复用策略：设计合理的内存复用机制，对中间结果进行原地更新，减少内存分配和释放的开销，降低整体内存占用。

3.3 算子融合与计算图优化

ops-transformer 不仅仅优化单个算子，更关注算子之间的协同效率。

水平融合：将多个独立的但输入/输出兼容的算子融合为一个复合算子，减少核函数启动次数和数据在全局内存中的传输。
垂直融合：将串行的计算操作（如 Layernorm + GELU + MatMul 的部分操作）融合成一个更大的复合算子，以消除中间结果的存储和加载开销。
与 Graph Engine 协同 ：ops-transformer 提供的算子与 CANN Graph Engine (https://atomgit.com/cann/ge) 紧密集成，在模型编译时，Graph Engine 可以对包含 ops-transformer 算子的计算图进行更全面的优化，例如调度优化、自动融合等。

四、易用性与开发集成：加速 Transformer 模型部署

ops-transformer 致力于提供标准化、易于集成的接口，加速开发者在 Ascend AI 处理器上构建和部署 Transformer 模型。

4.1 标准化 API 接口与灵活配置

ops-transformer 提供了统一且标准化的 C/C++ API 接口，方便开发者集成和使用。

函数命名规范 ：清晰、直观的函数命名，例如 MultiHeadAttention、TransformerEncoder，使开发者一目了然。
参数设计合理：每个算子函数通常通过结构体或枚举类型接收配置参数，提供了灵活的配置选项，如头数 (num_heads)、批次大小 (batch_size)、序列长度 (seq_len)、是否带掩码 (mask) 等。
统一数据结构 ：输入输出通常采用统一的 Tensor 或张量数据结构，便于数据在不同算子之间流转。

4.2 与 CANN 生态工具链的无缝衔接

ops-transformer 算子是 CANN 生态中的一等公民，与 Graph Engine 和模型转换工具无缝集成。

作为图算子 ：在 CANN Graph Engine 的计算图中，ops-transformer 算子可以直接作为图节点，与 AI 模型其他算子共同构成完整的计算图。
模型转换时优化 ：主流 AI 框架（如 PyTorch、TensorFlow）训练出的 Transformer 模型，在通过 CANN 模型转换工具转换为离线模型时，对应的 Transformer 计算模式可以自动映射到 ops-transformer 中的优化算子。
自定义算子参考 ：对于需要开发特定 Transformer 变体或自定义算子的开发者，ops-transformer 的实现可以作为高性能 TBE/Ascend C 算子开发的参考。

4.3 支持多种精度与混合精度训练/推理

ops-transformer 算子设计考虑了对不同数据精度的支持，以平衡性能与精度。

FP16/FP32 支持：提供 FP16 和 FP32 两种浮点精度的实现，允许开发者根据需求选择。FP16 通常在推理和训练中提供更高的吞吐量。
混合精度训练 ：结合 CANN 提供的混合精度训练能力，ops-transformer 算子能够自动或手动选择合适的精度进行计算，实现性能提升而精度损失可控。
INT8 推理 ：部分 ops-transformer 算子也支持 INT8 量化推理，进一步降低计算和内存开销，适用于对延迟要求极高的边缘设备部署。

五、 OPS-Transformer 在 CANN 生态中的协作与应用

ops-transformer 在 CANN 生态系统中扮演着加速大规模 AI 模型训练与推理的关键角色。

5.1 与 CANN Runtime 的协同：设备资源与任务调度

ops-transformer 算子的执行深度依赖于 CANN runtime (https://atomgit.com/cann/runtime) 提供的底层能力。

设备资源管理 ：runtime 负责 ops-transformer 算子在 Ascend AI 处理器上的设备上下文创建、内存分配和释放。
任务调度与执行 ：ops-transformer 算子通过 runtime 提供的流 (Stream) 机制提交到处理器上异步执行，实现与其他计算任务或数据传输的并行。
异步与同步 ：runtime 提供的事件 (Event) 和同步 (Synchronize) 机制确保 ops-transformer 算子在流水线中的正确执行顺序，同时最大化并行度。

5.2 与 Graph Engine 的互通：编译时优化与模型部署

ops-transformer 算子的价值在与 CANN Graph Engine (https://atomgit.com/cann/ge) 结合时得以最大化体现。

智能算子映射 ：当主流框架模型（如 TensorFlow、PyTorch）通过 CANN 转换工具导入时，Graph Engine 能够识别模型中的 Transformer 相关模式，并将其自动替换为 ops-transformer 中高度优化的算子实现。
全局图优化 ：Graph Engine 在编译计算图时，会将 ops-transformer 算子作为图中的节点，并进行更全面的全局优化，包括算子融合、调度优化、内存优化等，最终生成高效的 .om (Offline Model) 文件。
简化部署流程 ：开发者无需手动替换或优化 Transformer 算子，Graph Engine 会自动完成这些工作，大大简化了 Transformer 模型的部署流程。

5.3 Transformer 模型在 Ascend AI 处理器上的端到端加速

通过 ops-transformer 及其与 CANN 生态的无缝集成，Transformer 模型能够在 Ascend AI 处理器上实现端到端的性能加速。

训练加速 ：在分布式训练中，ops-transformer 的高效算子减少了每个训练步的计算时间，结合高性能集体通信库，显著提升了大规模模型的训练效率。
推理加速 ：在推理场景，特别是需要低延迟的实时应用中，ops-transformer 能够确保 Transformer 模型在毫秒级完成推理，满足严苛的性能指标。
资源高效利用：优化后的算子占用更少的计算资源和内存带宽，使得 Ascend AI 处理器能够处理更大规模的模型或更高吞吐量的请求。

六、未来演进与开放社区贡献：共筑 AI 算力新高地

ops-transformer 作为 CANN 生态中 Transformer 算子库的核心，其发展将持续聚焦于性能提升、功能扩展和社区协同。

6.1 持续支持最新 Transformer 变体与算法

Transformer 架构仍在快速演进，ops-transformer 将不断跟踪并支持最新的算法创新。

更灵活的注意力机制：支持如稀疏注意力、线性注意力、旋转位置编码（RoPE）等各种新兴的注意力变体，以适应更长序列和更高效的模型。
面向多模态任务：扩展对多模态 Transformer 模型的支持，例如在视觉和语言融合模型中的交叉注意力算子。
优化编译器后端 ：与 CANN Graph Engine 紧密配合，实现新的 Transformer 变体在编译时的自动优化和高效映射。

6.2 更高级别的优化与自动化调优

除了算子级别的优化，ops-transformer 也将探索更高层次的性能提升。

子图级优化：识别并优化整个 Transformer Block 或其子图，实现跨算子的全局性能优化。
动态 shape 优化：支持 Transformer 模型在推理时动态的序列长度输入，并能高效适应，减少填充（padding）带来的计算浪费。
自动化性能调优：集成自动化性能调优工具，根据不同模型、输入数据和硬件配置，自动选择最优的算子实现和融合策略。

6.3 开放生态与社区协同创新

ops-transformer 作为 CANN 开源生态的一部分，积极鼓励社区的参与和贡献。

贡献优化实现 ：欢迎开发者基于 TBE 或 Ascend C 贡献特定 Transformer 算子的优化实现，或提供新的 Transformer 架构支持。
反馈与改进 ：鼓励社区成员报告 bug、提出功能需求和改进建议，共同提升 ops-transformer 的质量和功能。
经验交流 ：通过社区论坛和活动，分享使用 ops-transformer 开发和部署大规模 Transformer 模型的经验和最佳实践。

cpp 复制代码

// 概念性 C++ 代码片段：使用 OPS-Transformer API 进行多头自注意力计算
// 这段代码旨在概念性地展示如何使用 CANN Runtime 和 OPS-Transformer 算子进行
// Transformer 架构中的核心 Multi-Head Attention 计算。
// 它不是一个完整的可执行程序，也并非"实战代码"，而是为了说明 API 调用逻辑。

#include <iostream>
#include <vector>
#include <string>
#include <cstdlib> // For rand()

// --- 概念性 CANN Runtime & OPS-Transformer 头文件 ---
// 实际 SDK 中，这些会是 acl/acl_rt.h, ops_transformer/ops_transformer.h 等。

// 概念性的返回状态码
typedef int AclError;
const AclError ACL_SUCCESS = 0;
const AclError ACL_ERROR_BAD_ALLOC = 1;
const AclError ACL_ERROR_INVALID_PARAM = 2;
// ... 更多错误码

// 概念性的句柄类型
typedef void* AclrtStream;   // 运行时流
typedef int   AclrtDeviceId; // 设备ID

// 概念性的 Tensor 结构 (通常在 CANN SDK 中会有定义，如 aclTensor)
// 这里简化为只包含设备数据指针和大小，实际会包含 shape, data_type, format 等
struct AclTensor {
    void*  deviceData;  // 指向设备内存中 Tensor 数据的指针
    size_t dataSize;    // Tensor 数据大小 (字节)
    std::vector<int64_t> shape; // 张量形状
    int    dataType;    // 数据类型 (例如 FP16, FP32)
    int    dataFormat;  // 数据格式 (例如 NCHW, NHWC)
};

// --- 概念性 CANN Runtime API 函数原型 (简化) ---
// 实际中，这些函数由 CANN SDK 提供。
AclError AclrtSetDevice(AclrtDeviceId deviceId) {
    std::cout << "[Runtime API] 设置设备 ID: " << deviceId << std::endl;
    return ACL_SUCCESS;
}
AclError AclrtCreateStream(AclrtStream* stream) {
    std::cout << "[Runtime API] 创建流" << std::endl;
    *stream = (AclrtStream)0xBEEF0000 + (rand() % 100);
    return ACL_SUCCESS;
}
AclError AclrtMalloc(void** devicePtr, size_t size, int memType) {
    std::cout << "[Runtime API] 在设备上分配 " << size << " 字节内存 (类型: " << memType << ")" << std::endl;
    *devicePtr = (void*)(0xDEADBEEF00000000ULL + rand() % 0xFFFFFFF);
    return ACL_SUCCESS;
}
AclError AclrtFree(void* devicePtr) {
    std::cout << "[Runtime API] 释放设备内存: " << devicePtr << std::endl;
    return ACL_SUCCESS;
}
AclError AclrtMemcpy(void* dst, size_t dstMax, const void* src, size_t count, int kind) {
    std::cout << "[Runtime API] 内存拷贝 (类型: " << kind << ", 大小: " << count << " 字节)" << std::endl;
    return ACL_SUCCESS;
}
AclError AclrtSynchronizeStream(AclrtStream stream) {
    std::cout << "[Runtime API] 同步流: " << stream << std::endl;
    return ACL_SUCCESS;
}

// --- 概念性 OPS-Transformer 算子 API 函数原型 ---
// 实际中，这些函数由 ops-transformer 库提供。

// 多头自注意力算子参数结构体 (简化)
struct MultiHeadAttentionParam {
    int numHeads;       // 注意力头数量
    float dropoutRate;  // Dropout 比率
    bool useCausalMask; // 是否使用因果掩码 (例如在 Decoder 中)
};

// 多头自注意力算子
// q: Query Tensor
// k: Key Tensor
// v: Value Tensor
// attentionMask: 注意力掩码 Tensor (可选)
// output: 输出 Tensor
// params: 算子参数
// stream: CANN runtime 流
AclError OpsTransformerMultiHeadAttention(const AclTensor* q,
                                        const AclTensor* k,
                                        const AclTensor* v,
                                        const AclTensor* attentionMask, // 可以是 nullptr
                                        AclTensor* output,
                                        const MultiHeadAttentionParam* params,
                                        AclrtStream stream) {
    if (!q || !k || !v || !output || !params || !stream) return ACL_ERROR_INVALID_PARAM;
    std::cout << "[OPS-Transformer] 执行 Multi-Head Attention 算子。" << std::endl;
    std::cout << "  Query Shape: [" << q->shape[0] << ", " << q->shape[1] << ", " << q->shape[2] << "]" << std::endl;
    std::cout << "  Num Heads: " << params->numHeads << ", Causal Mask: " << (params->useCausalMask ? "True" : "False") << std::endl;
    // 实际操作会调度硬件计算任务到流中
    return ACL_SUCCESS;
}


// --- 辅助宏用于错误检查 ---
#define CHECK_ACL_RET(ret, msg) \
    do { \
        if (ret != ACL_SUCCESS) { \
            std::cerr << "ACL Error (" << ret << "): " << msg << std::endl; \
            return -1; \
        } \
    } while(0)

int main() {
    std::cout << "--- CANN OPS-Transformer 概念性 API 使用流程 ---" << std::endl;

    AclError ret;
    AclrtDeviceId deviceId = 0;
    AclrtStream stream = nullptr;

    // 1. Runtime 初始化：设置设备、创建流
    ret = AclrtSetDevice(deviceId);
    CHECK_ACL_RET(ret, "设置设备失败");

    ret = AclrtCreateStream(&stream);
    CHECK_ACL_RET(ret, "创建流失败");

    // 2. 准备 Transformer 算子输入数据 (概念性)
    // 假设输入 Tensor shape 为 [batch_size, seq_len, hidden_size]
    // 假设 hidden_size = num_heads * head_dim
    int batchSize = 1;
    int seqLen = 128;
    int hiddenSize = 768; // 例如 BERT base 的 hidden size
    int numHeads = 12;
    int headDim = hiddenSize / numHeads;
    size_t tensorSize = (size_t)batchSize * seqLen * hiddenSize * sizeof(float); // 使用 FP32

    // 模拟分配设备内存 for Q, K, V 和 Output
    void* deviceQData = nullptr;
    void* deviceKData = nullptr;
    void* deviceVData = nullptr;
    void* deviceOutputData = nullptr;

    ret = AclrtMalloc(&deviceQData, tensorSize, 0); // 0: DEVICE
    CHECK_ACL_RET(ret, "分配设备 Query 内存失败");
    ret = AclrtMalloc(&deviceKData, tensorSize, 0); // 0: DEVICE
    CHECK_ACL_RET(ret, "分配设备 Key 内存失败");
    ret = AclrtMalloc(&deviceVData, tensorSize, 0); // 0: DEVICE
    CHECK_ACL_RET(ret, "分配设备 Value 内存失败");
    ret = AclrtMalloc(&deviceOutputData, tensorSize, 0); // Output shape 相同
    CHECK_ACL_RET(ret, "分配设备 Output 内存失败");

    // 3. 定义 AclTensor 结构体
    AclTensor queryTensor = {
        deviceQData, tensorSize, {(long)batchSize, (long)seqLen, (long)hiddenSize}, 0 /* FP32 */, 0 /* NCHW */
    };
    AclTensor keyTensor = {
        deviceKData, tensorSize, {(long)batchSize, (long)seqLen, (long)hiddenSize}, 0 /* FP32 */, 0 /* NCHW */
    };
    AclTensor valueTensor = {
        deviceVData, tensorSize, {(long)batchSize, (long)seqLen, (long)hiddenSize}, 0 /* FP32 */, 0 /* NCHW */
    };
    AclTensor outputTensor = {
        deviceOutputData, tensorSize, {(long)batchSize, (long)seqLen, (long)hiddenSize}, 0 /* FP32 */, 0 /* NCHW */
    };

    // 4. 定义 MultiHeadAttention 算子参数
    MultiHeadAttentionParam mhaParams = {
        numHeads,   // numHeads
        0.1f,       // dropoutRate
        false       // useCausalMask
    };

    // 5. 执行 Multi-Head Attention 算子
    // 注意力掩码 (attentionMask) 暂时设为 nullptr，表示不使用掩码
    ret = OpsTransformerMultiHeadAttention(&queryTensor, &keyTensor, &valueTensor,
                                           nullptr, // attentionMask
                                           &outputTensor, &mhaParams, stream);
    CHECK_ACL_RET(ret, "Multi-Head Attention 算子执行失败");

    // 6. 同步流，等待算子执行完成
    ret = AclrtSynchronizeStream(stream);
    CHECK_ACL_RET(ret, "同步流失败");

    std::cout << "概念性 OPS-Transformer Multi-Head Attention 流程完成。" << std::endl;

    // 7. 资源清理
    CHECK_ACL_RET(AclrtFree(deviceQData), "释放设备 Query 内存失败");
    CHECK_ACL_RET(AclrtFree(deviceKData), "释放设备 Key 内存失败");
    CHECK_ACL_RET(AclrtFree(deviceVData), "释放设备 Value 内存失败");
    CHECK_ACL_RET(AclrtFree(deviceOutputData), "释放设备 Output 内存失败");
    CHECK_ACL_RET(AclrtDestroyStream(stream), "销毁流失败");

    std::cout << "--- 所有资源已清理 ---" << std::endl;
    return 0;
}

这个 C++ 代码片段是一个概念性的 ops-transformer API 使用流程示意 。它并非可直接编译运行的"实战代码"，而是通过模拟 AclrtSetDevice、OpsTransformerMultiHeadAttention 等关键 API，展示了在 Ascend AI 处理器上进行多头自注意力计算的基本步骤：环境初始化、张量准备、算子调用与执行、以及最终的资源清理。这段代码旨在帮助读者理解 ops-transformer 如何作为底层的计算接口，为上层应用提供高性能且易于调用的 Transformer 算子。

总结来说，CANN ops-transformer 仓库是 Ascend AI 处理器上加速 Transformer 模型训练与推理的基石。它通过提供一系列深度优化、硬件感知的 Transformer 核心算子，显著提升了大规模语言模型和多模态模型在 Ascend AI 处理器上的性能。ops-transformer 与 CANN 生态中的 runtime 和 Graph Engine 紧密协同，为上层 AI 框架提供了强大的 Transformer 算力支撑。随着 AI 模型规模的持续增长和 Transformer 架构的不断演进，ops-transformer 将继续发挥其关键作用，赋能 AI 领域每一次重大突破，共同推动 AI 算力迈向新高地。