std::vector<int64_t> repeat_times_data = repeat_times.GetData();

std::vector<int64_t> out_grad_shape(out_grad.shape());

Tensor out_grad_tmp = out_grad;

if (repeat_times_data.size() != 0) {

while (true) {

std::vector<int64_t> expand_shape(out_grad_tmp.shape());

int num_reduce = 0;

// By definition, out_grad_shape.size() is guaranteed to be greater than

// or equal to repeat_times.size(). Paddle only supports up to 9

// dimensions.

while (repeat_times_data.size() != 0 && expand_shape.size() <= 8) {

// We construct the reduction from the backward direction, as the

// repeats are aligned with the output from right to left.

int64_t repeat = repeat_times_data.back();

int64_t orig_size = out_grad_shape.back() / repeat;

size_t out_grad_last_index = out_grad_shape.size() - 1;

// Reshape the corresponding dimension to be `repeat` multiplied by

// `orig_size`.

expand_shape[out_grad_last_index] = repeat;

expand_shape.insert(

expand_shape.begin() + out_grad_shape.size(), 1, orig_size);

repeat_times_data.pop_back();

out_grad_shape.pop_back();

++num_reduce;

}

// Find the reduce_axes, which are determined from the forward

// direction. Since there can be some axes that haven't been reduced, we

// simply skip them this round.

int64_t axis = static_cast<int64_t>(out_grad_shape.size());

std::vector<int64_t> reduce_axes;

for (int i = 0; i < num_reduce; ++i) {

reduce_axes.push_back(axis);

axis += 2;

}

out_grad_tmp = reshape<T>(out_grad_tmp, expand_shape);

out_grad_tmp = sum<T>(out_grad_tmp, reduce_axes);

if (repeat_times_data.size() == 0) {

break;

}

set_output<T>(reshape<T>(out_grad_tmp, x.shape()), x_grad);

class TestTileOpRank5(TestTileOpRank1):

def init_data(self):

self.ori_shape = (4, 2, 2, 2, 6)

self.repeat_times = (2, 3, 4, 5, 7)

def if_enable_cinn(self):

self.check_cinn = True

class TestTileOpRank6(TestTileOpRank1):

def init_data(self):

self.ori_shape = (2, 2, 2, 2, 2, 6)

self.repeat_times = (2, 2, 3, 4, 5, 7)

def if_enable_cinn(self):

self.check_cinn = True