Struct ActiveLearningSampler 

pub struct ActiveLearningSampler { /* private fields */ }

Active learning sampler that prioritizes uncertain or informative samples

This sampler selects samples based on uncertainty estimates or other information-theoretic criteria to maximize learning efficiency with minimal labeling effort.

Examples

use torsh_data::sampler::{ActiveLearningSampler, AcquisitionStrategy, Sampler};

let mut sampler = ActiveLearningSampler::new(
    1000,
    AcquisitionStrategy::UncertaintySampling,
    10
).with_generator(42);

// Update with uncertainty scores from model
let uncertainties = vec![0.5; 1000]; // Mock uncertainties
sampler.update_uncertainties(uncertainties);

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

// Add labeled samples
sampler.add_labeled_samples(&indices);

Implementations

impl ActiveLearningSampler

pub fn new( dataset_size: usize, acquisition_strategy: AcquisitionStrategy, budget_per_round: usize, ) -> Self

Create a new active learning sampler

Arguments

• dataset_size - Total size of the dataset
• acquisition_strategy - Strategy for selecting samples
• budget_per_round - Number of samples to select per round

Examples

use torsh_data::sampler::{ActiveLearningSampler, AcquisitionStrategy};

let sampler = ActiveLearningSampler::new(
    1000,
    AcquisitionStrategy::UncertaintySampling,
    20
);

pub fn with_initial_labeled( dataset_size: usize, acquisition_strategy: AcquisitionStrategy, budget_per_round: usize, initial_labeled: &[usize], ) -> Self

Create an active learning sampler with initial labeled samples

Arguments

• dataset_size - Total size of the dataset
• acquisition_strategy - Strategy for selecting samples
• budget_per_round - Number of samples to select per round
• initial_labeled - Initially labeled sample indices

pub fn update_uncertainties(&mut self, uncertainties: Vec<f64>)

Update uncertainty scores for all samples

Arguments

• uncertainties - Uncertainty scores for each sample (higher = more uncertain)

Panics

Panics if the length of uncertainties doesn’t match the dataset size.

pub fn add_labeled_samples(&mut self, indices: &[usize])

Add newly labeled samples

Arguments

• indices - Indices of newly labeled samples

pub fn remove_labeled_samples(&mut self, indices: &[usize])

Remove samples from labeled set (useful for experimental scenarios)

Arguments

• indices - Indices to remove from labeled set

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

Set random generator seed

Arguments

• seed - Random seed for reproducible sampling

pub fn current_round(&self) -> usize

Get the current round number

pub fn budget_per_round(&self) -> usize

Get the budget per round

pub fn strategy(&self) -> &AcquisitionStrategy

Get the acquisition strategy

pub fn num_labeled(&self) -> usize

Get the number of labeled samples

pub fn num_unlabeled(&self) -> usize

Get the number of unlabeled samples

pub fn labeled_indices(&self) -> Vec<usize>

Get the labeled sample indices

pub fn get_unlabeled_indices(&self) -> Vec<usize>

Get unlabeled sample indices

pub fn is_labeled(&self, index: usize) -> bool

Check if a sample is labeled

pub fn set_strategy(&mut self, strategy: AcquisitionStrategy)

Set a new acquisition strategy

Arguments

• strategy - New acquisition strategy to use

pub fn set_budget(&mut self, budget: usize)

Set a new budget per round

Arguments

• budget - New budget per round

pub fn reset(&mut self)

Reset the sampler to initial state

pub fn active_learning_stats(&self) -> ActiveLearningStats

Get statistics about the current active learning state

Trait Implementations

impl Clone for ActiveLearningSampler

fn clone(&self) -> ActiveLearningSampler

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Sampler for ActiveLearningSampler

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