onert::backend::train::ops::ElementwiseActivationLayer Class Reference

#include <ElementwiseActivationLayer.h>

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

Public Member Functions
	ElementwiseActivationLayer ()
void	configureBackward (const IPortableTensor *input, IPortableTensor *back_prop_input, const IPortableTensor *back_prop_output, float alpha, float beta, ElementwiseActivationType op_type)
void	forward (bool training) override
void	backward () override
Public Member Functions inherited from onert::exec::train::ITrainableFunction
virtual	~ITrainableFunction ()=default
virtual std::optional< backend::train::LayerScopeTensors >	registerLayerScopeTensors ()
Public Member Functions inherited from onert::backend::cpu::ops::ElementwiseActivationLayer
	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 ()

Additional Inherited Members
Protected Attributes inherited from onert::backend::cpu::ops::ElementwiseActivationLayer
const IPortableTensor *	_input
IPortableTensor *	_output
uint8_t	_table [256]
std::function< void(const IPortableTensor *input, IPortableTensor *output)>	_kernel

Detailed Description

Definition at line 33 of file ElementwiseActivationLayer.h.

Constructor & Destructor Documentation

ElementwiseActivationLayer()

onert::backend::train::ops::ElementwiseActivationLayer::ElementwiseActivationLayer

(

)

Definition at line 27 of file ElementwiseActivationLayer.cc.

                                                       : cpu::ops::ElementwiseActivationLayer()
{
  // DO NOTHING
}

Member Function Documentation

backward()

void onert::backend::train::ops::ElementwiseActivationLayer::backward ( )

overridevirtual

Implements onert::exec::train::ITrainableFunction.

Definition at line 88 of file ElementwiseActivationLayer.cc.

{
  _backward_kernel(_output, _back_prop_output, _back_prop_input);
}

References onert::backend::cpu::ops::ElementwiseActivationLayer::_output.

configureBackward()

void onert::backend::train::ops::ElementwiseActivationLayer::configureBackward	(	const IPortableTensor *	input,
		IPortableTensor *	back_prop_input,
		const IPortableTensor *	back_prop_output,
		float	alpha,
		float	beta,
		ElementwiseActivationType	op_type
	)

Definition at line 32 of file ElementwiseActivationLayer.cc.

{
  assert(input != nullptr);
  assert(back_prop_input != nullptr);
  assert(back_prop_output != nullptr);
 
  _back_prop_input = back_prop_input;
  _back_prop_output = back_prop_output;
 
  _op_type = op_type;
 
  switch (op_type)
  {
    case ElementwiseActivationType::kReLU:
      if (input->data_type() == OperandType::FLOAT32)
      {
        if ((alpha == std::numeric_limits<float>::infinity() || alpha == 6.0f) && beta == 0.f)
        {
          auto relu_cker = [&alpha]() {
            if (alpha == std::numeric_limits<float>::infinity())
              return nnfw::cker::train::ReLUGrad;
            else if (alpha == 6.0f)
              return nnfw::cker::train::ReLU6Grad;
            else
              throw std::runtime_error{"no supported relu kernel"};
          }();
 
          _backward_kernel = [relu_cker](const IPortableTensor *output,
                                         const IPortableTensor *incoming,
                                         IPortableTensor *outgoing) {
            relu_cker(getShape(output), getBuffer<float>(output), getShape(incoming),
                      getBuffer<float>(incoming), getShape(outgoing), getBuffer<float>(outgoing));
          };
        }
        else
        {
          throw std::runtime_error(
            "train ElementwiseActivationLayer : Unsupported ReLU activation type");
        }
      }
      else
      {
        throw std::runtime_error("train ElementwiseActivationLayer: Unsupported datatype");
      }
      break;
    default:
      throw std::runtime_error("train ElementwiseActivationLayer: Unsupported activation type yet");
  }
}

References onert::backend::train::ops::getShape(), onert::backend::train::ops::kReLU, nnfw::cker::train::ReLU6Grad(), and nnfw::cker::train::ReLUGrad().

forward()

void onert::backend::train::ops::ElementwiseActivationLayer::forward ( bool  training )

overridevirtual

Implements onert::exec::train::ITrainableFunction.

Definition at line 86 of file ElementwiseActivationLayer.cc.

{ cpu::ops::ElementwiseActivationLayer::run(); }

References onert::backend::cpu::ops::ElementwiseActivationLayer::run().

---

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

• runtime/onert/backend/train/ops/ElementwiseActivationLayer.h
• runtime/onert/backend/train/ops/ElementwiseActivationLayer.cc