Struct LadderNetworks 

pub struct LadderNetworks<S = Untrained> { /* private fields */ }

Ladder Networks for Deep Semi-Supervised Learning

Ladder Networks are neural networks that combine supervised and unsupervised learning objectives. They use lateral connections between encoder and decoder paths to enable effective learning from both labeled and unlabeled data.

The architecture consists of:

• An encoder path that applies noise and nonlinearities
• A decoder path that reconstructs clean representations
• Lateral connections that help the decoder
• Multiple reconstruction costs at different layers

Parameters

• layer_sizes - Sizes of hidden layers (including input and output)
• noise_std - Standard deviation of Gaussian noise added to each layer
• lambda_unsupervised - Weight for unsupervised reconstruction loss
• lambda_supervised - Weight for supervised classification loss
• denoising_cost_weights - Weights for denoising costs at each layer
• learning_rate - Learning rate for optimization
• max_iter - Maximum number of training iterations
• batch_size - Size of mini-batches for training

Examples

use sklears_semi_supervised::LadderNetworks;
use sklears_core::traits::{Predict, Fit};


let X = array![[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0]];
let y = array![0, 1, -1, -1]; // -1 indicates unlabeled

let ln = LadderNetworks::new()
    .layer_sizes(vec![2, 4, 2])
    .noise_std(0.3)
    .lambda_unsupervised(1.0)
    .lambda_supervised(1.0);
let fitted = ln.fit(&X.view(), &y.view()).unwrap();
let predictions = fitted.predict(&X.view()).unwrap();

Implementations

impl LadderNetworks<Untrained>

pub fn new() -> Self

Create a new LadderNetworks instance

pub fn layer_sizes(self, sizes: Vec<usize>) -> Self

Set the layer sizes (input size will be set automatically)

pub fn noise_std(self, std: f64) -> Self

Set the noise standard deviation

pub fn lambda_unsupervised(self, lambda: f64) -> Self

Set the unsupervised loss weight

pub fn lambda_supervised(self, lambda: f64) -> Self

Set the supervised loss weight

pub fn denoising_cost_weights(self, weights: Vec<f64>) -> Self

Set the denoising cost weights for each layer

pub fn learning_rate(self, lr: f64) -> Self

Set the learning rate

pub fn max_iter(self, max_iter: usize) -> Self

Set the maximum number of iterations

pub fn batch_size(self, batch_size: usize) -> Self

Set the batch size

pub fn beta1(self, beta1: f64) -> Self

Set Adam optimizer beta1 parameter

pub fn beta2(self, beta2: f64) -> Self

Set Adam optimizer beta2 parameter

pub fn random_state(self, seed: u64) -> Self

Set random state for reproducibility

Trait Implementations

impl<S: Clone> Clone for LadderNetworks<S>

fn clone(&self) -> LadderNetworks<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for LadderNetworks<S>

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

Formats the value using the given formatter.

impl Default for LadderNetworks<Untrained>

fn default() -> Self

Returns the “default value” for a type.

impl Estimator for LadderNetworks<Untrained>

type Config = ()

Configuration type for the estimator

type Error = SklearsError

Error type for the estimator

type Float = f64

The numeric type used by this estimator

fn config(&self) -> &Self::Config

Get estimator configuration

fn validate_config(&self) -> Result<(), SklearsError>

Validate estimator configuration with detailed error context

fn check_compatibility( &self, n_samples: usize, n_features: usize, ) -> Result<(), SklearsError>

Check if estimator is compatible with given data dimensions

fn metadata(&self) -> EstimatorMetadata

Get estimator metadata

impl Fit<ArrayBase<ViewRepr<&f64>, Dim<[usize; 2]>>, ArrayBase<ViewRepr<&i32>, Dim<[usize; 1]>>> for LadderNetworks<Untrained>

type Fitted = LadderNetworks<LadderNetworksTrained>

The fitted model type

fn fit( self, X: &ArrayView2<'_, Float>, y: &ArrayView1<'_, i32>, ) -> SklResult<Self::Fitted>

Fit the model to the provided data with validation

fn fit_with_validation( self, x: &X, y: &Y, _x_val: Option<&X>, _y_val: Option<&Y>, ) -> Result<(Self::Fitted, FitMetrics), SklearsError>

where Self: Sized,

Fit with custom validation and early stopping

impl Predict<ArrayBase<ViewRepr<&f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<i32>, Dim<[usize; 1]>>> for LadderNetworks<LadderNetworksTrained>

fn predict(&self, X: &ArrayView2<'_, Float>) -> SklResult<Array1<i32>>

Make predictions on the provided data

fn predict_with_uncertainty( &self, x: &X, ) -> Result<(Output, UncertaintyMeasure), SklearsError>

Make predictions with confidence intervals

impl PredictProba<ArrayBase<ViewRepr<&f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>> for LadderNetworks<LadderNetworksTrained>

fn predict_proba(&self, X: &ArrayView2<'_, Float>) -> SklResult<Array2<f64>>

Predict class probabilities