Struct StochasticDepth 

pub struct StochasticDepth<A: Float> { /* private fields */ }

Stochastic Depth regularization

Implements stochastic depth by randomly skipping layers during training. During inference, all layers are used with a scaling factor.

Example

use scirs2_core::ndarray::array;
use optirs_core::regularizers::StochasticDepth;

let stochastic_depth = StochasticDepth::new(0.2, 10, 50);
let features = array![[1.0, 2.0], [3.0, 4.0]];

// Apply stochastic depth for layer 5 during training
let output = stochastic_depth.apply_layer(5, &features, true);

Implementations

impl<A: Float + Debug + ScalarOperand + FromPrimitive + Send + Sync> StochasticDepth<A>

pub fn new(drop_prob: A, layer_idx: usize, numlayers: usize) -> Self

Create a new stochastic depth regularization

Arguments

• drop_prob - The base probability of dropping a layer
• layer_idx - The index of the current layer
• num_layers - The total number of layers in the network

pub fn set_layer(&mut self, layeridx: usize)

Set layer index

Arguments

• layer_idx - New layer index

pub fn set_rng_state(&mut self, state: u64)

Set the RNG state for deterministic behavior

pub fn apply_layer<D>( &self, layer_idx: usize, features: &Array<A, D>, training: bool, ) -> Array<A, D>

where D: Dimension,

Apply stochastic depth to a layer

Arguments

• layer_idx - Index of the layer
• features - Input features
• training - Whether in training mode

Returns

The output features, which are either:

• The identity (input) if the layer is dropped during training
• The input scaled by the survival probability during inference
• The input if not dropped during training

Trait Implementations

impl<A: Clone + Float> Clone for StochasticDepth<A>

fn clone(&self) -> StochasticDepth<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<A: Float + Debug + ScalarOperand + FromPrimitive, D: Dimension + Send + Sync> Regularizer<A, D> for StochasticDepth<A>

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

Apply regularization to parameters and gradients

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

Compute the regularization penalty value