Struct dfdx::nn::modules::DropoutOneIn

pub struct DropoutOneIn<const N: usize>;

Does nothing as a Module, and calls dropout() as ModuleMut with probability 1.0 / N.

To prevent programmer error, Module and ModuleMut are only implemented for specific tapes:

1. Module requires that the input tensor has a NoneTape. i.e. that gradients are not being tracked.
2. ModuleMut requires that the tensor has a OwnedTape. i.e. that the gradients are being tracked

That means the following will fail to compile:

1. Using Module with OwnedTape fails to compile

let dropout: DropoutOneIn<2> = BuildModule::build(&dev);
let grads = dropout.alloc_grads();
dropout.forward(dev.zeros::<Rank1<5>>().trace(grads));

2. Using ModuleMut with NoneTape fails to compile

let mut dropout: DropoutOneIn<2> = Default::default();
dropout.forward_mut(dev.zeros::<Rank1<5>>());

Generics:

• N: p is set as 1.0 / N

Examples:

let mut dropout: DropoutOneIn<2> = Default::default();
let grads = dropout.alloc_grads();
let x: Tensor<Rank2<2, 5>, f32, _> = dev.ones();
let r = dropout.forward_mut(x.trace(grads));
assert_eq!(r.array(), [[2.0, 2.0, 2.0, 0.0, 0.0], [2.0, 2.0, 0.0, 0.0, 2.0]]);

Trait Implementations

impl<const N: usize> Clone for DropoutOneIn<N>

fn clone(&self) -> DropoutOneIn<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for DropoutOneIn<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for DropoutOneIn<N>

fn default() -> DropoutOneIn<N>

Returns the “default value” for a type.

impl<const N: usize, S: Shape, E: Dtype, D: Device<E>> Module<Tensor<S, E, D, NoneTape>> for DropoutOneIn<N>

type Error = <D as HasErr>::Err

Does nothing

type Output = Tensor<S, E, D, NoneTape>

The type that this unit produces given Input.

fn try_forward( &self, input: Tensor<S, E, D, NoneTape> ) -> Result<Self::Output, D::Err>

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

Forward Input through the module and produce Module::Output.

impl<const N: usize, S: Shape, E: Dtype, D: Device<E>> ModuleMut<Tensor<S, E, D, OwnedTape<E, D>>> for DropoutOneIn<N>

fn try_forward_mut( &mut self, input: Tensor<S, E, D, OwnedTape<E, D>> ) -> Result<Self::Output, D::Err>

Calls dropout() with p=1/N using self.rng.

type Output = Tensor<S, E, D, OwnedTape<E, D>>

The type that this unit produces given Input.

type Error = <D as HasErr>::Err

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

Forward Input through the module and produce ModuleMut::Output.

impl<const N: usize> ZeroSizedModule for DropoutOneIn<N>