nndeploy::op Namespace Reference

Classes
class	Expr
class	Op
	Op的基类 More...
class	OpAbs
class	OpAcos
class	OpAdd
class	OpAsin
class	OpAtan
class	OpBatchNorm
class	OpBinary
class	OpCast
class	OpCeil
class	OpConcat
class	OpConstantOfShape
class	OpConv
class	OpCos
class	OpCosh
class	OpCreator
	Op的创建类 More...
class	OpDequantizeLinear
class	OpDiv
class	OpEmbedding
class	OpEqual
class	OpErf
class	OpExp
class	OpExpand
class	OpFlatten
class	OpFloor
class	OpGather
class	OpGelu
class	OpGemm
class	OpGlobalAveragepool
class	OpHardSigmoid
class	OpLog
class	OpMatMul
class	OpMaxPool
class	OpMul
class	OpMuls
class	OpNeg
class	OpPow
class	OpQLinearConv
class	OpQuantizeLinear
class	OpReciprocal
class	OpReduceMean
class	OpRelu
class	OpReshape
class	OpResize
class	OpRMSNorm
class	OpRound
class	OpSelu
class	OpShape
class	OpSigmoid
class	OpSign
class	OpSin
class	OpSinh
class	OpSlice
class	OpSoftmax
class	OpSplit
class	OpSqrt
class	OpSub
class	OpTan
class	OpTanh
class	OpTranspose
class	OpUnary
class	OpUnsqueeze
class	OpWhere
class	TypeOpCreator
	Op的创建类模板 More...
class	TypeOpRegister
	Op的创建类的注册类模板 More...

Typedefs
using	MIMOOpFunc = std::function< base::Status(std::initializer_list< device::Tensor * > inputs, std::initializer_list< device::Tensor * > outputs, std::shared_ptr< base::Param > op_param)>
using	MISOOpFunc = std::function< base::Status(std::initializer_list< device::Tensor * > inputs, device::Tensor *output, std::shared_ptr< base::Param > op_param)>
using	SIMOOpFunc = std::function< base::Status(device::Tensor *input, std::initializer_list< device::Tensor * > outputs, std::shared_ptr< base::Param > op_param)>
using	SISOOpFunc = std::function< base::Status(device::Tensor *input, device::Tensor *output, std::shared_ptr< base::Param > op_param)>

Enumerations
enum	ExprType : int { kExprTypeValueDesc = 0x0000 , kExprTypeOpDesc , kExprTypeModelDesc }

Functions
base::Status	abs (device::Tensor *input, device::Tensor *output)
base::Status	acos (device::Tensor *input, device::Tensor *output)
base::Status	add (device::Tensor *input1, device::Tensor *input2, device::Tensor *output)
void	adjustNegativeAxes (int &axes, int rank)
void	adjustNegativeAxes (std::vector< int > &axes, int rank)
base::Status	asin (device::Tensor *input, device::Tensor *output)
base::Status	atan (device::Tensor *input, device::Tensor *output)
base::Status	batchNorm (device::Tensor *input1, device::Tensor *scale, device::Tensor *bias, device::Tensor *mean, device::Tensor *var, std::shared_ptr< ir::BatchNormalizationParam > param, device::Tensor *output)
base::Status	cast (device::Tensor *input, std::shared_ptr< ir::CastParam > param, device::Tensor *output)
base::Status	ceil (device::Tensor *input, device::Tensor *output)
bool	checkAxesRange (int axes, int rank)
bool	checkAxesRange (std::vector< int > &axes, int rank)
base::Status	concat (std::vector< device::Tensor * > inputs, std::shared_ptr< ir::ConcatParam > param, device::Tensor *output)
base::Status	constantOfShape (device::Tensor *shape, std::shared_ptr< ir::ConstantOfShapeParam > param, device::Tensor *output)
base::Status	conv (device::Tensor *input, device::Tensor *weight, device::Tensor *bias, std::shared_ptr< ir::ConvParam > param, device::Tensor *output)
base::Status	cos (device::Tensor *input, device::Tensor *output)
base::Status	cosh (device::Tensor *input, device::Tensor *output)
Op *	createOp (base::DeviceType device_type, const std::string &name, ir::OpType op_type)
Op *	createOp (base::DeviceType device_type, const std::string &name, ir::OpType op_type, std::initializer_list< std::string > inputs, std::initializer_list< std::string > outputs)
Op *	createOp (base::DeviceType device_type, const std::string &name, ir::OpType op_type, std::vector< std::string > &inputs, std::vector< std::string > &outputs)
Op *	createOp (base::DeviceType device_type, const std::string &name, ir::OpType op_type, std::vector< std::string > &inputs, std::vector< std::string > &outputs, std::shared_ptr< base::Param > param)
Op *	createOp (base::DeviceType device_type, std::shared_ptr< ir::OpDesc > op_desc)
std::shared_ptr< Op >	createOpSharedPtr (base::DeviceType device_type, const std::string &name, ir::OpType op_type)
std::shared_ptr< Op >	createOpSharedPtr (base::DeviceType device_type, const std::string &name, ir::OpType op_type, std::initializer_list< std::string > inputs, std::initializer_list< std::string > outputs)
std::shared_ptr< Op >	createOpSharedPtr (base::DeviceType device_type, const std::string &name, ir::OpType op_type, std::vector< std::string > &inputs, std::vector< std::string > &outputs)
std::shared_ptr< Op >	createOpSharedPtr (base::DeviceType device_type, const std::string &name, ir::OpType op_type, std::vector< std::string > &inputs, std::vector< std::string > &outputs, std::shared_ptr< base::Param > param)
std::shared_ptr< Op >	createOpSharedPtr (base::DeviceType device_type, std::shared_ptr< ir::OpDesc > op_desc)
base::Status	dequantizeLinear (device::Tensor *input, device::Tensor *scale, device::Tensor *zero_point, std::shared_ptr< ir::DequantizeLinearParam > param, device::Tensor *output)
base::Status	div (device::Tensor *input1, device::Tensor *input2, device::Tensor *output)
base::Status	embedding (device::Tensor *input, device::Tensor *indice, device::Tensor *output)
base::Status	equal (device::Tensor *input_a, device::Tensor *input_b, device::Tensor *output)
base::Status	erf (device::Tensor *input, device::Tensor *output)
base::Status	exp (device::Tensor *input, device::Tensor *output)
base::Status	expand (device::Tensor *input, device::Tensor *shape, device::Tensor *output)
std::string	exprTypeToString (ExprType type)
base::Status	flatten (device::Tensor *inputs, std::shared_ptr< ir::FlattenParam > param, device::Tensor *output)
base::Status	floor (device::Tensor *input, device::Tensor *output)
base::Status	gather (device::Tensor *input, device::Tensor *index, std::shared_ptr< ir::GatherParam > param, device::Tensor *output)
base::Status	gelu (device::Tensor *input, device::Tensor *output)
base::Status	gemm (device::Tensor *inputs_a, device::Tensor *inputs_b, device::Tensor *inputs_c, std::shared_ptr< ir::GemmParam > param, device::Tensor *output)
std::map< base::DeviceTypeCode, std::map< ir::OpType, std::shared_ptr< OpCreator > > > &	getGlobalOpCreatorMap ()
	Get the Global Op Creator Map object. More...
base::Status	globalAveragepool (device::Tensor *input, device::Tensor *output)
base::Status	hardsigmoid (device::Tensor *input, device::Tensor *output)
base::Status	log (device::Tensor *input, device::Tensor *output)
std::shared_ptr< Expr >	makeAdd (ir::ModelDesc *model_desc, std::shared_ptr< Expr > input_0, std::shared_ptr< Expr > input_1, std::string op_name="", std::string output_name="")
std::shared_ptr< Expr >	makeBatchNorm (ir::ModelDesc *model_desc, std::shared_ptr< Expr > input, std::shared_ptr< ir::BatchNormalizationParam > param, const std::string &scale, const std::string &bias, const std::string &mean, const std::string &var, std::string op_name="", std::string output_name="")
std::shared_ptr< Expr >	makeBlock (ir::ModelDesc *model_desc, std::shared_ptr< ir::ModelDesc > model_block)
std::shared_ptr< Expr >	makeConstant (ir::ModelDesc *model_desc, std::string name)
std::shared_ptr< Expr >	makeConv (ir::ModelDesc *model_desc, std::shared_ptr< Expr > input, std::shared_ptr< ir::ConvParam > param, const std::string &weight, const std::string &bias="", std::string op_name="", std::string output_name="")
std::shared_ptr< Expr >	makeEmbedding (ir::ModelDesc *model_desc, std::shared_ptr< Expr > indices, std::string op_name, std::string output_name)
std::shared_ptr< Expr >	makeFlatten (ir::ModelDesc *model_desc, std::shared_ptr< Expr > input, std::shared_ptr< ir::FlattenParam > param, std::string op_name="", std::string output_name="")
std::shared_ptr< Expr >	makeGemm (ir::ModelDesc *model_desc, std::shared_ptr< Expr > input, std::shared_ptr< ir::GemmParam > param, const std::string &weight, const std::string &bias="", std::string op_name="", std::string output_name="")
std::shared_ptr< Expr >	makeGlobalAveragePool (ir::ModelDesc *model_desc, std::shared_ptr< Expr > input, std::string op_name="", std::string output_name="")
std::shared_ptr< Expr >	makeInput (ir::ModelDesc *model_desc, std::string name, base::DataType data_type=base::dataTypeOf< float >(), base::IntVector shape=base::IntVector())
	一系列创建函数 More...
std::shared_ptr< Expr >	makeMaxPool (ir::ModelDesc *model_desc, std::shared_ptr< Expr > input, std::shared_ptr< ir::MaxPoolParam > param, std::string op_name="", std::string output_name="")
void	makeOutput (ir::ModelDesc *model_desc, std::shared_ptr< Expr > expr)
std::shared_ptr< Expr >	makeRelu (ir::ModelDesc *model_desc, std::shared_ptr< Expr > input, std::string op_name="", std::string output_name="")
std::shared_ptr< Expr >	makeSigmoid (ir::ModelDesc *model_desc, std::shared_ptr< Expr > input, std::string op_name="", std::string output_name="")
std::shared_ptr< Expr >	makeSoftmax (ir::ModelDesc *model_desc, std::shared_ptr< Expr > input, std::shared_ptr< ir::SoftmaxParam > param, std::string op_name="", std::string output_name="")
base::Status	matmul (device::Tensor *inputs_a, device::Tensor *inputs_b, std::shared_ptr< ir::MatMulParam > param, device::Tensor *output)
base::Status	matmul (device::Tensor *inputs_a, device::Tensor *inputs_b, std::shared_ptr< ir::MatMulParam > param, device::Tensor *output, device::Tensor *inputs_bias)
base::Status	maxPool (device::Tensor *input, std::shared_ptr< ir::MaxPoolParam > param, device::Tensor *output)
base::Status	mul (device::Tensor *input1, device::Tensor *input2, device::Tensor *output)
base::Status	muls (device::Tensor *scale, device::Tensor *input, device::Tensor *output)
int32_t	multiplyDims (const base::IntVector &shape, int from, int upto_exclusive)
base::Status	neg (device::Tensor *input, device::Tensor *output)
base::Status	pow (device::Tensor *input, device::Tensor *exponent, device::Tensor *output)
base::Status	qLinearConv (device::Tensor *x, device::Tensor *x_scale, device::Tensor *x_zero_point, device::Tensor *w, device::Tensor *w_scale, device::Tensor *w_zero_point, device::Tensor *y_scale, device::Tensor *y_zero_point, device::Tensor *B, std::shared_ptr< ir::QLinearConvParam > param, device::Tensor *output)
base::Status	quantizeLinear (device::Tensor *input, device::Tensor *scale, device::Tensor *zero_point, std::shared_ptr< ir::QuantizeLinearParam > param, device::Tensor *output)
base::Status	reciprocal (device::Tensor *input, device::Tensor *output)
base::Status	reduceMean (device::Tensor *input, device::Tensor *axes, std::shared_ptr< ir::ReduceMeanParam > param, device::Tensor *output)
base::Status	relu (device::Tensor *input, device::Tensor *output)
base::Status	reshape (device::Tensor *input, device::Tensor *shape, std::shared_ptr< ir::ReshapeParam > param, device::Tensor *output)
base::Status	resize (device::Tensor *input, device::Tensor *roi, device::Tensor *scales, device::Tensor *sizes, std::shared_ptr< ir::ResizeParam > param, device::Tensor *output)
base::Status	rmsNorm (device::Tensor *input, device::Tensor *weight, std::shared_ptr< base::Param > param, device::Tensor *output)
base::Status	round (device::Tensor *input, device::Tensor *output)
base::Status	selu (device::Tensor *input, device::Tensor *output)
base::Status	shape (device::Tensor *input, std::shared_ptr< ir::ShapeParam > param, device::Tensor *output)
base::Status	sigmoid (device::Tensor *input, device::Tensor *output)
base::Status	sign (device::Tensor *input, device::Tensor *output)
base::Status	sin (device::Tensor *input, device::Tensor *output)
base::Status	sinh (device::Tensor *input, device::Tensor *output)
base::Status	slice (device::Tensor *input, device::Tensor *starts, device::Tensor *ends, device::Tensor *axes, device::Tensor *steps, device::Tensor *output)
base::Status	softmax (device::Tensor *input, std::shared_ptr< ir::SoftmaxParam > param, device::Tensor *output)
base::Status	split (device::Tensor *input, device::Tensor *section, std::shared_ptr< ir::SplitParam > param, std::vector< device::Tensor * > outputs)
base::Status	sqrt (device::Tensor *input, device::Tensor *output)
ExprType	stringToExprType (const std::string &src)
base::Status	sub (device::Tensor *input1, device::Tensor *input2, device::Tensor *output)
base::Status	tan (device::Tensor *input, device::Tensor *output)
base::Status	tanh (device::Tensor *input, device::Tensor *output)
base::Status	transpose (device::Tensor *input, std::shared_ptr< ir::TransposeParam > param, device::Tensor *output)
base::Status	unsqueeze (device::Tensor *input, device::Tensor *axes, device::Tensor *output)
base::Status	where (device::Tensor *input1, device::Tensor *input2, device::Tensor *condition, device::Tensor *output)

Typedef Documentation

MIMOOpFunc

using nndeploy::op::MIMOOpFunc = typedef std::function<base::Status(std::initializer_list<device::Tensor *> inputs, std::initializer_list<device::Tensor *> outputs, std::shared_ptr<base::Param> op_param)>

Definition at line 412 of file op.h.

MISOOpFunc

using nndeploy::op::MISOOpFunc = typedef std::function<base::Status( std::initializer_list<device::Tensor *> inputs, device::Tensor *output, std::shared_ptr<base::Param> op_param)>

Definition at line 408 of file op.h.

SIMOOpFunc

using nndeploy::op::SIMOOpFunc = typedef std::function<base::Status( device::Tensor *input, std::initializer_list<device::Tensor *> outputs, std::shared_ptr<base::Param> op_param)>

Definition at line 404 of file op.h.

SISOOpFunc

using nndeploy::op::SISOOpFunc = typedef std::function<base::Status(device::Tensor *input, device::Tensor *output, std::shared_ptr<base::Param> op_param)>

Definition at line 400 of file op.h.

Enumeration Type Documentation

ExprType

enum nndeploy::op::ExprType : int

Enumerator
kExprTypeValueDesc
kExprTypeOpDesc
kExprTypeModelDesc

Definition at line 13 of file expr.h.

Function Documentation

abs()

base::Status nndeploy::op::abs	(	device::Tensor *	input,
		device::Tensor *	output
	)

acos()

base::Status nndeploy::op::acos	(	device::Tensor *	input,
		device::Tensor *	output
	)

add()

base::Status nndeploy::op::add	(	device::Tensor *	input1,
		device::Tensor *	input2,
		device::Tensor *	output
	)

adjustNegativeAxes() [1/2]

void nndeploy::op::adjustNegativeAxes	(	int &	axes,
		int	rank
	)

adjustNegativeAxes() [2/2]

void nndeploy::op::adjustNegativeAxes	(	std::vector< int > &	axes,
		int	rank
	)

asin()

base::Status nndeploy::op::asin	(	device::Tensor *	input,
		device::Tensor *	output
	)

atan()

base::Status nndeploy::op::atan	(	device::Tensor *	input,
		device::Tensor *	output
	)

batchNorm()

base::Status nndeploy::op::batchNorm	(	device::Tensor *	input1,
		device::Tensor *	scale,
		device::Tensor *	bias,
		device::Tensor *	mean,
		device::Tensor *	var,
		std::shared_ptr< ir::BatchNormalizationParam >	param,
		device::Tensor *	output
	)

cast()

base::Status nndeploy::op::cast	(	device::Tensor *	input,
		std::shared_ptr< ir::CastParam >	param,
		device::Tensor *	output
	)

ceil()

base::Status nndeploy::op::ceil	(	device::Tensor *	input,
		device::Tensor *	output
	)

checkAxesRange() [1/2]

bool nndeploy::op::checkAxesRange	(	int	axes,
		int	rank
	)

checkAxesRange() [2/2]

bool nndeploy::op::checkAxesRange	(	std::vector< int > &	axes,
		int	rank
	)

concat()

base::Status nndeploy::op::concat	(	std::vector< device::Tensor * >	inputs,
		std::shared_ptr< ir::ConcatParam >	param,
		device::Tensor *	output
	)

constantOfShape()

base::Status nndeploy::op::constantOfShape	(	device::Tensor *	shape,
		std::shared_ptr< ir::ConstantOfShapeParam >	param,
		device::Tensor *	output
	)

conv()

base::Status nndeploy::op::conv	(	device::Tensor *	input,
		device::Tensor *	weight,
		device::Tensor *	bias,
		std::shared_ptr< ir::ConvParam >	param,
		device::Tensor *	output
	)

cos()

base::Status nndeploy::op::cos	(	device::Tensor *	input,
		device::Tensor *	output
	)

cosh()

base::Status nndeploy::op::cosh	(	device::Tensor *	input,
		device::Tensor *	output
	)

createOp() [1/5]

Op* nndeploy::op::createOp	(	base::DeviceType	device_type,
		const std::string &	name,
		ir::OpType	op_type
	)

createOp() [2/5]

Op* nndeploy::op::createOp	(	base::DeviceType	device_type,
		const std::string &	name,
		ir::OpType	op_type,
		std::initializer_list< std::string >	inputs,
		std::initializer_list< std::string >	outputs
	)

createOp() [3/5]

Op* nndeploy::op::createOp	(	base::DeviceType	device_type,
		const std::string &	name,
		ir::OpType	op_type,
		std::vector< std::string > &	inputs,
		std::vector< std::string > &	outputs
	)

createOp() [4/5]

Op* nndeploy::op::createOp	(	base::DeviceType	device_type,
		const std::string &	name,
		ir::OpType	op_type,
		std::vector< std::string > &	inputs,
		std::vector< std::string > &	outputs,
		std::shared_ptr< base::Param >	param
	)

createOp() [5/5]

Op* nndeploy::op::createOp	(	base::DeviceType	device_type,
		std::shared_ptr< ir::OpDesc >	op_desc
	)

createOpSharedPtr() [1/5]

std::shared_ptr<Op> nndeploy::op::createOpSharedPtr	(	base::DeviceType	device_type,
		const std::string &	name,
		ir::OpType	op_type
	)

createOpSharedPtr() [2/5]

std::shared_ptr<Op> nndeploy::op::createOpSharedPtr	(	base::DeviceType	device_type,
		const std::string &	name,
		ir::OpType	op_type,
		std::initializer_list< std::string >	inputs,
		std::initializer_list< std::string >	outputs
	)

createOpSharedPtr() [3/5]

std::shared_ptr<Op> nndeploy::op::createOpSharedPtr	(	base::DeviceType	device_type,
		const std::string &	name,
		ir::OpType	op_type,
		std::vector< std::string > &	inputs,
		std::vector< std::string > &	outputs
	)

createOpSharedPtr() [4/5]

std::shared_ptr<Op> nndeploy::op::createOpSharedPtr	(	base::DeviceType	device_type,
		const std::string &	name,
		ir::OpType	op_type,
		std::vector< std::string > &	inputs,
		std::vector< std::string > &	outputs,
		std::shared_ptr< base::Param >	param
	)

createOpSharedPtr() [5/5]

std::shared_ptr<Op> nndeploy::op::createOpSharedPtr	(	base::DeviceType	device_type,
		std::shared_ptr< ir::OpDesc >	op_desc
	)

dequantizeLinear()

base::Status nndeploy::op::dequantizeLinear	(	device::Tensor *	input,
		device::Tensor *	scale,
		device::Tensor *	zero_point,
		std::shared_ptr< ir::DequantizeLinearParam >	param,
		device::Tensor *	output
	)

div()

base::Status nndeploy::op::div	(	device::Tensor *	input1,
		device::Tensor *	input2,
		device::Tensor *	output
	)

embedding()

base::Status nndeploy::op::embedding	(	device::Tensor *	input,
		device::Tensor *	indice,
		device::Tensor *	output
	)

equal()

base::Status nndeploy::op::equal	(	device::Tensor *	input_a,
		device::Tensor *	input_b,
		device::Tensor *	output
	)

erf()

base::Status nndeploy::op::erf	(	device::Tensor *	input,
		device::Tensor *	output
	)

exp()

base::Status nndeploy::op::exp	(	device::Tensor *	input,
		device::Tensor *	output
	)

expand()

base::Status nndeploy::op::expand	(	device::Tensor *	input,
		device::Tensor *	shape,
		device::Tensor *	output
	)

exprTypeToString()

std::string nndeploy::op::exprTypeToString

(

ExprType

type

)

flatten()

base::Status nndeploy::op::flatten	(	device::Tensor *	inputs,
		std::shared_ptr< ir::FlattenParam >	param,
		device::Tensor *	output
	)

floor()

base::Status nndeploy::op::floor	(	device::Tensor *	input,
		device::Tensor *	output
	)

gather()

base::Status nndeploy::op::gather	(	device::Tensor *	input,
		device::Tensor *	index,
		std::shared_ptr< ir::GatherParam >	param,
		device::Tensor *	output
	)

gelu()

base::Status nndeploy::op::gelu	(	device::Tensor *	input,
		device::Tensor *	output
	)

gemm()

base::Status nndeploy::op::gemm	(	device::Tensor *	inputs_a,
		device::Tensor *	inputs_b,
		device::Tensor *	inputs_c,
		std::shared_ptr< ir::GemmParam >	param,
		device::Tensor *	output
	)

getGlobalOpCreatorMap()

std::map<base::DeviceTypeCode, std::map<ir::OpType, std::shared_ptr<OpCreator> > >& nndeploy::op::getGlobalOpCreatorMap

(

)

Get the Global Op Creator Map object.

Returns

std::map<ExecutorType, std::map<const std::string &, std::shared_ptr<OpCreator>>>&

globalAveragepool()

base::Status nndeploy::op::globalAveragepool	(	device::Tensor *	input,
		device::Tensor *	output
	)

hardsigmoid()

base::Status nndeploy::op::hardsigmoid	(	device::Tensor *	input,
		device::Tensor *	output
	)

log()

base::Status nndeploy::op::log	(	device::Tensor *	input,
		device::Tensor *	output
	)

makeAdd()

std::shared_ptr<Expr> nndeploy::op::makeAdd	(	ir::ModelDesc *	model_desc,
		std::shared_ptr< Expr >	input_0,
		std::shared_ptr< Expr >	input_1,
		std::string	op_name = "",
		std::string	output_name = ""
	)

makeBatchNorm()

std::shared_ptr<Expr> nndeploy::op::makeBatchNorm	(	ir::ModelDesc *	model_desc,
		std::shared_ptr< Expr >	input,
		std::shared_ptr< ir::BatchNormalizationParam >	param,
		const std::string &	scale,
		const std::string &	bias,
		const std::string &	mean,
		const std::string &	var,
		std::string	op_name = "",
		std::string	output_name = ""
	)

makeBlock()

std::shared_ptr<Expr> nndeploy::op::makeBlock	(	ir::ModelDesc *	model_desc,
		std::shared_ptr< ir::ModelDesc >	model_block
	)

makeConstant()

std::shared_ptr<Expr> nndeploy::op::makeConstant	(	ir::ModelDesc *	model_desc,
		std::string	name
	)

makeConv()

std::shared_ptr<Expr> nndeploy::op::makeConv	(	ir::ModelDesc *	model_desc,
		std::shared_ptr< Expr >	input,
		std::shared_ptr< ir::ConvParam >	param,
		const std::string &	weight,
		const std::string &	bias = "",
		std::string	op_name = "",
		std::string	output_name = ""
	)

makeEmbedding()

std::shared_ptr<Expr> nndeploy::op::makeEmbedding	(	ir::ModelDesc *	model_desc,
		std::shared_ptr< Expr >	indices,
		std::string	op_name,
		std::string	output_name
	)

makeFlatten()

std::shared_ptr<Expr> nndeploy::op::makeFlatten	(	ir::ModelDesc *	model_desc,
		std::shared_ptr< Expr >	input,
		std::shared_ptr< ir::FlattenParam >	param,
		std::string	op_name = "",
		std::string	output_name = ""
	)

makeGemm()

std::shared_ptr<Expr> nndeploy::op::makeGemm	(	ir::ModelDesc *	model_desc,
		std::shared_ptr< Expr >	input,
		std::shared_ptr< ir::GemmParam >	param,
		const std::string &	weight,
		const std::string &	bias = "",
		std::string	op_name = "",
		std::string	output_name = ""
	)

makeGlobalAveragePool()

std::shared_ptr<Expr> nndeploy::op::makeGlobalAveragePool	(	ir::ModelDesc *	model_desc,
		std::shared_ptr< Expr >	input,
		std::string	op_name = "",
		std::string	output_name = ""
	)

makeInput()

std::shared_ptr<Expr> nndeploy::op::makeInput	(	ir::ModelDesc *	model_desc,
		std::string	name,
		base::DataType	data_type = base::dataTypeOf< float >(),
		base::IntVector	shape = base::IntVector()
	)

一系列创建函数

Note

TODO: 目前pybind11导出ir::ModelDesc，采用shared_ptr作为hold type，可能需要讲全文的ir::ModelDesc *model_desc改为shared_ptr<ir::ModelDesc>

makeMaxPool()

std::shared_ptr<Expr> nndeploy::op::makeMaxPool	(	ir::ModelDesc *	model_desc,
		std::shared_ptr< Expr >	input,
		std::shared_ptr< ir::MaxPoolParam >	param,
		std::string	op_name = "",
		std::string	output_name = ""
	)

makeOutput()

void nndeploy::op::makeOutput	(	ir::ModelDesc *	model_desc,
		std::shared_ptr< Expr >	expr
	)

makeRelu()

std::shared_ptr<Expr> nndeploy::op::makeRelu	(	ir::ModelDesc *	model_desc,
		std::shared_ptr< Expr >	input,
		std::string	op_name = "",
		std::string	output_name = ""
	)

makeSigmoid()

std::shared_ptr<Expr> nndeploy::op::makeSigmoid	(	ir::ModelDesc *	model_desc,
		std::shared_ptr< Expr >	input,
		std::string	op_name = "",
		std::string	output_name = ""
	)

makeSoftmax()

std::shared_ptr<Expr> nndeploy::op::makeSoftmax	(	ir::ModelDesc *	model_desc,
		std::shared_ptr< Expr >	input,
		std::shared_ptr< ir::SoftmaxParam >	param,
		std::string	op_name = "",
		std::string	output_name = ""
	)

matmul() [1/2]

base::Status nndeploy::op::matmul	(	device::Tensor *	inputs_a,
		device::Tensor *	inputs_b,
		std::shared_ptr< ir::MatMulParam >	param,
		device::Tensor *	output
	)

matmul() [2/2]

base::Status nndeploy::op::matmul	(	device::Tensor *	inputs_a,
		device::Tensor *	inputs_b,
		std::shared_ptr< ir::MatMulParam >	param,
		device::Tensor *	output,
		device::Tensor *	inputs_bias
	)

maxPool()

base::Status nndeploy::op::maxPool	(	device::Tensor *	input,
		std::shared_ptr< ir::MaxPoolParam >	param,
		device::Tensor *	output
	)

mul()

base::Status nndeploy::op::mul	(	device::Tensor *	input1,
		device::Tensor *	input2,
		device::Tensor *	output
	)

muls()

base::Status nndeploy::op::muls	(	device::Tensor *	scale,
		device::Tensor *	input,
		device::Tensor *	output
	)

multiplyDims()

int32_t nndeploy::op::multiplyDims	(	const base::IntVector &	shape,
		int	from,
		int	upto_exclusive
	)

neg()

base::Status nndeploy::op::neg	(	device::Tensor *	input,
		device::Tensor *	output
	)

pow()

base::Status nndeploy::op::pow	(	device::Tensor *	input,
		device::Tensor *	exponent,
		device::Tensor *	output
	)

qLinearConv()

base::Status nndeploy::op::qLinearConv	(	device::Tensor *	x,
		device::Tensor *	x_scale,
		device::Tensor *	x_zero_point,
		device::Tensor *	w,
		device::Tensor *	w_scale,
		device::Tensor *	w_zero_point,
		device::Tensor *	y_scale,
		device::Tensor *	y_zero_point,
		device::Tensor *	B,
		std::shared_ptr< ir::QLinearConvParam >	param,
		device::Tensor *	output
	)

quantizeLinear()

base::Status nndeploy::op::quantizeLinear	(	device::Tensor *	input,
		device::Tensor *	scale,
		device::Tensor *	zero_point,
		std::shared_ptr< ir::QuantizeLinearParam >	param,
		device::Tensor *	output
	)

reciprocal()

base::Status nndeploy::op::reciprocal	(	device::Tensor *	input,
		device::Tensor *	output
	)

reduceMean()

base::Status nndeploy::op::reduceMean	(	device::Tensor *	input,
		device::Tensor *	axes,
		std::shared_ptr< ir::ReduceMeanParam >	param,
		device::Tensor *	output
	)

relu()

base::Status nndeploy::op::relu	(	device::Tensor *	input,
		device::Tensor *	output
	)

reshape()

base::Status nndeploy::op::reshape	(	device::Tensor *	input,
		device::Tensor *	shape,
		std::shared_ptr< ir::ReshapeParam >	param,
		device::Tensor *	output
	)

resize()

base::Status nndeploy::op::resize	(	device::Tensor *	input,
		device::Tensor *	roi,
		device::Tensor *	scales,
		device::Tensor *	sizes,
		std::shared_ptr< ir::ResizeParam >	param,
		device::Tensor *	output
	)

rmsNorm()

base::Status nndeploy::op::rmsNorm	(	device::Tensor *	input,
		device::Tensor *	weight,
		std::shared_ptr< base::Param >	param,
		device::Tensor *	output
	)

round()

base::Status nndeploy::op::round	(	device::Tensor *	input,
		device::Tensor *	output
	)

selu()

base::Status nndeploy::op::selu	(	device::Tensor *	input,
		device::Tensor *	output
	)

shape()

base::Status nndeploy::op::shape	(	device::Tensor *	input,
		std::shared_ptr< ir::ShapeParam >	param,
		device::Tensor *	output
	)

sigmoid()

base::Status nndeploy::op::sigmoid	(	device::Tensor *	input,
		device::Tensor *	output
	)

sign()

base::Status nndeploy::op::sign	(	device::Tensor *	input,
		device::Tensor *	output
	)

sin()

base::Status nndeploy::op::sin	(	device::Tensor *	input,
		device::Tensor *	output
	)

sinh()

base::Status nndeploy::op::sinh	(	device::Tensor *	input,
		device::Tensor *	output
	)

slice()

base::Status nndeploy::op::slice	(	device::Tensor *	input,
		device::Tensor *	starts,
		device::Tensor *	ends,
		device::Tensor *	axes,
		device::Tensor *	steps,
		device::Tensor *	output
	)

softmax()

base::Status nndeploy::op::softmax	(	device::Tensor *	input,
		std::shared_ptr< ir::SoftmaxParam >	param,
		device::Tensor *	output
	)

split()

base::Status nndeploy::op::split	(	device::Tensor *	input,
		device::Tensor *	section,
		std::shared_ptr< ir::SplitParam >	param,
		std::vector< device::Tensor * >	outputs
	)

sqrt()

base::Status nndeploy::op::sqrt	(	device::Tensor *	input,
		device::Tensor *	output
	)

stringToExprType()

ExprType nndeploy::op::stringToExprType

(

const std::string &

src

)

sub()

base::Status nndeploy::op::sub	(	device::Tensor *	input1,
		device::Tensor *	input2,
		device::Tensor *	output
	)

tan()

base::Status nndeploy::op::tan	(	device::Tensor *	input,
		device::Tensor *	output
	)

tanh()

base::Status nndeploy::op::tanh	(	device::Tensor *	input,
		device::Tensor *	output
	)

transpose()

base::Status nndeploy::op::transpose	(	device::Tensor *	input,
		std::shared_ptr< ir::TransposeParam >	param,
		device::Tensor *	output
	)

unsqueeze()

base::Status nndeploy::op::unsqueeze	(	device::Tensor *	input,
		device::Tensor *	axes,
		device::Tensor *	output
	)

where()

base::Status nndeploy::op::where	(	device::Tensor *	input1,
		device::Tensor *	input2,
		device::Tensor *	condition,
		device::Tensor *	output
	)