Trait Module 

pub trait Module<X> {
    type Output;

    // Required method
    fn forward(&self, x: &X) -> Result<Self::Output, Error>;
}

A unit of computation that consumes Input and produces Module::Output.

Required Associated Types

type Output

The type that this unit produces given Input.

Required Methods

fn forward(&self, x: &X) -> Result<Self::Output, Error>

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<Input, M1: Module<Input>> Module<Input> for (M1,)

fn forward(&self, x: &Input) -> Result<Self::Output, Error>

Calls forward sequentially on each module in the tuple.

type Output = <M1 as Module<Input>>::Output

impl<Input, M2: Module<M1::Output>, M1: Module<Input>> Module<Input> for (M1, M2)

fn forward(&self, x: &Input) -> Result<Self::Output, Error>

Calls forward sequentially on each module in the tuple.

type Output = <M2 as Module<<M1 as Module<Input>>::Output>>::Output

impl<Input, M3: Module<M2::Output>, M2: Module<M1::Output>, M1: Module<Input>> Module<Input> for (M1, M2, M3)

fn forward(&self, x: &Input) -> Result<Self::Output, Error>

Calls forward sequentially on each module in the tuple.

type Output = <M3 as Module<<M2 as Module<<M1 as Module<Input>>::Output>>::Output>>::Output

impl<Input, M4: Module<M3::Output>, M3: Module<M2::Output>, M2: Module<M1::Output>, M1: Module<Input>> Module<Input> for (M1, M2, M3, M4)

fn forward(&self, x: &Input) -> Result<Self::Output, Error>

Calls forward sequentially on each module in the tuple.

type Output = <M4 as Module<<M3 as Module<<M2 as Module<<M1 as Module<Input>>::Output>>::Output>>::Output>>::Output

impl<Input, M5: Module<M4::Output>, M4: Module<M3::Output>, M3: Module<M2::Output>, M2: Module<M1::Output>, M1: Module<Input>> Module<Input> for (M1, M2, M3, M4, M5)

fn forward(&self, x: &Input) -> Result<Self::Output, Error>

Calls forward sequentially on each module in the tuple.

type Output = <M5 as Module<<M4 as Module<<M3 as Module<<M2 as Module<<M1 as Module<Input>>::Output>>::Output>>::Output>>::Output>>::Output

impl<Input, M6: Module<M5::Output>, M5: Module<M4::Output>, M4: Module<M3::Output>, M3: Module<M2::Output>, M2: Module<M1::Output>, M1: Module<Input>> Module<Input> for (M1, M2, M3, M4, M5, M6)

fn forward(&self, x: &Input) -> Result<Self::Output, Error>

Calls forward sequentially on each module in the tuple.

type Output = <M6 as Module<<M5 as Module<<M4 as Module<<M3 as Module<<M2 as Module<<M1 as Module<Input>>::Output>>::Output>>::Output>>::Output>>::Output>>::Output

Implementors

impl<E: Dtype + Float + MatMulImpl, const I: usize, const O: usize, A: Module<[E; O], Output = [E; O]> + TracedModule<[E; O]> + Default> Module<[E; I]> for GLU<E, I, O, A>

type Output = [E; O]

impl<E: Dtype + MatMulImpl, const I: usize, const O: usize, C: Conv1dKernel<E, Const<I>, Const<O>>> Module<[E; I]> for Conv1d<E, I, O, C>

type Output = [E; O]

impl<E: Dtype + MatMulImpl, const I: usize, const O: usize> Module<[E; I]> for Dense<E, I, O>

type Output = [E; O]

impl<E: Dtype, const I: usize, M: Default + Module<[E; I], Output = [E; I]>> Module<[E; I]> for Residual<E, I, M>

type Output = <M as Module<[E; I]>>::Output

impl<E: Dtype, const I: usize, M: Default + Module<[E; I]>> Module<[E; I]> for LR<E, I, M>

type Output = <M as Module<[E; I]>>::Output

impl<E: Dtype, const I: usize> Module<[E; I]> for Bias1d<E, I>

type Output = [E; I]

impl<E: Dtype, const I: usize> Module<[E; I]> for Diag<E, I>

type Output = [E; I]

impl<E: Dtype, const I: usize> Module<[E; I]> for ScalarScale<E>

type Output = [E; I]

impl<E: Float + MatMulImpl, const I: usize> Module<[E; I]> for RMSDiv<E, I>

type Output = [E; I]

impl<E: Float, const I: usize> Module<[E; I]> for Activation<E>

type Output = [E; I]

impl<E: Float, const I: usize> Module<[E; I]> for Softmax

type Output = [E; I]

impl<E: Float, const I: usize> Module<[E; I]> for Swish<E, I>

type Output = [E; I]