arm_compute::NEReduceSum Class Reference

#include <NEReduceSum.h>

Collaboration diagram for arm_compute::NEReduceSum:

Public Member Functions
	NEReduceSum (std::shared_ptr< IMemoryManager > memory_manager=nullptr)
void	configure (ITensor *input, const Coordinates &reduction_axis, bool keep_dims, ITensor *output)
void	run () override

Static Public Member Functions
static Status	validate (const ITensorInfo *input, const Coordinates &reduction_axis, bool keep_dims, const ITensorInfo *output)

Detailed Description

Basic function to perform reduce operation

Definition at line 59 of file NEReduceSum.h.

Constructor & Destructor Documentation

NEReduceSum()

NEReduceSum::NEReduceSum

(

std::shared_ptr< IMemoryManager >

memory_manager = nullptr

)

Constructor

Definition at line 53 of file NEReduceSum.cpp.

  : _memory_group(std::move(memory_manager)), _reduction_kernels(), _reduced_outs(), _reshape(),
    _reduction_ops(), _keep_dims()
{
}

Member Function Documentation

configure()

void NEReduceSum::configure	(	ITensor *	input,
		const Coordinates &	reduction_axis,
		bool	keep_dims,
		ITensor *	output
	)

Configure kernel

Note

Supported tensor rank: up to 4

Parameters

[in]	input	Source tensor. Data type supported: QASYMM8/F16/F32
[in]	reduction_axis	Reduction axis vector.
[in]	keep_dims	If positive, retains reduced dimensions with length 1.
[out]	output	Destination tensor. Data type supported: Same as input

Definition at line 105 of file NEReduceSum.cpp.

{
  ARM_COMPUTE_ERROR_ON_NULLPTR(input);
 
  _reduction_ops = reduction_axis.num_dimensions();
  _reduction_kernels.resize(_reduction_ops);
  _reduced_outs.resize(_reduction_ops - (keep_dims ? 1 : 0));
  _keep_dims = keep_dims;
 
  Coordinates axis_local = reduction_axis;
  const int input_dims = input->info()->num_dimensions();
  const unsigned int reduction_ops = reduction_axis.num_dimensions();
 
  // Convert negative axis
  for (unsigned int i = 0; i < reduction_ops; ++i)
  {
    axis_local[i] = wrap_around(axis_local[i], input_dims);
  }
 
  // Perform reduction for every axis
  for (unsigned int i = 0; i < _reduction_ops; ++i)
  {
    TensorShape out_shape =
      i == 0 ? input->info()->tensor_shape() : (&_reduced_outs[i - 1])->info()->tensor_shape();
    out_shape.set(axis_local[i], 1);
    auto in = (i == 0) ? input : (&_reduced_outs[i - 1]);
 
    if (i == _reduction_ops - 1 && keep_dims)
    {
      _reduction_kernels[i].configure(in, output, axis_local[i], ReductionOperation::SUM);
    }
    else
    {
      _reduced_outs[i].allocator()->init(TensorInfo(out_shape, input->info()->num_channels(),
                                                    input->info()->data_type(),
                                                    input->info()->quantization_info())
                                           .set_data_layout(input->info()->data_layout()));
      _memory_group.manage(&_reduced_outs[i]);
      _reduction_kernels[i].configure(in, &_reduced_outs[i], axis_local[i],
                                      ReductionOperation::SUM);
    }
  }
 
  // Allocate intermediate tensors
  for (unsigned int i = 0; i < _reduction_ops - (keep_dims ? 1 : 0); ++i)
  {
    _reduced_outs[i].allocator()->allocate();
  }
 
  // Configure reshape layer if we want to drop the dimensions
  if (!keep_dims)
  {
    TensorShape out_shape = input->info()->tensor_shape();
 
    // We have to sort the reduction axis vectors in order for remove_dimension
    // to work properly
    std::sort(axis_local.begin(), axis_local.begin() + _reduction_ops);
    for (unsigned int i = 0; i < _reduction_ops; ++i)
    {
      out_shape.remove_dimension(axis_local[i] - i);
    }
    auto_init_if_empty(*output->info(), input->info()->clone()->set_tensor_shape(out_shape));
    _reshape.configure(&_reduced_outs[_reduction_ops - 1], output);
  }
}

References info.

run()

void NEReduceSum::run ( )

override

Definition at line 172 of file NEReduceSum.cpp.

{
  MemoryGroupResourceScope scope_mg(_memory_group);
 
  for (unsigned int i = 0; i < _reduction_ops; ++i)
  {
    _reduction_kernels[i].run();
  }
 
  if (!_keep_dims)
  {
    _reshape.run();
  }
}

validate()

Status NEReduceSum::validate ( const ITensorInfo *  input, const Coordinates &  reduction_axis, bool  keep_dims, const ITensorInfo *  output  )

static

Static function to check if given info will lead to a valid configuration of NEReduceSum

Parameters

[in]	input	Source tensor. Data type supported: QASYMM8/F16/F32
[in]	reduction_axis	Reduction axis vector.
[in]	keep_dims	If positive, retains reduced dimensions with length 1.
[in]	output	Destination tensor. Data type supported: Same as input

Returns

A status

Definition at line 59 of file NEReduceSum.cpp.

{
  ARM_COMPUTE_UNUSED(keep_dims);
  ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input);
  ARM_COMPUTE_RETURN_ERROR_ON_CPU_F16_UNSUPPORTED(input);
  ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::QASYMM8, DataType::F16,
                                                       DataType::F32);
  ARM_COMPUTE_RETURN_ERROR_ON(reduction_axis.num_dimensions() > input->num_dimensions());
 
  TensorShape out_shape = input->tensor_shape();
  const unsigned int reduction_ops = reduction_axis.num_dimensions();
  const int input_dims = input->num_dimensions();
  Coordinates axis_local = reduction_axis;
 
  // Convert negative axis
  for (unsigned int i = 0; i < reduction_ops; ++i)
  {
    axis_local[i] = wrap_around(axis_local[i], input_dims);
  }
 
  std::sort(axis_local.begin(), axis_local.begin() + reduction_ops);
  for (unsigned int i = 0; i < reduction_ops; ++i)
  {
    ARM_COMPUTE_RETURN_ERROR_ON(axis_local[i] > 3);
    ARM_COMPUTE_RETURN_ERROR_ON(static_cast<unsigned int>(axis_local[i]) >
                                input->num_dimensions() - 1);
    if (output->total_size() > 0 && keep_dims)
    {
      ARM_COMPUTE_RETURN_ERROR_ON(output->dimension(axis_local[i]) != 1);
    }
    if (keep_dims)
    {
      out_shape.set(axis_local[i], 1);
    }
    else
    {
      out_shape.remove_dimension(axis_local[i] - i);
    }
  }
  const TensorInfo out_info = input->clone()->set_tensor_shape(out_shape);
  ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_SHAPES(output, &out_info);
 
  return Status{};
}

---

The documentation for this class was generated from the following files:

• runtime/compute/ARMComputeEx/arm_compute/runtime/NEON/functions/NEReduceSum.h
• runtime/compute/ARMComputeEx/src/runtime/NEON/functions/NEReduceSum.cpp