Enum LayerType 

#[repr(i32)]
pub enum LayerType {
    kCONVOLUTION = 0,
    kCAST = 1,
    kACTIVATION = 2,
    kPOOLING = 3,
    kLRN = 4,
    kSCALE = 5,
    kSOFTMAX = 6,
    kDECONVOLUTION = 7,
    kCONCATENATION = 8,
    kELEMENTWISE = 9,
    kPLUGIN = 10,
    kUNARY = 11,
    kPADDING = 12,
    kSHUFFLE = 13,
    kREDUCE = 14,
    kTOPK = 15,
    kGATHER = 16,
    kMATRIX_MULTIPLY = 17,
    kRAGGED_SOFTMAX = 18,
    kCONSTANT = 19,
    kIDENTITY = 20,
    kPLUGIN_V2 = 21,
    kSLICE = 22,
    kSHAPE = 23,
    kPARAMETRIC_RELU = 24,
    kRESIZE = 25,
    kTRIP_LIMIT = 26,
    kRECURRENCE = 27,
    kITERATOR = 28,
    kLOOP_OUTPUT = 29,
    kSELECT = 30,
    kFILL = 31,
    kQUANTIZE = 32,
    kDEQUANTIZE = 33,
    kCONDITION = 34,
    kCONDITIONAL_INPUT = 35,
    kCONDITIONAL_OUTPUT = 36,
    kSCATTER = 37,
    kEINSUM = 38,
    kASSERTION = 39,
    kONE_HOT = 40,
    kNON_ZERO = 41,
    kGRID_SAMPLE = 42,
    kNMS = 43,
    kREVERSE_SEQUENCE = 44,
    kNORMALIZATION = 45,
    kPLUGIN_V3 = 46,
    kSQUEEZE = 47,
    kUNSQUEEZE = 48,
    kCUMULATIVE = 49,
    kDYNAMIC_QUANTIZE = 50,
    kATTENTION_INPUT = 51,
    kATTENTION_OUTPUT = 52,
    kROTARY_EMBEDDING = 53,
    kKVCACHE_UPDATE = 54,
}

! ! \enum LayerType ! ! \brief The type values of layer classes. ! ! \see ILayer::getType() !

Variants

kCONVOLUTION = 0

!< Convolution layer.

kCAST = 1

!< Cast layer

kACTIVATION = 2

!< Activation layer.

kPOOLING = 3

!< Pooling layer.

kLRN = 4

!< LRN layer.

kSCALE = 5

!< Scale layer.

kSOFTMAX = 6

!< SoftMax layer.

kDECONVOLUTION = 7

!< Deconvolution layer.

kCONCATENATION = 8

!< Concatenation layer.

kELEMENTWISE = 9

!< Elementwise layer.

kPLUGIN = 10

!< Plugin layer.

kUNARY = 11

!< UnaryOp operation Layer.

kPADDING = 12

!< Padding layer.

kSHUFFLE = 13

!< Shuffle layer.

kREDUCE = 14

!< Reduce layer.

kTOPK = 15

!< TopK layer.

kGATHER = 16

!< Gather layer.

kMATRIX_MULTIPLY = 17

!< Matrix multiply layer.

kRAGGED_SOFTMAX = 18

!< Ragged softmax layer.

kCONSTANT = 19

!< Constant layer.

kIDENTITY = 20

!< Identity layer.

kPLUGIN_V2 = 21

!< PluginV2 layer.

kSLICE = 22

!< Slice layer.

kSHAPE = 23

!< Shape layer.

kPARAMETRIC_RELU = 24

!< Parametric ReLU layer.

kRESIZE = 25

!< Resize Layer.

kTRIP_LIMIT = 26

!< Loop Trip limit layer

kRECURRENCE = 27

!< Loop Recurrence layer

kITERATOR = 28

!< Loop Iterator layer

kLOOP_OUTPUT = 29

!< Loop output layer

kSELECT = 30

!< Select layer.

kFILL = 31

!< Fill layer

kQUANTIZE = 32

!< Quantize layer

kDEQUANTIZE = 33

!< Dequantize layer

kCONDITION = 34

!< Condition layer

kCONDITIONAL_INPUT = 35

!< Conditional Input layer

kCONDITIONAL_OUTPUT = 36

!< Conditional Output layer

kSCATTER = 37

!< Scatter layer

kEINSUM = 38

!< Einsum layer

kASSERTION = 39

!< Assertion layer

kONE_HOT = 40

!< OneHot layer

kNON_ZERO = 41

!< NonZero layer

kGRID_SAMPLE = 42

!< Grid sample layer

kNMS = 43

!< NMS layer

kREVERSE_SEQUENCE = 44

!< Reverse sequence layer

kNORMALIZATION = 45

!< Normalization layer

kPLUGIN_V3 = 46

!< PluginV3 layer.

kSQUEEZE = 47

!< Squeeze Layer.

kUNSQUEEZE = 48

!< Unsqueeze Layer.

kCUMULATIVE = 49

!< Cumulative layer.

kDYNAMIC_QUANTIZE = 50

!< Dynamic Quantize layer.

kATTENTION_INPUT = 51

!< Attention Input.

kATTENTION_OUTPUT = 52

!< Attention Output.

kROTARY_EMBEDDING = 53

!< Rotary Embedding layer.

kKVCACHE_UPDATE = 54

!< KV Cache Update layer.

Trait Implementations

impl Clone for LayerType

fn clone(&self) -> LayerType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ExternType for LayerType

type Id = (n, v, i, n, f, e, r, _1, (), L, a, y, e, r, T, y, p, e)

A type-level representation of the type’s C++ namespace and type name.

type Kind = Trivial

Either cxx::kind::Opaque or cxx::kind::Trivial.

impl Hash for LayerType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for LayerType

fn eq(&self, other: &LayerType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for LayerType

impl SharedPtrTarget for LayerType

impl StructuralPartialEq for LayerType

impl UniquePtrTarget for LayerType

impl VectorElement for LayerType

impl WeakPtrTarget for LayerType