aclnnPrelu

aclnnPowScalarTensor

接口原型

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

第一段接口：aclnnStatus aclnnPowScalarTensorGetWorkspaceSize(const aclScalar* self, const aclTensor* exponent, aclTensor* out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnPowScalarTensor(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：以exponent每个元素作为self对应元素的幂进行计算。
计算公式：

aclnnPowScalarTensorGetWorkspaceSize

接口定义：

aclnnStatus aclnnPowScalarTensorGetWorkspaceSize(const aclScalar* self, const aclTensor* exponent, aclTensor* out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Host侧的aclScalar，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT8、UINT8、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持）。数据类型与exponent的数据类型需满足数据类型推导规则。
- exponent：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT8、UINT8、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持）。数据类型与self的数据类型需满足数据类型推导规则，支持非连续的Tensor，数据格式支持ND。
- out：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT8、UINT8、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要是self与exponent推导之后可转换的数据类型，shape需要与exponent的shape一致。支持非连续的Tensor。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、exponent、out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - exponent的数据类型和数据格式不在支持的范围内。
  - 推导出的数据类型无法转换为指定输出out的类型。
  - exponent和out的shape不一致。 :::

aclnnPowScalarTensor

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_pow.h"

#define CHECK_RET(cond, return_expr) \
  do &#123;                               \
    if (!(cond)) &#123;                   \
      return_expr;                   \
    &#125;                                \
  &#125; while (0)

#define LOG_PRINT(message, ...)     \
  do &#123;                              \
    printf(message, ##__VA_ARGS__); \
  &#125; while (0)

int64_t GetShapeSize(const std::vector<int64_t>& shape) &#123;
  int64_t shape_size = 1;
  for (auto i : shape) &#123;
    shape_size *= i;
  &#125;
  return shape_size;
&#125;

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** devicePowr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  auto size = GetShapeSize(shape) * sizeof(T);
  // 调用aclrtMalloc申请device侧内存
  auto ret = aclrtMalloc(devicePowr, 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(*devicePowr, 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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

  // 调用aclCreateTensor接口创建aclTensor
  *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND,
                            shape.data(), shape.size(), *devicePowr);
  return 0;
&#125;

int main() &#123;
  // 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> exponentShape = &#123;4, 2&#125;;
  std::vector<int64_t> outShape = &#123;4, 2&#125;;
  void* exponentDevicePowr = nullptr;
  void* outDevicePowr = nullptr;
  aclScalar* self = nullptr;
  aclTensor* exponent = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> exponentHostData = &#123;1, 1, 1, 2, 2, 2, 3, 3&#125;;
  std::vector<float> outHostData = &#123;0, 0, 0, 0, 0, 0, 0, 0&#125;;
  float selfValue = 1.2f;
  // 创建exponent aclTensor
  ret = CreateAclTensor(exponentHostData, exponentShape, &exponentDevicePowr, aclDataType::ACL_FLOAT, &exponent);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建self aclScalar
  self = aclCreateScalar(&selfValue, aclDataType::ACL_FLOAT);
  CHECK_RET(self != nullptr, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outHostData, outShape, &outDevicePowr, aclDataType::ACL_FLOAT, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3.调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnPowScalarTensor第一段接口
  ret = aclnnPowScalarTensorGetWorkspaceSize(self, exponent, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnPowScalarTensorGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspacePowr = nullptr;
  if (workspaceSize > 0) &#123;
    ret = aclrtMalloc(&workspacePowr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret;);
  &#125;
  // 调用aclnnPowScalarTensor第二段接口
  ret = aclnnPowScalarTensor(workspacePowr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnPowScalarTensor 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]), outDevicePowr, 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++) &#123;
    LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]);
  &#125;

  // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改
  aclDestroyScalar(self);
  aclDestroyTensor(exponent);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnPowTensorScalar

接口原型

第一段接口：aclnnStatus aclnnPowTensorScalarGetWorkspaceSize(const aclTensor* self, const aclScalar* exponent, aclTensor* out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnPowTensorScalar(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：将exponent每个元素作为对应输入元素的幂完成计算。
计算公式：

aclnnPowTensorScalarGetWorkspaceSize

接口定义：

aclnnStatus aclnnPowTensorScalarGetWorkspaceSize(const aclTensor* self, const aclScalar* exponent, aclTensor* out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT8、UINT8、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持）。支持非连续的Tensor，数据格式支持ND。
- exponent：Host侧的aclScalar，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT8、UINT8、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持）。
- out：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT8、UINT8、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型、数据格式和shape需要与self一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、exponent、out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self的数据类型和数据格式不在支持的范围内。
  - 推导出的数据类型无法转换为指定输出out的类型。
  - self和out的shape不一致。 :::

aclnnPowTensorScalar

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_pow.h"

#define CHECK_RET(cond, return_expr) \
  do &#123;                               \
    if (!(cond)) &#123;                   \
      return_expr;                   \
    &#125;                                \
  &#125; while (0)

#define LOG_PRINT(message, ...)     \
  do &#123;                              \
    printf(message, ##__VA_ARGS__); \
  &#125; while (0)

int64_t GetShapeSize(const std::vector<int64_t>& shape) &#123;
  int64_t shape_size = 1;
  for (auto i : shape) &#123;
    shape_size *= i;
  &#125;
  return shape_size;
&#125;

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

  // 调用aclCreateTensor接口创建aclTensor
  *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND,
                            shape.data(), shape.size(), *deviceAddr);
  return 0;
&#125;

int main() &#123;
  // 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 = &#123;4, 2&#125;;
  std::vector<int64_t> outShape = &#123;4, 2&#125;;
  void* selfDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclScalar* exponent = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = &#123;0, 1, 2, 3, 4, 5, 6, 7&#125;;
  std::vector<float> outHostData = &#123;0, 0, 0, 0, 0, 0, 0, 0&#125;;
  float exponentValue = 2.0f;
  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  exponent = aclCreateScalar(&exponentValue, aclDataType::ACL_FLOAT);

  // 3.调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnPowTensorScalar第一段接口
  ret = aclnnPowTensorScalarGetWorkspaceSize(self, exponent, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnPowTensorScalarGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) &#123;
    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;);
  &#125;
  // 调用aclnnPowTensorScalar第二段接口
  ret = aclnnPowTensorScalar(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnPowTensorScalar 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++) &#123;
    LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]);
  &#125;

  // 6. 释放aclTensor，需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyScalar(exponent);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnPowTensorTensor

接口原型

第一段接口：aclnnStatus aclnnPowTensorTensorGetWorkspaceSize(const aclTensor* self, const aclTensor* exponent, aclTensor* out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnPowTensorTensor(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：将exponent每个元素作为对应输入元素的幂完成计算。
计算公式：

aclnnPowTensorTensorGetWorkspaceSize

接口定义：

aclnnStatus aclnnPowTensorTensorGetWorkspaceSize(const aclTensor* self, const aclTensor* exponent, aclTensor* out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT8、UINT8、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要与exponent构成互推导关系，shape需要与exponent满足broadcast关系。支持非连续的Tensor，数据格式支持ND。
- exponent：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT8、UINT8、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要与self构成互推导关系，shape需要与self满足broadcast关系。支持非连续的Tensor，数据格式支持ND。
- out：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、DOUBLE、INT32、INT64、INT8、UINT8、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型需要是self与exponent推导之后可转换的数据类型，shape为self与exponent两者broadcast之后的shape。支持非连续的Tensor，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnPowTensorTensor

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_pow_tensor_tensor.h"

#define CHECK_RET(cond, return_expr) \
  do &#123;                               \
    if (!(cond)) &#123;                   \
      return_expr;                   \
    &#125;                                \
  &#125; while (0)

#define LOG_PRINT(message, ...)     \
  do &#123;                              \
    printf(message, ##__VA_ARGS__); \
  &#125; while (0)

int64_t GetShapeSize(const std::vector<int64_t>& shape) &#123;
  int64_t shape_size = 1;
  for (auto i : shape) &#123;
    shape_size *= i;
  &#125;
  return shape_size;
&#125;

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

  // 调用aclCreateTensor接口创建aclTensor
  *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND,
                            shape.data(), shape.size(), *deviceAddr);
  return 0;
&#125;

int main() &#123;
  // 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 = &#123;4, 2&#125;;
  std::vector<int64_t> exponentShape = &#123;4, 2&#125;;
  std::vector<int64_t> outShape = &#123;4, 2&#125;;
  void* selfDeviceAddr = nullptr;
  void* exponentDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* exponent = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = &#123;0, 1, 2, 3, 4, 5, 6, 7&#125;;
  std::vector<float> exponentHostData = &#123;1, 2, 7, 3, 2, 7, 9, 7&#125;;
  std::vector<float> outHostData = &#123;0, 0, 0, 0, 0, 0, 0, 0&#125;;
  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建exponent aclTensor
  ret = CreateAclTensor(exponentHostData, exponentShape, &exponentDeviceAddr, aclDataType::ACL_FLOAT, &exponent);
  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;
  // 调用aclnnPowTensorTensor第一段接口
  ret = aclnnPowTensorTensorGetWorkspaceSize(self, exponent, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnPowTensorTensorGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) &#123;
    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;);
  &#125;
  // 调用aclnnPowTensorTensor第二段接口
  ret = aclnnPowTensorTensor(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnPowTensorTensor 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++) &#123;
    LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]);
  &#125;

  // 6. 释放aclTensor，需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyTensor(exponent);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnPrelu

接口原型

第一段接口：aclnnStatus aclnnPreluGetWorkspaceSize(const aclTensor *self, aclTensor *weight, aclTensor *out，uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnPrelu(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：激活函数。若张量中value≥0，则取该value；若value<0，则取权重与value的乘积。
计算公式：

aclnnPreluGetWorkspaceSize

接口定义：

aclnnStatus aclnnPreluGetWorkspaceSize(const aclTensor *self, aclTensor *weight, aclTensor *out，uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16，且数据类型需要与weight构成互推导关系。支持非连续的Tensor，数据格式支持ND。
- weight：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16。支持非连续的Tensor，数据格式支持ND，元素个数需要与self第二维度保持一致。
- out：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16，shape需要与self保持一致。支持非连续的Tensor，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnPrelu

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_prelu.h"

#define CHECK_RET(cond, return_expr) \
  do &#123;                               \
    if (!(cond)) &#123;                   \
      return_expr;                   \
    &#125;                                \
  &#125; while (0)

#define LOG_PRINT(message, ...)     \
  do &#123;                              \
    printf(message, ##__VA_ARGS__); \
  &#125; while (0)

int64_t GetShapeSize(const std::vector<int64_t>& shape) &#123;
  int64_t shapeSize = 1;
  for (auto i : shape) &#123;
    shapeSize *= i;
  &#125;
  return shapeSize;
&#125;

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

  // 调用aclCreateTensor接口创建aclTensor
  *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND,
                            shape.data(), shape.size(), *deviceAddr);
  return 0;
&#125;

int main() &#123;
  // 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 = &#123;2, 4&#125;;
  std::vector<int64_t> weightShape = &#123;1&#125;;
  std::vector<int64_t> outShape = &#123;2, 4&#125;;
  void* selfDeviceAddr = nullptr;
  void* weightDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* weight = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = &#123;-2, 1, 2, -3, -4.7, 5.3, -6.9, 7&#125;;
  std::vector<float> weightHostData = &#123;3&#125;;
  std::vector<float> outHostData = &#123;0, 0, 0, 0, 0, 0, 0, 0&#125;;

  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  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;
  // 调用aclnnPrelu第一段接口
  ret = aclnnPreluGetWorkspaceSize(self, weight, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnPreluGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) &#123;
    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;);
  &#125;
  // 调用aclnnPrelu第二段接口
  ret = aclnnPrelu(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnPrelu 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++) &#123;
    LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]);
  &#125;

  // 6. 释放aclTensor，需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyTensor(weight);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnPreluBackward

接口原型

**第一段接口：**aclnnStatus aclnnPreluBackwardGetWorkspaceSize(const aclTensor *gradOutput, const aclTensor *self, const aclTensor *weight, aclTensor *gradIntput, aclTensor *gradWeight, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnPreluBackward(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：激活函数PReLU（aclnnPrelu）的反向计算。
计算公式：

gradInput的计算公式如下：

gradWeight的计算公式如下：

aclnnPreluBackwardGetWorkspaceSize

接口定义：

aclnnStatus aclnnPreluBackwardGetWorkspaceSize(const aclTensor *gradOutput, const aclTensor *self, const aclTensor *weight, aclTensor *gradIntput, aclTensor *gradWeight, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- gradOutput：Device侧的aclTensor，输入张量，反向传播的梯度值，数据类型支持FLOAT、FLOAT16，支持非连续的Tensor，数据格式支持ND。
- self：Device侧的aclTensor，输入张量，prelu正向的输入，数据类型支持FLOAT、FLOAT16，支持非连续的Tensor，数据格式支持ND。
- weight：Device侧的aclTensor，输入张量，prelu的权重，数据类型支持FLOAT、FLOAT16，支持非连续的Tensor，数据格式支持ND，且元素个数必须等于self的通道数或者1。
- gradIntput：Device侧的aclTensor，输出张量，是self的反向梯度，与self的维度和数据类型相同。
- gradWeight：Device侧的aclTensor，输出张量，是weight的反向梯度，数据类型支持FLOAT16、FLOAT32。支持非连续的Tensor，数据格式支持ND，需要与weight的数据类型相同，weight的元素个数为1时，shape需要与weight相同；weight元素个数不为1时，需要为1维Tensor，且元素个数与weight的元素个数相同。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的gradOutput、self、weight、gradInput、gradWeight是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - gradOutput、self、weight、gradInput、gradWeight的数据类型不在支持的范围之内。
  - gradOutput、self、weight、gradInput、gradWeight数据类型不同。
  - gradOutput、self、weight、gradInput、gradWeight维度超过8。
  - weight的元素个数不等于self的通道数或者1。
  - weight的元素个数为1时，gradWeight的shape与weight不相同。 :::

aclnnPreluBackward

接口定义：

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

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

调用示例

#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_prelu_backward.h"

#define CHECK_RET(cond, return_expr) \
  do &#123;                               \
    if (!(cond)) &#123;                   \
      return_expr;                   \
    &#125;                                \
  &#125; while (0)

#define LOG_PRINT(message, ...)     \
  do &#123;                              \
    printf(message, ##__VA_ARGS__); \
  &#125; while (0)

int64_t GetShapeSize(const std::vector<int64_t>& shape) &#123;
  int64_t shape_size = 1;
  for (auto i : shape) &#123;
    shape_size *= i;
  &#125;
  return shape_size;
&#125;

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

  // 调用aclCreateTensor接口创建aclTensor
  *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND,
                            shape.data(), shape.size(), *deviceAddr);
  return 0;
&#125;

int main() &#123;
  // 1. （固定写法）device/context/stream初始化, 参考AscendCL对外接口列表
  // 根据自己的实际device填写deviceId
  int32_t deviceId = 0;
  aclrtContext context;
  aclrtStream stream;
  auto ret = Init(deviceId, &context, &stream);
  // check根据自己的需要处理
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

  // 2. 构造输入与输出，需要根据API的接口自定义构造
  std::vector<int64_t> selfShape = &#123;4, 2&#125;;
  std::vector<int64_t> weightShape = &#123;2&#125;;
  std::vector<int64_t> gradOutputShape = &#123;4, 2&#125;;
  std::vector<int64_t> gradInputShape = &#123;4, 2&#125;;
  std::vector<int64_t> gradWeightShape = &#123;2&#125;;

  void* selfDeviceAddr = nullptr;
  void* gradOutputDeviceAddr = nullptr;
  void* weightDeviceAddr = nullptr;
  void* gradInputDeviceAddr = nullptr;
  void* gradWeightDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* weight = nullptr;
  aclTensor* gradOutput = nullptr;
  aclTensor* gradInput = nullptr;
  aclTensor* gradWeight = nullptr;

  std::vector<float> selfHostData = &#123;0, 1, 2, 3, 4, 5, 6, 7&#125;;
  std::vector<float> weightHostData = &#123;0.5, 0.5&#125;;
  std::vector<float> gradOutputHostData = &#123;1, 1, 1, 1, 1, 1, 1, 1&#125;;
  std::vector<float> gradInputHostData = &#123;0, 0, 0, 0, 0, 0, 0, 0&#125;;
  std::vector<float> gradWeightHostData = &#123;0, 0&#125;;

  // 创建weight aclTensor
  ret = CreateAclTensor(weightHostData, weightShape, &weightDeviceAddr, aclDataType::ACL_FLOAT, &weight);
  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);
  // 创建gradOutput aclTensor
  ret = CreateAclTensor(gradOutputHostData, gradOutputShape, &gradOutputDeviceAddr, aclDataType::ACL_FLOAT,
  &gradOutput);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建gradInput aclTensor
  ret = CreateAclTensor(gradInputHostData, gradInputShape, &gradInputDeviceAddr, aclDataType::ACL_FLOAT, &gradInput);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建gradWeight aclTensor
  ret = CreateAclTensor(gradWeightHostData, gradWeightShape, &gradWeightDeviceAddr, aclDataType::ACL_FLOAT, &gradWeight);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3. 调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnPreluBackward第一段接口
  ret = aclnnPreluBackwardGetWorkspaceSize(gradOutput, self, weight, gradInput, gradWeight, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnPreluBackwardGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) &#123;
    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);
  &#125;
  // 调用aclnnPreluBackward第二段接口
  ret = aclnnPreluBackward(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnPreluBackward 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 gradInputSize = GetShapeSize(gradInputShape);
  std::vector<float> gradInputResultData(gradInputSize, 0);
  ret = aclrtMemcpy(gradInputResultData.data(), gradInputResultData.size() * sizeof(gradInputResultData[0]), gradInputDeviceAddr, gradInputSize * 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 < gradInputSize; i++) &#123;
    LOG_PRINT("gradInput[%ld] is: %f\n", i, gradInputResultData[i]);
  &#125;

  auto gradWeightSize = GetShapeSize(gradWeightShape);
  std::vector<float> gradWeightResultData(gradWeightSize, 0);
  ret = aclrtMemcpy(gradWeightResultData.data(), gradWeightResultData.size() * sizeof(gradWeightResultData[0]), gradWeightDeviceAddr, gradWeightSize * 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 < gradWeightSize; i++) &#123;
    LOG_PRINT("gradWeight[%ld] is: %f\n", i, gradWeightResultData[i]);
  &#125;

  // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改
  aclDestroyTensor(gradOutput);
  aclDestroyTensor(self);
  aclDestroyTensor(weight);
  aclDestroyTensor(gradInput);
  aclDestroyTensor(gradWeight);

  // 7. 释放device资源， 需要根据具体API的接口定义修改
  aclrtFree(selfDeviceAddr);
  aclrtFree(gradOutputDeviceAddr);
  aclrtFree(weightDeviceAddr);
  aclrtFree(gradInputDeviceAddr);
  aclrtFree(gradWeightDeviceAddr);
  if (workspaceSize > 0) &#123;
    aclrtFree(workspaceAddr);
  &#125;
  aclrtDestroyStream(stream);
  aclrtDestroyContext(context);
  aclrtResetDevice(deviceId);
  aclFinalize();

  return 0;
&#125;

父主题： NN类算子接口

aclnnProd

接口原型

第一段接口：aclnnStatus aclnnProdGetWorkspaceSize(const aclTensor *self, const aclDataType dtype, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnProd(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：计算输入张量self中元素的乘积。

aclnnProdGetWorkspaceSize

接口定义：

aclnnStatus aclnnProdGetWorkspaceSize(const aclTensor *self, const aclDataType dtype, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、DOUBLE、INT8、UINT8、INT16、INT32、INT64、BOOL、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持）。支持非连续的Tensor，数据格式支持ND。
- dtype：Host侧的aclDataType，输出张量的数据类型，需要与out的数据类型一致。
- out：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、DOUBLE、INT8、UINT8、INT16、INT32、INT64、BOOL、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型与dtype一致。支持非连续的Tensor，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnProd

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_prod.h"

#define CHECK_RET(cond, return_expr) \
  do &#123;                               \
    if (!(cond)) &#123;                   \
      return_expr;                   \
    &#125;                                \
  &#125; while (0)

#define LOG_PRINT(message, ...)     \
  do &#123;                              \
    printf(message, ##__VA_ARGS__); \
  &#125; while (0)

int64_t GetShapeSize(const std::vector<int64_t>& shape) &#123;
  int64_t shape_size = 1;
  for (auto i : shape) &#123;
    shape_size *= i;
  &#125;
  return shape_size;
&#125;

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

  // 调用aclCreateTensor接口创建aclTensor
  *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND,
                            shape.data(), shape.size(), *deviceAddr);
  return 0;
&#125;

int main() &#123;
  // 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 = &#123;4, 2&#125;;
  std::vector<int64_t> outShape = &#123;1&#125;;
  void* selfDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = &#123;0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1&#125;;
  std::vector<float> outHostData = &#123;0.0&#125;;
  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3.调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnProd第一段接口
  ret = aclnnProdGetWorkspaceSize(self, aclDataType::ACL_FLOAT, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnProdGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) &#123;
    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;);
  &#125;
  // 调用aclnnProd第二段接口
  ret = aclnnProd(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnProd 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++) &#123;
    LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]);
  &#125;

  // 6. 释放aclTensor和aclIntArray，需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnProdDim

接口原型

第一段接口：aclnnStatus aclnnProdDimGetWorkspaceSize(const aclTensor *self, int64_t dim, bool keepDim, const aclDataType dtype, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnProdDim(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：计算输入张量self在指定维度上每行的乘积。

aclnnProdDimGetWorkspaceSize

接口定义：

aclnnStatus aclnnProdDimGetWorkspaceSize(const aclTensor *self, int64_t dim, bool keepDim, const aclDataType dtype, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、DOUBLE、INT8、UINT8、INT16、INT32、INT64、BOOL、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持）。支持非连续的Tensor，数据格式支持ND。
- dim：Host侧的int64，指定要缩减的维度，取值范围为[-self.dim(), self.dim())。
- keepDim：Host侧的bool，输出张量是否保留维度。
- dtype：Host侧的aclDataType，输出张量的数据类型，需要与out的数据类型一致。
- out：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT、DOUBLE、INT8、UINT8、INT16、INT32、INT64、BOOL、COMPLEX64、COMPLEX128、BFLOAT16（仅Atlas A2训练系列产品支持），且数据类型与dtype一致。支持非连续的Tensor，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self的数据类型不在支持的范围内。
  - self或out的shape超过8维。
  - dim取值不在支持的范围内。
  - dtype与out的dtype不一致。 :::

aclnnProdDim

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_prod.h"

#define CHECK_RET(cond, return_expr) \
  do &#123;                               \
    if (!(cond)) &#123;                   \
      return_expr;                   \
    &#125;                                \
  &#125; while (0)

#define LOG_PRINT(message, ...)     \
  do &#123;                              \
    printf(message, ##__VA_ARGS__); \
  &#125; while (0)

int64_t GetShapeSize(const std::vector<int64_t>& shape) &#123;
  int64_t shape_size = 1;
  for (auto i : shape) &#123;
    shape_size *= i;
  &#125;
  return shape_size;
&#125;

int Init(int32_t deviceId, aclrtContext* context, aclrtStream* stream) &#123;
  // 固定写法，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;
&#125;

template <typename T>
int CreateAclTensor(const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr,
                    aclDataType dataType, aclTensor** tensor) &#123;
  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--) &#123;
    strides[i] = shape[i + 1] * strides[i + 1];
  &#125;

  // 调用aclCreateTensor接口创建aclTensor
  *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND,
                            shape.data(), shape.size(), *deviceAddr);
  return 0;
&#125;

int main() &#123;
  // 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 = &#123;4, 2&#125;;
  std::vector<int64_t> outShape = &#123;1, 2&#125;;
  void* selfDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = &#123;0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1&#125;;
  std::vector<float> outHostData = &#123;0.0, 0.0&#125;;
  int64_t dim = 0;
  bool keepdim = true;
  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3.调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnProdDim第一段接口
  ret = aclnnProdDimGetWorkspaceSize(self, dim, keepdim, aclDataType::ACL_FLOAT, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnProdDimGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // 根据第一段接口计算出的workspaceSize申请device内存
  void* workspaceAddr = nullptr;
  if (workspaceSize > 0) &#123;
    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;);
  &#125;
  // 调用aclnnProdDim第二段接口
  ret = aclnnProdDim(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnProdDim 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++) &#123;
    LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]);
  &#125;

  // 6. 释放aclTensor和aclIntArray，需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

在线提单

aclnnPowScalarTensor​

接口原型​

功能描述​

aclnnPowScalarTensorGetWorkspaceSize​

aclnnPowScalarTensor​

调用示例​

aclnnPowTensorScalar​

接口原型​

功能描述​

aclnnPowTensorScalarGetWorkspaceSize​

aclnnPowTensorScalar​

调用示例​

aclnnPowTensorTensor​

接口原型​

功能描述​

aclnnPowTensorTensorGetWorkspaceSize​

aclnnPowTensorTensor​

调用示例​

aclnnPrelu​

接口原型​

功能描述​

aclnnPreluGetWorkspaceSize​

aclnnPrelu​

调用示例​

aclnnPreluBackward​

接口原型​

功能描述​

aclnnPreluBackwardGetWorkspaceSize​

aclnnPreluBackward​

调用示例​

aclnnProd​

接口原型​

功能描述​

aclnnProdGetWorkspaceSize​

aclnnProd​

调用示例​

aclnnProdDim​

接口原型​

功能描述​

aclnnProdDimGetWorkspaceSize​

aclnnProdDim​

调用示例​

aclnnPowScalarTensor

接口原型

功能描述

aclnnPowScalarTensorGetWorkspaceSize

aclnnPowScalarTensor

调用示例

aclnnPowTensorScalar

接口原型

功能描述

aclnnPowTensorScalarGetWorkspaceSize

aclnnPowTensorScalar

调用示例

aclnnPowTensorTensor

接口原型

功能描述

aclnnPowTensorTensorGetWorkspaceSize

aclnnPowTensorTensor

调用示例

aclnnPrelu

接口原型

功能描述

aclnnPreluGetWorkspaceSize

aclnnPrelu

调用示例

aclnnPreluBackward

接口原型

功能描述

aclnnPreluBackwardGetWorkspaceSize

aclnnPreluBackward

调用示例

aclnnProd

接口原型

功能描述

aclnnProdGetWorkspaceSize

aclnnProd

调用示例

aclnnProdDim

接口原型

功能描述

aclnnProdDimGetWorkspaceSize

aclnnProdDim

调用示例