aclnnConvDepthwise2d

aclnnComplex

接口原型

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

**第一段接口：**aclnnStatus aclnnComplexGetWorkspaceSize(const aclTensor *real, const aclTensor *imag, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnComplex(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：输入两个Shape和Dtype一致的张量real和imag，返回一个复数类型的张量out。
计算公式：

aclnnComplexGetWorkspaceSize

接口定义：

aclnnStatus aclnnComplexGetWorkspaceSize(const aclTensor *real, const aclTensor *imag, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- real(aclTensor*, 计算输入)：公式中的输入real，数据类型支持FLOAT、FLOAT16、DOUBLE，shape需要与imag满足broadcast关系。支持非连续的Tensor，数据格式支持ND。
- imag(aclTensor*，计算输入)：公式中的输入imag，数据类型支持FLOAT、FLOAT16、DOUBLE，shape需要与real满足broadcast关系。支持非连续的Tensor，数据格式支持ND。
- out(aclTensor*, 计算输出)：公式中的输出out，数据类型支持COMPLEX32、COMPLEX64、COMPLEX128，且数据类型需要是real与imag推导之后可转换的数据类型，shape需要是real与imag broadcast之后的shape。支持非连续的Tensor，数据格式支持ND。
- workspaceSize(uint64_t*, 出参)：返回用户需要在Device侧申请的workspace大小。
- executor(aclOpExecutor**, 出参)：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnComplex

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_complex.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_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

  // 2. 构造输入与输出，需要根据API的接口自定义构造
  std::vector<int64_t> realShape = &#123;4, 2&#125;;
  std::vector<int64_t> imagShape = &#123;4, 2&#125;;
  std::vector<int64_t> outShape = &#123;4, 2&#125;;
  void* realDeviceAddr = nullptr;
  void* imagDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* real = nullptr;
  aclTensor* imag = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> realHostData = &#123;0, 1, 2, 3, 4, 5, 6, 7&#125;;
  std::vector<float> imagHostData = &#123;1, 1, 1, 2, 2, 2, 3, 3&#125;;
  std::vector<float> outHostData(8, 0);
  // 创建real aclTensor
  ret = CreateAclTensor(realHostData, realShape, &realDeviceAddr, aclDataType::ACL_FLOAT, &real);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建imag aclTensor
  ret = CreateAclTensor(imagHostData, imagShape, &imagDeviceAddr, aclDataType::ACL_FLOAT, &imag);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_COMPLEX64, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3. 调用CANN算子库API，需要修改为具体的API名称
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnComplex第一段接口
  ret = aclnnComplexGetWorkspaceSize(real, imag, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnComplexGetWorkspaceSize 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;
  // 调用aclnnComplex第二段接口
  ret = aclnnComplex(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnComplex failed. ERROR: %d\n", ret); return ret);

  // 4. （固定写法）同步等待任务执行结束
  ret = aclrtSynchronizeStream(stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);

  // 5. 获取输出的值，将device侧内存上的结果拷贝至host侧，需要根据具体API的接口定义修改
  auto size = GetShapeSize(outShape);
  std::vector<float> resultData(size, 0);
  ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), outDeviceAddr,
                    size * sizeof(resultData[0]), ACL_MEMCPY_DEVICE_TO_HOST);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret);
  for (int64_t i = 0; i < size; i++) &#123;
    LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]);
  &#125;

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

父主题： NN类算子接口

aclnnConstantPadNd

接口原型

**第一段接口：**aclnnStatus aclnnConstantPadNdGetWorkspaceSize(const aclTensor *self, const aclIntArray *pad, const aclScalar *value, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnConstantPadNd(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtstream stream)

功能描述

算子功能：对输入张量self以pad参数为基准进行数据填充，填充的值为value。

aclnnConstantPadNdGetWorkspaceSize

接口定义：

aclnnStatus aclnnConstantPadNdGetWorkspaceSize(const aclTensor *self, const aclIntArray *pad, const aclScalar *value, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT32、INT32、INT64、INT16、INT8、UINT8、DOUBLE、UINT16、UINT32、UINT64、BOOL、COMPLEX64、COMPLEX128，支持非连续的Tensor，数据格式支持ND。
- pad：Host侧的aclIntArray，数据类型支持UINT8、INT8、INT16、INT32、INT64，数组长度必须为偶数且不能超过self维度的两倍。
- value：Host侧的aclScalar，数据类型支持FLOAT16、FLOAT32、INT32、INT64、INT16、INT8、UINT8、DOUBLE、UINT16、UINT32、UINT64、BOOL、COMPLEX64、COMPLEX128。
- out：Device侧的aclTensor，数据类型支持FLOAT16、FLOAT32、INT32、INT64、INT16、INT8、UINT8、DOUBLE、UINT16、UINT32、UINT64、BOOL、COMPLEX64、COMPLEX128，数据类型需要和self一致。支持非连续的Tensor，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的self、value或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self和out的数据类型不一致。
  - self的维度大于8。
  - pad中的值会导致out的某一维shape小于等于0。
  - pad中元素个数不为偶数。
  - pad中元素个数超过self维度的两倍。
  - out的shape与推导得出的shape结果不一致。 :::

aclnnConstantPadNd

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_constant_pad_nd.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, 4&#125;;
  void* selfDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclIntArray* pad = nullptr;
  aclScalar* value = 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, 0, 0, 0, 0, 0, 0, 0, 0&#125;;
  float valueValue = 1.0f;
  std::vector<int64_t> padData = &#123;1,1,0,0&#125;;

  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建pad aclIntArray
  pad = aclCreateIntArray(padData.data(), 4);
  CHECK_RET(pad != nullptr, return ret);
  // 创建value aclScalar
  value = aclCreateScalar(&valueValue, aclDataType::ACL_FLOAT);
  CHECK_RET(value != 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;
  // 调用aclnnConstantPadNd第一段接口
  ret = aclnnConstantPadNdGetWorkspaceSize(self, pad, value, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnConstantPadNdGetWorkspaceSize 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;
  // 调用aclnnConstantPadNd第二段接口
  ret = aclnnConstantPadNd(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnConstantPadNd 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和aclScalar，需要根据具体API的接口定义修改
  aclDestroyTensor(self);
  aclDestroyIntArray(pad);
  aclDestroyScalar(value);
  aclDestroyTensor(out);

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

父主题： NN类算子接口

aclnnConvDepthwise2d

接口原型

**第一段接口：**aclnnStatus aclnnConvDepthwise2dGetWorkspaceSize(const aclTensor *self, const aclTensor *weight, const aclIntArray *kernelSize, const aclTensor *bias, const aclIntArray *stride, const aclIntArray *padding, const aclIntArray *dilation, aclTensor *out, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnConvDepthwise2d(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：2D深度卷积。在每一深度上卷积，不求和。
计算公式：

假定输入self的shape是(N, Cin, H, W)，输出out的shape是(N, N∗Cout, Hout, Wout)，每个卷积核的输出表示为

然后将每个卷积核的输出在深度方向上合并输出。其中，⋆表示互相关的计算，N代表batch size，C代表通道数，W和H分别代表宽和高。

aclnnConvDepthwise2dGetWorkspaceSize

接口定义：

aclnnStatus aclnnConvDepthwise2dGetWorkspaceSize(const aclTensor *self, const aclTensor *weight, const aclIntArray *kernelSize, const aclTensor *bias, const aclIntArray *stride, const aclIntArray *padding, const aclIntArray *dilation, aclTensor *out, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self(aclTensor*, 计算输入)：公式中的输入self，数据类型支持FLOAT、FLOAT16。支持非连续的Tensor，数据格式支持NCHW（NHWC）。
- weight(aclTensor*，计算输入)：公式中的输入weight，数据类型支持FLOAT、FLOAT16。支持非连续的Tensor，数据格式支持NCHW。weight第一维数值应等于self通道数的整数倍。H、W两维的数值需小于self的H、W两维的数值。
- kernelSize(const aclIntArray *, 计算输入)：卷积核尺寸，(int, int)型的元组。
- bias(aclTensor*，计算输入)：公式中的bias，数据类型支持FLOAT、FLOAT16。支持非连续的Tensor，数据格式支持NCHW。仅支持一维且数值需要与weight第一维相等。
- stride(const aclIntArray *, 计算输入)：卷积扫描步长，数组长度需等于1或者self的维度减2。
- padding(const aclIntArray *, 计算输入)：对self的填充，数组长度需等于1或者self的维度减 2。
- dilation(const aclIntArray *, 计算输入)：卷积核中元素的间隔，数组长度需等于1或者self的维度减 2。
- out(aclTensor*, 计算输出)：公式中的out，数据类型支持FLOAT、FLOAT16。支持非连续的Tensor，数据格式支持NCHW。out通道数应等于weight第一维的数值。
- cubeMathType：Host侧的整型，判断Cube单元应该使用哪种计算逻辑进行运算，支持INT8类型的枚举值，枚举值如下：
  - 0：KEPP_DTYPE，保持输入的数据类型进行计算。
  - 1：ALLOW_FP32_DOWN_PRECISION，允许转换输入数据类型降低精度计算。
- workspaceSize(uint64_t*, 出参)：返回用户需要在Device侧申请的workspace大小。
- executor(aclOpExecutor**, 出参)：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的指针型入参是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self、weight、bias、out的数据类型和数据格式不在支持的范围内。
  - stride、padding输入的shape不对。
  - self、weight、bias、out的数据类型不一致。
  - weight和self的通道数不满足要求。
  - out的shape不满足infershape结果。
  - self、weight或bias为空Tensor。 :::

aclnnConvDepthwise2d

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_convolution.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_NCHW,
                            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> shapeSelf = &#123;2, 2, 2, 2&#125;;
  std::vector<int64_t> shapeWeight = &#123;2, 1, 1, 1&#125;;
  std::vector<int64_t> shapeBias = &#123;2&#125;;
  std::vector<int64_t> shapeResult = &#123;2, 2, 4, 4&#125;;
  void* deviceDataSelf = nullptr;
  void* deviceDataWeight = nullptr;
  void* deviceDataBias = nullptr;
  void* deviceDataResult = nullptr;
  aclTensor* self = nullptr;
  aclTensor* weight = nullptr;
  aclTensor* bias = nullptr;
  aclTensor* result = nullptr;
  aclIntArray* kernelSize = nullptr;
  aclIntArray* stride = nullptr;
  aclIntArray* padding = nullptr;
  aclIntArray* dilation = nullptr;
  std::vector<float> selfData(GetShapeSize(shapeSelf) * 2, 1);
  std::vector<float> weightData(GetShapeSize(shapeWeight) * 2, 1);
  std::vector<float> biasData(GetShapeSize(shapeBias) * 2, 1);
  std::vector<float> outData(GetShapeSize(shapeResult) * 2, 1);
  std::vector<int64_t> kernelSizeData = &#123;1, 1&#125;;
  std::vector<int64_t> strideData = &#123;1, 1&#125;;
  std::vector<int64_t> paddingData = &#123;1, 1&#125;;
  std::vector<int64_t> dilationData = &#123;1, 1&#125;;

  // 创建self aclTensor
  ret = CreateAclTensor(selfData, shapeSelf, &deviceDataSelf, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建weight aclTensor
  ret = CreateAclTensor(weightData, shapeWeight, &deviceDataWeight, aclDataType::ACL_FLOAT, &weight);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建bias aclTensor
  ret = CreateAclTensor(biasData, shapeBias, &deviceDataBias, aclDataType::ACL_FLOAT, &bias);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outData, shapeResult, &deviceDataResult, aclDataType::ACL_FLOAT, &result);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  kernelSize = aclCreateIntArray(kernelSizeData.data(), 2);
  stride = aclCreateIntArray(strideData.data(), 2);
  padding = aclCreateIntArray(paddingData.data(), 2);
  dilation = aclCreateIntArray(dilationData.data(), 2);

  // 3. 调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnConvDepthwise2d第一段接口
  ret = aclnnConvDepthwise2dGetWorkspaceSize(self, weight, kernelSize, bias, stride, padding, dilation, result, 1, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnConvDepthwise2dGetWorkspaceSize 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;
  // 调用aclnnConvDepthwise2d第二段接口
  ret = aclnnConvDepthwise2d(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnConvDepthwise2d 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(shapeResult);
  std::vector<float> resultData(size, 0);
  ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), deviceDataResult,
                    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(bias);
  aclDestroyTensor(result);
  aclDestroyIntArray(kernelSize);
  aclDestroyIntArray(stride);
  aclDestroyIntArray(padding);
  aclDestroyIntArray(dilation);
  return 0;
&#125;

父主题： NN类算子接口

aclnnConvolution

接口原型

第一段接口：aclnnStatus aclnnConvolutionGetWorkspaceSize( const aclTensor *input, const aclTensor *weight, const aclTensor *bias, const aclIntArray *stride, const aclIntArray *padding, const aclIntArray *dilation, const bool transposed, const aclIntArray *outputPadding, const int64_t groups, aclTensor *output, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnConvolution(const void * const workspace, const uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：实现卷积功能，支持1D卷积、2D卷积、3D卷积，同时支持转置卷积、空洞卷积、分组卷积。
计算公式：

假设输入张量input的shape是（N、Cin、H、W），（weight）的shape是（Cout、Cin、Kh、Kw），输出（output）的shape是（N，Cout、Hout、Wout），那输出将被表示为：

其中⋆表示互相关计算，根据卷积输入的dim，卷积的类型（空洞卷积、分组卷积）而定。N代表batch size，C代表通道数，W和H分别代表宽和高，相应输出维度的计算公式如下：

aclnnConvolutionGetWorkspaceSize

接口定义：

aclnnStatus aclnnConvolutionGetWorkspaceSize( const aclTensor *input, const aclTensor *weight, const aclTensor *bias, const aclIntArray *stride, const aclIntArray *padding, const aclIntArray *dilation, const bool transposed, const aclIntArray *outputPadding, const int64_t groups, aclTensor *output, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- input：Device侧的aclTensor，数据类型仅支持FLOAT、FLOAT16，支持非连续的Tensor，数据格式为NCL、NCHW、NCDHW。
- weight：Device侧的aclTensor，数据类型仅支持FLOAT、FLOAT16，支持非连续的Tensor，数据格式为NCL、NCHW、NCDHW。
- bias：Device侧的aclTensor，数据类型仅支持FLOAT、FLOAT16，支持非连续的Tensor，数据格式为NCL、NCHW、NCDHW（Transpose卷积下格式只能是ND）。
- stride：Host侧的aclIntArray，数组长度需等于1或者input的维度减2。
- padding：Host侧的aclIntArray，数组长度需等于1或者input的维度减2。
- dilation：Host侧的aclIntArray，数组长度需等于1或者input的维度减2。
- transposed：用于判断是否为转置卷积。当为True时，表示使用转置卷积或者分数步长卷积，可看作是普通卷积的梯度或者逆向操作，即从卷积的输出形状恢复到输入形状，同时保持与卷积相容的连接模式。它的参数和普通卷积类似，包括输入通道数、输出通道数、卷积核大小、步长、填充、输出填充、分组、偏置、扩张等。
- outputPadding：Host侧的aclIntArray，数组长度需等于1或者input的维度减2。
- groups：表示从输入通道到输出通道的块链接个数（目前暂不支持>1的情况）。
- output：Device侧的aclTensor，数据类型为input和weight中的高精度类型，数据格式为NCL、NCHW、NCDHW。
- cubeMathType：Host侧的整型，判断Cube单元应该使用哪种计算逻辑进行运算，支持INT8类型的枚举值，枚举值如下：
  - 0：KEPP_DTYPE，保持输入的数据类型进行计算。
  - 1：ALLOW_FP32_DOWN_PRECISION，允许转换输入数据类型降低精度计算。
  - 2：USE_FP16，允许转换输入数据类型至FLOAT16计算。当输入是FLOAT，允许转换为FLOAT16计算。
  - 3：USE_HF32，允许转换输入数据类型至HFLOAT32计算。当输入是FLOAT，Atlas 训练系列产品暂不支持，取3时会报错。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的指针类型入参是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - input、weight、bias、output数据类型和数据格式不在支持的范围内。
  - stride、padding、dilation、outputPadding输入shape不对。
  - input和output数据类型不一致。
  - groups为0或者大于0的情况下，weight和input通道数不满足要求。
  - output的shape不满足推导shape结果。
  - outputPadding值不满足要求。
  - input传入空tensor中为零的维度不满足要求。
  - input空间尺度在padding后小于weight的空间尺度。
  - transpose模式下bias的shape不为1。 :::

aclnnConvolution

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_convolution.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_NCHW,
                            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> shapeInput = &#123;2, 2, 2, 2&#125;;
  std::vector<int64_t> shapeWeight = &#123;1, 2, 1, 1&#125;;
  std::vector<int64_t> shapeResult = &#123;2, 1, 4, 4&#125;;
  std::vector<int64_t> convStrides;
  std::vector<int64_t> convPads;
  std::vector<int64_t> convOutPads;
  std::vector<int64_t> convDilations;

  void *deviceDataA = nullptr;
  void *deviceDataB = nullptr;
  void *deviceDataResult = nullptr;

  aclTensor* input = nullptr;
  aclTensor* weight = nullptr;
  aclTensor* result = nullptr;
  std::vector<float> inputData(GetShapeSize(shapeInput) * 2, 1);
  std::vector<float> weightData(GetShapeSize(shapeWeight) * 2, 1);
  std::vector<float> outputData(GetShapeSize(shapeResult) * 2, 1);

  convStrides = &#123;1, 1, 1, 1&#125;;
  convPads = &#123;1, 1, 1, 1&#125;;
  convOutPads = &#123;1, 1, 1, 1&#125;;
  convDilations = &#123;1, 1, 1, 1&#125;;
  // 创建self aclTensor
  ret = CreateAclTensor(inputData, shapeInput, &deviceDataA, aclDataType::ACL_FLOAT16, &input);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建other aclTensor
  ret = CreateAclTensor(weightData, shapeWeight, &deviceDataB, aclDataType::ACL_FLOAT16, &weight);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outputData, shapeResult, &deviceDataResult, aclDataType::ACL_FLOAT16, &result);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  aclIntArray *strides = aclCreateIntArray(convStrides.data(), 2);
  aclIntArray *pads = aclCreateIntArray(convPads.data(), 2);
  aclIntArray *outPads = aclCreateIntArray(convOutPads.data(), 2);
  aclIntArray *dilations = aclCreateIntArray(convDilations.data(), 2);

  // 3.调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnConvolution第一段接口
  ret = aclnnConvolutionGetWorkspaceSize( input, weight,  nullptr, strides, pads, dilations, false, outPads,  1, result, 1, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnConvolutionGetWorkspaceSize 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;
  // 调用aclnnConvolution第二段接口
  ret = aclnnConvolution(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnConvolution 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(shapeResult);
  std::vector<float> resultData(size, 0);
  ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), deviceDataResult, 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的接口定义修改
  aclDestroyTensor(input);
  aclDestroyTensor(weight);
  aclDestroyTensor(result);
  aclDestroyIntArray(strides);
  aclDestroyIntArray(pads);
  aclDestroyIntArray(outPads);
  aclDestroyIntArray(dilations);
  return 0;
&#125;

父主题： NN类算子接口

aclnnConvolutionBackward

接口原型

第一段接口：aclnnStatus aclnnConvolutionBackwardGetWorkspaceSize(const aclTensor *gradOutput, const aclTensor *input, const aclTensor *weight, const aclIntArray *biasSizes, const aclIntArray *stride, const aclIntArray *padding, const aclIntArray *dilation, const bool transposed, const aclIntArray *outputPadding, const int groups, const aclBoolArray *outputMask, int8_t cubeMathType, aclTensor *gradInput, aclTensor *gradWeight, aclTensor *gradBias, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnConvolutionBackward(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, const aclrtStream stream)

功能描述

算子功能：卷积函数aclnnConvolution的反向传播。根据输出掩码outputMask设置输入、权重和偏差的梯度，此函数支持1D、2D或3D卷积。
计算公式：

输入input(N, Cin, Din, Hin, Win)、输出out(N, Cout, Dout, Hout, Wout)和积步长(stride)、卷积核大小(kernelSize, kD, kH, kW)、膨胀参数(dilation)的关系是：

卷积反向传播需要计算对卷积正向的输入张量x、卷积核权重张量w和偏置b的梯度。
- 对于x的梯度
  
  ：
  
  其中，L为损失函数，
  
  为输出张量y对L的梯度。
- 对于w的梯度
  
  ：
- 对于b的梯度
  
  ：

aclnnConvolutionBackward

接口定义：

aclnnStatus aclnnConvolutionBackwardGetWorkspaceSize(const aclTensor *gradOutput, const aclTensor *input, const aclTensor *weight, const aclIntArray *biasSizes, const aclIntArray *stride, const aclIntArray *padding, const aclIntArray *dilation, const bool transposed, const aclIntArray *outputPadding, const int groups, const aclBoolArray *outputMask, int8_t cubeMathType, aclTensor *gradInput, aclTensor *gradWeight, aclTensor *gradBias, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- gradOutput：卷积输出梯度，公式中的输入∂L/∂y，Device侧的aclTensor。数据类型支持FLOAT、FLOAT16，且数据类型需要与input、weight数据类型满足数据类型推导规则。shape要求和input、weight满足卷积输入输出shape的推导关系。支持非连续的Tensor，数据格式支持ND、NCL、NCHW、NCDHW。
- input：卷积输入，公式中的输入x，Device侧的aclTensor。数据类型支持FLOAT、FLOAT16，且数据类型需要与gradOutput、weight数据类型满足数据类型推导规则。shape要求和gradOutput、weight满足卷积输入输出shape的推导关系。支持非连续的Tensor。数据格式支持ND、NCL、NCHW、NCDHW，且数据格式需要与input、weight一致。
- weight：卷积权重，公式中的输入w，Device侧的aclTensor。数据类型支持FLOAT、FLOAT16，且数据类型需要与gradOutput、input数据类型满足数据类型推导规则。shape要求和gradOutput、input满足卷积输入输出shape的推导关系。支持非连续的Tensor。数据格式支持ND、NCL、NCHW、NCDHW，且数据格式需要与input、weight一致。
- biasSizes：卷积正向过程中偏差（bias）的shape，Host侧的aclIntArray。数据类型为INT64，数组长度是1。在普通卷积中它等于[weight.shape[0]]，在转置卷积中它等于[weight.shape[1] * groups]。
- stride：反向传播过程中卷积核在输入上移动的步长，数值必须大于0，Host侧的aclIntArray。数据类型为INT64，数组长度可为1或weight.ndimension()-2，当为1时卷积核在输入上移动的步长和D、H和W方向上一样。
- padding：反向传播过程中对于输入填充，数值必须大于0，Host侧的aclIntArray。数据类型为INT64，数组长度可为1或weight.ndimension()-2，当为1时输入填充在D、H和W方向上一样。
- dilation：反向传播过程中的膨胀参数，数值必须大于0，Host侧的aclIntArray。数据类型为INT64，数组长度可为1或weight.ndimension()-2，当为1时膨胀参数在D、H和W方向上一样。
- transposed：转置卷积使能标志位，Host侧的布尔类型。当其值为True时，使能转置卷积。
- outputPadding：反向传播过程中对于输出填充，数值必须大于0，仅在transposed为True时生效，Host侧的整形数组。数据类型支持INT32、INT64，数组长度可为1或weight.ndimension() 2，当为1时对于输出填充在D、H和W方向上一样。
- groups：反向传播过程中输入通道的分组数。数据类型为INT64，数值必须大于0**(当前只支持group = 1的情况)**。
- outputMask：输出掩码参数，指定输出中是否包含输入、权重、偏差的梯度，Host侧的aclBoolArray。反向传播过程输出掩码参数为True对应位置的梯度。
- cubeMathType：Host侧的整型，判断Cube单元应该使用哪种计算逻辑进行运算，支持INT8类型的枚举值，枚举值如下：
  - 0：KEPP_DTYPE，保持输入的数据类型进行计算。
  - 1：ALLOW_FP32_DOWN_PRECISION，允许转换输入数据类型降低精度计算。
  - 2：USE_FP16，允许转换输入数据类型至FLOAT16计算。当输入是FLOAT，允许转换为FLOAT16计算。
  - 3：USE_HF32，允许转换输入数据类型至HFLOAT32计算。当输入是FLOAT，Atlas 训练系列产品暂不支持，取3时会报错。
- gradInput：卷积输入梯度，公式中的输入∂L/∂x，Device侧的aclTensor，数据类型和数据格式与input一致。
- gradWeight：卷积权重梯度，公式中的输入∂L/∂w，Device侧的aclTensor，数据类型和数据格式与weight一致。
- gradBias：卷积偏置梯度，公式中的输入∂L/∂b，Device侧的aclTensor，数据格式为ND
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器, 包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的指针类型入参是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - gradOutput、input或weight的数据类型不在支持的范围之内。
  - gradOutput、input或weight的shape不符合约束。
  - biasSizes、stride、dilation或outputPadding的shape不符合约束。
  - gradOutput、input、weight和gradInput、gradWeight、gradBias的数据类型不符合约束。
  - input传入空Tensor中为零的维度不满足要求。 :::

aclnnConvolutionBackwardGetWorkspaceSize

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_convolution_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 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
  if (shape.size() == 4) &#123;
    *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_NCHW,
                              shape.data(), shape.size(), *deviceAddr);
  &#125; else &#123;
    *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND,
                              shape.data(), shape.size(), *deviceAddr);   
  &#125;
  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_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

  // 2. 构造输入与输出，需要根据API的接口自定义构造
  std::vector<int64_t> gradOutputShape = &#123;2, 2, 7, 7&#125;;
  std::vector<int64_t> inputShape = &#123;2, 2, 7, 7&#125;;
  std::vector<int64_t> weightShape = &#123;2, 2, 1, 1&#125;;
  std::vector<int64_t> bias = &#123;2&#125;;
  std::vector<int64_t> stride = &#123;1, 1&#125;;
  std::vector<int64_t> padding = &#123;0, 0&#125;;
  std::vector<int64_t> dilation = &#123;1, 1&#125;;
  bool transposed = false;
  std::vector<int64_t> outputPadding = &#123;0, 0&#125;;
  int groups = 1;
  bool outputMask[3] = &#123;true, true, true&#125;;
  int8_t cubeMathType = 0;
  std::vector<int64_t> gradInputShape = &#123;2, 2, 7, 7&#125;;
  std::vector<int64_t> gradWeightShape = &#123;2, 2, 1, 1&#125;;
  std::vector<int64_t> gradBiasShape = &#123;2&#125;;
  // 创建gradOut aclTensor
  std::vector<float> gradOutputData(GetShapeSize(gradOutputShape) * 2, 1);
  aclTensor* gradOutput = nullptr;
  void *gradOutputdeviceAddr = nullptr;
  ret = CreateAclTensor(gradOutputData, gradOutputShape, &gradOutputdeviceAddr, aclDataType::ACL_FLOAT16, &gradOutput);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建input aclTensor
  std::vector<float> inputData(GetShapeSize(inputShape) * 2, 1);
  aclTensor* input = nullptr;
  void *inputdeviceAddr = nullptr;
  ret = CreateAclTensor(inputData, inputShape, &inputdeviceAddr, aclDataType::ACL_FLOAT16, &input);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建weight aclTensor
  std::vector<float> weightData(GetShapeSize(weightShape) * 2, 1);
  aclTensor* weight = nullptr;
  void *weightDeviceAddr = nullptr;
  ret = CreateAclTensor(weightData, weightShape, &weightDeviceAddr, aclDataType::ACL_FLOAT16, &weight);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建gradInput aclTensor
  std::vector<float> gradInputData(GetShapeSize(gradInputShape) * 2, 1);
  aclTensor* gradInput = nullptr;
  void *gradInputDeviceAddr = nullptr;
  ret = CreateAclTensor(gradInputData, gradInputShape, &gradInputDeviceAddr, aclDataType::ACL_FLOAT16, &gradInput);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建gradWeight aclTensor
  std::vector<float> gradWeightData(GetShapeSize(gradWeightShape) * 2, 1);
  aclTensor* gradWeight = nullptr;
  void *gradWeightDeviceAddr = nullptr;
  ret = CreateAclTensor(gradWeightData, gradWeightShape, &gradWeightDeviceAddr, aclDataType::ACL_FLOAT16, &gradWeight);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建gradBias aclTensor
  std::vector<float> gradBiasData(GetShapeSize(gradBiasShape) * 2, 1);
  aclTensor* gradBias = nullptr;
  void *gradBiasDeviceAddr = nullptr;
  ret = CreateAclTensor(gradBiasData, gradBiasShape, &gradBiasDeviceAddr, aclDataType::ACL_FLOAT16, &gradBias);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  aclIntArray *biasSizes = aclCreateIntArray(bias.data(), 1);
  aclIntArray *strides = aclCreateIntArray(stride.data(), 2);
  aclIntArray *pads = aclCreateIntArray(padding.data(), 2);
  aclIntArray *dilations = aclCreateIntArray(dilation.data(), 2);
  aclIntArray *outputPads = aclCreateIntArray(outputPadding.data(), 2);
  aclBoolArray *outMask = aclCreateBoolArray(outputMask, 3);

  // 3. 调用CANN算子库API，需要修改为具体的API名称
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnConvolutionBackward第一段接口
  ret = aclnnConvolutionBackwardGetWorkspaceSize(gradOutput, input, weight, biasSizes, strides, pads, dilations, transposed, outputPads, groups, outMask, cubeMathType, gradInput, gradWeight, gradBias, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnConvolutionBackwardGetWorkspaceSize 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;
  // 调用aclnnConvolutionBackward第二段接口
  ret = aclnnConvolutionBackward(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnConvolutionBackward failed. ERROR: %d\n", ret); return ret);

  // 4. （固定写法）同步等待任务执行结束
  ret = aclrtSynchronizeStream(stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);

  // 5. 获取输出的值，将device侧内存上的结果拷贝至Host侧，需要根据具体API的接口定义修改
  auto size = GetShapeSize(gradInputShape);
  std::vector<float> gradInputResult(size, 0);
  ret = aclrtMemcpy(gradInputResult.data(), gradInputResult.size() * sizeof(gradInputResult[0]), gradInputDeviceAddr,
                    size * sizeof(gradInputResult[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++) &#123;
    LOG_PRINT("gradInputResult[%ld] is: %f\n", i, gradInputResult[i]);
  &#125;
  size = GetShapeSize(gradWeightShape);
  std::vector<float> gradWeightResult(size, 0);
  ret = aclrtMemcpy(gradWeightResult.data(), gradWeightResult.size() * sizeof(gradWeightResult[0]), gradWeightDeviceAddr,
                    size * sizeof(gradWeightResult[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++) &#123;
    LOG_PRINT("gradWeightResult[%ld] is: %f\n", i, gradWeightResult[i]);
  &#125;
  size = GetShapeSize(gradBiasShape);
  std::vector<float> gradBiasResult(size, 0);
  ret = aclrtMemcpy(gradBiasResult.data(), gradBiasResult.size() * sizeof(gradBiasResult[0]), gradInputDeviceAddr,
                    size * sizeof(gradBiasResult[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++) &#123;
    LOG_PRINT("gradBiasResult[%ld] is: %f\n", i, gradBiasResult[i]);
  &#125;

  // 6. 释放aclTensor和aclScalar，需要根据具体API的接口定义修改
  aclDestroyTensor(gradOutput);
  aclDestroyTensor(input);
  aclDestroyTensor(weight);
  aclDestroyTensor(gradInput);
  aclDestroyTensor(gradWeight);
  aclDestroyTensor(gradBias);
  return 0;
&#125;

父主题： NN类算子接口

aclnnConvTbc

接口原型

**第一段接口：**aclnnStatus aclnnConvTbcGetWorkspaceSize(const aclTensor *self, const aclTensor *weight, const aclTensor *bias, const int64_t pad, aclTensor *output, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor
**第二段接口：**aclnnStatus aclnnConvtbc(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：实现输入/输出维度为T（时间或空间维度）、B（批次）、C（通道）的一维卷积。
计算公式：

假设输入input的shape是 (Hin, N, Cin) ，输出output的shape是 (Hout, N, Cout)，输出结果为

其中，⋆表示互相关的计算，N代表batchSize（批次），C代表通道数，H代表时间或空间维度。

aclnnConvTbcGetWorkspaceSize

接口定义：

aclnnStatus aclnnConvTbcGetWorkspaceSize(const aclTensor *self, const aclTensor *weight, const aclTensor *bias, const int64_t pad, aclTensor *output, int8_t cubeMathType, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，计算公式中的input，数据类型支持FLOAT、FLOAT16，支持非连续的Tensor，数据格式支持ND。
- weight：Device侧的aclTensor，计算公式中的weight，数据类型支持FLOAT、FLOAT16，数据类型与self一致，支持非连续的Tensor，数据格式为ND。
- bias：Device侧的aclTensor，计算公式中的bias，数据类型支持FLOAT、FLOAT16，支持非连续的Tensor，数据格式为ND。
- pad：Host侧整型，表示T维度上左右填充的个数，数据类型支持INT64。
- output：Device侧的aclTensor，输出张量，数据类型支持FLOAT、FLOAT16，数据类型与self一致，数据格式为ND。
- cubeMathType：Host侧的整型，判断Cube单元应该使用哪种计算逻辑进行运算，支持INT8类型的枚举值，枚举值如下：
  - 0：KEPP_DTYPE，保持输入的数据类型进行计算。
  - 1：ALLOW_FP32_DOWN_PRECISION，允许转换输入数据类型降低精度计算。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的指针类型入参是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - self、weight、bias、output数据类型和数据格式不在支持的范围之内。
  - self、weight、output数据类型不一致。
  - output的shape不满足推导的shape结果。
  - output的shape中存在小于0的值。
  - self或weight的dim不为3。
  - bias的dim不为1。
  - input的第三个维度值不等于weight的第2个维度值。
  - bias的值不等于weight的第三个维度值。 :::

aclnnConvTbc

接口定义：

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

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

调用示例

#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_conv_tbc.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_NCL,
                            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> shapeInput = &#123;2, 2, 3&#125;;
  std::vector<int64_t> shapeWeight = &#123;3, 3, 4&#125;;
  std::vector<int64_t> shapeBias = &#123;4&#125;;
  std::vector<int64_t> shapeResult = &#123;2, 2, 4&#125;;
  void *deviceDataA = nullptr;
  void *deviceDataB = nullptr;
  void *deviceDataResult = nullptr;
  aclTensor* input = nullptr;
  aclTensor* weight = nullptr;
  aclTensor* bias = nullptr;
  aclTensor* result = nullptr;
  std::vector<float> inputData(GetShapeSize(shapeInput) * 2, 1);
  std::vector<float> weightData(GetShapeSize(shapeWeight) * 2, 1);
  std::vector<float> biasData(GetShapeSize(shapeWeight) * 2, 1);
  std::vector<float> outputData(GetShapeSize(shapeResult) * 2, 1);

  // 创建input aclTensor
  ret = CreateAclTensor(inputData, shapeInput, &deviceDataA, aclDataType::ACL_FLOAT16, &input);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建weight aclTensor
  ret = CreateAclTensor(weightData, shapeWeight, &deviceDataB, aclDataType::ACL_FLOAT16, &weight);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
// 创建bias aclTensor
     ret = CreateAclTensor(biasData, shapeBias, &deviceDataB, aclDataType::ACL_FLOAT16, &bias);
     CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outputData, shapeResult, &deviceDataResult, aclDataType::ACL_FLOAT16, &result);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3.调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnConvTbc第一段接口
  ret = aclnnConvTbcGetWorkspaceSize( input, weight,  bias, 1, result, 1, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnConvTbcGetWorkspaceSize 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;
  // 调用aclnnConvTbc第二段接口
  ret = aclnnConvTbc(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnConvTbc 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(shapeResult);
  std::vector<float> resultData(size, 0);
  ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), deviceDataResult, 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的接口定义修改
  aclDestroyTensor(input);
  aclDestroyTensor(weight);
  aclDestroyTensor(bias);
  aclDestroyTensor(result);
  return 0;
&#125;

父主题： NN类算子接口

在线提单

aclnnComplex​

接口原型​

功能描述​

aclnnComplexGetWorkspaceSize​

aclnnComplex​

调用示例​

aclnnConstantPadNd​

接口原型​

功能描述​

aclnnConstantPadNdGetWorkspaceSize​

aclnnConstantPadNd​

调用示例​

aclnnConvDepthwise2d​

接口原型​

功能描述​

aclnnConvDepthwise2dGetWorkspaceSize​

aclnnConvDepthwise2d​

调用示例​

aclnnConvolution​

接口原型​

功能描述​

aclnnConvolutionGetWorkspaceSize​

aclnnConvolution​

调用示例​

aclnnConvolutionBackward​

接口原型​

功能描述​

aclnnConvolutionBackward​

aclnnConvolutionBackwardGetWorkspaceSize​

调用示例​

aclnnConvTbc​

接口原型​

功能描述​

aclnnConvTbcGetWorkspaceSize​

aclnnConvTbc​

调用示例​

aclnnComplex

接口原型

功能描述

aclnnComplexGetWorkspaceSize

aclnnComplex

调用示例

aclnnConstantPadNd

接口原型

功能描述

aclnnConstantPadNdGetWorkspaceSize

aclnnConstantPadNd

调用示例

aclnnConvDepthwise2d

接口原型

功能描述

aclnnConvDepthwise2dGetWorkspaceSize

aclnnConvDepthwise2d

调用示例

aclnnConvolution

接口原型

功能描述

aclnnConvolutionGetWorkspaceSize

aclnnConvolution

调用示例

aclnnConvolutionBackward

接口原型

功能描述

aclnnConvolutionBackward

aclnnConvolutionBackwardGetWorkspaceSize

调用示例

aclnnConvTbc

接口原型

功能描述

aclnnConvTbcGetWorkspaceSize

aclnnConvTbc

调用示例