Struct DropConnect 

pub struct DropConnect<A>
where
    A: Float,
{ /* private fields */ }

DropConnect regularizer

Randomly drops connections (weights) during training to prevent overfitting.

Example

use scirs2_core::ndarray::Array2;
use scirs2_core::ndarray::array;
use optirs_core::regularizers::DropConnect;

let dropconnect = DropConnect::new(0.5).expect("DropConnect::new succeeds"); // 50% connection dropout
let weights = array![[1.0, 2.0], [3.0, 4.0]];

// During training
let masked_weights = dropconnect.apply_to_weights(&weights, true);
// Some connections will be zeroed out randomly

// During inference
let inference_weights = dropconnect.apply_to_weights(&weights, false);
// No dropout during inference - weights are scaled appropriately

Implementations

impl<A> DropConnect<A>

where A: Float + Debug + ScalarOperand + Send + Sync,

pub fn new(dropprob: A) -> Result<DropConnect<A>, OptimError>

Create a new DropConnect regularizer

Arguments

• drop_prob - Probability of dropping each connection (0.0 to 1.0)

Returns

A new DropConnect instance or error if probability is invalid

pub fn apply_to_weights<D>( &self, weights: &ArrayBase<OwnedRepr<A>, D>, training: bool, ) -> ArrayBase<OwnedRepr<A>, D>

where D: Dimension,

Apply DropConnect to weights

Arguments

• weights - The weight matrix to apply DropConnect to
• training - Whether we’re in training mode (applies dropout) or inference mode

pub fn apply_to_gradients<D>( &self, gradients: &ArrayBase<OwnedRepr<A>, D>, weightsshape: D, training: bool, ) -> ArrayBase<OwnedRepr<A>, D>

where D: Dimension,

Apply DropConnect during gradient computation

This method should be called during backpropagation to ensure gradients are only computed for non-dropped connections

Trait Implementations

impl<A> Clone for DropConnect<A>

where A: Clone + Float,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A> Debug for DropConnect<A>

where A: Debug + Float,

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

Formats the value using the given formatter.

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

where A: Float + Debug + ScalarOperand + Send + Sync, D: Dimension + Send + Sync,

fn apply( &self, params: &ArrayBase<OwnedRepr<A>, D>, gradients: &mut ArrayBase<OwnedRepr<A>, D>, ) -> Result<A, OptimError>

Apply regularization to parameters and gradients

fn penalty(&self, _params: &ArrayBase<OwnedRepr<A>, D>) -> Result<A, OptimError>

Compute the regularization penalty value