#![deny(missing_docs)]
use std::{convert::Infallible, marker::PhantomData};
use rusttorch_core::{Result, RustTorchError};
mod checkpoint;
mod collate;
mod dataset;
mod error;
mod limits;
mod loader;
mod memory;
mod pin_memory;
mod sampler;
mod stream;
mod transform;
mod worker;
mod worker_checkpoint;
mod worker_context;
pub use checkpoint::{
CheckpointActive, CheckpointBuildError, CheckpointDisabled, CheckpointFresh,
CheckpointIteration, CheckpointPinRequest, CheckpointPinStatus, CheckpointResume,
CheckpointSourceFactory, Checkpointable, CheckpointableSource, DatasetCheckpoint,
LOADER_STATE_SCHEMA_VERSION, LoaderConfiguration, LoaderState, ReplaySafeDataset, Stateless,
StatelessTransformFactory, StatelessWorker, StreamCheckpointBuildError,
StreamCheckpointConfiguration, StreamLaneState, StreamLoaderState, TransactionalCheckpoint,
TransactionalTransformFactory, TransactionalWorker, WorkerCheckpoint, WorkerCheckpointActive,
WorkerCheckpointIteration, WorkerLaneState, WorkerTransformLanes, WorkerTransformState,
};
pub use collate::{
Bytes, Collate, CollateError, DefaultCollate, DefaultCollator, DefaultConvert,
DefaultConverter, FnCollate, VecCollate,
};
pub use dataset::{
ConcatDataset, ReplaySafeMap, ReplaySafeTensorDataset, SplitLength, StackDataset, StackTuple,
Subset, TensorDataset, TransactionalMap, chain_datasets, random_split,
};
pub use error::{LoaderError, PipelineError};
pub use limits::ResourceLimits;
pub use loader::{
AutoBatch, BuilderDatasetMarker, CheckpointPlan, DataLoaderBuilder, ExplicitBatches,
LoaderIter, LoaderPlan, LoaderPlanConfiguration, NoBatch, OwnedDataLoader,
PlanCheckpointIdentity, SerialExecution, WorkerExecution, WorkerLoaderIter,
};
pub use memory::{MemoryDisabled, MemoryEnabled, MemoryFootprint};
pub use pin_memory::{Auto, Explicit, PinDisabled, PinEnabled, PinMemory, PinMemoryStatus};
pub use sampler::{
BatchSampler, BatchSamplerState, BatchSource, BatchSourceCheckpoint, DistributedConfiguration,
DistributedSampler, DistributedSamplerState, FnBatchSource, FnSampler, RandomReplacement,
RandomSampler, RandomSamplerState, Sampler, SamplerCheckpoint, SequentialSampler,
SequentialSamplerState, SubsetRandomSampler, SubsetRandomSamplerState, WeightedRandomSampler,
WeightedRandomSamplerState,
};
pub use stream::{
ExactStreamDataLoader, ExactStreamLoaderIter, LogicalSampleId, SequenceId, StreamDataLoader,
StreamDataLoaderBuilder, StreamLoaderIter, WorkerRecord, WorkerSourceFactory,
};
pub use transform::{
CloneTransformFactory, FnTransform, FnTransformFactory, IdentityTransform,
IdentityTransformFactory, TASK_RNG_DERIVATION_VERSION, TaskContext, Transform,
TransformFactory,
};
pub use worker_context::{
CancellationToken, Deadline, FnWorkerInit, LoaderCancelled, NoWorkerInit,
WORKER_SEED_DERIVATION_VERSION, WaitOutcome, WorkerContext, WorkerInfo, WorkerInit,
get_worker_info, with_worker_info,
};
pub trait Dataset {
type Sample;
type Error;
fn len(&self) -> usize;
fn get(&self, index: usize) -> std::result::Result<Self::Sample, Self::Error>;
fn get_batch(&self, indices: &[usize]) -> std::result::Result<Vec<Self::Sample>, Self::Error> {
indices.iter().map(|&index| self.get(index)).collect()
}
fn get_batch_with_context(
&self,
indices: &[usize],
context: &WorkerContext,
) -> std::result::Result<Vec<Self::Sample>, Self::Error> {
let _ = context;
self.get_batch(indices)
}
fn is_empty(&self) -> bool {
self.len() == 0
}
fn samples(&self) -> DatasetSamples<'_, Self>
where
Self: Sized,
{
DatasetSamples {
dataset: self,
next_index: 0,
}
}
}
pub struct DatasetSamples<'a, D> {
dataset: &'a D,
next_index: usize,
}
impl<D> Iterator for DatasetSamples<'_, D>
where
D: Dataset,
{
type Item = std::result::Result<D::Sample, D::Error>;
fn next(&mut self) -> Option<Self::Item> {
if self.next_index >= self.dataset.len() {
return None;
}
let index = self.next_index;
self.next_index += 1;
Some(self.dataset.get(index))
}
}
type IdentityCollate<T, E> = fn(Vec<T>) -> std::result::Result<Vec<T>, E>;
fn identity_batch<T, E>(samples: Vec<T>) -> std::result::Result<Vec<T>, E> {
Ok(samples)
}
struct DatasetBatchIterator<'a, D, S, C, B, E> {
dataset: &'a D,
sampler: S,
batch_size: usize,
drop_last: bool,
collate: C,
exhausted: bool,
output: PhantomData<fn() -> (B, E)>,
}
impl<D, S, C, B, E> Iterator for DatasetBatchIterator<'_, D, S, C, B, E>
where
D: Dataset,
S: Iterator<Item = usize>,
C: FnMut(Vec<D::Sample>) -> std::result::Result<B, E>,
E: From<D::Error>,
{
type Item = std::result::Result<B, E>;
fn next(&mut self) -> Option<Self::Item> {
if self.exhausted {
return None;
}
let mut indices = Vec::with_capacity(self.batch_size);
while indices.len() < self.batch_size {
match self.sampler.next() {
Some(index) => indices.push(index),
None => {
self.exhausted = true;
if indices.is_empty() {
return None;
}
break;
}
}
}
let samples = match self.dataset.get_batch(&indices) {
Ok(samples) => samples,
Err(error) => {
self.exhausted = true;
return Some(Err(E::from(error)));
}
};
assert_eq!(
samples.len(),
indices.len(),
"Dataset::get_batch returned {} samples for {} indices",
samples.len(),
indices.len()
);
if self.drop_last && indices.len() < self.batch_size {
return None;
}
let batch = (self.collate)(samples);
if batch.is_err() {
self.exhausted = true;
}
Some(batch)
}
}
struct BatchIterator<I, C, T, B, E> {
source: I,
batch_size: usize,
drop_last: bool,
collate: C,
exhausted: bool,
output: PhantomData<fn(T) -> (B, E)>,
}
impl<I, C, T, B, E> BatchIterator<I, C, T, B, E> {
fn new(source: I, batch_size: usize, drop_last: bool, collate: C) -> Result<Self> {
if batch_size == 0 {
return Err(RustTorchError::InvalidConfiguration {
field: "batch_size",
reason: "must be greater than zero".to_owned(),
});
}
Ok(Self {
source,
batch_size,
drop_last,
collate,
exhausted: false,
output: PhantomData,
})
}
}
impl<I, C, T, B, E> Iterator for BatchIterator<I, C, T, B, E>
where
I: Iterator<Item = std::result::Result<T, E>>,
C: FnMut(Vec<T>) -> std::result::Result<B, E>,
{
type Item = std::result::Result<B, E>;
fn next(&mut self) -> Option<Self::Item> {
if self.exhausted {
return None;
}
let first = match self.source.next() {
Some(Ok(sample)) => sample,
Some(Err(error)) => {
self.exhausted = true;
return Some(Err(error));
}
None => {
self.exhausted = true;
return None;
}
};
let mut samples = Vec::with_capacity(self.batch_size);
samples.push(first);
while samples.len() < self.batch_size {
match self.source.next() {
Some(Ok(sample)) => samples.push(sample),
Some(Err(error)) => {
self.exhausted = true;
return Some(Err(error));
}
None => {
self.exhausted = true;
if self.drop_last {
return None;
}
break;
}
}
}
let batch = (self.collate)(samples);
if batch.is_err() {
self.exhausted = true;
}
Some(batch)
}
}
pub fn batches<I, T, E>(
source: I,
batch_size: usize,
drop_last: bool,
) -> Result<impl Iterator<Item = std::result::Result<Vec<T>, E>>>
where
I: Iterator<Item = std::result::Result<T, E>>,
{
batches_with_collate(source, batch_size, drop_last, identity_batch::<T, E>)
}
pub fn batches_with_collate<I, C, T, B, E>(
source: I,
batch_size: usize,
drop_last: bool,
collate: C,
) -> Result<impl Iterator<Item = std::result::Result<B, E>>>
where
I: Iterator<Item = std::result::Result<T, E>>,
C: FnMut(Vec<T>) -> std::result::Result<B, E>,
{
BatchIterator::new(source, batch_size, drop_last, collate)
}
pub struct DataLoader<
'a,
D = BuilderDatasetMarker,
S = std::iter::Empty<usize>,
C = (),
B = (),
E = Infallible,
> where
D: Dataset,
{
batches: DatasetBatchIterator<'a, D, S, C, B, E>,
}
impl DataLoader<'static, BuilderDatasetMarker, std::iter::Empty<usize>, (), (), Infallible> {
pub fn builder<D>(
dataset: D,
) -> DataLoaderBuilder<D, AutoBatch<SequentialSampler>, DefaultCollator>
where
D: Dataset,
{
DataLoaderBuilder::new(dataset)
}
}
impl<'a, D, S> DataLoader<'a, D, S, IdentityCollate<D::Sample, D::Error>, Vec<D::Sample>, D::Error>
where
D: Dataset,
S: Iterator<Item = usize>,
{
pub fn new(dataset: &'a D, sampler: S, batch_size: usize, drop_last: bool) -> Result<Self> {
Self::with_collate(
dataset,
sampler,
batch_size,
drop_last,
identity_batch::<D::Sample, D::Error>,
)
}
}
impl<'a, D, S, C, B, E> DataLoader<'a, D, S, C, B, E>
where
D: Dataset,
S: Iterator<Item = usize>,
C: FnMut(Vec<D::Sample>) -> std::result::Result<B, E>,
E: From<D::Error>,
{
pub fn with_collate(
dataset: &'a D,
sampler: S,
batch_size: usize,
drop_last: bool,
collate: C,
) -> Result<Self> {
if batch_size == 0 {
return Err(RustTorchError::InvalidConfiguration {
field: "batch_size",
reason: "must be greater than zero".to_owned(),
});
}
Ok(Self {
batches: DatasetBatchIterator {
dataset,
sampler,
batch_size,
drop_last,
collate,
exhausted: false,
output: PhantomData,
},
})
}
}
impl<D, S, C, B, E> Iterator for DataLoader<'_, D, S, C, B, E>
where
D: Dataset,
S: Iterator<Item = usize>,
C: FnMut(Vec<D::Sample>) -> std::result::Result<B, E>,
E: From<D::Error>,
{
type Item = std::result::Result<B, E>;
fn next(&mut self) -> Option<Self::Item> {
self.batches.next()
}
}