Struct DropConnect 

pub struct DropConnect<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).unwrap(); // 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: Float + Debug + ScalarOperand + Send + Sync> DropConnect<A>

pub fn new(dropprob: A) -> Result<Self>

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: Dimension>( &self, weights: &Array<A, D>, training: bool, ) -> Array<A, D>

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: Dimension>( &self, gradients: &Array<A, D>, weightsshape: D, training: bool, ) -> Array<A, D>

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 + Float> Clone for DropConnect<A>

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 + Float> Debug for DropConnect<A>

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

Formats the value using the given formatter.

impl<A: Float + Debug + ScalarOperand + Send + Sync, D: Dimension + Send + Sync> Regularizer<A, D> for DropConnect<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