Struct DataLoaderBuilder 

pub struct DataLoaderBuilder<D: Dataset> { /* private fields */ }

Builder for DataLoader

Provides a fluent API for configuring DataLoader instances with various options such as batch size, shuffling, number of workers, and memory pinning.

Examples

use torsh_data::dataloader::core::DataLoaderBuilder;
use torsh_data::dataset::TensorDataset;

let dataset = TensorDataset::new(vec![1, 2, 3, 4, 5]);
let dataloader = DataLoaderBuilder::new(dataset)
    .batch_size(32)
    .shuffle(true)
    .num_workers(4)
    .pin_memory(true)
    .drop_last(true)
    .build()?;

Implementations

impl<D: Dataset> DataLoaderBuilder<D>

pub fn new(dataset: D) -> Self

Create a new builder

Arguments

• dataset - The dataset to create a DataLoader for

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

Set batch size

Arguments

• batch_size - Number of samples per batch

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

Set whether to shuffle the data

Arguments

• shuffle - Whether to randomly shuffle the dataset

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

Set the number of worker threads

Arguments

• num_workers - Number of worker threads for parallel data loading

pub fn pin_memory(self, pin_memory: bool) -> Self

Set whether to pin memory

Arguments

• pin_memory - Whether to pin memory for faster GPU transfers

pub fn drop_last(self, drop_last: bool) -> Self

Set whether to drop the last incomplete batch

Arguments

• drop_last - Whether to drop the last batch if it’s smaller than batch_size

pub fn timeout(self, timeout: Duration) -> Self

Set timeout for collecting a batch

Arguments

• timeout - Maximum time to wait for batch collection

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

Set random generator seed

Arguments

• seed - Random seed for reproducible shuffling

pub fn build( self, ) -> Result<DataLoader<D, BatchingSampler<SequentialSampler>, DefaultCollate>>

Build the DataLoader with sequential sampling

Creates a DataLoader that processes the dataset in sequential order. This is the default behavior when shuffle is false or not specified.

pub fn build_with_random_sampling( self, ) -> Result<DataLoader<D, BatchingSampler<RandomSampler>, DefaultCollate>>

Build the DataLoader with random sampling (shuffled)

Creates a DataLoader that randomly shuffles the dataset order. Useful for training scenarios where data order should be randomized.

pub fn build_auto( self, ) -> Result<Box<dyn DataLoaderTrait<D, DefaultCollate> + Send + Sync>>

where D: Send + Sync + 'static, D::Item: Send + Sync + 'static, DefaultCollate: Collate<D::Item>, <DefaultCollate as Collate<D::Item>>::Output: Send,

Build the DataLoader with auto-selected sampling strategy

Automatically chooses between sequential and random sampling based on the shuffle setting configured in the builder.