aclnnRepeatInterleaveGrad
Applicable Products
| Product | Supported |
|---|---|
| √ | |
| × | |
| × | |
| × | |
| × | |
| × |
Function
Description: Performs backward propagation of the repeatInterleave operator, applying ReduceSum on the axis dimension of the yGrad tensor according to repeats.
- Example:
Assume tensor yGrad is ([[a1, b1, c1, d1, e1, f1], [a2, b2, c2, d2, e2, f2]]), repeats is ([1, 2, 2, 1]), and axis is 1. Then the resulting tensor is tensor([[a1, b1 + c1, d1 + e1, f1], [a2, b2 + c2, d2 + e2, f2]]). This performs ReduceSum on the axis dimension of tensor yGrad according to repeats.
Assume tensor yGrad is ([[a<sub>1</sub>, b<sub>1</sub>, c<sub>1</sub>, d<sub>1</sub>, e<sub>1</sub>, f<sub>1</sub>], [a<sub>2</sub>, b<sub>2</sub>, c<sub>2</sub>, d<sub>2</sub>, e<sub>2</sub>, f<sub>2</sub>]]), repeats is ([2]), and axis is 1.
Then the resulting tensor is tensor([[a<sub>1</sub> + b<sub>1</sub>, c<sub>1</sub> + d<sub>1</sub>, e<sub>1</sub> + f<sub>1</sub>], [a<sub>2</sub> + b<sub>2</sub>, c<sub>2</sub> + d<sub>2</sub>, e<sub>2</sub> + f<sub>2</sub>]]). Perform ReduceSum on the axis dimension of tensor yGrad for every two axes according to the value of repeats.
Note: This scenario is equivalent to repeats being (2).Function Prototype
Each operator is divided into a two-phase API. You must first call the "aclnnRepeatInterleaveGradGetWorkspaceSize" API to obtain the workspace size required for computation and the executor that contains the operator computation process, and then call the "aclnnRepeatInterleaveGrad" API to perform the computation.
aclnnStatus aclnnRepeatInterleaveGradGetWorkspaceSize(
const aclTensor *yGrad,
const aclTensor *repeats,
int64_t axis,
const aclTensor *out,
uint64_t *workspaceSize,
aclOpExecutor **executor)aclnnStatus aclnnRepeatInterleaveGrad(
void *workspace,
uint64_t workspaceSize,
aclOpExecutor *executor,
aclrtStream stream)aclnnRepeatInterleaveGradGetWorkspaceSize
Parameters:
Parameter Input/Output Description Instruction Data Type Data Format Dimension (Shape) Non-contiguous Tensor yGrad Input Input tensor to be processed by ReduceSum in the function description. Supports empty tensors. FLOAT16, BFLOAT16, FLOAT ND 0-8 √ repeats Input Number of repetitions. repeats must be a 0D or 1D tensor. If repeats is a 1D tensor with size 1, broadcasting is supported. If repeats is a 1D tensor with size greater than 1, the sum of the elements of repeats must equal the dimension of axis in yGrad. Empty tensors are not supported. INT32, INT64 ND √ axis Input Dimension on which ReduceSum operates. The value range of axis is [-n, n), where n is the dimension of yGrad. out Output Output tensor produced by ReduceSum in the function description. For shape constraints, see Constraints. Same as yGrad. ND - workspaceSize Output Returns the workspace size to be requested on the Device side. - - - - - executor Output Returns the operator executor, which contains the operator computation flow. - - - - - Ascend 950PR/Ascend 950DT : The data type of yGrad supports FLOAT16, BFLOAT16, and FLOAT.
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:
561002 Error Code Description ACLNN_ERR_PARAM_NULLPTR 161001 The passed self, repeats, or out is a null pointer. ACLNN_ERR_PARAM_INVALID 161002 The data type of self or repeats is not within the supported range. The data type of self differs from that of out. ACLNN_ERR_INNER_TILING_ERROR 561002 When self is not an empty tensor but repeats is an empty tensor.
aclnnRepeatInterleaveGrad
Parameters:
Parameter Input/Output Description workspace Input Specifies the workspace memory address applied on the Device side. workspaceSize Input Specifies the workspace size applied on the Device side, obtained by the first-phase API aclnnRepeatInterleaveGradGetWorkspaceSize. executor Input Op executor, which contains the operator computation flow. stream Input Specifies the stream for task execution. Return value
aclnnStatus: return code. For details, see aclnn Return Code.
Constraints
Deterministic computation:
- aclnnRepeatInterleaveGrad defaults to a deterministic implementation.
The following requirements must be met during computation:
If repeats is a 0D tensor or a 1D tensor with size 1, the element value of repeats must be a divisor of the dimension of yGrad on axis.
If it is a 1D tensor with a size greater than 1, the sum of the elements in repeats must equal the dimension of yGrad along axis. The values in the repeats tensor must be natural numbers.
The shape size of out satisfies the shape size after ReduceSum along the axis of yGrad.
For example, if the shape of yGrad is [64], repeat is [2], and axis is 0, the shape of out can be [32], [2, 16], [2, 4, 4], etc., as long as the shape size of out is 32.
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_repeat_interleave_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: 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);
// 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 the aclCreateTensor API.
*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.
// Set deviceId based on the 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. Customize the construction based on the API.
std::vector<int64_t> yGradShape = {4, 3};
std::vector<int64_t> repeatsShape = {2};
std::vector<int64_t> outShape = {2, 3};
void* yGradDeviceAddr = nullptr;
void* repeatsDeviceAddr = nullptr;
void* outDeviceAddr = nullptr;
aclTensor* yGrad = nullptr;
aclTensor* repeats = nullptr;
aclTensor* out = nullptr;
int64_t axis = 0;
std::vector<float> yGradHostData = {3, 4, 5, 3, 4, 5, -3, -4, -5, -3, -4, -5};
std::vector<int64_t> repeatsHostData = {2, 2};
std::vector<float> outHostData = {0, 0, 0, 0, 0, 0};
// Create the yGrad aclTensor.
ret = CreateAclTensor(yGradHostData, yGradShape, &yGradDeviceAddr, aclDataType::ACL_FLOAT, &yGrad);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// Create the repeats aclTensor.
ret = CreateAclTensor(repeatsHostData, repeatsShape, &repeatsDeviceAddr, aclDataType::ACL_INT64, &repeats);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// Create the out aclTensor.
ret = CreateAclTensor(outHostData, outShape, &outDeviceAddr, aclDataType::ACL_FLOAT, &out);
CHECK_RET(ret == ACL_SUCCESS, return ret);
// 3. Call the CANN operator library API. Replace with the specific API name.
uint64_t workspaceSize = 0;
aclOpExecutor* executor;
// Call the first-phase API of aclnnRepeatInterleaveGrad.
ret = aclnnRepeatInterleaveGradGetWorkspaceSize(yGrad, repeats, axis, out, &workspaceSize, &executor);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnRepeatInterleaveGradGetWorkspaceSize 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 aclnnRepeatInterleaveGrad.
ret = aclnnRepeatInterleaveGrad(workspaceAddr, workspaceSize, executor, stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnRepeatInterleaveGrad 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 size = GetShapeSize(outShape);
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("result[%ld] is: %f\n", i, resultData[i]);
}
// 6. Release aclTensor and aclScalar. Modify based on the specific API definition.
aclDestroyTensor(yGrad);
aclDestroyTensor(repeats);
aclDestroyTensor(out);
// 7. Release device resources. Modify based on the specific API definition.
aclrtFree(yGradDeviceAddr);
aclrtFree(repeatsDeviceAddr);
aclrtFree(outDeviceAddr);
if (workspaceSize > 0) {
aclrtFree(workspaceAddr);
}
aclrtDestroyStream(stream);
aclrtResetDevice(deviceId);
aclFinalize();
return 0;
}