How to improve file reading efficiency？

[morestart]

During training, the GPU utilization is not high, and it only reaches 100% after data loading is complete. I believe the bottleneck may lie in the data loading process. Are there any good methods to speed it up? This is my dataset and dataloader:

class GlobalDataset(Dataset):
    def __init__(
            self,
            input_data_list: list,
            target_data_list: list,
            use_roll: bool = True,
            is_train: bool = True,
    ):
        super().__init__()
        self.input_data_list = input_data_list
        self.target_data_list = target_data_list
        self.use_roll = use_roll
        self.is_train = is_train

    def __getitem__(self, item):
        input_data = torch.load(self.input_data_list[item])
        target_data = torch.load(self.target_data_list[item])

        img_shape_x, img_shape_y = input_data.shape[1:]

        if self.use_roll and self.is_train:
            y_roll = random.randint(0, img_shape_y)
        else:
            y_roll = 0
        input_data = torch.roll(input_data, y_roll, dims=-1).float()
        # target_data = torch.from_numpy(target_data)[:4, ...]
        return input_data, target_data

    def __len__(self):
        return len(self.input_data_list)

class GlobalForecastDatamodule(pl.LightningDataModule):
    def __init__(
            self,
            train_data_dir: str,
            val_data_dir: str,
            test_data_dir: str,
            # land_path: str,
            # soil_path: str,
            # topography_path: str,
            batch_size: int = 8,
            num_workers: int = 0,
            use_roll: bool = True
    ):
        super().__init__()
        self.train_data_dir = Path(train_data_dir)
        self.val_data_dir = Path(val_data_dir)
        self.test_data_dir = Path(test_data_dir)

        # self.land_mask = torch.from_numpy(np.load(land_path)).repeat(1, 1, 1)[..., 0:-1]
        # self.soil_mask = torch.from_numpy(np.load(soil_path)).repeat(1, 1, 1)[..., 0:-1]
        # self.topography_mask = torch.from_numpy(np.load(topography_path)).repeat(1, 1, 1)[..., 0:-1]

        self.batch_size = batch_size
        self.num_workers = num_workers

        self.use_roll = use_roll

        (self.train_input_files, self.train_target_files,
         self.val_input_files, self.val_target_files,
         self.test_input_files, self.test_target_files) = self.load_datasets()

    def load_datasets(self):
        train_p = self.train_data_dir
        logger.info(f'train data dir: {self.train_data_dir}')
        train_input_files = list(train_p.glob('*_input.pt'))
        train_target_files = list(train_p.glob('*_target.pt'))

        val_p = self.val_data_dir
        logger.info(f'val data dir: {self.val_data_dir}')
        val_input_files = list(val_p.glob('*_input.pt'))
        val_target_files = list(val_p.glob('*_target.pt'))

        test_p = self.test_data_dir
        logger.info(f'test data dir: {self.test_data_dir}')
        test_input_files = list(test_p.glob('*_input.pt'))
        test_target_files = list(test_p.glob('*_target.pt'))
        return train_input_files, train_target_files, val_input_files, val_target_files, test_input_files, test_target_files

    def train_dataloader(self):
        train_ds = GlobalDataset(self.train_input_files, self.train_target_files, is_train=True, use_roll=self.use_roll)
        return DataLoader(train_ds, batch_size=self.batch_size, shuffle=True, num_workers=self.num_workers,
                          pin_memory=True, prefetch_factor=self.num_workers * 2)

    def val_dataloader(self):
        val_ds = GlobalDataset(self.val_input_files, self.val_target_files, is_train=False, use_roll=False)
        return DataLoader(val_ds, batch_size=self.batch_size, shuffle=False, num_workers=self.num_workers,
                          pin_memory=True)

[morestart]

Epoch 0/99 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 519/236687 0:00:34 • 4:08:39 15.83it/s v_num: edw7
If using a batch size of 1, it can be kept at 15-16 items per second.
Increasing the batch size and the number of workers, the initial speed can be maintained at 15-16 iterations per second, but later it decreases to 1-2.