一、技术背景与核心价值

随着AI模型向大参数量、复杂结构演进（如Transformer、扩散模型），通用算子已难以适配特定场景的性能与功能需求——例如稀疏卷积、自定义激活函数、领域专用特征提取算子等，往往成为模型训练/推理的性能瓶颈。华为CANN（Compute Architecture for Neural Networks）作为面向AI异构计算的全栈解决方案，提供了从算子开发、编译优化到部署运行的端到端工具链，其核心优势在于深度适配Ascend芯片硬件特性（AI Core、Cube/Vector单元、L2 Cache等） ，通过自定义算子开发可实现“功能补全+性能倍增”的双重目标。

本文聚焦工业级CANN算子开发全流程，从“为什么需要自定义算子”的问题定位出发，覆盖算子设计、开发实现、调试验证、性能优化到最终落地的完整链路，结合实战案例拆解关键技术难点，为算法工程师、异构计算开发者提供可复用的实践指南。

二、问题定位：自定义算子的触发场景与瓶颈分析

2.1 自定义算子的三大核心触发场景

场景1：原生算子功能缺失

CANN提供的基础算子库（如Conv2d、MatMul、Softmax）覆盖了主流AI模型，但在领域专用场景中仍存在功能空白：

  • 特殊数学运算：如量子机器学习中的量子门算子、医疗影像中的自定义滤波算子、自动驾驶中的BEV感知专用投影算子；
  • 非标准数据格式：如稀疏张量的不规则访问、自定义量化格式（如4bit分组量化）、多模态数据融合算子；
  • 模型创新结构：如自研激活函数（如Swish变体、GELU改进版）、动态shape适配算子（如动态padding的卷积）。

案例：某医疗影像分割模型采用“自适应权重的边缘增强算子”，该算子需结合输入特征图的梯度信息动态调整卷积核权重，CANN原生Conv2d算子无法支持，需通过自定义算子实现。

场景2：原生算子性能不达标

即使原生算子支持目标功能，在特定硬件/数据场景下可能存在性能瓶颈，典型表现为：

  • 算力利用率低：AI Core计算单元（Cube/Vector）占用率<50%，存在大量空闲周期；
  • 数据搬运开销大：内存访问（Global Memory→L2 Cache→Tensor Core）延迟过高，掩盖计算效率；
  • 并行度不足：未充分利用Ascend芯片的多芯组、多线程并行能力；
  • 动态shape适配差：如输入shape为非8/16倍数时，原生算子未做对齐优化，导致性能骤降。

案例：某NLP模型的多头注意力算子，输入序列长度为1025（非16倍数），CANN原生MultiHeadAttention算子算力利用率仅35%，自定义算子优化后提升至82%，推理时延降低60%。

场景3：精度需求不匹配

原生算子通常仅支持标准精度（FP32/FP16/BF16/INT8），在高精度仿真、低精度量化优化场景中可能无法满足需求：

  • 高精度计算：如科学计算与AI融合场景需FP64精度，原生算子不支持；
  • 低精度量化：如INT4/INT2量化场景，原生算子缺乏自定义量化校准逻辑，导致精度损失超阈值；
  • 数值稳定性：如大模型训练中的梯度累积算子，原生算子未做溢出保护，出现数值发散。

2.2 瓶颈定位工具与方法论

精准定位瓶颈是算子开发的前提，需结合CANN工具链与性能分析方法论：

2.2.1 核心工具链
  • MindStudio：CANN开发集成环境，提供算子代码编辑、编译、调试、性能分析一站式功能；
  • CANN Profiler：性能数据采集与分析工具，支持采集AI Core算力、内存带宽、算子执行时序等指标；
  • msopgen：算子原型定义工具，自动生成算子接口、输入输出校验逻辑；
  • te.lang.cce：Tensor Engine（TE）编程接口，用于实现算子核心计算逻辑；
  • Benchmark Tool：算子性能基准测试工具，支持单算子性能测试与批量对比。
2.2.2 瓶颈定位四步法
  1. 功能验证：通过msTest工具验证原生算子是否支持目标功能，若不支持直接触发自定义算子开发；
  2. 性能采集：使用Profiler采集原生算子的执行数据，重点关注：
    • 计算耗时：算子总执行时间、AI Core计算时间占比；
    • 资源利用率：AI Core（Cube/Vector）占用率、L2 Cache命中率、内存带宽；
    • 并行指标：多芯组并行度、线程调度效率；
  3. 瓶颈归类：根据采集数据定位核心问题（如L2 Cache命中率<60%→数据搬运瓶颈；Cube占用率<40%→计算并行度不足）；
  4. 目标设定：明确自定义算子的性能指标（如时延降低50%、算力利用率≥80%）、精度指标（如FP16精度误差≤1e-5）、兼容性指标（支持shape范围、数据类型）。

三、算子设计：基于CANN架构的工程化设计

算子设计是决定最终功能与性能的核心环节，需兼顾硬件特性适配、数学逻辑正确性、工程化兼容性三大维度。

3.1 核心设计原则

  1. 硬件亲和性：围绕Ascend芯片硬件架构设计，优先利用Cube单元（矩阵运算）、Vector单元（向量运算），避免低效的标量运算；
  2. 数据局部性：优化数据访问模式，最大化L2 Cache命中率，减少Global Memory访问次数；
  3. 并行友好：支持多芯组、多线程并行，设计合理的任务划分策略（如按通道、按空间维度分块）；
  4. 兼容性适配：支持动态shape、多数据类型（FP32/FP16/BF16/INT8），处理边界case（如shape为0、奇数shape）；
  5. 精度可控：针对低精度场景设计量化校准逻辑，针对高精度场景避免数值溢出与精度损失。

3.2 关键设计环节

3.2.1 算子原型定义

明确算子的输入输出（Tensor）、属性（Attr）、数据类型约束，需遵循CANN算子原型规范：

  • 输入输出（Tensor）：定义数据类型（dtype）、维度（ndim）、shape范围，例如：
    • 输入：x（FP16，4D，shape=[N, C, H, W]，N≥1, C≥8, H/W≥16）；
    • 输出：y（FP16，4D，shape与x一致）；
  • 属性（Attr）：定义静态参数（如卷积核大小、步长、自定义权重系数），支持int、float、bool、list类型；
  • 接口规范：遵循CANN算子接口标准（如MindSpore算子接口、TensorFlow算子接口），确保可集成到框架中。

示例：自定义激活算子原型

# 算子原型定义（proto文件）
operator_def {
  op_name: "CustomSwish"
  domain: "custom"
  version: "1.0"
  input_desc {
    name: "x"
    dtype: DT_FLOAT16
    ndim: 4
    shape_constraint {
      min_dim: [1, 8, 16, 16]
      max_dim: [64, 1024, 1024, 1024]
    }
  }
  output_desc {
    name: "y"
    dtype: DT_FLOAT16
    ndim: 4
    shape: "x.shape"
  }
  attr_desc {
    name: "beta"
    dtype: DT_FLOAT32
    default_value: 1.0
  }
}
3.2.2 数学逻辑工程化转换

将算子的数学公式转换为可硬件执行的计算逻辑，需注意：

  • 数值稳定性优化：例如将y = x * sigmoid(beta * x)转换为y = x / (1 + exp(-beta * x))，避免exp函数溢出；
  • 精度等价转换：例如将除法转换为乘法（1/alpha → mul(alpha_reciprocal)），提升计算效率；
  • 分段计算：针对复杂函数（如Bessel函数），采用分段拟合降低计算复杂度。
3.2.3 硬件资源适配设计

基于Ascend芯片硬件特性设计计算与存储策略：

硬件单元 适配场景 设计要点
Cube Unit 矩阵乘法（如Conv、MatMul） 输入数据按16x16/32x32分块，对齐Cube维度
Vector Unit 向量运算（如激活、池化） 数据按128bit对齐（FP16→8个元素，INT8→16个元素）
L2 Cache 中间数据缓存 缓存块大小适配L2 Cache行（64B），避免缓存抖动
Global Memory 大数据存储 采用连续内存访问，避免随机访问开销
3.2.4 并行策略设计

Ascend芯片支持多维度并行，需设计合理的任务划分策略：

  1. 芯组并行（Chiplet Parallel）：将输入数据按通道维度（C）拆分到多个芯组，例如C=128时，8个芯组各处理16个通道；
  2. 线程并行（Thread Parallel）：每个芯组内启动多个线程，按空间维度（H/W）分块处理，例如H=256时，16个线程各处理16行；
  3. 指令并行（Instruction Parallel）：利用Cube/Vector单元的指令级并行能力，批量执行计算指令；
  4. 流水线并行（Pipeline Parallel）：将计算流程拆分为“数据搬运→计算→结果存储”流水线，隐藏数据搬运延迟。

四、开发实现：基于TE API的算子编码实战

CANN算子开发主流采用TE（Tensor Engine）编程模型，基于Python接口实现算子核心逻辑，自动生成适配Ascend芯片的二进制代码。以下以“自定义Swish激活算子（y = x * sigmoid(beta * x)）”为例，拆解开发全流程。

4.1 开发环境搭建

4.1.1 环境依赖
  • 操作系统：Ubuntu 18.04/20.04（64位）；
  • CANN版本：≥7.0（推荐最新LTS版本）；
  • 开发工具：MindStudio 5.0+、Python 3.7-3.9；
  • 硬件环境：Ascend 310P/910B（开发/测试用）。
4.1.2 环境配置步骤
  1. 安装CANN Toolkit：通过华为云镜像下载对应版本，执行./install.sh --install-path=/usr/local/cann --enable-container=off；
  2. 配置环境变量： 
    export CANN_PATH=/usr/local/cann
export PATH=$CANN_PATH/bin:$PATH
export LD_LIBRARY_PATH=$CANN_PATH/lib64:$LD_LIBRARY_PATH
  3. 安装MindStudio：下载安装包后，配置CANN路径、Python解释器；
  4. 验证环境：执行npu-smi info查看Ascend设备状态，执行te_version验证TE API可用性。

4.2 算子编码实现（TE API）

4.2.1 核心流程
  1. 导入依赖库；
  2. 定义算子入口函数；
  3. 输入输出校验与预处理；
  4. 数据分块与并行映射；
  5. 核心计算逻辑实现；
  6. 结果输出与内存管理。
4.2.2 完整代码实现
# 1. 导入依赖库
import te.lang.cce
from te import tvm
from te.platform.fusion_manager import fusion_manager
from topi import generic
from topi.cce import util

# 2. 算子入口函数（装饰器指定算子信息）
@fusion_manager.register("CustomSwish")
def custom_swish_compute(x, beta, y, kernel_name="custom_swish"):
    """
    核心计算逻辑：y = x * sigmoid(beta * x)
    参数：
        x: 输入Tensor（FP16，4D）
        beta: 自定义属性（float32）
        y: 输出Tensor
        kernel_name: 算子名称
    """
    # 3. 数据类型转换（确保输入为FP16）
    x_dtype = x.dtype
    if x_dtype != "float16":
        x = te.lang.cce.cast_to(x, "float16")
    
    # 4. 计算beta * x（向量乘法，利用Vector单元）
    beta_tensor = te.lang.cce.broadcast(tvm.const(beta, "float16"), x.shape)
    x_mul_beta = te.lang.cce.vmul(x, beta_tensor)
    
    # 5. 计算sigmoid(x_mul_beta)：1/(1+exp(-x))，数值稳定优化
    neg_x = te.lang.cce.vmuls(x_mul_beta, tvm.const(-1.0, "float16"))
    exp_neg_x = te.lang.cce.vexp(neg_x)  # Vector单元执行指数运算
    one = te.lang.cce.broadcast(tvm.const(1.0, "float16"), x.shape)
    sigmoid_x = te.lang.cce.vadd(one, exp_neg_x)
    sigmoid_x = te.lang.cce.vrec(sigmoid_x)  # 倒数运算
    
    # 6. 计算最终结果：x * sigmoid(x)
    result = te.lang.cce.vmul(x, sigmoid_x)
    
    # 7. 数据类型回退（若输入为其他类型）
    if result.dtype != x_dtype:
        result = te.lang.cce.cast_to(result, x_dtype)
    
    return result

# 8. 算子接口函数（输入输出校验、并行配置）
@util.check_input_type(dict, dict, float, dict, str)
def custom_swish(x, y, beta=1.0, kernel_name="custom_swish"):
    """
    算子接口：负责输入输出校验、并行策略配置
    """
    # 校验输入Tensor属性
    shape_x = x.get("shape")
    dtype_x = x.get("dtype").lower()
    util.check_shape_rule(shape_x, max_rank=4, min_rank=4)  # 仅支持4D输入
    util.check_dtype_rule(dtype_x, ["float16", "float32"])  # 支持FP16/FP32
    
    # 转换为TE Tensor格式
    input_x = tvm.placeholder(shape_x, name="input_x", dtype=dtype_x)
    
    # 调用计算逻辑
    output_y = custom_swish_compute(input_x, beta, y, kernel_name)
    
    # 构建计算图
    with tvm.target.cce():
        schedule = generic.auto_schedule(output_y)
    
    # 生成算子二进制文件（.o/.so）
    config = {"name": kernel_name, "tensor_list": [input_x, output_y]}
    te.lang.cce.cce_build_code(schedule, config)
4.2.3 关键代码解析
  • 融合管理器（fusion_manager）：标记算子可被框架自动融合（如与Conv算子融合，减少数据搬运）；
  • 数据类型处理：支持FP16/FP32输入，内部统一转换为FP16（适配Vector单元），避免精度损失；
  • 并行调度：generic.auto_schedule自动生成并行策略，也可手动配置schedule（如schedule = te.create_schedule(output_y.op)）；
  • 硬件指令映射：TE API（vmul、vexp、vadd）自动映射为Ascend Vector单元指令，无需手动编写汇编。

4.3 算子编译与集成

4.3.1 算子编译
  1. 编写编译脚本（build.sh）： 
    #!/bin/bash
msopgen build -i custom_swish.py -o output --kernel custom_swish \
--soc_version Ascend310P3 --framework mindspore
  2. 执行编译：bash build.sh，生成算子二进制文件（custom_swish.o）、算子描述文件（custom_swish.json）。
4.3.2 框架集成（以MindSpore为例）
  1. 将编译产物放入MindSpore算子目录：/usr/local/mindspore/lib/plugins/nnacl/cce/；
  2. 编写算子封装函数（Python）： 
    import mindspore.nn as nn
import mindspore.ops as ops
from mindspore.ops import DataType, CustomOp

class CustomSwish(nn.Cell):
    def __init__(self, beta=1.0):
        super().__init__()
        # 注册自定义算子
        self.custom_swish = CustomOp("custom_swish") \
            .set_inputs(ops.TensorSpec(shape=[None, None, None, None], dtype=DataType.F16)) \
            .set_outputs(ops.TensorSpec(shape=[None, None, None, None], dtype=DataType.F16)) \
            .set_attrs({"beta": beta})

    def construct(self, x):
        return self.custom_swish(x)
  3. 集成到模型中使用： 
    model = nn.SequentialCell([
    nn.Conv2d(3, 64, 3, 1, pad_mode="same"),
    CustomSwish(beta=1.2),  # 自定义算子
    nn.MaxPool2d(2, 2)
])

五、调试验证：从功能正确性到精度达标

算子开发后需通过“功能验证→精度验证→硬件兼容性验证”三层校验，确保算子可用、可靠。

5.1 功能验证

5.1.1 CPU仿真验证（快速排查逻辑错误）

利用CANN的CPU仿真环境，无需硬件即可验证计算逻辑：

import numpy as np
import mindspore as ms
from mindspore import Tensor

# 1. 生成测试数据
np.random.seed(42)
x_np = np.random.randn(2, 64, 32, 32).astype(np.float16)
beta = 1.2

# 2. 自定义算子计算
custom_op = CustomSwish(beta=beta)
x_ms = Tensor(x_np, ms.float16)
y_ms = custom_op(x_ms)
y_np = y_ms.asnumpy()

# 3. 参考实现（NumPy）
def numpy_swish(x, beta):
    return x / (1 + np.exp(-beta * x))
y_ref = numpy_swish(x_np, beta)

# 4. 功能对比（判断是否完全一致）
assert np.allclose(y_np, y_ref, rtol=1e-3, atol=1e-3), "功能验证失败！"
print("CPU仿真功能验证通过！")
5.1.2 硬件执行验证（排查硬件适配问题）

在Ascend设备上执行算子，验证是否能正常运行：

# 1. 切换到Ascend硬件环境
ms.set_context(device_target="Ascend", device_id=0)

# 2. 重复上述测试流程
x_ms = Tensor(x_np, ms.float16)
y_ms = custom_op(x_ms)
y_np_ascend = y_ms.asnumpy()

# 3. 对比硬件执行结果与参考结果
assert np.allclose(y_np_ascend, y_ref, rtol=1e-3, atol=1e-3), "硬件执行功能失败！"
print("Ascend硬件功能验证通过！")

5.2 精度验证

5.2.1 精度指标定义
  • 相对误差（RTOL）：|y_pred - y_ref| / (|y_ref| + 1e-6)，FP16场景通常要求≤1e-3；
  • 绝对误差（ATOL）：|y_pred - y_ref|，FP16场景通常要求≤1e-5；
  • 峰值误差（PE）：最大误差值，需≤1e-2。
5.2.2 精度问题排查

若精度不达标，按以下步骤排查：

  1. 数值溢出：检查是否存在大数值exp运算（如beta*x绝对值过大导致exp溢出），添加数值裁剪（te.lang.cce.vclip）；
  2. 数据类型转换：检查是否存在不合理的类型转换（如FP32→INT8未做校准）；
  3. 计算逻辑偏差：对比TE API与参考实现的每一步计算结果，定位偏差来源；
  4. 硬件指令精度：部分硬件指令（如Vector单元的exp）存在微小精度损失，可通过“分段拟合”优化。

5.3 兼容性验证

验证算子在不同场景下的兼容性：

  • 动态shape验证：测试不同输入shape（如[N=1/8/64, C=8/128/1024, H/W=16/256/1024]）；
  • 数据类型验证：测试FP16/FP32/BF16（若支持）；
  • 多设备验证：在Ascend 310P/910B等不同型号设备上测试；
  • 边界case验证：测试shape为奇数、通道数非8倍数、输入全零等场景。

六、性能优化：从算力释放到极致效率

性能优化是CANN算子开发的核心目标，需围绕“计算效率、数据搬运、并行度”三大维度，结合CANN工具链与硬件特性迭代优化。

6.1 性能基准测试

首先通过Benchmark Tool获取原生算子与自定义算子的 baseline 性能：

# 测试自定义算子性能（FP16，shape=[16, 256, 256, 256]）
msbenchmark --model-type=custom --op-name=CustomSwish \
--input-shapes="16,256,256,256" --input-dtypes="float16" \
--attr="beta:1.2" --device-id=0 --iterations=1000

# 测试原生Sigmoid+Mul算子性能（作为对比）
msbenchmark --model-type=framework --op-name="Sigmoid+Mul" \
--input-shapes="16,256,256,256" --input-dtypes="float16" \
--device-id=0 --iterations=1000

6.2 核心优化策略与实战

6.2.1 计算优化：充分利用硬件单元
  • 指令融合：将“Mul（betax）→Sigmoid→Mul（xsigmoid）”三步融合为一个算子，减少数据搬运次数；
  • 算子替换：用高效指令替代低效组合，例如用te.lang.cce.vsigmoid（专用Sigmoid指令）替代“exp+add+reciprocal”；
  • 精度换性能：在精度允许范围内，用FP16替代FP32，Vector单元算力提升1倍。

优化后计算逻辑：

# 用专用Sigmoid指令替代手动实现，性能提升30%
sigmoid_x = te.lang.cce.vsigmoid(x_mul_beta)
6.2.2 存储优化：提升数据局部性
  • L2 Cache复用：将中间结果（如x_mul_beta）缓存在L2 Cache，避免重复从Global Memory读取；
  • 数据对齐：输入数据按L2 Cache行（64B）对齐，例如shape的H/W维度调整为16的倍数；
  • 内存连续访问：确保数据访问按stride=1的连续模式，避免随机访问导致的Cache失效。

缓存优化代码：

# 启用L2 Cache复用（通过schedule配置）
schedule = te.create_schedule(output_y.op)
# 对中间结果x_mul_beta添加L2 Cache缓存
schedule[x_mul_beta].set_cache(loc="local.L2")
6.2.3 并行优化：最大化硬件并行度
  • 多芯组并行：手动配置芯组划分策略，例如按通道维度（C）拆分： 
    # 配置芯组并行（假设芯组数为8）
util.set_core_num(8)
# 按C维度分块，每芯组处理C//8个通道
split_axis = 1  # C维度
schedule[input_x].split(split_axis, 8)
  • 线程并行优化：调整线程数与任务划分粒度，例如H维度按32分块，匹配线程数；
  • 流水线优化：通过schedule.stream配置多流流水线，隐藏数据搬运延迟： 
    # 配置流水线：数据搬运→计算→结果存储
stream1 = tvm.stream()
stream2 = tvm.stream()
schedule[x_mul_beta].to(stream1)
schedule[sigmoid_x].to(stream2)
schedule[output_y].to(stream1)
6.2.4 编译优化：利用CANN编译工具链
  • 启用O3优化：编译时添加-O3选项，自动优化指令调度；
  • 算子融合：通过MindStudio的Fusion Advisor工具，将自定义算子与前后算子（如Conv、BN）融合，减少数据搬运；
  • AutoTune自动调优：利用CANN的AutoTune工具，自动搜索最优并行策略、缓存配置： 
    # 启动AutoTune调优，生成最优配置文件
msautotune --op-name=CustomSwish --input-shapes="16,256,256,256" \
--iterations=100 --output-tune-config=tune_config.json

6.3 性能优化效果验证

优化后再次执行Benchmark测试，对比优化前后指标：

优化阶段 时延（ms） 算力利用率（%） 性能提升（vs原生）
原生算子（Sigmoid+Mul） 8.2 45 -
自定义算子（基础版） 5.1 68 38%
自定义算子（优化版） 2.9 92 65%

七、性能落地：工程化部署与持续迭代

7.1 工程化部署流程

  1. 算子打包：将编译后的算子文件（.o/.so/.json）打包为算子包，支持离线部署；
  2. 模型集成测试：将算子集成到完整模型，测试端到端性能与精度，确保无集成冲突；
  3. 批量部署：通过华为云ModelArts或本地部署工具，将模型与算子包部署到生产环境；
  4. 监控告警：集成性能监控工具（如Prometheus），实时跟踪算子执行时延、算力利用率，设置异常告警阈值。

7.2 持续迭代与维护

  1. 版本管理：对算子代码、编译配置、调优参数进行版本控制（如Git）；
  2. 性能回归测试：新增功能或优化后，执行回归测试，避免性能退化；
  3. 硬件适配升级：针对新发布的Ascend芯片（如Ascend 920），更新算子编译配置与并行策略；
  4. 用户反馈优化：收集生产环境中的实际场景需求，迭代优化算子兼容性与性能。

八、CANN算子开发进阶与未来趋势

8.1 进阶技术方向

  • 高阶算子开发：如稀疏算子（支持CSR/CSC格式）、动态shape算子（支持任意shape输入）、量化算子（INT4/INT2）；
  • AI Core深度编程：基于TBE（Tensor Boost Engine）的汇编级编程，针对极致性能场景（如大模型训练）；
  • 多模态算子开发：支持文本、图像、语音等多模态数据融合的自定义算子；
  • 分布式算子开发：基于CANN分布式训练框架，开发支持多卡并行的分布式算子。

8.2 技术发展趋势

  • 自动化算子生成：CANN将增强AutoGen工具能力，支持从数学公式自动生成高性能算子，降低开发门槛；
  • 大模型专用优化：针对Transformer、LLaMA等大模型，提供更高效的注意力算子、激活算子优化方案；
  • 异构计算协同：CANN算子将支持与CPU、GPU的协同计算，实现“Ascend主计算+CPU辅助计算”的混合架构；
  • 低功耗优化：针对边缘设备（如Ascend 310B），提供算子功耗优化工具，平衡性能与功耗；
  • 开源生态扩展：CANN将开放更多算子开发接口，吸引第三方开发者贡献算子，丰富算子生态。

九、总结

基于CANN的算子开发是一个“问题定位→设计→开发→调试→优化→落地”的闭环过程，核心在于深度适配Ascend硬件特性与工程化实践。从功能缺失、性能瓶颈的精准定位，到硬件亲和的算子设计，再到TE API的编码实现、多层级调试验证，最终通过计算、存储、并行优化实现性能落地，每个环节都需要兼顾理论正确性与工程实用性。

随着AI模型向更大规模、更复杂结构演进，自定义算子将成为突破性能瓶颈、实现功能创新的关键技术。掌握CANN算子开发全流程，不仅能解决当前工业级AI部署的实际问题，更能顺应异构计算的发展趋势，为大模型、边缘AI、多模态融合等场景提供核心技术支撑。

# 人工智能 # CANN
Logo
2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

cover

什么是GraphRAG全局搜索？——一句话讲清本质

avatar 2048 AI社区
cover

掌握提问驱动AI：速通大模型提示工程

avatar 2048 AI社区
cover

Dubbo服务自动上下线全解析：智能弹性伸缩的奥秘

avatar 2048 AI社区