in which case I should use the monai.dataloader instead of torch.dataloader??

[Jingnan-Jia]

As we all know, pytorch has its own dataloader already. I found that monai also have a dataloader which inherate the original pytorch dataloader. The relative code is:

 class DataLoader(_TorchDataLoader):
    """Generates images/labels for train/validation/testing from dataset.
    It inherits from PyTorch DataLoader and adds default callbacks for `collate`
    and `worker_fn` if user doesn't set them.

    More information about PyTorch DataLoader, please check:
    https://github.com/pytorch/pytorch/blob/master/torch/utils/data/dataloader.py

    Args:
        dataset: dataset from which to load the data.
        num_workers: how many subprocesses to use for data
            loading. ``0`` means that the data will be loaded in the main process.
            (default: ``0``)
        kwargs: other parameters for PyTorch DataLoader.

    """

    def __init__(self, dataset: Dataset, num_workers: int = 0, **kwargs) -> None:
        if num_workers == 0:
            # when num_workers > 0, random states are determined by worker_init_fn
            # this is to make the behavior consistent when num_workers == 0
            # torch.int64 doesn't work well on some versions of windows
            _seed = torch.empty((), dtype=torch.int32).random_(generator=None).item()
            set_rnd(dataset, int(_seed))
        if "collate_fn" not in kwargs:
            kwargs.update({"collate_fn": list_data_collate})
        if "worker_init_fn" not in kwargs:
            kwargs.update({"worker_init_fn": worker_init_fn})

        super().__init__(  # type: ignore[call-overload]
            dataset=dataset,
            num_workers=num_workers,
            **kwargs,
        )

I know a new collate_fn is necessary because sometimes we have data augmentation like crop which can generate several patches for each image. In this case we need to reorganize the batch.

What I do not know is:

1. why we need a new worker_init_fn? I have seen the code of new worker_init_fn, its code is:

   def worker_init_fn(worker_id: int) -> None:
       """
       Callback function for PyTorch DataLoader `worker_init_fn`.
       It can set different random seed for the transforms in different workers.
   
       """
       worker_info = torch.utils.data.get_worker_info()
       set_rnd(worker_info.dataset, seed=worker_info.seed)
   

   I found the only difference between the new worker_init_fn and original worker_init_fn is the introduction of set_rnd(worker_info.dataset, seed=worker_info.seed) . But I donot know why we need this line?

2. Why we need the following lines:

           if num_workers == 0:
               # when num_workers > 0, random states are determined by worker_init_fn
               # this is to make the behavior consistent when num_workers == 0
               # torch.int64 doesn't work well on some versions of windows
               _seed = torch.empty((), dtype=torch.int32).random_(generator=None).item()
               set_rnd(dataset, int(_seed))
   

Or could you tell me in which case I should use the monai.dataloader instead of torch.dataloader??

[ericspod]

You should stick to MONAI's DataLoader if you have the choice. The things that have been changed are to ensure random number generation is reproducible. If that's not important to you then it probably won't matter which you use.