Namespaces
namespace	compute

namespace	pass

namespace	sinf

namespace	test

namespace	tinf

Data Structures
class	Array4DIndex
	Index class for 4D tensor to calculate linear index from multi-dimensional indices. More...

class	BuiltinOperatorMappingRule

class	BuiltinOptionsExtractor

class	BuiltinOptionsMappingRule

struct	CanonicalizePass
	Class to canoncalize CircleNodes. More...

class	CircleAbs
	ABS in Circle. More...

class	CircleAbsGraphBuilder

class	CircleAdd
	ADD in Circle. More...

class	CircleAddGraphBuilder

class	CircleAddN
	ADD_N in Circle. More...

class	CircleAddNGraphBuilder

class	CircleArgMax
	ARG_MAX in Circle. More...

class	CircleArgMaxGraphBuilder

class	CircleArgMin
	ARG_Min in Circle. More...

class	CircleArgMinGraphBuilder

class	CircleAveragePool2D
	AVERAGE_POOL_2D in Circle. More...

class	CircleAveragePool2DGraphBuilder

class	CircleBatchMatMul
	BATCH_MATMUL in Circle. More...

class	CircleBatchMatMulGraphBuilder

class	CircleBatchToSpaceND
	BATCH_TO_SPACE_ND in Circle. More...

class	CircleBatchToSpaceNDGraphBuilder

class	CircleBCQFullyConnected
	BCQ_FULLY_CONNECTED in Circle. More...

class	CircleBCQFullyConnectedGraphBuilder

class	CircleBCQGather
	BCQ_GATHER in Circle. More...

class	CircleBCQGatherGraphBuilder

class	CircleBidirectionalSequenceLSTM
	BIDIRECTIONAL_SEQUENCE_LSTM in Circle. More...

class	CircleBidirectionalSequenceLSTMGraphBuilder

class	CircleBidirectionalSequenceLSTMOut
	Virtual CIRCLEBIDIRECTIONAL_SEQUENCE_LSTM_OUT in Circle. More...

class	CircleBroadcastTo
	BroadcastTo in Circle. More...

class	CircleBroadcastToGraphBuilder

class	CircleCast
	CAST in Circle. More...

class	CircleCastGraphBuilder

class	CircleCeil
	CEIL in Circle. More...

class	CircleCeilGraphBuilder

class	CircleConcatenation
	CONCATENATION in Circle. More...

class	CircleConcatenationGraphBuilder

class	CircleConst
	Class to build tensor data. More...

class	CircleConstNodeBuilder
	Builder creates CircleConst node from Tensor with buffer. More...

class	CircleConv2D
	CONV_2D in Circle. More...

class	CircleConv2DGraphBuilder

class	CircleCos
	COS in Circle. More...

class	CircleCosGraphBuilder

class	CircleCumSum

class	CircleCumSumGraphBuilder

class	CircleCustom
	CUSTOM in Circle. More...

class	CircleCustomGraphBuilder

class	CircleCustomOut
	Virtual CIRCLECUSTOMOUT in Circle. More...

class	CircleDensify
	DENSIFY in Circle. More...

class	CircleDensifyGraphBuilder

class	CircleDepthToSpace
	DEPTH_TO_SPACE in Circle. More...

class	CircleDepthToSpaceGraphBuilder

class	CircleDepthwiseConv2D
	DEPTHWISE_CONV_2D in Circle. More...

class	CircleDepthwiseConv2DGraphBuilder

class	CircleDequantize
	DEQUANTIZE in Circle. More...

class	CircleDequantizeGraphBuilder

class	CircleDialect
	A singleton for Circle Dialect. More...

class	CircleDiv
	DIV in Circle. More...

class	CircleDivGraphBuilder

class	CircleElu
	ELU in Circle. More...

class	CircleEluGraphBuilder

class	CircleEqual
	EQUAL in Circle. More...

class	CircleEqualGraphBuilder

class	CircleExp
	EXP in Circle. More...

class	CircleExpandDims
	EXPAND_DIMS in Circle. More...

class	CircleExpandDimsGraphBuilder

class	CircleExpGraphBuilder

class	CircleExporter

class	CircleExporterImpl

class	CircleExportMetadata

class	CircleFakeQuant
	FAKE_QUANT in Circle. More...

class	CircleFakeQuantGraphBuilder

struct	CircleFileExpContract

class	CircleFill
	FILL in Circle. More...

class	CircleFillGraphBuilder

class	CircleFloor
	FLOOR in Circle. More...

class	CircleFloorDiv
	FLOOR_DIV in Circle. More...

class	CircleFloorDivGraphBuilder

class	CircleFloorGraphBuilder

class	CircleFloorMod
	FLOOR_MOD in Circle. More...

class	CircleFloorModGraphBuilder

class	CircleFullyConnected
	FULLY_CONNECTED in Circle. More...

class	CircleFullyConnectedGraphBuilder

class	CircleGather
	GATHER in Circle. More...

class	CircleGatherGraphBuilder

class	CircleGatherNd
	GATHER_ND in Circle. More...

class	CircleGatherNdGraphBuilder

class	CircleGelu
	GELU in Circle. More...

class	CircleGeluGraphBuilder

class	CircleGreater
	Greater in Circle. More...

class	CircleGreaterEqual
	GREATER EQUAL in Circle. More...

class	CircleGreaterEqualGraphBuilder

class	CircleGreaterGraphBuilder

class	CircleGRU
	GRU in Circle. More...

class	CircleGRUGraphBuilder

class	CircleHardSwish
	HardSwish in Circle. More...

class	CircleHardSwishGraphBuilder

class	CircleIf
	IF in Circle. More...

class	CircleIfGraphBuilder

class	CircleIfOut
	Virtual CIRCLEIFOUT in Circle. More...

class	CircleImportMetadata

class	CircleInput
	CircleNode used for Input of the Graph. More...

class	CircleInstanceNorm
	INSTANCE_NORM in Circle. More...

class	CircleInstanceNormGraphBuilder

class	CircleL2Normalize
	L2_NORMALIZATION in Circle. More...

class	CircleL2NormalizeGraphBuilder

class	CircleL2Pool2D
	L2_POOL_2D in Circle. More...

class	CircleL2Pool2DGraphBuilder

class	CircleLeakyRelu
	LEAKY_RELU in Circle. More...

class	CircleLeakyReluGraphBuilder

class	CircleLess
	LESS in Circle. More...

class	CircleLessEqual
	LESS_EQUAL in Circle. More...

class	CircleLessEqualGraphBuilder

class	CircleLessGraphBuilder

class	CircleLocalResponseNormalization
	LOCAL_RESPONSE_NORMALIZATION in Circle. More...

class	CircleLocalResponseNormalizationGraphBuilder

class	CircleLog
	LOG in Circle. More...

class	CircleLogGraphBuilder

class	CircleLogicalAnd
	LOGICAL_AND in Circle. More...

class	CircleLogicalAndGraphBuilder

class	CircleLogicalNot
	LOGICAL_NOT in Circle. More...

class	CircleLogicalNotGraphBuilder

class	CircleLogicalOr
	LOGICAL_OR in Circle. More...

class	CircleLogicalOrGraphBuilder

class	CircleLogistic
	LOGISTIC in Circle. More...

class	CircleLogisticGraphBuilder

class	CircleLogSoftmax
	LOG_SOFTMAX in Circle. More...

class	CircleLogSoftmaxGraphBuilder

class	CircleMatrixDiag
	MATRIX_DIAG in Circle. More...

class	CircleMatrixDiagGraphBuilder

class	CircleMatrixSetDiag
	MATRIX_SET_DIAG in Circle. More...

class	CircleMatrixSetDiagGraphBuilder

class	CircleMaximum
	MAXIMUM in Circle. More...

class	CircleMaximumGraphBuilder

class	CircleMaxPool2D
	MAX_POOL_2D in Circle. More...

class	CircleMaxPool2DGraphBuilder

class	CircleMean
	MEAN in Circle. More...

class	CircleMeanGraphBuilder

class	CircleMinimum
	MINIMUM in Circle. More...

class	CircleMinimumGraphBuilder

class	CircleMirrorPad
	MIRROR_PAD in Circle. More...

class	CircleMirrorPadGraphBuilder

class	CircleMul
	MUL in Circle. More...

class	CircleMulGraphBuilder

struct	CircleMXQuantParam

class	CircleNeg
	NEG in Circle. More...

class	CircleNegGraphBuilder

struct	CircleNode

class	CircleNodeExecutionPlan

struct	CircleNodeImpl

class	CircleNodeMixin

class	CircleNodeMixin< CircleNodeTrait::Bias >
	Mixin class for nodes that has a bias input. More...

class	CircleNodeMixin< CircleNodeTrait::FusedActFunc >

struct	CircleNodeMutableVisitor

struct	CircleNodeMutableVisitorBase

class	CircleNodeOrigin

class	CircleNodeSummaryBuilder

struct	CircleNodeVisitor

struct	CircleNodeVisitorBase

class	CircleNodeWithFEATURESSummaryBuilder

class	CircleNodeWithINPUTSummaryBuilder

class	CircleNodeWithReducerSummaryBuilder

class	CircleNodeWithXSummaryBuilder

class	CircleNodeWithXYSummaryBuilder

class	CircleNonMaxSuppressionV4
	NON_MAX_SUPPRESSION_V4 in Circle. More...

class	CircleNonMaxSuppressionV4GraphBuilder

class	CircleNonMaxSuppressionV4Out
	Virtual NONMAXSUPPRESSIONV4OUT in Circle. More...

class	CircleNonMaxSuppressionV5
	NON_MAX_SUPPRESSION_V5 in Circle. More...

class	CircleNonMaxSuppressionV5GraphBuilder

class	CircleNonMaxSuppressionV5Out
	Virtual NONMAXSUPPRESSIONV5OUT in Circle. More...

class	CircleNotEqual
	NOT EQUAL in Circle. More...

class	CircleNotEqualGraphBuilder

class	CircleOneHot
	ONEHOT in Circle. More...

class	CircleOneHotGraphBuilder

class	CircleOptimizer

class	CircleOutput
	CircleNode for Output of the Graph. More...

class	CircleOutputDummy
	Temporary DummyNode used with dangle CircleNode. More...

class	CircleOutputExclude
	CircleOutputExclude is used to specifying not exported nodes. More...

class	CirclePack
	PACK in Circle. More...

class	CirclePackGraphBuilder

class	CirclePad
	PAD in Circle. More...

class	CirclePadGraphBuilder

class	CirclePadV2
	PADV2 in Circle. More...

class	CirclePadV2GraphBuilder

class	CirclePow
	POW in Circle. More...

class	CirclePowGraphBuilder

class	CirclePRelu
	PRelu in Circle. More...

class	CirclePReluGraphBuilder

class	CircleQuantize
	QUANTIZE in Circle. More...

class	CircleQuantizeGraphBuilder

class	CircleQuantizer

struct	CircleQuantParam

class	CircleRange
	RANGE in Circle. More...

class	CircleRangeGraphBuilder

class	CircleRank
	RANK in Circle. More...

class	CircleRankGraphBuilder

class	CircleReader
	Loads Circle file and provides helpers to access attributes. More...

class	CircleReduceAny
	REDUCE_ANY in Circle. More...

class	CircleReduceAnyGraphBuilder

class	CircleReduceMax
	REDUCE_MAX in Circle. More...

class	CircleReduceMaxGraphBuilder

class	CircleReduceMin
	REDUCE_MIN in Circle. More...

class	CircleReduceMinGraphBuilder

class	CircleReduceProd
	REDUCE_PROD in Circle. More...

class	CircleReduceProdGraphBuilder

class	CircleRelu
	RELU in Circle. More...

class	CircleRelu0To1
	RELU_0_TO_1 in Circle. More...

class	CircleRelu0To1GraphBuilder

class	CircleRelu6
	RELU6 in Circle. More...

class	CircleRelu6GraphBuilder

class	CircleReluGraphBuilder

class	CircleReluN1To1
	RELU_N1_TO_1 in Circle. More...

class	CircleReluN1To1GraphBuilder

class	CircleReshape
	RESHAPE in Circle. More...

class	CircleReshapeGraphBuilder

class	CircleResizeBilinear
	RESIZE_BILINEAR in Circle. More...

class	CircleResizeBilinearGraphBuilder

class	CircleResizeNearestNeighbor
	RESIZE_NEAREST_NEIGHBOR in Circle. More...

class	CircleResizeNearestNeighborGraphBuilder

class	CircleReverseSequence
	REVERSE_SEQUENCE in Circle. More...

class	CircleReverseSequenceGraphBuilder

class	CircleReverseV2
	ReverseV2 in Circle. More...

class	CircleReverseV2GraphBuilder

class	CircleRmsNorm
	RMS_NORM in Circle. More...

class	CircleRmsNormGraphBuilder

class	CircleRoPE
	ROPE in Circle. More...

class	CircleRoPEGraphBuilder

class	CircleRound
	ROUND in Circle. More...

class	CircleRoundGraphBuilder

class	CircleRsqrt
	RSQRT in Circle. More...

class	CircleRsqrtGraphBuilder

class	CircleScatterNd
	SCATTER_ND in Circle. More...

class	CircleScatterNdGraphBuilder

class	CircleSegmentSum
	SEGMENT_SUM in Circle. More...

class	CircleSegmentSumGraphBuilder

class	CircleSelect
	SELECT in Circle. More...

class	CircleSelectGraphBuilder

class	CircleSelectV2
	SELECT_V2 in Circle. More...

class	CircleSelectV2GraphBuilder

class	CircleShape
	SHAPE in Circle. More...

class	CircleShapeGraphBuilder

class	CircleShapeInferencePass
	Pass to infer shape of circle nodes. More...

struct	CircleShapeInferenceRule

class	CircleSin
	SIN in Circle. More...

class	CircleSinGraphBuilder

class	CircleSlice
	SLICE in Circle. More...

class	CircleSliceGraphBuilder

class	CircleSoftmax
	SOFTMAX in Circle. More...

class	CircleSoftmaxGraphBuilder

class	CircleSpaceToBatchND
	SPACE_TO_BATCH_ND in Circle. More...

class	CircleSpaceToBatchNDGraphBuilder

class	CircleSpaceToDepth
	SPACE_TO_DEPTH in Circle. More...

class	CircleSpaceToDepthGraphBuilder

class	CircleSparseToDense
	SPARSE_TO_DENSE in Circle. More...

class	CircleSparseToDenseGraphBuilder

class	CircleSplit
	SPLIT in Circle. More...

class	CircleSplitGraphBuilder

class	CircleSplitOut
	Virtual CIRCLESPLITOUT in Circle. More...

class	CircleSplitV
	SPLIT_V in Circle. More...

class	CircleSplitVGraphBuilder

class	CircleSplitVOut
	Virtual CIRCLESPLITVOUT in Circle. More...

class	CircleSqrt
	SQRT in Circle. More...

class	CircleSqrtGraphBuilder

class	CircleSquare
	SQUARE in Circle. More...

class	CircleSquaredDifference
	SQUARED_DIFFERENCE in Circle. More...

class	CircleSquaredDifferenceGraphBuilder

class	CircleSquareGraphBuilder

class	CircleSqueeze
	SQUEEZE in Circle. More...

class	CircleSqueezeGraphBuilder

class	CircleStridedSlice
	STRIDED_SLICE in Circle. More...

class	CircleStridedSliceGraphBuilder

class	CircleSub
	SUB in Circle. More...

class	CircleSubGraphBuilder

class	CircleSum
	SUM in Circle. More...

class	CircleSumGraphBuilder

class	CircleSVDF
	SVDF in Circle. More...

class	CircleSVDFBuilder

class	CircleTanh
	TANH in Circle. More...

class	CircleTanhGraphBuilder

class	CircleTile
	TILE in Circle. More...

class	CircleTileGraphBuilder

class	CircleTopKV2
	TOPK_V2 in Circle. More...

class	CircleTopKV2GraphBuilder

class	CircleTopKV2Out
	Virtual CIRCLETOPKV2OUT in Circle. More...

class	CircleTranspose
	TRANSPOSE in Circle. More...

class	CircleTransposeConv
	TRANSPOSE_CONV in Circle. More...

class	CircleTransposeConvGraphBuilder

class	CircleTransposeGraphBuilder

class	CircleTypeInferencePass
	Pass to infer type of circle nodes. More...

struct	CircleTypeInferenceRule
	Type Inference Rule for CircleDialect. More...

class	CircleUnidirectionalSequenceLSTM
	UNIDIRECTIONAL_SEQUENCE_LSTM in Circle. More...

class	CircleUnidirectionalSequenceLSTMGraphBuilder

class	CircleUnique
	Unique in Circle. More...

class	CircleUniqueGraphBuilder

class	CircleUniqueOut
	Virtual CIRCLEUNIQUEOUT in Circle. More...

class	CircleUnpack
	UNPACK in Circle. More...

class	CircleUnpackGraphBuilder

class	CircleUnpackOut
	Virtual CIRCLEUNPACKOUT in Circle. More...

class	CircleVariable
	Virtual CircleVariable in Circle for 'variable' Tensor. More...

class	CircleWhere
	WHERE in Circle. More...

class	CircleWhereGraphBuilder

class	CircleWhile
	WHILE in Circle. More...

class	CircleWhileGraphBuilder

class	CircleWhileOut
	Virtual CIRCLEWHILEOUT in Circle. More...

class	CircleZerosLike
	ZEROS_LIKE in Circle. More...

class	CircleZerosLikeGraphBuilder

struct	CloneContext

class	CloneNode

class	CloneNodeLet

class	CloneNodeLet< CN::ABC >

class	CloneNodeLet< CN::DEF >

class	CloneNodeLet< CN::GHIJ >

class	CloneNodeLet< CN::KLMN >

class	CloneNodeLet< CN::OPQR >

class	CloneNodeLet< CN::STUV >

class	CloneNodeLet< CN::WXYZ >

class	CommonSubExpressionEliminationPass
	Pass to perform CSE (Common Sub-expression Elimination) More...

class	CommonSubExpressionEliminationTestGraph

class	ConnectNode

class	ConstantFoldingAddTestGraph

class	ConstantFoldingTestGraph

struct	ConvertNCHWToNHWCPass
	Class to convert NCHW Ops to NHWC. More...

struct	ConvertToFakeQuantizedModelPass
	Class to convert a quantized model to a fake-quantized fp32 model. More...

class	CopyQuantParamPass
	Pass to copy quantparam (scale, zerop) of a tensor to another tensor. More...

struct	DeadNodeQueryServiceImpl

struct	DecomposeHardSwishPass
	Class to decompose HardSwish to Add, Mul and Relu6. More...

struct	DecomposeSoftmaxPass
	Class to decompose Softmax into backend friendly structures. More...

class	Dilation

class	DimMetaData

class	DynamicBatchToSingleBatchPass
	Pass to convert dynamic batch to single batch. More...

struct	ExpandBroadcastConstPass
	Class to remove broadcasts of Const nodes. More...

struct	ExportContext

class	Filter

class	FixedArityNode
	Nodes with the fixed number of inputs. More...

struct	FoldAddV2Pass
	Class to fold AddV2 to a constant tensor. More...

struct	FoldCastPass
	Class to fold Cast to a constant tensor. More...

struct	FoldDensifyPass
	Class to Fold Densify if input is Sparse Constant. More...

struct	FoldDepthwiseConv2DPass
	Class to fold DepthwiseConv2D with constant input and filter into a constant tensor. More...

struct	FoldDequantizePass
	Class to fold Dequantize, which can be folded by constant inputs. More...

struct	FoldFullyConnectedPass
	Class to fold FullyConnected with constant input and filter into a constant tensor. More...

struct	FoldGatherPass
	Class to fold Gather to a constant tensor. More...

struct	FoldMulPass
	Class to fold Mul to a constant tensor. More...

struct	FoldReshapePass
	Class to fold Reshape to a constant tensor. More...

struct	FoldShapePass
	Class to fold Shape to a constant tensor. More...

struct	FoldSparseToDensePass
	Class to fold SparseToDense to a constant tensor. More...

struct	FoldSqueezePass
	Class to fold Squeeze to a constant tensor. More...

class	ForceQuantParamPass
	Pass to write quantparam (scale, zerop) to the specified tensors. More...

struct	ForwardReshapeToUnaryOpPass
	Class to Forward send Reshape after UnaryOp. More...

struct	ForwardTransposeOpPass
	Class to Forward Transpose Ops for further optimization. More...

struct	FuseActivationFunctionPass
	Class to fuse activation functions into preceding operators. More...

struct	FuseAddToFullyConnectedBiasPass
	Class to fuse Add to following FC bias. More...

struct	FuseAddWithConvPass
	Class to fuse CircleAdd into CircleConv2D. More...

struct	FuseAddWithFullyConnectedPass
	Class to fuse Add into FullyConnected. More...

struct	FuseAddWithTConvPass
	Class to fuse Add into CircleTransposeConv. More...

struct	FuseBatchNormWithConvPass
	Class to fuse Batch Normalization into CircleConv. More...

struct	FuseBatchNormWithDwConvPass
	Class to fuse Batch Normalization into CircleDepthWiseConv2D. More...

struct	FuseBatchNormWithTConvPass
	Class to fuse Batch Normalization into CircleTransposeConv. More...

struct	FuseBCQPass
	Class to fuse certain pattern of subgraph into CircleBCQFullyConnected or CircleBCQGather. More...

struct	FuseGeluPass
	Class to fuse certain pattern of subgraph into CircleGelu. More...

struct	FuseHorizontalFullyConnectedPass

struct	FuseInstanceNormPass
	Class to fuse certain pattern of subgraph into CircleInstanceNorm with auxiliary nodes. More...

struct	FuseMeanWithMeanPass
	Class to fuse two Mean operations follow one by one into one Mean with merge reduction indices. More...

struct	FuseMulToFullyConnectedWeightsPass
	Class to fuse Mul into following FullyConnected. More...

struct	FuseMulWithConvPass
	Class to fuse Mul operation with a preceding Conv. More...

struct	FuseMulWithDivPass
	Class to fuse Mul operation with a Div operation. More...

struct	FuseMulWithFullyConnectedPass
	Class to fuse Mul into CircleFullyConnected. More...

struct	FuseMulWithRmsNormPass
	Class to fuse Mul into CircleRmsNorm. More...

struct	FusePreActivationBatchNormPass
	Class to fuse batch normalization of pre-activation. More...

struct	FusePReluPass
	Class to fuse certain pattern of subgraph into CirclePRelu with auxiliary nodes. More...

struct	FuseRmsNormPass
	Class to fuse certain pattern of subgraph into CircleRmsNorm. More...

struct	FuseRoPEPass
	Class to fuse certain pattern of subgraph into CircleRoPE with auxiliary nodes. More...

struct	FuseRsqrtPass
	Class to fuse certain pattern of subgraph into CircleRsqrt. More...

struct	FuseSliceWithTConvPass
	Class to fuse Slice operation with a preceding TConv. More...

struct	FuseTransposeWithMeanPass
	Class to fuse Mean operation with a preceding Transpose. More...

class	GraphBuilder
	Base of general single output graph builder(e.g., Conv2DGraphBuilder) More...

struct	GraphBuilderBase
	Interface of convert circle::OperatorT to CircleNode. More...

class	GraphBuilderContext
	Class to store context to build loco graph IR from TensorFlow. More...

class	GraphBuilderMultiOutput
	Base of general multiple outputs graph builder(e.g., CircleIfGraphBuilder) More...

class	GraphBuilderRegistry
	Class to return graph builder for Circle nodes. More...

struct	GraphBuilderSource

class	Importer

class	ImporterEx

class	IndexNodeFinder

class	IndexTensorOutputs
	Set of Tensor Index of outputs of operators including graph input nodes. More...

struct	InsertQuantizeOpOnDTypeMismatch

struct	LayerInfo

class	Logger
	Logger Implementation. More...

class	LoggerConfig
	Logger Configuration. More...

struct	LoggingContext
	Global logging context. More...

struct	MakeBatchNormGammaPositivePass
	Class to make negative gamma of batchnorm to a small positive value (1e-10) This pass can change the execution result of the model. So, use it only when the impact is known to be acceptable. More...

class	Module
	Collection of 'loco::Graph's. More...

class	ModulePass

class	ModuleProgressReporter

class	NodeBuilderBase
	Creates nodes from given Tensor and context. More...

class	NodeFiller

class	NodeSummaryBuilder

class	NodeSummaryBuilderFactory

struct	OpCode

class	OperationExporterRule

struct	PartedModule
	PartedModule holds partitioned module and group name. More...

struct	PartedModules

struct	PartitionTable
	PartitionTable holds partition information. More...

class	Pass

struct	PGroup
	Partition Group with Partition Nodes of same group and I/Os nodes. More...

struct	PGroups

class	PhaseRunner

class	PhaseRunner< logo::PhaseStrategy::Restart >

class	PhaseRunner< logo::PhaseStrategy::Saturate >

struct	PNode
	Partition Node with CircleNode with group name. More...

class	ProgressReporter

struct	PropagateQParamBackwardPass
	Class to propagate quantization parameters of an operator's output to input. More...

struct	PropagateQParamForwardPass
	Class to propagate quantization parameters of an operator's input to output. More...

struct	QuantizeActivation
	Quantize non-const activation using recorded min/max values. More...

struct	QuantizeBias
	QuantizeBias quantizes tensors for bias. More...

struct	QuantizeConstInputActivation

class	QuantizeDequantizeWeightsPass
	Pass to quantize weights. More...

struct	QuantizedModelVerifier
	Class to verify quantized model. More...

struct	QuantizeOnnxDequantizeLinearPass
	Class to quantize ONNXDequantizeLinear operator. More...

class	QuantizeOnnxFakeQuantModelPass
	Pass to create a quantized graph from a graph fake-quantized on onnx. More...

struct	QuantizeOnnxQDQPass
	Class to quantize ONNX QuantizeLinear-DequantizeLinear operator. More...

class	QuantizePreCheckerPass
	Pass to verify the input model has the form acceptable by quantizer. More...

struct	QuantizeSpecialActivation
	Quantize non-const activaion using pre-defined scale/zp for special Ops. More...

struct	QuantizeWeights
	QuantizeWeights quantizes tensors for weights. More...

struct	QuantizeWeightsOnly
	QuantizeWeightsOnly quantizes tensors for weights. More...

class	QuantizeWeightsPass
	Pass to quantize weights. More...

class	QuantizeWithMinMaxPass
	Pass to quantize activation, weights, and bias. More...

struct	QuantizeWithPredecessorPass
	Class to quantize nodes using their predecessors' qparam. More...

struct	RemoveDuplicateConstPass
	Class to remove duplicate Const nodes. More...

struct	RemoveFakeQuantPass
	Class to Remove FakeQuant node. More...

struct	RemoveGatherGuardPass
	Class to remove Add+FloorMod guard ops of Gather. More...

struct	RemoveQDQForMixedPrecisionOpPass
	Class to remove QDQ pattern for mixed-precision Ops. More...

struct	RemoveQuantDequantSeqPass
	Class to Remove Quantize-Dequantize sequence. More...

struct	RemoveRedundantDequantizePass
	Class to remove redundant dequantize operations. More...

struct	RemoveRedundantQuantizePass
	Class to remove redundant quantize operations. More...

struct	RemoveRedundantReshapePass
	Class to remove redundant Reshape node into 1 Reshape node. More...

struct	RemoveRedundantTransposePass
	fuse or remove subsequent Transpose operators More...

struct	RemoveUnnecessaryAddPass
	Class to temove unnecessary(input and output are same) Add node. More...

struct	RemoveUnnecessaryCastPass
	Class to remove unnecessary Cast nodes. More...

struct	RemoveUnnecessaryDivPass
	Class to temove unnecessary(input and output are same) Mul/Div node. More...

struct	RemoveUnnecessaryMulPass

struct	RemoveUnnecessaryReshapeNetPass
	Class to remove unnecessary Reshape nodes. More...

struct	RemoveUnnecessaryReshapePass
	Class to Remove Unnecessary(input shape and output shape same) Reshape node. More...

struct	RemoveUnnecessarySlicePass
	Class to Remove Unnecessary(input and output are same) Slice node. More...

struct	RemoveUnnecessarySplitPass
	Remove unnecessary Split OP. More...

struct	RemoveUnnecessaryStridedSlicePass
	Class to Remove Unnecessary(input and output are same) StridedSlice node. More...

struct	RemoveUnnecessaryTransposeNetPass

struct	ReplaceMulAddWithDepthwiseConvPass
	Class to replace channel-wise mul/add with CircleDepthwiseConv2D. More...

struct	ReplaceNonConstFCWithBatchMatMulPass
	Class to replace "FC with non-const weight" with Batched MatMul. More...

struct	ReplaceSubWithAddPass
	Class to Replace Sub With Add. More...

struct	ReplaceWithFCGeluFCPass
	Class to generate FC-Gelu-FC from a certain Op pattern. More...

class	RequantizePass
	Pass to re-quantize graph (ex: int8 -> uint8) More...

struct	ResolveCustomOpAddPass
	Class to resolve certain custom op of subgraph into add op in circle schema. More...

struct	ResolveCustomOpBatchMatMulPass
	Class to resolve certain custom op of subgraph into batchmatmul op in circle schema. More...

struct	ResolveCustomOpMatMulPass
	Class to resolve certain custom op of subgraph into matmul op in circle schema. More...

struct	ResolveCustomOpMaxPoolWithArgmaxPass
	Class to resolve custom op MaxPoolWithArgmax to subgraph with circle's MaxPool and ArgMax. More...

struct	ResolveCustomOpSplitVPass
	Class to resolve certain custom op of subgraph into splitv op in circle schema. More...

struct	ResolveFormerCustomOpPass
	Class to convert a custom operator to a built-in operator. More...

struct	SerializedGraphData

struct	SerializedModelData

struct	ShapeDescription

struct	ShuffleWeightTo16x1Float32Pass
	Class to convert weight format of FullyConnected to SHUFFLED16x1FLOAT32. More...

class	SparseIndexVector

class	Sparsifier

struct	SparsifyTensorPass
	Pass to sparsify tensor. More...

struct	SparsityParam

class	Stride

struct	SubGraphContext
	Record the information of T/F Lite SubGraph and its mapping to loco. More...

struct	SubstituteExpandDimsToReshapePass
	Class to substitute ExpandDims to single reshape node. More...

struct	SubstitutePackToReshapePass
	Class to Substitute Pack with 1 input to single reshape node. More...

struct	SubstitutePadV2ToPadPass
	Class to substitute PadV2 in certain condition to Pad. More...

struct	SubstituteSplitVToSplitPass
	Class to substitute certain SplitV to Split. More...

struct	SubstituteSqueezeToReshapePass
	Class to Substitute Squeeze to Reshape node for certain conditions. More...

struct	SubstituteStridedSliceToReshapePass
	Class to substitute Strided_Slice with certain condition to single reshape node. More...

struct	SubstituteTransposeToReshapePass
	Class to Substitute Transpose with certain input shape condition to single reshape node. More...

struct	TransformMinMaxToRelu6Pass
	Class to transform Maximum(Minimum(input, 6), 0) to Relu6. More...

struct	TransformMinReluToRelu6Pass
	Class to transform Relu(Minimum(input, 6)) to Relu6. More...

struct	TransformSqrtDivToRsqrtMulPass
	Class to transform Div(X,Sqrt(y)) to Mul(X,Rsqrt(y)) More...

class	TypedNodeBuilder
	Placeholder for builders of tensors with different types. More...

struct	TypeMapper
	TypeMapper maps between c++ primitive data type and loco::DataType. More...

struct	TypeMapper< float >

struct	TypeMapper< int16_t >

struct	TypeMapper< int32_t >

struct	TypeMapper< int64_t >

struct	TypeMapper< int8_t >

struct	TypeMapper< uint16_t >

struct	TypeMapper< uint32_t >

struct	TypeMapper< uint64_t >

struct	TypeMapper< uint8_t >

struct	UnrollUnidirectionalSequenceLSTMPass
	Class to Unroll UnidirectionalSequenceLSTM. More...

struct	UserSettings
	UserSettings provides user settings by key-value. More...

class	UserSettingsImpl

class	VariadicArityNode
	Nodes with the variadic inputs. More...

class	VectorWrapper
	Wrapper to use flatbuffers::Vector pointer as std::vector entity. More...

class	VerifyQuantizedBiasScale
	Verify the scale of quantized bias node. More...

class	VerifyQuantizedNodeChannelWiseGranularity

class	VerifyQuantizedNodeGranularity
	Verify the granualrity of quantized node. More...

class	VerifyQuantizedNodeLayerWiseGranularity

class	VerifyQuantizedNodeS16Type

class	VerifyQuantizedNodeType
	Verify the data type of quantized node. More...

class	VerifyQuantizedNodeTypeBase
	Verify using quantization type of a node and bias. More...

class	VerifyQuantizedNodeU8Type

struct	VirtualOutputDetector

struct	XpSepActFromTransposeConvPass
	Experimental Class to separate activation functions from TransposeConv. More...

Typedefs
using	CircleTensorIndex = int32_t

using	TensorIndex = int32_t

using	OriginTable = std::map< uint32_t, std::shared_ptr< CircleNodeOrigin > >

using	NodeName = std::string

using	ExecutionPlanTable = std::map< uint32_t, std::vector< uint32_t > >

using	LuciNodeTrait = CircleNodeTrait

template<LuciNodeTrait T>
using	LuciNodeMixin = CircleNodeMixin< T >

using	FormattedGraph = locop::FormattedGraphImpl< locop::Formatter::LinearV1 >

using	MapNode2Clone = std::map< const CircleNode , CircleNode >

using	GroupKey = std::string

using	LayerInfoMap = std::unordered_map< std::string, luci::LayerInfo >

using	Phase = std::vector< std::unique_ptr< Pass > >

using	IterFunc = std::function< void(uint32_t *, loco::TensorShape &, int32_t)>

using	CircleNodeID = uint32_t

Enumerations
enum class	NodeBuilderType { BUFFER }
	Tensor types which requires separated node. More...

enum class	FusedActFunc { UNDEFINED , NONE , RELU , RELU_N1_TO_1 , RELU6 , TANH , SIGN_BIT }

enum class	MirrorPadMode { UNDEFINED , REFLECT , SYMMETRIC }

enum class	Padding { UNDEFINED , SAME , VALID }

enum class	RoPEMode { UNDEFINED , GPT_NEOX , GPT_J }

enum class	CircleNodeTrait { FusedActFunc , Bias }
	enumeration of mixin class More...

enum class	CircleOpcode { CIRCLE_NODE , CIRCLE_VNODE }

enum class	ShapeStatus { UNDEFINED , NOSHAPE , VALID }
	ShapeStatus is to remember circle node shape status. More...

enum	DimensionType { DENSE , SPARSE_CSR }

enum	SparseIndexVectorType { NONE , I32 , U16 , U8 }

enum	QuantizationGranularity { LayerWise = 0 , ChannelWise = 1 }

enum	ActivationQType { MinMax , PreDefinedLogistic , PreDefinedTanh , PreDefinedSoftmax , IntScale }

enum class	CN { ABC , DEF , GHIJ , KLMN , OPQR , STUV , WXYZ }

Functions
circle::ActivationFunctionType	to_circle_actfunc (luci::FusedActFunc func)

circle::TensorType	to_circle_tensortype (loco::DataType type)

circle::MirrorPadMode	to_circle_mirrorpadmode (luci::MirrorPadMode mode)

circle::RoPEMode	to_circle_rope (luci::RoPEMode mode)

circle::FullyConnectedOptionsWeightsFormat	to_circle_weightsformat (luci::CircleFullyConnected::WeightsFormat format)

circle::DimensionType	to_circle_dimensiontype (luci::DimensionType type)

flatbuffers::Offset< void >	to_circle_sparse_index_vector (flatbuffers::FlatBufferBuilder &fb, const SparseIndexVector &sparse_idx_vec)

circle::SparseIndexVector	to_circle_sparse_index_vector_type (luci::SparseIndexVectorType type)

circle::BuiltinOperator	circle_builtin_operator (const luci::CircleNode *node)

circle::BuiltinOptions	circle_builtin_options (const luci::CircleNode *node)

std::string	circle_custom_code (const luci::CircleNode *node)

flatbuffers::Offset< flatbuffers::Vector< uint8_t > >	circle_custom_options (flatbuffers::FlatBufferBuilder &fb, const luci::CircleNode *node)

circle::Padding	getOpPadding (const loco::Padding2D pad, const loco::Stride< 2 > stride, const ShapeDescription &ifm, const ShapeDescription &ofm)

circle::Padding	getOpPadding (const luci::Padding pad)

void	set_tensor_index (loco::Node *node, const CircleTensorIndex &tensor_id)

void	clear_tensor_index (loco::Node *node)

CircleTensorIndex	get_tensor_index (loco::Node *node)

bool	check_size_limit (const flatbuffers::FlatBufferBuilder &fb, const uint64_t data_size)

std::vector< flatbuffers::Offset< circle::Metadata > >	createCircleMetadataVector (flatbuffers::FlatBufferBuilder &builder, SerializedModelData &md)
	Create Metadata corresponding to model metadata.

void	exportNodes (loco::Graph *g, flatbuffers::FlatBufferBuilder &builder, SerializedModelData &md, SerializedGraphData &gd)
	create Operators corresponding to model nodes

void	prepareModelData (flatbuffers::FlatBufferBuilder &builder, SerializedModelData &md)
	one time preparation for SerializedModelData

void	exportOpDefinedTensors (loco::Graph *g, flatbuffers::FlatBufferBuilder &builder, SerializedModelData &md, SerializedGraphData &gd)
	create Tensors corresponding to results of all nodes in graph

void	clearExportInfo (loco::Graph *g)
	clear temporary export information annotated to graph nodes

const char *	tensor_name (const circle::Tensor *tensor)

const circle::QuantizationParameters *	tensor_quantization (const circle::Tensor *tensor)

loco::DataType	luci_datatype (circle::TensorType type)

FusedActFunc	luci_actfunc (const circle::ActivationFunctionType type)

Padding	luci_padding (const circle::Padding padding)

MirrorPadMode	luci_mirrorpad_mode (const circle::MirrorPadMode mode)

RoPEMode	luci_rope_mode (const circle::RoPEMode mode)

luci::CircleFullyConnected::WeightsFormat	luci_weights_format (const circle::FullyConnectedOptionsWeightsFormat weights_format)

std::unique_ptr< CircleQuantParam >	luci_quantparam (const circle::QuantizationParameters *quantization)

std::unique_ptr< CircleMXQuantParam >	luci_mx_quantparam (const circle::MXQuantization *quantization)

void	copy_tensor_attributes (const circle::Tensor tensor, CircleNode node)
	Copy common tensor attributes such as name, type, etc. to node.

std::string	fb_string2std_string (const flatbuffers::String *fb_str)

template<typename T >
VectorWrapper< T >	wrap (const flatbuffers::Vector< T > *vec)

CircleVariable *	create_circlevariable (GraphBuilderContext *context, int32_t tensor_index)

DimensionType	luci_dim_type (const circle::DimensionType dim_type)

SparseIndexVector	luci_sparse_index_vector (const circle::SparseIndexVectorUnion &sparse_index_vector)

std::unique_ptr< CircleQuantParam >	luci_quantparam (const circle::QuantizationParametersT *quantization)

std::unique_ptr< CircleMXQuantParam >	luci_mx_quantparam (const circle::MXQuantizationT *quantization)

std::unique_ptr< SparsityParam >	luci_sparsityparam (const circle::SparsityParametersT *sparsity)

std::unique_ptr< SparsityParam >	luci_sparsityparam (const circle::SparsityParameters *sparparam)

	REGISTER_WRAPPER (flatbuffers::Offset< circle::SubGraph >)

	REGISTER_WRAPPER (flatbuffers::Offset< circle::Buffer >)

	REGISTER_WRAPPER (flatbuffers::Offset< circle::Tensor >)

	REGISTER_WRAPPER (flatbuffers::Offset< circle::Operator >)

	REGISTER_WRAPPER (flatbuffers::Offset< circle::OperatorCode >)

	REGISTER_WRAPPER (flatbuffers::Offset< circle::Metadata >)

	REGISTER_WRAPPER (int32_t)

	REGISTER_WRAPPER (uint8_t)

bool	validate_batch_space_nd (const GraphBuilderBase::ValidateArgs &args)

bool	validate_minmax (const GraphBuilderBase::ValidateArgs &args)

bool	validate_reduce_minmax (const GraphBuilderBase::ValidateArgs &args)

template<typename T , typename ARG >
__attribute__((noinline)) std T	_must_cast (ARG arg)

template<typename T >
T	must_cast (loco::Node *node)

template<typename T >
T	must_cast (const loco::Node *node)

void	link (loco::GraphOutput , CircleOutput )
	Link GraphOutput with CircleOutput node.

void	link (loco::GraphInput , CircleInput )
	Link GraphInput with CircleInput node.

CircleOutput *	output_node (loco::Graph *g, const loco::GraphOutputIndex &index)
	Find a CircleOutput node with a given output index.

CircleInput *	input_node (loco::Graph *g, const loco::GraphInputIndex &index)
	Find a Pull node with a given input index.

void	copy_quantparam (const luci::CircleNode src, luci::CircleNode dst)
	copy CircleQuantParam of src to dst

uint32_t	size (loco::DataType data_type)
	Returns the size of the data type.

std::unique_ptr< Module >	make_module (void)

	__attribute__ ((noinline)) std

	INSTANTIATE (loco::DataType::S64)

	INSTANTIATE (loco::DataType::S32)

	INSTANTIATE (loco::DataType::S16)

	INSTANTIATE (loco::DataType::S8)

	INSTANTIATE (loco::DataType::S4)

	INSTANTIATE (loco::DataType::FLOAT32)

	INSTANTIATE (loco::DataType::U8)

	INSTANTIATE (loco::DataType::U4)

	INSTANTIATE (loco::DataType::BOOL)

	INSTANTIATE (loco::DataType::FLOAT16)

template<>
uint32_t	CircleConst::size< loco::DataType::STRING > (void) const

template<>
void	CircleConst::size< loco::DataType::STRING > (uint32_t l)

template<>
const std::string &	CircleConst::at< loco::DataType::STRING > (uint32_t n) const

template<>
std::string &	CircleConst::at< loco::DataType::STRING > (uint32_t n)

template<>
const std::string &	CircleConst::scalar< loco::DataType::STRING > (void) const

template<>
std::string &	CircleConst::scalar< loco::DataType::STRING > (void)

FormattedGraph	fmt (loco::Graph *g)

void	clone_connect (const luci::CircleNode *node, luci::CloneContext &clonecontext)
	Connect cloned node from input node.

PartedModules	apply (Module *module, const PartitionTable &partition)
	Method to do paritioning from module and PartitionTable to produce PartedModules.

bool	validate (luci::PartitionTable &partition)

std::string	opcode_name (const CircleNode *node)

void	remove_unused_inputoutputs (luci::PGroups , const luci::Module )
	This will remove unused inputs/outputs in each pgroup of pgroups.

void	dump (std::ostream &os, const PNode *pnode)

void	dump (std::ostream &os, const PGroup *pgroup)

void	dump (std::ostream &os, const PGroups *pgroups)

std::unique_ptr< luci::PGroups >	merge_pgroups (const luci::PGroups *s_pgroups)
	This will merge pgroups with same group values in topological order.

std::unique_ptr< luci::PGroups >	produce_pgroups (const luci::Module *source, const luci::PartitionTable &partition)
	This will produce a PGroups from Module and PartitionTable.

luci::PartedModules	produce_pmodules (const luci::PGroups *pgroups)
	This will produce list of luci::Module as PartedModules from pgroups.

void	dump (std::ostream &os, const PartedModule *pmodule)

void	dump (std::ostream &os, const PartedModules *pmodules)

void	dynamic_batch_to_single_batch (luci::Module *)

template void	SparsifyTensorPass::sparsify_tensor< loco::DataType::S32 > (luci::CircleConst *cop)

template void	SparsifyTensorPass::sparsify_tensor< loco::DataType::S8 > (luci::CircleConst *cop)

template void	SparsifyTensorPass::sparsify_tensor< loco::DataType::FLOAT32 > (luci::CircleConst *cop)

bool	is_batchnorm_add (const luci::CircleAdd add, luci::CircleMul &mul, luci::CircleConst *&beta)
	Find Mul-Add pattern and return Mul and beta as BatchNorm.

bool	is_batchnorm_add (const luci::CircleAdd *add)
	Find Mul-Add pattern.

bool	is_batchnorm_mul (const luci::CircleMul mul, luci::CircleNode &pred_node, luci::CircleConst *&gamma)
	Find Const-Mul pattern and return Node and gamma as BatchNorm.

bool	fuse_activation_function (luci::CircleNode *node)

bool	fuse_sub_with_conv (luci::CircleSub *sub)

bool	fuse_add_with_conv (luci::CircleAdd add, std::vector< luci::CircleSub > &sub_list)

bool	fuse_mul_with_conv (luci::CircleMul *mul)

bool	swap_mul_add (luci::CircleAdd add, std::vector< luci::CircleMul > &mul_list, std::vector< luci::CircleAdd * > &add_list)

bool	to_compute (const Padding padding, compute::PaddingType &padding_type)

bool	to_compute (const FusedActFunc act, compute::FusedActFunc &act_func)

template<typename T >
CircleConst *	create_const_node (loco::Graph *g, const loco::DataType dtype, const std::vector< uint32_t > &shape, const T value)

template<typename T >
luci::CircleConst *	create_const_node (loco::Graph *g, const loco::DataType dtype, const std::vector< uint32_t > &shape, const std::vector< T > &values)

std::vector< loco::Node * >	inference_candidates (loco::Graph *g)
	Enumerate all the nodes whose shape/dtype should be inferenced to export graph.

LayerInfoMap	layer_info_map (loco::Graph *g, std::vector< LayerInfo > &layers_info)

template<class ARG_TYPE_1 , class ARG_TYPE_2 >
NodeFiller< ARG_TYPE_1, ARG_TYPE_2 >	fill (ARG_TYPE_1 arg_1, ARG_TYPE_2 arg_2)

bool	is_same_shape (const luci::CircleNode *node, const loco::TensorShape &shape)

bool	is_same_shape (const luci::CircleNode *node, const std::initializer_list< uint32_t > shape)

bool	has_dynamic_shape (const loco::Node *node)

sparsity::TfLiteDimensionType	to_tflite_sparsity (luci::DimensionType dt)

sparsity::TfLiteIntArray *	to_tflite_sparsity (const luci::SparseIndexVector &data)

sparsity::TfLiteSparsity	to_tflite_sparsity (const luci::SparsityParam *sp)

template<typename T >
sparsity::TfLiteIntArray *	makeTfLiteArray (const std::vector< T > &data)

sparsity::TfLiteDimensionMetadata *	makeTfLiteDimensionMetadata (const std::vector< luci::DimMetaData > &data)

void	freeTfLiteSparsity (sparsity::TfLiteSparsity &tflsp)

bool	in_array (const std::string &str, const std::vector< std::string > &array)

std::string	to_string (const std::vector< std::string > &strings)

std::string	to_lower_case (std::string s)

loco::DataType	str_to_dtype (const std::string &str)

std::vector< loco::DataType >	str_vec_to_dtype_vec (std::vector< std::string > &vec)

QuantizationGranularity	str_to_granularity (const std::string &str)

void	propagate_concat_quantparam (luci::CircleConcatenation *concat)

void	propagate_pad_v2_quantparam (luci::CirclePadV2 *pad_v2)

bool	is_quantized (const CircleNode *node)

bool	is_fp32 (const CircleNode *node)

uint8_t	fp32_to_uint8_cast (float f)

void	asymmetric_wquant_with_minmax_per_layer (CircleConst *node, float min, float max, float &scaling_factor, int64_t &zp, float &nudged_min, float &nudged_max)

void	symmetric_wquant_with_minmax_per_layer (CircleConst *node, float min, float max, float &scaling_factor, float &nudged_min, float &nudged_max)

int32_t	max_for_sym_quant (const loco::DataType &type)

void	compute_sym_scale (float min, float max, float &scaling_factor, float &nudged_min, float &nudged_max, loco::DataType out_type)

void	compute_asym_scale_zp (float min, float max, float &scaling_factor, int64_t &zp, float &nudged_min, float &nudged_max)

bool	get_channel_dim_index (CircleConst *node, loco::TensorShape &dimension, int32_t &channel_dim_index)

uint32_t	cal_offset (loco::TensorShape &dimension, uint32_t *indices)

ActivationQType	activation_qtype (const CircleNode *node)

std::unique_ptr< CircleQuantParam >	make_predefined_qparam (ActivationQType qtype, loco::DataType dtype, CircleQuantParam *old_quant_param)

void	set_int_scale (luci::CircleNode *node)

void	quant_const (luci::CircleConst *node, loco::DataType quant_type)

void	warn_accuracy_with_range (luci::CircleNode *n)

bool	is_onnx_dequantize_linear (const luci::CircleCustom *node)

bool	is_onnx_quantize_linear (const luci::CircleCustom *node)

void	iterate_per_channel (CircleConst *node, int32_t &channel_dim_index, IterFunc func)

void	iterate_per_channel (CircleConst *node, IterFunc func)

void	cal_minmax_per_channel (CircleConst *node, std::vector< float > &min, std::vector< float > &max, int32_t &channel_dim_index)

void	check_quant_unfriendly_values (const luci::CircleConst *node)

std::unique_ptr< CircleQuantParam >	make_predefined_qparam (CircleNode *node, loco::DataType dtype)

bool	has_execution_plan (const luci::CircleNode *circle_node)

void	add_execution_plan (luci::CircleNode *circle_node, const luci::CircleNodeExecutionPlan &execution_plan)

luci::CircleNodeExecutionPlan	get_execution_plan (const luci::CircleNode *circle_node)

bool	has_node_id (const luci::CircleNode *circle_node)

void	set_node_id (luci::CircleNode *circle_node, CircleNodeID id)

CircleNodeID	get_node_id (const luci::CircleNode *circle_node)

std::shared_ptr< CircleNodeOrigin >	single_origin (uint32_t id, const std::string &name)

std::shared_ptr< CircleNodeOrigin >	composite_origin (const std::initializer_list< std::shared_ptr< CircleNodeOrigin > > origins)

std::shared_ptr< CircleNodeOrigin >	composite_origin (const std::vector< std::shared_ptr< CircleNodeOrigin > > &origins)

void	change_outputs (loco::Graph *, const std::vector< std::string > &)
	Change output to nodes with string name.

void	copy_common_attributes (const luci::CircleNode src, luci::CircleNode dst)
	Copy common attributes of CircleNode from src to dst.

CircleNode *	clone_node (const CircleNode node, loco::Graph graph)
	Return a new cloned CircleNode object with same attributes value of node to graph.

luci::CircleConst *	clone (luci::CircleConst *node)
	Return cloned object of CircleConst node.

ShapeDescription	to_shape_description (const luci::CircleNode *node)

ShapeDescription	to_shape_description (const loco::TensorShape &shape)

ShapeDescription	to_shape_description (const loco::NodeShape &shape)

template<typename Permutation >
bool	isNHWC (Permutation *perm)

template<>
bool	isNHWC (loco::Permutation< loco::Domain::Feature > *perm)

template<>
bool	isNHWC (loco::Permutation< loco::Domain::Filter > *perm)

bool	validate (loco::Graph *)

bool	validate_name (loco::Graph *)
	Return true if all nodes in graph have non empty name.

bool	validate_unique_name (luci::Module *)
	Return true if all names in the Module are unique.

bool	validate (luci::Module *)

bool	validate_shape (loco::Graph *)

bool	validate_shape (luci::Module *)

loco::NodeShape	shape_get (const loco::Node *node)

bool	shape_known (const loco::Node *node)

loco::DataType	dtype_get (const loco::Node *node)

bool	dtype_known (const loco::Node *node)

Detailed Description

@Note Methods in this file provides helper functions to reduce duplicate codes

Typedef Documentation

◆ CircleNodeID

using luci::CircleNodeID = typedef uint32_t

Definition at line 25 of file CircleNodeID.h.

◆ CircleTensorIndex

using luci::CircleTensorIndex = typedef int32_t

Definition at line 61 of file CircleExporterUtils.h.

◆ ExecutionPlanTable

using luci::ExecutionPlanTable = typedef std::map<uint32_t, std::vector<uint32_t> >

Definition at line 23 of file ExecutionPlanTable.h.

◆ FormattedGraph

using luci::FormattedGraph = typedef locop::FormattedGraphImpl<locop::Formatter::LinearV1>

Definition at line 28 of file LogHelper.h.

◆ GroupKey

using luci::GroupKey = typedef std::string

Definition at line 32 of file PartitionIR.h.

◆ IterFunc

using luci::IterFunc = typedef std::function<void(uint32_t *, loco::TensorShape &, int32_t)>

Definition at line 111 of file QuantizationUtils.h.

◆ LayerInfoMap

using luci::LayerInfoMap = typedef std::unordered_map<std::string, luci::LayerInfo>

Definition at line 27 of file LayerInfoMap.h.

◆ LuciNodeMixin

template<LuciNodeTrait T>

using luci::LuciNodeMixin = typedef CircleNodeMixin<T>

Definition at line 29 of file LuciNodeMixins.h.

◆ LuciNodeTrait

using luci::LuciNodeTrait = typedef CircleNodeTrait

Definition at line 27 of file LuciNodeMixins.h.

◆ MapNode2Clone

using luci::MapNode2Clone = typedef std::map<const CircleNode * , CircleNode * >

Note: MapNode2Clone is used as a map from original node to cloned node to find input of a cloned node

(Original) (Clone)

[A] [A'] | [B] | [B'] | | | | \ / \ / [C] [C']

From view of [C'] we need to find [A'] and [B']. We know [C] from [C'], then we can get from input of [C] as [A], [B] then [A]->[A'] and [B]->[B'] from the map.

Definition at line 42 of file ConnectNode.h.

◆ NodeName

using luci::NodeName = typedef std::string

Definition at line 37 of file CircleNodeDecl.h.

◆ OriginTable

using luci::OriginTable = typedef std::map<uint32_t, std::shared_ptr<CircleNodeOrigin> >

Definition at line 32 of file CircleImportMetadata.h.

◆ Phase

using luci::Phase = typedef std::vector<std::unique_ptr<Pass> >

Definition at line 29 of file ModulePhase.h.

◆ TensorIndex

using luci::TensorIndex = typedef int32_t

Definition at line 32 of file GraphBuilderContext.h.

Enumeration Type Documentation

◆ ActivationQType

enum luci::ActivationQType

Enumerator
MinMax
PreDefinedLogistic
PreDefinedTanh
PreDefinedSoftmax
IntScale

Definition at line 74 of file QuantizationUtils.h.

{
  MinMax,             // Quantize using recorded min/max
  PreDefinedLogistic, // Quantize using pre-defined values
  PreDefinedTanh,     // Quantize using pre-defined values
  PreDefinedSoftmax,  // Quantize using pre-defined values
  IntScale,           // Round scale to a positive integer
};

◆ CircleNodeTrait

enum class luci::CircleNodeTrait

strong

enumeration of mixin class

Enumerator
FusedActFunc
Bias

Definition at line 31 of file CircleNodeMixins.h.

{
  FusedActFunc,
  Bias
};

◆ CircleOpcode

enum class luci::CircleOpcode

strong

Enumerator
CIRCLE_NODE
CIRCLE_VNODE

Definition at line 23 of file CircleOpcode.h.

{
#define CIRCLE_NODE(OPCODE, CLASS) OPCODE,
#define CIRCLE_VNODE CIRCLE_NODE
#include "CircleNodes.lst"
#undef CIRCLE_VNODE
#undef CIRCLE_NODE
};

◆ CN

enum class luci::CN

strong

Enumerator
ABC
DEF
GHIJ
KLMN
OPQR
STUV
WXYZ

Definition at line 28 of file CircleCloneNode.h.

{
  ABC,
  DEF,
  GHIJ,
  KLMN,
  OPQR,
  STUV,
  WXYZ,
};

◆ DimensionType

enum luci::DimensionType

Enumerator
DENSE
SPARSE_CSR

Definition at line 28 of file SparsityParam.h.

{
  DENSE,
  SPARSE_CSR,
};

◆ FusedActFunc

enum class luci::FusedActFunc

strong

Enumerator
UNDEFINED
NONE
RELU
RELU_N1_TO_1
RELU6
TANH
SIGN_BIT

Definition at line 24 of file AttrFusedActFunc.h.

{
  UNDEFINED, // This is not defined by TFLite or Circle. This was added to
             // prevent programming error.
  NONE,
  RELU,
  RELU_N1_TO_1,
  RELU6,
  TANH,
  SIGN_BIT
};

◆ MirrorPadMode

enum class luci::MirrorPadMode

strong

Enumerator
UNDEFINED
REFLECT
SYMMETRIC

Definition at line 23 of file AttrMirrorPadMode.h.

{
  UNDEFINED, // This is not defined by Circle. This was added to prevent programming error.
 
  REFLECT,
  SYMMETRIC,
};

◆ NodeBuilderType

enum class luci::NodeBuilderType

strong

Tensor types which requires separated node.

Enumerator
BUFFER

Definition at line 31 of file NodeBuilder.h.

{
  BUFFER,
  // TODO Extend this struct here if needed to add new type of NodeBuilderBase
};

◆ Padding

enum class luci::Padding

strong

Enumerator
UNDEFINED
SAME
VALID

Definition at line 23 of file AttrPadding.h.

{
  UNDEFINED, // This is not defined by TFLite. This was added to prevent programming error.
 
  SAME,
  VALID,
};

◆ QuantizationGranularity

enum luci::QuantizationGranularity

Enumerator
LayerWise
ChannelWise

Definition at line 27 of file QuantizationParameters.h.

{
  LayerWise = 0,
  ChannelWise = 1,
};

◆ RoPEMode

enum class luci::RoPEMode

strong

Enumerator
UNDEFINED
GPT_NEOX
GPT_J

Definition at line 23 of file AttrRoPEMode.h.

{
  UNDEFINED, // This is not defined by Circle. This was added to prevent programming error.
 
  GPT_NEOX,
  GPT_J,
};

◆ ShapeStatus

enum class luci::ShapeStatus

strong

ShapeStatus is to remember circle node shape status.

Note: This is not an attribute from the file but inner status of a node. Shape with [] is scalar but sometimes it acts as dynamic shape.

Enumerator
UNDEFINED
NOSHAPE
VALID

Definition at line 28 of file PropertyShapeStatus.h.

{
  UNDEFINED, // Shape status is undefined
 
  NOSHAPE, // shape is unknown; to distinguish from scalar
  VALID,   // shape is valid
};

◆ SparseIndexVectorType

enum luci::SparseIndexVectorType

Enumerator
NONE
I32
U16
U8

Definition at line 34 of file SparsityParam.h.

{
  NONE,
  I32,
  U16,
  U8,
};

Function Documentation

◆ attribute()

luci::__attribute__ ( (noinline) )

Definition at line 39 of file CastHelpers.cpp.

{
  std::string msg = "\nCall stack:\n";
  const int max_frames = 5;
  void *addrlist[max_frames];
 
  int addrlen = backtrace(addrlist, max_frames);
  if (addrlen > 0)
  {
    char **symbollist = backtrace_symbols(addrlist, addrlen);
    if (symbollist)
    {
      for (int i = 1; i < addrlen; ++i)
      {
        msg += "  ";
        msg += std::to_string(i);
        msg += ": ";
 
        std::string symbol_line(symbollist[i]);
        size_t mangled_start = symbol_line.find('(');
        size_t mangled_end = symbol_line.find('+');
        if (mangled_start != std::string::npos && mangled_end != std::string::npos)
        {
          std::string mangled_name =
            symbol_line.substr(mangled_start + 1, mangled_end - mangled_start - 1);
          std::string demangled_name = _demangle(mangled_name.c_str());
          // TODO uncomment this if binary module is better to show
          // msg += symbol_line.substr(0, mangled_start);
          msg += "(";
          msg += demangled_name;
          msg += symbol_line.substr(mangled_end);
        }
        else
        {
          msg += symbol_line;
        }
        msg += "\n";
      }
      free(symbollist);
    }
    else
      msg += "  Call stack not available.\n";
  }
  else
    msg += "  Call stack not available.\n";
 
  return msg;
}

References must_cast().

◆ _must_cast()

template<typename T , typename ARG >

__attribute__((noinline)) std T luci::_must_cast ( ARG arg )

inline

Definition at line 29 of file CastHelpers.h.

{
  auto cast_arg = dynamic_cast<T>(arg);
  if (cast_arg == nullptr)
  {
    std::string msg = "luci::must_cast() failed to cast: ";
    msg += typeid(T).name();
    msg += _callstacks();
    throw std::invalid_argument(msg.c_str());
  }
  return cast_arg;
}

References must_cast().

◆ activation_qtype()

ActivationQType luci::activation_qtype ( const CircleNode * node )

Definition at line 300 of file QuantizationUtils.cpp.

{
  auto fused_act_node = dynamic_cast<const CircleNodeMixin<CircleNodeTrait::FusedActFunc> *>(node);
  if (fused_act_node && fused_act_node->fusedActivationFunction() == FusedActFunc::TANH)
    return ActivationQType::PreDefinedTanh;
 
#define RETURN_INPUT_ACTIVATION_QTYPE(CLASS, INPUT)         \
  {                                                         \
    auto n = loco::must_cast<const CLASS *>(node);          \
    auto input = loco::must_cast<CircleNode *>(n->INPUT()); \
    return activation_qtype(input);                         \
  }
 
  switch (node->opcode())
  {
    case CircleOpcode::LOGISTIC:
      return ActivationQType::PreDefinedLogistic;
    case CircleOpcode::TANH:
      return ActivationQType::PreDefinedTanh;
    case CircleOpcode::SOFTMAX:
      return ActivationQType::PreDefinedSoftmax;
    case CircleOpcode::FLOOR:
    case CircleOpcode::FLOOR_DIV:
    case CircleOpcode::FLOOR_MOD:
    case CircleOpcode::CEIL:
      return ActivationQType::IntScale;
    case CircleOpcode::GATHER:
      RETURN_INPUT_ACTIVATION_QTYPE(CircleGather, params);
    case CircleOpcode::RESHAPE:
      RETURN_INPUT_ACTIVATION_QTYPE(CircleReshape, tensor);
    case CircleOpcode::TRANSPOSE:
      RETURN_INPUT_ACTIVATION_QTYPE(CircleTranspose, a);
    case CircleOpcode::STRIDED_SLICE:
      RETURN_INPUT_ACTIVATION_QTYPE(CircleStridedSlice, input);
    case CircleOpcode::SPLIT:
      RETURN_INPUT_ACTIVATION_QTYPE(CircleSplit, input);
    case CircleOpcode::CIRCLESPLITOUT:
      RETURN_INPUT_ACTIVATION_QTYPE(CircleSplitOut, input);
    case CircleOpcode::SPLIT_V:
      RETURN_INPUT_ACTIVATION_QTYPE(CircleSplitV, input);
    case CircleOpcode::CIRCLESPLITVOUT:
      RETURN_INPUT_ACTIVATION_QTYPE(CircleSplitVOut, input);
    case CircleOpcode::UNPACK:
      RETURN_INPUT_ACTIVATION_QTYPE(CircleUnpack, value);
    case CircleOpcode::CIRCLEUNPACKOUT:
      RETURN_INPUT_ACTIVATION_QTYPE(CircleUnpackOut, input);
    case CircleOpcode::QUANTIZE:
      RETURN_INPUT_ACTIVATION_QTYPE(CircleQuantize, input);
    default:
      break;
  }
 
#undef RETURN_INPUT_ACTIVATION_QTYPE
 
  return ActivationQType::MinMax;
}

References IntScale, MinMax, must_cast(), luci::CircleNode::opcode(), PreDefinedLogistic, PreDefinedSoftmax, PreDefinedTanh, RETURN_INPUT_ACTIVATION_QTYPE, and TANH.

Referenced by luci::QuantizeSpecialActivation::visit(), luci::QuantizeSpecialActivation::visit(), luci::QuantizeSpecialActivation::visit(), and luci::QuantizeSpecialActivation::visit().

◆ add_execution_plan()

void luci::add_execution_plan	(	luci::CircleNode *	circle_node,
		const luci::CircleNodeExecutionPlan &	execution_plan
	)

Definition at line 62 of file CircleNodeExecutionPlan.cpp.

{
  circle_node->annot<CircleExecutionPlanAnnotation>(nullptr);
  circle_node->annot(std::make_unique<CircleExecutionPlanAnnotation>(execution_plan));
}

References must_cast().

◆ apply()

PartedModules luci::apply	(	Module *	module,
		const PartitionTable &	partition
	)

Method to do paritioning from module and PartitionTable to produce PartedModules.

This will return Partitioned Modules object.

Definition at line 36 of file Partition.cpp.

{
  assert(source != nullptr);
 
  LOGGER(l);
 
  auto pgroups = produce_pgroups(source, partition);
  INFO(l) << "--- Partition Graph (1)------------------------";
  INFO(l) << pgroups.get();
 
  auto mpgroups = merge_pgroups(pgroups.get());
  INFO(l) << "--- Partition Graph (2)------------------------";
  INFO(l) << mpgroups.get();
 
  remove_unused_inputoutputs(mpgroups.get(), source);
  INFO(l) << "--- Partition Graph (3)------------------------";
  INFO(l) << mpgroups.get();
 
  auto pmodules = produce_pmodules(mpgroups.get());
  INFO(l) << "--- Modules -----------------------------------";
  INFO(l) << &pmodules;
 
  return pmodules;
}

References INFO, LOGGER, merge_pgroups(), must_cast(), produce_pgroups(), produce_pmodules(), and remove_unused_inputoutputs().

Referenced by entry().

◆ asymmetric_wquant_with_minmax_per_layer()

void luci::asymmetric_wquant_with_minmax_per_layer	(	CircleConst *	node,
		float	min,
		float	max,
		float &	scaling_factor,
		int64_t &	zp,
		float &	nudged_min,
		float &	nudged_max
	)

Definition at line 46 of file QuantizationUtils.cpp.

{
  const int32_t kMinScale = 0;
  const int32_t kMaxScale = 255;
 
  uint32_t size = node->size<loco::DataType::FLOAT32>();
  compute_asym_scale_zp(min, max, scaling_factor, zp, nudged_min, nudged_max);
  const float scaling_factor_inv = 1.0 / scaling_factor;
  std::vector<int32_t> quantized_values(size);
  for (uint32_t i = 0; i < size; ++i)
  {
    // clipping
    auto data = node->at<loco::DataType::FLOAT32>(i);
    data = data < nudged_min ? nudged_min : data;
    data = data > nudged_max ? nudged_max : data;
    quantized_values[i] =
      static_cast<int32_t>(std::round((data - nudged_min) * scaling_factor_inv));
  }
 
  node->dtype(loco::DataType::U8);      // change the type of tensor
  node->size<loco::DataType::U8>(size); // resize tensor
  for (uint32_t i = 0; i < size; ++i)
  {
    node->at<loco::DataType::U8>(i) = std::min(kMaxScale, std::max(kMinScale, quantized_values[i]));
  }
}

References luci::CircleConst::at(), compute_asym_scale_zp(), flatbuffers::data(), must_cast(), luci::CircleConst::size(), and size.

Referenced by quant_const().

◆ cal_minmax_per_channel()

void luci::cal_minmax_per_channel	(	CircleConst *	node,
		std::vector< float > &	min,
		std::vector< float > &	max,
		int32_t &	channel_dim_index
	)

Definition at line 621 of file QuantizationUtils.cpp.

{
  loco::TensorShape dimension;
  dimension.rank(4);
 
  if (!get_channel_dim_index(node, dimension, channel_dim_index))
  {
    throw std::runtime_error("Failed to find channel index in " + node->name());
  }
  auto size = dimension.dim(channel_dim_index).value();
 
  std::vector<bool> has_min_max_value(size, false);
  min.resize(size);
  max.resize(size);
 
  auto cal_minmax = [&](uint32_t *indices, loco::TensorShape &dimension, int channel_dim_index) {
    int channel_idx = indices[channel_dim_index];
    auto data = node->at<loco::DataType::FLOAT32>(cal_offset(dimension, indices));
    if (has_min_max_value[channel_idx])
    {
      min[channel_idx] = data < min[channel_idx] ? data : min[channel_idx];
      max[channel_idx] = data > max[channel_idx] ? data : max[channel_idx];
    }
    else
    {
      min[channel_idx] = data;
      max[channel_idx] = data;
      has_min_max_value[channel_idx] = true;
    }
  };
 
  iterate_per_channel(node, channel_dim_index, cal_minmax);
}

References luci::CircleConst::at(), cal_offset(), flatbuffers::data(), loco::TensorShape::dim(), get_channel_dim_index(), iterate_per_channel(), must_cast(), luci::CircleNode::name(), loco::TensorShape::rank(), size, and loco::Dimension::value().

◆ cal_offset()

uint32_t luci::cal_offset	(	loco::TensorShape &	dimension,
		uint32_t *	indices
	)

Definition at line 287 of file QuantizationUtils.cpp.

{
  return indices[0] * dimension.dim(1).value() * dimension.dim(2).value() *
           dimension.dim(3).value() +
         indices[1] * dimension.dim(2).value() * dimension.dim(3).value() +
         indices[2] * dimension.dim(3).value() + indices[3];
}

References loco::TensorShape::dim(), and loco::Dimension::value().

Referenced by cal_minmax_per_channel().

◆ change_outputs()

void luci::change_outputs	(	loco::Graph *	graph,
		const std::vector< std::string > &	new_outputs
	)

Change output to nodes with string name.

Note: Should match existing number of nodes and all names should exist. Will throw exception if failed.

Definition at line 48 of file ChangeOutputs.cpp.

{
  if (new_outputs.size() != graph->outputs()->size())
  {
    throw oops::UserExn("Change outputs failed: number of outputs should be ",
                        graph->outputs()->size());
  }
 
  std::map<std::string, luci::CircleNode *> named_nodes;
 
  for (auto &node_name : new_outputs)
  {
    auto node = find_by_name(graph, node_name);
    if (node == nullptr)
    {
      throw oops::UserExn("Change outputs failed: node not found: ", node_name);
    }
    named_nodes[node_name] = node;
  }
  // just to be sure
  assert(graph->outputs()->size() == named_nodes.size());
 
  for (uint32_t out = 0; out < graph->outputs()->size(); ++out)
  {
    auto output = luci::output_node(graph, out); // output is CircleOutput
    assert(output != nullptr);
 
    auto &node_name = new_outputs.at(out);
    auto node = named_nodes[node_name];
    assert(node != nullptr);
 
    output->from(node);
 
    // update GraphOutput shape, dtype to node
    auto graph_out = graph->outputs()->at(out);
    auto output_shape = std::make_unique<loco::TensorShape>();
 
    output_shape->rank(node->rank());
    for (uint32_t r = 0; r < node->rank(); ++r)
    {
      if (node->dim(r).known())
        output_shape->dim(r).set(node->dim(r).value());
      else
        output_shape->dim(r).unset();
    }
    graph_out->shape(std::move(output_shape));
    graph_out->dtype(node->dtype());
  }
}

References must_cast(), output_node(), output_shape, and size.

Referenced by entry().

◆ check_quant_unfriendly_values()

void luci::check_quant_unfriendly_values ( const luci::CircleConst * node )

Definition at line 656 of file QuantizationUtils.cpp.

{
  assert(node); // FIX_CALLER_UNLESS
 
  if (node->dtype() != loco::DataType::FLOAT32)
    return;
 
  for (uint32_t i = 0; i < node->size<loco::DataType::FLOAT32>(); i++)
  {
    const auto val = node->at<loco::DataType::FLOAT32>(i);
 
    if (val == std::numeric_limits<float>::lowest())
      throw std::runtime_error(node->name() + " includes -inf");
 
    if (val == std::numeric_limits<float>::max())
      throw std::runtime_error(node->name() + " includes inf");
  }
}

References luci::CircleConst::at(), must_cast(), luci::CircleNode::name(), and luci::CircleConst::size().

Referenced by quant_const().

◆ check_size_limit()

bool luci::check_size_limit	(	const flatbuffers::FlatBufferBuilder &	fb,
		const uint64_t	data_size
	)

inline

Definition at line 68 of file CircleExporterUtils.h.

{
  return FLATBUFFERS_SIZE_MAX < data_size + fb.GetSize();
}

References FLATBUFFERS_SIZE_MAX, and must_cast().

◆ circle_builtin_operator()

circle::BuiltinOperator luci::circle_builtin_operator ( const luci::CircleNode * node )

Definition at line 189 of file CircleExporterUtils.cpp.

{
  return node->accept(&BuiltinOperatorMappingRule::get());
}

References luci::CircleNode::accept(), and luci::BuiltinOperatorMappingRule::get().

Referenced by luci::OperationExporterRule::visit().

◆ circle_builtin_options()

circle::BuiltinOptions luci::circle_builtin_options ( const luci::CircleNode * node )

Definition at line 194 of file CircleExporterUtils.cpp.

{
  if (auto cast = dynamic_cast<const luci::CircleCast *>(node))
  {
    return (cast->out_data_type() == loco::DataType::Unknown) ? circle::BuiltinOptions_NONE
                                                              : circle::BuiltinOptions_CastOptions;
  }
 
  return node->accept(&BuiltinOptionsMappingRule::get());
}

References luci::CircleNode::accept(), and luci::BuiltinOptionsMappingRule::get().

Referenced by luci::OperationExporterRule::visit().

◆ circle_custom_code()

std::string luci::circle_custom_code ( const luci::CircleNode * node )

Definition at line 205 of file CircleExporterUtils.cpp.

{
  if (auto custom_node = dynamic_cast<const luci::CircleCustom *>(node))
  {
    return custom_node->custom_code();
  }
 
  return "";
}

References must_cast().

Referenced by luci::OperationExporterRule::visit().

◆ circle_custom_options()

flatbuffers::Offset< flatbuffers::Vector< uint8_t > > luci::circle_custom_options	(	flatbuffers::FlatBufferBuilder &	fb,
		const luci::CircleNode *	node
	)

Definition at line 216 of file CircleExporterUtils.cpp.

{
  if (auto custom_node = dynamic_cast<const luci::CircleCustom *>(node))
  {
    std::vector<uint8_t> custom_options_vec{custom_node->custom_options().begin(),
                                            custom_node->custom_options().end()};
    return fb.CreateVector(custom_options_vec);
  }
 
  return 0;
}

References must_cast().

Referenced by luci::OperationExporterRule::visit().

◆ CircleConst::at< loco::DataType::STRING >() [1/2]

template<>

std::string & luci::CircleConst::at< loco::DataType::STRING > ( uint32_t n )

Definition at line 109 of file CircleConst.cpp.

{
  assert(dtype() == loco::DataType::STRING);
  assert(n < _strings.size());
  return _strings.at(n);
}

References must_cast().

◆ CircleConst::at< loco::DataType::STRING >() [2/2]

template<>

const std::string & luci::CircleConst::at< loco::DataType::STRING > ( uint32_t n ) const

Definition at line 102 of file CircleConst.cpp.

{
  assert(dtype() == loco::DataType::STRING);
  assert(n < _strings.size());
  return _strings.at(n);
}

References must_cast().

◆ CircleConst::scalar< loco::DataType::STRING >() [1/2]

template<>

std::string & luci::CircleConst::scalar< loco::DataType::STRING > ( void )

Definition at line 123 of file CircleConst.cpp.

{
  assert(dtype() == loco::DataType::STRING);
  assert(1 == _strings.size());
  return _strings.at(0);
}

◆ CircleConst::scalar< loco::DataType::STRING >() [2/2]

template<>

const std::string & luci::CircleConst::scalar< loco::DataType::STRING > ( void ) const

Definition at line 116 of file CircleConst.cpp.

{
  assert(dtype() == loco::DataType::STRING);
  assert(1 == _strings.size());
  return _strings.at(0);
}

◆ CircleConst::size< loco::DataType::STRING >() [1/2]

template<>

void luci::CircleConst::size< loco::DataType::STRING > ( uint32_t l )

Definition at line 95 of file CircleConst.cpp.

{
  assert(dtype() == loco::DataType::STRING);
  assert(_data.size() == 0);
  _strings.resize(l);
}

◆ CircleConst::size< loco::DataType::STRING >() [2/2]

template<>

uint32_t luci::CircleConst::size< loco::DataType::STRING > ( void ) const

Definition at line 88 of file CircleConst.cpp.

{
  assert(dtype() == loco::DataType::STRING);
  assert(_data.size() == 0);
  return _strings.size();
}

◆ clear_tensor_index()

void luci::clear_tensor_index ( loco::Node * node )

Definition at line 314 of file CircleExporterUtils.cpp.

{
  if (node->annot<CircleTensorIndexAnnotation>() != nullptr)
    node->annot<CircleTensorIndexAnnotation>(nullptr);
}

References loco::AnnotatedItem< Annotation >::annot().

Referenced by clearExportInfo().

◆ clearExportInfo()

void luci::clearExportInfo ( loco::Graph * g )

clear temporary export information annotated to graph nodes

Definition at line 744 of file CircleTensorExporter.cpp.

{
  auto nodes = g->nodes();
  for (uint32_t n = 0; n < nodes->size(); ++n)
  {
    auto node = loco::must_cast<luci::CircleNode *>(nodes->at(n));
    clear_tensor_index(node);
  }
}

References clear_tensor_index(), loco::must_cast(), and must_cast().

◆ clone()

luci::CircleConst * luci::clone ( luci::CircleConst * node )

Return cloned object of CircleConst node.

Definition at line 106 of file CircleConst.cpp.

{
  auto *cloned = clone_circleconst(node, node->graph());
 
  copy_common_attributes(node, cloned);
 
  return cloned;
}

References copy_common_attributes(), loco::Node::graph(), and must_cast().

Referenced by luci::CloneContext::emplace(), propagate_concat_quantparam(), and propagate_pad_v2_quantparam().

◆ clone_connect()

void luci::clone_connect	(	const luci::CircleNode *	node,
		luci::CloneContext &	clonecontext
	)

Connect cloned node from input node.

Definition at line 24 of file ConnectNode.cpp.

{
  ConnectNode cn(clonecontext);
  node->accept(&cn);
}

References luci::CircleNode::accept(), and must_cast().

◆ clone_node()

luci::CircleNode * luci::clone_node	(	const CircleNode *	node,
		loco::Graph *	graph
	)

Return a new cloned CircleNode object with same attributes value of node to graph.

Note: Will return nullptr if clone has failed; Each visit implementation must copy node specific attributes.

Definition at line 70 of file CircleNodeClone.cpp.

{
  if (node == nullptr || graph == nullptr)
    return nullptr;
 
  CloneNode cn(graph);
  auto cloned = node->accept(&cn);
  if (cloned != nullptr)
    copy_common_attributes(node, cloned);
  return cloned;
}

References luci::CircleNode::accept(), copy_common_attributes(), and must_cast().

◆ composite_origin() [1/2]

std::shared_ptr< CircleNodeOrigin > luci::composite_origin ( const std::initializer_list< std::shared_ptr< CircleNodeOrigin > > origins )

Examples: /github/workspace/compiler/luci/pass/src/RemoveUnnecessaryTransposeNetPass.cpp.

Definition at line 126 of file CircleNodeOrigin.cpp.

{
  auto origin = std::make_shared<CompositeOrigin>(origins);
 
  // For empty source, no need to create origin
  if (origin->sources().empty())
    return nullptr;
 
  return origin;
}

References must_cast().

Referenced by luci::CircleImportMetadata::origin_table().

◆ composite_origin() [2/2]

std::shared_ptr< CircleNodeOrigin > luci::composite_origin ( const std::vector< std::shared_ptr< CircleNodeOrigin > > & origins )

Definition at line 138 of file CircleNodeOrigin.cpp.

{
  auto origin = std::make_shared<CompositeOrigin>(origins);
 
  // For empty source, no need to create origin
  if (origin->sources().empty())
    return nullptr;
 
  return origin;
}

References must_cast().

◆ compute_asym_scale_zp()

void luci::compute_asym_scale_zp	(	float	min,
		float	max,
		float &	scaling_factor,
		int64_t &	zp,
		float &	nudged_min,
		float &	nudged_max
	)

Definition at line 150 of file QuantizationUtils.cpp.

{
  LOGGER(l);
 
  assert(min <= max);
  const int32_t kMinScale = 0;
  const int32_t kMaxScale = 255;
  const double qmin_double = kMinScale;
  const double qmax_double = kMaxScale;
  const double rmin = std::fmin(0, min);
  const double rmax = std::fmax(0, max);
 
  double scale = (rmax - rmin) / (qmax_double - qmin_double);
  double zero_point_double = 0;
  uint8_t nudged_zero_point = 0;
  if (scale == 0)
  {
    WARN(l) << "The minimum and maximum values are the same." << std::endl;
    if (min >= 0 && max >= 0)
      zero_point_double = kMinScale;
    else
      zero_point_double = kMaxScale;
  }
  else
    zero_point_double = qmin_double - rmin / scale;
  if (min >= 0)
  {
    assert(min >= 0 && max >= 0);
    nudged_zero_point = kMinScale;
    scale = max / (qmax_double - qmin_double);
    if (min > 0 && max > 0)
      WARN(l) << "The minimum and maximum values are all positive." << std::endl;
  }
  else if (max < 0)
  {
    assert(min < 0 && max < 0);
    nudged_zero_point = kMaxScale;
    scale = -min / (qmax_double - qmin_double);
    WARN(l) << "The minimum and maximum values are all negative." << std::endl;
  }
  else
  {
    assert(min < 0 && max >= 0);
    nudged_zero_point = fp32_to_uint8_cast(std::round(zero_point_double));
  }
 
  // protect scale from being very low due to overflow
  if (scale < 1e-5)
  {
    scale = 1e-5;
    nudged_zero_point = fp32_to_uint8_cast(std::round(qmin_double - rmin / scale));
  }
 
  nudged_min = static_cast<float>((qmin_double - nudged_zero_point) * scale);
  nudged_max = static_cast<float>((qmax_double - nudged_zero_point) * scale);
 
  scaling_factor = scale;
  zp = nudged_zero_point;
}

References fp32_to_uint8_cast(), LOGGER, must_cast(), and WARN.

Referenced by asymmetric_wquant_with_minmax_per_layer(), and luci::QuantizeActivation::visit().

◆ compute_sym_scale()

void luci::compute_sym_scale	(	float	min,
		float	max,
		float &	scaling_factor,
		float &	nudged_min,
		float &	nudged_max,
		loco::DataType	out_type
	)

Definition at line 116 of file QuantizationUtils.cpp.

{
  assert(min <= max);
  assert(out_type == loco::DataType::S4 || out_type == loco::DataType::S8 ||
         out_type == loco::DataType::S16);
 
  const int32_t kMaxScale = max_for_sym_quant(out_type);
  const int32_t kMinScale = -kMaxScale;
  const double qmin_double = kMinScale;
  const double qmax_double = kMaxScale;
  const double rmin = std::fmin(0, min);
  const double rmax = std::fmax(0, max);
  double scale_factor_from_min_side{0};
  double scale_factor_from_max_side{0};
 
  if ((qmin_double * rmin) > 0)
    scale_factor_from_min_side = rmin / qmin_double;
 
  if ((qmax_double * rmax) > 0)
    scale_factor_from_max_side = rmax / qmax_double;
 
  scaling_factor = scale_factor_from_min_side > scale_factor_from_max_side
                     ? scale_factor_from_min_side
                     : scale_factor_from_max_side;
 
  // protect scale from being very low to avoid overflow/underflow
  const float kMinScalingFactor = (out_type == loco::DataType::S16) ? 1e-8 : 1e-5;
  scaling_factor = std::max(scaling_factor, kMinScalingFactor);
 
  nudged_min = static_cast<float>(qmin_double * scaling_factor);
  nudged_max = static_cast<float>(qmax_double * scaling_factor);
}

References max_for_sym_quant(), and must_cast().

Referenced by symmetric_wquant_with_minmax_per_layer(), and luci::QuantizeActivation::visit().

◆ copy_common_attributes()

void luci::copy_common_attributes	(	const luci::CircleNode *	src,
		luci::CircleNode *	dst
	)

Copy common attributes of CircleNode from src to dst.

Note: Attributes of specific node type like keep_dims() of CircleSum are not copied.

Definition at line 33 of file CircleNodeClone.cpp.

{
  assert(src != nullptr);
  assert(dst != nullptr);
 
  dst->name(src->name());
  dst->dtype(src->dtype());
 
  dst->rank(src->rank());
  for (uint32_t i = 0; i < src->rank(); i++)
  {
    dst->dim(i) = src->dim(i);
  }
  dst->shape_status(src->shape_status());
 
  // quantparam
  copy_quantparam(src, dst);
 
  // sparsity
  const auto *sparsity = src->sparsityparam();
  if (sparsity != nullptr)
  {
    auto sparam = std::make_unique<luci::SparsityParam>();
    sparam->traversal_order = sparsity->traversal_order;
    sparam->block_map = sparsity->block_map;
    sparam->dim_metadata = sparsity->dim_metadata;
 
    dst->sparsityparam(std::move(sparam));
  }
 
  // op version
  dst->op_version(src->op_version());
}

References copy_quantparam(), must_cast(), luci::CircleNode::name(), luci::CircleNode::op_version(), luci::CircleNode::shape_status(), and luci::CircleNode::sparsityparam().

Referenced by clone(), and clone_node().

◆ copy_quantparam()

void luci::copy_quantparam	(	const luci::CircleNode *	src,
		luci::CircleNode *	dst
	)

copy CircleQuantParam of src to dst

Definition at line 28 of file CircleQuantParam.cpp.

{
  auto q = src->quantparam();
  if (q == nullptr)
    dst->quantparam(nullptr);
  else
  {
    auto qparam = std::make_unique<luci::CircleQuantParam>();
    qparam->scale = q->scale;
    qparam->zerop = q->zerop;
    qparam->min = q->min;
    qparam->max = q->max;
    qparam->quantized_dimension = q->quantized_dimension;
 
    dst->quantparam(std::move(qparam));
  }
}

References must_cast(), and luci::CircleNode::quantparam().

Referenced by copy_common_attributes(), and luci::CopyQuantParamPass::run().

◆ copy_tensor_attributes()

void luci::copy_tensor_attributes	(	const circle::Tensor *	tensor,
		CircleNode *	node
	)

Copy common tensor attributes such as name, type, etc. to node.

Definition at line 292 of file CircleReader.cpp.

{
  assert(tensor != nullptr);
 
  node->name(tensor_name(tensor));
  node->dtype(luci_datatype(tensor->type()));
 
  const auto tensor_shape_signature = wrap(tensor->shape_signature());
  const auto tensor_shape = wrap(tensor->shape());
  assert(tensor_shape_signature.size() == 0 ||
         tensor_shape_signature.size() == tensor_shape.size());
 
  const auto dims = tensor_shape; // in NHWC
  node->rank(dims.size());
  for (uint32_t r = 0; r < dims.size(); ++r)
  {
    if (tensor_shape_signature.size() > 0 && tensor_shape_signature.at(r) == -1)
      node->dim(r).unset();
    else
      node->dim(r).set(dims[r]);
  }
 
  const auto quantization = tensor->quantization();
  if (quantization != nullptr)
  {
    if (quantization->details_type() ==
        circle::QuantizationDetails::QuantizationDetails_MXQuantization)
    {
      const auto qdetails = quantization->details_as_MXQuantization();
      auto mx_quantparam = luci_mx_quantparam(qdetails);
      if (mx_quantparam)
        node->mx_quantparam(std::move(mx_quantparam));
    }
    else
    {
      // clang-format off
    auto quantparam = luci_quantparam(quantization);
    if (quantparam)
      node->quantparam(std::move(quantparam));
      // clang-format on
    }
  }
 
  const auto sparsity = tensor->sparsity();
  if (sparsity != nullptr)
  {
    auto sparsityparam = luci_sparsityparam(sparsity);
    if (sparsityparam)
      node->sparsityparam(std::move(sparsityparam));
  }
}

References luci_datatype(), luci_mx_quantparam(), luci_quantparam(), luci_sparsityparam(), must_cast(), luci::CircleNode::mx_quantparam(), luci::CircleNode::name(), luci::CircleNode::quantparam(), luci::CircleNode::sparsityparam(), tensor_name(), and wrap().

Referenced by luci::GraphBuilder::build(), luci::GraphBuilderMultiOutput::build(), luci::CircleWhileGraphBuilder::build(), luci_interpreter::CircleReferencingConstNodeBuilder::build(), luci::CircleConstNodeBuilder::build(), and create_circlevariable().

◆ create_circlevariable()

CircleVariable * luci::create_circlevariable	(	GraphBuilderContext *	context,
		int32_t	tensor_index
	)

Definition at line 48 of file CircleVariable.cpp.

{
  LOGGER(l);
 
  auto graph = context->graph();
  auto reader = context->reader();
  const auto tensors = reader->tensors();
  const auto variable_tensor = tensors[tensor_index];
  assert(variable_tensor != nullptr);
 
  if (not variable_tensor->is_variable())
  {
    // not a variable
    return nullptr;
  }
  {
    // check if there is no buffer as we don't support this for now
    // TODO use buffer when this is enabled in Kernel
    assert(reader->buffers()[variable_tensor->buffer()] != nullptr);
    assert(reader->buffers()[variable_tensor->buffer()]->data() == nullptr);
  }
 
  auto variable_node = graph->nodes()->create<CircleVariable>();
  copy_tensor_attributes(variable_tensor, variable_node);
  variable_node->shape_status(luci::ShapeStatus::VALID);
 
  INFO(l) << "[luci] NodeFinder variable node(" << tensor_index << ") -> " << variable_node << " "
          << wrap(variable_tensor->shape()) << std::endl;
 
  return variable_node;
}

References copy_tensor_attributes(), luci::GraphBuilderContext::graph(), INFO, LOGGER, must_cast(), luci::GraphBuilderContext::reader(), luci::CircleReader::tensors(), VALID, and wrap().

◆ create_const_node() [1/2]

template<typename T >

luci::CircleConst * luci::create_const_node	(	loco::Graph *	g,
		const loco::DataType	dtype,
		const std::vector< uint32_t > &	shape,
		const std::vector< T > &	values
	)

Definition at line 61 of file CreateCircleConst.h.

{
  auto node = g->nodes()->create<luci::CircleConst>();
  node->dtype(dtype);
  node->rank(shape.size());
 
  uint32_t size = 1;
  for (uint32_t i = 0; i < shape.size(); ++i)
  {
    node->dim(i) = shape.at(i);
    size *= shape.at(i);
  }
  node->shape_status(luci::ShapeStatus::VALID);
 
  node->size<TypeMapper<T>::get()>(size);
  for (uint32_t i = 0; i < size; i++)
  {
    node->at<TypeMapper<T>::get()>(i) = values[i];
  }
 
  return node;
}

References luci::CircleConst::at(), must_cast(), size, and VALID.

◆ create_const_node() [2/2]

template<typename T >

CircleConst * luci::create_const_node	(	loco::Graph *	g,
		const loco::DataType	dtype,
		const std::vector< uint32_t > &	shape,
		const T	value
	)

Definition at line 33 of file CreateCircleConst.h.

{
  auto node = g->nodes()->create<CircleConst>();
  node->dtype(dtype);
  node->rank(shape.size());
 
  uint32_t size = 1;
  for (uint32_t i = 0; i < shape.size(); ++i)
  {
    node->dim(i) = shape.at(i);
    size *= shape.at(i);
  }
  node->shape_status(ShapeStatus::VALID);
 
  node->size<TypeMapper<T>::get()>(size);
  for (uint32_t i = 0; i < size; i++)
  {
    node->at<TypeMapper<T>::get()>(i) = value;
  }
 
  return node;
}

References luci::CircleConst::at(), must_cast(), size, and VALID.

◆ createCircleMetadataVector()

std::vector< flatbuffers::Offset< circle::Metadata > > luci::createCircleMetadataVector	(	flatbuffers::FlatBufferBuilder &	builder,
		luci::SerializedModelData &	md
	)

Create Metadata corresponding to model metadata.

Definition at line 129 of file CircleExportMetadata.cpp.

{
  std::vector<flatbuffers::Offset<circle::Metadata>> metadata_vec;
 
  auto settings = luci::UserSettings::settings();
  if (settings->get(luci::UserSettings::Key::ProfilingDataGen))
  {
    metadata_vec.emplace_back(
      metadata_offset(builder, md, md._metadata.encoded_source_table(), "ONE_source_table"));
 
    metadata_vec.emplace_back(
      metadata_offset(builder, md, md._metadata.encoded_op_table(), "ONE_op_table"));
  }
  if (settings->get(luci::UserSettings::Key::ExecutionPlanGen))
  {
    metadata_vec.emplace_back(metadata_offset(
      builder, md, md._metadata.encoded_execution_plan_table(), "ONE_execution_plan_table"));
  }
  return metadata_vec;
}

References luci::SerializedModelData::_metadata, luci::CircleExportMetadata::encoded_execution_plan_table(), luci::CircleExportMetadata::encoded_op_table(), luci::CircleExportMetadata::encoded_source_table(), luci::UserSettings::ExecutionPlanGen, must_cast(), luci::UserSettings::ProfilingDataGen, and luci::UserSettings::settings().

◆ dtype_get()

loco::DataType luci::dtype_get ( const loco::Node * node )

Definition at line 22 of file CircleTypeInferenceHelper.cpp.

{
  assert(luci::dtype_known(node));
  return loco::must_cast<const luci::CircleNode *>(node)->dtype();
}

References dtype_known(), and loco::must_cast().

◆ dtype_known()

bool luci::dtype_known ( const loco::Node * node )

Definition at line 28 of file CircleTypeInferenceHelper.cpp.

{
  return loco::must_cast<const luci::CircleNode *>(node)->dtype() != loco::DataType::Unknown;
}

References loco::must_cast().

Referenced by dtype_get().

◆ dump() [1/5]

void luci::dump	(	std::ostream &	os,
		const PartedModule *	pmodule
	)

Definition at line 26 of file PartitionPModulesDump.cpp.

{
  os << "--- PartedModule: " << pmodule->group << std::endl;
  os << luci::fmt(pmodule->module->graph());
}

References fmt(), and must_cast().

◆ dump() [2/5]

void luci::dump	(	std::ostream &	os,
		const PartedModules *	pmodules
	)

Definition at line 32 of file PartitionPModulesDump.cpp.

{
  for (auto &pmodule : pmodules->pmodules)
  {
    dump(os, &pmodule);
  }
  os << std::endl;
}

References dump(), must_cast(), and luci::PartedModules::pmodules.

◆ dump() [3/5]

void luci::dump	(	std::ostream &	os,
		const PGroup *	pgroup
	)

Definition at line 32 of file PartitionIRDump.cpp.

{
  os << "--- PGroup: " << pgroup->group << std::endl;
  os << "Input(s): [ ";
  for (auto &node_in : pgroup->inputs)
    os << node_in->name() << " ";
  os << "]" << std::endl;
  for (auto &pnode : pgroup->pnodes)
  {
    dump(os, pnode.get());
  }
  os << "Output(s): [ ";
  for (auto &node_out : pgroup->outputs)
    os << node_out->name() << " ";
  os << "]" << std::endl;
}

References dump(), luci::PGroup::group, luci::PGroup::inputs, must_cast(), luci::PGroup::outputs, and luci::PGroup::pnodes.

◆ dump() [4/5]

void luci::dump	(	std::ostream &	os,
		const PGroups *	pgroups
	)

Definition at line 49 of file PartitionIRDump.cpp.

{
  for (auto &pgroup : pgroups->pgroups)
  {
    dump(os, pgroup.get());
  }
  os << "--- Node2Group items: " << std::endl;
  for (auto it = pgroups->node2group.begin(); it != pgroups->node2group.end(); ++it)
  {
    auto node = it->first;
    auto &group = it->second;
    os << "  Node: " << node << "(" << luci::opcode_name(node) << "," << node->name()
       << "): " << group << std::endl;
  }
}

References dump(), must_cast(), luci::PGroups::node2group, opcode_name(), and luci::PGroups::pgroups.

◆ dump() [5/5]

void luci::dump	(	std::ostream &	os,
		const PNode *	pnode
	)

Definition at line 26 of file PartitionIRDump.cpp.

{
  os << "PNode: " << pnode->group << ", " << pnode->node << ":" << luci::opcode_name(pnode->node)
     << ":" << pnode->node->name() << std::endl;
}

References must_cast(), and opcode_name().

Referenced by dump(), dump(), dump(), operator<<(), and operator<<().

◆ dynamic_batch_to_single_batch()

void luci::dynamic_batch_to_single_batch ( luci::Module * m )

Definition at line 29 of file DynamicBatchToSingleBatch.cpp.

{
  assert(m); // FIX CALLER UNLESS
 
  for (uint32_t i = 0; i < m->size(); i++)
  {
    auto g = m->graph(i);
 
    logo::Phase phase;
 
    phase.emplace_back(std::make_unique<luci::DynamicBatchToSingleBatchPass>());
 
    // Needed to infer shapes of other nodes
    phase.emplace_back(std::make_unique<luci::CircleShapeInferencePass>());
 
    ProgressReporter prog(g, logo::PhaseStrategy::Saturate);
    logo::PhaseRunner<logo::PhaseStrategy::Saturate> phase_runner{g};
    phase_runner.attach(&prog);
    phase_runner.run(phase);
  }
}

References m, must_cast(), and logo::Saturate.

Referenced by entry().

◆ exportNodes()

void luci::exportNodes	(	loco::Graph *	g,
		flatbuffers::FlatBufferBuilder &	builder,
		SerializedModelData &	md,
		SerializedGraphData &	gd
	)

create Operators corresponding to model nodes

Parameters

nodes	container with nodes
gd	information about serializer parts of model

Definition at line 28 of file CircleOperationExporter.cpp.

{
  uint32_t node_position = 0;
  for (auto node : loco::postorder_traversal(loco::output_nodes(g)))
  {
    ExportContext ctx{builder, md, gd};
    OperationExporterRule exporter_rule{ctx};
 
    auto circle_node = loco::must_cast<luci::CircleNode *>(node);
    circle_node->accept(&exporter_rule);
 
    const auto ops_size = gd._operators.size();
 
    if (has_origin(circle_node) && ops_size != gd._operators.size())
    {
      const auto node_id = gd._operators.size() - 1;
      for (auto source : get_origin(circle_node)->sources())
      {
        md._metadata.add_op_table(node_id, source->id());
      }
    }
    if (has_execution_plan(circle_node))
    {
      // Add to node (in node_position) metadata vector with execution_plan information:
      // order of execution, and offsets output tensors.
      const auto execution_plan = get_execution_plan(circle_node);
      std::vector<uint32_t> execution_plan_vector;
      execution_plan_vector.push_back(execution_plan.order_in_plan());
      for (auto offset : execution_plan.offsets())
      {
        execution_plan_vector.push_back(offset);
      }
      md._metadata.add_execution_plan_table(node_position, execution_plan_vector);
    }
 
    node_position++;
  }
}

References luci::SerializedModelData::_metadata, luci::SerializedGraphData::_operators, luci::CircleExportMetadata::add_execution_plan_table(), luci::CircleExportMetadata::add_op_table(), get_execution_plan(), has_execution_plan(), loco::must_cast(), must_cast(), offset(), loco::output_nodes(), and loco::postorder_traversal().

◆ exportOpDefinedTensors()

void luci::exportOpDefinedTensors	(	loco::Graph *	g,
		flatbuffers::FlatBufferBuilder &	builder,
		SerializedModelData &	md,
		SerializedGraphData &	gd
	)

create Tensors corresponding to results of all nodes in graph

Parameters

computational	graph
gd	information about serialized parts of model

Definition at line 715 of file CircleTensorExporter.cpp.

{
  CircleTensorContext tensor_ctx;
 
  // NOTE There may exist dangle CircleInput that is not visited with postorder_traversal()
  //      All dangle CircleOutput should be visited by postorder_traversal()
  auto nodes = g->nodes();
  for (uint32_t n = 0; n < nodes->size(); ++n)
  {
    auto node = dynamic_cast<luci::CircleInput *>(nodes->at(n));
    if (node != nullptr)
      allocateCircleTensor(node, tensor_ctx);
  }
 
  for (auto node : loco::postorder_traversal(loco::output_nodes(g)))
  {
    CircleNode *circle_node = loco::must_cast<luci::CircleNode *>(node);
    if (dynamic_cast<const luci::CircleInput *>(circle_node) != nullptr)
      continue;
    allocateCircleTensor(circle_node, tensor_ctx);
  }
 
  for (const auto &tensor_info : tensor_ctx)
  {
    exportOpDefinedTensor(tensor_info, builder, md, gd);
  }
}

References loco::must_cast(), must_cast(), loco::output_nodes(), and loco::postorder_traversal().

◆ fb_string2std_string()

std::string luci::fb_string2std_string ( const flatbuffers::String * fb_str )

Definition at line 344 of file CircleReader.cpp.

{
  return fb_str == nullptr ? "" : fb_str->str();
}

References must_cast().

Referenced by luci::CircleReader::name().

◆ fill()

template<class ARG_TYPE_1 , class ARG_TYPE_2 >

NodeFiller< ARG_TYPE_1, ARG_TYPE_2 > luci::fill	(	ARG_TYPE_1 **	arg_1,
		ARG_TYPE_2 **	arg_2
	)

inline

Definition at line 72 of file NodeFiller.h.

{
  return NodeFiller<ARG_TYPE_1, ARG_TYPE_2>{arg_1, arg_2};
}

References must_cast().

◆ fmt()

FormattedGraph luci::fmt ( loco::Graph * g )

Definition at line 23 of file LogHelper.cpp.

{
  auto node_summary_builder = std::make_unique<NodeSummaryBuilderFactory>();
  return std::move(locop::fmt<locop::LinearV1>(g).with(std::move(node_summary_builder)));
}

References must_cast().

Referenced by dump(), fme_apply::ProgressReporter::notify(), luci::ProgressReporter::notify(), luci::ModuleProgressReporter::notify(), fme_apply::ProgressReporter::notify(), luci::ProgressReporter::notify(), luci::ModuleProgressReporter::notify(), validate(), and validate_shape().

◆ fp32_to_uint8_cast()

uint8_t luci::fp32_to_uint8_cast ( float f )

Definition at line 39 of file QuantizationUtils.cpp.

{
  assert(std::numeric_limits<uint8_t>::min() <= f);
  assert(f <= std::numeric_limits<uint8_t>::max());
  return static_cast<uint8_t>(f);
}

References must_cast().

Referenced by compute_asym_scale_zp().

◆ freeTfLiteSparsity()

void luci::freeTfLiteSparsity ( sparsity::TfLiteSparsity & tflsp )

Definition at line 298 of file SparsityFormatConverter.cpp.

{
  assert(tflsp.traversal_order);
  assert(tflsp.block_map);
  delete[] tflsp.traversal_order;
  delete[] tflsp.block_map;
 
  for (int i = 0; i < tflsp.dim_metadata_size; ++i)
  {
    assert(tflsp.dim_metadata[i].array_segments);
    assert(tflsp.dim_metadata[i].array_indices);
    delete[] tflsp.dim_metadata[i].array_segments;
    delete[] tflsp.dim_metadata[i].array_indices;
  }
}

References sparsity::TfLiteDimensionMetadata::array_indices, sparsity::TfLiteDimensionMetadata::array_segments, sparsity::TfLiteSparsity::block_map, sparsity::TfLiteSparsity::dim_metadata, sparsity::TfLiteSparsity::dim_metadata_size, freeTfLiteSparsity(), and sparsity::TfLiteSparsity::traversal_order.

Referenced by freeTfLiteSparsity().

◆ fuse_activation_function()

bool luci::fuse_activation_function ( luci::CircleNode * node )

Definition at line 27 of file FuseActivationFunctionPass.cpp.

{
  auto preds = loco::preds(node);
  assert(preds.size() == 1);
 
  auto pred_node = static_cast<luci::CircleNode *>(*preds.begin());
  if (loco::succs(pred_node).size() != 1)
    return false;
 
  auto node_with_fused_act =
    dynamic_cast<luci::CircleNodeMixin<luci::CircleNodeTrait::FusedActFunc> *>(pred_node);
  if (node_with_fused_act == nullptr)
    return false;
 
  // TODO remove this work-around
  // This will skip fuse for concat as luci-interpreter doesn't support this yet
  if (dynamic_cast<luci::CircleConcatenation *>(pred_node) != nullptr)
    return false;
  // TODO remove this work-around
  // This will skip fuse for TransposeConv as backends does not support this yet
  // NOTE remove this when XpSepActFromTransposeConvOpPass is removed
  if (dynamic_cast<luci::CircleTransposeConv *>(pred_node) != nullptr)
    return false;
 
  auto fused_act = node_with_fused_act->fusedActivationFunction();
 
  luci::FusedActFunc target_func = luci::FusedActFunc::UNDEFINED;
 
  auto opcode = node->opcode();
  if (opcode == luci::CircleOpcode::RELU)
  {
    if (fused_act == luci::FusedActFunc::NONE || fused_act == luci::FusedActFunc::RELU)
      target_func = luci::FusedActFunc::RELU;
    else if (fused_act == luci::FusedActFunc::RELU6)
      target_func = luci::FusedActFunc::RELU6;
    else
      return false;
  }
  else if (opcode == luci::CircleOpcode::RELU6)
  {
    if (fused_act == luci::FusedActFunc::NONE || fused_act == luci::FusedActFunc::RELU ||
        fused_act == luci::FusedActFunc::RELU6)
      target_func = luci::FusedActFunc::RELU6;
    else
      return false;
  }
  else if (opcode == luci::CircleOpcode::RELU_N1_TO_1)
  {
    if (fused_act == luci::FusedActFunc::NONE || fused_act == luci::FusedActFunc::RELU_N1_TO_1)
      target_func = luci::FusedActFunc::RELU_N1_TO_1;
    else
      return false;
  }
  else
    return false;
 
  node_with_fused_act->fusedActivationFunction(target_func);
  luci::add_origin(pred_node, luci::get_origin(node));
  loco::replace(node).with(pred_node);
 
  node->drop();
 
  return true;
}

References loco::Node::drop(), must_cast(), NONE, luci::CircleNode::opcode(), loco::preds(), RELU, RELU6, RELU_N1_TO_1, loco::replace(), loco::succs(), UNDEFINED, and loco::Subst< SubstQualifier::Default >::with().

Referenced by luci::FuseActivationFunctionPass::run().

◆ fuse_add_with_conv()

bool luci::fuse_add_with_conv	(	luci::CircleAdd *	add,
		std::vector< luci::CircleSub * > &	sub_list
	)

Fuse ADD with the preceding CONV

BEFORE

  [Conv]  bias
     |

[Passable Op] (None, Max pool, Pad, etc) | [Add] beta

AFTER

  [Conv]  bias + beta
     |

[Passable Op]

A special case where SUB is newly inserted

BEFORE

        [Conv]  bias
     \   /
     [Add]
     /   \
        [Add]  beta

AFTER

        [Conv]  bias + beta
     \   /
     [Add]
     /   \

beta [Sub]

Returns: true if success

Definition at line 341 of file FusePreActivationBatchNormPass.cpp.

{
  auto x = dynamic_cast<luci::CircleConst *>(add->x());
  auto y = dynamic_cast<luci::CircleConst *>(add->y());
 
  luci::CircleNode *pred = nullptr;
  luci::CircleConst *beta = nullptr;
 
  if (x != nullptr && y == nullptr)
  {
    pred = loco::must_cast<luci::CircleNode *>(add->y());
    beta = x;
  }
  else if (x == nullptr && y != nullptr)
  {
    pred = loco::must_cast<luci::CircleNode *>(add->x());
    beta = y;
  }
  else
  {
    return false;
  }
 
  assert(beta->rank() == 1);
 
  auto channel_size = beta->dim(0).value();
  auto conv = get_backward_conv2d(pred, channel_size);
 
  if (conv != nullptr)
  {
    if (!update_conv_bias_with_beta(conv, beta, true))
      return false;
 
    luci::add_origin(conv, luci::get_origin(add));
    loco::replace(add).with(pred);
    add->drop();
 
    return true;
  }
  // A special case shown at the residual blocks of ResNetV2
  // TODO: Handle this with get_backward_conv2d
  else if (pred->opcode() == luci::CircleOpcode::ADD)
  {
    auto pred_add = loco::must_cast<luci::CircleAdd *>(pred);
    conv = get_backward_conv2d(loco::must_cast<luci::CircleNode *>(pred_add->y()), channel_size);
    if (conv == nullptr)
      conv = get_backward_conv2d(loco::must_cast<luci::CircleNode *>(pred_add->x()), channel_size);
 
    if (conv == nullptr)
      return false;
 
    if (!update_conv_bias_with_beta(conv, beta, true))
      return false;
 
    luci::add_origin(conv, luci::get_origin(add));
 
    auto relu = *loco::succs(add).begin();
    auto relu_node = loco::must_cast<luci::CircleRelu *>(relu);
    assert(relu_node != nullptr);
 
    loco::replace(add).with(pred);
 
    add->drop();
 
    sub_list.push_back(insert_sub(pred, beta));
    luci::add_origin(sub_list.back(), luci::get_origin(add));
 
    relu_node->features(pred);
 
    return true;
  }
 
  return false;
}

References loco::must_cast(), must_cast(), loco::replace(), loco::succs(), and loco::Subst< SubstQualifier::Default >::with().

Referenced by luci::FusePreActivationBatchNormPass::run().

◆ fuse_mul_with_conv()

bool luci::fuse_mul_with_conv ( luci::CircleMul * mul )

Fuse MUL with the next CONV

BEFORE

     [Mul]  gamma
       |
     [Relu]
      /  \

W1 [Conv] [Conv] W2

AFTER

          [Relu]
           /  \

gamma X W1 [Conv] [Conv] gamma X W2

Returns: true if success

Definition at line 433 of file FusePreActivationBatchNormPass.cpp.

{
  luci::CircleNode *pred_node = nullptr;
  luci::CircleConst *gamma = nullptr;
 
  if (!is_batchnorm_mul(mul, pred_node, gamma))
    return false;
 
  auto mul_succ = loco::succs(mul);
  assert(mul_succ.size() == 1);
 
  auto relu = loco::must_cast<luci::CircleRelu *>(*mul_succ.begin());
 
  auto channel_size = gamma->dim(0).value();
 
  bool fusable = true;
  auto relu_succ = loco::succs(relu);
  for (auto s : relu_succ)
  {
    auto conv = get_forward_conv2d(loco::must_cast<luci::CircleNode *>(s), channel_size);
    if (conv == nullptr)
      fusable = false;
  }
 
  if (fusable)
  {
    for (auto s : relu_succ)
    {
      // Find the next CONV
      auto conv = get_forward_conv2d(loco::must_cast<luci::CircleNode *>(s), channel_size);
 
      // Update CONV weights
      update_conv_weights_with_gamma(conv, gamma);
 
      // Update origin
      // TODO need to remove const
      luci::add_origin(const_cast<luci::CircleConv2D *>(conv),
                       luci::get_origin(loco::must_cast<luci::CircleNode *>(mul)));
    }
 
    loco::replace(mul).with(pred_node);
    relu->features(pred_node);
 
    mul->drop();
 
    return true;
  }
 
  return false;
}

References is_batchnorm_mul(), loco::must_cast(), must_cast(), loco::replace(), loco::succs(), and loco::Subst< SubstQualifier::Default >::with().

Referenced by luci::FuseMulWithConvPass::run(), and luci::FusePreActivationBatchNormPass::run().

◆ fuse_sub_with_conv()

bool luci::fuse_sub_with_conv ( luci::CircleSub * sub )

Fuse SUB with CONV

BEFORE

beta [Sub] | [Passable Op] [Conv] bias \ / [Add]

AFTER

[Passable Op]   [Conv] bias - beta
           \   /
           [Add]

Returns: true if success

Definition at line 272 of file FusePreActivationBatchNormPass.cpp.

{
  luci::CircleAdd *add = nullptr;
  luci::CircleConv2D *conv = nullptr;
  auto succs = loco::succs(sub);
  if (succs.size() != 1)
    return false;
 
  add = get_forward_add(loco::must_cast<luci::CircleNode *>(*succs.begin()));
  if (add == nullptr)
    return false;
 
  conv = dynamic_cast<luci::CircleConv2D *>(add->x());
  if (conv == nullptr)
    conv = dynamic_cast<luci::CircleConv2D *>(add->y());
 
  if (conv == nullptr)
    return false;
 
  auto beta = luci::must_cast<luci::CircleConst *>(sub->y());
  assert(beta != nullptr);
  if (!update_conv_bias_with_beta(conv, beta, false))
    return false;
 
  luci::add_origin(conv, luci::get_origin(sub));
 
  auto pred = sub->x();
  loco::replace(sub).with(pred);
 
  sub->drop();
 
  return true;
}

References luci::FixedArityNode< N, Base >::drop(), loco::must_cast(), must_cast(), loco::replace(), loco::succs(), loco::Subst< SubstQualifier::Default >::with(), luci::CircleSub::x(), and luci::CircleSub::y().

Referenced by luci::FusePreActivationBatchNormPass::run().

◆ get_channel_dim_index()

bool luci::get_channel_dim_index	(	CircleConst *	node,
		loco::TensorShape &	dimension,
		int32_t &	channel_dim_index
	)

Definition at line 211 of file QuantizationUtils.cpp.

{
  auto succs = loco::succs(node);
 
  // opcode is initialized to CIRCLEINPUT, because
  // CIRCLEINPUT should never be the successor of any node
  // (this is checked w/ the assert in the loop body)
  luci::CircleOpcode opcode = luci::CircleOpcode::CIRCLEINPUT;
  for (auto out : succs)
  {
    const auto circle_node = static_cast<CircleNode *>(out);
    assert(circle_node->opcode() != luci::CircleOpcode::CIRCLEINPUT);
 
    if (opcode == luci::CircleOpcode::CIRCLEINPUT)
    {
      opcode = circle_node->opcode();
    }
    else
    {
      // Node is used by multiple layers with different opcodes
      // We do not care such cases
      if (opcode != circle_node->opcode())
        return false;
    }
  }
 
  for (auto out : succs)
  {
    auto conv = dynamic_cast<CircleConv2D *>(out);
    auto dw_conv = dynamic_cast<CircleDepthwiseConv2D *>(out);
    auto tw_conv = dynamic_cast<CircleTransposeConv *>(out);
    auto fc = dynamic_cast<CircleFullyConnected *>(out);
 
    // Refer to https://github.com/Samsung/ONE/pull/2448.
    if ((conv != nullptr && conv->filter() == node) ||
        (tw_conv != nullptr && tw_conv->filter() == node)) // OHWI
    {
      assert(node->rank() == 4);
      dimension.dim(0).set(node->dim(0).value());
      dimension.dim(1).set(node->dim(1).value());
      dimension.dim(2).set(node->dim(2).value());
      dimension.dim(3).set(node->dim(3).value());
      channel_dim_index = 0; // Set channel_dim_index based on "O"
      return true;
    }
    else if (dw_conv != nullptr && dw_conv->filter() == node) // IHWC
    {
      assert(node->rank() == 4);
      dimension.dim(0).set(node->dim(0).value());
      dimension.dim(1).set(node->dim(1).value());
      dimension.dim(2).set(node->dim(2).value());
      dimension.dim(3).set(node->dim(3).value());
      channel_dim_index = 3; // Set channel_dim_index based on "C"
      return true;
    }
    else if (fc != nullptr && fc->weights() == node) // OI
    {
      assert(node->rank() == 2);
      dimension.dim(0).set(node->dim(0).value());
      dimension.dim(1).set(1); // Set FC layer like CONV
      dimension.dim(2).set(1);
      dimension.dim(3).set(node->dim(1).value());
      channel_dim_index = 0; // Set channel_dim_index based on "O"
      return true;
    }
    else
    {
      // node does not support channle-wise quantization
      assert(false);
    }
  }
 
  return false;
}

References loco::TensorShape::dim(), must_cast(), loco::Dimension::set(), and loco::succs().

Referenced by cal_minmax_per_channel(), iterate_per_channel(), and iterate_per_channel().

◆ get_execution_plan()

luci::CircleNodeExecutionPlan luci::get_execution_plan ( const luci::CircleNode * circle_node )

Definition at line 69 of file CircleNodeExecutionPlan.cpp.

{
  if (!has_execution_plan(circle_node))
    throw std::runtime_error("Cannot find CircleNodeExecutionPlanAnnotation");
 
  return circle_node->annot<CircleExecutionPlanAnnotation>()->execution_plan();
}

References has_execution_plan(), and must_cast().

Referenced by luci_interpreter::build_kernel_CircleAveragePool2D(), luci_interpreter::build_kernel_CircleBatchMatMul(), luci_interpreter::build_kernel_CircleConv2D(), luci_interpreter::build_kernel_CircleDepthwiseConv2D(), exportNodes(), luci_interpreter::GraphLoader::loadOperators(), and luci_interpreter::GraphLoader::loadTensors().

◆ get_node_id()

luci::CircleNodeID luci::get_node_id ( const luci::CircleNode * circle_node )

Definition at line 65 of file CircleNodeID.cpp.

{
  if (!has_node_id(circle_node))
    throw std::runtime_error("Cannot find CircleNodeID");
 
  return circle_node->annot<CircleNodeIDAnnotation>()->node_id();
}

References has_node_id(), and must_cast().

Referenced by minmax_embedder::Embedder::embed(), and onert::odc::Embedder::embed().

◆ get_tensor_index()

CircleTensorIndex luci::get_tensor_index ( loco::Node * node )

Definition at line 320 of file CircleExporterUtils.cpp.

{
  assert(node->annot<CircleTensorIndexAnnotation>() != nullptr);
  return node->annot<CircleTensorIndexAnnotation>()->index();
}

References loco::AnnotatedItem< Annotation >::annot().

Referenced by luci::OperationExporterRule::visit().

◆ getOpPadding() [1/2]

circle::Padding luci::getOpPadding	(	const loco::Padding2D *	pad,
		const loco::Stride< 2 > *	stride,
		const ShapeDescription &	ifm,
		const ShapeDescription &	ofm
	)

Definition at line 249 of file CircleExporterUtils.cpp.

{
  // VALID padding
  if (pad->top() == 0 && pad->bottom() == 0 && pad->left() == 0 && pad->right() == 0)
    return circle::Padding_VALID;
 
  // SAME padding
  //
  // For same padding, by definition, following equation should hold:
  //   O = floor((I - 1) / S) + 1
  //   where input size I, output size O, stride S
  //
  // NOTE input and output 'feature' map are shape of NHWC
  bool same_padding_criterion_1 =
    (static_cast<uint32_t>(ofm._dims[1]) == (ifm._dims[1] - 1) / stride->vertical() + 1) &&
    (static_cast<uint32_t>(ofm._dims[2]) == (ifm._dims[2] - 1) / stride->horizontal() + 1);
 
  // For same padding, rear padding is same or bigger than front padding by at most 1
  bool same_padding_criterion_2 =
    (pad->top() <= pad->bottom()) && (pad->bottom() <= pad->top() + 1) &&
    (pad->left() <= pad->right()) && (pad->right() <= pad->left() + 1);
 
  if (same_padding_criterion_1 && same_padding_criterion_2)
    return circle::Padding_SAME;
 
  INTERNAL_EXN("Unsupported padding criteria");
}

References luci::ShapeDescription::_dims, loco::Padding2D::bottom(), INTERNAL_EXN, loco::Padding2D::left(), must_cast(), loco::Padding2D::right(), and loco::Padding2D::top().

Referenced by luci::BuiltinOptionsExtractor::visit(), luci::BuiltinOptionsExtractor::visit(), luci::BuiltinOptionsExtractor::visit(), luci::BuiltinOptionsExtractor::visit(), luci::BuiltinOptionsExtractor::visit(), and luci::BuiltinOptionsExtractor::visit().

◆ getOpPadding() [2/2]

circle::Padding luci::getOpPadding ( const luci::Padding pad )

Definition at line 278 of file CircleExporterUtils.cpp.

{
  if (pad == luci::Padding::VALID)
    return circle::Padding_VALID;
  if (pad == luci::Padding::SAME)
    return circle::Padding_SAME;
 
  INTERNAL_EXN_V("Unsupported luci::Padding", oops::to_uint32(pad));
}

References INTERNAL_EXN_V, SAME, oops::to_uint32(), and VALID.

◆ has_dynamic_shape()

bool luci::has_dynamic_shape ( const loco::Node * node )

Definition at line 62 of file Shape.cpp.

{
  const auto circle_node = loco::must_cast<const luci::CircleNode *>(node);
  for (uint32_t i = 0; i < circle_node->rank(); ++i)
    if (!circle_node->dim(i).known())
      return true;
  return false;
}

References loco::must_cast(), and must_cast().

Referenced by luci::ConvertNCHWToNHWCPass::run().

◆ has_execution_plan()

bool luci::has_execution_plan ( const luci::CircleNode * circle_node )

Definition at line 57 of file CircleNodeExecutionPlan.cpp.

{
  return circle_node->annot<CircleExecutionPlanAnnotation>() != nullptr;
}

References must_cast().

Referenced by luci_interpreter::build_kernel_CircleAveragePool2D(), luci_interpreter::build_kernel_CircleBatchMatMul(), luci_interpreter::build_kernel_CircleConv2D(), luci_interpreter::build_kernel_CircleDepthwiseConv2D(), exportNodes(), get_execution_plan(), luci_interpreter::GraphLoader::loadOperators(), and luci_interpreter::GraphLoader::loadTensors().

◆ has_node_id()

bool luci::has_node_id ( const luci::CircleNode * circle_node )

Definition at line 54 of file CircleNodeID.cpp.

{
  return circle_node->annot<CircleNodeIDAnnotation>() != nullptr;
}

References must_cast().

Referenced by minmax_embedder::Embedder::embed(), onert::odc::Embedder::embed(), and get_node_id().

◆ in_array()

bool luci::in_array	(	const std::string &	str,
		const std::vector< std::string > &	array
	)

Definition at line 24 of file Strings.cpp.

{
  return std::find(array.begin(), array.end(), str) != array.end();
}

References must_cast().

◆ inference_candidates()

std::vector< loco::Node * > luci::inference_candidates ( loco::Graph * g )

Enumerate all the nodes whose shape/dtype should be inferenced to export graph.

Definition at line 24 of file InferenceCandidates.cpp.

{
  auto candidates = loco::postorder_traversal(loco::output_nodes(g));
 
  for (auto node : loco::all_nodes(g))
  {
    // already included as candidate
    if (std::find(candidates.begin(), candidates.end(), node) != candidates.end())
      continue;
 
    // As the node is not used for both graph output and multiple output operation,
    // it cannot be candidate.
    if (node->dialect()->service<DeadNodeQueryServiceImpl>()->isDeadNode(node))
      continue;
 
    candidates.emplace_back(node);
  }
 
  return candidates;
}

References loco::all_nodes(), loco::output_nodes(), and loco::postorder_traversal().

Referenced by luci::CircleTypeInferencePass::run(), and luci::CircleShapeInferencePass::run().

◆ input_node()

CircleInput * luci::input_node	(	loco::Graph *	g,
		const loco::GraphInputIndex &	index
	)

Find a Pull node with a given input index.

Definition at line 45 of file CircleNodes.cpp.

{
  for (uint32_t n = 0; n < g->nodes()->size(); ++n)
  {
    if (auto input = dynamic_cast<CircleInput *>(g->nodes()->at(n)))
    {
      if (input->indexed() && input->index() == index)
      {
        return input;
      }
    }
  }
  return nullptr;
}

References must_cast(), and size.

Referenced by luci::CircleWhileGraphBuilder::build(), luci::test::ExampleGraph< ExampleGraphType::CircleTranspose >::ExampleGraph(), luci::DynamicBatchToSingleBatchPass::run(), luci::sinf::Algorithm::visit(), and luci_interpreter::Interpreter::writeInputTensor().

◆ INSTANTIATE() [1/10]

luci::INSTANTIATE ( loco::DataType::BOOL )

◆ INSTANTIATE() [2/10]

luci::INSTANTIATE ( loco::DataType::FLOAT16 )

◆ INSTANTIATE() [3/10]

luci::INSTANTIATE ( loco::DataType::FLOAT32 )

◆ INSTANTIATE() [4/10]

luci::INSTANTIATE ( loco::DataType::S16 )

◆ INSTANTIATE() [5/10]

luci::INSTANTIATE ( loco::DataType::S32 )

◆ INSTANTIATE() [6/10]

luci::INSTANTIATE ( loco::DataType::S4 )

◆ INSTANTIATE() [7/10]

luci::INSTANTIATE ( loco::DataType::S64 )

◆ INSTANTIATE() [8/10]

luci::INSTANTIATE ( loco::DataType::S8 )

◆ INSTANTIATE() [9/10]

luci::INSTANTIATE ( loco::DataType::U4 )

◆ INSTANTIATE() [10/10]

luci::INSTANTIATE ( loco::DataType::U8 )

◆ is_batchnorm_add() [1/2]

bool luci::is_batchnorm_add ( const luci::CircleAdd * add )

Find Mul-Add pattern.

Definition at line 76 of file BatchNormPatternFinder.cpp.

{
  // for dummy mul and beta
  luci::CircleMul *mul = nullptr;
  luci::CircleConst *beta = nullptr;
 
  return is_batchnorm_add(add, mul, beta);
}

References is_batchnorm_add().

◆ is_batchnorm_add() [2/2]

bool luci::is_batchnorm_add	(	const luci::CircleAdd *	add,
		luci::CircleMul *&	mul,
		luci::CircleConst *&	beta
	)

Find Mul-Add pattern and return Mul and beta as BatchNorm.

Definition at line 24 of file BatchNormPatternFinder.cpp.

{
  auto x = loco::must_cast<luci::CircleNode *>(add->x());
  auto y = loco::must_cast<luci::CircleNode *>(add->y());
 
  luci::CircleMul *pred = nullptr;
  luci::CircleConst *constant = nullptr;
 
  if (x->opcode() == luci::CircleOpcode::CIRCLECONST && y->opcode() == luci::CircleOpcode::MUL)
  {
    pred = loco::must_cast<luci::CircleMul *>(y);
    constant = luci::must_cast<luci::CircleConst *>(x);
  }
  else if (x->opcode() == luci::CircleOpcode::MUL && y->opcode() == luci::CircleOpcode::CIRCLECONST)
  {
    pred = loco::must_cast<luci::CircleMul *>(x);
    constant = luci::must_cast<luci::CircleConst *>(y);
  }
  else
  {
    return false;
  }
 
  uint32_t channel_dim = 0;
 
  if (constant->rank() == 1)
  {
    channel_dim = constant->dim(0).value();
  }
  else if (constant->rank() == 4)
  {
    for (uint32_t i = 0; i < 3; i++)
    {
      if (constant->dim(i).value() != 1)
        return false;
    }
    channel_dim = constant->dim(3).value();
  }
  else
  {
    return false;
  }
 
  // Assumption: Layout is channel-last
  if (!(channel_dim == add->dim(add->rank() - 1)))
    return false;
 
  mul = pred;
  beta = constant;
  return true;
}

References loco::must_cast(), and must_cast().

Referenced by is_batchnorm_add(), and swap_mul_add().

◆ is_batchnorm_mul()

bool luci::is_batchnorm_mul	(	const luci::CircleMul *	mul,
		luci::CircleNode *&	pred_node,
		luci::CircleConst *&	gamma
	)

Find Const-Mul pattern and return Node and gamma as BatchNorm.

Definition at line 85 of file BatchNormPatternFinder.cpp.

{
  auto x = dynamic_cast<luci::CircleConst *>(mul->x());
  auto y = dynamic_cast<luci::CircleConst *>(mul->y());
 
  luci::CircleNode *pred = nullptr;
  luci::CircleConst *constant = nullptr;
 
  if (x != nullptr && y == nullptr)
  {
    pred = loco::must_cast<luci::CircleNode *>(mul->y());
    constant = x;
  }
  else if (x == nullptr && y != nullptr)
  {
    pred = loco::must_cast<luci::CircleNode *>(mul->x());
    constant = y;
  }
  else
  {
    return false;
  }
 
  uint32_t channel_dim = 0;
 
  if (constant->rank() == 1)
  {
    channel_dim = constant->dim(0).value();
  }
  else if (constant->rank() == 4)
  {
    for (uint32_t i = 0; i < 3; i++)
    {
      if (constant->dim(i).value() != 1)
        return false;
    }
    channel_dim = constant->dim(3).value();
  }
  else
  {
    return false;
  }
 
  // Assumption: Layout is channel-last
  if (!(channel_dim == mul->dim(mul->rank() - 1)))
    return false;
 
  pred_node = pred;
  gamma = constant;
  return true;
}

References loco::must_cast(), and must_cast().

Referenced by fuse_mul_with_conv(), and swap_mul_add().

◆ is_fp32()

bool luci::is_fp32 ( const CircleNode * node )

Definition at line 37 of file QuantizationUtils.cpp.

37{ return node->dtype() == loco::DataType::FLOAT32; }

Referenced by luci::QuantizeActivation::visit().

◆ is_onnx_dequantize_linear()

bool luci::is_onnx_dequantize_linear ( const luci::CircleCustom * node )

Definition at line 534 of file QuantizationUtils.cpp.

{
  if (node->numInputs() != 3)
    return false;
 
  if (node->numOutputs() != 1)
    return false;
 
  if (node->custom_code() != "ONNXDequantizeLinear")
    return false;
 
  return true;
}

References luci::CircleCustom::custom_code(), luci::CircleCustom::numInputs(), and luci::CircleCustom::numOutputs().

◆ is_onnx_quantize_linear()

bool luci::is_onnx_quantize_linear ( const luci::CircleCustom * node )

Definition at line 548 of file QuantizationUtils.cpp.

{
  if (node->numInputs() != 3)
    return false;
 
  if (node->numOutputs() != 1)
    return false;
 
  if (node->custom_code() != "ONNXQuantizeLinear")
    return false;
 
  return true;
}

References luci::CircleCustom::custom_code(), luci::CircleCustom::numInputs(), and luci::CircleCustom::numOutputs().

◆ is_quantized()

bool luci::is_quantized ( const CircleNode * node )

Definition at line 28 of file QuantizationUtils.cpp.

{
  return node->quantparam() != nullptr &&
         (node->dtype() == loco::DataType::U8 ||  // activation, weight (uint8 quant)
          node->dtype() == loco::DataType::S16 || // activation, weight (int16 quant)
          node->dtype() == loco::DataType::S32 || // bias (uint8 quant)
          node->dtype() == loco::DataType::S64);  // bias (int16 quant)
}

References luci::CircleNode::quantparam().

Referenced by propagate_pad_v2_quantparam(), and luci::QuantizeOnnxFakeQuantModelPass::run().

◆ is_same_shape() [1/2]

bool luci::is_same_shape	(	const luci::CircleNode *	node,
		const loco::TensorShape &	shape
	)

Definition at line 22 of file Shape.cpp.

{
  if (node == nullptr)
    return false;
 
  if (node->shape_status() != luci::ShapeStatus::VALID)
    return false;
 
  if (node->rank() != shape.rank())
    return false;
 
  for (uint32_t i = 0; i < node->rank(); ++i)
  {
    if (node->dim(i).known() != shape.dim(i).known())
      return false;
 
    if (node->dim(i).value() != shape.dim(i).value())
      return false;
  }
 
  return true;
}

References loco::TensorShape::dim(), loco::Dimension::known(), must_cast(), loco::TensorShape::rank(), luci::CircleNode::shape_status(), VALID, and loco::Dimension::value().

Referenced by luci::CircleShapeInferencePass::run().

◆ is_same_shape() [2/2]

bool luci::is_same_shape	(	const luci::CircleNode *	node,
		const std::initializer_list< uint32_t >	shape
	)

Definition at line 45 of file Shape.cpp.

{
  if (node == nullptr)
    return false;
 
  if (node->rank() != shape.size())
    return false;
 
  uint32_t i = 0;
  for (auto it = shape.begin(); it != shape.end(); ++it, ++i)
  {
    if (node->dim(i).value() != *it)
      return false;
  }
  return true;
}

References must_cast().

◆ isNHWC() [1/3]

template<>

bool luci::isNHWC ( loco::Permutation< loco::Domain::Feature > * perm )

inline

Definition at line 44 of file ShapeDescription.h.

{
  return perm->axis(loco::FeatureAxis::Count) == 0 && perm->axis(loco::FeatureAxis::Height) == 1 &&
         perm->axis(loco::FeatureAxis::Width) == 2 && perm->axis(loco::FeatureAxis::Depth) == 3;
}

References loco::Count, loco::Depth, loco::Height, and loco::Width.

◆ isNHWC() [2/3]

template<>

bool luci::isNHWC ( loco::Permutation< loco::Domain::Filter > * perm )

inline

Definition at line 50 of file ShapeDescription.h.

{
  return perm->axis(loco::FilterAxis::Count) == 0 && perm->axis(loco::FilterAxis::Height) == 1 &&
         perm->axis(loco::FilterAxis::Width) == 2 && perm->axis(loco::FilterAxis::Depth) == 3;
}

References loco::Count, loco::Depth, loco::Height, and loco::Width.

◆ isNHWC() [3/3]

template<typename Permutation >

bool luci::isNHWC ( Permutation * perm )

inline

◆ iterate_per_channel() [1/2]

void luci::iterate_per_channel	(	CircleConst *	node,
		int32_t &	channel_dim_index,
		IterFunc	func
	)

Definition at line 562 of file QuantizationUtils.cpp.

{
  loco::TensorShape dimension;
  dimension.rank(4);
  uint32_t indices[4] = {
    0,
  };
 
  if (!get_channel_dim_index(node, dimension, channel_dim_index))
  {
    assert(false);
    return;
  }
 
  for (indices[0] = 0; indices[0] < dimension.dim(0).value(); indices[0]++)
  {
    for (indices[1] = 0; indices[1] < dimension.dim(1).value(); indices[1]++)
    {
      for (indices[2] = 0; indices[2] < dimension.dim(2).value(); indices[2]++)
      {
        for (indices[3] = 0; indices[3] < dimension.dim(3).value(); indices[3]++)
        {
          func(indices, dimension, channel_dim_index);
        }
      }
    }
  }
}

References loco::TensorShape::dim(), get_channel_dim_index(), must_cast(), and loco::TensorShape::rank().

Referenced by cal_minmax_per_channel().

◆ iterate_per_channel() [2/2]

void luci::iterate_per_channel	(	CircleConst *	node,
		IterFunc	func
	)

Definition at line 591 of file QuantizationUtils.cpp.

{
  loco::TensorShape dimension;
  dimension.rank(4);
  uint32_t indices[4] = {
    0,
  };
  int32_t channel_dim_index{0};
 
  if (!get_channel_dim_index(node, dimension, channel_dim_index))
  {
    assert(false);
    return;
  }
 
  for (indices[0] = 0; indices[0] < dimension.dim(0).value(); indices[0]++)
  {
    for (indices[1] = 0; indices[1] < dimension.dim(1).value(); indices[1]++)
    {
      for (indices[2] = 0; indices[2] < dimension.dim(2).value(); indices[2]++)
      {
        for (indices[3] = 0; indices[3] < dimension.dim(3).value(); indices[3]++)
        {
          func(indices, dimension, channel_dim_index);
        }
      }
    }
  }
}

References loco::TensorShape::dim(), get_channel_dim_index(), must_cast(), and loco::TensorShape::rank().

◆ layer_info_map()

LayerInfoMap luci::layer_info_map	(	loco::Graph *	g,
		std::vector< LayerInfo > &	layers_info
	)

Definition at line 142 of file LayerInfoMap.cpp.

{
  LayerInfoMap info_by_name;
 
  for (auto &&info : layers_info)
  {
    auto &name = info.name;
    bool found = false;
    for (auto node : loco::active_nodes(loco::output_nodes(g)))
    {
      auto cnode = loco::must_cast<luci::CircleNode *>(node);
      if (cnode->opcode() == luci::CircleOpcode::CIRCLEOUTPUT)
        continue;
 
      if (cnode->name() == name)
      {
        // Check and add multiple-output node and its outputs to info_by_name
        if (const auto multi_output = get_multi_output_node(cnode))
        {
          add_multi_output_node(info_by_name, info, multi_output);
          found = true;
          continue;
        }
 
        if (info_by_name.find(name) != info_by_name.end())
        {
          throw std::runtime_error("Duplicate layer name " + name +
                                   ". Check layer names in the quantization configuration file.");
        }
 
        info_by_name[name] = info;
        found = true;
        continue;
      }
    }
 
    if (not found)
      throw std::runtime_error("No such layer named " + name +
                               ". Check layer names in the quantization configuration file.");
  }
 
  // TODO Check all names in layers_info exist in the info_by_name
  // TODO Check names in info_by_name but not in layers_info are from virtual outputs
 
  return info_by_name;
}

References loco::active_nodes(), info, loco::must_cast(), must_cast(), and loco::output_nodes().

Referenced by luci::QuantizeDequantizeWeightsPass::run(), luci::QuantizeWithMinMaxPass::run(), and luci::QuantizedModelVerifier::verify().

◆ link() [1/2]

void luci::link	(	loco::GraphInput *	input,
		CircleInput *	node
	)

Link GraphInput with CircleInput node.

Definition at line 43 of file CircleNodes.cpp.

43{ node->index(input->index()); }

luci::CircleInput::index

void index(const loco::GraphInputIndex &index)

Definition CircleInput.cpp:25

References luci::CircleInput::index().

◆ link() [2/2]

void luci::link	(	loco::GraphOutput *	output,
		CircleOutput *	node
	)

Link GraphOutput with CircleOutput node.

Definition at line 26 of file CircleNodes.cpp.

26{ node->index(output->index()); }

luci::CircleOutput::index

void index(const loco::GraphOutputIndex &index)

Definition CircleOutput.cpp:25

References luci::CircleOutput::index().

Referenced by luci::test::TestGraph::TestGraph().

◆ luci_actfunc()

FusedActFunc luci::luci_actfunc ( const circle::ActivationFunctionType type )

Definition at line 84 of file CircleReader.cpp.

{
  switch (type)
  {
    case circle::ActivationFunctionType::ActivationFunctionType_NONE:
      return luci::FusedActFunc::NONE;
    case circle::ActivationFunctionType::ActivationFunctionType_RELU:
      return luci::FusedActFunc::RELU;
    case circle::ActivationFunctionType::ActivationFunctionType_RELU_N1_TO_1:
      return luci::FusedActFunc::RELU_N1_TO_1;
    case circle::ActivationFunctionType::ActivationFunctionType_RELU6:
      return luci::FusedActFunc::RELU6;
    case circle::ActivationFunctionType::ActivationFunctionType_TANH:
      return luci::FusedActFunc::TANH;
    case circle::ActivationFunctionType::ActivationFunctionType_SIGN_BIT:
      return luci::FusedActFunc::SIGN_BIT;
    default:
      break;
  }
  assert(false);
  return luci::FusedActFunc::UNDEFINED;
}

References NONE, RELU, RELU6, RELU_N1_TO_1, SIGN_BIT, TANH, type, and UNDEFINED.

Referenced by luci_interpreter::configure_kernel_CircleConcatenation(), luci_interpreter::createConv2DParams(), luci_interpreter::createPoolParams(), luci_interpreter::kernels::evalTISOKernel(), and luci_interpreter::kernels::evalTISOQuantizedKernel().

◆ luci_datatype()

loco::DataType luci::luci_datatype ( circle::TensorType type )

Definition at line 45 of file CircleReader.cpp.

{
  switch (type)
  {
    case circle::TensorType_FLOAT32:
      return loco::DataType::FLOAT32;
    case circle::TensorType_FLOAT16:
      return loco::DataType::FLOAT16;
    case circle::TensorType_INT32:
      return loco::DataType::S32;
    case circle::TensorType_UINT8:
      return loco::DataType::U8;
    case circle::TensorType_UINT4:
      return loco::DataType::U4;
    case circle::TensorType_INT64:
      return loco::DataType::S64;
    case circle::TensorType_STRING:
      return loco::DataType::STRING;
    case circle::TensorType_BOOL:
      return loco::DataType::BOOL;
    case circle::TensorType_INT16:
      return loco::DataType::S16;
    case circle::TensorType_COMPLEX64:
      break;
    case circle::TensorType_INT8:
      return loco::DataType::S8;
    case circle::TensorType_INT4:
      return loco::DataType::S4;
    case circle::TensorType_MXFP4:
      return loco::DataType::MXFP4;
    case circle::TensorType_MXINT8:
      return loco::DataType::MXINT8;
    default:
      break;
  }
  assert(false);
  return loco::DataType::Unknown;
}

References type.

Referenced by luci::GraphBuilderMultiOutput::build(), luci::CircleConstNodeBuilder::build(), copy_tensor_attributes(), and luci_interpreter::Tensor::element_type().

◆ luci_dim_type()

DimensionType luci::luci_dim_type ( const circle::DimensionType dim_type )

Definition at line 162 of file CircleReader.cpp.

{
  switch (dim_type)
  {
    case circle::DimensionType_DENSE:
      return DimensionType::DENSE;
    case circle::DimensionType_SPARSE_CSR:
      return DimensionType::SPARSE_CSR;
    default:
      throw std::runtime_error("Invalid DimensionType");
  }
}

References DENSE, must_cast(), and SPARSE_CSR.

Referenced by luci_sparsityparam().

◆ luci_mirrorpad_mode()

MirrorPadMode luci::luci_mirrorpad_mode ( const circle::MirrorPadMode mode )

Definition at line 120 of file CircleReader.cpp.

{
  switch (mode)
  {
    case circle::MirrorPadMode::MirrorPadMode_REFLECT:
      return MirrorPadMode::REFLECT;
    case circle::MirrorPadMode::MirrorPadMode_SYMMETRIC:
      return MirrorPadMode::SYMMETRIC;
  }
  assert(false);
  return MirrorPadMode::UNDEFINED;
}

References REFLECT, SYMMETRIC, and UNDEFINED.

◆ luci_mx_quantparam() [1/2]

std::unique_ptr< CircleMXQuantParam > luci::luci_mx_quantparam ( const circle::MXQuantization * quantization )

Definition at line 250 of file CircleReader.cpp.

{
  // create temporary unpacked API object
  assert(qparams != nullptr);
  circle::MXQuantizationT quantization;
  qparams->UnPackTo(&quantization);
 
  return luci_mx_quantparam(&quantization);
}

References luci_mx_quantparam(), and must_cast().

Referenced by copy_tensor_attributes(), and luci_mx_quantparam().

◆ luci_mx_quantparam() [2/2]

std::unique_ptr< CircleMXQuantParam > luci::luci_mx_quantparam ( const circle::MXQuantizationT * quantization )

Definition at line 230 of file CircleReader.cpp.

{
  const auto &axis = quantization->axis;
 
  auto quantparam = std::make_unique<CircleMXQuantParam>();
  quantparam->axis = axis;
 
  return quantparam;
}

◆ luci_padding()

Padding luci::luci_padding ( const circle::Padding padding )

Definition at line 107 of file CircleReader.cpp.

{
  switch (padding)
  {
    case circle::Padding::Padding_SAME:
      return Padding::SAME;
    case circle::Padding::Padding_VALID:
      return Padding::VALID;
  }
  assert(false);
  return Padding::UNDEFINED;
}

References SAME, UNDEFINED, and VALID.

Referenced by luci_interpreter::computeConvPadding(), and luci_interpreter::createPoolParams().

◆ luci_quantparam() [1/2]

std::unique_ptr< CircleQuantParam > luci::luci_quantparam ( const circle::QuantizationParameters * quantization )

Definition at line 240 of file CircleReader.cpp.

{
  // create temporary unpacked API object
  assert(qparams != nullptr);
  circle::QuantizationParametersT quantization;
  qparams->UnPackTo(&quantization);
 
  return luci_quantparam(&quantization);
}

References luci_quantparam(), and must_cast().

Referenced by copy_tensor_attributes(), and luci_quantparam().

◆ luci_quantparam() [2/2]

std::unique_ptr< CircleQuantParam > luci::luci_quantparam ( const circle::QuantizationParametersT * quantization )

Definition at line 206 of file CircleReader.cpp.

{
  const auto &min = quantization->min;
  const auto &max = quantization->max;
  const auto &scale = quantization->scale;
  const auto &zero_point = quantization->zero_point;
  const auto &quantized_dimension = quantization->quantized_dimension;
 
  if ((!min.empty() && !max.empty()) || (!scale.empty() && !zero_point.empty()))
  {
    auto quantparam = std::make_unique<CircleQuantParam>();
 
    quantparam->min = min;
    quantparam->max = max;
    quantparam->scale = scale;
    quantparam->zerop = zero_point;
    quantparam->quantized_dimension = quantized_dimension;
 
    return quantparam;
  }
 
  return nullptr;
}

◆ luci_rope_mode()

RoPEMode luci::luci_rope_mode ( const circle::RoPEMode mode )

Definition at line 133 of file CircleReader.cpp.

{
  switch (mode)
  {
    case circle::RoPEMode::RoPEMode_GPT_NEOX:
      return RoPEMode::GPT_NEOX;
    case circle::RoPEMode::RoPEMode_GPT_J:
      return RoPEMode::GPT_J;
  }
  assert(false);
  return RoPEMode::UNDEFINED;
}

References GPT_J, GPT_NEOX, and UNDEFINED.

◆ luci_sparse_index_vector()

SparseIndexVector luci::luci_sparse_index_vector ( const circle::SparseIndexVectorUnion & sparse_index_vector )

Definition at line 176 of file CircleReader.cpp.

{
  switch (sparse_index_vector.type)
  {
    case circle::SparseIndexVector_NONE:
      return SparseIndexVector{SparseIndexVectorType::NONE, nullptr};
    case circle::SparseIndexVector_Int32Vector:
    {
      const auto const_vec_ptr =
        static_cast<const void *>(&(sparse_index_vector.AsInt32Vector()->values));
      return SparseIndexVector{SparseIndexVectorType::I32, const_vec_ptr};
    }
    case circle::SparseIndexVector_Uint16Vector:
    {
      const auto const_vec_ptr =
        static_cast<const void *>(&(sparse_index_vector.AsUint16Vector()->values));
      return SparseIndexVector{SparseIndexVectorType::U16, const_vec_ptr};
    }
    case circle::SparseIndexVector_Uint8Vector:
    {
      const auto const_vec_ptr =
        static_cast<const void *>(&(sparse_index_vector.AsUint8Vector()->values));
      return SparseIndexVector{SparseIndexVectorType::U8, const_vec_ptr};
    }
    default:
      throw std::runtime_error("Invalid SparseIndexVector type");
  }
}

References I32, must_cast(), NONE, U16, and U8.

Referenced by luci_sparsityparam().

◆ luci_sparsityparam() [1/2]

std::unique_ptr< SparsityParam > luci::luci_sparsityparam ( const circle::SparsityParameters * sparparam )

Definition at line 282 of file CircleReader.cpp.

{
  // create temporary unpacked API object
  assert(sparparam != nullptr);
  circle::SparsityParametersT sparsity;
  sparparam->UnPackTo(&sparsity);
 
  return luci_sparsityparam(&sparsity);
}

References luci_sparsityparam(), and must_cast().

◆ luci_sparsityparam() [2/2]

std::unique_ptr< SparsityParam > luci::luci_sparsityparam ( const circle::SparsityParametersT * sparsity )

Definition at line 260 of file CircleReader.cpp.

{
  assert(sparsity);
  const auto &traversal_order = sparsity->traversal_order;
  const auto &block_map = sparsity->block_map;
  const auto &dim_metadata = sparsity->dim_metadata;
 
  // TODO find a condition that should return nullptr
  auto sparsityparam = std::make_unique<SparsityParam>();
 
  sparsityparam->traversal_order = traversal_order;
  sparsityparam->block_map = block_map;
  for (const auto &dm : dim_metadata)
  {
    sparsityparam->dim_metadata.emplace_back(luci_dim_type(dm->format), dm->dense_size,
                                             luci_sparse_index_vector(dm->array_segments),
                                             luci_sparse_index_vector(dm->array_indices));
  }
 
  return sparsityparam;
}

References luci_dim_type(), luci_sparse_index_vector(), and must_cast().

Referenced by copy_tensor_attributes(), and luci_sparsityparam().

◆ luci_weights_format()

luci::CircleFullyConnected::WeightsFormat luci::luci_weights_format ( const circle::FullyConnectedOptionsWeightsFormat weights_format )

Definition at line 147 of file CircleReader.cpp.

{
  switch (weights_format)
  {
    case circle::FullyConnectedOptionsWeightsFormat_DEFAULT:
      return luci::CircleFullyConnected::WeightsFormat::DEFAULT;
    case circle::FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8:
      return luci::CircleFullyConnected::WeightsFormat::SHUFFLED4x16INT8;
    case circle::FullyConnectedOptionsWeightsFormat_SHUFFLED16x1FLOAT32:
      return luci::CircleFullyConnected::WeightsFormat::SHUFFLED16x1FLOAT32;
    default:
      throw std::runtime_error("Invalid FullyConnectedOptionsWeightsFormat");
  }
}

References luci::CircleFullyConnected::DEFAULT, luci::CircleFullyConnected::SHUFFLED16x1FLOAT32, and luci::CircleFullyConnected::SHUFFLED4x16INT8.

◆ make_module()

std::unique_ptr< Module > luci::make_module ( void )

Definition at line 44 of file Module.cpp.

44{ return std::make_unique<Module>(); }

◆ make_predefined_qparam() [1/2]

std::unique_ptr< CircleQuantParam > luci::make_predefined_qparam	(	ActivationQType	qtype,
		loco::DataType	dtype,
		CircleQuantParam *	old_quant_param
	)

Definition at line 357 of file QuantizationUtils.cpp.

{
  auto qparam = std::make_unique<CircleQuantParam>();
 
  auto set_qparam = [&qparam, old_quant_param](float scale, int64_t zp) {
    qparam->scale.emplace_back(scale);
    qparam->zerop.emplace_back(zp);
    qparam->min = old_quant_param->min;
    qparam->max = old_quant_param->max;
  };
 
  switch (qtype)
  {
    case ActivationQType::PreDefinedLogistic:
      if (dtype == loco::DataType::U8)
        set_qparam(1.0f / 256.0f, 0);
      else
      {
        assert(dtype == loco::DataType::S16);
        set_qparam(1.0f / 32768.0f, 0);
      }
      break;
    case ActivationQType::PreDefinedTanh:
      if (dtype == loco::DataType::U8)
        set_qparam(2.0f / 256.0f, 128);
      else
      {
        assert(dtype == loco::DataType::S16);
        set_qparam(1.0f / 32768.0f, 0);
      }
      break;
    case ActivationQType::PreDefinedSoftmax:
      if (dtype == loco::DataType::U8)
        set_qparam(1.0f / 255.0f, 0);
      else
      {
        assert(dtype == loco::DataType::S16);
        set_qparam(1.0f / 32767.0f, 0);
      }
      break;
    default:
      throw std::runtime_error("Unsupported opcode with pre-defined qparam");
  }
  return qparam;
}

References must_cast(), PreDefinedLogistic, PreDefinedSoftmax, and PreDefinedTanh.

Referenced by luci::QuantizeSpecialActivation::visit(), luci::QuantizeSpecialActivation::visit(), luci::QuantizeSpecialActivation::visit(), and luci::QuantizeSpecialActivation::visit().

◆ make_predefined_qparam() [2/2]

std::unique_ptr< CircleQuantParam > luci::make_predefined_qparam	(	CircleNode *	node,
		loco::DataType	dtype
	)

◆ makeTfLiteArray()

template<typename T >

sparsity::TfLiteIntArray * luci::makeTfLiteArray ( const std::vector< T > & data )

Definition at line 268 of file SparsityFormatConverter.cpp.

{
  size_t cn = data.size();
  size_t sz = 1 + data.size();
  sparsity::TfLiteIntArray *sp = (sparsity::TfLiteIntArray *)(new int[sz]);
  sp->size = cn;
  for (size_t i = 0; i < cn; ++i)
  {
    sp->data[i] = data[i];
  }
  return sp;
}

References sparsity::TfLiteIntArray::data, makeTfLiteArray(), and sparsity::TfLiteIntArray::size.

Referenced by makeTfLiteArray(), to_tflite_sparsity(), and to_tflite_sparsity().

◆ makeTfLiteDimensionMetadata()

sparsity::TfLiteDimensionMetadata * luci::makeTfLiteDimensionMetadata ( const std::vector< luci::DimMetaData > & data )

Definition at line 282 of file SparsityFormatConverter.cpp.

{
  size_t cn = data.size();
  sparsity::TfLiteDimensionMetadata *tfldm = new sparsity::TfLiteDimensionMetadata[cn];
 
  for (size_t i = 0; i < cn; ++i)
  {
    tfldm[i].format = to_tflite_sparsity(data[i].format());
    tfldm[i].dense_size = data[i].dense_size();
    tfldm[i].array_segments = to_tflite_sparsity(data[i].array_segments());
    tfldm[i].array_indices = to_tflite_sparsity(data[i].array_indices());
  }
 
  return tfldm;
}

References sparsity::TfLiteDimensionMetadata::array_indices, sparsity::TfLiteDimensionMetadata::array_segments, sparsity::TfLiteDimensionMetadata::dense_size, sparsity::TfLiteDimensionMetadata::format, makeTfLiteDimensionMetadata(), and to_tflite_sparsity().

Referenced by makeTfLiteDimensionMetadata(), and to_tflite_sparsity().

◆ max_for_sym_quant()

int32_t luci::max_for_sym_quant ( const loco::DataType & type )

Definition at line 104 of file QuantizationUtils.cpp.

{
  if (type == loco::DataType::S4)
    return std::numeric_limits<int8_t>::max() >> 4;
  else if (type == loco::DataType::S8)
    return std::numeric_limits<int8_t>::max();
  else if (type == loco::DataType::S16)
    return std::numeric_limits<int16_t>::max();
  else
    throw std::runtime_error("Unsupported dtype for symmetric quantization");
};

References type.

Referenced by compute_sym_scale().

◆ merge_pgroups()

std::unique_ptr< luci::PGroups > luci::merge_pgroups ( const luci::PGroups * s_pgroups )

This will merge pgroups with same group values in topological order.

Definition at line 200 of file PartitionMerge.cpp.

{
  // Make a copy of pgroups to apply merge action
  // Q) do we really need a copy?
  auto d_pgroups = s_pgroups->make_copy();
 
  // Merge partition graphs
  // - This is initial implementation that works for limited networks
  // - if A and B is same group -> if A is input of B -> ... -> merge B into A
  auto &pgroups = d_pgroups->pgroups;
  bool changed;
  do
  {
    changed = false;
    for (auto &pgroup_i : pgroups)
    {
      bool merged = false;
      for (auto it = pgroups.begin(); it != pgroups.end(); ++it)
      {
        auto &pgroup = *it;
 
        // skip if same object
        if (pgroup->id == pgroup_i->id)
          continue;
        // skip if different group
        if (pgroup->group != pgroup_i->group)
          continue;
        // skip if not connected
        if (!is_input_of(pgroup_i.get(), pgroup.get()))
          continue;
        // skip if there are multiple inputs but inputs differ in group
        if (!is_input_same(pgroup.get(), d_pgroups.get()))
          continue;
        // skip if pgroup has different group for other users of pgroup_i
        if (!is_output_same(pgroup_i.get(), d_pgroups.get()))
          continue;
        // TODO add more condition may be needed
 
        merge_into(pgroup.get(), pgroup_i.get());
 
        auto eit = d_pgroups->id2pgroup.find(pgroup->id);
        assert(eit != d_pgroups->id2pgroup.end());
        d_pgroups->id2pgroup.erase(eit);
 
        // remove merged pgroup from pgroups
        pgroups.erase(it);
 
        merged = true;
        break;
      }
      if (merged)
      {
        changed = true;
        break;
      }
    }
  } while (changed);
 
  return d_pgroups;
}

References luci::PGroup::group, luci::PGroup::id, must_cast(), and luci::PGroups::pgroups.

Referenced by apply().

◆ must_cast() [1/2]

template<typename T >

T luci::must_cast ( const loco::Node * node )

Definition at line 100 of file CircleNodeDecl.h.

{
  return luci::_must_cast<T, const loco::Node *>(node);
}

References must_cast().

◆ must_cast() [2/2]

template<typename T >

T luci::must_cast ( loco::Node * node )

Examples: /github/workspace/compiler/luci/pass/src/RemoveUnnecessaryTransposeNetPass.cpp, and /github/workspace/compiler/luci/pass/src/SubstituteExpandDimsToReshapePass.cpp.

Definition at line 95 of file CircleNodeDecl.h.

{
  return luci::_must_cast<T, loco::Node *>(node);
}

References must_cast().

◆ opcode_name()

std::string luci::opcode_name ( const CircleNode * node )

Definition at line 66 of file CircleOpCode.cpp.

{
  QueryCircleName qcn;
  auto cname = node->accept(&qcn);
  if (cname != nullptr)
    return std::string(cname);
 
  QueryOpCode qoc;
  auto opcode = node->accept(&qoc);
  auto name = circle::EnumNameBuiltinOperator(opcode);
  return std::string(name);
}

References luci::CircleNode::accept(), and must_cast().

Referenced by dump(), and dump().

◆ output_node()

CircleOutput * luci::output_node	(	loco::Graph *	g,
		const loco::GraphOutputIndex &	index
	)

Find a CircleOutput node with a given output index.

Definition at line 28 of file CircleNodes.cpp.

{
  for (uint32_t n = 0; n < g->nodes()->size(); ++n)
  {
    if (auto output = dynamic_cast<CircleOutput *>(g->nodes()->at(n)))
    {
      if (output->indexed() && output->index() == index)
      {
        return output;
      }
    }
  }
  return nullptr;
}

References must_cast(), and size.

Referenced by change_outputs(), luci_interpreter::Interpreter::getOutputTensorSize(), luci_interpreter::Interpreter::readOutputTensor(), and luci::FuseBCQPass::run().

◆ prepareModelData()

void luci::prepareModelData	(	FlatBufferBuilder &	builder,
		SerializedModelData &	md
	)

one time preparation for SerializedModelData

Definition at line 701 of file CircleTensorExporter.cpp.

{
  md.clear();
 
  // add one empty buffer
  //   note: this follows TFLite
  //   note: there's a comment in tflite fbs file
  //   - Note the 0th entry of this array must be an empty buffer (sentinel).
  //   - This is a convention so that tensors without a buffer can provide 0 as
  //   - their buffer.
  md._empty_buffer = encodeOpBuffer(builder);
  md._buffers.push_back(md._empty_buffer);
}

References luci::SerializedModelData::_buffers, luci::SerializedModelData::_empty_buffer, luci::SerializedModelData::clear(), and must_cast().

◆ produce_pgroups()

std::unique_ptr< luci::PGroups > luci::produce_pgroups	(	const luci::Module *	source,
		const luci::PartitionTable &	partition
	)

This will produce a PGroups from Module and PartitionTable.

Note: Each PGroup will hold one CircleNode and partition key value as group. Supports only single Graph in the Module for now.

Definition at line 225 of file PartitionPGroups.cpp.

{
  assert(source != nullptr);
  // NOTE Only main graph (subgraph index 0) will be partitioned.
  // Other subgraphs will follow the owner (IF/WHILE/...) group
 
  LOGGER(l);
 
  auto pgroups = std::make_unique<luci::PGroups>();
 
  pgroups->default_group = partition.default_group;
 
  // Create a PGroup per CircleNode: each PGroup will have one CircleNode
  auto graph = source->graph();
  auto nodes = graph->nodes();
  for (uint32_t idx = 0; idx < nodes->size(); ++idx)
  {
    auto node = loco::must_cast<luci::CircleNode *>(nodes->at(idx));
 
    // check if node is normal node that we are interested
    if (check_allocate_partition(node))
    {
      auto group = group_from_partition(node, partition);
 
      append(node, pgroups.get(), group, idx);
    }
    else
    {
      INFO(l) << "Skip Op: " << node->name() << std::endl;
      // record as default group
      pgroups->node2group[node] = partition.default_group;
    }
  }
 
  return pgroups;
}

References luci::PGroups::default_group, luci::Module::graph(), INFO, LOGGER, loco::must_cast(), must_cast(), luci::CircleNode::name(), and luci::PGroups::node2group.

Referenced by apply().

◆ produce_pmodules()

luci::PartedModules luci::produce_pmodules ( const luci::PGroups * pgroups )

This will produce list of luci::Module as PartedModules from pgroups.

Definition at line 376 of file PartitionPModules.cpp.

{
  LOGGER(l);
 
  luci::PartedModules pms;
 
  for (auto &pgroup : pgroups->pgroups)
  {
    luci::PartedModule pm;
    pm.module = std::make_unique<luci::Module>();
    pm.group = pgroup->group;
 
    // the main graph for this module
    auto graph = loco::make_graph();
    auto graph_ptr = graph.get();
 
    auto graph_name = make_name(pgroup.get());
    graph->name(graph_name);
 
    // Add main graph so that other subgraphs can be added inside build_graph
    pm.module->add(std::move(graph));
 
    INFO(l) << "--- Partition Graph build----------------------";
    INFO(l) << "--- name: " << graph_name;
    build_graph(pm, graph_ptr, pgroup.get());
 
    pms.pmodules.emplace_back(std::move(pm));
  }
 
  return pms;
}

References luci::PGroup::group, INFO, LOGGER, loco::make_graph(), must_cast(), and luci::PGroups::pgroups.

Referenced by apply().

◆ propagate_concat_quantparam()

void luci::propagate_concat_quantparam ( luci::CircleConcatenation * concat )

BEFORE

   [CircleNode]             [CircleConst]
   (U8 qparam1)                 (FP32)
             \                    /
              \                  /
              [CircleConcatenation]
                  (U8 qparam2)

AFTER [CircleNode] [CircleConst] [CircleConst] <- Dead node (U8 qparam2) (U8 qparam2) (FP32) \ / \ / [CircleConcatenation] (U8 qparam2)

Definition at line 290 of file PropagateQParamBackwardPass.cpp.

{
  assert(concat->quantparam() != nullptr);
 
  const auto num_inputs = concat->numValues();
 
  // Quantize const inputs using their values if concat has fused act function
  if (concat->fusedActivationFunction() != luci::FusedActFunc::NONE)
  {
    for (uint32_t i = 0; i < num_inputs; i++)
    {
      auto node = concat->arg(i);
      auto const_node = dynamic_cast<luci::CircleConst *>(node);
      if (const_node != nullptr)
      {
        auto new_const = luci::clone(const_node);
        quant_const(new_const, concat->dtype());
        concat->values(i, new_const);
      }
    }
    return;
  }
 
  for (uint32_t i = 0; i < num_inputs; i++)
  {
    auto node = loco::must_cast<luci::CircleNode *>(concat->arg(i));
 
    // Quantize constant values
    if (node->opcode() == luci::CircleOpcode::CIRCLECONST)
    {
      luci::CircleConst *const_node = luci::must_cast<luci::CircleConst *>(node);
 
      const auto concat_qparam = concat->quantparam();
      assert(concat_qparam->scale.size() == 1);
      const auto scaling_factor = concat_qparam->scale[0];
      const auto zerop = concat_qparam->zerop[0];
 
      auto new_const = luci::clone(const_node);
      quant_const_values(new_const, scaling_factor, zerop, concat->dtype());
      concat->values(i, new_const);
      overwrite_quantparam(concat, new_const);
    }
    else
    {
      const auto succs = loco::succs(node);
      if (succs.size() > 1)
        continue;
 
      overwrite_quantparam(concat, node);
    }
  }
}

References clone(), loco::must_cast(), must_cast(), NONE, quant_const(), and loco::succs().

◆ propagate_pad_v2_quantparam()

void luci::propagate_pad_v2_quantparam ( luci::CirclePadV2 * pad_v2 )

BEFORE

   [CircleNode] [CircleConst] [CircleConst]
   (U8 qparam1)     (S32)       (FP32)
             \        |         /
              \       |        /
                [CirclePadV2]
                 (U8 qparam2)

AFTER (case 1)

By default qparam is propagated from output to inputs to meet backend requirements.

   [CircleNode] [CircleConst] [CircleConst]   [CircleConst] <- Dead node
   (U8 qparam2)     (S32)      (U8 qparam2)       (FP32)
             \        |         /
              \       |        /
                [CirclePadV2]
                 (U8 qparam2)

AFTER (case 2)

In case padded value is the lowest float value Qparam is propagated from input to output and constant.

This is a special case for optimization constructed pad, needed to guarantee that extremely large negative constant do not stretch output quantization range.

    [CircleNode] [CircleConst] [CircleConst]   [CircleConst] <- Dead node
    (U8 qparam1)     (S32)      (U8 qparam1)       (FP32)
              \        |         /
               \       |        /
                 [CirclePadV2]
                  (U8 qparam1)

Definition at line 378 of file PropagateQParamBackwardPass.cpp.

{
  if (ignore_pad_v2_const_quantization(pad_v2))
  {
    // propagate input quantization paramters from input to output and padding const value
    auto pad_v2_input = loco::must_cast<luci::CircleNode *>(pad_v2->arg(0));
    overwrite_quantparam(pad_v2_input, pad_v2);
 
    auto const_value_node = luci::must_cast<luci::CircleConst *>(
      pad_v2->arg(2)); // FIX ignore_pad_v2_const_quantization UNLESS
    auto new_const = luci::clone(const_value_node);
 
    const auto pad_v2_input_qparam = pad_v2_input->quantparam();
    assert(pad_v2_input_qparam != nullptr);
    assert(pad_v2_input_qparam->scale.size() == 1);
    const auto scaling_factor = pad_v2_input_qparam->scale.at(0);
    const auto zerop = pad_v2_input_qparam->zerop.at(0);
 
    quant_const_values(new_const, scaling_factor, zerop, pad_v2->dtype());
    overwrite_quantparam(pad_v2_input, new_const);
    pad_v2->constant_values(new_const);
    return;
  }
 
  // Propagate quantization paramters from output to inputs,
  // to fit both input and counstant_value in one quant range.
  auto quant_input = [pad_v2](void (CirclePadV2::*arg_setter)(loco::Node *), uint32_t arg) {
    auto node = loco::must_cast<luci::CircleNode *>(pad_v2->arg(arg));
 
    // Quantize constant values
    if (node->opcode() == luci::CircleOpcode::CIRCLECONST)
    {
      luci::CircleConst *const_node = luci::must_cast<luci::CircleConst *>(node);
      if (is_quantized(const_node))
        return;
 
      if (const_node->dtype() != loco::DataType::FLOAT32)
        throw std::runtime_error("Unsupported data type for constant input of PadV2 Op");
 
      const auto pad_v2_qparam = pad_v2->quantparam();
      if (pad_v2_qparam == nullptr)
        throw std::runtime_error("quantparam of PadV2 is not found during propagation");
 
      assert(pad_v2_qparam->scale.size() == 1);
      const auto scaling_factor = pad_v2_qparam->scale.at(0);
      const auto zerop = pad_v2_qparam->zerop.at(0);
 
      auto new_const = luci::clone(const_node);
      quant_const_values(new_const, scaling_factor, zerop, pad_v2->dtype());
      overwrite_quantparam(pad_v2, new_const);
      (pad_v2->*arg_setter)(new_const);
    }
    else
    {
      const auto succs = loco::succs(node);
      if (succs.size() > 1)
        return;
 
      overwrite_quantparam(pad_v2, node);
    }
  };
 
  quant_input(&CirclePadV2::input, 0);
  quant_input(&CirclePadV2::constant_values, 2);
}

References clone(), luci::CirclePadV2::constant_values(), luci::CirclePadV2::input(), is_quantized(), loco::must_cast(), must_cast(), and loco::succs().

◆ quant_const()

void luci::quant_const	(	luci::CircleConst *	node,
		loco::DataType	quant_type
	)

Definition at line 418 of file QuantizationUtils.cpp.

{
  assert(node->dtype() == loco::DataType::FLOAT32);
 
  check_quant_unfriendly_values(node);
 
  float min = std::numeric_limits<float>::max();
  float max = std::numeric_limits<float>::lowest();
  for (uint32_t i = 0; i < node->size<loco::DataType::FLOAT32>(); i++)
  {
    auto data = node->at<loco::DataType::FLOAT32>(i);
    min = data < min ? data : min;
    max = data > max ? data : max;
  }
 
  float scaling_factor{0.0};
  int64_t zp{0};
  float nudged_min{0.0};
  float nudged_max{0.0};
 
  switch (quant_type)
  {
    case loco::DataType::U8:
      asymmetric_wquant_with_minmax_per_layer(node, min, max, scaling_factor, zp, nudged_min,
                                              nudged_max);
      break;
    case loco::DataType::S16:
      symmetric_wquant_with_minmax_per_layer(node, min, max, scaling_factor, nudged_min,
                                             nudged_max);
      break;
    default:
      throw std::runtime_error("Unsupported data type");
  }
 
  auto quantparam = std::make_unique<luci::CircleQuantParam>();
  quantparam->scale.push_back(scaling_factor);
  quantparam->zerop.push_back(zp);
  // Copy min and max values if it exists
  if (node->quantparam())
  {
    quantparam->min = node->quantparam()->min;
    quantparam->max = node->quantparam()->max;
  }
  node->quantparam(std::move(quantparam));
}

References asymmetric_wquant_with_minmax_per_layer(), luci::CircleConst::at(), check_quant_unfriendly_values(), flatbuffers::data(), luci::CircleQuantParam::max, luci::CircleQuantParam::min, must_cast(), luci::CircleNode::quantparam(), luci::CircleConst::size(), and symmetric_wquant_with_minmax_per_layer().

Referenced by propagate_concat_quantparam().

◆ REGISTER_WRAPPER() [1/8]

luci::REGISTER_WRAPPER ( flatbuffers::Offset< circle::Buffer > )

◆ REGISTER_WRAPPER() [2/8]

luci::REGISTER_WRAPPER ( flatbuffers::Offset< circle::Metadata > )

◆ REGISTER_WRAPPER() [3/8]

luci::REGISTER_WRAPPER ( flatbuffers::Offset< circle::Operator > )

◆ REGISTER_WRAPPER() [4/8]

luci::REGISTER_WRAPPER ( flatbuffers::Offset< circle::OperatorCode > )

◆ REGISTER_WRAPPER() [5/8]

luci::REGISTER_WRAPPER ( flatbuffers::Offset< circle::SubGraph > )

◆ REGISTER_WRAPPER() [6/8]

luci::REGISTER_WRAPPER ( flatbuffers::Offset< circle::Tensor > )

◆ REGISTER_WRAPPER() [7/8]

luci::REGISTER_WRAPPER ( int32_t )

◆ REGISTER_WRAPPER() [8/8]

luci::REGISTER_WRAPPER ( uint8_t )

◆ remove_unused_inputoutputs()

void luci::remove_unused_inputoutputs	(	luci::PGroups *	pgroups,
		const luci::Module *	source
	)

This will remove unused inputs/outputs in each pgroup of pgroups.

Definition at line 67 of file PartitionCleanup.cpp.

{
  assert(source != nullptr);
  assert(pgroups != nullptr);
 
  LOGGER(l);
 
  INFO(l) << "--- Cleanup unused inputs/outputs";
 
  // remove input within same pgroup
  for (auto &pgroup : pgroups->pgroups)
  {
    bool changed;
    do
    {
      changed = false;
      for (auto it = pgroup->inputs.begin(); it != pgroup->inputs.end(); ++it)
      {
        auto input = *it;
        if (pgroups->pgroup_of(input) == pgroup.get())
        {
          INFO(l) << "  Cleanup input " << input->name() << " from group " << pgroup->group;
          pgroup->inputs.erase(it);
          changed = true;
          break;
        }
        // NOTE CircleConst is one of input type, as they are registered as
        //      input to some node and then (should be) merged.
        //      Remove if this input is CircleConst
        if (dynamic_cast<CircleConst *>(input) != nullptr)
        {
          INFO(l) << "  Cleanup CircleConst " << input->name() << " from group " << pgroup->group;
          pgroup->inputs.erase(it);
          changed = true;
          break;
        }
      }
    } while (changed);
  }
 
  // remove unused output(s)
  // 'used_outputs' will hold actual used outputs for all PGroups
  CircleNodes used_outputs;
 
  gather_graph_outputs(used_outputs, source);
  gather_pgroups_outputs(used_outputs, pgroups);
 
  for (auto &pgroup : pgroups->pgroups)
  {
    bool changed;
    do
    {
      changed = false;
      for (auto it = pgroup->outputs.begin(); it != pgroup->outputs.end(); ++it)
      {
        auto output = *it;
        auto oit = std::find(used_outputs.begin(), used_outputs.end(), output);
        if (oit == used_outputs.end())
        {
          INFO(l) << "  Cleanup output " << output->name() << " from group " << pgroup->group;
          pgroup->outputs.erase(it);
          changed = true;
          break;
        }
      }
    } while (changed);
  }
}

References INFO, LOGGER, must_cast(), luci::PGroups::pgroup_of(), and luci::PGroups::pgroups.

Referenced by apply().

◆ set_int_scale()

void luci::set_int_scale ( luci::CircleNode * node )

Definition at line 406 of file QuantizationUtils.cpp.

{
  assert(node); // FIX_CALLER_UNLESS
 
  auto qparam = node->quantparam();
  assert(qparam);                    // FIX_CALLER_UNLESS
  assert(qparam->scale.size() == 1); // FIX_CALLER_UNLESS
 
  auto fp_scale = qparam->scale[0];
  qparam->scale[0] = fp_scale < 1 ? 1.0f : std::round(fp_scale);
}

References must_cast(), and luci::CircleNode::quantparam().

Referenced by luci::QuantizeSpecialActivation::visit(), luci::QuantizeSpecialActivation::visit(), luci::QuantizeSpecialActivation::visit(), and luci::QuantizeSpecialActivation::visit().

◆ set_node_id()

void luci::set_node_id	(	luci::CircleNode *	circle_node,
		luci::CircleNodeID	id
	)

Definition at line 59 of file CircleNodeID.cpp.

{
  circle_node->annot<CircleNodeIDAnnotation>(nullptr);
  circle_node->annot(std::make_unique<CircleNodeIDAnnotation>(id));
}

References must_cast().

◆ set_tensor_index()

void luci::set_tensor_index	(	loco::Node *	node,
		const CircleTensorIndex &	tensor_id
	)

Definition at line 308 of file CircleExporterUtils.cpp.

{
  assert(node->annot<CircleTensorIndexAnnotation>() == nullptr);
  node->annot(std::make_unique<CircleTensorIndexAnnotation>(tensor_id));
}

References loco::AnnotatedItem< Annotation >::annot(), and must_cast().

◆ shape_get()

loco::NodeShape luci::shape_get ( const loco::Node * node )

Definition at line 124 of file CircleShapeInferenceHelper.cpp.

{
  assert(luci::shape_known(node));
  return loco::NodeShape{sinf::circle_shape(loco::must_cast<const luci::CircleNode *>(node))};
}

References luci::sinf::circle_shape(), loco::must_cast(), and shape_known().

Referenced by luci::sinf::Algorithm::visit().

◆ shape_known()

bool luci::shape_known ( const loco::Node * node )

Definition at line 130 of file CircleShapeInferenceHelper.cpp.

{
  return loco::must_cast<const luci::CircleNode *>(node)->shape_status() !=
         luci::ShapeStatus::UNDEFINED;
}

References loco::must_cast(), and UNDEFINED.

Referenced by shape_get().

◆ single_origin()

std::shared_ptr< CircleNodeOrigin > luci::single_origin	(	uint32_t	id,
		const std::string &	name
	)

Definition at line 120 of file CircleNodeOrigin.cpp.

{
  return std::make_shared<SingleOrigin>(id, name);
}

Referenced by luci::CircleImportMetadata::origin_table().

◆ size()

uint32_t luci::size ( loco::DataType data_type )

inline

Returns the size of the data type.

Note: luci saves S4, U4 in a single byte. The extra 4 bits in the MSB side are filled with sign bits.

Definition at line 31 of file DataTypeHelper.h.

{
  switch (data_type)
  {
    case loco::DataType::S4:
      return sizeof(loco::DataTypeImpl<loco::DataType::S4>::Type);
    case loco::DataType::U4:
      return sizeof(loco::DataTypeImpl<loco::DataType::U4>::Type);
    default:
      return loco::size(data_type);
  }
}

References loco::size().

Referenced by luci_interpreter_pal::BroadcastTo(), mpqsolver::core::MAEMetric::compute(), circle_planner::ScratchpadHelperLinux::ComputeScratchpadSizeBatchMatMul(), entry(), luci_interpreter::getDataTypeSize(), circle_eval_diff::getEachByteSizeOf(), record_minmax::getTensorSize(), and circle_eval_diff::getTotalByteSizeOf().

◆ SparsifyTensorPass::sparsify_tensor< loco::DataType::FLOAT32 >()

template void luci::SparsifyTensorPass::sparsify_tensor< loco::DataType::FLOAT32 > ( luci::CircleConst * cop )

extern

Referenced by luci::SparsifyTensorPass::run().

◆ SparsifyTensorPass::sparsify_tensor< loco::DataType::S32 >()

template void luci::SparsifyTensorPass::sparsify_tensor< loco::DataType::S32 > ( luci::CircleConst * cop )

extern

Referenced by luci::SparsifyTensorPass::run().

◆ SparsifyTensorPass::sparsify_tensor< loco::DataType::S8 >()

template void luci::SparsifyTensorPass::sparsify_tensor< loco::DataType::S8 > ( luci::CircleConst * cop )

extern

Referenced by luci::SparsifyTensorPass::run().

◆ str_to_dtype()

loco::DataType luci::str_to_dtype ( const std::string & str )

Definition at line 47 of file Strings.cpp.

{
  if (to_lower_case(str).compare("uint4") == 0)
    return loco::DataType::U4;
  if (to_lower_case(str).compare("uint8") == 0)
    return loco::DataType::U8;
  if (to_lower_case(str).compare("uint16") == 0)
    return loco::DataType::U16;
  if (to_lower_case(str).compare("uint32") == 0)
    return loco::DataType::U32;
  if (to_lower_case(str).compare("uint64") == 0)
    return loco::DataType::U64;
 
  if (to_lower_case(str).compare("int4") == 0)
    return loco::DataType::S4;
  if (to_lower_case(str).compare("int8") == 0)
    return loco::DataType::S8;
  if (to_lower_case(str).compare("int16") == 0)
    return loco::DataType::S16;
  if (to_lower_case(str).compare("int32") == 0)
    return loco::DataType::S32;
  if (to_lower_case(str).compare("int64") == 0)
    return loco::DataType::S64;
 
  if (to_lower_case(str).compare("float16") == 0)
    return loco::DataType::FLOAT16;
  if (to_lower_case(str).compare("float32") == 0)
    return loco::DataType::FLOAT32;
  if (to_lower_case(str).compare("float64") == 0)
    return loco::DataType::FLOAT64;
 
  if (to_lower_case(str).compare("bool") == 0)
    return loco::DataType::BOOL;
 
  return loco::DataType::Unknown;
}

References to_lower_case().

◆ str_to_granularity()

QuantizationGranularity luci::str_to_granularity ( const std::string & str )

Definition at line 93 of file Strings.cpp.

{
  if (to_lower_case(str).compare("layer") == 0)
    return QuantizationGranularity::LayerWise;
 
  if (to_lower_case(str).compare("channel") == 0)
    return QuantizationGranularity::ChannelWise;
 
  throw std::runtime_error("Quantization granularity must be either 'layer' or 'channel'");
}

References ChannelWise, LayerWise, and to_lower_case().

◆ str_vec_to_dtype_vec()

std::vector< loco::DataType > luci::str_vec_to_dtype_vec ( std::vector< std::string > & vec )

Definition at line 85 of file Strings.cpp.

{
  std::vector<loco::DataType> res;
  std::transform(vec.begin(), vec.end(), std::back_inserter(res),
                 [](std::string s) -> loco::DataType { return str_to_dtype(to_lower_case(s)); });
  return res;
}

References must_cast().

◆ swap_mul_add()

bool luci::swap_mul_add	(	luci::CircleAdd *	add,
		std::vector< luci::CircleMul * > &	mul_list,
		std::vector< luci::CircleAdd * > &	add_list
	)

Swap MUL/ADD if they are from batch normalization

BEFORE [Mul] gamma | [Add + Relu] beta

AFTER [Add] beta/gamma | [Mul] gamma | [Relu]

Returns: true if success

Definition at line 499 of file FusePreActivationBatchNormPass.cpp.

{
  luci::CircleNode *pred_node = nullptr;
  luci::CircleMul *mul = nullptr;
  luci::CircleConst *beta = nullptr;
  luci::CircleConst *gamma = nullptr;
 
  if (!is_batchnorm_add(add, mul, beta))
    return false;
  if (add->fusedActivationFunction() != luci::FusedActFunc::RELU)
    return false;
 
  if (loco::succs(mul).size() != 1)
    return false;
 
  if (!is_batchnorm_mul(mul, pred_node, gamma))
    return false;
 
  if (beta->dtype() != loco::DataType::FLOAT32 || gamma->dtype() != loco::DataType::FLOAT32)
    throw std::runtime_error("FusePreActivationBatchNormPass only supports Float32 model");
 
  if (!is_non_negative(gamma))
    return false;
 
  // Insert Relu at the bottom
  auto name = add->name();
  assert(name.length() > 0);
 
  auto relu = add->graph()->nodes()->create<luci::CircleRelu>();
  relu->features(mul);
  relu->name(name + "/Relu");
  luci::add_origin(relu, luci::get_origin(add));
  loco::replace(add).with(relu);
 
  // Replace beta <- beta / gamma
  if (add->x() == beta)
  {
    add->y(pred_node);
  }
  else
  {
    add->x(pred_node);
  }
  add->fusedActivationFunction(luci::FusedActFunc::NONE);
  uint32_t size = beta->size<loco::DataType::FLOAT32>();
  for (uint32_t i = 0; i < size; ++i)
  {
    auto b = beta->at<loco::DataType::FLOAT32>(i);
    auto g = gamma->at<loco::DataType::FLOAT32>(i);
    if (b == g)
    {
      beta->at<loco::DataType::FLOAT32>(i) = 1;
    }
    else
    {
      // If g is 0, we use a small value (empirically determined)
      if (g == 0)
        g = 1e-10;
      beta->at<loco::DataType::FLOAT32>(i) = b / g;
    }
  }
 
  if (mul->x() == gamma)
  {
    mul->y(add);
  }
  else
  {
    mul->x(add);
  }
 
  mul_list.push_back(mul);
  add_list.push_back(add);
 
  return true;
}

References luci::CircleConst::at(), is_batchnorm_add(), is_batchnorm_mul(), must_cast(), NONE, RELU, loco::replace(), luci::CircleConst::size(), size, loco::succs(), and loco::Subst< SubstQualifier::Default >::with().

Referenced by luci::FusePreActivationBatchNormPass::run().

◆ symmetric_wquant_with_minmax_per_layer()

void luci::symmetric_wquant_with_minmax_per_layer	(	CircleConst *	node,
		float	min,
		float	max,
		float &	scaling_factor,
		float &	nudged_min,
		float &	nudged_max
	)

Definition at line 75 of file QuantizationUtils.cpp.

{
  const int32_t kMaxScale = std::numeric_limits<int16_t>::max();
  const int32_t kMinScale = -kMaxScale;
 
  uint32_t size = node->size<loco::DataType::FLOAT32>();
  compute_sym_scale(min, max, scaling_factor, nudged_min, nudged_max);
  const float scaling_factor_inv = 1.0 / scaling_factor;
  std::vector<int32_t> quantized_values(size);
  for (uint32_t i = 0; i < size; ++i)
  {
    // clipping
    auto data = node->at<loco::DataType::FLOAT32>(i);
    data = data < nudged_min ? nudged_min : data;
    data = data > nudged_max ? nudged_max : data;
    quantized_values[i] = static_cast<int32_t>(std::round(data * scaling_factor_inv));
  }
 
  node->dtype(loco::DataType::S16);      // change the type of tensor
  node->size<loco::DataType::S16>(size); // resize tensor
  for (uint32_t i = 0; i < size; ++i)
  {
    node->at<loco::DataType::S16>(i) =
      std::min(kMaxScale, std::max(kMinScale, quantized_values[i]));
  }
}

References luci::CircleConst::at(), compute_sym_scale(), flatbuffers::data(), must_cast(), luci::CircleConst::size(), and size.

Referenced by quant_const().

◆ tensor_name()

const char * luci::tensor_name ( const circle::Tensor * tensor )

Definition at line 29 of file CircleReader.cpp.

{
  assert(tensor != nullptr);
 
  if (tensor->name() == nullptr || std::string(tensor->name()->c_str()).empty())
    return "(noname)";
 
  return tensor->name()->c_str();
}

Referenced by luci::GraphBuilderMultiOutput::build(), luci::CircleWhileGraphBuilder::build(), copy_tensor_attributes(), luci::CircleOptimizer::sparsify(), luci::CircleCastGraphBuilder::validate(), luci::CircleGreaterGraphBuilder::validate(), and luci::CircleUnpackGraphBuilder::validate().

◆ tensor_quantization()

const circle::QuantizationParameters * luci::tensor_quantization ( const circle::Tensor * tensor )

Definition at line 39 of file CircleReader.cpp.

{
  assert(tensor != nullptr);
  return tensor->quantization();
}

◆ to_circle_actfunc()

circle::ActivationFunctionType luci::to_circle_actfunc ( luci::FusedActFunc func )

Definition at line 28 of file CircleExporterUtils.cpp.

{
  switch (func)
  {
    case luci::FusedActFunc::NONE:
      return circle::ActivationFunctionType_NONE;
    case luci::FusedActFunc::RELU:
      return circle::ActivationFunctionType_RELU;
    case luci::FusedActFunc::RELU_N1_TO_1:
      return circle::ActivationFunctionType_RELU_N1_TO_1;
    case luci::FusedActFunc::RELU6:
      return circle::ActivationFunctionType_RELU6;
    case luci::FusedActFunc::TANH:
      return circle::ActivationFunctionType_TANH;
    case luci::FusedActFunc::SIGN_BIT:
      return circle::ActivationFunctionType_SIGN_BIT;
    default:
      INTERNAL_EXN_V("trying to convert unsupported luci::FusedActFunc", oops::to_uint32(func));
  }
}

References INTERNAL_EXN_V, NONE, RELU, RELU6, RELU_N1_TO_1, SIGN_BIT, TANH, and oops::to_uint32().

◆ to_circle_dimensiontype()

circle::DimensionType luci::to_circle_dimensiontype ( luci::DimensionType type )

Definition at line 132 of file CircleExporterUtils.cpp.

{
  switch (type)
  {
    case luci::DimensionType::DENSE:
      return circle::DimensionType_DENSE;
    case luci::DimensionType::SPARSE_CSR:
      return circle::DimensionType_SPARSE_CSR;
    default:
      INTERNAL_EXN_V("trying to convert unsupported luci::DimensionType", oops::to_uint32(type));
  }
}

References DENSE, INTERNAL_EXN_V, SPARSE_CSR, oops::to_uint32(), and type.

◆ to_circle_mirrorpadmode()

circle::MirrorPadMode luci::to_circle_mirrorpadmode ( luci::MirrorPadMode mode )

Definition at line 90 of file CircleExporterUtils.cpp.

{
  switch (mode)
  {
    case luci::MirrorPadMode::REFLECT:
      return circle::MirrorPadMode::MirrorPadMode_REFLECT;
    case luci::MirrorPadMode::SYMMETRIC:
      return circle::MirrorPadMode::MirrorPadMode_SYMMETRIC;
    default:
      INTERNAL_EXN_V("trying to convert unsupported luci::MirrorPadMode", oops::to_uint32(mode));
  }
}

References INTERNAL_EXN_V, REFLECT, SYMMETRIC, and oops::to_uint32().

Referenced by luci::BuiltinOptionsExtractor::visit().

◆ to_circle_rope()

circle::RoPEMode luci::to_circle_rope ( luci::RoPEMode mode )

Definition at line 103 of file CircleExporterUtils.cpp.

{
  switch (mode)
  {
    case luci::RoPEMode::GPT_NEOX:
      return circle::RoPEMode::RoPEMode_GPT_NEOX;
    case luci::RoPEMode::GPT_J:
      return circle::RoPEMode::RoPEMode_GPT_J;
    default:
      INTERNAL_EXN_V("trying to convert unsupported luci::RoPEMode", oops::to_uint32(mode));
  }
}

References GPT_J, GPT_NEOX, INTERNAL_EXN_V, and oops::to_uint32().

Referenced by luci::BuiltinOptionsExtractor::visit().

◆ to_circle_sparse_index_vector()

flatbuffers::Offset< void > luci::to_circle_sparse_index_vector	(	flatbuffers::FlatBufferBuilder &	fb,
		const SparseIndexVector &	sparse_idx_vec
	)

Definition at line 145 of file CircleExporterUtils.cpp.

{
  auto type = sparse_idx_vec.type();
  switch (type)
  {
    case luci::SparseIndexVectorType::NONE:
      return flatbuffers::Offset<void>();
    case luci::SparseIndexVectorType::I32:
    {
      return circle::CreateInt32VectorDirect(fb, sparse_idx_vec.as_int32_vector()).Union();
    }
    case luci::SparseIndexVectorType::U16:
    {
      return circle::CreateUint16VectorDirect(fb, sparse_idx_vec.as_uint16_vector()).Union();
    }
    case luci::SparseIndexVectorType::U8:
    {
      return circle::CreateUint8VectorDirect(fb, sparse_idx_vec.as_uint8_vector()).Union();
    }
    default:
      INTERNAL_EXN_V("trying to convert unsupported luci::SparseIndexVectorType",
                     oops::to_uint32(type));
  }
}

References I32, INTERNAL_EXN_V, must_cast(), NONE, oops::to_uint32(), type, U16, and U8.

◆ to_circle_sparse_index_vector_type()

circle::SparseIndexVector luci::to_circle_sparse_index_vector_type ( luci::SparseIndexVectorType type )

Definition at line 171 of file CircleExporterUtils.cpp.

{
  switch (type)
  {
    case luci::SparseIndexVectorType::NONE:
      return circle::SparseIndexVector_NONE;
    case luci::SparseIndexVectorType::I32:
      return circle::SparseIndexVector_Int32Vector;
    case luci::SparseIndexVectorType::U16:
      return circle::SparseIndexVector_Uint16Vector;
    case luci::SparseIndexVectorType::U8:
      return circle::SparseIndexVector_Uint8Vector;
    default:
      INTERNAL_EXN_V("trying to convert unsupported luci::SparseIndexVectorType",
                     oops::to_uint32(type));
  }
}

References I32, INTERNAL_EXN_V, NONE, oops::to_uint32(), type, U16, and U8.

◆ to_circle_tensortype()

circle::TensorType luci::to_circle_tensortype ( loco::DataType type )

Definition at line 49 of file CircleExporterUtils.cpp.

{
  switch (type)
  {
    case loco::DataType::U4:
      return circle::TensorType_UINT4;
    case loco::DataType::U8:
      return circle::TensorType_UINT8;
 
    case loco::DataType::S4:
      return circle::TensorType_INT4;
    case loco::DataType::S8:
      return circle::TensorType_INT8;
    case loco::DataType::S16:
      return circle::TensorType_INT16;
    case loco::DataType::S32:
      return circle::TensorType_INT32;
    case loco::DataType::S64:
      return circle::TensorType_INT64;
 
    case loco::DataType::FLOAT16:
      return circle::TensorType_FLOAT16;
    case loco::DataType::FLOAT32:
      return circle::TensorType_FLOAT32;
 
    case loco::DataType::BOOL:
      return circle::TensorType_BOOL;
 
    case loco::DataType::STRING:
      return circle::TensorType_STRING;
 
    case loco::DataType::MXFP4:
      return circle::TensorType_MXFP4;
    case loco::DataType::MXINT8:
      return circle::TensorType_MXINT8;
 
    default:
      INTERNAL_EXN_V("failed to convert unsupported loco::DataType", oops::to_uint32(type));
  }
}

References INTERNAL_EXN_V, oops::to_uint32(), and type.

Referenced by luci::BuiltinOptionsExtractor::visit(), luci::BuiltinOptionsExtractor::visit(), luci::BuiltinOptionsExtractor::visit(), luci::BuiltinOptionsExtractor::visit(), and luci::BuiltinOptionsExtractor::visit().

◆ to_circle_weightsformat()

circle::FullyConnectedOptionsWeightsFormat luci::to_circle_weightsformat ( luci::CircleFullyConnected::WeightsFormat format )

Definition at line 117 of file CircleExporterUtils.cpp.

{
  switch (format)
  {
    case luci::CircleFullyConnected::WeightsFormat::DEFAULT:
      return circle::FullyConnectedOptionsWeightsFormat_DEFAULT;
    case luci::CircleFullyConnected::WeightsFormat::SHUFFLED4x16INT8:
      return circle::FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8;
    case luci::CircleFullyConnected::WeightsFormat::SHUFFLED16x1FLOAT32:
      return circle::FullyConnectedOptionsWeightsFormat_SHUFFLED16x1FLOAT32;
    default:
      INTERNAL_EXN_V("trying to convert unsupported luci::WeightsFormat", oops::to_uint32(format));
  }
}

References luci::CircleFullyConnected::DEFAULT, INTERNAL_EXN_V, luci::CircleFullyConnected::SHUFFLED16x1FLOAT32, luci::CircleFullyConnected::SHUFFLED4x16INT8, and oops::to_uint32().

Referenced by luci::BuiltinOptionsExtractor::visit().

◆ to_compute() [1/2]

bool luci::to_compute	(	const FusedActFunc	act,
		compute::FusedActFunc &	act_func
	)

Definition at line 40 of file Compute.cpp.

{
  switch (act)
  {
    case FusedActFunc::NONE:
      act_func = compute::FusedActFunc::NONE;
      break;
 
    case FusedActFunc::TANH:
      act_func = compute::FusedActFunc::TANH;
      break;
 
    case FusedActFunc::RELU:
      act_func = compute::FusedActFunc::RELU;
      break;
 
    case FusedActFunc::RELU_N1_TO_1:
      act_func = compute::FusedActFunc::RELU_N1_TO_1;
      break;
 
    case FusedActFunc::RELU6:
      act_func = compute::FusedActFunc::RELU6;
      break;
 
    default:
      return false;
  }
  return true;
}

References must_cast(), luci::compute::NONE, NONE, luci::compute::RELU, RELU, luci::compute::RELU6, RELU6, luci::compute::RELU_N1_TO_1, RELU_N1_TO_1, luci::compute::TANH, and TANH.

◆ to_compute() [2/2]

bool luci::to_compute	(	const Padding	padding,
		compute::PaddingType &	padding_type
	)

Definition at line 22 of file Compute.cpp.

{
  switch (padding)
  {
    case Padding::SAME:
      padding_type = compute::PaddingType::kSame;
      break;
 
    case Padding::VALID:
      padding_type = compute::PaddingType::kValid;
      break;
 
    default:
      return false;
  }
  return true;
}

References luci::compute::kSame, luci::compute::kValid, SAME, and VALID.

◆ to_lower_case()

std::string luci::to_lower_case ( std::string s )

Definition at line 41 of file Strings.cpp.

{
  std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });
  return s;
}

References must_cast().

Referenced by str_to_dtype(), and str_to_granularity().

◆ to_shape_description() [1/3]

ShapeDescription luci::to_shape_description ( const loco::NodeShape & shape )

Definition at line 56 of file ShapeDescription.cpp.

{
  switch (shape.domain())
  {
    case loco::Domain::Tensor:
      return to_shape_description(shape.as<loco::TensorShape>());
    default:
      break;
  }
 
  INTERNAL_EXN_V("Unsupported loco domain", oops::to_uint32(shape.domain()));
}

References loco::NodeShape::as(), loco::NodeShape::domain(), INTERNAL_EXN_V, loco::Tensor, to_shape_description(), and oops::to_uint32().

◆ to_shape_description() [2/3]

ShapeDescription luci::to_shape_description ( const loco::TensorShape & shape )

Definition at line 39 of file ShapeDescription.cpp.

{
  ShapeDescription res;
 
  res._rank_known = true;
 
  res._dims.resize(shape.rank());
  for (uint32_t axis = 0; axis < shape.rank(); ++axis)
  {
    // All the dimensions SHOULD be known
    assert(shape.dim(axis).known());
    res._dims.at(axis) = shape.dim(axis).value();
  }
 
  return res;
}

References luci::ShapeDescription::_rank_known, loco::TensorShape::dim(), loco::Dimension::known(), must_cast(), loco::TensorShape::rank(), and loco::Dimension::value().

◆ to_shape_description() [3/3]

ShapeDescription luci::to_shape_description ( const luci::CircleNode * node )

Definition at line 26 of file ShapeDescription.cpp.

{
  ShapeDescription res;
 
  res._rank_known = true;
 
  res._dims.resize(circle_node->rank());
  for (uint32_t i = 0; i < circle_node->rank(); ++i)
    res._dims.at(i) = circle_node->dim(i).known() ? circle_node->dim(i).value() : -1;
 
  return res;
}

References luci::ShapeDescription::_rank_known, and must_cast().

Referenced by to_shape_description().

◆ to_string()

std::string luci::to_string ( const std::vector< std::string > & strings )

Definition at line 29 of file Strings.cpp.

{
  assert(!strings.empty());
 
  std::string res;
  for (unsigned int i = 0; i < strings.size() - 1; i++)
    res += strings[i] + ", ";
 
  res += strings[strings.size() - 1];
  return res;
}

References must_cast().

◆ to_tflite_sparsity() [1/3]

sparsity::TfLiteIntArray * luci::to_tflite_sparsity ( const luci::SparseIndexVector & data )

Definition at line 237 of file SparsityFormatConverter.cpp.

{
  auto type = data.type();
  switch (type)
  {
    case luci::SparseIndexVectorType::NONE:
    {
      std::vector<int32_t> empty;
      return makeTfLiteArray(empty);
    }
    case luci::SparseIndexVectorType::I32:
      return makeTfLiteArray<int32_t>(*data.as_int32_vector());
    case luci::SparseIndexVectorType::U16:
      return makeTfLiteArray<uint16_t>(*data.as_uint16_vector());
    case luci::SparseIndexVectorType::U8:
      return makeTfLiteArray<uint8_t>(*data.as_uint8_vector());
    default:
      INTERNAL_EXN_V("unsupported SparseIndexVectorType", oops::to_uint32(type));
  }
}

References I32, INTERNAL_EXN_V, makeTfLiteArray(), NONE, to_tflite_sparsity(), oops::to_uint32(), type, U16, and U8.

◆ to_tflite_sparsity() [2/3]

sparsity::TfLiteSparsity luci::to_tflite_sparsity ( const luci::SparsityParam * sp )

Definition at line 258 of file SparsityFormatConverter.cpp.

{
  sparsity::TfLiteSparsity tflsp;
  tflsp.traversal_order = makeTfLiteArray(sp->traversal_order);
  tflsp.block_map = makeTfLiteArray(sp->block_map);
  tflsp.dim_metadata = makeTfLiteDimensionMetadata(sp->dim_metadata);
  tflsp.dim_metadata_size = sp->dim_metadata.size();
  return tflsp;
}

References luci::SparsityParam::block_map, sparsity::TfLiteSparsity::block_map, luci::SparsityParam::dim_metadata, sparsity::TfLiteSparsity::dim_metadata, sparsity::TfLiteSparsity::dim_metadata_size, makeTfLiteArray(), makeTfLiteDimensionMetadata(), to_tflite_sparsity(), luci::SparsityParam::traversal_order, and sparsity::TfLiteSparsity::traversal_order.

◆ to_tflite_sparsity() [3/3]

sparsity::TfLiteDimensionType luci::to_tflite_sparsity ( luci::DimensionType dt )

Definition at line 225 of file SparsityFormatConverter.cpp.

{
  switch (dt)
  {
    case luci::DimensionType::DENSE:
      return sparsity::TfLiteDimensionType::kTfLiteDimDense;
    case luci::DimensionType::SPARSE_CSR:
      return sparsity::TfLiteDimensionType::kTfLiteDimSparseCSR;
  }
  return sparsity::TfLiteDimensionType::kTfLiteDimDense;
}

References DENSE, SPARSE_CSR, and to_tflite_sparsity().

Referenced by makeTfLiteDimensionMetadata(), to_tflite_sparsity(), to_tflite_sparsity(), and to_tflite_sparsity().

◆ validate() [1/3]

bool luci::validate ( loco::Graph * g )

Definition at line 322 of file Validate.cpp.

{
  if (!loco::valid(g))
    return false;
 
  if (!validate_shape_dtype(g))
    return false;
 
  if (!validate_multi_outs(g))
    return false;
 
  // TODO add more validation
 
  return true;
}

References must_cast(), and loco::valid().

◆ validate() [2/3]

bool luci::validate ( luci::Module * module )

Definition at line 398 of file Validate.cpp.

{
  LOGGER(l);
 
  INFO(l) << "--- validate Module -----------------------------------";
 
  for (size_t g = 0; g < module->size(); ++g)
  {
    auto graph = module->graph(g);
 
    INFO(l) << luci::fmt(graph) << std::endl;
 
    if (!validate(graph))
    {
      std::cerr << "ERROR: Invalid circle model" << std::endl;
      return false;
    }
    if (!validate_name(graph))
    {
      std::cerr << "ERROR: circle model has empty name" << std::endl;
      return false;
    }
  }
 
  if (!validate_unique_name(module))
  {
    std::cerr << "ERROR: circle model has duplicate names" << std::endl;
    return false;
  }
 
  return true;
}

References fmt(), INFO, LOGGER, validate_name(), and validate_unique_name().

◆ validate() [3/3]

bool luci::validate ( luci::PartitionTable & partition )

Definition at line 28 of file PartitionValidate.cpp.

{
  if (partition.groups.size() == 0)
  {
    std::cerr << "There is no 'backends' information";
    return false;
  }
  if (partition.default_group.empty())
  {
    std::cerr << "There is no 'default' backend information";
    return false;
  }
  if (!pepper::is_one_of<std::string>(partition.default_group, partition.groups))
  {
    std::cerr << "'default' backend is not one of 'backends' item";
    return false;
  }
  for (auto &byopcode : partition.byopcodes)
  {
    if (!pepper::is_one_of<std::string>(byopcode.second, partition.groups))
    {
      std::cerr << "OPCODE " << byopcode.first << " is not assigned to one of 'backends' items";
      return false;
    }
  }
  for (auto &byopname : partition.byopnames)
  {
    if (!pepper::is_one_of<std::string>(byopname.second, partition.groups))
    {
      std::cerr << "OPNAME " << byopname.first << " is not assigned to one of 'backends' items";
      return false;
    }
  }
  return true;
}

References must_cast().

Referenced by minmax_embedder::Embedder::embed(), onert::odc::Embedder::embed(), entry(), onert::odc::Quantizer::quantize(), mpqsolver::core::Quantizer::quantize(), and ReadModule().

◆ validate_batch_space_nd()

bool luci::validate_batch_space_nd ( const GraphBuilderBase::ValidateArgs & args )

Definition at line 22 of file ValidateHelpers.cpp.

{
  const auto &inputs = args.op.inputs;
  if (inputs.size() != 3)
    return false;
 
  // input 1 and 2 should have INT32/INT64 type
  const auto tensors = args.reader.tensors();
  const auto tensor_1 = tensors.at(inputs.at(1));
  assert(tensor_1 != nullptr);
  switch (tensor_1->type())
  {
    case circle::TensorType_INT32:
    case circle::TensorType_INT64:
      break;
    default:
      return false;
  }
  const auto tensor_2 = tensors.at(inputs.at(2));
  assert(tensor_2 != nullptr);
  switch (tensor_2->type())
  {
    case circle::TensorType_INT32:
    case circle::TensorType_INT64:
      break;
    default:
      return false;
  }
 
  // Only support input shape dimension 3 and 4 only
  const auto tensor_0 = tensors.at(inputs.at(0));
  assert(tensor_0 != nullptr);
  const auto t_0_s = wrap(tensor_0->shape()).size();
  if (t_0_s != 3 && t_0_s != 4)
    return false;
 
  // TODO check input shape
 
  return true;
}

References must_cast(), and wrap().

Referenced by luci::CircleBatchToSpaceNDGraphBuilder::validate(), and luci::CircleSpaceToBatchNDGraphBuilder::validate().

◆ validate_minmax()

bool luci::validate_minmax ( const GraphBuilderBase::ValidateArgs & args )

Definition at line 63 of file ValidateHelpers.cpp.

{
  const auto &inputs = args.op.inputs;
  const auto &outputs = args.op.outputs;
 
  if (inputs.size() != 2)
    return false;
 
  if (outputs.size() != 1)
    return false;
 
  const auto tensors = args.reader.tensors();
  const auto tensor = tensors.at(inputs.at(0));
  assert(tensor != nullptr);
  switch (tensor->type())
  {
    case circle::TensorType_FLOAT16:
    case circle::TensorType_FLOAT32:
    case circle::TensorType_FLOAT64:
    case circle::TensorType_INT16:
    case circle::TensorType_INT32:
    case circle::TensorType_INT64:
    case circle::TensorType_UINT8:
      break;
    default:
      return false;
  }
 
  assert(tensors[inputs.at(1)] != nullptr);
  if (tensors[inputs.at(1)]->type() != tensor->type())
    return false;
 
  assert(tensors[outputs[0]] != nullptr);
  if (tensors[outputs[0]]->type() != tensor->type())
    return false;
 
  return true;
}

References type.

Referenced by luci::CircleMaximumGraphBuilder::validate(), and luci::CircleMinimumGraphBuilder::validate().

◆ validate_name()

bool luci::validate_name ( loco::Graph * g )

Return true if all nodes in graph have non empty name.

Definition at line 338 of file Validate.cpp.

{
  auto nodes = g->nodes();
  for (uint32_t n = 0; n < nodes->size(); ++n)
  {
    auto node = loco::must_cast<luci::CircleNode *>(nodes->at(n));
    // skip virtual nodes
    VirtualNodeDetector d;
    if (node->accept(&d))
      continue;
 
    auto name = node->name();
    if (name.empty())
      return false;
  }
 
  return true;
}

References luci::CircleNode::accept(), loco::must_cast(), must_cast(), and luci::CircleNode::name().

Referenced by validate().

◆ validate_reduce_minmax()

bool luci::validate_reduce_minmax ( const GraphBuilderBase::ValidateArgs & args )

Definition at line 102 of file ValidateHelpers.cpp.

{
  const auto &inputs = args.op.inputs;
  const auto &outputs = args.op.outputs;
 
  if (inputs.size() != 2)
    return false;
 
  if (outputs.size() != 1)
    return false;
 
  const auto tensors = args.reader.tensors();
  const auto tensor_axis = tensors.at(inputs.at(1));
  assert(tensor_axis != nullptr);
  switch (tensor_axis->type())
  {
    case circle::TensorType_INT32:
    case circle::TensorType_INT64:
      break;
    default:
      return false;
  }
 
  return true;
}

References must_cast().

Referenced by luci::CircleReduceMaxGraphBuilder::validate(), and luci::CircleReduceMinGraphBuilder::validate().

◆ validate_shape() [1/2]

bool luci::validate_shape ( loco::Graph * g )

Definition at line 311 of file Validate.cpp.

{
  if (!loco::valid(g))
    return false;
 
  if (!::validate_shape(g))
    return false;
 
  return true;
}

References loco::valid(), and validate_shape().

Referenced by entry(), validate_shape(), and validate_shape().

◆ validate_shape() [2/2]

bool luci::validate_shape ( luci::Module * module )

Definition at line 431 of file Validate.cpp.

{
  LOGGER(l);
 
  INFO(l) << "--- validate shape of Module -----------------------------------";
 
  for (size_t g = 0; g < module->size(); ++g)
  {
    auto graph = module->graph(g);
 
    INFO(l) << luci::fmt(graph) << std::endl;
 
    if (!validate_shape(graph))
    {
      std::cerr << "ERROR: Invalid circle model" << std::endl;
      return false;
    }
  }
 
  return true;
}

References fmt(), INFO, LOGGER, and validate_shape().

◆ validate_unique_name()

bool luci::validate_unique_name ( luci::Module * m )

Return true if all names in the Module are unique.

Note: CircleOutput may have duplicate name

Definition at line 357 of file Validate.cpp.

{
  LOGGER(l);
 
  std::unordered_map<std::string, bool> names_col;
 
  for (size_t g = 0; g < m->size(); ++g)
  {
    auto graph = m->graph(g);
    auto nodes = graph->nodes();
    for (uint32_t n = 0; n < nodes->size(); ++n)
    {
      auto node = loco::must_cast<luci::CircleNode *>(nodes->at(n));
      // skip CircleOutput as it may have same name with from() node
      auto output = dynamic_cast<luci::CircleOutput *>(node);
      if (output != nullptr)
        continue;
      // skip virtual nodes
      VirtualNodeDetector d;
      if (node->accept(&d))
        continue;
 
      auto name = node->name();
      INFO(l) << "Node: " << name << ", " << (uint32_t)(node->opcode()) << std::endl;
      auto it = names_col.find(name);
      if (it != names_col.end())
      {
        INFO(l) << "validate_unique_name: found duplicate " << name << ", " << graph->name()
                << std::endl;
        return false;
      }
 
      names_col[name] = true;
    }
    // There can exist same tensor name between different subgraphs.
    names_col.clear();
  }
 
  return true;
}

References luci::CircleNode::accept(), INFO, LOGGER, m, loco::must_cast(), must_cast(), luci::CircleNode::name(), and luci::CircleNode::opcode().

Referenced by validate().

◆ warn_accuracy_with_range()

void luci::warn_accuracy_with_range ( luci::CircleNode * n )

Definition at line 520 of file QuantizationUtils.cpp.

{
  LOGGER(l);
  auto qp = n->quantparam();
  auto k = qp->zerop.size();
  for (uint32_t i = 0; i < k; i++)
  {
    if (warn_scale_zp(qp->scale[i], qp->zerop[i], n))
      WARN(l) << "Quantization of " << i << "-th channel of " << n->name()
              << "'s quantization may cause accuracy issues" << std::endl;
    ;
  }
}

References LOGGER, must_cast(), and WARN.

Referenced by luci::QuantizeWithMinMaxPass::run().

◆ wrap()

template<typename T >

VectorWrapper< T > luci::wrap ( const flatbuffers::Vector< T > * vec )

Definition at line 84 of file CircleReader.h.

{
  return VectorWrapper<T>(vec);
}

References must_cast().

Namespaces

Data Structures

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

◆ CircleNodeID

◆ CircleTensorIndex

◆ ExecutionPlanTable

◆ FormattedGraph

◆ GroupKey

◆ IterFunc

◆ LayerInfoMap

◆ LuciNodeMixin

◆ LuciNodeTrait

◆ MapNode2Clone

◆ NodeName

◆ OriginTable

◆ Phase

◆ TensorIndex

Enumeration Type Documentation

◆ ActivationQType

◆ CircleNodeTrait

◆ CircleOpcode

◆ CN

◆ DimensionType

◆ FusedActFunc

◆ MirrorPadMode

◆ NodeBuilderType

◆ Padding

◆ QuantizationGranularity

◆ RoPEMode

◆ ShapeStatus

◆ SparseIndexVectorType

Function Documentation

◆ __attribute__()

◆ _must_cast()

◆ activation_qtype()

◆ add_execution_plan()

◆ apply()

◆ asymmetric_wquant_with_minmax_per_layer()

◆ cal_minmax_per_channel()

◆ cal_offset()

◆ change_outputs()

◆ check_quant_unfriendly_values()

◆ check_size_limit()

◆ circle_builtin_operator()

◆ circle_builtin_options()

◆ circle_custom_code()

◆ circle_custom_options()

◆ CircleConst::at< loco::DataType::STRING >() [1/2]

◆ CircleConst::at< loco::DataType::STRING >() [2/2]

◆ CircleConst::scalar< loco::DataType::STRING >() [1/2]

◆ CircleConst::scalar< loco::DataType::STRING >() [2/2]

◆ CircleConst::size< loco::DataType::STRING >() [1/2]

◆ CircleConst::size< loco::DataType::STRING >() [2/2]

◆ clear_tensor_index()

◆ clearExportInfo()

◆ clone()

◆ clone_connect()

◆ clone_node()

◆ composite_origin() [1/2]

◆ composite_origin() [2/2]

◆ compute_asym_scale_zp()

◆ compute_sym_scale()

◆ copy_common_attributes()

◆ copy_quantparam()

◆ copy_tensor_attributes()

◆ create_circlevariable()

◆ create_const_node() [1/2]

◆ create_const_node() [2/2]

◆ createCircleMetadataVector()

◆ dtype_get()

◆ dtype_known()

◆ dump() [1/5]

◆ dump() [2/5]

◆ dump() [3/5]

◆ dump() [4/5]

◆ dump() [5/5]

◆ attribute()