Struct Dropout 

pub struct Dropout<A: Float + Debug> { /* private fields */ }

Dropout regularization for gradients

This type implements the Regularizer trait, so it operates on the gradient array handed to Regularizer::apply, not on layer activations. While in training mode it zeroes each gradient entry independently with probability rate and rescales the survivors by 1 / (1 - rate) (inverted dropout), which keeps the expected gradient unchanged. In evaluation mode — or when rate is zero — gradients pass through untouched.

Applying the same idea to activations requires a forward/backward pass that this crate’s optimizer-side Regularizer interface does not model; use crate::regularizers::SpatialDropout or a neural-network layer for that.

A fresh mask is drawn on every Regularizer::apply call — masks are never cached or reused across calls, so consecutive calls with identical gradients generally produce different results.

Examples

use scirs2_core::ndarray::Array1;
use optirs_core::regularizers::Dropout;
use scirs2_core::random::SeedableRng;
use scirs2_core::random::rngs::SmallRng;

// Create a dropout regularizer with 0.5 dropout rate
let seed = [0u8; 32];
let mut rng = SmallRng::from_seed(seed);
let mut dropout = Dropout::new(0.5f64, &mut rng);

// Set to training mode
dropout.train();

// Check the dropout rate
assert_eq!(dropout.rate(), 0.5);

// Set to evaluation mode
dropout.eval();
assert!(!dropout.is_training());

Implementations

impl<A: Float + Debug + Send + Sync> Dropout<A>

pub fn new<R: Rng>(rate: A, rng: &mut R) -> Self

Create a new dropout regularizer

Arguments

• rate - Dropout rate (0.0 to 1.0, fraction of entries that are dropped)
• rng - Random number generator used to seed this regularizer’s own RNG

pub fn rate(&self) -> A

Get the dropout rate

pub fn set_rate(&mut self, rate: A) -> &mut Self

Set the dropout rate

Arguments

• rate - Dropout rate (0.0 to 1.0, fraction of entries that are dropped)

pub fn train(&mut self) -> &mut Self

Set to training mode (apply dropout to gradients)

pub fn eval(&mut self) -> &mut Self

Set to inference mode (gradients pass through unchanged)

pub fn is_training(&self) -> bool

Get the training mode

Trait Implementations

impl<A: Debug + Float + Debug> Debug for Dropout<A>

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

Formats the value using the given formatter.

impl<A, D> Regularizer<A, D> for Dropout<A>

where A: Float + ScalarOperand + Debug + Send + Sync, D: Dimension<Pattern = D>,

fn apply(&self, _params: &Array<A, D>, gradients: &mut Array<A, D>) -> Result<A>

Mask the gradients in place with a freshly drawn dropout mask.

params is ignored: this regularizer perturbs the gradient signal, not the parameters. Always returns a zero penalty because dropout adds no term to the loss.

fn penalty(&self, _params: &Array<A, D>) -> Result<A>

Compute the regularization penalty value