aclnnAvgPool2dBackward

aclnnAtanh/aclnnInplaceAtanh

接口原型

aclnnAtanh和aclnnInplaceAtanh实现相同的功能，其使用区别如下，请根据自身实际场景选择合适的算子。
- aclnnAtanh：需新建一个输出张量对象存储计算结果。
- aclnnInplaceAtanh：无需新建输出张量对象，直接在输入张量的内存中存储计算结果。
每个算子分为两段接口，必须先调用“aclnnXxxGetWorkspaceSize”接口获取入参并根据计算流程计算所需workspace大小，再调用“aclnnXxx”接口执行计算。
aclnnAtanh两段式接口如下：
- **第一段接口：**aclnnStatus aclnnAtanhGetWorkspaceSize(const aclTensor *self, const aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
- **第二段接口：**aclnnStatus aclnnAtanh(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)
aclnnInplaceAtanh两段式接口如下：
- **第一段接口：**aclnnStatus aclnnInplaceAtanhGetWorkspaceSize(aclTensor *selfRef, uint64_t *workspaceSize, aclOpExecutor **executor)
- **第二段接口：**aclnnStatus aclnnInplaceAtanh(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：对输入Tensor中的每个元素进行反双曲正切计算后并输出。
计算公式：

aclnnAtanhGetWorkspaceSize

接口定义：

aclnnStatus aclnnAtanhGetWorkspaceSize(const aclTensor *self, const aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，输入张量，数据类型支持FLOAT16、FLOAT、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL、COMPLEX64、COMPLEX128。当类型为INT8、INT16、UINT8、BOOL、INT32、INT64时，转化为FLOAT32进行运算，输出FLOAT32类型。支持非连续的Tensor，数据格式支持ND，维度不大于8，且shape需要与out一致。
- out：Device侧的aclTensor，输出张量，数据类型支持FLOAT16、FLOAT、DOUBLE、COMPLEX64、COMPLEX128，支持非连续的Tensor，数据格式支持ND，维度不大于8，且shape需要与self一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self和out的数据类型不在支持的范围之内。
  - self和out的shape不一致。
  - self或out的维数大于8。

aclnnAtanh

接口定义：

aclnnStatus aclnnAtanh(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnAtanhGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

aclnnInplaceAtanhGetWorkspaceSize

接口定义：

aclnnStatus aclnnInplaceAtanhGetWorkspaceSize(aclTensor *selfRef, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- selfRef：Device侧的aclTensor，输入/输出张量，数据类型支持FLOAT16、FLOAT、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL、COMPLEX64、COMPLEX128。支持非连续的Tensor，数据格式支持ND，维度不大于8。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的selfRef是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - selfRef的数据类型不在支持的范围之内。
  - selfRef的维数大于8。

aclnnInplaceAtanh

接口定义：

aclnnStatus aclnnInplaceAtanh(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnInplaceAtanhGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

调用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_atanh.h" #define CHECK_RET(cond, return_expr) \ do { \ if (!(cond)) { \ return_expr; \ } \ } while (0) #define LOG_PRINT(message, ...) \ do { \ printf(message, ##__VA_ARGS__); \ } while (0) int64_t GetShapeSize(const std::vector<int64_t>& shape) { int64_t shapeSize = 1; for (auto i : shape) { shapeSize *= i; } return shapeSize; } int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) { // 固定写法，AscendCL初始化 auto ret = aclInit(nullptr); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret); ret = aclrtSetDevice(deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateContext(context, deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret); ret = aclrtSetCurrentContext(*context); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret); return 0; } template <typename T> int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType, aclTensor** tensor) { auto size = GetShapeSize(shape) * sizeof(T); // 调用aclrtMalloc申请device侧内存 auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret); // 调用aclrtMemcpy将Host侧数据拷贝到device侧内存上 ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret); // 计算连续tensor的strides std::vector<int64_t> strides(shape.size(), 1); for (int64_t i = shape.size() - 2; i >= 0; i--) { strides[i] = shape[i + 1] * strides[i + 1]; } // 调用aclCreateTensor接口创建aclTensor *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(), *deviceAddr); return 0; } int main() { // 1. （固定写法）device/context/stream初始化，参考AscendCL对外接口列表 // 根据自己的实际device填写deviceId int32_t deviceId = 0; aclrtContext context; aclrtStream stream; auto ret = Init(deviceId, &context, &stream); // check根据自己的需要处理 CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret); // 2. 构造输入与输出，需要根据API的接口自定义构造 std::vector<int64_t> selfShape = {4, 2}; std::vector<int64_t> outShape = {4, 2}; void* selfDeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* self = nullptr; aclTensor* out = nullptr; std::vector<float> selfHostData = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7,0.8}; std::vector<float> outHostData = {0, 0, 0, 0, 0, 0, 0, 0}; // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建out aclTensor ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out); CHECK_RET(ret == ACL_SUCCESS, return ret); // 3. 调用CANN算子库API，需要修改为具体的API名称 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnAtanh第一段接口 ret = aclnnAtanhGetWorkspaceSize(self, out, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAtanhGetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; if (workspaceSize > 0) { ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret); } // 调用aclnnAtanh第二段接口 ret = aclnnAtanh(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAtanh failed. ERROR: %d\n", ret); return ret); uint64_t inplaceWorkspaceSize = 0; aclOpExecutor* inplaceExecutor; // 调用aclnnInplaceAtanh第一段接口 ret = aclnnInplaceAtanhGetWorkspaceSize(self, &inplaceWorkspaceSize, &inplaceExecutor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceAtanhGetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* inplaceWorkspaceAddr = nullptr; if (inplaceWorkspaceSize > 0) { ret = aclrtMalloc(&inplaceWorkspaceAddr, inplaceWorkspaceSize, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret); } // 调用aclnnInplaceAtanh第二段接口 ret = aclnnInplaceAtanh(inplaceWorkspaceAddr, inplaceWorkspaceSize, inplaceExecutor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnInplaceAtanh failed. ERROR: %d\n", ret); return ret); // 4. （固定写法）同步等待任务执行结束 ret = aclrtSynchronizeStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret); // 5. 获取输出的值，将device侧内存上的结果拷贝至Host侧，需要根据具体API的接口定义修改 auto size = GetShapeSize(outShape); std::vector<float> resultData(size, 0); ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr, size * sizeof(resultData[0]), ACL_MEMCPY_DEVICE_TO_HOST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret); for (int64_t i = 0; i < size; i++) { LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]); } // 6. 释放aclTensor，需要根据具体API的接口定义修改 aclDestroyTensor(self); aclDestroyTensor(out); return 0; }

父主题： NN类算子接口

aclnnAtan2/aclnnInplaceAtan2

接口原型

:::note 说明

aclnnAtan2和aclnnInplaceAtan2实现相同的功能，其使用区别如下，请根据自身实际场景选择合适的算子。
- aclnnAtan2：需新建一个输出张量对象存储计算结果。
- aclnnInplaceAtan2：无需新建输出张量对象，直接在输入张量的内存中存储计算结果。
每个算子分为两段接口，必须先调用“aclnnXxxGetWorkspaceSize”接口获取入参并根据计算流程计算所需workspace大小，再调用“aclnnXxx”接口执行计算。 :::
aclnnAtan2两段式接口如下：
- **第一段接口：**aclnnStatus aclnnAtan2GetWorkspaceSize(const aclTensor *self, const aclTensor *other, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
- **第二段接口：**aclnnStatus aclnnAtan2(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)
aclnnInplaceAtan2两段式接口如下：
- **第一段接口：**aclnnStatus aclnnInplaceAtan2GetWorkspaceSize(aclTensor *selfRef, const aclTensor *other, uint64_t *workspaceSize, aclOpExecutor **executor)
- **第二段接口：**aclnnStatus aclnnInplaceAtan2(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：对输入张量self和other逐元素进行反正切运算（self表示y坐标，other表示x坐标）。
计算公式：

aclnnAtan2GetWorkspaceSize

接口定义：

aclnnStatus aclnnAtan2GetWorkspaceSize(const aclTensor *self, const aclTensor *other, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，输入张量，数据类型支持INT8、INT16、INT32、 INT64、UINT8、BOOL、BFLOAT16（仅Atlas A2训练系列产品支持）、FLOAT、FLOAT16、DOUBLE，shape需要与other满足broadcast关系。支持非连续的Tensor，数据格式支持ND，维度不大于8。
- other：Device侧的aclTensor，输入张量，数据类型支持INT8、INT16、INT32、 INT64、UINT8、BOOL、BFLOAT16（仅Atlas A2训练系列产品支持）、FLOAT、FLOAT16、DOUBLE，shape需要与self满足broadcast关系。支持非连续的Tensor，数据格式支持ND，维度不大于8。
- out：Device侧的aclTensor，输出张量，数据类型支持FLOAT、FLOAT16、DOUBLE，shape是self与other broadcast之后的shape。支持非连续的Tensor，数据格式支持ND，维度不大于8。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、other或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self、other或out的数据类型或数据格式不在支持的范围之内
  - self和other的shape不能做broadcast。
  - self、other或out的维数大于8。
  - self、other broadcast之后得到的shape和out不一致。 :::

aclnnAtan2

接口定义：

aclnnStatus aclnnAtan2(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnAtan2GetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

aclnnInplaceAtan2GetWorkspaceSize

接口定义：

aclnnStatus aclnnInplaceAtan2GetWorkspaceSize(aclTensor *selfRef, const aclTensor *other, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- selfRef：Device侧的aclTensor，输入/输出张量，数据类型支持INT8、INT16、INT32、 INT64、UINT8、BOOL、BFLOAT16（仅Atlas A2训练系列产品支持）、FLOAT、FLOAT16、DOUBLE，shape需要与other满足broadcast关系。支持非连续的Tensor，数据格式支持ND，维度不大于8。
- other：Device侧的aclTensor，输入张量，数据类型支持INT8、INT16、INT32、 INT64、UINT8、BOOL、BFLOAT16（仅Atlas A2训练系列产品支持）、FLOAT、FLOAT16、DOUBLE，shape需要与selfRef满足broadcast关系。支持非连续的Tensor，数据格式支持ND，维度不大于8。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的selfRef、other是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - selfRef、other的数据类型和数据格式不在支持的范围之内。
  - selfRef、other的shape不能做broadcast。
  - selfRef、other的维数大于8。 :::

aclnnInplaceAtan2

接口定义：

aclnnStatus aclnnInplaceAtan2(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnInplaceAtan2GetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

调用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_Atan2.h" #define CHECK_RET(cond, return_expr) \ do { \ if (!(cond)) { \ return_expr; \ } \ } while (0) #define LOG_PRINT(message, ...) \ do { \ printf(message, ##__VA_ARGS__); \ } while (0) int64_t GetShapeSize(const std::vector<int64_t>& shape) { int64_t shapeSize = 1; for (auto i : shape) { shapeSize *= i; } return shapeSize; } int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) { // 固定写法，AscendCL初始化 auto ret = aclInit(nullptr); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret); ret = aclrtSetDevice(deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateContext(context, deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret); ret = aclrtSetCurrentContext(*context); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret); return 0; } template <typename T> int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType, aclTensor** tensor) { auto size = GetShapeSize(shape) * sizeof(T); // 调用aclrtMalloc申请device侧内存 auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret); // 调用aclrtMemcpy将host侧数据拷贝到device侧内存上 ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret); // 计算连续tensor的strides std::vector<int64_t> strides(shape.size(), 1); for (int64_t i = shape.size() - 2; i >= 0; i--) { strides[i] = shape[i + 1] * strides[i + 1]; } // 调用aclCreateTensor接口创建aclTensor *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(), *deviceAddr); return 0; } int main() { // 1. （固定写法）device/context/stream初始化，参考AscendCL对外接口列表 // 根据自己的实际device填写deviceId int32_t deviceId = 0; aclrtContext context; aclrtStream stream; auto ret = Init(deviceId, &context, &stream); // check根据自己的需要处理 CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret); // 2. 构造输入与输出，需要根据API的接口自定义构造 std::vector<int64_t> selfShape = {4, 2}; std::vector<int64_t> otherShape = {4, 2}; std::vector<int64_t> outShape = {4, 2}; void* selfDeviceAddr = nullptr; void* otherDeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* self = nullptr; aclTensor* other = nullptr; aclTensor* out = nullptr; std::vector<float> selfHostData = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7,0.8}; std::vector<float> otherHostData = {0.8,0.7,0.6,0.5,0.4,0.3, 0.2,0.1, }; std::vector<float> outHostData = {0, 0, 0, 0, 0, 0, 0, 0}; // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建other aclTensor ret = CreateAclTensor(otherHostData, otherShape, &otherDeviceAddr, aclDataType::ACL_FLOAT, &other); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建out aclTensor ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out); CHECK_RET(ret == ACL_SUCCESS, return ret); // 3. 调用CANN算子库API，需要修改为具体的API名称 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnAtan2第一段接口 ret = aclnnAtan2GetWorkspaceSize(self, other,out, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAtan2GetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; if (workspaceSize > 0) { ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret); } // 调用aclnnAtan2第二段接口 ret = aclnnAtan2(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAtan2 failed. ERROR: %d\n", ret); return ret); // 4. （固定写法）同步等待任务执行结束 ret = aclrtSynchronizeStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret); // 5. 获取输出的值，将device侧内存上的结果拷贝至host侧，需要根据具体API的接口定义修改 auto size = GetShapeSize(outShape); std::vector<float> resultData(size, 0); ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr, size * sizeof(resultData[0]), ACL_MEMCPY_DEVICE_TO_HOST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret); for (int64_t i = 0; i < size; i++) { LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]); } // 6. 释放aclTensor，需要根据具体API的接口定义修改 aclDestroyTensor(self); aclDestroyTensor(out); return 0; }

父主题： NN类算子接口

aclnnAvgPool2d

接口原型

每个算子有两段接口，必须先调用“aclnnXxxGetWorkspaceSize”接口获取入参并根据计算流程计算所需workspace大小，再调用“aclnnXxx”接口执行计算。两段式接口如下：

第一段接口：aclnnStatus aclnnAvgPool2dGetWorkspaceSize(const aclTensor *self, const aclIntArray *kernelSize, const aclIntArray *strides, const aclIntArray *paddings, const bool ceilMode, const bool countIncludePad, const uint64_t divisorOverride, const int8_t cubeMathType, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnAvgPool2d(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：对张量进行窗口为kH∗kW、步长为sH∗sW的2D平均池化操作。
计算公式：

输入张量self（N, C, H, W）、输出张量out（N, C, Hout, Wout）、池化步长（stride）、池化窗口大小（kH, kW），四者间的关系是

aclnnAvgPool2dGetWorkspaceSize

接口定义：

aclnnStatus aclnnAvgPool2dGetWorkspaceSize(const aclTensor *self, const aclIntArray *kernelSize, const aclIntArray *strides, const aclIntArray *paddings, const bool ceilMode, const bool countIncludePad, const uint64_t divisorOverride, const int8_t cubeMathType, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor。NPU上数据类型仅支持FLOAT16和FLOAT。支持非连续的Tensor。支持数据格式为NCHW和CHW。
- kernelSize：Host侧的aclIntArray，整型数组，长度为1（kH=kW）或2（kH, kW），表示池化窗口大小。数据类型支持INT32和INT64。
- strides：Host侧的aclIntArray，整型数组，长度为1（sH=sW）或2（sH, sW），表示池化操作的步长。数据类型支持INT32和INT64。
- paddings：Host侧的aclIntArray，整型数组，长度为1（padH=padW）或2（padH, padW），表示输入的H、W方向上padding补0的层数。数据类型支持INT32和INT64。
- ceilMode：Host侧的布尔值，表示推导的输出out的shape是否向上取整。
- countIncludePad：Host侧的布尔值，计算平均池化时是否包括padding填充的0。
- divisorOverride：数据类型支持UINT64，表示取平均的除数。
- cubeMathType：Host侧的整型，判断Cube单元应该使用哪种计算逻辑进行运算，支持INT8类型的枚举值，枚举值如下：
  - 0：KEPP_DTYPE，保持输入的数据类型进行计算。
  - 1：ALLOW_FP32_DOWN_PRECISION，允许转换输入数据类型降低精度计算。
- out：Device侧的aclTensor。数据类型、数据格式需要与self一致。
- workSpaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、kernelSize、strides、paddings或out中含有空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - 传入的self或out的数据类型或数据格式不在支持的范围内。
  - 传入的self和out数据类型或数据格式不一致。
  - 传入的self、kernelSize、strides或out有某维度的值小于0。 :::

aclnnAvgPool2d

接口定义：

aclnnStatus aclnnAvgPool2d(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnAvgPool2dGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

调用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_avgpool2d.h" #define CHECK_RET(cond, return_expr) \ do { \ if (!(cond)) { \ return_expr; \ } \ } while (0) #define LOG_PRINT(message, ...) \ do { \ printf(message, ##__VA_ARGS__); \ } while (0) int64_t GetShapeSize(const std::vector<int64_t>& shape) { int64_t shapeSize = 1; for (auto i : shape) { shapeSize *= i; } return shapeSize; } int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) { // 固定写法，AscendCL初始化 auto ret = aclInit(nullptr); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret); ret = aclrtSetDevice(deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateContext(context, deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret); ret = aclrtSetCurrentContext(*context); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret); return 0; } template <typename T> int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType, aclTensor** tensor) { auto size = GetShapeSize(shape) * sizeof(T); // 调用aclrtMalloc申请device侧内存 auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret); // 调用aclrtMemcpy将Host侧数据拷贝到device侧内存上 ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret); // 计算连续tensor的strides std::vector<int64_t> strides(shape.size(), 1); for (int64_t i = shape.size() - 2; i >= 0; i--) { strides[i] = shape[i + 1] * strides[i + 1]; } // 调用aclCreateTensor接口创建aclTensor *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_NCHW, shape.data(), shape.size(), *deviceAddr); return 0; } int main() { // 1. （固定写法）device/context/stream初始化，参考AscendCL对外接口列表 // 根据自己的实际device填写deviceId int32_t deviceId = 0; aclrtContext context; aclrtStream stream; auto ret = Init(deviceId, &context, &stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret); // 2. 构造输入与输出，需要根据API的接口自定义构造 uint64_t divisorOverride = 1; bool countIncludePad = true; bool ceilMode = false; int8_t cubeMathType = 1; std::vector<int64_t> selfShape = {1, 16, 4, 4}; std::vector<int64_t> outShape = {1, 16, 1, 1}; std::vector<int64_t> kernelDims = {4, 4}; std::vector<int64_t> strideDims = {1, 1}; std::vector<int64_t> paddingDims = {0, 0}; void* selfDeviceAddr = nullptr; void *outDeviceAddr = nullptr; aclTensor* self = nullptr; aclTensor* out = nullptr; std::vector<float> selfHostData(256, 2); std::vector<float> outHostData(16, 0); // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建out aclTensor ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out); CHECK_RET(ret == ACL_SUCCESS, return ret); aclIntArray *kernelSize = aclCreateIntArray(kernelDims.data(), 2); aclIntArray *strides = aclCreateIntArray(strideDims.data(), 2); aclIntArray *paddings = aclCreateIntArray(paddingDims.data(), 2); // 3. 调用CANN算子库API，需要修改为具体的API名称 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnAvgPool2d第一段接口 ret = aclnnAvgPool2dGetWorkspaceSize(self, kernelSize, strides, paddings, ceilMode, countIncludePad, divisorOverride, cubeMathType, out, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAvgPool2dGetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; if (workspaceSize > 0) { ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret); } // 调用aclnnAvgPool2d第二段接口 ret = aclnnAvgPool2d(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAvgPool2d failed. ERROR: %d\n", ret); return ret); // 4. （固定写法）同步等待任务执行结束 ret = aclrtSynchronizeStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret); // 5. 获取输出的值，将device侧内存上的结果拷贝至Host侧，需要根据具体API的接口定义修改 auto size = GetShapeSize(outShape); std::vector<float> resultData(size, 0); ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr, size * sizeof(resultData[0]), ACL_MEMCPY_DEVICE_TO_HOST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret); for (int64_t i = 0; i < size; i++) { LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]); } // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(self); aclDestroyTensor(out); aclDestroyIntArray(strides); aclDestroyIntArray(paddings); aclDestroyIntArray(kernelSize); return 0; }

父主题： NN类算子接口

aclnnAvgPool2dBackward

接口原型

**第一段接口：**aclnnStatus aclnnAvgPool2dBackwardGetWorkspaceSize(const aclTensor *gradOutput, const aclTensor *self, const aclIntArray *kernelSize, const aclIntArray *stride, const aclIntArray *padding, bool ceilMode, bool countIncludePad, int64_t divisorOverride, int8_t cubeMathType, aclTensor *gradInput , uint64_t &workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnAvgPool2dBackward(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：二维平均池化（aclnnAvgPool2d）的反向传播，计算二维平均池化正向传播的输入梯度。
计算公式：

假设二维平均池化正向的输入特征张量为X，输出特征张量为Y，池化窗口大小为k∗k，步长为s，则X的梯度∂L/∂X计算公式为

各参数含义如下：
- L为损失函数，⌊⋅⌋表示向下取整。
- Xi, j：输入特征图中第i行，第j列的像素值。
- Y⌊(i∗s+m)/k⌋, ⌊(j∗s+n)/k⌋：输出特征图中第⌊(i∗s+m)/k⌋行，第⌊(j∗s+n)/k⌋列的像素值。

aclnnAvgPool2dBackwardGetWorkspaceSize

接口定义：

aclnnStatus aclnnAvgPool2dBackwardGetWorkspaceSize(const aclTensor *gradOutput, const aclTensor *self, const aclIntArray *kernelSize, const aclIntArray *stride, const aclIntArray *padding, bool ceilMode, bool countIncludePad, int64_t divisorOverride, int8_t cubeMathType, aclTensor *gradInput , uint64_t &workspaceSize, aclOpExecutor **executor)
参数说明：
- gradOutput：Device侧的aclTensor，公式中的∂L/∂Y，数据类型支持FLOAT16和FLOAT。支持非连续的Tensor。数据格式支持NCHW和NCL。
- self：Device侧的aclTensor，平均池化正向过程中的输入张量X，数据类型支持FLOAT16和FLOAT。支持非连续的Tensor。数据格式支持NCHW和NCL。
- kernelSize：Host侧的aclIntArray，INT64的数组，长度为1（kH=kW）或2（kH, kW），表示池化窗口大小。数值必须大于0。
- stride：Host侧的aclIntArray，INT64的数组，长度为为1(sH=sW）或2（sH, sW），表示步长大小。数值必须大于0。
- padding：Host侧的aclIntArray，平均池化正向传播过程中对于输入的填充，数据类型为INT64，长度为1（padH=padW）或2（padH, padW），表示输入的H、W方向上padding补0的层数。支持padding小于0，padding的上限不能超过kernelSize对应位置的一半，比如kernelSize的H为2，padding的H最大只能为1。
- ceilMode：Host侧的布尔型，表示平均池化正向过程中推导输出shape是否向上取整。数据类型支持BOOL。
- countIncludePad：Host侧的布尔型，计算平均池化时是否包括padding填充。数据类型支持BOOL。
- divisorOverride：Host侧的整型，表示取平均的除数。数据类型支持INT64。支持范围为[-255, 255]。如果该值为0，表示不影响padding是否参与平均计算。
- cubeMathType：Host侧的整型，判断Cube单元应该使用哪种计算逻辑进行运算，支持INT8类型的枚举值，枚举值如下：
  - 0：KEPP_DTYPE，保持输入的数据类型进行计算。
  - 1：ALLOW_FP32_DOWN_PRECISION，允许转换输入数据类型降低精度计算。
- gradInput：Device侧的aclTensor，公式中的∂L/∂X。数据类型支持FLOAT16和FLOAT。支持非连续的Tensor。支持数据格式为NCHW和NCL。数据类型、数据格式需要与self一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的gradOutput、self、kernelSize、stride、padding或gradInput是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - 传入的gradOutput或gradInput的数据类型或数据格式不在支持的范围之内。
  - 传入的self和gradInput数据类型或数据格式不一致。
  - 传入的gradOutput、self、kernelSize、stride或gradInput维度不在支持的范围内。
  - 传入的gradOutput、self、kernelSize、stride或gradInput在某维度的值小于0。
  - 传入的cubeMathType取值不在支持范围内。
  - padding不能超过kernelSize对应位置的1/2，比如paddingH=2, kerneSizeH=2，paddingH>1/2*kerneSizeH。 :::

aclnnAvgPool2dBackward

接口定义：

aclnnStatus aclnnAvgPool2dBackward(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnAvgPool2dBackwardGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

调用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 cpp #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_avgpool2dbackward.h" #define CHECK_RET(cond, return_expr) \ do { \ if (!(cond)) { \ return_expr; \ } \ } while (0) #define LOG_PRINT(message, ...) \ do { \ printf(message, ##__VA_ARGS__); \ } while (0) int64_t GetShapeSize(const std::vector<int64_t>& shape) { int64_t shapeSize = 1; for (auto i : shape) { shapeSize *= i; } return shapeSize; } int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) { // 固定写法，AscendCL初始化 auto ret = aclInit(nullptr); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret); ret = aclrtSetDevice(deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateContext(context, deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret); ret = aclrtSetCurrentContext(*context); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret); return 0; } template <typename T> int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType, aclTensor** tensor) { auto size = GetShapeSize(shape) * sizeof(T); // 调用aclrtMalloc申请device侧内存 auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret); // 调用aclrtMemcpy将host侧数据拷贝到device侧内存上 ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret); // 计算连续tensor的strides std::vector<int64_t> stride(shape.size(), 1); for (int64_t i = shape.size() - 2; i >= 0; i--) { stride[i] = shape[i + 1] * stride[i + 1]; } // 调用aclCreateTensor接口创建aclTensor *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, stride.data(), 0, aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(), *deviceAddr); return 0; } int main() { // 1. （固定写法）device/context/stream初始化，参考AscendCL对外接口列表 // 根据自己的实际device填写deviceId int32_t deviceId = 0; aclrtContext context; aclrtStream stream; auto ret = Init(deviceId, &context, &stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret); // 2. 构造输入与输出，需要根据API的接口自定义构造 std::vector<int64_t> gradOutputShape = {1, 16, 1, 1}; std::vector<int64_t> selfShape = {1, 16, 4, 4}; std::vector<int64_t> kernelDims = {4, 4}; std::vector<int64_t> strideDims = {1, 1}; std::vector<int64_t> paddingDims = {0, 0}; bool ceilMode = false; int64_t divisorOverride = 0; bool countIncludePad = true; int8_t cubeMathType = 1; std::vector<int64_t> gradInputShape = {1, 16, 4, 4}; void* gradOutputDeviceAddr = nullptr; void* selfDeviceAddr = nullptr; void* gradInputDeviceAddr = nullptr; aclTensor* gradOutput = nullptr; aclTensor* self = nullptr; aclTensor* gradInput = nullptr; std::vector<float> gradOutputHostData(GetShapeSize(gradOutputShape) * 2, 1); std::vector<float> selfHostData(GetShapeSize(self) * 2, 1); std::vector<float> gradInputHostData(GetShapeSize(gradInputShape) * 2, 1); // gradOutput aclTensor ret = CreateAclTensor(gradOutputHostData, gradOutputShape, &gradOutputDeviceAddr, aclDataType::ACL_FLOAT, &gradOutput); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建 gradInput aclTensor ret = CreateAclTensor(gradInputputHostData, gradInputShape, &gradInputDeviceAddr, aclDataType::ACL_FLOAT, &gradInput); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建kernel aclIntArray aclIntArray *kernelSize = aclCreateIntArray(kernelDims.data(), 2); CHECK_RET(kernelSize != nullptr, return ACLNN_ERR_PARAM_NULLPTR); // 创建stride aclIntArray aclIntArray *stride = aclCreateIntArray(strideDims.data(), 2); CHECK_RET(stride != nullptr, return ACLNN_ERR_PARAM_NULLPTR); // 创建paddings aclIntArray aclIntArray *padding = aclCreateIntArray(paddingDims.data(), 2); CHECK_RET(padding != nullptr, return ACLNN_ERR_PARAM_NULLPTR); // 3. 调用CANN算子库API，需要修改为具体的API名称 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnAvgPool2dBackward第一段接口 ret = aclnnAvgPool2dBackwardGetWorkspaceSize(gradOutput,self,kernelSize,stride,padding,ceilMode, countIncludePad,divisorOverride,cubeMathType,gradInput,&workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAvgPool2dBackwardGetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; if (workspaceSize > 0) { ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret); } // 调用aclnnAvgPool2dBackward第二段接口 ret = aclnnAvgPool2dBackward(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAvgPool2dBackward failed. ERROR: %d\n", ret); return ret); // 4. （固定写法）同步等待任务执行结束 ret = aclrtSynchronizeStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret); // 5. 获取输出的值，将device侧内存上的结果拷贝至host侧，需要根据具体API的接口定义修改 auto size = GetShapeSize(gradInputShape); std::vector<float> outData(size, 0); ret = aclrtMemcpy(outData.data(), outData.size() * sizeof(outData[0]), gradInputDeviceAddr, size * sizeof(outData[0]), ACL_MEMCPY_DEVICE_TO_HOST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret); for (int64_t i = 0; i < size; i++) { LOG_PRINT("out result[%ld] is: %f\n", i, outData[i]); } // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(gradOutput); aclDestroyTensor(self); aclDestroyTensor(gradInput); aclDestroyIntArray(kernelSize); aclDestroyIntArray(stride); aclDestroyIntArray(padding); return 0; }

父主题： NN类算子接口

aclnnBaddbmm/aclnnInplaceBaddbmm

接口原型

:::note 说明

aclnnBaddbmm和aclnnInplaceBaddbmm实现相同的功能，其使用区别如下，请根据自身实际场景选择合适的算子。
- aclnnBaddbmm：需新建一个输出张量对象存储计算结果。
- aclnnInplaceBaddbmm：无需新建输出张量对象，直接在输入张量的内存中存储计算结果。
每个算子分为两段接口，必须先调用“aclnnXxxGetWorkspaceSize”接口获取入参并根据计算流程计算所需workspace大小，再调用“aclnnXxx”接口执行计算。 :::
aclnnBaddbmm两段式接口如下：
- **第一段接口：**aclnnStatus aclnnBaddbmmGetWorkSpaceSize(const aclTensor *self, const aclTensor *batch1, const aclTensor *batch2, const aclScalar *beta, const aclScalar *alpha, aclTensor *out, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor)
- **第二段接口：**aclnnStatus aclnnBaddbmm(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)
aclnnInplaceBaddbmm两段式接口如下：
- **第一段接口：**aclnnStatus aclnnInplaceBaddbmmGetWorkSpaceSize(const aclTensor *selfRef, const aclTensor *batch1, const aclTensor *batch2, const aclScalar *beta, const aclScalar *alpha, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor)
- 第二段接口：aclnnStatus aclnnInplaceBaddbmm(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：计算α与batch1、batch2矩阵乘结果的乘积，再与β和self的乘积求和。其中batch1、batch2必须是3维张量，两个shape不支持做broadcast，而self需支持和batch1@batch2的结果做broadcast。
计算公式：
示例：

假设self的shape是(A, M, K），batch1@batch2的shape是(1, M, 1)，那么输出out的shape为(A, M, K)。每一个维度的数字需要相等或其中一个为1。

注意，若此时batch1@batch2的shape是(2, M, 2)，那么算子会因不能完成broadcast出现报错。

aclnnBaddbmmGetWorkspaceSize

接口定义：

aclnnStatus aclnnBaddbmmGetWorkSpaceSize(const aclTensor *self, const aclTensor *batch1, const aclTensor *batch2, const aclScalar *beta, const aclScalar *alpha, aclTensor *out, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型与batch1@batch2的数据类型需满足数据类型推导规则，shape需要与batch1@batch2满足broadcast关系。数据格式支持ND，支持非连续Tensor，支持空Tensor。
  
  :::note 说明
  - 对于数据类型，只能batch1@batch2的dtype向self推导，不能反过来，因此若self为FLOAT16，batch1@batch2为FLOAT，会报错。
  - 对于shape，只能是self通过broadcast变成和batch1@batch2一样的shape，不可以是batch1@batch2的shape通过broadcast变成和self一样。例如self的shape是(1, 3, 5)， batch1@batch2的shape是(1, 1, 1)，执行会报错。 :::
- batch1：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型与batch2、self的数据类型需满足数据类型推导规则。shape需要与batch2满足bmm输入约束条件。数据格式支持ND，支持非连续Tensor，支持空Tensor。
- batch2：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型与batch1、self的数据类型需满足数据类型推导规则。shape需要与batch1满足bmm输入约束条件。数据格式支持ND，支持非连续Tensor，支持空Tensor。
- beta：Host侧的aclScalar，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL，且数据类型需要可转换成self与batch1@batch2推导后的数据类型。
- alpha：Host侧的aclScalar，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL，且数据类型需要可转换成self与batch1@batch2推导后的数据类型。
- out：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要与self保持一致，shape要求与batch1@batch2的shape保持一致。数据格式支持ND，支持非连续Tensor，支持空Tensor。
- cubeMathType：Host侧的整型，判断Cube单元应该使用哪种计算逻辑进行运算，支持INT8类型的枚举值，枚举值如下：
  - 0：KEPP_DTYPE，保持输入的数据类型进行计算。
  - 1：ALLOW_FP32_DOWN_PRECISION，允许转换输入数据类型降低精度计算。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、batch1或batch2是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self、batch1、batch2或out的数据类型或数据格式不在支持的范围内。
  - self、batch1、batch2或out的数据类型不一致。
  - self、batch1、batch2或out的数据格式不一致。
  - self不能与batch1@batch2做broadcast操作。 :::

aclnnBaddbmm

接口定义：

aclnnStatus aclnnBaddbmm(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnBaddbmmGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

aclnnInplaceBaddbmmGetWorkspaceSize

接口定义：

aclnnStatus aclnnInplaceBaddbmmGetWorkSpaceSize(const aclTensor *selfRef, const aclTensor *batch1, const aclTensor *batch2, const aclScalar *beta, const aclScalar *alpha, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- selfRef：Device侧的aclTensor，输入/输出张量，数据类型支持FLOAT16、FLOAT、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型与batch1@batch2的数据类型需满足数据类型推导规则，shape需要与batch1@batch2满足broadcast关系。数据格式支持ND，支持非连续Tensor，支持空Tensor。
  
  :::note 说明
  - 对于数据类型，只能batch1@batch2的dtype向selfRef推导，不能反过来，因此若selfRef为FLOAT16，batch1@batch2为FLOAT，会报错。
  - 对于shape，只能是selfRef通过broadcast变成和batch1@batch2一样的shape，不可以是batch1@batch2的shape通过broadcast变成和selfRef一样。例如selfRef的shape是(1, 3, 5)， batch1@batch2的shape是(1, 1, 1)，执行会报错。 :::
- batch1：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型与batch2、selfRef的数据类型需满足数据类型推导规则。shape需要与batch2满足bmm输入约束条件。数据格式支持ND，支持非连续Tensor，支持空Tensor。
- batch2：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型与batch1、selfRef的数据类型需满足数据类型推导规则。shape需要与batch1满足bmm输入约束条件。数据格式支持ND，支持非连续Tensor，支持空Tensor。
- beta：Host侧的aclScalar，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL，且数据类型需要可转换成selfRef与batch1@batch2推导后的数据类型。
- alpha：Host侧的aclScalar，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL，且数据类型需要可转换成selfRef与batch1@batch2推导后的数据类型。
- cubeMathType：Host侧的整型，判断Cube单元应该使用哪种计算逻辑进行运算，支持INT8类型的枚举值，枚举值如下：
  - 0：KEPP_DTYPE，保持输入的数据类型进行计算。
  - 1：ALLOW_FP32_DOWN_PRECISION，允许转换输入数据类型降低精度计算。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的selfRef、batch1或batch2是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - selfRef、batch1、batch2或out的数据类型或数据格式不在支持的范围内。
  - selfRef、batch1、batch2或out的数据类型不一致。
  - selfRef、batch1、batch2或out的数据格式不一致。
  - selfRef不能与batch1@batch2做broadcast操作。
  - batch1和batch2的第一维度不相等。
  - batch1和batch2的维度不是三维。
  - batch1的最后一维和batch2的倒数第二维不相等。 :::

aclnnInplaceBaddbmm

接口定义：

aclnnStatus aclnnInplaceBaddbmm(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnInplaceBaddbmmGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

调用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_baddbmm.h" #define CHECK_RET(cond, return_expr) \ do { \ if (!(cond)) { \ return_expr; \ } \ } while (0) #define LOG_PRINT(message, ...) \ do { \ printf(message, ##__VA_ARGS__); \ } while (0) int64_t GetShapeSize(const std::vector<int64_t>& shape) { int64_t shapeSize = 1; for (auto i : shape) { shapeSize *= i; } return shapeSize; } int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) { // 固定写法，AscendCL初始化 auto ret = aclInit(nullptr); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret); ret = aclrtSetDevice(deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateContext(context, deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret); ret = aclrtSetCurrentContext(*context); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret); return 0; } template <typename T> int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType, aclTensor** tensor) { auto size = GetShapeSize(shape) * sizeof(T); // 调用aclrtMalloc申请device侧内存 auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret); // 调用aclrtMemcpy将Host侧数据拷贝到device侧内存上 ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret); // 计算连续tensor的strides std::vector<int64_t> strides(shape.size(), 1); for (int64_t i = shape.size() - 2; i >= 0; i--) { strides[i] = shape[i + 1] * strides[i + 1]; } // 调用aclCreateTensor接口创建aclTensor *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(), *deviceAddr); return 0; } int main() { // 1. （固定写法）device/context/stream初始化，参考AscendCL对外接口列表 // 根据自己的实际device填写deviceId int32_t deviceId = 0; aclrtContext context; aclrtStream stream; auto ret = Init(deviceId, &context, &stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret); // 2. 构造输入与输出，需要根据API的接口自定义构造 std::vector<int64_t> selfShape = {1, 2, 4}; std::vector<int64_t> batch1Shape = {1, 2, 3}; std::vector<int64_t> batch2Shape = {1, 3, 4}; std::vector<int64_t> outShape = {1, 2, 4}; void* selfDeviceAddr = nullptr; void* batch1DeviceAddr = nullptr; void* batch2DeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* self = nullptr; aclTensor* batch1 = nullptr; aclTensor* batch2 = nullptr; aclScalar* alpha = nullptr; aclScalar* beta = nullptr; aclTensor* out = nullptr; std::vector<float> selfHostData = {0, 1, 2, 3, 4, 5, 6, 7}; std::vector<float> batch1HostData = {1, 1, 1, 2, 2, 2}; std::vector<float> batch2HostData = {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4}; std::vector<float> outHostData(8, 0); int8_t cubeMathType = 1; float alphaValue = 1.2f; float betaValue = 1.0f; // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建batch1 aclTensor ret = CreateAclTensor(batch1HostData, batch1Shape, &batch1DeviceAddr, aclDataType::ACL_FLOAT, &batch1); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建batch2 aclTensor ret = CreateAclTensor(batch2HostData, batch2Shape, &batch2DeviceAddr, aclDataType::ACL_FLOAT, &batch2); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建alpha aclScalar alpha = aclCreateScalar(&alphaValue,aclDataType::ACL_FLOAT); CHECK_RET(alpha != nullptr, return ret); // 创建beta aclScalar beta = aclCreateScalar(&betaValue,aclDataType::ACL_FLOAT); CHECK_RET(beta != nullptr, return ret); // 创建out aclTensor ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out); CHECK_RET(ret == ACL_SUCCESS, return ret); // 3. 调用CANN算子库API，需要修改为具体的API名称 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnBaddbmm第一段接口 ret = aclnnBaddbmmGetWorkspaceSize(self, batch1, batch2, alpha, beta, out, cubeMathType, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBaddbmmGetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; if (workspaceSize > 0) { ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret); } // 调用aclnnBaddbmm第二段接口 ret = aclnnBaddbmm(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBaddbmm failed. ERROR: %d\n", ret); return ret); // 4. （固定写法）同步等待任务执行结束 ret = aclrtSynchronizeStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret); // 5. 获取输出的值，将device侧内存上的结果拷贝至Host侧，需要根据具体API的接口定义修改 auto size = GetShapeSize(outShape); std::vector<float> resultData(size, 0); ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr, size * sizeof(resultData[0]), ACL_MEMCPY_DEVICE_TO_HOST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret); for (int64_t i = 0; i < size; i++) { LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]); } // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(self); aclDestroyTensor(batch1); aclDestroyTensor(batch2); aclDestroyScalar(alpha); aclDestroyScalar(beta); aclDestroyTensor(out); return 0; }

父主题： NN类算子接口

aclnnBatchMatMul

接口原型

**第一段接口：**aclnnStatus aclnnBatchMatMulGetWorkspaceSize(const aclTensor *self, const aclTensor *mat2, aclTensor *out, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnBatchMatMul(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：完成两个3维矩阵乘计算。
计算公式：
示例：

假设张量self的shape是(A, M, K)，张量mat2的shape是(A, K, N)，则输出out的shape是(A, M, N)。第一维相等，后两維做矩阵乘运算。

注意，如果mat2的shape是(1, K, N)，会因为不能完成broadcast而报错。

aclnnBatchMatMulGetWorkSpaceSize

接口定义：

aclnnStatus aclnnBatchMatMulGetWorkspaceSize(const aclTensor *self, const aclTensor *mat2, aclTensor *out, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：矩阵乘运算的第一个输入，Device侧的aclTensor，shape仅支持3维。数据类型支持FLOAT16、FLOAT、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型与mat2的数据类型需满足数据类型推导规则，支持非连续的Tensor，支持空Tensor，数据格式支持ND。
- mat2：矩阵乘运算的第二个输入，Device侧的aclTensor，shape仅支持3维。数据类型支持FLOAT16、FLOAT、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型与self的数据类型需满足数据类型推导规则，支持非连续的Tensor，支持空Tensor，数据格式支持ND。
- out：输出Tensor，Device侧的aclTensor。数据类型支持FLOAT16、FLOAT、BFLOAT16（仅Atlas A2训练系列产品支持）。数据类型与self保持一致。支持非连续的Tensor，数据格式支持ND。
- cubeMathType：Host侧的整型，判断Cube单元应该使用哪种计算逻辑进行运算，支持INT8类型的枚举值，枚举值如下：
  - 0：KEPP_DTYPE，保持输入的数据类型进行计算。
  - 1：ALLOW_FP32_DOWN_PRECISION，允许转换输入数据类型降低精度计算。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、mat2或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self、mat2或out的数据类型或数据格式不在支持的范围内。
  - self、mat2或out的数据类型或数据格式不一致。
  - self和mat2的第一维度不相等。
  - self和mat2的维度不是三维。
  - self的最后一维和mat2的倒数第二维不相等。 :::

aclnnBatchMatMul

接口定义：

aclnnStatus aclnnBatchMatMul(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnBatchMatMulGetWorkSpaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

约束与限制

本算子仅支持3维张量计算，不支持broadcast。如需进行更高维度的矩阵乘计算或需要支持broadcast，可调用aclnnMatmul实现。

调用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_batch_matmul.h" #define CHECK_RET(cond, return_expr) \ do { \ if (!(cond)) { \ return_expr; \ } \ } while (0) #define LOG_PRINT(message, ...) \ do { \ printf(message, ##__VA_ARGS__); \ } while (0) int64_t GetShapeSize(const std::vector<int64_t>& shape) { int64_t shapeSize = 1; for (auto i : shape) { shapeSize *= i; } return shapeSize; } int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) { // 固定写法，AscendCL初始化 auto ret = aclInit(nullptr); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret); ret = aclrtSetDevice(deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateContext(context, deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret); ret = aclrtSetCurrentContext(*context); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret); return 0; } template <typename T> int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType, aclTensor** tensor) { auto size = GetShapeSize(shape) * sizeof(T); // 调用aclrtMalloc申请device侧内存 auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret); // 调用aclrtMemcpy将Host侧数据拷贝到device侧内存上 ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret); // 计算连续tensor的strides std::vector<int64_t> strides(shape.size(), 1); for (int64_t i = shape.size() - 2; i >= 0; i--) { strides[i] = shape[i + 1] * strides[i + 1]; } // 调用aclCreateTensor接口创建aclTensor *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(), *deviceAddr); return 0; } int main() { // 1. （固定写法）device/context/stream初始化，参考AscendCL对外接口列表 // 根据自己的实际device填写deviceId int32_t deviceId = 0; aclrtContext context; aclrtStream stream; auto ret = Init(deviceId, &context, &stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret); // 2. 构造输入与输出，需要根据API的接口自定义构造 std::vector<int64_t> selfShape = {1, 2, 3}; std::vector<int64_t> mat2Shape = {1, 3, 4}; std::vector<int64_t> outShape = {1, 2, 4}; void* selfDeviceAddr = nullptr; void* mat2DeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* self = nullptr; aclTensor* mat2 = nullptr; aclTensor* out = nullptr; std::vector<float> selfHostData = {0, 1, 2, 3, 4, 5}; std::vector<float> mat2HostData = {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4}; std::vector<float> outHostData(8, 0); int8_t cubeMathType = 1; // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建mat2 aclTensor ret = CreateAclTensor(mat2HostData, mat2Shape, &mat2DeviceAddr, aclDataType::ACL_FLOAT, &mat2); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建out aclTensor ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out); CHECK_RET(ret == ACL_SUCCESS, return ret); // 3. 调用CANN算子库API，需要修改为具体的API名称 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnBatchMatMul第一段接口 ret = aclnnBatchMatMulGetWorkspaceSize(self, mat2, out, cubeMathType, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchMatMulGetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; if (workspaceSize > 0) { ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret); } // 调用aclnnBatchMatMul第二段接口 ret = aclnnBatchMatMul(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchMatMul failed. ERROR: %d\n", ret); return ret); // 4. （固定写法）同步等待任务执行结束 ret = aclrtSynchronizeStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret); // 5. 获取输出的值，将device侧内存上的结果拷贝至Host侧，需要根据具体API的接口定义修改 auto size = GetShapeSize(outShape); std::vector<float> resultData(size, 0); ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr, size * sizeof(resultData[0]), ACL_MEMCPY_DEVICE_TO_HOST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret); for (int64_t i = 0; i < size; i++) { LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]); } // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(self); aclDestroyTensor(mat2); aclDestroyTensor(out); return 0; }

父主题： NN类算子接口

aclnnBatchNorm

接口原型

**第一段接口：**aclnnStatus aclnnBatchNormGetWorkspaceSize(const aclTensor *input, const aclTensor *weight, const aclTensor *bias, aclTensor *runningMean, aclTensor *runningVar, bool training, double momentum, double eps, aclTensor *output, aclTensor *saveMean, aclTensor *saveInvstd, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnBatchNorm(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：对一批数据做正则化处理（Batch Normalization），处理后的数据符合标准正态分布（均值为0、标准差为1）。
计算公式：

其中E[x]表示均值，Var(x)表示方差，ε表示一个极小的浮点数（防止分母为0）。

aclnnBatchNormGetWorkspaceSize

接口定义：

aclnnStatus aclnnBatchNormGetWorkspaceSize(const aclTensor *input, const aclTensor *weight, const aclTensor *bias, aclTensor *runningMean, aclTensor *runningVar, bool training, double momentum, double eps, aclTensor *output, aclTensor *saveMean, aclTensor *saveInvstd, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- input：Device侧的aclTensor，数据类型仅支持FLOAT、FLOAT16，支持非连续的Tensor，支持的shape和格式有：二维（对应格式为NC）、三维（对应的格式为NCL）、四维（对应的格式为NCHW）、五维（对应的格式为NCDHW）。
- weight：可选参数，Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。shape为1维，长度与input入参中C轴的长度相等。
- bias：可选参数，Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。shape为1维，长度与input入参中C轴的长度相等。
- runningMean：可选参数，Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。shape为1维，长度与input入参中C轴的长度相等。
- runningVar：可选参数，Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。shape为1维，长度与input入参中C轴的长度相等。
- training：Host侧的bool值，标记是否训练场景，True表示训练场景，False表示推理场景。
- momentum：Host侧的double值，计算滑动平均的均值。
- eps：Host侧的double值，用于防止分母为0。
- output：Device侧的aclTensor，数据类型与input一致，支持非连续的Tensor，支持的shape和格式有：二维（对应格式为NC）、三维（对应的格式为NCL）、四维（对应的格式为NCHW）、五维（对应的格式为NCDHW）。
- saveMean：Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。shape为1维，长度与input入参中C轴的长度相等。
- saveInvstd：Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。shape为1维，长度与input入参中C轴的长度相等。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的指针类型参数是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - 参数input和output数据类型和数据格式不在支持的范围内。
  - 参数input和output数据的shape不在支持的范围内。 :::

aclnnBatchNorm

接口定义：

aclnnStatus aclnnBatchNorm(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnBatchNormGetWorkspaceSize获取。
- executor：op执行器，包含了算子计算流程。
- stream：指定执行任务的AscendCL stream流。
返回值：

返回aclnnStatus状态码，具体参见aclnn返回码。

调用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_batch_norm.h" #define CHECK_RET(cond, return_expr) \ do { \ if (!(cond)) { \ return_expr; \ } \ } while (0) #define LOG_PRINT(message, ...) \ do { \ printf(message, ##__VA_ARGS__); \ } while (0) int64_t GetShapeSize(const std::vector<int64_t>& shape) { int64_t shape_size = 1; for (auto i : shape) { shape_size *= i; } return shape_size; } int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) { // 固定写法，AscendCL初始化 auto ret = aclInit(nullptr); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclInit failed. ERROR: %d\n", ret); return ret); ret = aclrtSetDevice(deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetDevice failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateContext(context, deviceId); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateContext failed. ERROR: %d\n", ret); return ret); ret = aclrtSetCurrentContext(*context); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSetCurrentContext failed. ERROR: %d\n", ret); return ret); ret = aclrtCreateStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret); return 0; } template <typename T> int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType, aclTensor** tensor) { auto size = GetShapeSize(shape) * sizeof(T); // 调用aclrtMalloc申请device侧内存 auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret); // 调用aclrtMemcpy将Host侧数据拷贝到device侧内存上 ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret); // 计算连续tensor的strides std::vector<int64_t> strides(shape.size(), 1); for (int64_t i = shape.size() - 2; i >= 0; i--) { strides[i] = shape[i + 1] * strides[i + 1]; } // 调用aclCreateTensor接口创建aclTensor *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND, shape.data(), shape.size(), *deviceAddr); return 0; } int main() { // 1. （固定写法）device/context/stream初始化, 参考AscendCL对外接口列表 // 根据自己的实际device填写deviceId int32_t deviceId = 0; aclrtContext context; aclrtStream stream; auto ret = Init(deviceId, &context, &stream); // check根据自己的需要处理 CHECK_RET(ret == 0, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret); // 2. 构造输入与输出，需要根据API的接口自定义构造 std::vector<int64_t> inputShape = {2, 3, 2}; std::vector<int64_t> meanShape = {3}; void* inputDeviceAddr = nullptr; void* weightDeviceAddr = nullptr; void* biasDeviceAddr = nullptr; void* runningMeanDeviceAddr = nullptr; void* runningVarDeviceAddr = nullptr; void* outDeviceAddr = nullptr; void* saveMeanDeviceAddr = nullptr; void* saveInvstdDeviceAddr = nullptr; aclTensor* input = nullptr; aclTensor* weight = nullptr; aclTensor* bias = nullptr; aclTensor* runningMean = nullptr; aclTensor* runningVar = nullptr; aclTensor* out = nullptr; aclTensor* saveMean = nullptr; aclTensor* saveInvstd = nullptr; std::vector<float> inputHostData = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; std::vector<float> zeroHostData = {0, 0, 0}; std::vector<float> oneHostData = {1, 1, 1}; // 创建input aclTensor ret = CreateAclTensor(inputHostData, inputShape, &inputDeviceAddr, aclDataType::ACL_FLOAT, &input); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建weight aclTensor ret = CreateAclTensor(oneHostData, meanShape, &weightDeviceAddr, aclDataType::ACL_FLOAT, &weight); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建bias aclTensor ret = CreateAclTensor(zeroHostData, meanShape, &biasDeviceAddr, aclDataType::ACL_FLOAT, &bias); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建runningMean aclTensor ret = CreateAclTensor(zeroHostData, meanShape, &runningMeanDeviceAddr, aclDataType::ACL_FLOAT, &runningMean); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建runningVar aclTensor ret = CreateAclTensor(oneHostData, meanShape, &runningVarDeviceAddr, aclDataType::ACL_FLOAT, &runningVar); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建out aclTensor ret = CreateAclTensor(inputHostData, inputShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建saveMean aclTensor ret = CreateAclTensor(zeroHostData, meanShape, &saveMeanDeviceAddr, aclDataType::ACL_FLOAT, &saveMean); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建saveInvstd aclTensor ret = CreateAclTensor(zeroHostData, meanShape, &saveInvstdDeviceAddr, aclDataType::ACL_FLOAT, &saveInvstd); CHECK_RET(ret == ACL_SUCCESS, return ret); // 3.调用CANN算子库API，需要修改为具体的算子接口 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnBatchNorm第一段接口 ret = aclnnBatchNormGetWorkspaceSize(input, weight, bias, runningMean, runningVar, true, 0.1, 1e-5, out, saveMean, saveInvstd, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNormGetWorkspaceSize failed. ERROR: %d\n", ret); return ret); // 根据第一段接口计算出的workspaceSize申请device内存 void* workspaceAddr = nullptr; if (workspaceSize > 0) { ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret;); } // 调用aclnnBatchNorm第二段接口 ret = aclnnBatchNorm(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNorm failed. ERROR: %d\n", ret); return ret); // 4. （固定写法）同步等待任务执行结束 ret = aclrtSynchronizeStream(stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret); // 5. 获取输出的值，将device侧内存上的结果拷贝至Host侧，需要根据具体API的接口定义修改 auto size = GetShapeSize(inputShape); std::vector<float> resultData(size, 0); ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr, size * sizeof(float), ACL_MEMCPY_DEVICE_TO_HOST); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret); for (int64_t i = 0; i < size; i++) { LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]); } // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(input); aclDestroyTensor(weight); aclDestroyTensor(bias); aclDestroyTensor(runningMean); aclDestroyTensor(runningVar); aclDestroyTensor(out); aclDestroyTensor(saveMean); aclDestroyTensor(saveInvstd); return 0; }

父主题： NN类算子接口

在线提单

aclnnAtanh/aclnnInplaceAtanh​

接口原型​

功能描述​

aclnnAtanhGetWorkspaceSize​

aclnnAtanh​

aclnnInplaceAtanhGetWorkspaceSize​

aclnnInplaceAtanh​

调用示例​

aclnnAtan2/aclnnInplaceAtan2​

接口原型​

功能描述​

aclnnAtan2GetWorkspaceSize​

aclnnAtan2​

aclnnInplaceAtan2GetWorkspaceSize​

aclnnInplaceAtan2​

调用示例​

aclnnAvgPool2d​

接口原型​

功能描述​

aclnnAvgPool2dGetWorkspaceSize​

aclnnAvgPool2d​

调用示例​

aclnnAvgPool2dBackward​

接口原型​

功能描述​

aclnnAvgPool2dBackwardGetWorkspaceSize​

aclnnAvgPool2dBackward​

调用示例​

aclnnBaddbmm/aclnnInplaceBaddbmm​

接口原型​

功能描述​

aclnnBaddbmmGetWorkspaceSize​

aclnnBaddbmm​

aclnnInplaceBaddbmmGetWorkspaceSize​

aclnnInplaceBaddbmm​

调用示例​

aclnnBatchMatMul​

接口原型​

功能描述​

aclnnBatchMatMulGetWorkSpaceSize​

aclnnBatchMatMul​

约束与限制​

调用示例​

aclnnBatchNorm​

接口原型​

功能描述​

aclnnBatchNormGetWorkspaceSize​

aclnnBatchNorm​

调用示例​

aclnnAtanh/aclnnInplaceAtanh

接口原型

功能描述

aclnnAtanhGetWorkspaceSize

aclnnAtanh

aclnnInplaceAtanhGetWorkspaceSize

aclnnInplaceAtanh

调用示例

aclnnAtan2/aclnnInplaceAtan2

接口原型

功能描述

aclnnAtan2GetWorkspaceSize

aclnnAtan2

aclnnInplaceAtan2GetWorkspaceSize

aclnnInplaceAtan2

调用示例

aclnnAvgPool2d

接口原型

功能描述

aclnnAvgPool2dGetWorkspaceSize

aclnnAvgPool2d

调用示例

aclnnAvgPool2dBackward

接口原型

功能描述

aclnnAvgPool2dBackwardGetWorkspaceSize

aclnnAvgPool2dBackward

调用示例

aclnnBaddbmm/aclnnInplaceBaddbmm

接口原型

功能描述

aclnnBaddbmmGetWorkspaceSize

aclnnBaddbmm

aclnnInplaceBaddbmmGetWorkspaceSize

aclnnInplaceBaddbmm

调用示例

aclnnBatchMatMul

接口原型

功能描述

aclnnBatchMatMulGetWorkSpaceSize

aclnnBatchMatMul

约束与限制

调用示例

aclnnBatchNorm

接口原型

功能描述

aclnnBatchNormGetWorkspaceSize

aclnnBatchNorm

调用示例