nnfw::cker::ReduceMean Class Reference

#include <ReduceMean.h>

Collaboration diagram for nnfw::cker::ReduceMean:

Public Member Functions
	ReduceMean ()
template<typename T >
int	PrepareforReduce (const Shape &input_shape, const Shape &output_shape, const std::vector< int > &axes, T *output_data, T init_value)
template<typename In , typename Out >
bool	ReduceOp (const Shape &input_shape, const In *input_data, const Shape &output_shape, Out *output_data, const std::vector< int > &axes, bool, Out init_value, Out reducer(const Out current, const Out in, int normalizer))
template<typename In , typename Out >
bool	ReduceOp (const Shape &input_shape, const In *input_data, float input_scale, int32_t input_offset, const Shape &output_shape, Out *output_data, float output_scale, int32_t output_offset, const std::vector< int > &axes, bool, Out init_value, int reducer(const int current, const In in))
Public Member Functions inherited from nnfw::cker::Reduce
	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 111 of file ReduceMean.h.

Constructor & Destructor Documentation

ReduceMean()

nnfw::cker::ReduceMean::ReduceMean ( )

inline

Definition at line 114 of file ReduceMean.h.

: Reduce(){};

Member Function Documentation

PrepareforReduce()

template<typename T >

int nnfw::cker::ReduceMean::PrepareforReduce ( const Shape &  input_shape, const Shape &  output_shape, const std::vector< int > &  axes, T *  output_data, T  init_value  )

inline

Definition at line 117 of file ReduceMean.h.

  {
    // Reset output data.
    if (!InitTensorDataForReduce(output_shape, init_value, output_data))
    {
      return -1;
    }
    const auto input_dims = input_shape.DimsData();
    const int num_dims = input_shape.DimensionsCount();
    int resolved_axis_size = 1;
    const auto num_axes = axes.size();
 
    for (size_t idx = 0; idx < num_axes; idx++)
    {
      int current = axes[idx] < 0 ? (axes[idx] + num_dims) : axes[idx];
      assert(current >= 0 && current < num_dims);
      resolved_axis_size *= input_dims[current];
    }
 
    prepare(num_dims, resolved_axis_size);
 
    // Resolve axis.
    int num_resolved_axis = 0;
    if (!ResolveAxis(input_shape.DimensionsCount(), axes, resolved_axis_data(), &num_resolved_axis))
    {
      return -1;
    }
 
    return num_resolved_axis;
  }

References nnfw::cker::Shape::DimensionsCount(), nnfw::cker::Shape::DimsData(), nnfw::cker::InitTensorDataForReduce(), output_shape, nnfw::cker::Reduce::prepare(), nnfw::cker::ResolveAxis(), and nnfw::cker::Reduce::resolved_axis_data().

Referenced by ReduceOp(), and ReduceOp().

ReduceOp() [1/2]

template<typename In , typename Out >

bool nnfw::cker::ReduceMean::ReduceOp ( const Shape &  input_shape, const In *  input_data, const Shape &  output_shape, Out *  output_data, const std::vector< int > &  axes, bool  , Out  init_value, Out   reducerconst Out current, const Out in, int normalizer  )

inline

Definition at line 152 of file ReduceMean.h.

  {
    int num_resolved_axis;
    num_resolved_axis = PrepareforReduce(input_shape, output_shape, axes, output_data, init_value);
    if (num_resolved_axis == -1)
    {
      return false;
    }
    return ReduceMeanImpl<In, Out>(input_data, input_shape, resolved_axis_data(), num_resolved_axis,
                                   temp_index_data(), reducer, output_data);
  }

References output_shape, PrepareforReduce(), nnfw::cker::Reduce::resolved_axis_data(), and nnfw::cker::Reduce::temp_index_data().

Referenced by nnfw::cker::Mean(), and nnfw::cker::MeanQ8Asymm().

ReduceOp() [2/2]

template<typename In , typename Out >

bool nnfw::cker::ReduceMean::ReduceOp ( const Shape &  input_shape, const In *  input_data, float  input_scale, int32_t  input_offset, const Shape &  output_shape, Out *  output_data, float  output_scale, int32_t  output_offset, const std::vector< int > &  axes, bool  , Out  init_value, int   reducerconst int current, const In in  )

inline

Definition at line 167 of file ReduceMean.h.

  {
    size_t num_outputs = 1;
    auto output_dims = output_shape.DimsData();
 
    for (size_t idx = 0; idx < static_cast<size_t>(output_shape.DimensionsCount()); idx++)
    {
      num_outputs *= output_dims[idx];
    }
    _temp_sum.resize(num_outputs, 0);
    int num_resolved_axis;
    num_resolved_axis = PrepareforReduce(input_shape, output_shape, axes, output_data, init_value);
    if (num_resolved_axis == -1)
    {
      return false;
    }
 
    size_t normalizer =
      ReduceSumQuantImpl<In>(input_data, input_shape, resolved_axis_data(), num_resolved_axis,
                             temp_index_data(), reducer, _temp_sum.data());
    if (num_outputs > 0)
    {
      float scale = input_scale / output_scale;
      float bias = -input_offset * scale;
      for (size_t idx = 0; idx < num_outputs; idx++)
      {
        float float_mean = static_cast<float>(_temp_sum[idx]) / normalizer;
        float result = std::min(round_nearest(float_mean * scale + bias + output_offset),
                                static_cast<float>(std::numeric_limits<Out>::max()));
        result = std::max(result, static_cast<float>(std::numeric_limits<Out>::min()));
        output_data[idx] = static_cast<Out>(result);
      }
    }
    return false;
  }

References output_shape, PrepareforReduce(), nnfw::cker::Reduce::resolved_axis_data(), nnfw::cker::round_nearest(), and nnfw::cker::Reduce::temp_index_data().

---

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

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