Struct Chain

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

Tuple Fields

0: T

1: U

Trait Implementations

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 as Backward>::OutputDelta

type InputDelta = <T as Backward>::InputDelta

type TrainDelta = (<T as Backward>::TrainDelta, <U as Backward>::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: 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.

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, U> Forward for Chain<T, U>

where T: Forward, U: Forward<Input = T::Output>,

type Input = <T as Forward>::Input

type Internal = (<T as Forward>::Internal, <T as Forward>::Output, <U as Forward>::Internal)

type Output = <U as Forward>::Output

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

forward produces:

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> 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.