Struct SimCLR 

pub struct SimCLR {
    pub projection_dim: usize,
    pub embedding_dim: usize,
    pub temperature: f64,
    pub augmentation_strength: f64,
    pub batch_size: usize,
    pub max_epochs: usize,
    pub learning_rate: f64,
    pub momentum: f64,
    pub labeled_weight: f64,
    pub random_state: Option<u64>,
}

SimCLR (A Simple Framework for Contrastive Learning) adaptation for semi-supervised learning

This implements SimCLR’s contrastive learning approach adapted for semi-supervised scenarios. It learns representations by maximizing agreement between differently augmented views of the same data.

Parameters

• projection_dim - Dimensionality of projection head (typically smaller than embedding_dim)
• embedding_dim - Dimensionality of learned embeddings
• temperature - Temperature parameter for contrastive loss
• augmentation_strength - Strength of data augmentation
• batch_size - Batch size for training
• max_epochs - Maximum number of training epochs
• learning_rate - Learning rate for optimization
• momentum - Momentum for exponential moving averages
• labeled_weight - Weight for supervised contrastive loss component
• random_state - Random seed for reproducibility

Fields

projection_dim: usize

projection_dim

embedding_dim: usize

embedding_dim

temperature: f64

temperature

augmentation_strength: f64

augmentation_strength

batch_size: usize

batch_size

max_epochs: usize

max_epochs

learning_rate: f64

learning_rate

momentum: f64

momentum

labeled_weight: f64

labeled_weight

random_state: Option<u64>

random_state

Implementations

impl SimCLR

pub fn new() -> Self

Create a new SimCLR instance

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

Set the projection head dimensionality

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

Set the embedding dimensionality

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

Set the temperature parameter

pub fn augmentation_strength(self, strength: f64) -> Self

Set the augmentation strength

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

Set the batch size

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

Set the maximum number of epochs

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

Set the learning rate

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

Set the momentum parameter

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

Set the labeled weight

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

Set the random state

Trait Implementations

impl Clone for SimCLR

fn clone(&self) -> SimCLR

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SimCLR

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

Formats the value using the given formatter.

impl Default for SimCLR

fn default() -> Self

Returns the “default value” for a type.

impl Estimator for SimCLR

type Config = SimCLR

Configuration type for the estimator

type Error = ContrastiveLearningError

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 SimCLR

type Fitted = FittedSimCLR

The fitted model type

fn fit( self, X: &ArrayView2<'_, f64>, y: &ArrayView1<'_, i32>, ) -> Result<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