PoolLayer.cc File Reference

#include "PoolLayer.h"
#include <cker/operation/AveragePool.h>
#include <cker/operation/MaxPool.h>
#include <unordered_map>

Go to the source code of this file.

Namespaces
namespace	onert
namespace	onert::backend
namespace	onert::backend::cpu
namespace	onert::backend::cpu::ops

Macros
#define	POOLING_PARAMETERS

Macro Definition Documentation

POOLING_PARAMETERS

#define POOLING_PARAMETERS

Value:

  nnfw::cker::PoolParams op_params;                     \
  op_params.stride_height = strideHeight;               \
  op_params.stride_width = strideWidth;                 \
  op_params.filter_height = kernelHeight;               \
  op_params.filter_width = kernelWidth;                 \
  op_params.padding_values.height = (int8_t)paddingTop; \
  op_params.padding_values.width = (int8_t)paddingLeft; \
  op_params.float_activation_min = 0;                   \
  op_params.float_activation_max = 0;                   \
  op_params.quantized_activation_min = 0;               \
  op_params.quantized_activation_max = 0;

Definition at line 69 of file PoolLayer.cc.

{
  assert(input != nullptr);
  assert(output != nullptr);
 
  _input = input;
  _output = output;
 
  POOLING_PARAMETERS
 
  switch (_input->data_type())
  {
    case OperandType::FLOAT32:
    {
      float output_activation_min = 0;
      float output_activation_max = 0;
      CalculateActivationRange<float>(activation, &output_activation_min, &output_activation_max);
      op_params.float_activation_min = output_activation_min;
      op_params.float_activation_max = output_activation_max;
 
      _kernel = generateKernelGeneric<float>(op_params, op_type);
      break;
    }
    case OperandType::QUANT_UINT8_ASYMM:
    {
      int32_t output_activation_min = 0;
      int32_t output_activation_max = 0;
      CalculateActivationRangeQuantized(activation, _output, &output_activation_min,
                                        &output_activation_max);
      op_params.quantized_activation_min = output_activation_min;
      op_params.quantized_activation_max = output_activation_max;
      _kernel = generateKernelGeneric<uint8_t>(op_params, op_type);
      break;
    }
    case OperandType::QUANT_INT8_ASYMM:
    {
      int32_t output_activation_min = 0;
      int32_t output_activation_max = 0;
      CalculateActivationRangeQuantized(activation, _output, &output_activation_min,
                                        &output_activation_max);
      op_params.quantized_activation_min = output_activation_min;
      op_params.quantized_activation_max = output_activation_max;
      _kernel = generateKernelGeneric<int8_t>(op_params, op_type);
      break;
    }
    default:
      throw std::runtime_error{"Pool: unsupported data type"};
  }
}
 
void PoolLayer::run() { _kernel(_input, _output); }
 
#undef AVGPOOLING_PARAMETERS
 
} // namespace onert::backend::cpu::ops