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,
    kMOE = 55,
    kDIST_COLLECTIVE = 56,
}

LayerType

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.

kMOE = 55

< MoE layer.

kDIST_COLLECTIVE = 56

< DistCollective 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 From<LayerType> for LayerType

fn from(value: LayerType) -> Self

Converts to this type from the input type.

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 Into<LayerType> for LayerType

fn into(self) -> LayerType

Converts this type into the (usually inferred) input type.

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