aclnnBatchNormElemt

aclnnBatchNorm

接口原型

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

**第一段接口：**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类算子接口

aclnnBatchNormBackward

接口原型

**第一段接口：**aclnnStatus aclnnBatchNormBackwardGetWorkspaceSize(const aclTensor *gradOut, const aclTensor *input, const aclTensor *weight, const aclTensor *runningMean, const aclTensor *runningVar, const aclTensor *saveMean, const aclTensor *saveInvstd, bool training, double eps, const aclBoolArray *outputMask, aclTensor *gradInput, aclTensor *gradWeight, aclTensor *gradBias, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnBatchNormBackward(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：aclnnBatchNorm的反向计算。
计算公式：

aclnnBatchNormBackwardGetWorkspaceSize

接口定义：

aclnnStatus aclnnBatchNormBackwardGetWorkspaceSize(const aclTensor *gradOut, const aclTensor *input, const aclTensor *weight, const aclTensor *runningMean, const aclTensor *runningVar, const aclTensor *saveMean, const aclTensor *saveInvstd, bool training, double eps, const aclBoolArray *outputMask, aclTensor *gradInput, aclTensor *gradWeight, aclTensor *gradBias, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- gradOut：Device侧的aclTensor，数据类型仅支持FLOAT、FLOAT16，支持非连续的Tensor，支持的shape和格式有：二维（对应格式为NC）、三维（对应的格式为NCL）、四维（对应的格式为NCHW）、五维（对应的格式为NCDHW）。
- input：Device侧的aclTensor，数据类型仅支持FLOAT、FLOAT16，支持非连续的Tensor，支持的shape和格式有：二维（对应格式为NC）、三维（对应的格式为NCL）、四维（对应的格式为NCHW）、五维（对应的格式为NCDHW）。
- weight：可选参数，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轴的长度相等。
- saveMean：可选参数，Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。shape为1维，长度与input入参中C轴的长度相等。
- saveInvstd：可选参数，Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。shape为1维，长度与input入参中C轴的长度相等。
- training：Host侧的bool值，标记是否训练场景，True表示训练场景，False表示推理场景。
- eps：Host侧的double值，用于防止分母为0。
- outputMask：aclBoolArray类型，输出的掩码。3个bool类型的标记，分别表示是否计算gradInput、gradWeight、gradBias3个输出。
- gradInput：Device侧的aclTensor，数据类型与input一致，支持非连续的Tensor，支持的shape和格式有：二维（对应格式为NC）、三维（对应的格式为NCL）、四维（对应的格式为NCHW）、五维（对应的格式为NCDHW）。
- gradWeight：Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。shape为1维，长度与input入参中C轴的长度相等。
- gradBias：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，gradOut，gradInput数据类型和数据格式不在支持的范围内。
  - 参数input，gradOut，gradInput数据的shape不在支持的范围内。 :::

aclnnBatchNormBackward

接口定义：

aclnnStatus aclnnBatchNormBackward(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnBatchNormBackwardGetWorkspaceSize获取。
- 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 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_batch_norm_backward.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* gradOutDeviceAddr = nullptr; void* inputDeviceAddr = nullptr; void* weightDeviceAddr = nullptr; void* runningMeanDeviceAddr = nullptr; void* runningVarDeviceAddr = nullptr; void* saveMeanDeviceAddr = nullptr; void* saveInvstdDeviceAddr = nullptr; void* gradInputDeviceAddr = nullptr; void* gradWeightDeviceAddr = nullptr; void* gradBiasDeviceAddr = nullptr; aclTensor* gradOut = nullptr; aclTensor* input = nullptr; aclTensor* weight = nullptr; aclTensor* runningMean = nullptr; aclTensor* runningVar = nullptr; aclTensor* saveMean = nullptr; aclTensor* saveInvstd = nullptr; aclTensor* gradInput = nullptr; aclTensor* gradWeight = nullptr; aclTensor* gradBias = 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}; // 创建gradOut aclTensor ret = CreateAclTensor(inputHostData, inputShape, &gradOutDeviceAddr, aclDataType::ACL_FLOAT, &gradOut); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建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); // 创建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); // 创建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); // 创建gradInput aclTensor ret = CreateAclTensor(inputHostData, inputShape, &gradInputDeviceAddr, aclDataType::ACL_FLOAT, &gradInput); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建gradWeight aclTensor ret = CreateAclTensor(zeroHostData, meanShape, &gradWeightDeviceAddr, aclDataType::ACL_FLOAT, &gradWeight); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建gradBias aclTensor ret = CreateAclTensor(zeroHostData, meanShape, &gradBiasDeviceAddr, aclDataType::ACL_FLOAT, &gradBias); CHECK_RET(ret == ACL_SUCCESS, return ret); std::array<bool, 3> value = {true, true, true}; auto outputMask = aclCreateBoolArray(value.data(), value.size()); // 3.调用CANN算子库API，需要修改为具体的算子接口 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnBatchNormBackward第一段接口 ret = aclnnBatchNormBackwardGetWorkspaceSize(gradOut, input, weight, runningMean, runningVar, saveMean, saveInvstd, true, 1e-5, outputMask, gradInput, gradWeight, gradBias, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNormBackwardGetWorkspaceSize 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;); } // 调用aclnnBatchNormBackward第二段接口 ret = aclnnBatchNormBackward(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNormBackward 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]), gradInput, 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(gradOut); aclDestroyTensor(input); aclDestroyTensor(weight); aclDestroyTensor(runningMean); aclDestroyTensor(runningVar); aclDestroyTensor(saveMean); aclDestroyTensor(saveInvstd); aclDestroyTensor(gradInput); aclDestroyTensor(gradWeight); aclDestroyTensor(gradBias); return 0; }

父主题： NN类算子接口

aclnnBatchNormElemt

接口原型

第一段接口：aclnnStatus aclnnBatchNormElemtGetWorkspaceSize(const aclTensor* input, const aclTensor* weight, const aclTensor* bias, aclTensor* mean, aclTensor* invstd, float eps, aclTensor* output, uint64_t* workspaceSize, aclOpExecutor** executor)
第二段接口：aclnnStatus aclnnBatchNormElemt(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream)

功能描述

算子功能：根据全局的均值和标准差倒数对输入数据做BN，走推理模式。多卡BatchNorm场景下实现SyncBatchNorm，需通过aclnnBatchNormStats、aclnnBatchNormGatherStatsWithCounts和aclnnBatchNormElemt算子组合实现。

:::note 说明 BatchNorm的性能和BatchSize相关，BatchSize越大，BatchNorm的统计量也会越准。对于目标检测类似的任务，占用显存较高，一张显卡往往只能使用较少的图片（比如2张）来训练，这就导致BN的表现变差。为解决该问题，需要实现SyncBatchNorm，即所有卡共享同一个BN，得到全局的统计量。 :::
计算公式：

其中标准差与方差的关系如下：

aclnnBatchNormElemtGetWorkspaceSize

接口定义：

aclnnStatus aclnnBatchNormElemtGetWorkspaceSize(const aclTensor* input, const aclTensor* weight, const aclTensor* bias, aclTensor* mean, aclTensor* invstd, float eps, aclTensor* output, uint64_t* workspaceSize, aclOpExecutor** executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT，支持非连续Tensor，数据格式五维及以下支持NCDHW、NCHW、NCL、NC，六维到八维支持ND。
- weight：可选参数，BN权重，Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。Shape为一维，长度和入参self中C轴的长度相同。
- bias：可选参数，BN偏置，Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。Shape为一维，长度和入参self中C轴的长度相同。
- mean：输入数据均值，Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。Shape为一维，长度和入参self中C轴的长度相同。
- invstd：输入数据标准差的倒数，Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。Shape为一维，长度和入参self中C轴的长度相同。invstd大于0时，和Cuda行为保持一致，其余情况不做保证。
- eps：用于防止产生除0的偏移，Host侧的float值，默认值为1e-5。
- output：Device侧的aclTensor，数据类型与input一致，支持非连续Tensor，数据格式与输入一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的指针类型入参是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - input、output数据类型和数据格式不在支持的范围内。
  - input、output数据的shape不在支持的范围内。
  - mean、invstd、weight、bias维度不为一维，并且shape不等于入参C轴的长度。 :::

aclnnBatchNormElemt

接口定义：

aclnnStatus aclnnBatchNormElemt(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnBatchNormElemtGetWorkspaceSize获取。
- 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 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_batch_norm_elemt.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, 4, 2}; std::vector<int64_t> meanShape = {4}; std::vector<int64_t> invstdShape = {4}; std::vector<int64_t> outShape = {2, 4, 2}; double eps = 1e-2; void* inputDeviceAddr = nullptr; void* meanDeviceAddr = nullptr; void* invstdDeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* input = nullptr; aclTensor* mean = nullptr; aclTensor* invstd = nullptr; aclTensor* out = nullptr; std::vector<float> inputHostData = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; std::vector<float> meanHostData = {1, 2, 3, 4}; std::vector<float> invstdHostData = {5, 6, 7, 8}; std::vector<float> outHostData = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // 创建input aclTensor ret = CreateAclTensor(inputHostData, inputShape, &inputDeviceAddr, aclDataType::ACL_FLOAT, &input); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建mean aclTensor ret = CreateAclTensor(meanHostData, meanShape, &meanDeviceAddr, aclDataType::ACL_FLOAT, &mean); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建invstd aclTensor ret = CreateAclTensor(invstdHostData, invstdShape, &invstdDeviceAddr, aclDataType::ACL_FLOAT, &invstd); 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，需要修改为具体的算子接口 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnBatchNormElemt第一段接口 ret = aclnnBatchNormElemtGetWorkspaceSize(input, nullptr, nullptr, mean, invstd, eps, out, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNormElemtGetWorkspaceSize 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;); } // 调用aclnnBatchNormElemt第二段接口 ret = aclnnBatchNormElemt(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNormElemt 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(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(mean); aclDestroyTensor(invstd); aclDestroyTensor(out); return 0; }

父主题： NN类算子接口

aclnnBatchNormElemtBackward

接口原型

**第一段接口：**aclnnStatus aclnnBatchNormElemtBackwardGetWorkspaceSize(const aclTensor* gradOut, const aclTensor* input, const aclTensor* mean, const aclTensor* invstd, const aclTensor* weight, const aclTensor* meanDy, const aclTensor* meanDyXmu, aclTensor* gradInput,uint64_t* workspaceSize, aclOpExecutor** executor)
第二段接口：aclnnStatus aclnnBatchNormElemtBackward(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream)

功能描述

算子功能：aclnnBatchNormElemt的反向计算。
计算公式：

aclnnBatchNormElemtBackwardGetWorkspaceSize

接口定义：

aclnnStatus aclnnBatchNormElemtBackwardGetWorkspaceSize(const aclTensor* gradOut, const aclTensor* input, const aclTensor* mean, const aclTensor* invstd, const aclTensor* weight, const aclTensor* meanDy, const aclTensor* meanDyXmu, aclTensor* gradInput,uint64_t* workspaceSize, aclOpExecutor** executor)
参数说明：
- gradOut：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT，支持非连续Tensor，数据格式五维及以下支持NCDHW、NCHW、NCL、NC，六维到八维支持ND。
- input：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT，支持非连续Tensor，数据格式五维及以下支持NCDHW、NCHW、NCL、NC，六维到八维支持ND。
- mean：Device侧的aclTensor，数据类型仅支持FLOAT16、FLOAT，数据格式为ND。
- invstd：Device侧的aclTensor，数据类型仅支持FLOAT16、FLOAT，数据格式为ND。
- weight：可选参数，Device侧的aclTensor，数据类型仅支持FLOAT16、FLOAT，数据格式为ND。
- meanDy：Device侧的aclTensor，数据类型仅支持FLOAT16、FLOAT，数据格式为ND。
- meanDyXmu：Device侧的aclTensor，数据类型仅支持FLOAT16、FLOAT，数据格式为ND。
- gradInput：Device侧的aclTensor，数据类型与input一致，支持非连续Tensor，数据格式与输入一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnBatchNormElemtBackward

接口定义：

aclnnStatus aclnnBatchNormElemtBackward(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnBatchNormElemtBackwardGetWorkspaceSize获取。
- 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 164 165 166 167 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_batch_norm_elemt_backward.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 = {4, 2}; std::vector<int64_t> gradOutShape = {4, 2}; std::vector<int64_t> gradInputShape = {4, 2}; std::vector<int64_t> meanShape = {2}; std::vector<int64_t> invstdShape = {2}; std::vector<int64_t> weightShape = {2}; std::vector<int64_t> meanDyShape = {2}; std::vector<int64_t> meanDyXmuShape = {2}; void* inputDeviceAddr = nullptr; void* gradOutDeviceAddr = nullptr; void* gradInputDeviceAddr = nullptr; void* meanDeviceAddr = nullptr; void* invstdDeviceAddr = nullptr; void* weightDeviceAddr = nullptr; void* meanDyDeviceAddr = nullptr; void* meanDyXmuDeviceAddr = nullptr; aclTensor* input = nullptr; aclTensor* gradOut = nullptr; aclTensor* gradInput = nullptr; aclTensor* mean = nullptr; aclTensor* invstd = nullptr; aclTensor* weight = nullptr; aclTensor* meanDy = nullptr; aclTensor* meanDyXmu = nullptr; std::vector<float> inputHostData = {0, 1, 2, 3, 4, 5, 6, 7}; std::vector<float> gradOutHostData = {1, 1, 1, 2, 2, 2, 3, 3}; std::vector<float> gradInputHostData = {0, 0, 0, 0, 0, 0, 0, 0}; std::vector<float> meanHostData = {1, 1}; std::vector<float> invstdHostData = {1, 1}; std::vector<float> weightHostData = {1, 1}; std::vector<float> meanDyHostData = {1, 1}; std::vector<float> meanDyXmuHostData = {1, 1}; ret = CreateAclTensor(inputHostData, inputShape, &inputDeviceAddr, aclDataType::ACL_FLOAT, &input); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(gradOutHostData, gradOutShape, &gradOutDeviceAddr, aclDataType::ACL_FLOAT, &gradOut); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(gradInputHostData, gradInputShape, &gradInputDeviceAddr, aclDataType::ACL_FLOAT, &gradInput); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(meanHostData, meanShape, &meanDeviceAddr, aclDataType::ACL_FLOAT, &mean); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(invstdHostData, invstdShape, &invstdDeviceAddr, aclDataType::ACL_FLOAT, &invstd); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(weightHostData, weightShape, &weightDeviceAddr, aclDataType::ACL_FLOAT, &weight); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(meanDyHostData, meanDyShape, &meanDyDeviceAddr, aclDataType::ACL_FLOAT, &meanDy); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(meanDyXmuHostData, meanDyXmuShape, &meanDyXmuDeviceAddr, aclDataType::ACL_FLOAT, &meanDyXmu); CHECK_RET(ret == ACL_SUCCESS, return ret); // 3.调用CANN算子库API，需要修改为具体的算子接口 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnBatchNormElemtBackward第一段接口 ret = aclnnBatchNormElemtBackwardGetWorkspaceSize(gradOut, input, mean, invstd, weight, meanDy, meanDyXmu, gradInput, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNormElemtBackwardGetWorkspaceSize 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;); } // 调用aclnnBatchNormElemtBackward第二段接口 ret = aclnnBatchNormElemtBackward(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNormElemtBackward 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> resultData(size, 0); ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), gradInputDeviceAddr, 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(gradOut); aclDestroyTensor(gradInput); aclDestroyTensor(mean); aclDestroyTensor(invstd); aclDestroyTensor(weight); aclDestroyTensor(meanDy); aclDestroyTensor(meanDyXmu); return 0; }

父主题： NN类算子接口

aclnnBatchNormGatherStatsWithCounts

接口原型

**第一段接口：**aclnnStatus aclnnBatchNormGatherStatsWithCountsGetWorkspaceSize(const aclTensor* input, const aclTensor* mean, const aclTensor* invstd, aclTensor* runningMean, aclTensor* runningVar, double momentum, double eps, const aclTensor* counts, aclTensor* meanAllOut, aclTensor* invstdAllOut, uint64_t* workspaceSize, aclOpExecutor** executor)
第二段接口：aclnnStatus aclnnBatchNormGatherStatsWithCounts(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream)

功能描述

算子功能：多卡BatchNorm场景下实现SyncBatchNorm，需通过aclnnBatchNormStats、aclnnBatchNormGatherStatsWithCounts和aclnnBatchNormElemt算子组合实现。其中aclnnBatchNormGatherStatsWithCounts主要收集所有device的均值和方差，并更新全局的均值和方差，计算时依赖aclnnBatchNormStats计算单卡数据的均值和标准差的倒数。

:::note 说明 BatchNorm的性能和BatchSize相关，BatchSize越大，BatchNorm的统计量也会越准。对于目标检测类似的任务，占用显存较高，一张显卡往往只能使用较少的图片（比如2张）来训练，这就导致BN的表现变差。为解决该问题，需要实现SyncBatchNorm，即所有卡共享同一个BN，得到全局的统计量。 :::
计算公式：

runningMean（M）与runningVar（V）更新公式如下：

aclnnBatchNormGatherStatsWithCountsGetWorkspaceSize

接口定义：

aclnnStatus aclnnBatchNormGatherStatsWithCountsGetWorkspaceSize(const aclTensor* input, const aclTensor* mean, const aclTensor* invstd, aclTensor* runningMean, aclTensor* runningVar, double momentum, double eps, const aclTensor* counts, aclTensor* meanAllOut, aclTensor* invstdAllOut, uint64_t* workspaceSize, aclOpExecutor** executor)
参数说明：
- input：Device侧的aclTensor，输入Tensor，数据类型支持FLOAT16、FLOAT，支持非连续Tensor，数据格式五维及以下支持NCDHW、NCHW、NCL、NC，六维到八维支持ND。
- mean：输入数据均值，Device侧的aclTensor，数据类型支持FLOAT16、FLOAT，支持非连续的Tensor，数据格式为ND。二维Tensor，第一轴对应的大小与input入参中的C轴长度相同。
- invstd：输入数据标准差的倒数，Device侧的aclTensor，数据类型仅支持FLOAT16、FLOAT，支持非连续的Tensor，数据格式为ND。二维Tensor，第一轴对应的大小与input入参中的C轴长度相同。
- runningMean：训练时数据的均值，Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。一维Tensor，长度与input入参中的C轴长度相同。
- runningVar：训练时数据的方差，Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。一维Tensor，长度与input入参中的C轴长度相同。
- momentum：runningMean和runningVar的指数平滑参数，默认0.1。
- eps：用于防止做BN时，分母出现0的情况，默认值为1e-5。
- counts：输入数据的元素个数，Device侧的aclTensor，数据类型仅支持FLOAT，支持非连续的Tensor，数据格式为ND。一维Tensor，长度与mean或invstd入参0轴的长度相同。
- meanAll：SyncBatchNorm后，所有卡上数据的均值，Device侧的aclTensor，数据类型仅支持FLOAT16、FLOAT，支持非连续的Tensor，数据格式为ND。
- invstdAll：SyncBatchNorm后，所有卡上数据的标准差的倒数，Device侧的aclTensor，数据类型仅支持FLOAT16、FLOAT，支持非连续的Tensor，数据格式为ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnBatchNormGatherStatsWithCounts

接口定义：
- aclnnStatus aclnnBatchNormGatherStatsWithCounts(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnBatchNormGatherStatsWithCountsGetWorkspaceSize获取。
- 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 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_batch_norm_gather_stats_with_counts.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, 4, 2}; std::vector<int64_t> meanShape = {2, 4}; std::vector<int64_t> invstdShape = {2, 4}; std::vector<int64_t> countShape = {2}; std::vector<int64_t> meanOutShape = {4}; std::vector<int64_t> invstdOutShape = {4}; double eps = 1e-2; void* inputDeviceAddr = nullptr; void* meanDeviceAddr = nullptr; void* invstdDeviceAddr = nullptr; void* countDeviceAddr = nullptr; void* meanOutDeviceAddr = nullptr; void* invstdOutDeviceAddr = nullptr; aclTensor* input = nullptr; aclTensor* mean = nullptr; aclTensor* invstd = nullptr; aclTensor* count = nullptr; aclTensor* meanOut = nullptr; aclTensor* invstdOut = nullptr; std::vector<float> inputHostData = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; std::vector<float> meanHostData = {1, 2, 3, 4, 5, 6, 7, 8}; std::vector<float> invstdHostData = {5, 6, 7, 8, 9, 10, 11, 12}; std::vector<float> countHostData = {1, 2}; std::vector<float> meanOutHostData = {0, 0, 0, 0}; std::vector<float> invstdOutHostData = {0, 0, 0, 0}; // 创建input aclTensor ret = CreateAclTensor(inputHostData, inputShape, &inputDeviceAddr, aclDataType::ACL_FLOAT, &input); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建mean aclTensor ret = CreateAclTensor(meanHostData, meanShape, &meanDeviceAddr, aclDataType::ACL_FLOAT, &mean); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建invstd aclTensor ret = CreateAclTensor(invstdHostData, invstdShape, &invstdDeviceAddr, aclDataType::ACL_FLOAT, &invstd); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建invstd aclTensor ret = CreateAclTensor(countHostData, countShape, &countDeviceAddr, aclDataType::ACL_FLOAT, &count); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建meanOut aclTensor ret = CreateAclTensor(meanOutHostData, meanOutShape, &meanOutDeviceAddr, aclDataType::ACL_FLOAT, &meanOut); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建invstdOut aclTensor ret = CreateAclTensor(invstdOutHostData, invstdOutShape, &invstdOutDeviceAddr, aclDataType::ACL_FLOAT, &invstdOut); CHECK_RET(ret == ACL_SUCCESS, return ret); // 3.调用CANN算子库API，需要修改为具体的算子接口 uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnBatchNormGatherStatsWithCounts第一段接口 ret = aclnnBatchNormGatherStatsWithCountsGetWorkspaceSize(input, mean, invstd, nullptr, nullptr, 1e-4, 1e-2, count, meanOut, invstdOut, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNormGatherStatsWithCountsGetWorkspaceSize 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;); } // 调用aclnnBatchNormGatherStatsWithCounts第二段接口 ret = aclnnBatchNormGatherStatsWithCounts(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNormGatherStatsWithCounts 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(meanOutShape); std::vector<float> resultData(size, 0); ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), meanOutDeviceAddr, 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(mean); aclDestroyTensor(invstd); aclDestroyTensor(count); aclDestroyTensor(meanOut); aclDestroyTensor(invstdOut); return 0; }

父主题： NN类算子接口

aclnnBatchNormReduceBackward

接口原型

第一段接口：aclnnStatus aclnnBatchNormReduceBackwardGetWorkspaceSize(const aclTensor* gradOut, const aclTensor* input, const aclTensor* mean, const aclTensor* invstd, const aclTensor* weight, const bool inputG, const bool weightG, const bool biasG, aclTensor* sumDy, aclTensor* sumDyXmu, aclTensor* gradWeight, aclTensor* gradBias, uint64_t* workspaceSize, aclOpExecutor** executor)
第二段接口：aclnnStatus aclnnBatchNormReduceBackward(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream)

功能描述

算子功能：BN的反向传播计算了损失函数L相对于对应层各输入xi 的梯度（∂L/∂xi）、对缩放权重γ的梯度（∂L/∂γ）以及对偏移量β的梯度（∂L/∂β），具体参见aclnnBatchNormBackward。本算子计算了其中的“∂L/∂γ”和“∂L/∂β”，并且还用损失函数L相对于输出yi 的偏差推导出“∂L/∂xi”所需的中间量sumDy和sumDyXmu。
计算公式：

aclnnBatchNormReduceBackwardGetWorkspaceSize

接口定义：

aclnnStatus aclnnBatchNormReduceBackwardGetWorkspaceSize(const aclTensor* gradOut, const aclTensor* input, const aclTensor* mean, const aclTensor* invstd, const aclTensor* weight, const bool inputG, const bool weightG, const bool biasG, aclTensor* sumDy, aclTensor* sumDyXmu, aclTensor* gradWeight, aclTensor* gradBias, uint64_t* workspaceSize, aclOpExecutor** executor)
参数说明：
- gradOut：Device侧的aclTensor，数据类型仅支持FLOAT、FLOAT16，支持非连续的Tensor，数据格式为ND。
- input：Device侧的aclTensor，数据类型仅支持FLOAT、FLOAT16，支持非连续的Tensor，数据格式为ND。
- mean：Device侧的aclTensor，数据类型仅支持FLOAT、FLOAT16，支持非连续的Tensor，数据格式为ND。
- invstd：Device侧的aclTensor，数据类型仅支持FFLOAT、FLOAT16，支持非连续的Tensor，数据格式为ND。
- weight：Device侧的aclTensor，数据类型仅支持FLOAT、FLOAT16，支持非连续的Tensor，数据格式为ND。
- inputG：BOOL类型，输出掩码，标记是否需要输出sumDy和sumDyXmu。
- weightG：BOOL类型，输出掩码，标记是否需要输出gradWeight。
- biasG：BOOL类型，输出掩码，标记是否需要输出gradBias。
- sumDy：Device侧的aclTensor，如果inputG为True则输出，支持非连续的Tensor，数据格式与输入一致。
- sumDyXmu：Device侧的aclTensor，如果inputG为True则输出，支持非连续的Tensor，数据格式与输入一致。
- gradWeight：Device侧的aclTensor，如果weightG为True则输出，支持非连续的Tensor，数据格式与输入一致。
- gradBias：Device侧的aclTensor，如果biasG为True则输出，支持非连续的Tensor，数据格式与输入一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnBatchNormReduceBackward

接口定义：

aclnnStatus aclnnBatchNormReduceBackward(void* workspace, uint64_t workspaceSize, aclOpExecutor* executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnBatchNormReduceBackwardGetWorkspaceSize获取。
- 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 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_batch_norm_backward_reduce.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; } void PrintOutResult(std::vector<int64_t> &shape, void** deviceAddr) { auto size = GetShapeSize(shape); std::vector<float> resultData(size, 0); auto ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), *deviceAddr, 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); for (int64_t i = 0; i < size; i++) { LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]); } } 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 == 0, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret); // check根据自己的需要处理 // 2. 构造输入与输出，需要根据API的接口自定义构造 std::vector<int64_t> gradOutShape = {4, 2}; std::vector<int64_t> inputShape = {4, 2}; std::vector<int64_t> meanShape = {2}; std::vector<int64_t> invstdShape = {2}; std::vector<int64_t> weightShape = {2}; std::vector<int64_t> sumDyShape = {2}; std::vector<int64_t> sumDyXmuShape = {2}; std::vector<int64_t> gradWeightShape = {2}; std::vector<int64_t> gradBiasShape = {2}; void* inputDeviceAddr = nullptr; void* gradOutDeviceAddr = nullptr; void* meanDeviceAddr = nullptr; void* invstdDeviceAddr = nullptr; void* weightDeviceAddr = nullptr; void* sumDyDeviceAddr = nullptr; void* sumDyXmuDeviceAddr = nullptr; void* gradWeightDeviceAddr = nullptr; void* gradBiasDeviceAddr = nullptr; aclTensor* input = nullptr; aclTensor* gradOut = nullptr; aclTensor* mean = nullptr; aclTensor* invstd = nullptr; aclTensor* weight = nullptr; aclTensor* sumDy = nullptr; aclTensor* sumDyXmu = nullptr; aclTensor* gradWeight = nullptr; aclTensor* gradBias = nullptr; std::vector<float> gradOutHostData = {1, 1, 1, 2, 2, 2, 3, 3}; std::vector<float> inputHostData = {0, 1, 2, 3, 4, 5, 6, 7}; std::vector<float> meanHostData = {1, 1}; std::vector<float> invstdHostData = {1, 1}; std::vector<float> weightHostData = {1, 1}; std::vector<float> sumDyHostData = {1, 1}; std::vector<float> sumDyXmuHostData = {1, 1}; std::vector<float> gradWeightHostData = {1, 1}; std::vector<float> gradBiasHostData = {1, 1}; ret = CreateAclTensor(gradOutHostData, gradOutShape, &gradOutDeviceAddr, aclDataType::ACL_FLOAT, &gradOut); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(inputHostData, inputShape, &inputDeviceAddr, aclDataType::ACL_FLOAT, &input); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(meanHostData, meanShape, &meanDeviceAddr, aclDataType::ACL_FLOAT, &mean); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(invstdHostData, invstdShape, &invstdDeviceAddr, aclDataType::ACL_FLOAT, &invstd); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(weightHostData, weightShape, &weightDeviceAddr, aclDataType::ACL_FLOAT, &weight); CHECK_RET(ret == ACL_SUCCESS, return ret); bool inputG = true; bool weightG = true; bool biasG = true; ret = CreateAclTensor(sumDyHostData, sumDyShape, &sumDyDeviceAddr, aclDataType::ACL_FLOAT, &sumDy); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(sumDyXmuHostData, sumDyXmuShape, &sumDyXmuDeviceAddr, aclDataType::ACL_FLOAT, &sumDyXmu); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(gradWeightHostData, gradWeightShape, &gradWeightDeviceAddr, aclDataType::ACL_FLOAT, &gradWeight); CHECK_RET(ret == ACL_SUCCESS, return ret); ret = CreateAclTensor(gradBiasHostData, gradBiasShape, &gradBiasDeviceAddr, aclDataType::ACL_FLOAT, &gradBias); CHECK_RET(ret == ACL_SUCCESS, return ret); // 3. 调用CANN算子库API uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnBatchNormReduceBackward第一段接口 ret = aclnnBatchNormReduceBackwardGetWorkspaceSize(gradOut, input, mean, invstd, weight, inputG, weightG, biasG, sumDy, sumDyXmu, gradWeight, gradBias, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNormReduceBackwardGetWorkspaceSize 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;); } // 调用aclnnBatchNormReduceBackwardNpuImpl第二段接口 ret = aclnnBatchNormReduceBackward(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNormReduceBackward 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的接口定义修改 PrintOutResult(sumDyShape, &sumDyDeviceAddr); PrintOutResult(sumDyXmuShape, &sumDyXmuDeviceAddr); PrintOutResult(gradWeightShape, &gradWeightDeviceAddr); PrintOutResult(gradBiasShape, &gradBiasDeviceAddr); // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(input); aclDestroyTensor(gradOut); aclDestroyTensor(mean); aclDestroyTensor(invstd); aclDestroyTensor(weight); aclDestroyTensor(sumDy); aclDestroyTensor(sumDyXmu); aclDestroyTensor(gradWeight); aclDestroyTensor(gradBias); return 0; }

父主题： NN类算子接口

在线提单

aclnnBatchNorm​

接口原型​

功能描述​

aclnnBatchNormGetWorkspaceSize​

aclnnBatchNorm​

调用示例​

aclnnBatchNormBackward​

接口原型​

功能描述​

aclnnBatchNormBackwardGetWorkspaceSize​

aclnnBatchNormBackward​

调用示例​

aclnnBatchNormElemt​

接口原型​

功能描述​

aclnnBatchNormElemtGetWorkspaceSize​

aclnnBatchNormElemt​

调用示例​

aclnnBatchNormElemtBackward​

接口原型​

功能描述​

aclnnBatchNormElemtBackwardGetWorkspaceSize​

aclnnBatchNormElemtBackward​

调用示例​

aclnnBatchNormGatherStatsWithCounts​

接口原型​

功能描述​

aclnnBatchNormGatherStatsWithCountsGetWorkspaceSize​

aclnnBatchNormGatherStatsWithCounts​

调用示例​

aclnnBatchNormReduceBackward​

接口原型​

功能描述​

aclnnBatchNormReduceBackwardGetWorkspaceSize​

aclnnBatchNormReduceBackward​

调用示例​

aclnnBatchNorm

接口原型

功能描述

aclnnBatchNormGetWorkspaceSize

aclnnBatchNorm

调用示例

aclnnBatchNormBackward

接口原型

功能描述

aclnnBatchNormBackwardGetWorkspaceSize

aclnnBatchNormBackward

调用示例

aclnnBatchNormElemt

接口原型

功能描述

aclnnBatchNormElemtGetWorkspaceSize

aclnnBatchNormElemt

调用示例

aclnnBatchNormElemtBackward

接口原型

功能描述

aclnnBatchNormElemtBackwardGetWorkspaceSize

aclnnBatchNormElemtBackward

调用示例

aclnnBatchNormGatherStatsWithCounts

接口原型

功能描述

aclnnBatchNormGatherStatsWithCountsGetWorkspaceSize

aclnnBatchNormGatherStatsWithCounts

调用示例

aclnnBatchNormReduceBackward

接口原型

功能描述

aclnnBatchNormReduceBackwardGetWorkspaceSize

aclnnBatchNormReduceBackward

调用示例