Struct DistributedWrapper 

pub struct DistributedWrapper<S: Sampler> { /* private fields */ }

Wrapper that makes any sampler work in a distributed setting

This wrapper takes an underlying sampler and distributes its indices across multiple replicas (processes). Each replica gets a disjoint subset of the indices, ensuring no overlap between processes.

Examples

use torsh_data::sampler::{SequentialSampler, DistributedWrapper, Sampler};

let base_sampler = SequentialSampler::new(10);
// Process 0 of 2 processes
let distributed = DistributedWrapper::new(base_sampler, 2, 0);

let indices: Vec<usize> = distributed.iter().collect();
// Process 0 gets: [0, 2, 4, 6, 8]
// Process 1 would get: [1, 3, 5, 7, 9]

Implementations

impl<S: Sampler> DistributedWrapper<S>

pub fn new(sampler: S, num_replicas: usize, rank: usize) -> Self

Create a new distributed wrapper

Arguments

• sampler - The underlying sampler to distribute
• num_replicas - Total number of processes
• rank - Current process rank (0-based)

Panics

Panics if num_replicas is 0 or rank >= num_replicas

pub fn with_shuffle(self, shuffle: bool) -> Self

Enable or disable shuffling

When shuffling is enabled, the indices are shuffled before distribution. This ensures different ordering across epochs.

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

Set the random number generator seed

Arguments

• seed - Random seed for reproducible shuffling

pub fn num_replicas(&self) -> usize

Get the number of replicas

pub fn rank(&self) -> usize

Get the current rank

pub fn shuffle(&self) -> bool

Check if shuffling is enabled

pub fn generator(&self) -> Option<u64>

Get the generator seed if set

pub fn sampler(&self) -> &S

Get a reference to the underlying sampler

pub fn into_sampler(self) -> S

Get the underlying sampler by value

Trait Implementations

impl<S: Clone + Sampler> Clone for DistributedWrapper<S>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Sampler> Debug for DistributedWrapper<S>

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

Formats the value using the given formatter.

impl<S: Sampler> Sampler for DistributedWrapper<S>

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