aclnnNonzero

aclnnNLLLossBackward

接口原型

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

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

功能描述

算子功能：负对数似然损失函数（aclnnNLLLoss）的反向传播。

aclnnNLLLossBackwardGetWorkspaceSize

接口定义：

aclnnStatus aclnnNLLLossBackwardGetWorkspaceSize(const aclTensor *gradOutput, const aclTensor *self, const aclTensor *target, const aclTensor *weight, int64_t reduction, int64_t ignoreIndex, const aclTensor *totalWeight, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- gradOutput：Device侧的aclTensor，shape为(N, )或者为(1, )，数据类型支持FLOAT、FLOAT16、BFLOAT16（仅Atlas A2训练系列产品支持）。支持非连续的Tensor，数据格式支持ND。
- self：Device侧的aclTensor，shape为(N, C)或者(C, )，其中N表示batch size，C表示类别数。数据类型支持FLOAT、FLOAT16、BFLOAT16（仅Atlas A2训练系列产品支持）。支持非连续的Tensor、数据格式支持ND 。
- target：Device侧的aclTensor，表示真实标签，shape为(N, ) 或者(1, )，其中每个元素的取值范围是[0, C-1]。数据类型支持INT64、UINT8 ，支持非连续的Tensor，数据格式支持ND 。
- weight：Device侧的aclTensor，表示各个类别的权重，shape为(C, )。数据类型支持FLOAT、FLOAT16、BFLOAT16（仅Atlas A2训练系列产品支持）。支持非连续的Tensor，数据格式支持ND。
- reduction： Host侧的int64_t，指定损失函数的计算方式。支持3种枚举值：当取值为0，即为"none"，表示不应用减少；当取值为1，即为"mean"，表示输出的总和将除以输出中的元素数；当取值为2，即为"sum"，表示输出将被求和。
- ignoreIndex：Host侧的int64_t，指定一个被忽略且不影响输入梯度的目标值。
- totalWeight：Device侧的aclTensor，shape为(1,)，数据类型支持FLOAT、FLOAT16、BFLOAT16（仅Atlas A2训练系列产品支持）。且数据类型为与weight相同。数据格式支持ND。
- out：Device侧的aclTensor。shape需要与self一致。支持非连续的Tensor，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的gradOutput、self、target、weight、out、totalWeight为空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - gradOutput、self、target、weight、totalWeight的数据类型不在支持的范围内。
  - gradOutput、self、weight、totalWeight的数据类型不一致。
  - gradOutput、self、weight、out、totalWeight的shape不正确。
  - reduction值不在0~2范围之内。 :::

aclnnNLLLossBackward

接口定义：

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

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

调用示例

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

  // 2. 构造输入与输出，需要根据API的接口自定义构造
  std::vector<int64_t> gradOutputShape = &#123;2&#125;;
  std::vector<int64_t> selfShape = &#123;2, 3&#125;;
  std::vector<int64_t> targetShape = &#123;2&#125;;
  std::vector<int64_t> weightShape = &#123;3&#125;;
  std::vector<int64_t> totalWeightShape = &#123;1&#125;;
  std::vector<int64_t> outShape = &#123;2, 3&#125;;
  void* gradOutputDeviceAddr = nullptr;
  void* selfDeviceAddr = nullptr;
  void* targetDeviceAddr = nullptr;
  void* weightDeviceAddr = nullptr;
  void* totalWeightDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* gradOutput = nullptr;
  aclTensor* self = nullptr;
  aclTensor* target = nullptr;
  aclTensor* weight = nullptr;
  aclTensor* totalWeight = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> gradOutputHostData = &#123;2.1, 1.3&#125;;
  std::vector<float> selfHostData = &#123;0, 1, 2, 3, 4, 5&#125;;
  std::vector<int32_t> targetHostData = &#123;0, 2&#125;;
  std::vector<float> weightHostData = &#123;1.1, 1.2, 1.3&#125;;
  std::vector<float> totalWeightHostData = &#123;3.5&#125;;
  std::vector<float> outHostData = &#123;0, 0, 0, 0, 0, 0&#125;;
  int64_t reduction = 0;
  int64_t ignoreIndex = -100;

  // 创建gradOutput aclTensor
  ret = CreateAclTensor(gradOutputHostData, gradOutputShape, &gradOutputDeviceAddr, aclDataType::ACL_FLOAT, &gradOutput);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建target aclTensor
  ret = CreateAclTensor(targetHostData, targetShape, &targetDeviceAddr, aclDataType::ACL_INT32, &target);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建weight aclTensor
  ret = CreateAclTensor(weightHostData, weightShape, &weightDeviceAddr, aclDataType::ACL_FLOAT, &weight);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建totalWeightOut aclTensor
  ret = CreateAclTensor(totalWeightHostData, totalWeightShape, &totalWeightDeviceAddr, aclDataType::ACL_FLOAT,
                        &totalWeight);
  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;
  // 调用aclnnNLLLossBackward第一段接口
  ret = aclnnNLLLossBackwardGetWorkspaceSize(gradOutput, self, target, weight, reduction, ignoreIndex, totalWeight, out,&workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNLLLossBackwardGetWorkspaceSize 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;
  // 调用aclnnNLLLossBackward第二段接口
  ret = aclnnNLLLossBackward(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNLLLossBackward 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(target);
  aclDestroyTensor(weight);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnNLLLoss2d

接口原型

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

功能描述

算子功能：计算负对数似然损失值。
计算公式：
- 当reduction为none时，公式如下：
- 当reduction不为none时，公式如下：
其中输入张量为x，真实标签为y，每个类别的缩放权重为w，N是batch size。

aclnnNLLLoss2dGetWorkspaceSize

接口定义：

aclnnStatus aclnnNLLLoss2dGetWorkspaceSize(const aclTensor *self, const aclTensor *target, const aclTensor *weight, int64_t reduction, int64_t ignoreIndex, aclTensor *out, aclTensor *totalWeightOut, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，shape为4维，第1、2维是N和C，分别表示batch size和类别数。数据类型支持FLOAT。支持非连续的Tensor，数据格式支持ND。
- target：Device侧的aclTensor，表示真实标签，shape为3维，第1维是N，其中每个元素的取值范围是[0, C-1]。数据类型支持INT64、UINT8。支持非连续的Tensor，数据格式支持ND。
- weight：Device侧的aclTensor，表示每个类别的缩放权重，shape为(C, )，数据类型支持FLOAT。支持非连续的Tensor，数据格式支持ND。
- reduction：Host侧的int64_t，指定要应用到输出的缩减。支持3种枚举值：当取值为0，即为"none"，表示不应用减少；当取值为1，即为"mean"，表示输出的总和将除以输出中的元素数；当取值为2，即为"sum"，表示输出将被求和。
- ignoreIndex：Host侧的int64_t，指定一个被忽略且不影响输入梯度的目标值。
- out：Device侧的aclTensor，数据类型支持FLOAT且与self相同，shape(N, )为或者(1, )，数据格式支持ND，且数据格式需要与self一致。
- totalWeightOut：Device侧的aclTensor，数据类型支持FLOAT且与weight相同，shape为(1, )，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnNLLLoss2d

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_nll_loss2d.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;1, 2, 3, 2&#125;;
	std::vector<int64_t> targetShape = &#123;1, 3, 2&#125;;
	std::vector<int64_t> weightShape = &#123;2&#125;;
	std::vector<int64_t> outShape = &#123;1, 3, 2&#125;;
	std::vector<int64_t> totalWeightOutShape = &#123;1&#125;;
	void* selfDeviceAddr = nullptr;
	void* targetDeviceAddr = nullptr;
	void* weightDeviceAddr = nullptr;
	void* outDeviceAddr = nullptr;
	void* totalWeightOutDeviceAddr = nullptr;
	aclTensor* self = nullptr;
	aclTensor* target = nullptr;
	aclTensor* weight = nullptr;
	aclTensor* out = nullptr;
	aclTensor* totalWeightOut = nullptr;
	std::vector<float> selfHostData = &#123;0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 8.1, 9.1, 10.1, 11.1&#125;;
	std::vector<int32_t> targetHostData = &#123;1, 0, 1, 1, 2, 1&#125;;
	std::vector<float> weightHostData = &#123;1.1, 1.2&#125;;
	std::vector<float> outHostData = &#123;0.0, 0.0, 0.0, 0.0, 0.0, 0.0&#125;;
	std::vector<float> totalWeightOutHostData = &#123;0&#125;;
	int64_t reduction = 0;
	int64_t ignoreIndex = -100;

	// 创建self aclTensor
	ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
	CHECK_RET(ret == ACL_SUCCESS, return ret);
	// 创建target aclTensor
	ret = CreateAclTensor(targetHostData, targetShape, &targetDeviceAddr, aclDataType::ACL_INT32, &target);
	CHECK_RET(ret == ACL_SUCCESS, return ret);
	// 创建weight aclScalar
	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);
	// 创建totalWeightOut aclTensor
	ret = CreateAclTensor(totalWeightOutHostData, totalWeightOutShape, &totalWeightOutDeviceAddr, aclDataType::ACL_FLOAT,
	&totalWeightOut);
	CHECK_RET(ret == ACL_SUCCESS, return ret);

	// 3.调用CANN算子库API，需要修改为具体的算子接口
	uint64_t workspaceSize = 0;
	aclOpExecutor* executor;
	// 调用aclnnNLLLoss2d第一段接口
	ret = aclnnNLLLoss2dGetWorkspaceSize(self, target, weight, reduction, ignoreIndex, out, totalWeightOut, &workspaceSize,
	&executor);
	CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNLLLoss2dGetWorkspaceSize 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;
    // 调用aclnnNLLLoss2d第二段接口
    ret = aclnnNLLLoss2d(workspaceAddr, workspaceSize, executor, stream);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNLLLoss2d 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(target);
    aclDestroyTensor(weight);
    aclDestroyTensor(out);
    return 0;
&#125;

父主题： NN类算子接口

aclnnNLLLoss2dBackward

接口原型

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

功能描述

算子功能：负对数似然损失函数（aclnnNLLLoss2d）的反向传播。

aclnnNLLLoss2dBackwardGetWorkspaceSize

接口定义：

aclnnStatus aclnnNLLLoss2dBackwardGetWorkspaceSize(const aclTensor *gradOutput, const aclTensor *self, const aclTensor *target, const aclTensor *weight, int64_t reduction, int64_t ignoreIndex, aclTensor *totalWeight, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- gradOutput：Device侧的aclTensor，shape为三维（第一维是N）或者一维（且元素个数为1），数据类型支持FLOAT、FLOAT16。支持非连续的Tensor，数据格式支持ND。
- self：Device侧的aclTensor，shape为四维，第一维是N表示batch size，第二维是C表示类别，数据类型支持FLOAT、FLOAT16。支持非连续的Tensor，数据格式支持ND。
- target：Device侧的aclTensor，表示真实标签，shape为三维，第一维是N，其中每个元素的取值范围是[0, C-1]，数据类型支持INT64、UINT8。支持非连续的Tensor，数据格式支持ND。
- weight：Device侧的aclTensor，表示各个类别的权重，shape为(C, )，数据类型支持FLOAT、FLOAT16。支持非连续的Tensor，数据格式支持ND。
- reduction：Host侧的int64_t，指定要应用到输出的缩减。支持3种枚举值：当取值为0，即为"none"，表示不应用减少；当取值为1，即为"mean"，表示输出的总和将除以输出中的元素数；当取值为2，即为"sum"，表示输出将被求和。
- ignoreIndex：Host侧的int64_t，指定一个被忽略且不影响输入梯度的目标值。
- totalWeight：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16，且数据类型为与weight相同，shape为(1, )，数据格式支持ND。
- out：Device侧的aclTensor，shape与self相同，数据类型支持FLOAT。数据格式支持ND，数据类型和数据格式需要与self一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的gradOutput、self、target、weight、totalWeight或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - gradOutput、self、target、weight、totalWeight或out的数据类型和数据格式不在支持的范围内。
  - target非3维Tensor，self非4维Tensor。
  - weight的元素个数不是C。
  - self的第0、2、3维的元素个数和target的第0、1、2维元素个数不相等。
  - totalWeight的元素个数不是1。
  - reduction是none时，gradOutput的维数不是3或者gradOutput的第0、1、2维的元素个数和target的第0、1、2维元素个数不相等。
  - reduction不是none时，gradOutput的维数大于1或者元素个数不为1。
  - reduction值不在0~2范围之内。 :::

aclnnNLLLoss2dBackward

接口定义：

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

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

调用示例

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

  // 2. 构造输入与输出，需要根据API的接口自定义构造
  std::vector<int64_t> gradShape = &#123;3, 1, 1&#125;;
  std::vector<int64_t> selfShape = &#123;3, 5, 1, 1&#125;;
  std::vector<int64_t> targetShape = &#123;3, 1, 1&#125;;
  std::vector<int64_t> weightShape = &#123;5&#125;;
  std::vector<int64_t> totalWeightShape = &#123;1&#125;;
  std::vector<int64_t> outShape = &#123;3, 5, 1, 1&#125;;
  void* gradDeviceAddr = nullptr;
  void* selfDeviceAddr = nullptr;
  void* targetDeviceAddr = nullptr;
  void* weightDeviceAddr = nullptr;
  void* totalWeightDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* grad = nullptr;
  aclTensor* self = nullptr;
  aclTensor* target = nullptr;
  aclTensor* weight = nullptr;
  aclTensor* totalWeight = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> gradHostData = &#123;2.7, 2.6, 2.5&#125;;
  std::vector<float> selfHostData = &#123;4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5.0, 5.1, 5.2, 5.3, 5.4, 5.5&#125;;
  std::vector<int64_t> targetHostData = &#123;2, 3, 1&#125;;
  std::vector<float> weightHostData = &#123;1.0, 1.0, 1.0, 1.0, 1.0&#125;;
  std::vector<float> totalWeightHostData = &#123;1.0&#125;;
  std::vector<float> outHostData = &#123;0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0&#125;;
  int64_t reduction = 0;
  int64_t ignoreIndex = -100;

  // 创建grad aclTensor
  ret = CreateAclTensor(gradHostData, gradShape, &gradDeviceAddr, aclDataType::ACL_FLOAT, &grad);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建target aclTensor
  ret = CreateAclTensor(targetHostData, targetShape, &targetDeviceAddr, aclDataType::ACL_INT64, &target);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建weight aclTensor
  ret = CreateAclTensor(weightHostData, weightShape, &weightDeviceAddr, aclDataType::ACL_FLOAT, &weight);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建totalWeight aclTensor
  ret = CreateAclTensor(totalWeightHostData, totalWeightShape, &totalWeightDeviceAddr,
                        aclDataType::ACL_FLOAT, &totalWeight);
  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;
  // 调用aclnnNLLLoss2dBackward第一段接口
  ret = aclnnNLLLoss2dBackwardGetWorkspaceSize(grad, self, target, weight, reduction, ignoreIndex, totalWeight, out,
                                  &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNLLLoss2dBackwardGetWorkspaceSize 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;
  // 调用aclnnNLLLoss2dBackward第二段接口
  ret = aclnnNLLLoss2dBackward(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNLLLoss2dBackward 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(grad);
  aclDestroyTensor(self);
  aclDestroyTensor(target);
  aclDestroyTensor(weight);
  aclDestroyTensor(totalWeight);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnNonzero

接口原型

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

功能描述

算子功能：按行优先排列返回张量self中非0元素索引的张量。

aclnnNonzeroGetWorkspaceSize

接口定义：

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

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

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

aclnnNonzero

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_nonzero.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> selfShape = &#123;4, 2&#125;;
  std::vector<int64_t> outShape = &#123;7, 2&#125;;
  void* selfDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* self = nullptr;
  aclTensor* out = nullptr;
  std::vector<float> selfHostData = &#123;0, 1, 2, 3, 4, 5, 6, 7&#125;;
  std::vector<int64_t> outHostData(14, 0);
  // 创建self aclTensor
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // 创建out aclTensor
  ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_INT64, &out);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3. 调用CANN算子库API，需要修改为具体的API名称
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnNonzero第一段接口
  ret = aclnnNonzeroGetWorkspaceSize(self, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNonzeroGetWorkspaceSize 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;
  // 调用aclnnNonzero第二段接口
  ret = aclnnNonzero(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNonzero 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<int64_t> 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: %ld\n", i, resultData[i]);
  &#125;

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

父主题： NN类算子接口

aclnnNorm

接口原型

**第一段接口：**aclnnStatus aclnnNormGetWorkspaceSize(const aclTensor *self, const aclScalar *p, const aclIntArray* dim, bool keepDim，aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
第二段接口：aclnnStatus aclnnNorm(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：计算张量的矩阵范数或向量范数。
计算公式：
- 1-范数：
- 2-范数：
- 无穷-范数
常见的矩阵范数除了1、2范数和无穷范数之外，还包括F范数（表示矩阵元素绝对值的平方和再开平方）、核范数（表示所有矩阵行向量绝对值之和的最大值）等数学范数。

aclnnNormGetWorkspaceSize

接口定义：

aclnnStatus aclnnNormGetWorkspaceSize(const aclTensor *self, const aclScalar *p, const aclIntArray* dim, bool keepDim，aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- self：Device侧的aclTensor，数据类型支持FLOAT、FLOAT16、BFLOAT16（仅Atlas A2训练系列产品支持）、DOUBLE、COMPLEX64、COMPLEX128。支持非连续的Tensor，数据格式支持ND。
- p：Host侧的aclScalar，范数类型，数据类型仅支持INT32。
- dim：指定要计算范数的维度，Host侧的aclIntArray，数据类型支持INT32。如果dim为None，将在self的所有维度上计算范数。
- keepDim：输出张量是否保留dim，Host侧的aclScalar。当dim=None和out=None则忽略。默认值为False，数据类型支持BOOL。
- out：表示输出张量，Device侧的aclTensor。数据类型支持FLOAT、FLOAT16、BFLOAT16（仅Atlas A2训练系列产品支持）、DOUBLE、COMPLEX64、COMPLEX128，数据格式支持ND，且数据格式需要与self一致。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

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

aclnnNorm

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_norm.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;
  aclScalar* pScalar = nullptr;
  aclIntArray* dim = 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;;
  std::vector<int64_t> dimData = &#123;0&#125;;
  float pValue = 0.0f;
  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);
  // 创建p aclScalar
  pScalar = aclCreateScalar(&pValue, aclDataType::ACL_FLOAT);
  CHECK_RET(pScalar != nullptr, return ret);
  // 创建dim aclIntArray
  dim = aclCreateIntArray(dimData.data(), 1);
  CHECK_RET(dim != nullptr, return ret);

  // 3.调用CANN算子库API，需要修改为具体的算子接口
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // 调用aclnnNormGetWorkspaceSize第一段接口
  ret = aclnnNormGetWorkspaceSize(self, pScalar, dim, keepDim, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormGetWorkspaceSize 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;
  // 调用aclnnNorm第二段接口
  ret = aclnnNorm(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNorm 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(dim);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnNormalFloatFloat

接口原型

**第一段接口：**aclnnStatus aclnnNormalFloatFloatGetWorkspaceSize(float mean, float std, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnNormalFloatFloat(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：生成随机数张量，该随机数是从给定的均值（float）和标准差（float）的独立正态分布中获取。

aclnnNormalFloatFloatGetWorkspaceSize

接口定义：

aclnnStatus aclnnNormalFloatFloatGetWorkspaceSize(float mean, float std, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- mean：计算输入，生成随机数分布的均值，数据类型支持FLOAT。
- std：计算输入，生成随机数分布的方差，数据类型支持FLOAT。
- seed：计算输入，采样伪随机数生成器的种子值，数据类型支持INT64。
- offset：计算输入，采样伪随机数生成器的的偏移量，数据类型支持INT64。
- out：Device侧的aclTensor，输出张量，数据类型支持FLOAT16、FLOAT32、DOUBLE，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - 传入的mean和std的数据类型不在支持的范围之内。
  - 推导出的数据类型无法转换为指定输出out的类型。
  - seed和offset的数据类型和取值范围不符合接口入参要求。 :::

aclnnNormalFloatFloat

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_normal_v2.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> outShape = &#123;1, 4&#125;;
  void* outDeviceAddr = nullptr;
  aclTensor* out= nullptr;
  std::vector<float> outHostData = &#123;0.0, 0.0, 0.0, 0.0&#125;;
  float mean = 3.2f;
  float std = 1.2f;
  int64_t seed = 1;
  int64_t offset = 1;
  // 创建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;
  // 调用aclnnNormalFloatFloat第一段接口
  ret = aclnnNormalFloatFloatGetWorkspaceSize(mean, std, seed, offset, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormalFloatFloatGetWorkspaceSize 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;
  // 调用aclnnNormalFloatFloat第二段接口
  ret = aclnnNormalFloatFloat(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormalFloatFloat 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侧
  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(out);
  return 0;
&#125;

父主题： NN类算子接口

aclnnNormalFloatTensor

接口原型

**第一段接口：**aclnnStatus aclnnNormalFloatTensorGetWorkspaceSize(float mean, const aclTensor *std, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
**第二段接口：**aclnnStatus aclnnNormalFloatTensor(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor, aclrtStream stream)

功能描述

算子功能：生成随机数张量，该随机数是从给定的均值（float）和标准差（tensor）的独立正态分布中获取。

aclnnNormalFloatTensorGetWorkspaceSize

接口定义：

aclnnStatus aclnnNormalFloatTensorGetWorkspaceSize(float mean, const aclTensor *std, int64_t seed, int64_t offset, aclTensor *out, uint64_t *workspaceSize, aclOpExecutor **executor)
参数说明：
- mean：计算输入，生成随机数分布的均值，数据类型支持FLOAT。
- std：计算输入，Device侧的aclTensor，生成随机数分布方差的张量，数据类型支持FLOAT16、FLOAT32、DOUBLE。数据格式支持ND，张量中元素总数和均值元素需保持一致。
- seed：计算输入，采样伪随机数生成器的种子值，数据类型支持INT64，数据格式支持ND。需要满足step不等于0。
- offset：计算输入，采样伪随机数生成器的的偏移量，数据类型支持INT64，数据格式支持ND。
- out：Device侧的aclTensor，输出张量，数据类型支持FLOAT16、FLOAT32、DOUBLE，数据格式支持ND。
- workspaceSize：返回用户需要在Device侧申请的workspace大小。
- executor：返回op执行器，包含了算子计算流程。
返回值：

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

:::note 说明第一段接口完成入参校验，出现以下场景时报错：
- 返回161001（ACLNN_ERR_PARAM_NULLPTR）：传入的std或out是空指针。
- 返回161002（ACLNN_ERR_PARAM_INVALID）：
  - 传入的mean和std的数据类型不在支持的范围之内。
  - 推导出的数据类型无法转换为指定输出out的类型。
  - mean、seed和offset的数据类型和取值范围不符合接口入参要求。 :::

aclnnNormalFloatTensor

接口定义：

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

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

调用示例

#include <iostream>
#include <vector>
#include "acl/acl.h"
#include "aclnnop/aclnn_normal_v2.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> stdShape = &#123;1, 4&#125;;
  std::vector<int64_t> outShape = &#123;1, 4&#125;;
  void* stdDeviceAddr = nullptr;
  void* outDeviceAddr = nullptr;
  aclTensor* std= nullptr;
  aclTensor* out= nullptr;
  std::vector<float> stdHostData = &#123;1.1, 1.2, 1.3, 1.4&#125;;
  std::vector<float> outHostData = &#123;0.0, 0.0, 0.0, 0.0&#125;;
  float mean = 1.2f;
  int64_t seed = 1;
  int64_t offset = 1;
  // 创建self aclTensor
  ret = CreateAclTensor(stdHostData , stdShape , &stdDeviceAddr , aclDataType::ACL_FLOAT, &std);
  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;
  // 调用aclnnNormalFloatTensor第一段接口
  ret = aclnnNormalFloatTensorGetWorkspaceSize(mean, std, seed, offset, out, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormalFloatTensorGetWorkspaceSize 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;
  // 调用aclnnNormalFloatTensor第二段接口
  ret = aclnnNormalFloatTensor(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnNormalFloatTensor 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侧
  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(std);
  aclDestroyTensor(out);
  return 0;
&#125;

父主题： NN类算子接口

在线提单

aclnnNLLLossBackward​

接口原型​

功能描述​

aclnnNLLLossBackwardGetWorkspaceSize​

aclnnNLLLossBackward​

调用示例​

aclnnNLLLoss2d​

接口原型​

功能描述​

aclnnNLLLoss2dGetWorkspaceSize​

aclnnNLLLoss2d​

调用示例​

aclnnNLLLoss2dBackward​

接口原型​

功能描述​

aclnnNLLLoss2dBackwardGetWorkspaceSize​

aclnnNLLLoss2dBackward​

调用示例​

aclnnNonzero​

接口原型​

功能描述​

aclnnNonzeroGetWorkspaceSize​

aclnnNonzero​

调用示例​

aclnnNorm​

接口原型​

功能描述​

aclnnNormGetWorkspaceSize​

aclnnNorm​

调用示例​

aclnnNormalFloatFloat​

接口原型​

功能描述​

aclnnNormalFloatFloatGetWorkspaceSize​

aclnnNormalFloatFloat​

调用示例​

aclnnNormalFloatTensor​

接口原型​

功能描述​

aclnnNormalFloatTensorGetWorkspaceSize​

aclnnNormalFloatTensor​

调用示例​

aclnnNLLLossBackward

接口原型

功能描述

aclnnNLLLossBackwardGetWorkspaceSize

aclnnNLLLossBackward

调用示例

aclnnNLLLoss2d

接口原型

功能描述

aclnnNLLLoss2dGetWorkspaceSize

aclnnNLLLoss2d

调用示例

aclnnNLLLoss2dBackward

接口原型

功能描述

aclnnNLLLoss2dBackwardGetWorkspaceSize

aclnnNLLLoss2dBackward

调用示例

aclnnNonzero

接口原型

功能描述

aclnnNonzeroGetWorkspaceSize

aclnnNonzero

调用示例

aclnnNorm

接口原型

功能描述

aclnnNormGetWorkspaceSize

aclnnNorm

调用示例

aclnnNormalFloatFloat

接口原型

功能描述

aclnnNormalFloatFloatGetWorkspaceSize

aclnnNormalFloatFloat

调用示例

aclnnNormalFloatTensor

接口原型

功能描述

aclnnNormalFloatTensorGetWorkspaceSize

aclnnNormalFloatTensor

调用示例