Struct AdaptiveSampler 

pub struct AdaptiveSampler { /* private fields */ }

Adaptive sampler that dynamically adjusts sampling strategy based on training progress

This sampler combines multiple sampling strategies and adapts the sampling distribution based on model performance, loss patterns, and sample difficulty over time.

Examples

use torsh_data::sampler::{AdaptiveSampler, AdaptiveStrategy, Sampler};

let mut sampler = AdaptiveSampler::new(1000, 64)
    .with_adaptation_rate(0.1)
    .with_warmup_epochs(5)
    .with_generator(42);

// Add custom strategy
sampler = sampler.add_strategy(
    AdaptiveStrategy::InverseFrequency { power: 1.0 },
    0.2
);

// During training, update with sample losses
let sample_indices = vec![0, 1, 2, 3, 4];
let losses = vec![0.5, 0.8, 0.3, 0.9, 0.2];
sampler.update_sample_losses(&sample_indices, &losses);

// Set current epoch for adaptation
sampler.set_epoch(10);

// Get adaptive samples
let indices: Vec<usize> = sampler.iter().collect();
assert_eq!(indices.len(), 64);

Implementations

impl AdaptiveSampler

pub fn new(dataset_size: usize, num_samples: usize) -> Self

Create a new adaptive sampler

Creates a sampler with default strategies: hard sampling, uniform, and uncertainty.

Arguments

• dataset_size - Total size of the dataset
• num_samples - Number of samples to select per iteration

Examples

use torsh_data::sampler::AdaptiveSampler;

let sampler = AdaptiveSampler::new(1000, 32);
assert_eq!(sampler.len(), 32);

pub fn add_strategy(self, strategy: AdaptiveStrategy, weight: f64) -> Self

Add a custom sampling strategy

Arguments

• strategy - The adaptive strategy to add
• weight - Initial weight for this strategy (will be normalized)

pub fn with_adaptation_rate(self, rate: f64) -> Self

Set adaptation rate for strategy weight updates

Arguments

• rate - Adaptation rate (typically 0.01-0.2)

pub fn with_smoothing_factor(self, factor: f64) -> Self

Set smoothing factor for exponential moving average of losses

Arguments

• factor - Smoothing factor (0.0-1.0, higher values = more smoothing)

pub fn with_warmup_epochs(self, epochs: usize) -> Self

Set number of warmup epochs before adaptation begins

Arguments

• epochs - Number of warmup epochs

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

Set random generator seed

Arguments

• seed - Random seed for reproducible sampling

pub fn current_epoch(&self) -> usize

Get the current epoch

pub fn warmup_epochs(&self) -> usize

Get the warmup epochs

pub fn adaptation_rate(&self) -> f64

Get the adaptation rate

pub fn smoothing_factor(&self) -> f64

Get the smoothing factor

pub fn strategy_weights(&self) -> &[f64]

Get the current strategy weights

pub fn strategies(&self) -> &[AdaptiveStrategy]

Get the current strategies

pub fn sample_losses(&self) -> &[f64]

Get sample losses

pub fn sample_difficulties(&self) -> &[f64]

Get sample difficulties

pub fn sample_frequencies(&self) -> &[usize]

Get sample frequencies

pub fn is_warming_up(&self) -> bool

Check if the sampler is in warmup phase

pub fn update_sample_losses(&mut self, sample_indices: &[usize], losses: &[f64])

Update sample losses from training

This method should be called after each training batch to update the sampler’s understanding of sample difficulty.

Arguments

• sample_indices - Indices of samples in the batch
• losses - Corresponding loss values for each sample

Panics

Panics if the lengths of sample_indices and losses don’t match.

pub fn set_epoch(&mut self, epoch: usize)

Set current epoch for adaptation tracking

Arguments

• epoch - Current training epoch

pub fn reset(&mut self)

Reset sampler state

pub fn adaptive_stats(&self) -> AdaptiveStats

Get statistics about the current adaptive sampling state

Trait Implementations

impl Clone for AdaptiveSampler

fn clone(&self) -> AdaptiveSampler

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Sampler for AdaptiveSampler

type Iter = SamplerIterator

Iterator type returned by the sampler

fn iter(&self) -> Self::Iter

Create an iterator over indices

fn len(&self) -> usize

Total number of samples that will be yielded

fn is_empty(&self) -> bool

Check if sampler is empty

fn into_batch_sampler( self, batch_size: usize, drop_last: bool, ) -> BatchingSampler<Self>

where Self: Sized,

Convert this sampler into a batch sampler

fn into_distributed( self, num_replicas: usize, rank: usize, ) -> DistributedWrapper<Self>

where Self: Sized,

Create a distributed version of this sampler