aclnnBernoulliTensor/aclnnInplaceBernoulliTensor

aclnnBatchNormStats

接口原型

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

**第一段接口：**aclnnStatus aclnnBatchNormStatsGetWorkspaceSize(const aclTensor *input, double eps, aclTensor *meanOut, aclTensor *invstdOut, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnBatchNormStats(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：计算单卡输入数据的均值和标准差的倒数。多卡BatchNorm场景下实现SyncBatchNorm，需通过aclnnBatchNormStats、aclnnBatchNormGatherStatsWithCounts和aclnnBatchNormElemt算子组合实现。

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

aclnnBatchNormStatsGetWorkspaceSize

接口定义：

aclnnStatus aclnnBatchNormStatsGetWorkspaceSize(const aclTensor *input, double eps, aclTensor *meanOut, aclTensor *invstdOut, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- input：输入张量，Device侧的aclTensor，数据类型支持FLOAT、FLOAT16。支持非连续的Tensor，数据格式五维及以下支持NCDHW、NCHW、NCL、NC，六维到八维支持ND。
- eps：用于防止分母为0，DOUBLE类型数值。
- meanOut：输出均值，Device侧的aclTensor，数据类型支持FLOAT，数据格式支持ND。当输入为FLOAT16时，也会转成FLOAT处理。
- invstdOut：输出标准差倒数，Device侧的aclTensor，数据类型支持FLOAT，数据格式支持ND。当输入为FLOAT16时，也会转成FLOAT处理。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的input、meanOut或invstdOut是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - input、meanOut和invstdOut的数据类型不在支持的范围内。、
  - input维度小于2或大于8，meanOut和invstdOut维度不为1。 :::

aclnnBatchNormStats

接口定义：

aclnnStatus aclnnBatchNormStats(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnBatchNormStatsGetWorkspaceSize获取。
- 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_batch_norm_stats.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> inputShape = {2, 3}; std::vector<int64_t> outShape = {3,}; void* inputDeviceAddr = nullptr; void* meanOutDeviceAddr = nullptr; void* invstdOutDeviceAddr = nullptr; aclTensor* input = nullptr; aclTensor* meanOut = nullptr; aclTensor* invstdOut = nullptr; std::vector<float> inputHostData = {1, 2, 3, 4, 5, 6}; std::vector<float> meanOutHostData = {0, 0, 0}; std::vector<float> invstdOutHostData = {0, 0, 0}; // 创建self aclTensor ret = CreateAclTensor(inputHostData, inputShape, &inputDeviceAddr, aclDataType::ACL_FLOAT, &input); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建meanOut aclTensor ret = CreateAclTensor(meanOutHostData, outShape, &meanOutDeviceAddr, aclDataType::ACL_FLOAT, &meanOut); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建invstdOut aclTensor ret = CreateAclTensor(invstdOutHostData, outShape, &invstdOutDeviceAddr, aclDataType::ACL_FLOAT, &invstdOut); CHECK_RET(ret == ACL_SUCCESS, return ret); // 3. 调用CANN算子库API，需要修改为具体的API名称 double eps = 1e-5; uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnBatchNormStats第一段接口 ret = aclnnBatchNormStatsGetWorkspaceSize(input, eps, meanOut, invstdOut, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNormStatsGetWorkspaceSize 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); } // 调用aclnnBatchNormStats第二段接口 ret = aclnnBatchNormStats(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBatchNormStats 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> meanOutData(size, 0); ret = aclrtMemcpy(meanOutData.data(), meanOutData.size() * sizeof(meanOutData[0]), meanOutDeviceAddr, size * sizeof(meanOutData[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("mean result[%ld] is: %f\n", i, meanOutData[i]); } std::vector<float> invstdOutData(size, 0); ret = aclrtMemcpy(invstdOutData.data(), invstdOutData.size() * sizeof(invstdOutData[0]), invstdOutDeviceAddr, size * sizeof(invstdOutData[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("mean result[%ld] is: %f\n", i, invstdOutData[i]); } // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改 aclDestroyTensor(input); aclDestroyTensor(meanOut); aclDestroyTensor(invstdOut); return 0; }

父主题： NN类算子接口

aclnnBernoulli/aclnnInplaceBernoulli

接口原型

:::note 说明

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

功能描述

算子功能：从伯努利分布中提取二进制随机数（0或1），prob（标量）为生成二进制随机数的概率，输入的张量用于指定形状。
计算公式：

aclnnBernoulliGetWorkspaceSize

接口定义：

aclnnStatus aclnnBernoulliGetWorkspaceSize(const aclTensor *input, const aclScalar *prob, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- input：Device侧的aclTensor，输入张量。数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL，支持非连续的Tensor，数据格式支持ND。
- prob：Host侧的aclScalar，生成二进制随机数的概率。DOUBLE类型数值，取值范围0≤prob≤1，且数据格式要与input一致。
- seed：设置随机数生成器的种子，数据类型支持整型。
- offset：设置随机数偏移量offset，数据类型支持整型。
- out：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL，支持非连续的Tensor，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnBernoulli

接口定义：

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

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

aclnnInplaceBernoulliGetWorkspaceSize

接口定义：

aclnnStatus aclnnInplaceBernoulliGetWorkspaceSize(const aclTensor *input, const aclScalar *prob, int64_t seed, int64_t offset, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- input：Device侧的aclTensor，输入张量。数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL，支持非连续的Tensor，数据格式支持ND。
- prob：Host侧的aclScalar，生成二进制随机数的概率。DOUBLE类型数值，取值范围0≤prob≤1，且数据格式要与input一致。
- seed：设置随机数生成器的种子，数据类型支持INT64。
- offset：设置随机数偏移量offset，数据类型支持INT64。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnInplaceBernoulli

接口定义：

aclnnStatus aclnnInplaceBernoulli(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnInplaceBernoulliGetWorkspaceSize获取。
- 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 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_bernoulli.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> selfShape = {4, 2}; std::vector<int64_t> outShape = {4, 2}; void* selfDeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* self = nullptr; aclScalar* prob= nullptr; aclTensor* out = nullptr; std::vector<float> selfHostData = {0, 1, 2, 3, 4, 5, 6, 7}; std::vector<float> outHostData = {0, 0, 0, 0, 0, 0, 0, 0}; float probValue = 1.2f; int64_t seed = 1; int64_t offset = 1; // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建prob aclScalar prob = aclCreateScalar(&probValue, aclDataType::ACL_FLOAT); CHECK_RET(prob != nullptr, 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; // 调用aclnnBernoulli第一段接口 ret = aclnnBernoulliGetWorkspaceSize(self, prob, seed, offset, out, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBernoulliGetWorkspaceSize 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;); } // 调用aclnnBernoulli第二段接口 ret = aclnnBernoulli(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBernoulli 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(self); aclDestroyScalar(prob); aclDestroyTensor(out); return 0; }

父主题： NN类算子接口

aclnnBernoulliTensor/aclnnInplaceBernoulliTensor

接口原型

:::note 说明

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

功能描述

算子功能：从伯努利分布中提取二进制随机数（0 或 1），prob（张量）为生成二进制随机数的概率，输入的张量用于指定形状。
计算公式：

aclnnBernoulliTensorGetWorkspaceSize

接口定义：

aclnnStatus aclnnBernoulliTensorGetWorkspaceSize(const aclTensor *input, const aclTensor *prob, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- input：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL，支持非连续的Tensor，数据格式支持ND。
- prob：Device侧的aclTensor，指定二进制随机数的概率，满足0≤prob≤1，数据类型支持FLOAT16、FLOAT、DOUBLE。shape需要与input满足broadcast关系，支持非连续的Tensor，数据格式支持ND。
- seed：随机数生成器的种子，它影响生成的随机数序列，输入为INT64数据类型。
- offset：随机数生成器的偏移量，它影响生成的随机数序列的位置，输入为INT64数据类型。
- out：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL。支持非连续的Tensor，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnBernoulliTensor

接口定义：

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

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

aclnnInplaceBernoulliTensorGetWorkspaceSize

接口定义：

aclnnStatus aclnnInplaceBernoulliTensorGetWorkspaceSize(const aclTensor *input, const aclTensor *prob, int64_t seed, int64_t offset, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- input：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT16、INT8、UINT8、BOOL，支持非连续的Tensor，数据格式支持ND。
- prob：Device侧的aclTensor，指定二进制随机数的概率，满足0≤prob≤1，数据类型支持FLOAT16、FLOAT、DOUBLE。shape需要与input满足broadcast关系，支持非连续的Tensor，数据格式支持ND。
- seed：随机数生成器的种子，它影响生成的随机数序列，输入为INT64数据类型。
- offset：随机数生成器的偏移量，它影响生成的随机数序列的位置，输入为INT64数据类型。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnInplaceBernoulliTensor

接口定义：

aclnnStatus aclnnInplaceBernoulliTensor(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnInplaceBernoulliTensorGetWorkspaceSize获取。
- 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 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_bernoulli.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> selfShape = {4, 2}; std::vector<int64_t> probShape = {4, 2}; std::vector<int64_t> outShape = {4, 2}; void* selfDeviceAddr = nullptr; void* probDeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* self = nullptr; aclTensor* prob= nullptr; aclTensor* out = nullptr; std::vector<float> selfHostData = {0, 1, 2, 3, 4, 5, 6, 7}; std::vector<float> probHostData = {0, 0, 0, 0, 0, 0, 0, 0}; std::vector<float> outHostData = {0, 0, 0, 0, 0, 0, 0, 0}; int64_t seed = 1; int64_t offset = 1; // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建prob aclTensor ret = CreateAclTensor(probHostData , probShape, &probDeviceAddr, aclDataType::ACL_FLOAT, &prob); CHECK_RET(prob != nullptr, 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; // 调用aclnnBernoulliTensor第一段接口 ret = aclnnBernoulliTensorGetWorkspaceSize(self, prob, seed, offset, out, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBernoulliTensorGetWorkspaceSize 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;); } // 调用aclnnBernoulliTensor第二段接口 ret = aclnnBernoulliTensor(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBernoulli 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(self); aclDestroyTensor(prob); aclDestroyTensor(out); return 0; }

父主题： NN类算子接口

aclnnBinaryCrossEntropy

接口原型

第一段接口：aclnnStatus aclnnBinaryCrossEntropyGetWorkspaceSize(const aclTensor *self, const aclTensor *target, const aclTensor *weight, const int64_t reduction, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnBinaryCrossEntropy(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：计算张量self和张量target的二元交叉熵。
计算公式：

当reduction不为none时，公式如下：

aclnnBinaryCrossEntropyGetWorkspaceSize

接口定义：

aclnnStatus aclnnBinaryCrossEntropyGetWorkspaceSize(const aclTensor *self, const aclTensor *target, const aclTensor *weight, const int64_t reduction, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，表示一个概率分布。数据类型支持FLOAT16、FLOAT，数据格式支持ND，取值在0~1之间。
- target：Device侧的aclTensor，表示一个概率分布。数据类型支持FLOAT16、FLOAT，shape和数据类型需要与self一致，数据格式支持ND，取值在0~1之间。
- weight：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT，shape需要能够broadcast到self，且数据类型需要与self一致，数据格式支持ND。weight可以是nullptr，等价于所有权重值都是1。
- reduction：Host侧的int64_t，输出归约的枚举值，支持3种枚举值：当取值为0，即为"none"；当取值为1，即为"mean"；当取值为2，即为"sum"。
- out：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT，且数据类型需要与self一致。当reduction=0（“none”）时，shape与self一致，其他情况shape为[1]，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnBinaryCrossEntropy

接口定义：

aclnnStatus aclnnBinaryCrossEntropy(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnBinaryCrossEntropyGetWorkspaceSize获取。
- 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_binary_cross_entropy.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> selfShape = {2, 2}; std::vector<int64_t> targetShape = {2, 2}; std::vector<int64_t> weightShape = {2, 2}; std::vector<int64_t> outShape = {2, 2}; void* selfDeviceAddr = nullptr; void* targetDeviceAddr = nullptr; void* weightDeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* self = nullptr; aclTensor* target = nullptr; aclTensor* weight = nullptr; aclTensor* out = nullptr; std::vector<float> selfHostData = {0.3, 0.3, 0.3, 0.3}; std::vector<float> targetHostData = {0.5, 0.5, 0.5, 0.5}; std::vector<float> weightHostData = {1, 1, 1, 1}; std::vector<float> outHostData = {0, 0, 0, 0}; // 创建self aclTensor ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建target aclTensor ret = CreateAclTensor(targetHostData, targetShape, &targetDeviceAddr, aclDataType::ACL_FLOAT, &target); // 创建weight aclTensor ret = CreateAclTensor(weightHostData, weightShape, &weightDeviceAddr, aclDataType::ACL_FLOAT, &weight); 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); int64_t reduction = 0; // 3. 调用CANN算子库API uint64_t workspaceSize = 0; aclOpExecutor* executor; // 调用aclnnBinaryCrossEntropy第一段接口 ret = aclnnBinaryCrossEntropyGetWorkspaceSize(self, target, weight, reduction, out, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBinaryCrossEntropyGetWorkspaceSize 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;); } // 调用aclnnBinaryCrossEntropy第二段接口 ret = aclnnBinaryCrossEntropy(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBinaryCrossEntropy 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(self); aclDestroyTensor(target); aclDestroyTensor(weight); aclDestroyTensor(out); return 0; }

父主题： NN类算子接口

aclnnBinaryCrossEntropyBackward

接口原型

第一段接口：aclnnStatus aclnnBinaryCrossEntropyBackwardGetWorkspaceSize(const aclTensor *gradOutput, const aclTensor *self, const aclTensor *target, const aclTensor *weightOptional, int64_t reduction, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnBinaryCrossEntropyBackward(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：求二元交叉熵函数aclnnBinaryCrossEntropy反向传播的梯度值。
计算公式：

已知二元交叉熵的计算公式如下：

其中x表示网络前一层的输出，即正向的预测值；target表示样本的标签值，求二元交叉熵对x的偏导：

再计算输出向量：

aclnnBinaryCrossEntropyBackwardGetWorkspaceSize

接口定义：

aclnnStatus aclnnBinaryCrossEntropyBackwardGetWorkspaceSize(const aclTensor *gradOutput, const aclTensor *self, const aclTensor *target, const aclTensor *weightOptional, int64_t reduction, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- gradOutput：网络反向传播前一步的梯度值，Device侧的aclTensor。数据类型支持FLOAT16、FLOAT，且数据类型需要与其它参数一起转换到promotion类型，shape可以broadcast到self的shape，支持非连续的Tensor，数据格式支持ND。
- self：网络正向前一层的计算结果，Device侧的aclTensor。数据类型支持FLOAT16、FLOAT，且数据类型需要与其它参数一起转换到promotion类型，支持非连续的Tensor，数据格式支持ND。
- target：样本的标签值，取值范围0或1，Device侧的aclTensor。数据类型支持FLOAT16、FLOAT，且数据类型需要与其它参数一起转换到promotion类型，shape可以broadcast到self的shape，支持非连续的Tensor，数据格式支持ND。
- weightOptional：结果的权重，可选参数，Device侧的aclTensor。数据类型支持FLOAT16、FLOAT，且数据类型需要与其它参数一起转换到promotion类型，shape可以broadcast到self的shape，支持非连续的Tensor，数据格式支持ND。当weightOptional为空时，需要以self的shape调用Level0的ones接口创建一个全1的Tensor。
- reduction：表示对二元交叉熵反向求梯度计算结果做的reduce操作，仅支持0、1、2三个值，0表示不做任何操作（none）；1表示对结果取平均值（mean）；2表示对结果求和（sum）。
- out：存储梯度计算结果，Device侧的aclTensor，数据类型支持FLOAT16、FLOAT，shape与self相同，数据格式支持ND，且数据格式需要与self一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的gradOutput、self、target、out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - gradOutput、self、target、out的数据类型不在支持的范围内。
  - gradOutput、self、target、weightOptional的数据类型不同。
  - gradOutput、target和weightOptional的shape不能broadcast到self的shape。
  - reduction取值不是0、1、2三者之一。
  - gradOutput、self、target、weightOptional的shape维度大于8。 :::

aclnnBinaryCrossEntropyBackward

接口定义：

aclnnStatus aclnnBinaryCrossEntropyBackward(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)
参数说明：
- workspace：在Device侧申请的workspace内存起址。
- workspaceSize：在Device侧申请的workspace大小，由第一段接口aclnnBinaryCrossEntropyBackwardGetWorkspaceSize获取。
- 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 cpp #include <iostream> #include <vector> #include "acl/acl.h" #include "aclnnop/aclnn_binary_cross_entropy_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> gradOutputShape = {4, 2}; std::vector<int64_t> selfShape = {4, 2}; std::vector<int64_t> targetShape = {4, 2}; std::vector<int64_t> weightShape = {4, 2}; std::vector<int64_t> outShape = {4, 2}; void* gradOutputDeviceAddr = nullptr; void* selfDeviceAddr = nullptr; void* targetDeviceAddr = nullptr; void* weightDeviceAddr = nullptr; void* outDeviceAddr = nullptr; aclTensor* gradOutput = nullptr; aclTensor* self = nullptr; aclTensor* target = nullptr; aclTensor* weight = nullptr; aclTensor* out = nullptr; std::vector<float> gradOutputHostData = {0.1, 0.1, 0.1, 0.1, 0.2, 0.2, 0.2, 0.2}; std::vector<float> selfHostData = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8}; std::vector<float> targetHostData = {1, 1, 1, 0, 0, 0, 1, 1}; std::vector<float> weightHostData = {2, 2, 2, 2, 2, 2, 2, 2}; std::vector<float> outHostData = {0, 0, 0, 0, 0, 0, 0, 0}; // 创建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); // 创建target aclTensor ret = CreateAclTensor(targetHostData, targetShape, &targetDeviceAddr, aclDataType::ACL_FLOAT, &target); CHECK_RET(ret == ACL_SUCCESS, return ret); // 创建weight aclTensor ret = CreateAclTensor(weightHostData, weightShape, &weightDeviceAddr, aclDataType::ACL_FLOAT, &weight); 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; // 调用aclnnBinaryCrossEntropyBackward第一段接口 ret = aclnnBinaryCrossEntropyBackwardGetWorkspaceSize(gradOutput, self, target, weight, 0, out, &workspaceSize, &executor); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBinaryCrossEntropyBackwardGetWorkspaceSize 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;); } // 调用aclnnBinaryCrossEntropyBackward第二段接口 ret = aclnnBinaryCrossEntropyBackward(workspaceAddr, workspaceSize, executor, stream); CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnBinaryCrossEntropyBackward 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，需要根据具体API的接口定义修改 aclDestroyTensor(gradOutput); aclDestroyTensor(self); aclDestroyTensor(target); aclDestroyTensor(weight); aclDestroyTensor(out); return 0; }

父主题： NN类算子接口

在线提单

aclnnBatchNormStats​

接口原型​

功能描述​

aclnnBatchNormStatsGetWorkspaceSize​

aclnnBatchNormStats​

调用示例​

aclnnBernoulli/aclnnInplaceBernoulli​

接口原型​

功能描述​

aclnnBernoulliGetWorkspaceSize​

aclnnBernoulli​

aclnnInplaceBernoulliGetWorkspaceSize​

aclnnInplaceBernoulli​

调用示例​

aclnnBernoulliTensor/aclnnInplaceBernoulliTensor​

接口原型​

功能描述​

aclnnBernoulliTensorGetWorkspaceSize​

aclnnBernoulliTensor​

aclnnInplaceBernoulliTensorGetWorkspaceSize​

aclnnInplaceBernoulliTensor​

调用示例​

aclnnBinaryCrossEntropy​

接口原型​

功能描述​

aclnnBinaryCrossEntropyGetWorkspaceSize​

aclnnBinaryCrossEntropy​

调用示例​

aclnnBinaryCrossEntropyBackward​

接口原型​

功能描述​

aclnnBinaryCrossEntropyBackwardGetWorkspaceSize​

aclnnBinaryCrossEntropyBackward​

调用示例​

aclnnBatchNormStats

接口原型

功能描述

aclnnBatchNormStatsGetWorkspaceSize

aclnnBatchNormStats

调用示例

aclnnBernoulli/aclnnInplaceBernoulli

接口原型

功能描述

aclnnBernoulliGetWorkspaceSize

aclnnBernoulli

aclnnInplaceBernoulliGetWorkspaceSize

aclnnInplaceBernoulli

调用示例

aclnnBernoulliTensor/aclnnInplaceBernoulliTensor

接口原型

功能描述

aclnnBernoulliTensorGetWorkspaceSize

aclnnBernoulliTensor

aclnnInplaceBernoulliTensorGetWorkspaceSize

aclnnInplaceBernoulliTensor

调用示例

aclnnBinaryCrossEntropy

接口原型

功能描述

aclnnBinaryCrossEntropyGetWorkspaceSize

aclnnBinaryCrossEntropy

调用示例

aclnnBinaryCrossEntropyBackward

接口原型

功能描述

aclnnBinaryCrossEntropyBackwardGetWorkspaceSize

aclnnBinaryCrossEntropyBackward

调用示例