Enum TensorOp 

pub enum TensorOp {
    Input {
        name: String,
    },
    Constant {
        value_cid: String,
    },
    MatMul,
    Add,
    Mul,
    Sub,
    Div,
    Einsum {
        subscripts: String,
    },
    Reshape {
        shape: Vec<i64>,
    },
    Transpose {
        axes: Vec<usize>,
    },
    ReduceSum {
        axes: Vec<usize>,
        keepdims: bool,
    },
    ReduceMean {
        axes: Vec<usize>,
        keepdims: bool,
    },
    ReLU,
    Tanh,
    Sigmoid,
    GELU,
    Softmax {
        axis: i64,
    },
    LayerNorm {
        normalized_shape: Vec<usize>,
        eps: f64,
    },
    BatchNorm {
        eps: f64,
        momentum: f64,
    },
    Dropout {
        p: f64,
    },
    Exp,
    Log,
    Pow {
        exponent: f64,
    },
    Sqrt,
    Concat {
        axis: usize,
    },
    Split {
        axis: usize,
        sections: Vec<usize>,
    },
    Gather {
        axis: usize,
    },
    Scatter {
        axis: usize,
    },
    Slice {
        start: Vec<i64>,
        end: Vec<i64>,
        strides: Vec<i64>,
    },
    Pad {
        padding: Vec<(usize, usize)>,
        mode: String,
    },
    FusedLinear,
    FusedAddReLU,
    FusedBatchNormReLU {
        eps: f64,
        momentum: f64,
    },
    FusedLayerNormDropout {
        normalized_shape: Vec<usize>,
        eps: f64,
        dropout_p: f64,
    },
}

Tensor operation types

Variants

Input

Input placeholder

Fields

name: String

Constant

Constant tensor

Fields

value_cid: String

MatMul

Matrix multiplication

Add

Element-wise addition

Mul

Element-wise multiplication

Sub

Element-wise subtraction

Div

Element-wise division

Einsum

Einsum operation with subscript notation

Fields

subscripts: String

Reshape

Reshape operation

Fields

shape: Vec<i64>

Transpose

Transpose operation

Fields

axes: Vec<usize>

ReduceSum

Reduce sum along axes

Fields

axes: Vec<usize>

keepdims: bool

ReduceMean

Reduce mean along axes

Fields

axes: Vec<usize>

keepdims: bool

ReLU

Activation: ReLU

Tanh

Activation: Tanh

Sigmoid

Activation: Sigmoid

GELU

Activation: GELU (Gaussian Error Linear Unit)

Softmax

Activation: Softmax along axis

Fields

axis: i64

LayerNorm

Layer normalization

Fields

normalized_shape: Vec<usize>

eps: f64

BatchNorm

Batch normalization

Fields

eps: f64

momentum: f64

Dropout

Dropout (training mode)

Fields

p: f64

Exp

Element-wise exponential

Log

Element-wise logarithm

Pow

Element-wise power

Fields

exponent: f64

Sqrt

Element-wise square root

Concat

Concatenate tensors along axis

Fields

axis: usize

Split

Split tensor along axis

Fields

axis: usize

sections: Vec<usize>

Gather

Gather elements along axis

Fields

axis: usize

Scatter

Scatter elements along axis

Fields

axis: usize

Slice

Slice tensor

Fields

start: Vec<i64>

end: Vec<i64>

strides: Vec<i64>

Pad

Pad tensor

Fields

padding: Vec<(usize, usize)>

mode: String

FusedLinear

Fused MatMul + Add (common in linear layers)

FusedAddReLU

Fused Add + ReLU

FusedBatchNormReLU

Fused BatchNorm + ReLU

Fields

eps: f64

momentum: f64

FusedLayerNormDropout

Fused LayerNorm + Dropout

Fields

normalized_shape: Vec<usize>

eps: f64

dropout_p: f64

Implementations

impl TensorOp

pub fn num_inputs(&self) -> usize

Get the number of inputs required by this operation

pub fn is_pure(&self) -> bool

Check if this is a pure operation (no side effects)

pub fn infer_output_shape( &self, input_shapes: &[Vec<usize>], ) -> Result<Vec<usize>, GraphError>

Infer output shape from input shapes

Trait Implementations

impl Clone for TensorOp

fn clone(&self) -> TensorOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TensorOp

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TensorOp

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TensorOp

fn eq(&self, other: &TensorOp) -> 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 Serialize for TensorOp

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TensorOp