Trait RevModule

pub trait RevModule<X>: Module<X> {
    type SelfGrads: Gradients;

    // Required methods
    fn reverse(
        &self,
        inputs: &X,
        grads_wrt_output: &<Self as Module<X>>::Output,
    ) -> (X, Self::SelfGrads);
    fn apply(
        &mut self,
        applyer: &mut impl GradApplyer,
        updates: Self::SelfGrads,
    ) -> Result<(), Error>;
}

A unit of computation which can do backpropagation without knowledge of any additional state.

This trait is to be implemented by individual network layers, but not compositions of them.

Required Associated Types

type SelfGrads: Gradients

The type describing gradients with respect to the modules’ own parameters.

Required Methods

fn reverse( &self, inputs: &X, grads_wrt_output: &<Self as Module<X>>::Output, ) -> (X, Self::SelfGrads)

Returns the gradients with respect to the input, and the gradients with respect to any internal parameters.

fn apply( &mut self, applyer: &mut impl GradApplyer, updates: Self::SelfGrads, ) -> Result<(), Error>

Applies a gradient update step: adding product of the provided gradients and the scalar to the parameters.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

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

type SelfGrads = [[E; I]; O]

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

type SelfGrads = <C as Conv1dKernel<E, Const<I>, Const<O>>>::Weights

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

type SelfGrads = ClassWrapper<[E; I], ClassBias>

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

type SelfGrads = [E; I]

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

type SelfGrads = [E; 1]

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

type SelfGrads = ()

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

type SelfGrads = ()

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

type SelfGrads = ()

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

type SelfGrads = ClassWrapper<[E; I], ClassActivation>