Namespaces
namespace	BLAS
namespace	PyKeras
namespace	PyTorch
namespace	UTILITY

Classes
struct	BinaryOperatorTrait
struct	BinaryOperatorTrait< T, Add >
struct	BinaryOperatorTrait< T, Div >
struct	BinaryOperatorTrait< T, FMod >
struct	BinaryOperatorTrait< T, Mod >
struct	BinaryOperatorTrait< T, Mul >
struct	BinaryOperatorTrait< T, Pow >
struct	BinaryOperatorTrait< T, Sub >
struct	ComparisionTrait
struct	ComparisionTrait< T, Eq >
struct	ComparisionTrait< T, Greater >
struct	ComparisionTrait< T, GreaterEq >
struct	ComparisionTrait< T, Less >
struct	ComparisionTrait< T, LessEq >
struct	Dim
struct	DynamicTensorInfo
struct	ExtractDataFromTP
struct	ExtractDataFromTP< double >
struct	ExtractDataFromTP< float >
struct	ExtractDataFromTP< int32_t >
struct	ExtractDataFromTP< int64_t >
struct	FreeBlock
struct	GNN_Data
struct	GNN_Init
struct	GraphIndependent_Init
class	InitializedTensor
struct	InputTensorInfo
struct	IsOpTraits
struct	IsOpTraits< EBasicIsOperator::kIsInf >
struct	IsOpTraits< EBasicIsOperator::kIsInfNeg >
struct	IsOpTraits< EBasicIsOperator::kIsInfPos >
struct	IsOpTraits< EBasicIsOperator::kIsNaN >
struct	MemoryEvent
struct	MemoryPoolInfo
struct	MemoryResult
struct	NaryOperatorTraits
struct	NaryOperatorTraits< float, EBasicNaryOperator::Mean >
struct	NaryOperatorTraits< T, EBasicNaryOperator::Max >
struct	NaryOperatorTraits< T, EBasicNaryOperator::Mean >
struct	NaryOperatorTraits< T, EBasicNaryOperator::Min >
struct	NaryOperatorTraits< T, EBasicNaryOperator::Sum >
struct	RAttributes_Pool
class	RFunction
class	RFunction_Aggregate
class	RFunction_Mean
class	RFunction_MLP
class	RFunction_Sum
class	RFunction_Update
class	RModel
class	RModel_Base
class	RModel_GNN
class	RModel_GNNBase
class	RModel_GraphIndependent
class	RModelParser_ONNX
class	ROperator
class	ROperator_Basic_Is
class	ROperator_BasicBinary
class	ROperator_BasicNary
class	ROperator_BasicUnary
class	ROperator_BatchNormalization
class	ROperator_Cast
class	ROperator_Clip
class	ROperator_Comparision
class	ROperator_Concat
class	ROperator_Constant
class	ROperator_Conv
class	ROperator_ConvTranspose
	Transposed Convolution operator. More...
class	ROperator_Custom
class	ROperator_Einsum
class	ROperator_Elu
class	ROperator_Erf
class	ROperator_Expand
class	ROperator_EyeLike
class	ROperator_Gather
class	ROperator_GatherND
class	ROperator_Gelu
class	ROperator_Gemm
class	ROperator_GRU
	Gated Recurrent Unit operator. More...
class	ROperator_Identity
class	ROperator_If
class	ROperator_LayerNormalization
class	ROperator_LeakyRelu
class	ROperator_LSTM
	Long Short-Term Memory operator. More...
class	ROperator_NonZero
class	ROperator_Not
class	ROperator_Pad
class	ROperator_Pool
class	ROperator_Random
class	ROperator_Range
class	ROperator_Reduce
class	ROperator_Relu
class	ROperator_Reshape
class	ROperator_RNN
	Recurrent Neural Network operator. More...
class	ROperator_ScatterElements
class	ROperator_ScatterND
class	ROperator_Selu
class	ROperator_Shape
class	ROperator_Sigmoid
class	ROperator_Slice
class	ROperator_Softmax
class	ROperator_Split
class	ROperator_Swish
class	ROperator_Tanh
class	ROperator_Tile
class	ROperator_TopK
class	ROperator_Transpose
class	ROperator_Where
struct	SingleDim
struct	TensorDims
struct	TensorInfo
struct	TensorLifeInfo
struct	TensorMemoryInfo
struct	TensorShape
struct	TensorShape< Dim >
struct	TensorShape< size_t >
struct	TensorType
struct	TensorType< bool >
struct	TensorType< double >
struct	TensorType< float >
struct	TensorType< int32_t >
struct	TensorType< int64_t >
struct	TensorType< int8_t >
struct	TensorType< uint32_t >
struct	TensorType< uint64_t >
struct	TensorType< uint8_t >
struct	UnaryOpTraits
struct	UnaryOpTraits< T, EBasicUnaryOperator::kAbs >
struct	UnaryOpTraits< T, EBasicUnaryOperator::kAtan >
struct	UnaryOpTraits< T, EBasicUnaryOperator::kCos >
struct	UnaryOpTraits< T, EBasicUnaryOperator::kExp >
struct	UnaryOpTraits< T, EBasicUnaryOperator::kFloor >
struct	UnaryOpTraits< T, EBasicUnaryOperator::kLog >
struct	UnaryOpTraits< T, EBasicUnaryOperator::kNeg >
struct	UnaryOpTraits< T, EBasicUnaryOperator::kReciprocal >
struct	UnaryOpTraits< T, EBasicUnaryOperator::kSin >
struct	UnaryOpTraits< T, EBasicUnaryOperator::kSoftplus >
struct	UnaryOpTraits< T, EBasicUnaryOperator::kSqrt >

Typedefs
typedef std::int64_t	int_t
using	ParserFuncSignature
using	ParserFuseFuncSignature

Enumerations
enum class	Activation { RELU = 0x0 , Invalid = 0x1 }
enum class	EActivationType { UNDEFINED = 0 , RELU = 1 , SOFTMAX = 2 , SIGMOID = 3 , LEAKYRELU = 4 , TANH = 5 , ELU = 6 }
enum	EBasicBinaryOperator { Add , Sub , Mul , Div , Pow , Mod , FMod }
enum class	EBasicIsOperator { kIsInf , kIsInfPos , kIsInfNeg , kIsNaN }
enum class	EBasicNaryOperator { Max , Min , Mean , Sum }
enum class	EBasicUnaryOperator { kReciprocal , kSqrt , kNeg , kExp , kLog , kSin , kCos , kAbs , kSoftplus , kAtan , kFloor }
enum	EComparisionOperator { Eq , Less , LessEq , Greater , GreaterEq }
enum	EReduceOpMode { ReduceMean , ReduceSum , ReduceSumSquare , ReduceProd , InvalidReduceOp }
enum class	ETensorType { UNDEFINED = 0 , FLOAT = 1 , UINT8 = 2 , INT8 = 3 , UINT16 = 4 , INT16 = 5 , INT32 = 6 , INT64 = 7 , STRING = 8 , BOOL = 9 , FLOAT16 = 10 , DOUBLE = 11 , UINT32 = 12 , UINT64 = 13 , COMPLEX64 = 14 , COMPLEX28 = 15 , BFLOAT16 = 16 }
enum class	FunctionReducer { INVALID = 0 , SUM = 1 , MEAN = 2 }
enum class	FunctionRelation { INVALID = 0 , NODES_EDGES = 1 , NODES_GLOBALS = 2 , EDGES_GLOBALS = 3 }
enum class	FunctionTarget { INVALID = 0 , NODES = 1 , EDGES = 2 , GLOBALS = 3 }
enum class	FunctionType { UPDATE = 0 , AGGREGATE = 1 }
enum class	GraphType { INVALID = 0 , GNN = 1 , GraphIndependent = 2 }
enum class	OptimizationLevel { kBasic = 0x0 , kExtended = 0x1 }
enum class	Options { kDefault = 0x0 , kNoSession = 0x1 , kNoWeightFile = 0x2 , kRootBinaryWeightFile = 0x4 , kGNN = 0x8 , kGNNComponent = 0x10 }
enum	PoolOpMode { InvalidPool , MaxPool , AveragePool , GlobalAveragePool }
enum	RandomOpMode { kUniform , kNormal }
enum	ReshapeOpMode { Reshape , Flatten , Squeeze , Unsqueeze }
enum class	WeightFileType { None , RootBinary , Text }

Functions
void	CloseNestedLoops (std::stringstream &out, size_t loopRank)
GNN_Data	Concatenate (GNN_Data &data1, GNN_Data &data2, int axis=0)
template<typename T>
TMVA::Experimental::RTensor< T >	Concatenate (TMVA::Experimental::RTensor< T > &t1, TMVA::Experimental::RTensor< T > &t2, int axis=0)
std::string	ConvertDimShapeToLength (const std::vector< Dim > &shape)
std::string	ConvertDimShapeToString (const std::vector< Dim > &shape)
std::vector< Dim >	ConvertShapeToDim (const std::vector< size_t > &shape)
	Convert shape from integer format to dynamic one (based on Dim).
std::vector< size_t >	ConvertShapeToInt (const std::vector< Dim > &shape)
	Convert shape based on Dim to integer format.
std::size_t	ConvertShapeToLength (const std::vector< size_t > &shape)
std::string	ConvertShapeToString (const std::vector< size_t > &shape)
ETensorType	ConvertStringToType (std::string type)
std::string	ConvertTypeToString (ETensorType type)
template<class T>
std::string	ConvertValToString (T value)
template<class T>
std::string	ConvertValuesToString (const std::vector< T > &data, size_t maxprint=5)
template<class T>
std::string	ConvertValuesToString (size_t n, const T *data, size_t maxprint=-1)
GNN_Data	Copy (const GNN_Data &data)
void	Copy (float output, float const input, int size)
void	EmitNestedLoops (std::stringstream &out, size_t loopRank, const std::vector< Dim > shape)
void	Fill (float *output, float value, int size)
void	Gemm_Call (float output, bool transa, bool transb, int m, int n, int k, float alpha, const float A, const float B, float beta, const float C)
template<typename T>
std::string	GenerateConstantTensorCode (const std::pair< std::string, InitializedTensor > &t)
template<typename T>
ETensorType	GetTemplatedType (T)
constexpr size_t	GetTypeSize (ETensorType type)
bool	IsInteger (const std::string &s)
template<class Arr>
constexpr TensorDims	makeDims (Arr const &arr)
std::ostream &	operator<< (std::ostream &os, const Dim &d)
std::underlying_type_t< Options >	operator\| (Options opA, Options opB)
std::underlying_type_t< Options >	operator\| (std::underlying_type_t< Options > opA, Options opB)
MemoryResult	OrganizeMemory (const std::vector< TensorLifeInfo > &tensorsInfo)
	Greedy best-fit planner with coalescing free list.
template<EBasicBinaryOperator Op>
std::unique_ptr< ROperator >	ParseBasicBinary (RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto)
template<EBasicIsOperator Op>
std::unique_ptr< ROperator >	ParseBasicIs (RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto)
template<EBasicNaryOperator Op>
std::unique_ptr< ROperator >	ParseBasicNary (RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto)
template<EBasicUnaryOperator Op>
std::unique_ptr< ROperator >	ParseBasicUnary (RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto)
template<EComparisionOperator Op>
std::unique_ptr< ROperator >	ParseComparision (RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto)
float	ParseFloatToken (const std::string &s)
template<EReduceOpMode Op>
std::unique_ptr< ROperator >	ParseReduce (RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto)
template<class T>
void	ReadTensorFromStream (std::istream &is, T &target, std::string const &expectedName, std::size_t expectedLength)
void	Relu (float output, float const input, int size)

Variables
ParserFuncSignature	ParseAbs
ParserFuncSignature	ParseAdd
ParserFuncSignature	ParseAtan
ParserFuncSignature	ParseBatchNormalization
ParserFuncSignature	ParseCast
ParserFuncSignature	ParseClip
ParserFuncSignature	ParseConcat
ParserFuncSignature	ParseConstant
ParserFuncSignature	ParseConv
ParserFuncSignature	ParseConvTranspose
ParserFuncSignature	ParseCos
ParserFuncSignature	ParseDiv
ParserFuncSignature	ParseEinsum
ParserFuncSignature	ParseElu
ParserFuncSignature	ParseEq
ParserFuncSignature	ParseErf
ParserFuncSignature	ParseExp
ParserFuncSignature	ParseExpand
ParserFuncSignature	ParseEyeLike
ParserFuncSignature	ParseFloor
ParserFuseFuncSignature	ParseFuseBatchnormRelu
ParserFuseFuncSignature	ParseFuseConvAdd
ParserFuseFuncSignature	ParseFuseConvTransposeAdd
ParserFuseFuncSignature	ParseFuseGemmRelu
ParserFuseFuncSignature	ParseFuseMatMulAdd
ParserFuncSignature	ParseGather
ParserFuncSignature	ParseGatherND
ParserFuncSignature	ParseGelu
ParserFuncSignature	ParseGemm
ParserFuncSignature	ParseGreater
ParserFuncSignature	ParseGreaterEq
ParserFuncSignature	ParseGRU
ParserFuncSignature	ParseIdentity
ParserFuncSignature	ParseIf
ParserFuncSignature	ParseIsInf
ParserFuncSignature	ParseIsNaN
ParserFuncSignature	ParseLayerNormalization
ParserFuncSignature	ParseLeakyRelu
ParserFuncSignature	ParseLess
ParserFuncSignature	ParseLessEq
ParserFuncSignature	ParseLog
ParserFuncSignature	ParseLSTM
ParserFuncSignature	ParseMatMul
ParserFuncSignature	ParseMax
ParserFuncSignature	ParseMean
ParserFuncSignature	ParseMin
ParserFuncSignature	ParseMod
ParserFuncSignature	ParseMul
ParserFuncSignature	ParseNeg
ParserFuncSignature	ParseNonZero
ParserFuncSignature	ParseNot
ParserFuncSignature	ParsePad
ParserFuncSignature	ParsePool
ParserFuncSignature	ParsePow
ParserFuncSignature	ParseRandom
ParserFuncSignature	ParseRange
ParserFuncSignature	ParseReciprocal
ParserFuncSignature	ParseReduceMean
ParserFuncSignature	ParseReduceProd
ParserFuncSignature	ParseReduceSum
ParserFuncSignature	ParseReduceSumSquare
ParserFuncSignature	ParseRelu
ParserFuncSignature	ParseReshape
ParserFuncSignature	ParseRNN
ParserFuncSignature	ParseScatterElements
ParserFuncSignature	ParseScatterND
ParserFuncSignature	ParseSelu
ParserFuncSignature	ParseShape
ParserFuncSignature	ParseSigmoid
ParserFuncSignature	ParseSin
ParserFuncSignature	ParseSlice
ParserFuncSignature	ParseSoftmax
ParserFuncSignature	ParseSoftplus
ParserFuncSignature	ParseSplit
ParserFuncSignature	ParseSqrt
ParserFuncSignature	ParseSub
ParserFuncSignature	ParseSum
ParserFuncSignature	ParseTanh
ParserFuncSignature	ParseTile
ParserFuncSignature	ParseTopK
ParserFuncSignature	ParseTranspose
ParserFuncSignature	ParseWhere
const std::string	SP = " "

Typedef Documentation

◆ int_t

typedef std::int64_t TMVA::Experimental::SOFIE::int_t

Definition at line 55 of file SOFIE_common.hxx.

◆ ParserFuncSignature

using TMVA::Experimental::SOFIE::ParserFuncSignature

Initial value:

std::function<std::unique_ptr<ROperator>(RModelParser_ONNX & , const onnx::NodeProto & )>

TMVA::Experimental::SOFIE::RModelParser_ONNX

Definition RModelParser_ONNX.hxx:30

Definition at line 25 of file RModelParser_ONNX.hxx.

◆ ParserFuseFuncSignature

using TMVA::Experimental::SOFIE::ParserFuseFuncSignature

Initial value:

std::function<std::unique_ptr<ROperator> (RModelParser_ONNX& , const onnx::NodeProto& , const onnx::NodeProto& )>

Definition at line 27 of file RModelParser_ONNX.hxx.

Enumeration Type Documentation

◆ Activation

enum class TMVA::Experimental::SOFIE::Activation

strong

Enumerator
RELU
Invalid

Definition at line 13 of file RFunction_MLP.hxx.

◆ EActivationType

enum class TMVA::Experimental::SOFIE::EActivationType

strong

Enumerator
UNDEFINED
RELU
SOFTMAX
SIGMOID
LEAKYRELU
TANH
ELU

Definition at line 33 of file SOFIE_common.hxx.

◆ EBasicBinaryOperator

enum TMVA::Experimental::SOFIE::EBasicBinaryOperator

Enumerator
Add
Sub
Mul
Div
Pow
Mod
FMod

Definition at line 14 of file ROperator_BasicBinary.hxx.

◆ EBasicIsOperator

enum class TMVA::Experimental::SOFIE::EBasicIsOperator

strong

Enumerator
kIsInf
kIsInfPos
kIsInfNeg
kIsNaN

Definition at line 13 of file ROperator_Basic_Is.hxx.

◆ EBasicNaryOperator

enum class TMVA::Experimental::SOFIE::EBasicNaryOperator

strong

Enumerator
Max
Min
Mean
Sum

Definition at line 16 of file ROperator_BasicNary.hxx.

◆ EBasicUnaryOperator

enum class TMVA::Experimental::SOFIE::EBasicUnaryOperator

strong

Enumerator
kReciprocal
kSqrt
kNeg
kExp
kLog
kSin
kCos
kAbs
kSoftplus
kAtan
kFloor

Definition at line 12 of file ROperator_BasicUnary.hxx.

◆ EComparisionOperator

enum TMVA::Experimental::SOFIE::EComparisionOperator

Enumerator
Eq
Less
LessEq
Greater
GreaterEq

Definition at line 15 of file ROperator_Comparision.hxx.

◆ EReduceOpMode

enum TMVA::Experimental::SOFIE::EReduceOpMode

Enumerator
ReduceMean
ReduceSum
ReduceSumSquare
ReduceProd
InvalidReduceOp

Definition at line 19 of file ROperator_Reduce.hxx.

◆ ETensorType

enum class TMVA::Experimental::SOFIE::ETensorType

strong

Enumerator
UNDEFINED
FLOAT
UINT8
INT8
UINT16
INT16
INT32
INT64
STRING
BOOL
FLOAT16
DOUBLE
UINT32
UINT64
COMPLEX64
COMPLEX28
BFLOAT16

Definition at line 28 of file SOFIE_common.hxx.

◆ FunctionReducer

enum class TMVA::Experimental::SOFIE::FunctionReducer

strong

Enumerator
INVALID
SUM
MEAN

Definition at line 108 of file RModel_Base.hxx.

◆ FunctionRelation

enum class TMVA::Experimental::SOFIE::FunctionRelation

strong

Enumerator
INVALID
NODES_EDGES
NODES_GLOBALS
EDGES_GLOBALS

Definition at line 109 of file RModel_Base.hxx.

◆ FunctionTarget

enum class TMVA::Experimental::SOFIE::FunctionTarget

strong

Enumerator
INVALID
NODES
EDGES
GLOBALS

Definition at line 107 of file RModel_Base.hxx.

◆ FunctionType

enum class TMVA::Experimental::SOFIE::FunctionType

strong

Enumerator
UPDATE
AGGREGATE

Definition at line 106 of file RModel_Base.hxx.

◆ GraphType

enum class TMVA::Experimental::SOFIE::GraphType

strong

Enumerator
INVALID
GNN
GraphIndependent

Definition at line 104 of file RModel_Base.hxx.

◆ OptimizationLevel

enum class TMVA::Experimental::SOFIE::OptimizationLevel

strong

Enumerator
kBasic
kExtended

Definition at line 35 of file RModel_Base.hxx.

◆ Options

enum class TMVA::Experimental::SOFIE::Options

strong

Enumerator
kDefault
kNoSession
kNoWeightFile
kRootBinaryWeightFile
kGNN
kGNNComponent

Definition at line 22 of file RModel_Base.hxx.

◆ PoolOpMode

enum TMVA::Experimental::SOFIE::PoolOpMode

Enumerator
InvalidPool
MaxPool
AveragePool
GlobalAveragePool

Definition at line 31 of file ROperator_Pool.hxx.

◆ RandomOpMode

enum TMVA::Experimental::SOFIE::RandomOpMode

Enumerator
kUniform
kNormal

Definition at line 16 of file ROperator_Random.hxx.

◆ ReshapeOpMode

enum TMVA::Experimental::SOFIE::ReshapeOpMode

Enumerator
Reshape
Flatten
Squeeze
Unsqueeze

Definition at line 17 of file ROperator_Reshape.hxx.

◆ WeightFileType

enum class TMVA::Experimental::SOFIE::WeightFileType

strong

Enumerator
None
RootBinary
Text

Definition at line 40 of file RModel_Base.hxx.

Function Documentation

◆ CloseNestedLoops()

void TMVA::Experimental::SOFIE::CloseNestedLoops	(	std::stringstream &	out,
		size_t	loopRank )

Definition at line 566 of file SOFIE_common.cxx.

◆ Concatenate() [1/2]

GNN_Data TMVA::Experimental::SOFIE::Concatenate	(	GNN_Data &	data1,
		GNN_Data &	data2,
		int	axis = 0 )

inline

Definition at line 739 of file SOFIE_common.hxx.

◆ Concatenate() [2/2]

template<typename T>

TMVA::Experimental::RTensor< T > TMVA::Experimental::SOFIE::Concatenate	(	TMVA::Experimental::RTensor< T > &	t1,
		TMVA::Experimental::RTensor< T > &	t2,
		int	axis = 0 )

Definition at line 702 of file SOFIE_common.hxx.

◆ ConvertDimShapeToLength()

std::string TMVA::Experimental::SOFIE::ConvertDimShapeToLength ( const std::vector< Dim > & shape )

Definition at line 147 of file SOFIE_common.cxx.

◆ ConvertDimShapeToString()

std::string TMVA::Experimental::SOFIE::ConvertDimShapeToString ( const std::vector< Dim > & shape )

Definition at line 136 of file SOFIE_common.cxx.

◆ ConvertShapeToDim()

std::vector< Dim > TMVA::Experimental::SOFIE::ConvertShapeToDim ( const std::vector< size_t > & shape )

Convert shape from integer format to dynamic one (based on Dim).

Parameters

shape

Returns: shape based on Dim

Definition at line 17 of file SOFIE_common.cxx.

◆ ConvertShapeToInt()

std::vector< size_t > TMVA::Experimental::SOFIE::ConvertShapeToInt ( const std::vector< Dim > & shape )

Convert shape based on Dim to integer format.

Parameters

shape

Returns: shape based on integer. Return an empty shape in case shape is dynamic (has a parameter)

Definition at line 28 of file SOFIE_common.cxx.

◆ ConvertShapeToLength()

std::size_t TMVA::Experimental::SOFIE::ConvertShapeToLength ( const std::vector< size_t > & shape )

Definition at line 54 of file SOFIE_common.cxx.

◆ ConvertShapeToString()

std::string TMVA::Experimental::SOFIE::ConvertShapeToString ( const std::vector< size_t > & shape )

Definition at line 125 of file SOFIE_common.cxx.

◆ ConvertStringToType()

ETensorType TMVA::Experimental::SOFIE::ConvertStringToType ( std::string type )

Definition at line 104 of file SOFIE_common.cxx.

◆ ConvertTypeToString()

std::string TMVA::Experimental::SOFIE::ConvertTypeToString ( ETensorType type )

Definition at line 61 of file SOFIE_common.cxx.

◆ ConvertValToString()

template<class T>

std::string TMVA::Experimental::SOFIE::ConvertValToString ( T value )

Definition at line 216 of file SOFIE_common.hxx.

◆ ConvertValuesToString() [1/2]

template<class T>

std::string TMVA::Experimental::SOFIE::ConvertValuesToString	(	const std::vector< T > &	data,
		size_t	maxprint = 5 )

Definition at line 244 of file SOFIE_common.hxx.

◆ ConvertValuesToString() [2/2]

template<class T>

std::string TMVA::Experimental::SOFIE::ConvertValuesToString	(	size_t	n,
		const T *	data,
		size_t	maxprint = -1 )

Definition at line 227 of file SOFIE_common.hxx.

◆ Copy() [1/2]

GNN_Data TMVA::Experimental::SOFIE::Copy ( const GNN_Data & data )

inline

Definition at line 749 of file SOFIE_common.hxx.

◆ Copy() [2/2]

void TMVA::Experimental::SOFIE::Copy	(	float *	output,
		float const *	input,
		int	size )

inline

Definition at line 782 of file SOFIE_common.hxx.

◆ EmitNestedLoops()

void TMVA::Experimental::SOFIE::EmitNestedLoops	(	std::stringstream &	out,
		size_t	loopRank,
		const std::vector< Dim >	shape )

Definition at line 558 of file SOFIE_common.cxx.

◆ Fill()

void TMVA::Experimental::SOFIE::Fill	(	float *	output,
		float	value,
		int	size )

inline

Definition at line 777 of file SOFIE_common.hxx.

◆ Gemm_Call()

void TMVA::Experimental::SOFIE::Gemm_Call	(	float *	output,
		bool	transa,
		bool	transb,
		int	m,
		int	n,
		int	k,
		float	alpha,
		const float *	A,
		const float *	B,
		float	beta,
		const float *	C )

inline

Definition at line 762 of file SOFIE_common.hxx.

◆ GenerateConstantTensorCode()

template<typename T>

std::string TMVA::Experimental::SOFIE::GenerateConstantTensorCode ( const std::pair< std::string, InitializedTensor > & t )

Definition at line 753 of file RModel.cxx.

◆ GetTemplatedType()

template<typename T>

ETensorType TMVA::Experimental::SOFIE::GetTemplatedType ( T )

Definition at line 326 of file SOFIE_common.hxx.

◆ GetTypeSize()

size_t TMVA::Experimental::SOFIE::GetTypeSize ( ETensorType type )

constexpr

Definition at line 37 of file SOFIE_common.hxx.

◆ IsInteger()

bool TMVA::Experimental::SOFIE::IsInteger ( const std::string & s )

Definition at line 196 of file SOFIE_common.cxx.

◆ makeDims()

template<class Arr>

TensorDims TMVA::Experimental::SOFIE::makeDims ( Arr const & arr )

constexpr

Definition at line 878 of file SOFIE_common.hxx.

◆ operator<<()

std::ostream & TMVA::Experimental::SOFIE::operator<<	(	std::ostream &	os,
		const Dim &	d )

inline

Definition at line 104 of file SOFIE_common.hxx.

◆ operator|() [1/2]

std::underlying_type_t< Options > TMVA::Experimental::SOFIE::operator\|	(	Options	opA,
		Options	opB )

Definition at line 56 of file RModel.cxx.

◆ operator|() [2/2]

std::underlying_type_t< Options > TMVA::Experimental::SOFIE::operator\|	(	std::underlying_type_t< Options >	opA,
		Options	opB )

Definition at line 59 of file RModel.cxx.

◆ OrganizeMemory()

MemoryResult TMVA::Experimental::SOFIE::OrganizeMemory ( const std::vector< TensorLifeInfo > & tensorsInfo )

Greedy best-fit planner with coalescing free list.

Definition at line 595 of file SOFIE_common.cxx.

◆ ParseBasicBinary()

template<EBasicBinaryOperator Op>

std::unique_ptr< ROperator > TMVA::Experimental::SOFIE::ParseBasicBinary	(	RModelParser_ONNX &	parser,
		const onnx::NodeProto &	nodeproto )

Definition at line 10 of file ParseBasicBinary.cxx.

◆ ParseBasicIs()

template<EBasicIsOperator Op>

std::unique_ptr< ROperator > TMVA::Experimental::SOFIE::ParseBasicIs	(	RModelParser_ONNX &	parser,
		const onnx::NodeProto &	nodeproto )

Definition at line 10 of file ParseBasicIs.cxx.

◆ ParseBasicNary()

template<EBasicNaryOperator Op>

std::unique_ptr< ROperator > TMVA::Experimental::SOFIE::ParseBasicNary	(	RModelParser_ONNX &	parser,
		const onnx::NodeProto &	nodeproto )

Definition at line 11 of file ParseBasicNary.cxx.

◆ ParseBasicUnary()

template<EBasicUnaryOperator Op>

std::unique_ptr< ROperator > TMVA::Experimental::SOFIE::ParseBasicUnary	(	RModelParser_ONNX &	parser,
		const onnx::NodeProto &	nodeproto )

Definition at line 10 of file ParseBasicUnary.cxx.

◆ ParseComparision()

template<EComparisionOperator Op>

std::unique_ptr< ROperator > TMVA::Experimental::SOFIE::ParseComparision	(	RModelParser_ONNX &	parser,
		const onnx::NodeProto &	nodeproto )

Definition at line 10 of file ParseComparision.cxx.

◆ ParseFloatToken()

float TMVA::Experimental::SOFIE::ParseFloatToken ( const std::string & s )

inline

Definition at line 794 of file SOFIE_common.hxx.

◆ ParseReduce()

template<EReduceOpMode Op>

std::unique_ptr< ROperator > TMVA::Experimental::SOFIE::ParseReduce	(	RModelParser_ONNX &	parser,
		const onnx::NodeProto &	nodeproto )

Definition at line 11 of file ParseReduce.cxx.

◆ ReadTensorFromStream()

template<class T>

void TMVA::Experimental::SOFIE::ReadTensorFromStream	(	std::istream &	is,
		T &	target,
		std::string const &	expectedName,
		std::size_t	expectedLength )

Definition at line 802 of file SOFIE_common.hxx.

◆ Relu()

void TMVA::Experimental::SOFIE::Relu	(	float *	output,
		float const *	input,
		int	size )

inline

Definition at line 787 of file SOFIE_common.hxx.

Variable Documentation

◆ ParseAbs

ParserFuncSignature TMVA::Experimental::SOFIE::ParseAbs

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicUnary<EBasicUnaryOperator::kAbs>(parser, nodeproto);
}

Definition at line 79 of file ParseBasicUnary.cxx.

◆ ParseAdd

ParserFuncSignature TMVA::Experimental::SOFIE::ParseAdd

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicBinary<EBasicBinaryOperator::Add>(parser, nodeproto);
}

Definition at line 66 of file ParseBasicBinary.cxx.

◆ ParseAtan

ParserFuncSignature TMVA::Experimental::SOFIE::ParseAtan

Initial value:

                              = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicUnary<EBasicUnaryOperator::kAtan>(parser, nodeproto);
}

Definition at line 89 of file ParseBasicUnary.cxx.

◆ ParseBatchNormalization

ParserFuncSignature TMVA::Experimental::SOFIE::ParseBatchNormalization

Definition at line 9 of file ParseBatchNormalization.cxx.

◆ ParseCast

ParserFuncSignature TMVA::Experimental::SOFIE::ParseCast

Initial value:

                              = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   auto input_name = nodeproto.input(0);
   if (!parser.IsRegisteredTensorType(input_name)) {
      throw std::runtime_error("TMVA::SOFIE ONNX Parser Cast op has input tensor" + input_name +
                               "  but its type is not yet registered");
   }
 
   ETensorType output_type = ETensorType::UNDEFINED;
 
   for (int_t i = 0; i < nodeproto.attribute_size(); i++) {
      std::string attribute_name = nodeproto.attribute(i).name();
      if (attribute_name == "to") {
         output_type = static_cast<ETensorType>(nodeproto.attribute(i).i());
      }
   }
   if (output_type == ETensorType::UNDEFINED)
      throw std::runtime_error("TMVA::SOFIE ONNX Parser Cast op has invalid output type");
 
   std::string output_name = nodeproto.output(0);
   auto op = std::make_unique<ROperator_Cast>(output_type, nodeproto.input(0), output_name);
 
   if (!parser.IsRegisteredTensorType(output_name)) {
      parser.RegisterTensorType(output_name, output_type);
   }
 
   return op;
}

Definition at line 9 of file ParseCast.cxx.

◆ ParseClip

ParserFuncSignature TMVA::Experimental::SOFIE::ParseClip

Definition at line 25 of file ParseClip.cxx.

◆ ParseConcat

ParserFuncSignature TMVA::Experimental::SOFIE::ParseConcat

Definition at line 9 of file ParseConcat.cxx.

◆ ParseConstant

ParserFuncSignature TMVA::Experimental::SOFIE::ParseConstant

Definition at line 11 of file ParseConstant.cxx.

◆ ParseConv

ParserFuncSignature TMVA::Experimental::SOFIE::ParseConv

Definition at line 9 of file ParseConv.cxx.

◆ ParseConvTranspose

ParserFuncSignature TMVA::Experimental::SOFIE::ParseConvTranspose

Definition at line 9 of file ParseConvTranspose.cxx.

◆ ParseCos

ParserFuncSignature TMVA::Experimental::SOFIE::ParseCos

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicUnary<EBasicUnaryOperator::kCos>(parser, nodeproto);
}

Definition at line 74 of file ParseBasicUnary.cxx.

◆ ParseDiv

ParserFuncSignature TMVA::Experimental::SOFIE::ParseDiv

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicBinary<EBasicBinaryOperator::Div>(parser, nodeproto);
}

Definition at line 81 of file ParseBasicBinary.cxx.

◆ ParseEinsum

ParserFuncSignature TMVA::Experimental::SOFIE::ParseEinsum

Definition at line 9 of file ParseEinsum.cxx.

◆ ParseElu

ParserFuncSignature TMVA::Experimental::SOFIE::ParseElu

Definition at line 9 of file ParseElu.cxx.

◆ ParseEq

ParserFuncSignature TMVA::Experimental::SOFIE::ParseEq

Initial value:

                            = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseComparision<EComparisionOperator::Eq>(parser, nodeproto);
}

Definition at line 59 of file ParseComparision.cxx.

◆ ParseErf

ParserFuncSignature TMVA::Experimental::SOFIE::ParseErf

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   ETensorType input_type;
 
   auto input_name = nodeproto.input(0);
   if (parser.IsRegisteredTensorType(input_name)) {
      input_type = parser.GetTensorType(input_name);
   } else {
      throw std::runtime_error("TMVA::SOFIE ONNX Parser Erf op has input tensor" + input_name +
                               " but its type is not yet registered");
   }
 
   std::unique_ptr<ROperator> op;
   std::string output_name = nodeproto.output(0);
 
   switch (input_type) {
   case ETensorType::FLOAT: op.reset(new ROperator_Erf<float>(input_name, output_name)); break;
   default:
      throw std::runtime_error("TMVA::SOFIE - Unsupported - Operator Erf does not yet support input type " +
                               std::to_string(static_cast<int>(input_type)));
   }
 
   if (!parser.IsRegisteredTensorType(output_name)) {
      parser.RegisterTensorType(output_name, input_type);
   }
 
   return op;
}

Definition at line 9 of file ParseErf.cxx.

◆ ParseExp

ParserFuncSignature TMVA::Experimental::SOFIE::ParseExp

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicUnary<EBasicUnaryOperator::kExp>(parser, nodeproto);
}

Definition at line 59 of file ParseBasicUnary.cxx.

◆ ParseExpand

ParserFuncSignature TMVA::Experimental::SOFIE::ParseExpand

Definition at line 9 of file ParseExpand.cxx.

◆ ParseEyeLike

ParserFuncSignature TMVA::Experimental::SOFIE::ParseEyeLike

Definition at line 9 of file ParseEyeLike.cxx.

◆ ParseFloor

ParserFuncSignature TMVA::Experimental::SOFIE::ParseFloor

Initial value:

                               = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicUnary<EBasicUnaryOperator::kFloor>(parser, nodeproto);
}

Definition at line 94 of file ParseBasicUnary.cxx.

◆ ParseFuseBatchnormRelu

ParserFuseFuncSignature TMVA::Experimental::SOFIE::ParseFuseBatchnormRelu

Definition at line 9 of file ParseFuseBatchnormRelu.cxx.

◆ ParseFuseConvAdd

ParserFuseFuncSignature TMVA::Experimental::SOFIE::ParseFuseConvAdd

Initial value:

                                         = [](RModelParser_ONNX & , const onnx::NodeProto & ,
                                              const onnx::NodeProto & ) {
   std::unique_ptr<ROperator> op;
   return op;
}

Definition at line 9 of file ParseFuseConvAdd.cxx.

◆ ParseFuseConvTransposeAdd

ParserFuseFuncSignature TMVA::Experimental::SOFIE::ParseFuseConvTransposeAdd

Definition at line 9 of file ParseFuseConvTransposeAdd.cxx.

◆ ParseFuseGemmRelu

ParserFuseFuncSignature TMVA::Experimental::SOFIE::ParseFuseGemmRelu

Definition at line 9 of file ParseFuseGemmRelu.cxx.

◆ ParseFuseMatMulAdd

ParserFuseFuncSignature TMVA::Experimental::SOFIE::ParseFuseMatMulAdd

Definition at line 9 of file ParseFuseMatMulAdd.cxx.

◆ ParseGather

ParserFuncSignature TMVA::Experimental::SOFIE::ParseGather

Definition at line 10 of file ParseGather.cxx.

◆ ParseGatherND

ParserFuncSignature TMVA::Experimental::SOFIE::ParseGatherND

Definition at line 10 of file ParseGatherND.cxx.

◆ ParseGelu

ParserFuncSignature TMVA::Experimental::SOFIE::ParseGelu

Initial value:

                              = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   ETensorType input_type = ETensorType::UNDEFINED;
 
   auto input_name = nodeproto.input(0);
   if (parser.IsRegisteredTensorType(input_name)) {
      input_type = parser.GetTensorType(input_name);
   } else {
      throw std::runtime_error("TMVA::SOFIE ONNX Parser gelu op has input tensor" + input_name +
                               " but its type is not yet registered");
   }
 
   
   std::string approximate = "none";
   for (int i = 0; i < nodeproto.attribute_size(); i++) {
      const auto &attr = nodeproto.attribute(i);
      if (attr.name() == "approximate") {
         approximate = attr.s();
      }
   }
 
   std::string output_name = nodeproto.output(0);
 
   auto  op = std::make_unique<ROperator_Gelu>(input_name, output_name, approximate);
 
   if (!parser.IsRegisteredTensorType(output_name)) {
      parser.RegisterTensorType(output_name, input_type);
   }
 
   return op;
}

Definition at line 9 of file ParseGelu.cxx.

◆ ParseGemm

ParserFuncSignature TMVA::Experimental::SOFIE::ParseGemm

Definition at line 9 of file ParseGemm.cxx.

◆ ParseGreater

ParserFuncSignature TMVA::Experimental::SOFIE::ParseGreater

Initial value:

                                 = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseComparision<EComparisionOperator::Greater>(parser, nodeproto);
}

Definition at line 74 of file ParseComparision.cxx.

◆ ParseGreaterEq

ParserFuncSignature TMVA::Experimental::SOFIE::ParseGreaterEq

Initial value:

                                   = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseComparision<EComparisionOperator::GreaterEq>(parser, nodeproto);
}

Definition at line 79 of file ParseComparision.cxx.

◆ ParseGRU

ParserFuncSignature TMVA::Experimental::SOFIE::ParseGRU

Definition at line 9 of file ParseGRU.cxx.

◆ ParseIdentity

ParserFuncSignature TMVA::Experimental::SOFIE::ParseIdentity

Initial value:

                                  = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   ETensorType input_type = ETensorType::UNDEFINED;
 
   auto input_name = nodeproto.input(0);
   if (parser.IsRegisteredTensorType(input_name)) {
      input_type = parser.GetTensorType(input_name);
   } else {
      throw std::runtime_error("TMVA::SOFIE ONNX Parser Identity op has input tensor" + input_name +
                               "  but its type is not yet registered");
   }
 
   std::unique_ptr<ROperator> op;
   std::string output_name = nodeproto.output(0);
 
   switch (input_type) {
   case ETensorType::FLOAT: op.reset(new ROperator_Identity<float>(input_name, output_name)); break;
   default:
      throw std::runtime_error("TMVA::SOFIE - Unsupported - Operator Identity does not yet support input type " +
                               std::to_string(static_cast<int>(input_type)));
   }
 
   if (!parser.IsRegisteredTensorType(output_name)) {
      parser.RegisterTensorType(output_name, input_type);
   }
 
   return op;
}

Definition at line 9 of file ParseIdentity.cxx.

◆ ParseIf

ParserFuncSignature TMVA::Experimental::SOFIE::ParseIf

Definition at line 9 of file ParseIf.cxx.

◆ ParseIsInf

ParserFuncSignature TMVA::Experimental::SOFIE::ParseIsInf

Initial value:

                               = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicIs<EBasicIsOperator::kIsInf>(parser, nodeproto);
}

Definition at line 63 of file ParseBasicIs.cxx.

◆ ParseIsNaN

ParserFuncSignature TMVA::Experimental::SOFIE::ParseIsNaN

Initial value:

                               = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicIs<EBasicIsOperator::kIsNaN>(parser, nodeproto);
}

Definition at line 58 of file ParseBasicIs.cxx.

◆ ParseLayerNormalization

ParserFuncSignature TMVA::Experimental::SOFIE::ParseLayerNormalization

Definition at line 9 of file ParseLayerNormalization.cxx.

◆ ParseLeakyRelu

ParserFuncSignature TMVA::Experimental::SOFIE::ParseLeakyRelu

Definition at line 9 of file ParseLeakyRelu.cxx.

◆ ParseLess

ParserFuncSignature TMVA::Experimental::SOFIE::ParseLess

Initial value:

                              = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseComparision<EComparisionOperator::Less>(parser, nodeproto);
}

Definition at line 64 of file ParseComparision.cxx.

◆ ParseLessEq

ParserFuncSignature TMVA::Experimental::SOFIE::ParseLessEq

Initial value:

                                = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseComparision<EComparisionOperator::LessEq>(parser, nodeproto);
}

Definition at line 69 of file ParseComparision.cxx.

◆ ParseLog

ParserFuncSignature TMVA::Experimental::SOFIE::ParseLog

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicUnary<EBasicUnaryOperator::kLog>(parser, nodeproto);
}

Definition at line 64 of file ParseBasicUnary.cxx.

◆ ParseLSTM

ParserFuncSignature TMVA::Experimental::SOFIE::ParseLSTM

Definition at line 9 of file ParseLSTM.cxx.

◆ ParseMatMul

ParserFuncSignature TMVA::Experimental::SOFIE::ParseMatMul

Definition at line 9 of file ParseMatMul.cxx.

◆ ParseMax

ParserFuncSignature TMVA::Experimental::SOFIE::ParseMax

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicNary<EBasicNaryOperator::Max>(parser, nodeproto);
}

Definition at line 47 of file ParseBasicNary.cxx.

◆ ParseMean

ParserFuncSignature TMVA::Experimental::SOFIE::ParseMean

Initial value:

                              = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicNary<EBasicNaryOperator::Mean>(parser, nodeproto);
}

Definition at line 57 of file ParseBasicNary.cxx.

◆ ParseMin

ParserFuncSignature TMVA::Experimental::SOFIE::ParseMin

Initial value:

                            = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicNary<EBasicNaryOperator::Min>(parser, nodeproto);
}

Definition at line 52 of file ParseBasicNary.cxx.

◆ ParseMod

ParserFuncSignature TMVA::Experimental::SOFIE::ParseMod

Definition at line 92 of file ParseBasicBinary.cxx.

◆ ParseMul

ParserFuncSignature TMVA::Experimental::SOFIE::ParseMul

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicBinary<EBasicBinaryOperator::Mul>(parser, nodeproto);
}

Definition at line 76 of file ParseBasicBinary.cxx.

◆ ParseNeg

ParserFuncSignature TMVA::Experimental::SOFIE::ParseNeg

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicUnary<EBasicUnaryOperator::kNeg>(parser, nodeproto);
}

Definition at line 54 of file ParseBasicUnary.cxx.

◆ ParseNonZero

ParserFuncSignature TMVA::Experimental::SOFIE::ParseNonZero

Definition at line 9 of file ParseNonZero.cxx.

◆ ParseNot

ParserFuncSignature TMVA::Experimental::SOFIE::ParseNot

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto)
{
   ETensorType input_type = ETensorType::UNDEFINED;
 
   if (nodeproto.input_size() != 1 || nodeproto.output_size() != 1)
      std::runtime_error("TMVA::SOFIE ONNX Parser Not op has invalid input or output size ");
 
   std::string input_name = nodeproto.input(0);
 
   if (parser.IsRegisteredTensorType(input_name)) {
      input_type = parser.GetTensorType(input_name);
      if (input_type !=ETensorType::BOOL  && input_type !=ETensorType::UINT8 )
         throw std::runtime_error("TMVA::SOFIE ONNX Parser Not op has invalid input type " + ConvertTypeToString(input_type));
   } else {
      throw
         std::runtime_error("TMVA::SOFIE ONNX Parser Not op has input tensor " + input_name +
                                  " but its type is not yet registered");
   }
 
   std::string output_name = nodeproto.output(0);
   std::unique_ptr<ROperator> op(new ROperator_Not(input_name, output_name));
 
   
   if (!parser.IsRegisteredTensorType(output_name)) {
      parser.RegisterTensorType(output_name, input_type);
   }
 
   return op;
}

Definition at line 9 of file ParseNot.cxx.

◆ ParsePad

ParserFuncSignature TMVA::Experimental::SOFIE::ParsePad

Definition at line 9 of file ParsePad.cxx.

◆ ParsePool

ParserFuncSignature TMVA::Experimental::SOFIE::ParsePool

Definition at line 9 of file ParsePool.cxx.

◆ ParsePow

ParserFuncSignature TMVA::Experimental::SOFIE::ParsePow

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicBinary<EBasicBinaryOperator::Pow>(parser, nodeproto);
}

Definition at line 86 of file ParseBasicBinary.cxx.

◆ ParseRandom

ParserFuncSignature TMVA::Experimental::SOFIE::ParseRandom

Definition at line 9 of file ParseRandom.cxx.

◆ ParseRange

ParserFuncSignature TMVA::Experimental::SOFIE::ParseRange

Definition at line 9 of file ParseRange.cxx.

◆ ParseReciprocal

ParserFuncSignature TMVA::Experimental::SOFIE::ParseReciprocal

Initial value:

                                    = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicUnary<EBasicUnaryOperator::kReciprocal>(parser, nodeproto);
}

Definition at line 49 of file ParseBasicUnary.cxx.

◆ ParseReduceMean

ParserFuncSignature TMVA::Experimental::SOFIE::ParseReduceMean

Initial value:

                                    = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseReduce<EReduceOpMode::ReduceMean>(parser, nodeproto);
}

Definition at line 77 of file ParseReduce.cxx.

◆ ParseReduceProd

ParserFuncSignature TMVA::Experimental::SOFIE::ParseReduceProd

Initial value:

                                    = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseReduce<EReduceOpMode::ReduceProd>(parser, nodeproto);
}

Definition at line 87 of file ParseReduce.cxx.

◆ ParseReduceSum

ParserFuncSignature TMVA::Experimental::SOFIE::ParseReduceSum

Initial value:

                                   = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseReduce<EReduceOpMode::ReduceSum>(parser, nodeproto);
}

Definition at line 92 of file ParseReduce.cxx.

◆ ParseReduceSumSquare

ParserFuncSignature TMVA::Experimental::SOFIE::ParseReduceSumSquare

Initial value:

                                         = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseReduce<EReduceOpMode::ReduceSumSquare>(parser, nodeproto);
}

Definition at line 82 of file ParseReduce.cxx.

◆ ParseRelu

ParserFuncSignature TMVA::Experimental::SOFIE::ParseRelu

Initial value:

                              = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   ETensorType input_type;
 
   auto input_name = nodeproto.input(0);
   if (parser.IsRegisteredTensorType(input_name)) {
      input_type = parser.GetTensorType(input_name);
   } else {
      throw std::runtime_error("TMVA::SOFIE ONNX Parser relu op has input tensor" + input_name +
                               " but its type is not yet registered");
   }
 
   std::unique_ptr<ROperator> op;
   std::string output_name = nodeproto.output(0);
 
   switch (input_type) {
   case ETensorType::FLOAT: op.reset(new ROperator_Relu<float>(input_name, output_name)); break;
   default:
      throw std::runtime_error("TMVA::SOFIE - Unsupported - Operator Relu does not yet support input type " +
                               std::to_string(static_cast<int>(input_type)));
   }
 
   if (!parser.IsRegisteredTensorType(output_name)) {
      parser.RegisterTensorType(output_name, input_type);
   }
 
   return op;
}

Definition at line 9 of file ParseRelu.cxx.

◆ ParseReshape

ParserFuncSignature TMVA::Experimental::SOFIE::ParseReshape

Definition at line 9 of file ParseReshape.cxx.

◆ ParseRNN

ParserFuncSignature TMVA::Experimental::SOFIE::ParseRNN

Definition at line 9 of file ParseRNN.cxx.

◆ ParseScatterElements

ParserFuncSignature TMVA::Experimental::SOFIE::ParseScatterElements

Definition at line 9 of file ParseScatterElements.cxx.

◆ ParseScatterND

ParserFuncSignature TMVA::Experimental::SOFIE::ParseScatterND

Definition at line 9 of file ParseScatterND.cxx.

◆ ParseSelu

ParserFuncSignature TMVA::Experimental::SOFIE::ParseSelu

Initial value:

                              = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   ETensorType input_type = ETensorType::UNDEFINED;
 
   auto input_name = nodeproto.input(0);
   if (parser.IsRegisteredTensorType(input_name)) {
      input_type = parser.GetTensorType(input_name);
   } else {
      throw std::runtime_error("TMVA::SOFIE ONNX Parser selu op has input tensor" + input_name +
                               " but its type is not yet registered");
   }
 
   std::unique_ptr<ROperator> op;
 
   std::string output_name = nodeproto.output(0);
   switch (input_type) {
   case ETensorType::FLOAT: op.reset(new ROperator_Selu<float>(input_name, output_name)); break;
   default:
      throw std::runtime_error("TMVA::SOFIE - Unsupported - Operator Selu does not yet support input type " +
                               std::to_string(static_cast<int>(input_type)));
   }
 
   if (!parser.IsRegisteredTensorType(output_name)) {
      parser.RegisterTensorType(output_name, input_type);
   }
 
   return op;
}

Definition at line 9 of file ParseSelu.cxx.

◆ ParseShape

ParserFuncSignature TMVA::Experimental::SOFIE::ParseShape

Initial value:

                               = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   auto input_name = nodeproto.input(0);
   if (!parser.IsRegisteredTensorType(input_name)) {
      throw std::runtime_error("TMVA::SOFIE ONNX Parser Shape op has input tensor" + input_name +
                               " but its type is not yet registered");
   }
 
   std::unique_ptr<ROperator> op;
   std::string output_name = nodeproto.output(0);
   int attr_start = 0;
   int attr_end = INT_MAX;  
 
   for (int_t i = 0; i < nodeproto.attribute_size(); i++) {
      std::string attribute_name = nodeproto.attribute(i).name();
      if (attribute_name == "start")
         attr_start = nodeproto.attribute(i).i();
      if (attribute_name == "end")
         attr_end = nodeproto.attribute(i).i();
   }
 
   op.reset(new ROperator_Shape(attr_start, attr_end, input_name, output_name));
 
   
   if (!parser.IsRegisteredTensorType(output_name)) {
      parser.RegisterTensorType(output_name, ETensorType::INT64);
   }
 
   return op;
}

Definition at line 9 of file ParseShape.cxx.

◆ ParseSigmoid

ParserFuncSignature TMVA::Experimental::SOFIE::ParseSigmoid

Initial value:

                                 = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   ETensorType input_type;
 
   auto input_name = nodeproto.input(0);
   if (parser.IsRegisteredTensorType(input_name)) {
      input_type = parser.GetTensorType(input_name);
   } else {
      throw std::runtime_error("TMVA::SOFIE ONNX Parser Sigmoid op has input tensor" + input_name +
                               " but its type is not yet registered");
   }
 
   std::unique_ptr<ROperator> op;
   std::string output_name = nodeproto.output(0);
 
   switch (input_type) {
   case ETensorType::FLOAT: op.reset(new ROperator_Sigmoid<float>(input_name, output_name)); break;
   default:
      throw std::runtime_error("TMVA::SOFIE - Unsupported - Operator Sigmoid does not yet support input type " +
                               std::to_string(static_cast<int>(input_type)));
   }
 
   if (!parser.IsRegisteredTensorType(output_name)) {
      parser.RegisterTensorType(output_name, input_type);
   }
 
   return op;
}

Definition at line 9 of file ParseSigmoid.cxx.

◆ ParseSin

ParserFuncSignature TMVA::Experimental::SOFIE::ParseSin

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicUnary<EBasicUnaryOperator::kSin>(parser, nodeproto);
}

Definition at line 69 of file ParseBasicUnary.cxx.

◆ ParseSlice

ParserFuncSignature TMVA::Experimental::SOFIE::ParseSlice

Definition at line 9 of file ParseSlice.cxx.

◆ ParseSoftmax

ParserFuncSignature TMVA::Experimental::SOFIE::ParseSoftmax

Initial value:

                                 = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   ETensorType input_type;
 
   auto input_name = nodeproto.input(0);
   if (parser.IsRegisteredTensorType(input_name)) {
      input_type = parser.GetTensorType(input_name);
   } else {
      throw std::runtime_error("TMVA::SOFIE ONNX Parser Softmax op has input tensor " + input_name +
                               " but its type is not yet registered");
   }
 
   std::unique_ptr<ROperator> op;
   std::string output_name = nodeproto.output(0);
 
   bool logSoftmax = (nodeproto.op_type() == "LogSoftmax");
 
   int64_t attr_axis = -1;
   if (nodeproto.attribute_size() == 1 && nodeproto.attribute(0).name() == "axis")
      attr_axis = nodeproto.attribute(0).i();
 
   op.reset(new ROperator_Softmax(attr_axis, input_name, output_name, logSoftmax));
 
 
   if (!parser.IsRegisteredTensorType(output_name)) {
      parser.RegisterTensorType(output_name, input_type);
   }
   return op;
}

Definition at line 9 of file ParseSoftmax.cxx.

◆ ParseSoftplus

ParserFuncSignature TMVA::Experimental::SOFIE::ParseSoftplus

Initial value:

                                  = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicUnary<EBasicUnaryOperator::kSoftplus>(parser, nodeproto);
}

Definition at line 84 of file ParseBasicUnary.cxx.

◆ ParseSplit

ParserFuncSignature TMVA::Experimental::SOFIE::ParseSplit

Definition at line 9 of file ParseSplit.cxx.

◆ ParseSqrt

ParserFuncSignature TMVA::Experimental::SOFIE::ParseSqrt

Initial value:

                              = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicUnary<EBasicUnaryOperator::kSqrt>(parser, nodeproto);
}

Definition at line 44 of file ParseBasicUnary.cxx.

◆ ParseSub

ParserFuncSignature TMVA::Experimental::SOFIE::ParseSub

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicBinary<EBasicBinaryOperator::Sub>(parser, nodeproto);
}

Definition at line 71 of file ParseBasicBinary.cxx.

◆ ParseSum

ParserFuncSignature TMVA::Experimental::SOFIE::ParseSum

Initial value:

                             = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   return ParseBasicNary<EBasicNaryOperator::Sum>(parser, nodeproto);
}

Definition at line 62 of file ParseBasicNary.cxx.

◆ ParseTanh

ParserFuncSignature TMVA::Experimental::SOFIE::ParseTanh

Initial value:

                              = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   ETensorType input_type;
 
   auto input_name = nodeproto.input(0);
   if (parser.IsRegisteredTensorType(input_name)) {
      input_type = parser.GetTensorType(input_name);
   } else {
      throw std::runtime_error("TMVA::SOFIE ONNX Parser Tanh op has input tensor" + input_name +
                               " but its type is not yet registered");
   }
 
   std::unique_ptr<ROperator> op;
   std::string output_name = nodeproto.output(0);
 
   switch (input_type) {
   case ETensorType::FLOAT: op.reset(new ROperator_Tanh<float>(input_name, output_name)); break;
   default:
      throw std::runtime_error("TMVA::SOFIE - Unsupported - Operator Tanh does not yet support input type " +
                               std::to_string(static_cast<int>(input_type)));
   }
 
   if (!parser.IsRegisteredTensorType(output_name)) {
      parser.RegisterTensorType(output_name, input_type);
   }
 
   return op;
}

Definition at line 9 of file ParseTanh.cxx.

◆ ParseTile

ParserFuncSignature TMVA::Experimental::SOFIE::ParseTile

Definition at line 9 of file ParseTile.cxx.

◆ ParseTopK

ParserFuncSignature TMVA::Experimental::SOFIE::ParseTopK

Definition at line 9 of file ParseTopK.cxx.

◆ ParseTranspose

ParserFuncSignature TMVA::Experimental::SOFIE::ParseTranspose

Initial value:

                                   = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
   ETensorType input_type;
 
   auto input_name = nodeproto.input(0);
   if (parser.IsRegisteredTensorType(input_name)) {
      input_type = parser.GetTensorType(input_name);
   } else {
      throw std::runtime_error("TMVA::SOFIE ONNX Parser tranpose op has input tensor" + input_name +
                               " but its type is not yet registered");
   }
 
 
   std::string output_name = nodeproto.output(0);
   std::vector<int_t> attr_perm;
 
   if (nodeproto.attribute_size() == 1) {
      attr_perm.assign(nodeproto.attribute(0).ints().begin(), nodeproto.attribute(0).ints().end());
   }
 
   auto op = std::make_unique<ROperator_Transpose>(attr_perm, nodeproto.input(0), nodeproto.output(0));
 
   if (!parser.IsRegisteredTensorType(output_name)) {
      parser.RegisterTensorType(output_name, input_type);
   }
 
   return op;
}

Definition at line 9 of file ParseTranspose.cxx.

◆ ParseWhere

ParserFuncSignature TMVA::Experimental::SOFIE::ParseWhere

Definition at line 9 of file ParseWhere.cxx.

◆ SP

const std::string TMVA::Experimental::SOFIE::SP = " "

Definition at line 557 of file SOFIE_common.cxx.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ int_t

◆ ParserFuncSignature

◆ ParserFuseFuncSignature

Enumeration Type Documentation

◆ Activation

◆ EActivationType

◆ EBasicBinaryOperator

◆ EBasicIsOperator

◆ EBasicNaryOperator

◆ EBasicUnaryOperator

◆ EComparisionOperator

◆ EReduceOpMode

◆ ETensorType

◆ FunctionReducer

◆ FunctionRelation

◆ FunctionTarget

◆ FunctionType

◆ GraphType

◆ OptimizationLevel

◆ Options

◆ PoolOpMode

◆ RandomOpMode

◆ ReshapeOpMode

◆ WeightFileType

Function Documentation

◆ CloseNestedLoops()

◆ Concatenate() [1/2]

◆ Concatenate() [2/2]

◆ ConvertDimShapeToLength()

◆ ConvertDimShapeToString()

◆ ConvertShapeToDim()

◆ ConvertShapeToInt()

◆ ConvertShapeToLength()

◆ ConvertShapeToString()

◆ ConvertStringToType()

◆ ConvertTypeToString()

◆ ConvertValToString()

◆ ConvertValuesToString() [1/2]

◆ ConvertValuesToString() [2/2]

◆ Copy() [1/2]

◆ Copy() [2/2]

◆ EmitNestedLoops()

◆ Fill()

◆ Gemm_Call()

◆ GenerateConstantTensorCode()

◆ GetTemplatedType()

◆ GetTypeSize()

◆ IsInteger()

◆ makeDims()

◆ operator<<()

◆ operator|() [1/2]

◆ operator|() [2/2]

◆ OrganizeMemory()

◆ ParseBasicBinary()

◆ ParseBasicIs()

◆ ParseBasicNary()

◆ ParseBasicUnary()

◆ ParseComparision()

◆ ParseFloatToken()

◆ ParseReduce()

◆ ReadTensorFromStream()

◆ Relu()

Variable Documentation

◆ ParseAbs

◆ ParseAdd

◆ ParseAtan

◆ ParseBatchNormalization

◆ ParseCast

◆ ParseClip

◆ ParseConcat

◆ ParseConstant

◆ ParseConv

◆ ParseConvTranspose