Using 3rd Party Data Iterables

When training a model on a specific task, data loading and preprocessing might become a bottleneck. Lightning does not enforce a specific data loading approach nor does it try to control it. The only assumption Lightning makes is that a valid iterable is provided.

For PyTorch-based programs, these iterables are typically instances of DataLoader. However, Lightning also supports other data types such as a list of batches, generators, or other custom iterables or collections of the former.

# random list of batches
data = [(torch.rand(32, 3, 32, 32), torch.randint(0, 10, (32,))) for _ in range(100)]
model = LitClassifier()
trainer = Trainer(), data)

Below we showcase Lightning examples with packages that compete with the generic PyTorch DataLoader and might be faster depending on your use case. They might require custom data serialization, loading, and preprocessing that is often hardware accelerated.


As datasets grow in size and the number of nodes scales, loading training data can become a significant challenge. The StreamingDataset can make training on large datasets from cloud storage as fast, cheap, and scalable as possible.

This library uses a custom built IterableDataset. The library recommends iterating through it via a regular DataLoader. This means that support in the Trainer is seamless:

import lightning as L
from streaming import MDSWriter, StreamingDataset

class YourDataset(StreamingDataset):

# you could do this in the `prepare_data` hook too
with MDSWriter(out="...", columns=...) as out:

train_dataset = YourDataset()
train_dataloader = DataLoader(train_dataset, batch_size=batch_size)
model = ...
trainer = L.Trainer(), train_dataloader)


Taking the example from the FFCV readme, we can use it with Lightning by just removing the hardcoded ToDevice(0) as Lightning takes care of GPU placement. In case you want to use some data transformations on GPUs, change the ToDevice(0) to ToDevice(self.trainer.local_rank) to correctly map to the desired GPU in your pipeline. When moving data to a specific device, you can always refer to self.trainer.local_rank to get the accelerator used by the current process.

import lightning as L
from ffcv.loader import Loader, OrderOption
from ffcv.transforms import ToTensor, ToDevice, ToTorchImage, Cutout
from ffcv.fields.decoders import IntDecoder, RandomResizedCropRGBImageDecoder

# Random resized crop
decoder = RandomResizedCropRGBImageDecoder((224, 224))
# Data decoding and augmentation
image_pipeline = [decoder, Cutout(), ToTensor(), ToTorchImage()]
label_pipeline = [IntDecoder(), ToTensor()]
# Pipeline for each data field
pipelines = {"image": image_pipeline, "label": label_pipeline}
# Replaces PyTorch data loader (``)
train_dataloader = Loader(
    write_path, batch_size=bs, num_workers=num_workers, order=OrderOption.RANDOM, pipelines=pipelines

model = ...
trainer = L.Trainer(), train_dataloader)


The WebDataset makes it easy to write I/O pipelines for large datasets. Datasets can be stored locally or in the cloud. WebDataset is just an instance of a standard IterableDataset. The webdataset library contains a small wrapper (WebLoader) that adds a fluid interface to the DataLoader (and is otherwise identical).

import lightning as L
import webdataset as wds

dataset = wds.WebDataset(urls)
train_dataloader = wds.WebLoader(dataset)

model = ...
trainer = L.Trainer(), train_dataloader)

You can find a complete example here.


By just changing device_id=0 to device_id=self.trainer.local_rank we can also leverage DALI’s GPU decoding:

import lightning as L
from nvidia.dali.pipeline import pipeline_def
import nvidia.dali.types as types
import nvidia.dali.fn as fn
from nvidia.dali.plugin.pytorch import DALIGenericIterator
import os

# To run with different data, see documentation of nvidia.dali.fn.readers.file
# points to
data_root_dir = os.environ["DALI_EXTRA_PATH"]
images_dir = os.path.join(data_root_dir, "db", "single", "jpeg")

@pipeline_def(num_threads=4, device_id=self.trainer.local_rank)
def get_dali_pipeline():
    images, labels = fn.readers.file(file_root=images_dir, random_shuffle=True, name="Reader")
    # decode data on the GPU
    images = fn.decoders.image_random_crop(images, device="mixed", output_type=types.RGB)
    # the rest of processing happens on the GPU as well
    images = fn.resize(images, resize_x=256, resize_y=256)
    images = fn.crop_mirror_normalize(
        mean=[0.485 * 255, 0.456 * 255, 0.406 * 255],
        std=[0.229 * 255, 0.224 * 255, 0.225 * 255],
    return images, labels

train_dataloader = DALIGenericIterator(
    ["data", "label"],

model = ...
trainer = L.Trainer(), train_dataloader)

You can find a complete tutorial here.


Lightning works with all kinds of custom data iterables as shown above. There are, however, a few features that cannot be supported this way. These restrictions come from the fact that for their support, Lightning needs to know a lot on the internals of these iterables.

  • In a distributed multi-GPU setting (ddp), Lightning wraps the DataLoader’s sampler with a wrapper for distributed support. This makes sure that each GPU sees a different part of the dataset. As sampling can be implemented in arbitrary ways with custom iterables, Lightning might not be able to do this for you. If this is the case, you can use the use_distributed_sampler argument to disable this logic and set the distributed sampler yourself.