Trait dfdx::nn::Module

pub trait Module<Input>: Default + CanUpdateWithGradients {
    type Output;

    fn forward(&self, input: Input) -> Self::Output;
}

A unit of a neural network. Acts on the generic Input and produces Module::Output.

Generic Input means you can implement module for multiple input types on the same struct. For example [Linear] implements Module for 1d inputs and 2d inputs.

Required Associated Types

type Output

Required Methods

fn forward(&self, input: Input) -> Self::Output

Implementations on Foreign Types

impl<Input, A, B> Module<Input> for (A, B) where
    Input: Tensor,
    A: Module<Input>,
    B: Module<A::Output>, 

type Output = <B as Module<<A as Module<Input>>::Output>>::Output

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

impl<Input, A, B, C> Module<Input> for (A, B, C) where
    Input: Tensor,
    A: Module<Input>,
    B: Module<A::Output>,
    C: Module<B::Output>, 

type Output = <C as Module<<B as Module<<A as Module<Input>>::Output>>::Output>>::Output

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

impl<Input, A, B, C, D> Module<Input> for (A, B, C, D) where
    Input: Tensor,
    A: Module<Input>,
    B: Module<A::Output>,
    C: Module<B::Output>,
    D: Module<C::Output>, 

type Output = <D as Module<<C as Module<<B as Module<<A as Module<Input>>::Output>>::Output>>::Output>>::Output

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

impl<Input, A, B, C, D, E> Module<Input> for (A, B, C, D, E) where
    Input: Tensor,
    A: Module<Input>,
    B: Module<A::Output>,
    C: Module<B::Output>,
    D: Module<C::Output>,
    E: Module<D::Output>, 

type Output = <E as Module<<D as Module<<C as Module<<B as Module<<A as Module<Input>>::Output>>::Output>>::Output>>::Output>>::Output

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

impl<Input, A, B, C, D, E, F> Module<Input> for (A, B, C, D, E, F) where
    Input: Tensor,
    A: Module<Input>,
    B: Module<A::Output>,
    C: Module<B::Output>,
    D: Module<C::Output>,
    E: Module<D::Output>,
    F: Module<E::Output>, 

type Output = <F as Module<<E as Module<<D as Module<<C as Module<<B as Module<<A as Module<Input>>::Output>>::Output>>::Output>>::Output>>::Output>>::Output

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

Implementors

impl<T: Tensor<Dtype = f32>> Module<T> for Abs

type Output = T

impl<T: Tensor<Dtype = f32>> Module<T> for Cos

type Output = T

impl<T: Tensor<Dtype = f32>> Module<T> for Exp

type Output = T

impl<T: Tensor<Dtype = f32>> Module<T> for Ln

type Output = T

impl<T: Tensor<Dtype = f32>> Module<T> for ReLU

type Output = T

impl<T: Tensor<Dtype = f32>> Module<T> for Sigmoid

type Output = T

impl<T: Tensor<Dtype = f32>> Module<T> for Sin

type Output = T

impl<T: Tensor<Dtype = f32>> Module<T> for Sqrt

type Output = T

impl<T: Tensor<Dtype = f32>> Module<T> for Square

type Output = T

impl<T: Tensor<Dtype = f32>> Module<T> for Tanh

type Output = T

impl<const B: usize, const I: usize, const O: usize, H: Tape> Module<Tensor2D<B, I, H>> for Linear<I, O>

type Output = Tensor2D<B, O, H>

impl<const I: usize, const O: usize, H: Tape> Module<Tensor1D<I, H>> for Linear<I, O>

type Output = Tensor1D<O, H>