Enum ActivationOperationIr 

pub enum ActivationOperationIr {
    Relu(UnaryOpIr),
    ReluBackward(BinaryOpIr),
    LeakyRelu(ScalarOpIr),
    PRelu(BinaryOpIr),
    Gelu(UnaryOpIr),
    GeluBackward(BinaryOpIr),
    Sigmoid(UnaryOpIr),
    SigmoidBackward(BinaryOpIr),
    HardSigmoid(HardSigmoidOpIr),
    LogSigmoid(UnaryOpIr),
    LogSigmoidBackward(BinaryOpIr),
    Softmax(DimOpIr),
    LogSoftmax(DimOpIr),
    Softmin(DimOpIr),
}

Operation intermediate representation for activation functions.

Activations are kept in their own enum (rather than smeared across FloatOperationIr) so backends can match a single arm to dispatch the fused implementation, instead of receiving the function decomposed into 5–20 primitive ops.

Variants

Relu(UnaryOpIr)

relu.

ReluBackward(BinaryOpIr)

relu_backward. lhs = output of the forward pass, rhs = upstream gradient.

LeakyRelu(ScalarOpIr)

leaky_relu. lhs = input, rhs = negative_slope scalar.

PRelu(BinaryOpIr)

prelu. lhs = input, rhs = alpha tensor.

Gelu(UnaryOpIr)

gelu.

GeluBackward(BinaryOpIr)

gelu_backward. lhs = forward input, rhs = upstream gradient.

Sigmoid(UnaryOpIr)

sigmoid.

SigmoidBackward(BinaryOpIr)

sigmoid_backward. lhs = output of the forward pass, rhs = upstream gradient.

HardSigmoid(HardSigmoidOpIr)

hard_sigmoid.

LogSigmoid(UnaryOpIr)

log_sigmoid.

LogSigmoidBackward(BinaryOpIr)

log_sigmoid_backward. lhs = forward input, rhs = upstream gradient.

Softmax(DimOpIr)

softmax.

LogSoftmax(DimOpIr)

log_softmax.

Softmin(DimOpIr)

softmin.

Trait Implementations

impl Clone for ActivationOperationIr

fn clone(&self) -> ActivationOperationIr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ActivationOperationIr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ActivationOperationIr

fn deserialize<__D>( __deserializer: __D, ) -> Result<ActivationOperationIr, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for ActivationOperationIr

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

where __H: Hasher,

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 ActivationOperationIr

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ActivationOperationIr