Documentation
Download
文档中心
aclnnPreluBackward

aclnnPreluBackward

📄 View Source Code

Applicable Products

ProductSupported
Ascend 950PR/Ascend 950DT√
Atlas A3 training products/Atlas A3 inference products√
Atlas A2 training products/Atlas A2 inference products√
Atlas 200I/500 A2 inference products×
Atlas inference products×
Atlas training products√

Function

Description: Completes the backward computation of aclnnPreluBackward.

The formula for gradInput is as follows:

gradInputi,j,...={gradOutputi,j,...,if selfi,j,...>0gradOutputi,j,...∗weighti,if selfi,j,...<=0gradInput_{i,j,...}= \begin{cases} gradOutput_{i,j,...}, & if\ self_{i,j,...} > 0 \\ gradOutput_{i,j,...} * weight_{i}, & if\ self_{i,j,...} <= 0 \end{cases}

The formula for gradWeight is as follows:

gradWeightj=∑i,...{0,if selfi,j,...>0gradOutputi,j,...∗selfi,j,...,if selfi,j,...<=0gradWeight_{j}=\sum_{i,...} \begin{cases} 0, & if\ self_{i,j,...} > 0 \\ gradOutput_{i,j,...} * self_{i,j,...}, & if\ self_{i,j,...} <= 0 \end{cases}

Function Prototype

Each operator is divided into a two-phase API. First call the "aclnnPreluBackwardGetWorkspaceSize" API to obtain the workspace size required for computation and the executor that contains the operator computation process, and then call the "aclnnPreluBackward" API to perform the computation.

aclnnStatus aclnnPreluBackwardGetWorkspaceSize(
  const aclTensor*  gradOutput,
  const aclTensor*  self,
  const aclTensor*  weight,
  aclTensor*        gradInput,
  aclTensor*        gradWeight,
  uint64_t*         workspaceSize,
  aclOpExecutor**   executor)
aclnnStatus aclnnPreluBackward(
  void*            workspace,
  uint64_t         workspace_size,
  aclOpExecutor*   executor,
  aclrtStream      stream)

aclnnPreluBackwardGetWorkspaceSize

  • Parameters:

    Parameter Input/Output Description Instruction Data Type Data Format Dimension (Shape) Non-contiguous Tensor
    gradOutput (aclTensor*) Input Gradient value for backward propagation. Corresponds to gradOutput in the formula.
    • Supports empty tensors.
    • The dtype must be the same as self.
    • The shape must satisfy the broadcast relationship with self, and the broadcast shape must equal the shape of self.
    		 FLOAT16, FLOAT32, BFLOAT16 ND 0-8 √
    self (aclTensor*) Input Forward input value of PReLU. Corresponds to self in the formula. Supports empty tensors. FLOAT16, FLOAT32, BFLOAT16 ND 0-8 √
    weight (aclTensor*) Input PReLU weight, i.e., weight in the formula.
    • An empty tensor is supported.
    • The data type must be the same as that of self.
    • When the shape of self has more than one dimension, the shape of weight can be the same as that of self with the value of the second dimension kept consistent and the values of other dimensions set to 1; or weight can be a 1D tensor whose number of elements equals the second dimension of the shape of self.
    • Otherwise, the number of elements in weight is 1.
    		 FLOAT16, FLOAT32, BFLOAT16 ND 0-8 √
    gradInput (aclTensor*) Output Gradient value of self.
    • dtype must be the same as self.
    • shape must satisfy the broadcast relationship with gradOutput
    • The shape and data type of gradInput are the same as those of self.
    		 FLOAT, FLOAT16, BFLOAT16 ND 0-8 √
    gradWeight (aclTensor*) Output Gradient value of weight.
    • The dtype must be the same as self.
    • The dtype must be the same as weight.
    • The shape of gradWeight must be consistent with the shape of weight.
    		 FLOAT, FLOAT16, BFLOAT16 ND 0-8 √
    workspaceSize (uint64_t*) Output Returns the workspace size to be requested on the Device side. - - - - -
    executor (aclOpExecutor**) Output Returns the op executor, which contains the operator computation flow. - - - - -
    • Atlas training products: data types FLOAT16 and FLOAT32 are supported.

  • Return value

    aclnnStatus: return code. For details, see aclnn Return Code.

    The first-phase API performs input parameter validation and returns an error in the following scenarios:

    Return Code Error Code Description
    ACLNN_ERR_PARAM_NULLPTR 161001 The input gradOutput, self, weight, gradInput, and gradWeight are null pointers.
    ACLNN_ERR_PARAM_INVALID 161002 The data types of gradOutput, self, weight, gradInput, and gradWeight are not within the supported range.
    The data types of gradOutput, self, weight, gradInput, and gradWeight are different.
    gradOutput, self, weight, gradInput, or gradWeight has more than 8 dimensions.
    The number of elements in weight is not equal to the number of channels in self or 1.
    When the number of elements in weight is 1, the shape of gradWeight is different from that of weight.
    The shapes of gradOutput and self do not satisfy the broadcast shape condition.

aclnnPreluBackward

  • Parameters:

    Parameter Input/Output Description
    workspace Input Address of the workspace memory applied on the device side.
    workspaceSize Input Size of the workspace applied on the device side, obtained from the first-phase API aclnnPreluBackwardGetWorkspaceSize.
    executor Input Operator executor, which contains the operator computation flow.
    stream Input Specifies the stream for executing the task.

  • Return value

    aclnnStatus: return code. For details, see aclnn Return Code.

Constraints

  • Deterministic computation:

  • aclnnPreluBackward defaults to a deterministic implementation.

Example

The following provides example code for reference only. For details about compilation and running, see Compile and Run Samples.

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

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

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

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

int Init(int32_t deviceId, aclrtStream* stream) {
  // Boilerplate: resource initialization.
  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);
  // Call aclrtMalloc to apply for device-side memory.
  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);

  // Copy data from the host to the device memory by calling aclrtMemcpy.
  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);

  // Compute the strides of a contiguous tensor.
  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];
  }

  // Create an aclTensor by calling aclCreateTensor.
  *tensor = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_ND,
                            shape.data(), shape.size(), *deviceAddr);
  return 0;
}

int main() {
  // 1. (Boilerplate) Initialize the device/stream. See the ACL API manual.
  // Set deviceId based on the actual device.
  int32_t deviceId = 0;
  aclrtStream stream;
  auto ret = Init(deviceId, &stream);
  // Handle the check based on your requirements.
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);
  // 2. Construct the input and output. Customize the construction based on the API interface.
  std::vector<int64_t> selfShape = {4, 2};
  std::vector<int64_t> weightShape = {2};
  std::vector<int64_t> gradOutputShape = {4, 2};
  std::vector<int64_t> gradInputShape = {4, 2};
  std::vector<int64_t> gradWeightShape = {2};

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

  std::vector<float> selfHostData = {0, 1, 2, 3, 4, 5, 6, 7};
  std::vector<float> weightHostData = {0.5, 0.5};
  std::vector<float> gradOutputHostData = {1, 1, 1, 1, 1, 1, 1, 1};
  std::vector<float> gradInputHostData = {0, 0, 0, 0, 0, 0, 0, 0};
  std::vector<float> gradWeightHostData = {0, 0};

  // Create the weight aclTensor.
  ret = CreateAclTensor(weightHostData, weightShape, &weightDeviceAddr, aclDataType::ACL_FLOAT, &weight);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // Create the self aclTensor.
  ret = CreateAclTensor(selfHostData, selfShape, &selfDeviceAddr, aclDataType::ACL_FLOAT, &self);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // Create the gradOutput aclTensor.
  ret = CreateAclTensor(gradOutputHostData, gradOutputShape, &gradOutputDeviceAddr, aclDataType::ACL_FLOAT,
  &gradOutput);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // Create the gradInput aclTensor.
  ret = CreateAclTensor(gradInputHostData, gradInputShape, &gradInputDeviceAddr, aclDataType::ACL_FLOAT, &gradInput);
  CHECK_RET(ret == ACL_SUCCESS, return ret);
  // Create the gradWeight aclTensor.
  ret = CreateAclTensor(gradWeightHostData, gradWeightShape, &gradWeightDeviceAddr, aclDataType::ACL_FLOAT, &gradWeight);
  CHECK_RET(ret == ACL_SUCCESS, return ret);

  // 3. Call the CANN operator library API. Replace with the specific API.
  uint64_t workspaceSize = 0;
  aclOpExecutor* executor;
  // Call the first-phase API of aclnnPreluBackward.
  ret = aclnnPreluBackwardGetWorkspaceSize(gradOutput, self, weight, gradInput, gradWeight, &workspaceSize, &executor);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnPreluBackwardGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
  // Allocate device memory based on the workspaceSize computed by the first-phase API.
  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);
  }
  // Call the second-phase API of aclnnPreluBackward.
  ret = aclnnPreluBackward(workspaceAddr, workspaceSize, executor, stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnPreluBackward failed. ERROR: %d\n", ret); return ret);
  // 4. (Boilerplate) Synchronously wait for task execution to complete.
  ret = aclrtSynchronizeStream(stream);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); return ret);
  // 5. Obtain the output value and copy the result from the device memory to the host memory. Modify based on the specific API definition.
  auto gradInputSize = GetShapeSize(gradInputShape);
  std::vector<float> gradInputResultData(gradInputSize, 0);
  ret = aclrtMemcpy(gradInputResultData.data(), gradInputResultData.size() * sizeof(gradInputResultData[0]), gradInputDeviceAddr, gradInputSize * sizeof(float), ACL_MEMCPY_DEVICE_TO_HOST);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret);
  for (int64_t i = 0; i < gradInputSize; i++) {
    LOG_PRINT("gradInput[%ld] is: %f\n", i, gradInputResultData[i]);
  }

  auto gradWeightSize = GetShapeSize(gradWeightShape);
  std::vector<float> gradWeightResultData(gradWeightSize, 0);
  ret = aclrtMemcpy(gradWeightResultData.data(), gradWeightResultData.size() * sizeof(gradWeightResultData[0]), gradWeightDeviceAddr, gradWeightSize * sizeof(float), ACL_MEMCPY_DEVICE_TO_HOST);
  CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("copy result from device to host failed. ERROR: %d\n", ret); return ret);
  for (int64_t i = 0; i < gradWeightSize; i++) {
    LOG_PRINT("gradWeight[%ld] is: %f\n", i, gradWeightResultData[i]);
  }

  // 6. Release aclTensor and aclScalar. Modify based on the specific API definition.
  aclDestroyTensor(gradOutput);
  aclDestroyTensor(self);
  aclDestroyTensor(weight);
  aclDestroyTensor(gradInput);
  aclDestroyTensor(gradWeight);

  // 7. Release device resources. Modify based on the specific API definition.
  aclrtFree(selfDeviceAddr);
  aclrtFree(gradOutputDeviceAddr);
  aclrtFree(weightDeviceAddr);
  aclrtFree(gradInputDeviceAddr);
  aclrtFree(gradWeightDeviceAddr);
  if (workspaceSize > 0) {
    aclrtFree(workspaceAddr);
  }
  aclrtDestroyStream(stream);
  aclrtResetDevice(deviceId);
  aclFinalize();

  return 0;
}
This site uses cookies to improve your browsing experience. By continuing to browse this site, you agree to our use of cookies.View Details