aclnnUpsampleNearest2dBackward

Applicable Products

Product	Supported
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	√

Description

Description: Backward propagation of aclnnUpsampleNearest2dV2.
Corresponding Formula:
$gradInput(N, C, H, W) += gradOutput( N, C, ceil ( scalesH * H ), ceil ( scalesW * W ))$

Function Prototype

Each operator is divided into a two-phase API. You must first call the "aclnnUpsampleNearest2dBackwardGetWorkspaceSize" API to obtain the input parameters and calculate the required workspace size based on the computation process, and then call the "aclnnUpsampleNearest2dBackward" API to execute the computation.

aclnnStatus aclnnUpsampleNearest2dBackwardGetWorkspaceSize(
  const aclTensor   *gradOut,
  const aclIntArray *outputSize,
  const aclIntArray *inputSize,
  double             scalesH,
  double             scalesW,
  aclTensor*         gradInput,
  uint64_t          *workspaceSize,
  aclOpExecutor    **executor)

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

aclnnUpsampleNearest2dBackwardGetWorkspaceSize

Parameters

Parameter Name	Input/Output	Description	Description	Data Type	Data Format	Dimension (shape)	Non-contiguous Tensor
gradOut (aclTensor*)	Input	Represents the gradient tensor for backward computation, corresponding to `gradOutput` in the formula.	The H/W axes do not support empty tensors. Supports NCHW and NHWC. The input dimension must be 4.	FLOAT32, FLOAT16, BFLOAT16	NCHW, NHWC	4	√
outputSize (aclIntArray*)	Input	Indicates the spatial size of the input `gradOut` in the H and W dimensions.	The size is 2, and each element is greater than zero.	INT64	-	-	-
inputSize (aclIntArray*)	Input	Specifies the spatial size of `gradInput`.	The size is 4, and the last two elements are both greater than zero. When the data format of the input `gradOut` is NCHW, it indicates the spatial size of the output `gradInput` in the N, C, H, and W dimensions respectively; when the data format of the input `gradOut` is NHWC, it indicates the spatial size of the output `gradInput` in the N, H, W, and C dimensions respectively.	INT64	-	-	-
scalesH (double)	Input	Represents the height dimension multiplier of the output gradInput, corresponding to `scalesH` in the formula.	-	-	-	-	-
scalesW (double)	Input	Represents the width dimension multiplier of the output gradInput, corresponding to `scalesW` in the formula.	-	-	-	-	-
gradInput (aclTensor*)	Output	Represents the output tensor of the backward computation, corresponding to `gradInput` in the formula.	The H/W axes do not support empty tensors. The data type and data format must be consistent with the input parameter `gradOut`. The N and C axes of the shape must be consistent with the input parameter `gradOut`.	FLOAT32, FLOAT16, BFLOAT16	NCHW, NHWC	4	√
workspaceSize (uint64_t*)	Output	Returns the workspace size to be requested on the Device side.	-	-	-	-	-
executor (aclOpExecutor**)	Output	Returns the operator executor, which contains the operator computation flow.	-	-	-	-	-

Atlas inference products, Atlas training products:

The input gradOut and output gradInput support only FLOAT16 data type.

Return Value

aclnnStatus: return status code. For details, see aclnn Return Codes.

The first-phase API performs input parameter validation and reports errors in the following scenarios:

Return Code	Error Code	Description
ACLNN_ERR_PARAM_NULLPTR	161001	The input parameter is a required input, output, or required attribute, and is a null pointer.
ACLNN_ERR_PARAM_INVALID	161002
		The data type of gradOut is not within the supported range.
		The data types of gradOut and gradInput are inconsistent.
		The dimension of gradOut is not 4.
		The size of outputSize is not equal to 2.
		An element value of outputSize is less than 1.
		The size of inputSize is not equal to 4.
		An element value in the last two elements of inputSize is less than 1.
		The size of gradOut in the H and W dimensions is inconsistent with outputSize[0] and outputSize[1].
		The dimension sizes of the N and C axes of gradOut and gradInput are not equal.

aclnnUpsampleNearest2dBackward

Parameters

Parameter Name	Input/Output	Description
workspace	Input	Address of the workspace memory applied on the Device side.
workspaceSize	Input	Size of the workspace requested on the Device side, obtained through the first-phase API aclnnUpsampleNearest2dBackwardGetWorkspaceSize.
executor	Input	Operator executor, which contains the operator computation process.
stream	Input	Specifies the stream on which the task is executed.

Return Value

aclnnStatus: return status code. For details, see aclnn Return Codes.

Constraints

The parameters inputSize, outputSize, scalesH, and scalesW must satisfy the following constraints:
$outputSize\_H = floor(inputSize\_H * scalesH)$ $outputSize\_W = floor(inputSize\_W * scalesW)$
Deterministic computation:
- aclnnUpsampleNearest2dBackward uses deterministic implementation by default.

Example

The following sample code is 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_upsample_nearest_2d_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)
{
    // Fixed usage: initialize resources.
    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 allocate device 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);

    // Call aclrtMemcpy to copy host data to the device memory.
    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];
    }

    // Call the aclCreateTensor API to create an aclTensor.
    *tensor = aclCreateTensor(
        shape.data(), shape.size(), dataType, strides.data(), 0, aclFormat::ACL_FORMAT_NCHW, shape.data(), shape.size(),
        *deviceAddr);
    return 0;
}

int main()
{
    // 1. (Boilerplate) Initialize device/stream. See the ACL API manual.
    // Fill in the deviceId based on your actual device.
    int32_t deviceId = 0;
    aclrtStream stream;
    auto ret = Init(deviceId, &stream);
    // Handle the check result as needed.
    CHECK_RET(ret == 0, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);
    // 2. Construct the input and output. Customize the construction based on the API.
    std::vector<int64_t> gradOutShape = {2, 2, 3, 3};
    std::vector<int64_t> gradInputShape = {2, 2, 1, 1};
    void* gradOutDeviceAddr = nullptr;
    void* gradInputDeviceAddr = nullptr;
    aclTensor* gradOut = nullptr;
    aclTensor* gradInput = nullptr;
    std::vector<float> gradOutHostData = {1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18,
                                          19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36};
    std::vector<float> gradInputHostData = {2.0, 2, 2, 2};
    std::vector<int64_t> outputSizeData = {3, 3};
    std::vector<int64_t> inputSizeData = {2, 2, 1, 1};
    double scalesH = 0.0;
    double scalesW = 0.0;
    // Create gradOut aclTensor.
    ret = CreateAclTensor(gradOutHostData, gradOutShape, &gradOutDeviceAddr, aclDataType::ACL_FLOAT, &gradOut);
    CHECK_RET(ret == ACL_SUCCESS, return ret);
    // Create gradInput aclTensor.
    ret = CreateAclTensor(gradInputHostData, gradInputShape, &gradInputDeviceAddr, aclDataType::ACL_FLOAT, &gradInput);
    CHECK_RET(ret == ACL_SUCCESS, return ret);

    const aclIntArray* outputSize = aclCreateIntArray(outputSizeData.data(), outputSizeData.size());
    CHECK_RET(outputSize != nullptr, return ACL_ERROR_INTERNAL_ERROR);

    const aclIntArray* inputSize = aclCreateIntArray(inputSizeData.data(), inputSizeData.size());
    CHECK_RET(inputSize != nullptr, return ACL_ERROR_INTERNAL_ERROR);

    // 3. Call the CANN operator library API. Replace with the specific API as needed.
    uint64_t workspaceSize = 0;
    aclOpExecutor* executor;
    // Call the first-phase API of aclnnUpsampleNearest2dBackward.
    ret = aclnnUpsampleNearest2dBackwardGetWorkspaceSize(
        gradOut, outputSize, inputSize, scalesH, scalesW, gradInput, &workspaceSize, &executor);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnUpsampleNearest2dBackwardGetWorkspaceSize failed. ERROR: %d\n", ret);
              return ret);
    // Apply for device memory based on the workspaceSize calculated 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 aclnnUpsampleNearest2dBackward.
    ret = aclnnUpsampleNearest2dBackward(workspaceAddr, workspaceSize, executor, stream);
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnUpsampleNearest2dBackward failed. ERROR: %d\n", ret); return ret);
    // 4. (Boilerplate) Synchronize and 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 device memory to host memory. Modify based on the specific API definition.
    auto size = GetShapeSize(gradInputShape);
    std::vector<float> resultData(size, 0);
    ret = aclrtMemcpy(
        resultData.data(), resultData.size() * sizeof(resultData[0]), gradInputDeviceAddr, 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++) {
        LOG_PRINT("result[%ld] is: %f\n", i, resultData[i]);
    }

    // 6. Release aclTensor and aclScalar. Modify based on the specific API definition.
    aclDestroyTensor(gradOut);
    aclDestroyTensor(gradInput);

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