#include <ElementwiseActivationLayer.h>

Collaboration diagram for onert::backend::cpu::ops::ElementwiseActivationLayer:

[legend]

Public Member Functions
	ElementwiseActivationLayer ()

void	configure (const IPortableTensor input, IPortableTensor output, float alpha, float beta, bool approximate, const ElementwiseActivationType op_type)

void	run () override

void	PopulateLookupTable (const ElementwiseActivationType op_type)

void	EvalUsingLookupTable (const IPortableTensor input, IPortableTensor output)

Public Member Functions inherited from onert::exec::IFunction
virtual	~IFunction ()=default

virtual void	prepare ()

Protected Attributes
const IPortableTensor *	_input

IPortableTensor *	_output

uint8_t	_table [256]

std::function< void(const IPortableTensor input, IPortableTensor output)>	_kernel

Detailed Description

Definition at line 37 of file ElementwiseActivationLayer.h.

Constructor & Destructor Documentation

◆ ElementwiseActivationLayer()

onert::backend::cpu::ops::ElementwiseActivationLayer::ElementwiseActivationLayer ( )

Definition at line 32 of file ElementwiseActivationLayer.cc.

  : _input(nullptr), _output(nullptr), _kernel()
{
  // DO NOTHING
}

Member Function Documentation

◆ configure()

void onert::backend::cpu::ops::ElementwiseActivationLayer::configure	(	const IPortableTensor *	input,
		IPortableTensor *	output,
		float	alpha,
		float	beta,
		bool	approximate,
		const ElementwiseActivationType	op_type
	)

Definition at line 82 of file ElementwiseActivationLayer.cc.

{
  _input = input;
  _output = output;
 
  switch (op_type)
  {
    case ElementwiseActivationType::kElu:
      if (input->data_type() == OperandType::FLOAT32)
      {
        _kernel = [](const IPortableTensor *input, IPortableTensor *output) {
          nnfw::cker::ELU(getShape(input), getBuffer<float>(input), getShape(output),
                          getBuffer<float>(output));
        };
      }
      else
      {
        throw std::runtime_error{"ElementwiseActivationLayer(Elu): unsupported data type"};
      }
      break;
    case ElementwiseActivationType::kLogistic:
      if (_input->data_type() == OperandType::QUANT_UINT8_ASYMM)
      {
        PopulateLookupTable(op_type);
        _kernel = std::bind(&ElementwiseActivationLayer::EvalUsingLookupTable, this,
                            std::placeholders::_1, std::placeholders::_2);
      }
      else if (_input->data_type() == OperandType::FLOAT32)
      {
        _kernel = [](const IPortableTensor *input, IPortableTensor *output) {
          nnfw::cker::Logistic(getShape(input), getBuffer<float>(input), getShape(output),
                               getBuffer<float>(output));
        };
      }
      else
      {
        throw std::runtime_error{"ElementwiseActivationLayer(Logistic): unsupported data type"};
      }
      break;
    case ElementwiseActivationType::kReLU:
      if (_input->data_type() == OperandType::FLOAT32)
      {
        if (alpha == std::numeric_limits<float>::infinity() && beta == 0.f)
        {
          _kernel = [](const IPortableTensor *input, IPortableTensor *output) {
            nnfw::cker::ReLU(getShape(input), getBuffer<float>(input), getShape(output),
                             getBuffer<float>(output));
          };
        }
        else if (alpha == 6.f && beta == 0.f)
        {
          _kernel = [](const IPortableTensor *input, IPortableTensor *output) {
            nnfw::cker::ReLU6(getShape(input), getBuffer<float>(input), getShape(output),
                              getBuffer<float>(output));
          };
        }
        else
        {
          throw std::runtime_error(
            "ElementwiseActivationLayer : This layer suppports only ReLU(0-inf) and ReLU6(0-6)");
        }
      }
      else
      {
        throw std::runtime_error{"ElementwiseActivationLayer(ReLU): unsupported data type"};
      }
      break;
    case ElementwiseActivationType::kTanh:
      if (_input->data_type() == OperandType::QUANT_UINT8_ASYMM)
      {
        PopulateLookupTable(op_type);
        _kernel = std::bind(&ElementwiseActivationLayer::EvalUsingLookupTable, this,
                            std::placeholders::_1, std::placeholders::_2);
      }
      else if (_input->data_type() == OperandType::FLOAT32)
      {
        _kernel = [](const IPortableTensor *input, IPortableTensor *output) {
          nnfw::cker::Tanh(getShape(input), getBuffer<float>(input), getShape(output),
                           getBuffer<float>(output));
        };
      }
      else
      {
        throw std::runtime_error{"ElementwiseActivationLayer(Tanh): unsupported data type"};
      }
      break;
    case ElementwiseActivationType::kLeakyReLU:
      if (_input->data_type() == OperandType::FLOAT32)
      {
        _kernel = [alpha](const IPortableTensor *input, IPortableTensor *output) {
          nnfw::cker::LeakyReLU(nnfw::cker::LeakyReluParams{alpha}, getShape(input),
                                getBuffer<float>(input), getShape(output),
                                getBuffer<float>(output));
        };
      }
      else
      {
        throw std::runtime_error{"ElementwiseActivationLayer(LeakyReLU): unsupported data type"};
      }
      break;
    case ElementwiseActivationType::kGELU:
      if (_input->data_type() == OperandType::FLOAT32)
      {
        _kernel = [approximate](const IPortableTensor *input, IPortableTensor *output) {
          nnfw::cker::GELU(nnfw::cker::GELUParams{approximate}, getShape(input),
                           getBuffer<float>(input), getShape(output), getBuffer<float>(output));
        };
      }
      else
      {
        throw std::runtime_error{"ElementwiseActivationLayer(GELU): unsupported data type"};
      }
      break;
    default:
      throw std::runtime_error("ElementwiseActivationLayer: unsupported op type");
  }
}

References _input, _kernel, _output, onert::backend::IPortableTensor::data_type(), nnfw::cker::ELU(), EvalUsingLookupTable(), nnfw::cker::GELU(), onert::backend::cpu::ops::getShape(), onert::backend::cpu::ops::kElu, onert::backend::cpu::ops::kGELU, onert::backend::cpu::ops::kLeakyReLU, onert::backend::cpu::ops::kLogistic, onert::backend::cpu::ops::kReLU, onert::backend::cpu::ops::kTanh, nnfw::cker::LeakyReLU(), nnfw::cker::Logistic(), PopulateLookupTable(), nnfw::cker::ReLU(), nnfw::cker::ReLU6(), and nnfw::cker::Tanh().

◆ EvalUsingLookupTable()

void onert::backend::cpu::ops::ElementwiseActivationLayer::EvalUsingLookupTable	(	const IPortableTensor *	input,
		IPortableTensor *	output
	)

Definition at line 69 of file ElementwiseActivationLayer.cc.

{
  const int size = MatchingFlatSize(getShape(input), getShape(output));
  const uint8_t *input_data = getBuffer<uint8_t>(input);
  uint8_t *output_data = getBuffer<uint8_t>(output);
 
  for (int i = 0; i < size; ++i)
  {
    output_data[i] = _table[input_data[i]];
  }
}

References _table, onert::backend::cpu::ops::getShape(), MatchingFlatSize(), and size.

Referenced by configure().

◆ PopulateLookupTable()

void onert::backend::cpu::ops::ElementwiseActivationLayer::PopulateLookupTable ( const ElementwiseActivationType op_type )

Definition at line 38 of file ElementwiseActivationLayer.cc.

{
  const auto input_scale = static_cast<double>(_input->data_scale());
  const auto input_zero_point = static_cast<int32_t>(_input->data_zero_point());
  const auto output_scale = static_cast<double>(_output->data_scale());
  const auto output_zero_point = static_cast<int32_t>(_output->data_zero_point());
  const float inverse_scale = 1 / output_scale;
  int32_t maxval = std::numeric_limits<uint8_t>::max();
  int32_t minval = std::numeric_limits<uint8_t>::min();
  for (int32_t val = minval; val <= maxval; ++val)
  {
    const float dequantized = input_scale * (val - input_zero_point);
    float transformed = 0.f;
    if (op_type == ElementwiseActivationType::kTanh)
    {
      transformed = std::tanh(dequantized);
    }
    else if (op_type == ElementwiseActivationType::kLogistic)
    {
      transformed = 1.0f / (1.0f + std::exp(-dequantized));
    }
    else
    {
      throw std::runtime_error("ElementwiseActivationLayer : unsupported activation type");
    }
    const float rescaled = std::round(transformed * inverse_scale);
    const int32_t quantized = static_cast<int32_t>(rescaled + output_zero_point);
    _table[val] = static_cast<uint8_t>(std::max(std::min(maxval, quantized), minval));
  }
}