#include <ElementwiseActivation.h>

Collaboration diagram for onert::ir::operation::ElementwiseActivation:

[legend]

Data Structures
struct	Param

Public Types
enum	Input { INPUT = 0 }

enum class	Type { ELU , LOGISTIC , RELU , TANH , LEAKY_RELU , GELU }

Public Member Functions
	ElementwiseActivation (const OperandIndexSequence &inputs, const OperandIndexSequence &outputs, const Param &param)

void	accept (OperationVisitor &v) const override

std::string	name () const override

OpCode	opcode () const final

const Param &	param () const

Public Member Functions inherited from onert::ir::Operation
	Operation (OperandConstraint input_constr, const OperandIndexSequence &inputs, const OperandIndexSequence &outputs, OperandConstraint output_constr=OperandConstraint::createAny())

	Operation (OperandConstraint input_constr, OperandConstraint output_constr=OperandConstraint::createAny())

	Operation (const Operation &)=default

	Operation (Operation &&)=default

Operation &	operator= (const Operation &)=default

Operation &	operator= (Operation &&)=default

virtual	~Operation ()

void	replaceInputs (const OperandIndex &from, const OperandIndex &to) override

void	replaceOutputs (const OperandIndex &from, const OperandIndex &to) override

OperandIndexSequence &	getInputs ()

const OperandIndexSequence &	getInputs () const override

OperandIndexSequence	getUsedInputSet () const override

const OperandIndexSequence &	getOutputs () const override

OperandIndexSequence	getUsedOutputSet () const override

void	setInputs (const OperandIndexSequence &indexes)

void	setOutputs (const OperandIndexSequence &indexes)

Public Member Functions inherited from onert::ir::IOperation
virtual	~IOperation ()=default

Static Public Attributes
static float	infinity = std::numeric_limits<float>::infinity()

Detailed Description

Definition at line 25 of file ElementwiseActivation.h.

Member Enumeration Documentation

◆ Input

enum onert::ir::operation::ElementwiseActivation::Input

Enumerator
INPUT

Definition at line 28 of file ElementwiseActivation.h.

  {
    INPUT = 0
  };

◆ Type

enum class onert::ir::operation::ElementwiseActivation::Type

strong

Enumerator
ELU
LOGISTIC
RELU
TANH
LEAKY_RELU
GELU

Definition at line 33 of file ElementwiseActivation.h.

  {
    ELU,
    LOGISTIC,
    RELU,
    TANH,
    LEAKY_RELU,
    GELU
  };

Constructor & Destructor Documentation

◆ ElementwiseActivation()

onert::ir::operation::ElementwiseActivation::ElementwiseActivation	(	const OperandIndexSequence &	inputs,
		const OperandIndexSequence &	outputs,
		const Param &	param
	)

Definition at line 27 of file ElementwiseActivation.cc.

  : Operation{OperandConstraint::createExact(1u), inputs, outputs}, _param{param}
{
  if (param.op_type == Type::LOGISTIC)
  {
    assert(param.alpha == 0.0f && param.beta == 0.0f &&
           "Logistic will be supported only as "
           "sigmoid function(L=1, k=1, x0=0). So, do "
           "not use alpha and beta");
  }
  else if (param.op_type == Type::RELU)
  {
    assert(param.alpha >= param.beta && "ReLU's alpha must be equal or greater than beta");
  }
  else if (param.op_type == Type::TANH)
  {
    assert(param.alpha == 1.0f && param.beta == 1.0f &&
           "f(x) = alpha * tanh(beta * x), Tanh is "
           "supported only the values of alpha and "
           "beta are 1.f");
  }
}

References onert::ir::operation::ElementwiseActivation::Param::alpha, onert::ir::operation::ElementwiseActivation::Param::beta, LOGISTIC, onert::ir::operation::ElementwiseActivation::Param::op_type, param(), RELU, and TANH.

Member Function Documentation

◆ accept()

void onert::ir::operation::ElementwiseActivation::accept ( OperationVisitor & v ) const

overridevirtual

Implements onert::ir::IOperation.

Reimplemented in onert::ir::train::operation::ElementwiseActivation.

Definition at line 25 of file ElementwiseActivation.cc.

25{ v.visit(*this); }

◆ name()

std::string onert::ir::operation::ElementwiseActivation::name ( ) const

overridevirtual

Reimplemented from onert::ir::IOperation.

Definition at line 52 of file ElementwiseActivation.cc.

{
  using ElementwiseActivationType = onert::ir::operation::ElementwiseActivation::Type;
  static const std::unordered_map<Type, std::string> name_map{
    {ElementwiseActivationType::ELU, "ELU"},
    {ElementwiseActivationType::LOGISTIC, "Logistic"},
    {ElementwiseActivationType::RELU, "ReLU"},
    {ElementwiseActivationType::TANH, "Tanh"},
    {ElementwiseActivationType::LEAKY_RELU, "LeakyRelu"},
    {ElementwiseActivationType::GELU, "GELU"}};
  return name_map.at(_param.op_type);
}

References onert::ir::operation::ElementwiseActivation::Param::op_type.

◆ opcode()

OpCode onert::ir::operation::ElementwiseActivation::opcode ( ) const

inlinefinalvirtual

Implements onert::ir::IOperation.

Definition at line 64 of file ElementwiseActivation.h.

64{ return OpCode::ElementwiseActivation; }

◆ param()

const Param & onert::ir::operation::ElementwiseActivation::param ( ) const

inline

Definition at line 67 of file ElementwiseActivation.h.

67{ return _param; }

Referenced by ElementwiseActivation(), onert::backend::train::KernelGenerator::visit(), onert::ir::OperationDumper::visit(), onert::ir::OperationValidator::visit(), and onert::ir::train::UseDefGenerator::visit().

Field Documentation

◆ infinity

float onert::ir::operation::ElementwiseActivation::infinity = std::numeric_limits<float>::infinity()

inlinestatic

Definition at line 70 of file ElementwiseActivation.h.

Referenced by onert::backend::acl_common::asActivationLayerInfo(), and onert::loader::BaseLoader< LoaderDomain >::loadOperation().

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

runtime/onert/core/include/ir/operation/ElementwiseActivation.h
runtime/onert/core/src/ir/operation/ElementwiseActivation.cc

Data Structures

Public Types

Public Member Functions

Static Public Attributes