Struct mli::Chain

pub struct Chain<T, U>(pub T, pub U);

Trait Implementations

impl<T, U> Forward for Chain<T, U> where
    T: Forward,
    U: Forward<Input = T::Output>, 

type Input = T::Input

type Internal = (T::Internal, T::Output, U::Internal)

type Output = U::Output

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

forward produces: - All intermediary values produced, which can be reused in the back propogation step - The output f given an input

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

run only produces the output from the input. The default implementation uses forward. You can make a custom implementation of this to avoid the overhead of producing and returning the internal variables.

impl<T, U, O> Backward for Chain<T, U> where
    T: Backward<OutputDelta = U::InputDelta> + Forward<Output = O>,
    U: Backward + Forward<Input = O>, 

type OutputDelta = U::OutputDelta

type InputDelta = T::InputDelta

type TrainDelta = (T::TrainDelta, U::TrainDelta)

fn backward(
    &self,
    input: &T::Input,
    internal: &Self::Internal,
    output_delta: &U::OutputDelta
) -> (Self::InputDelta, Self::TrainDelta)

partials produces the change required in the input and trainable variables.

fn backward_input(
    &self,
    input: &Self::Input,
    internal: &Self::Internal,
    output_delta: &Self::OutputDelta
) -> Self::InputDelta

See Backward::backward for documentation.

fn backward_train(
    &self,
    input: &Self::Input,
    internal: &Self::Internal,
    output_delta: &Self::OutputDelta
) -> Self::TrainDelta

See Backward::backward for documentation.

impl<T, U, O> Train for Chain<T, U> where
    T: Train + Backward<OutputDelta = U::InputDelta> + Forward<Output = O>,
    U: Train + Backward + Forward<Input = O>, 

fn train(&mut self, train_delta: &Self::TrainDelta)

train takes in a train delta Δv and applies it to the trained variables.

fn propogate(
    &mut self,
    input: &Self::Input,
    internal: &Self::Internal,
    output_delta: &Self::OutputDelta
) -> Self::InputDelta

propogate should have the same effect as running backwards followed by train.

impl<T: Debug, U: Debug> Debug for Chain<T, U>

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

Formats the value using the given formatter.

impl<T: Clone, U: Clone> Clone for Chain<T, U>

fn clone(&self) -> Chain<T, U>

Returns a copy of the value.

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

Performs copy-assignment from source.