nnfw::cker::Reduce Class Reference

#include <Reduce.h>

Public Member Functions
	Reduce ()
void	prepare (size_t temp_index_size, size_t resolved_axis_size)
template<typename T >
bool	ReduceGeneric (const Shape &input_shape, const T *input_data, const Shape &output_shape, T *output_data, const std::vector< int > &axes, bool, T init_value, T reducer(const T current, const T in))
template<typename T , typename U >
bool	QuantizedMeanOrSum (const T *input_data, int32_t input_zero_point, float input_scale, const Shape &input_shape, T *output_data, int32_t output_zero_point, float output_scale, const Shape &output_shape, const std::vector< int > &axes, bool, U *temp_sum, bool compute_sum, U reducer(const U current, const T in))
int32_t *	resolved_axis_data (void)
int32_t *	temp_index_data (void)

Detailed Description

Definition at line 230 of file Reduce.h.

Constructor & Destructor Documentation

Reduce()

nnfw::cker::Reduce::Reduce ( )

inline

Definition at line 233 of file Reduce.h.

: _temp_index(), _resolved_axis(), _prepared(false) {}

Member Function Documentation

prepare()

void nnfw::cker::Reduce::prepare ( size_t  temp_index_size, size_t  resolved_axis_size  )

inline

Definition at line 235 of file Reduce.h.

  {
    if (_prepared)
      return;
 
    // prepare space for temp_index and resolved_axis
    if (temp_index_size > kMaxSmallSize)
      _temp_index.resize(temp_index_size);
    if (resolved_axis_size > kMaxSmallSize)
      _resolved_axis.resize(resolved_axis_size);
    _prepared = true;
  }

Referenced by nnfw::cker::ReduceMean::PrepareforReduce().

QuantizedMeanOrSum()

template<typename T , typename U >

bool nnfw::cker::Reduce::QuantizedMeanOrSum ( const T *  input_data, int32_t  input_zero_point, float  input_scale, const Shape &  input_shape, T *  output_data, int32_t  output_zero_point, float  output_scale, const Shape &  output_shape, const std::vector< int > &  axes, bool  , U *  temp_sum, bool  compute_sum, U   reducerconst U current, const T in  )

inline

Definition at line 276 of file Reduce.h.

  {
    // Reset output data.
    size_t num_outputs = 1;
    for (int idx = 0; idx < output_shape.DimensionsCount(); ++idx)
    {
      size_t current = static_cast<size_t>(output_shape.Dims(idx));
      // Overflow prevention.
      if (num_outputs > std::numeric_limits<size_t>::max() / current)
      {
        return false;
      }
      num_outputs *= current;
    }
    for (size_t idx = 0; idx < num_outputs; ++idx)
    {
      output_data[idx] = T();
      temp_sum[idx] = U();
    }
 
    // Resolve axis.
    int num_resolved_axis = 0;
    if (!ResolveAxis(input_shape.DimensionsCount(), axes, resolved_axis_data(), &num_resolved_axis))
    {
      return false;
    }
 
    if (!ReduceImpl<T, U>(input_data, input_shape, output_shape, resolved_axis_data(),
                          num_resolved_axis, temp_index_data(), reducer, temp_sum))
    {
      return false;
    }
 
    // Calculate mean by dividing output_data by num of aggregated element.
    size_t num_elements_in_axis = 1;
    for (int idx = 0; idx < num_resolved_axis; ++idx)
    {
      size_t current = static_cast<size_t>(input_shape.Dims(resolved_axis_data()[idx]));
      // Overflow prevention.
      if (current > static_cast<size_t>(std::numeric_limits<size_t>::max() / num_elements_in_axis))
      {
        return false;
      }
      num_elements_in_axis *= current;
    }
 
    if (num_elements_in_axis > 0)
    {
      const float scale = input_scale / output_scale;
      if (compute_sum)
      {
        // TODO(b/116341117): Eliminate float and do this completely in 8bit.
        const float bias = -input_zero_point * scale * num_elements_in_axis;
        for (size_t idx = 0; idx < num_outputs; ++idx)
        {
          const U value =
            static_cast<U>(std::round(temp_sum[idx] * scale + bias)) + output_zero_point;
          output_data[idx] = static_cast<T>(value);
        }
      }
      else
      {
        const float bias = -input_zero_point * scale;
        for (size_t idx = 0; idx < num_outputs; ++idx)
        {
          float float_mean =
            static_cast<float>(temp_sum[idx]) / static_cast<float>(num_elements_in_axis);
          float result = std::min(std::round(float_mean * scale + bias) + output_zero_point,
                                  static_cast<float>(std::numeric_limits<T>::max()));
          result = std::max(result, static_cast<float>(std::numeric_limits<T>::min()));
          output_data[idx] = static_cast<T>(result);
        }
      }
    }
    return true;
  }

References nnfw::cker::Shape::DimensionsCount(), nnfw::cker::Shape::Dims(), output_shape, nnfw::cker::ResolveAxis(), resolved_axis_data(), and temp_index_data().

ReduceGeneric()

template<typename T >

bool nnfw::cker::Reduce::ReduceGeneric ( const Shape &  input_shape, const T *  input_data, const Shape &  output_shape, T *  output_data, const std::vector< int > &  axes, bool  , T  init_value, T   reducerconst T current, const T in  )

inline

Definition at line 251 of file Reduce.h.

  {
    // Reset output data.
    if (!InitTensorDataForReduce(output_shape, init_value, output_data))
    {
      return false;
    }
 
    // Resolve axis.
    int num_resolved_axis = 0;
    if (!ResolveAxis(input_shape.DimensionsCount(), axes, resolved_axis_data(), &num_resolved_axis))
    {
      return false;
    }
 
    return ReduceImpl<T, T>(input_data, input_shape, output_shape, resolved_axis_data(),
                            num_resolved_axis, temp_index_data(), reducer, output_data);
  }

References nnfw::cker::Shape::DimensionsCount(), nnfw::cker::InitTensorDataForReduce(), output_shape, nnfw::cker::ResolveAxis(), resolved_axis_data(), and temp_index_data().

resolved_axis_data()

int32_t * nnfw::cker::Reduce::resolved_axis_data ( void  )

inline

Definition at line 358 of file Reduce.h.

  {
    return _resolved_axis.size() ? _resolved_axis.data() : _resolved_axis_small;
  }

Referenced by nnfw::cker::ReduceMean::PrepareforReduce(), QuantizedMeanOrSum(), ReduceGeneric(), nnfw::cker::ReduceMean::ReduceOp(), and nnfw::cker::ReduceMean::ReduceOp().

temp_index_data()

int32_t * nnfw::cker::Reduce::temp_index_data ( void  )

inline

Definition at line 362 of file Reduce.h.

  {
    return _temp_index.size() ? _temp_index.data() : _temp_index_small;
  }

Referenced by QuantizedMeanOrSum(), ReduceGeneric(), nnfw::cker::ReduceMean::ReduceOp(), and nnfw::cker::ReduceMean::ReduceOp().

---

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

• compute/cker/include/cker/operation/Reduce.h