aclnnAdaLayerNormBackward

📄 查看源码

产品支持情况

产品	是否支持
Ascend 950PR/Ascend 950DT	×
Atlas A3 训练系列产品/Atlas A3 推理系列产品	√
Atlas A2 训练系列产品/Atlas A2 推理系列产品	√
Atlas 200I/500 A2 推理产品	×
Atlas 推理系列产品	×
Atlas 训练系列产品	×

功能说明

• 接口功能：aclnnAdaLayerNormV2的反向传播。用于计算输入张量的梯度，以便在反向传播过程中更新模型参数。

• 计算公式：

  正向：

  $$out=LayerNorm(input)\times (1+scale)+shift$$

  反向：

  $$z=(input-mean)\times rstd$$

  $$dy\_g=gradOut\times weightOptional\times (1+scale)$$

  $$tem{p}_1=1/N\times \sum _{reduce\_axis\_2}(gradOut\times weightOptional\times (1+scale))$$

  $$tem{p}_2=1/N\times (input-mean)\times rstd\times \sum _{reduce\_axis\_2}(gradOut\times weightOptional\times (1+scale)\times (input-mean)\times rstd)$$

  $$gradInputOut=(gradOut\times weightOptional\times (1+scale)-(tem{p}_1+tem{p}_2))\times rstd$$

  $$gradScaleOut=\sum _{reduce\_axis\_1}(gradOut\times ((input-mean)\times rstd\times weightOptional+biasOptional))$$

  $$gradShiftOut=\sum _{reduce\_axis\_1}gradOut$$

  $$gradWeightOut=\sum _{reduce\_axis\_0,1}gradOut\times (1+scale)\times (input-mean)\times rstd$$

  $$gradBiasOut=\sum _{reduce\_axis\_0,1}gradOut\times (1+scale)$$

  其中，N为进行归一化计算的轴的维度，即归一化轴维度的大小。

函数原型

每个算子分为两段式接口，必须先调用“aclnnAdaLayerNormBackwardGetWorkspaceSize”接口获取计算所需workspace大小以及包含了算子计算流程的执行器，再调用“aclnnAdaLayerNormBackward”接口执行计算。

aclnnStatus aclnnAdaLayerNormBackwardGetWorkspaceSize(
    const aclTensor*    gradOut, 
    const aclTensor*    input, 
    const aclIntArray*  normalizedShape, 
    const aclTensor*    rstd,
    const aclTensor*    mean, 
    const aclTensor*    scale, 
    const aclTensor*    shift, 
    const aclTensor*    weightOptional, 
    const aclTensor*    biasOptional, 
    aclTensor*          gradInputOut, 
    aclTensor*          gradScaleOut, 
    aclTensor*          gradShiftOut,
    aclTensor*          gradWeightOut, 
    aclTensor*          gradBiasOut, 
    uint64_t*           workspaceSize, 
    aclOpExecutor**     executor)

aclnnStatus aclnnAdaLayerNormBackward(
  void*          workspace, 
  uint64_t       workspaceSize, 
  aclOpExecutor* executor, 
  aclrtStream    stream)

aclnnAdaLayerNormBackwardGetWorkspaceSize

• 参数说明

  参数名	输入/输出	描述	使用说明	数据类型	数据格式	维度(shape)	非连续Tensor
  gradOut（aclTensor*）	输入	表示反向计算的梯度Tensor，对应计算公式中的`gradOut`。	不支持空Tensor。 与输入`input`的数据类型相同。 shape为[B, S, H]，其中B支持0-6维。	FLOAT32、FLOAT16、BFLOAT16	ND	2-8	√
  input（aclTensor*）	输入	表示正向计算的首个输入，对应计算公式中的`input`。	不支持空Tensor。 与输入`gradOut`的数据类型相同。 shape与`gradOut`的shape相等，为[B, S, H], 其中B支持0-6维。	FLOAT32、FLOAT16、BFLOAT16	ND	2-8	√
  normalizedShape（aclIntArray*）	输入	表示需要进行norm计算的维度，对应计算公式中的`reduce_axis_2`。	公式中的`reduce_axis_0`对应维度B，`reduce_axis_1`对应维度S，B和S维度不进行norm计算的维度。 在此处值固定为长度为1的数组，数组固定元素为[H]，不支持为空。	INT64	-	-	-
  mean（aclTensor*）	输入	正向计算的第二个输出，表示`input`的均值，对应计算公式中的`mean`。	不支持空Tensor。 与输入`gradOut`的数据类型相同且位宽不低于输入`input`的数据类型位宽。 shape与`rstd`的shape相等，为[B, S, 1]，最后一维固定为1，其他维度与`input`一致。	FLOAT32、FLOAT16、BFLOAT16	ND	2-8	√
  rstd（aclTensor*）	输入	正向计算的第三个输出，表示`input`的标准差的倒数，对应计算公式中的`rstd`。	不支持空Tensor。 与输入`gradOut`的数据类型相同且位宽不低于输入`input`的数据类型位宽。 shape与`mean`的shape相等，为[B, S, 1]，最后一维固定为1，其他维度与`input`一致。	FLOAT32、FLOAT16、BFLOAT16	ND	2-8	√
  scale（aclTensor*）	输入	表示自适应缩放参数。对应计算公式中的`scale`。	不支持空Tensor。 数据类型与`gradOut`的数据类型一致。 shape为[B, H]或[B, 1, H]，其中B支持0-6维，维度数量和大小与`gradOut`中的B保持一致，H与`gradOut`中H维一致。	FLOAT32、FLOAT16、BFLOAT16	ND	1-8	√
  shift（aclTensor*）	输入	表示自适应偏移参数。	不支持空Tensor。 数据类型与入参`gradOut`的数据类型一致。 shape为[B, H]或[B, 1, H]，其中B支持0-6维，维度数量和大小与`gradOut`中的B保持一致，H与`gradOut`中H维一致。	FLOAT32、FLOAT16、BFLOAT16	ND	1-8	√
  weightOptional（aclTensor*）	输入	可选输入参数，表示归一化缩放参数。对应计算公式中的`weightOptional`。	不支持空Tensor。 当数据类型不为FLOAT32时，参数数据类型与`input`相同。 shape为[H]，H与`gradOut`中H维一致。	FLOAT32、FLOAT16、BFLOAT16	ND	1	√
  biasOptional（aclTensor*）	输入	可选输入参数，表示归一化偏移参数。对应计算公式中的`biasOptional`。	不支持空Tensor。 数据类型与可选参数`weightOptional`一致。 shape为[H]，H与`gradOut`中H维一致。	FLOAT32、FLOAT16、BFLOAT16	ND	1	√
  gradInputOut（aclTensor*）	输出	可选输出，表示反向传播的输出梯度，对应计算公式中的`gradInputOut`。	不支持空Tensor。 当指针`gradInputOut`不为空时，输出`input`梯度计算结果，且其与输入`input`的数据类型相同。 shape与`input`的shape相等，为[B, S, H]。	FLOAT32、FLOAT16、BFLOAT16	ND	2-8	√
  gradScaleOut（aclTensor*）	输出	可选输出，表示反向传播自适应缩放系数的梯度，对应计算公式中的`gradScaleOut`。	不支持空Tensor。 当指针`gradScaleOut`不为空时，输出`scale`梯度计算结果，且其与输入`input`的数据类型相同。 shape与`scale`的shape相等，为[B, H]或[B, 1, H]。	FLOAT32、FLOAT16、BFLOAT16	ND	1-8	√
  gradShiftOut（aclTensor*）	输出	可选输出，表示反向传播自适应偏移系数的梯度，对应计算公式中的`gradShiftOut`。	不支持空Tensor。 当指针`gradShiftOut`不为空时，输出`shift`梯度计算结果，且其与输入`input`的数据类型相同。 shape与`shift`的shape相等，为[B, H]或[B, 1, H]。	FLOAT32、FLOAT16、BFLOAT16	ND	1-8	√
  gradWeightOut（aclTensor*）	输出	可选输出，表示反向传播归一化缩放系数的梯度，对应计算公式中的`gradWeightOut`。	不支持空Tensor。 当指针`gradWeightOut`不为空时，输出`weightOptional`梯度计算结果，且其与输入`weightOptional`的数据类型相同。 shape与`weightOptional`的shape相等，为[H]。	FLOAT32、FLOAT16、BFLOAT16	ND	1	√
  gradBiasOut（aclTensor*）	输出	可选输出，表示反向传播归一化偏置系数的梯度，对应计算公式中的`gradBiasOut`。	不支持空Tensor。 当指针`gradBiasOut`不为空时，输出`biasOptional`梯度计算结果，且其与输入`weightOptional`的数据类型相同。 shape与`gradWeightOut`的shape相等，为[H]。	FLOAT32、FLOAT16、BFLOAT16	ND	1	√
  workspaceSize（uint64_t*）	输出	返回需要在Device侧申请的workspace大小。	-	-	-	-	-
  executor（aclOpExecutor**）	输出	返回op执行器，包含了算子计算流程。	-	-	-	-	-

• 返回值

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

  第一段接口完成入参校验，出现以下场景时报错：

  返回码	错误码	描述
  ACLNN_ERR_PARAM_NULLPTR	161001	传入的gradOut、input、normalizedShape、mean、rstd、scale、shift为空指针。
  ACLNN_ERR_PARAM_INVALID	161002	gradOut、weightOptional（非空时）或biasOptional（非空时）的数据类型不在支持范围内。
  		input、mean、rstd、scale、shift数据类型与gradOut不相同。
  		weightOptional（非空时）与biasOptional（非空时）数据类型不相同。
  		weightOptional（非空时）与biasOptional（非空时）不满足约束（当数据类型不为FLOAT32，数据类型与input相同）。
  		gradInputOut（非空时）、gradScaleOut（非空时）、gradShiftOut（非空时）、gradWeightOut（非空时）或gradBiasOut（非空时）数据类型与参数说明中不一致。
  		input的维度小于2。
  		normalizedShape数组长度不为1。
  		input的shape数组与normalizedShape数组右对齐时对应维度不相等。
  		gradOut的shape与input的shape不相等。
  		mean的shape乘积与input从第0轴到第len(input) - len(normalizedShape)轴的乘积不相等。
  		rstd的shape乘积与input从第0根轴到第len(input) - len(normalizedShape)轴的乘积不相等。
  		scale的shape不等于[B, 1, H]或[B, H]。
  		shift的shape不等于[B, 1, H]或[B, H]。
  		gradScaleOut（非空时）shape与scale不相等。
  		gradShiftOut（非空时）shape与shift不相等。
  		weightOptional非空且shape数组与normalizedShape数组不相等。
  		biasOptional非空且shape数组与normalizedShape数组不相等。
  		gradOut，input，mean，rstd，scale，shift，weightOptional（非空时），biasOptional（非空时），gradInputOut（非空时），gradScaleOut（非空时），gradShiftOut（非空时），gradWeightOut（非空时），gradBiasOut（非空时）的shape维度大于8维。

aclnnAdaLayerNormBackward

• 参数说明

  参数名	输入/输出	描述
  workspace	输入	在Device侧申请的workspace内存地址。
  workspaceSize	输入	在Device侧申请的workspace大小，由第一段接口aclnnAdaLayerNormBackwardGetWorkspaceSize获取。
  executor	输入	op执行器，包含了算子计算流程。
  stream	输入	指定执行任务的Stream。

• 返回值

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

约束说明

• 混合精度搭配：

  • AdaLayerNormBackward算子下列参数数据类型一致：

    分组	包含的具体参数名
    Group A	gradOut、input、rstd、mean、scale、shift、gradInputOut、gradScaleOut、gradShiftOut
    Group B	weightOptional、biasOptional、gradWeightOut、gradBiasOut

  • 上述两类数据类型固定搭配类型为（左侧和右侧数据类型严格对应）：

    第一类参数（Group A）	第二类参数（Group B）
    FLOAT32	FLOAT32
    FLOAT16	FLOAT16
    FLOAT16	FLOAT32
    BFLOAT16	BFLOAT16
    BFLOAT16	FLOAT32

• 确定性计算：

  • aclnnAdaLayerNormBackward默认确定性实现。

调用示例

示例代码如下，仅供参考，具体编译和执行过程请参考编译与运行样例。

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

#define CHECK_RET(cond, return_expr) \
    do {                             \
        if (!(cond)) {               \
            return_expr;             \
        }                            \
    } while (0)

#define LOG_PRINT(message, ...)         \
    do {                                \
        printf(message, ##__VA_ARGS__); \
    } while (0)

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

int Init(int32_t deviceId, aclrtStream* stream)
{
    // 固定写法，资源初始化
    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 = aclrtCreateStream(stream);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtCreateStream failed. ERROR: %d\n", ret); return ret);
    return 0;
}

template <typename T>
int CreateAclTensor(
    const std::vector<T>& hostData, const std::vector<int64_t>& shape, void** deviceAddr, aclDataType dataType,
    aclTensor** tensor)
{
    auto size = GetShapeSize(shape) * sizeof(T);
    // 调用aclrtMalloc申请device侧内存
    auto ret = aclrtMalloc(deviceAddr, size, ACL_MEM_MALLOC_HUGE_FIRST);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); return ret);
    // 调用aclrtMemcpy将host侧数据拷贝到device侧内存上
    ret = aclrtMemcpy(*deviceAddr, size, hostData.data(), size, ACL_MEMCPY_HOST_TO_DEVICE);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtMemcpy failed. ERROR: %d\n", ret); return ret);

    // 计算连续tensor的strides
    std::vector<int64_t> strides(shape.size(), 1);
    for (int64_t i = shape.size() - 2; i >= 0; i--) {
        strides[i] = shape[i + 1] * strides[i + 1];
    }

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

int main()
{
    // 1.（固定写法）device/stream初始化，参考acl API手册
    // 根据自己的实际device填写deviceId
    int32_t deviceId = 0;
    aclrtStream stream;
    auto ret = Init(deviceId, &stream);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);

    // 2. 构造输入与输出，需要根据API的接口自定义构造
    std::vector<int64_t> xShape = {2, 2, 2};
    std::vector<int64_t> meanShape = {2, 2, 1};
    std::vector<int64_t> scaleShape = {2, 2};
    std::vector<int64_t> shiftShape = {2, 2};
    std::vector<int64_t> normShape = {2};
    void* dyDeviceAddr = nullptr;
    void* xDeviceAddr = nullptr;
    void* rstdDeviceAddr = nullptr;
    void* meanDeviceAddr = nullptr;
    void* scaleDeviceAddr = nullptr;
    void* shiftDeviceAddr = nullptr;
    void* weightDeviceAddr = nullptr;
    void* biasDeviceAddr = nullptr;
    void* outDeviceAddr = nullptr;
    void* dsDeviceAddr = nullptr;
    void* dtDeviceAddr = nullptr;
    void* dwDeviceAddr = nullptr;
    void* dbDeviceAddr = nullptr;
    aclTensor* dy = nullptr;
    aclTensor* x = nullptr;
    aclIntArray* norm = nullptr;
    aclTensor* rstd = nullptr;
    aclTensor* mean = nullptr;
    aclTensor* scale = nullptr;
    aclTensor* shift = nullptr;
    aclTensor* weight = nullptr;
    aclTensor* bias = nullptr;
    aclTensor* out = nullptr;
    aclTensor* ds = nullptr;
    aclTensor* dt = nullptr;
    aclTensor* dw = nullptr;
    aclTensor* db = nullptr;
    std::vector<float> dyHostData = {2, 3, 4, 5, 2, 3, 4, 5};
    std::vector<float> xHostData = {2, 3, 4, 5, 2, 3, 4, 5};
    std::vector<int64_t> normData = {2};
    std::vector<float> meanHostData = {2, 3, 4, 5};
    std::vector<float> rstdHostData = {4, 5, 6, 7};
    std::vector<float> scaleHostData = {1, 1, 2, 2};
    std::vector<float> shiftHostData = {2, 2, 1, 1};
    std::vector<float> weightHostData = {1, 1};
    std::vector<float> biasHostData = {0, 0};
    std::vector<float> outHostData(8, 0);
    std::vector<float> dsHostData(4, 0);
    std::vector<float> dtHostData(4, 0);
    std::vector<float> dwHostData(2, 0);
    std::vector<float> dbHostData(2, 0);

    // 创建dy aclTensor
    ret = CreateAclTensor(dyHostData, xShape, &dyDeviceAddr, aclDataType::ACL_FLOAT, &dy);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // 创建x aclTensor
    ret = CreateAclTensor(xHostData, xShape, &xDeviceAddr, aclDataType::ACL_FLOAT, &x);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // 创建normalizedShape aclIntArray
    norm = aclCreateIntArray(normData.data(), 1);
    CHECK_RET(norm != nullptr, return ret);
    // 创建rstd aclTensor
    ret = CreateAclTensor(rstdHostData, meanShape, &rstdDeviceAddr, aclDataType::ACL_FLOAT, &rstd);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // 创建mean aclTensor
    ret = CreateAclTensor(meanHostData, meanShape, &meanDeviceAddr, aclDataType::ACL_FLOAT, &mean);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // 创建scale aclTensor
    ret = CreateAclTensor(scaleHostData, scaleShape, &scaleDeviceAddr, aclDataType::ACL_FLOAT, &scale);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // 创建shift aclTensor
    ret = CreateAclTensor(shiftHostData, shiftShape, &shiftDeviceAddr, aclDataType::ACL_FLOAT, &shift);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // 创建weight aclTensor
    ret = CreateAclTensor(weightHostData, normShape, &weightDeviceAddr, aclDataType::ACL_FLOAT, &weight);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // 创建bias aclTensor
    ret = CreateAclTensor(biasHostData, normShape, &biasDeviceAddr, aclDataType::ACL_FLOAT, &bias);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // 创建out aclTensor
    ret = CreateAclTensor(outHostData, xShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // 创建ds aclTensor
    ret = CreateAclTensor(dsHostData, scaleShape, &dsDeviceAddr, aclDataType::ACL_FLOAT, &ds);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // 创建dt aclTensor
    ret = CreateAclTensor(dtHostData, shiftShape, &dtDeviceAddr, aclDataType::ACL_FLOAT, &dt);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // 创建dw aclTensor
    ret = CreateAclTensor(dwHostData, normShape, &dwDeviceAddr, aclDataType::ACL_FLOAT, &dw);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // 创建db aclTensor
    ret = CreateAclTensor(dbHostData, normShape, &dbDeviceAddr, aclDataType::ACL_FLOAT, &db);
    CHECK_RET(ret == ACL_SUCCESS, return ret);

    // 3. 调用CANN算子库API，需要修改为具体的API名称
    uint64_t workspaceSize = 0;
    aclOpExecutor* executor;
    // 调用aclnnAdaLayerNormBackward第一段接口
    ret = aclnnAdaLayerNormBackwardGetWorkspaceSize(
        dy, x, norm, rstd, mean, scale, shift, weight, bias, out, ds, dt, dw, db, &workspaceSize, &executor);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAdaLayerNormBackwardGetWorkspaceSize failed. ERROR: %d\n", ret);
              return ret);
    // 根据第一段接口计算出的workspaceSize申请device内存
    void* workspaceAddr = nullptr;
    if (workspaceSize > 0) {
        ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
        CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); return ret);
    }
    // 调用aclnnAdaLayerNormBackward第二段接口
    ret = aclnnAdaLayerNormBackward(workspaceAddr, workspaceSize, executor, stream);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAdaLayerNormBackward 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(xShape);
    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++) {
        LOG_PRINT("out result[%ld] is: %f\n", i, resultData[i]);
    }

    auto size1 = GetShapeSize(scaleShape);
    std::vector<float> resultData1(size1, 0);
    ret = aclrtMemcpy(
        resultData1.data(), resultData1.size() * sizeof(resultData1[0]), dsDeviceAddr, size1 * sizeof(resultData1[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 < size1; i++) {
        LOG_PRINT("ds result[%ld] is: %f\n", i, resultData1[i]);
    }

    auto size2 = GetShapeSize(shiftShape);
    std::vector<float> resultData2(size2, 0);
    ret = aclrtMemcpy(
        resultData2.data(), resultData2.size() * sizeof(resultData2[0]), dtDeviceAddr, size2 * sizeof(resultData2[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 < size2; i++) {
        LOG_PRINT("dt result[%ld] is: %f\n", i, resultData2[i]);
    }

    auto size3 = GetShapeSize(normShape);
    std::vector<float> resultData3(size3, 0);
    ret = aclrtMemcpy(
        resultData3.data(), resultData3.size() * sizeof(resultData3[0]), dwDeviceAddr, size3 * sizeof(resultData3[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 < size3; i++) {
        LOG_PRINT("dw result[%ld] is: %f\n", i, resultData3[i]);
    }

    auto size4 = GetShapeSize(normShape);
    std::vector<float> resultData4(size4, 0);
    ret = aclrtMemcpy(
        resultData4.data(), resultData4.size() * sizeof(resultData4[0]), dbDeviceAddr, size4 * sizeof(resultData4[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 < size4; i++) {
        LOG_PRINT("db result[%ld] is: %f\n", i, resultData4[i]);
    }

    // 6. 释放aclTensor、aclIntArray和aclBoolArray，需要根据具体API的接口定义修改
    aclDestroyTensor(dy);
    aclDestroyTensor(x);
    aclDestroyIntArray(norm);
    aclDestroyTensor(mean);
    aclDestroyTensor(rstd);
    aclDestroyTensor(scale);
    aclDestroyTensor(shift);
    aclDestroyTensor(weight);
    aclDestroyTensor(bias);
    aclDestroyTensor(out);
    aclDestroyTensor(ds);
    aclDestroyTensor(dt);
    aclDestroyTensor(dw);
    aclDestroyTensor(db);

    // 7. 释放device 资源
    aclrtFree(dyDeviceAddr);
    aclrtFree(xDeviceAddr);
    aclrtFree(meanDeviceAddr);
    aclrtFree(rstdDeviceAddr);
    aclrtFree(scaleDeviceAddr);
    aclrtFree(shiftDeviceAddr);
    aclrtFree(weightDeviceAddr);
    aclrtFree(biasDeviceAddr);
    aclrtFree(outDeviceAddr);
    aclrtFree(dsDeviceAddr);
    aclrtFree(dtDeviceAddr);
    aclrtFree(dwDeviceAddr);
    aclrtFree(dbDeviceAddr);
    if (workspaceSize > 0) {
        aclrtFree(workspaceAddr);
    }
    aclrtDestroyStream(stream);
    aclrtResetDevice(deviceId);
    aclFinalize();

    return 0;
}