aclnnUnfoldGrad
Applicable Products
| Product | Supported |
|---|---|
| ร | |
| โ | |
| โ | |
| ร | |
| ร | |
| ร |
Function
Description: Implements the backward function of the Unfold operator to compute the corresponding gradients.
The Unfold operator extracts all slices of size along dimension from the input self. The step between two slices is given by . If is the size of dimension of the input self, the size of dimension in the returned tensor will be . An additional dimension of size is appended to the returned tensor.
The shape of the gradOut input of the UnfoldGrad operator is the shape of the Unfold forward output, the inputSizes input is the shape of the Unfold forward input self, and the shape of the gradIn output of the UnfoldGrad operator is the shape of the Unfold forward input self.
Example:
>>> x = torch.arange(1., 8) >>> x tensor([ 1., 2., 3., 4., 5., 6., 7.]) >>> x.unfold(0, 2, 1) tensor([[ 1., 2.], [ 2., 3.], [ 3., 4.], [ 4., 5.], [ 5., 6.], [ 6., 7.]]) >>> x.unfold(0, 2, 2) tensor([[ 1., 2.], [ 3., 4.], [ 5., 6.]]) >>> res = torch.ops.aten.unfold_backward(grad, [7], 0, 2, 2) tensor([1, 2, 3, 4, 5, 6, 0])
Function Prototype
Each operator is divided into a two-phase API. The "aclnnUnfoldGradGetWorkspaceSize" API must be called first to obtain the workspace size required for computation and the executor that encapsulates the operator computation flow. Then, the "aclnnUnfoldGrad" API is called to perform the computation.
aclnnStatus aclnnUnfoldGradGetWorkspaceSize(
const aclTensor *gradOut,
const aclIntArray *inputSizes,
int64_t dim,
int64_t size,
int64_t step,
const aclTensor *gradIn,
uint64_t *workspaceSize,
aclOpExecutor **executor)aclnnStatus aclnnUnfoldGrad(
void *workspace,
uint64_t workspaceSize,
aclOpExecutor *executor,
aclrtStream stream)aclnnUnfoldGradGetWorkspaceSize
Parameters:
Parameter Input/Output Description Instruction Data Type Data Format Shape Non-contiguous Tensor gradOut (aclTensor *) Input Represents the gradient update coefficient. The shape is (..., (sizedim-size)/step+1, size). The dim-th dimension of gradOut must equal (inputSizes[dim]-size)/step+1, and the size of gradOut must equal the size of inputSizes plus 1. FLOAT, FLOAT16, BFLOAT16 ND 1-8 - inputSizes (aclIntArray*) Input Indicates the shape of the output tensor. The value is (..., sizedim), where the size of inputSizes is less than or equal to 8. INT64 - - - dim (int64_t) Input Indicates the dimension along which the unfolding occurs, i.e., dim in the formula. dim only supports len(inputSizes)-1 or len(inputSizes)-2. INT64 - - - size (int64_t) Input Represents the size of each unfolded slice, i.e., the size in the formula. - size must be greater than 0 and less than or equal to the dim-th dimension of inputSizes.
- When dim equals len(inputSizes)-1, for the fp32 data type, size must be less than or equal to 49088. For the fp16 data type, size must be less than or equal to 32720.
- When dim equals len(inputSizes)-2, for the fp32 data type, size must be less than or equal to 88. For the fp16 data type, step and size must be less than or equal to 72.
INT64 - - - step (int64_t) Input Represents the stride between each slice, i.e., step in the formula. - step must be greater than 0.
- When dim equals len(inputSizes) - 1, for the fp32 data type, size must be less than or equal to 49088. For the fp16 data type, size must be less than or equal to 32720.
- When dim equals len(inputSizes) - 2, for the fp32 data type, size must be less than or equal to 88. For the fp16 data type, both step and size must be less than or equal to 72.
INT64 - - - gradIn (aclTensor *) Output Indicates the corresponding gradient of Unfold. Its shape is inputSizes. It remains consistent with gradOut. ND 1-8 - workspaceSize (uint64_t*) Output Returns the workspace size to be allocated on the Device side. - - - - - executor (aclOpExecutor**) Output Returns the op executor, which contains the operator computation flow. - - - - - Return value
aclnnStatus: return code. For details, see aclnn Return Codes.
The first-phase API performs input parameter validation and returns an error in the following scenarios:
Return Value Error Code Description ACLNN_ERR_PARAM_NULLPTR 161001 The input or output tensor is a null pointer. ACLNN_ERR_PARAM_INVALID 161002 The data types or data formats of the input and output are not within the supported range. ACLNN_ERR_INNER_TILING_ERROR 561002 The dim-th dimension of gradOut is not equal to (inputSizes[dim] - size) / step + 1. The size of gradOut is not equal to the size of inputSizes plus 1. size is less than or equal to 0, or size is greater than the dim-th dimension of inputSizes. step is less than or equal to 0. dim is not equal to len(inputSizes)-1 and dim is not equal to the len(inputSizes)-2 axis. When dim equals len(inputSizes)-1, for the fp32 data type, step and size are greater than 49088. For the fp16 data type, step and size are greater than 32720. When dim equals len(inputSizes)-2, for the FP32 data type, step and size are greater than 88. For the FP16 data type, step and size are greater than 72.
aclnnUnfoldGrad
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 through the first-phase API aclnnUnfoldGradGetWorkspaceSize. executor Input Operator executor that contains the operator computation process. stream Input Specifies the stream for task execution. Return value
aclnnStatus: return code. For details, see aclnn Return Codes.
Constraints
Deterministic computation:
- aclnnUnfoldGrad defaults to a deterministic implementation.
The shape of gradOut meets the following constraints:
The dim-th dimension of gradOut equals (inputSizes[dim] - size) / step + 1.
The size of gradOut equals the size of inputSizes plus 1.
Requirements for dim, size, and step:
size is greater than 0 and less than or equal to the dim-th dimension of inputSizes.
step is greater than 0.
dim equals len(inputSizes)-1 or len(inputSizes)-2 axis.
When dim equals len(inputSizes)-1, for fp32 data type, step and size are greater than 49088. For fp16 data type, step and size are greater than 32720.
When dim equals len(inputSizes) - 2, for the fp32 data type, step and size are greater than 88. For the fp16 data type, step and size are greater than 72.
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_unfold_grad.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) {
// 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);
// Call aclrtMemcpy to copy host-side data to device-side 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);
// Calculate 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_ND,
shape.data(), shape.size(), *deviceAddr);
return 0;
}
int main() {
// 1. (Boilerplate) Initialize the device/stream. Refer to the ACL API manual.
// Fill in the deviceId based on your actual device.
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. Construct the input and output. Custom construction is required based on the API.
std::vector<int64_t> gradOutShape = {3, 2, 3};
std::vector<int64_t> gradInShape = {8, 2};
void* gradOutDeviceAddr = nullptr;
void* gradInDeviceAddr = nullptr;
aclTensor* gradOut = nullptr;
aclTensor* gradIn = nullptr;
std::vector<float> gradOutHostData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0};
std::vector<int64_t> inputSizesData = {8, 2};
std::vector<float> gradInHostData(16, 0);
// Create the gradOut aclTensor.
ret = CreateAclTensor(gradOutHostData, gradOutShape, &gradOutDeviceAddr, aclDataType::ACL_FLOAT, &gradOut);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// Create the gradIn aclTensor.
ret = CreateAclTensor(gradInHostData, gradInShape, &gradInDeviceAddr, aclDataType::ACL_FLOAT, &gradIn);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// Create an aclIntArray.
auto inputSizes = aclCreateIntArray(inputSizesData.data(), 2);
CHECK_RET(inputSizes != nullptr, return ret);
// 3. Call the CANN operator library API. Replace with the actual API name.
uint64_t workspaceSize = 0;
aclOpExecutor* executor;
// Call the first-phase API of aclnnUnfoldGrad.
ret = aclnnUnfoldGradGetWorkspaceSize(gradOut, inputSizes, 0, 3, 2, gradIn, &workspaceSize, &executor);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnUnfoldGradGetWorkspaceSize failed. ERROR: %d\n", ret); return ret);
// Allocate 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 aclnnUnfoldGrad.
ret = aclnnUnfoldGrad(workspaceAddr, workspaceSize, executor, stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnUnfoldGrad 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 the device memory to the host memory. Modify based on the specific API definition.
auto size = GetShapeSize(gradInShape);
std::vector<float> resultData(size, 0);
ret = aclrtMemcpy(resultData.data(), resultData.size() * sizeof(resultData[0]), gradInDeviceAddr,
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("result[%ld] is: %f\n", i, resultData[i]);
}
// 6. Release aclTensor and aclIntArray. Modify based on the specific API definition.
aclDestroyTensor(gradOut);
aclDestroyIntArray(inputSizes);
aclDestroyTensor(gradIn);
// 7. Release device resources. Modify based on the specific API definition.
aclrtFree(gradOutDeviceAddr);
aclrtFree(gradInDeviceAddr);
if (workspaceSize > 0) {
aclrtFree(workspaceAddr);
}
aclrtDestroyStream(stream);
aclrtResetDevice(deviceId);
aclFinalize();
return 0;
}