arm_compute v19.11
diff --git a/src/runtime/CL/functions/CLReductionOperation.cpp b/src/runtime/CL/functions/CLReductionOperation.cpp
index 38f0a75..3aa5a81 100644
--- a/src/runtime/CL/functions/CLReductionOperation.cpp
+++ b/src/runtime/CL/functions/CLReductionOperation.cpp
@@ -26,15 +26,17 @@
#include "arm_compute/core/CL/ICLTensor.h"
#include "arm_compute/core/CL/kernels/CLReductionOperationKernel.h"
#include "arm_compute/core/Error.h"
+#include "arm_compute/core/Helpers.h"
#include "arm_compute/core/PixelValue.h"
#include "arm_compute/core/TensorInfo.h"
#include "arm_compute/core/Validate.h"
+#include "arm_compute/core/utils/misc/ShapeCalculator.h"
#include "arm_compute/runtime/CL/CLScheduler.h"
#include "arm_compute/runtime/Tensor.h"
#include "support/ToolchainSupport.h"
-using namespace arm_compute;
-
+namespace arm_compute
+{
namespace
{
unsigned int calculate_number_of_stages(const ITensorInfo *input, unsigned int axis)
@@ -56,17 +58,52 @@
} // namespace
CLReductionOperation::CLReductionOperation(std::shared_ptr<IMemoryManager> memory_manager)
- : _memory_group(std::move(memory_manager)), _results_vector(), _reduction_kernels_vector(), _border_handlers_vector(), _num_of_stages(), _reduction_axis(), _is_serial()
+ : _memory_group(std::move(memory_manager)), _results_vector(), _reduction_kernels_vector(), _border_handlers_vector(), _reshape_kernel(), _op(), _num_of_stages(), _reduction_axis(), _is_serial(),
+ _is_reshape_required(false)
{
}
-Status CLReductionOperation::validate(const ITensorInfo *input, const ITensorInfo *output, unsigned int axis, ReductionOperation op)
+Status CLReductionOperation::validate(const ITensorInfo *input, const ITensorInfo *output, unsigned int axis, ReductionOperation op, bool keep_dims)
{
- const unsigned int num_of_stages = calculate_number_of_stages(input, axis);
- bool is_serial = is_data_type_quantized(input->data_type()) || axis != 0;
+ ARM_COMPUTE_RETURN_ERROR_ON_MSG(axis >= TensorShape::num_max_dimensions, "Reduction axis greater than max number of dimensions");
+ ARM_COMPUTE_RETURN_ERROR_ON_MSG(axis > 3, "Unsupported reduction axis");
+
+ const unsigned int num_of_stages = calculate_number_of_stages(input, axis);
+ const bool is_serial = needs_serialized_reduction(op, input->data_type(), axis);
+ const bool is_arg_min_max = (op == ReductionOperation::ARG_IDX_MAX) || (op == ReductionOperation::ARG_IDX_MIN);
+ const bool is_reshape_required = !keep_dims || is_arg_min_max;
+
+ if(is_reshape_required)
+ {
+ const TensorInfo expected_output_shape = output->clone()->set_tensor_shape(arm_compute::misc::shape_calculator::compute_reduced_shape(input->tensor_shape(), axis, keep_dims));
+ ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_SHAPES(&expected_output_shape, output);
+ }
+
+ auto *output_internal = output;
+
+ TensorInfo output_before_reshape;
+ const auto input_shape = input->tensor_shape();
+ const auto input_data_type = input->data_type();
+ const auto input_num_channles = input->num_channels();
+ const auto input_qinfo = input->quantization_info();
+ const auto output_data_type = is_arg_min_max ? DataType::S32 : output->data_type();
+
+ auto initialize_tensorinfo = [](TensorInfo & ti, TensorShape shape, DataType data_type, int num_channels, QuantizationInfo qinfo)
+ {
+ ti.set_data_type(data_type).set_tensor_shape(shape).set_num_channels(num_channels).set_quantization_info(qinfo);
+ };
+
+ if(is_reshape_required)
+ {
+ auto shape_before_reshape = input_shape;
+ shape_before_reshape.set(axis, 1);
+ initialize_tensorinfo(output_before_reshape, shape_before_reshape, output_data_type, input_num_channles, input_qinfo);
+ output_internal = &output_before_reshape;
+ }
+
if(is_serial)
{
- ARM_COMPUTE_RETURN_ON_ERROR(CLReductionOperationKernel::validate(input, output, axis, op));
+ ARM_COMPUTE_RETURN_ON_ERROR(CLReductionOperationKernel::validate(input, output_internal, axis, op));
}
else
{
@@ -74,14 +111,13 @@
std::vector<TensorInfo> sums_vector(num_of_stages - 1);
// Create intermediate tensor info
- TensorShape shape{ input->tensor_shape() };
+ TensorShape shape{ input_shape };
+
+ shape.set(0, ceil(shape.x() / 128.f));
for(unsigned int i = 0; i < num_of_stages - 1; i++)
{
- shape.set(0, ceil(shape.x() / 128.f));
- sums_vector[i].set_data_type(input->data_type());
- sums_vector[i].set_tensor_shape(shape);
- sums_vector[i].set_num_channels(input->num_channels());
+ initialize_tensorinfo(sums_vector[i], shape, input_data_type, input_num_channles, input_qinfo);
}
ReductionOperation first_kernel_op;
@@ -130,17 +166,72 @@
// Validate ReductionOperation on the last stage
const unsigned int last_stage = num_of_stages - 1;
- ARM_COMPUTE_RETURN_ON_ERROR(CLReductionOperationKernel::validate(&sums_vector[last_stage - 1], output, axis, last_kernel_op, input->dimension(0)));
+ ARM_COMPUTE_RETURN_ON_ERROR(CLReductionOperationKernel::validate(&sums_vector[last_stage - 1], output_internal, axis, last_kernel_op, input->dimension(0)));
+ }
+
+ if(is_reshape_required)
+ {
+ ARM_COMPUTE_RETURN_ON_ERROR(CLReshapeLayerKernel::validate(output_internal, output));
}
return Status{};
}
-void CLReductionOperation::configure(ICLTensor *input, ICLTensor *output, unsigned int axis, ReductionOperation op)
+ICLTensor *CLReductionOperation::configure_intermediate_result_vector(ICLTensor *input, ICLTensor *output)
{
- _num_of_stages = calculate_number_of_stages(input->info(), axis);
- _reduction_axis = axis;
- _is_serial = is_data_type_quantized(input->info()->data_type()) || axis != 0;
+ if(!_is_reshape_required && _is_serial)
+ {
+ return output;
+ }
+
+ auto intermediate_result_vector_size = _is_serial ? 1 : _num_of_stages;
+ const auto is_arg_min_max = (_op == ReductionOperation::ARG_IDX_MAX || _op == ReductionOperation::ARG_IDX_MIN);
+
+ if(!_is_reshape_required)
+ {
+ --intermediate_result_vector_size;
+ }
+
+ _results_vector.resize(intermediate_result_vector_size);
+ auto shape = input->info()->tensor_shape();
+
+ shape.set(_reduction_axis, _is_serial ? 1 : ceil(shape.x() / 128.f));
+
+ for(auto &v : _results_vector)
+ {
+ if(&v == &_results_vector.back() && _is_reshape_required)
+ {
+ shape.set(_reduction_axis, 1);
+ }
+ v.allocator()->init(input->info()->clone()->set_tensor_shape(shape));
+ }
+
+ if(is_arg_min_max)
+ {
+ _results_vector.back().info()->set_data_type(DataType::S32).set_is_resizable(true).reset_padding();
+ }
+
+ return _is_reshape_required ? &_results_vector.back() : output;
+}
+
+void CLReductionOperation::configure(ICLTensor *input, ICLTensor *output, unsigned int axis, ReductionOperation op, bool keep_dims)
+{
+ _op = op;
+ _num_of_stages = calculate_number_of_stages(input->info(), axis);
+ _reduction_axis = axis;
+ _is_serial = needs_serialized_reduction(op, input->info()->data_type(), axis);
+ const bool is_arg_min_max = (op == ReductionOperation::ARG_IDX_MAX) || (op == ReductionOperation::ARG_IDX_MIN);
+ _is_reshape_required = !keep_dims || is_arg_min_max;
+
+ auto *output_internal = configure_intermediate_result_vector(input, output);
+
+ // ArgMinMax might not give initialized output tensor, so initialize here.
+ if(_is_reshape_required)
+ {
+ const TensorShape output_shape = arm_compute::misc::shape_calculator::compute_reduced_shape(input->info()->tensor_shape(), axis, false);
+ const auto output_data_type = is_arg_min_max ? DataType::S32 : input->info()->data_type();
+ auto_init_if_empty(*output->info(), input->info()->clone()->set_tensor_shape(output_shape).set_data_type(output_data_type).reset_padding().set_is_resizable(true));
+ }
// Configure reduction operation kernels
_reduction_kernels_vector.resize(_num_of_stages);
@@ -148,20 +239,16 @@
// Create temporary tensors
if(_is_serial)
{
- _reduction_kernels_vector[0].configure(input, output, axis, op, 0);
+ if(_is_reshape_required)
+ {
+ _memory_group.manage(&_results_vector.back());
+ }
+
+ _reduction_kernels_vector[0].configure(input, output_internal, axis, op, 0);
}
else
{
_border_handlers_vector.resize(_num_of_stages);
- _results_vector.resize(_num_of_stages - 1);
- TensorShape shape{ input->info()->tensor_shape() };
- for(unsigned int i = 0; i < _num_of_stages - 1; i++)
- {
- shape.set(0, ceil(shape.x() / 128.f));
- _results_vector[i].allocator()->init(input->info()->clone()->set_tensor_shape(shape));
- }
-
- // Apply ReductionOperation only on first kernel
_memory_group.manage(&_results_vector[0]);
ReductionOperation first_kernel_op;
@@ -262,10 +349,22 @@
// Apply ReductionOperation on the last stage
const unsigned int last_stage = _num_of_stages - 1;
const unsigned int input_width = input->info()->dimension(0);
- _reduction_kernels_vector[last_stage].configure(&_results_vector[last_stage - 1], output, axis, last_kernel_op, input_width);
+
+ if(_is_reshape_required)
+ {
+ _memory_group.manage(&_results_vector.back());
+ }
+
+ _reduction_kernels_vector[last_stage].configure(&_results_vector[last_stage - 1], output_internal, axis, last_kernel_op, input_width);
_border_handlers_vector[last_stage].configure(&_results_vector[last_stage - 1], _reduction_kernels_vector[last_stage].border_size(), BorderMode::CONSTANT, pixelValue);
_results_vector[last_stage - 1].allocator()->allocate();
}
+
+ if(_is_reshape_required)
+ {
+ _reshape_kernel.configure(&_results_vector.back(), output);
+ _results_vector.back().allocator()->allocate();
+ }
}
void CLReductionOperation::run()
@@ -284,4 +383,10 @@
CLScheduler::get().enqueue(_reduction_kernels_vector[i], false);
}
}
+
+ if(_is_reshape_required)
+ {
+ CLScheduler::get().enqueue(_reshape_kernel, false);
+ }
}
+} // namespace arm_compute