34class CLDataset(LightningDataModule):
 35    r"""The base class of continual learning datasets."""
 36
 37    def __init__(
 38        self,
 39        root: str | dict[int, str],
 40        num_tasks: int,
 41        batch_size: int | dict[int, int] = 1,
 42        num_workers: int | dict[int, int] = 0,
 43        custom_transforms: (
 44            Callable
 45            | transforms.Compose
 46            | None
 47            | dict[int, Callable | transforms.Compose | None]
 48        ) = None,
 49        repeat_channels: int | None | dict[int, int | None] = None,
 50        to_tensor: bool | dict[int, bool] = True,
 51        resize: tuple[int, int] | None | dict[int, tuple[int, int] | None] = None,
 52    ) -> None:
 53        r"""
 54        **Args:**
 55        - **root** (`str` | `dict[int, str]`): the root directory where the original data files for constructing the CL dataset physically live.
 56        If it is a dict, the keys are task IDs and the values are the root directories for each task. If it is a string, it is the same root directory for all tasks.
 57        - **num_tasks** (`int`): the maximum number of tasks supported by the CL dataset. This decides the valid task IDs from 1 to `num_tasks`.
 58        - **batch_size** (`int` | `dict[int, int]`): the batch size for train, val, and test dataloaders.
 59        If it is a dict, the keys are task IDs and the values are the batch sizes for each task. If it is an `int`, it is the same batch size for all tasks.
 60        - **num_workers** (`int` | `dict[int, int]`): the number of workers for dataloaders.
 61        If it is a dict, the keys are task IDs and the values are the number of workers for each task. If it is an `int`, it is the same number of workers for all tasks.
 62        - **custom_transforms** (`transform` or `transforms.Compose` or `None` or dict of them): the custom transforms to apply ONLY to the TRAIN dataset. Can be a single transform, composed transforms, or no transform. `ToTensor()`, normalization, permute, and so on are not included.
 63        If it is a dict, the keys are task IDs and the values are the custom transforms for each task. If it is a single transform or composed transforms, it is applied to all tasks. If it is `None`, no custom transforms are applied.
 64        - **repeat_channels** (`int` | `None` | dict of them): the number of channels to repeat for each task. Default is `None`, which means no repeat.
 65        If it is a dict, the keys are task IDs and the values are the number of channels to repeat for each task. If it is an `int`, it is the same number of channels to repeat for all tasks. If it is `None`, no repeat is applied.
 66        - **to_tensor** (`bool` | `dict[int, bool]`): whether to include the `ToTensor()` transform. Default is `True`.
 67        If it is a dict, the keys are task IDs and the values are whether to include the `ToTensor()` transform for each task. If it is a single boolean value, it is applied to all tasks.
 68        - **resize** (`tuple[int, int]` | `None` or dict of them): the size to resize the images to. Default is `None`, which means no resize.
 69        If it is a dict, the keys are task IDs and the values are the sizes to resize for each task. If it is a single tuple of two integers, it is applied to all tasks. If it is `None`, no resize is applied.
 70        """
 71        super().__init__()
 72
 73        self.root: dict[int, str] = (
 74            OmegaConf.to_container(root)
 75            if isinstance(root, DictConfig)
 76            else {t: root for t in range(1, num_tasks + 1)}
 77        )
 78        r"""The dict of root directories of the original data files for each task."""
 79        self.num_tasks: int = num_tasks
 80        r"""The maximum number of tasks supported by the dataset."""
 81        self.cl_paradigm: str
 82        r"""The continual learning paradigm."""
 83        self.batch_size: dict[int, int] = (
 84            OmegaConf.to_container(batch_size)
 85            if isinstance(batch_size, DictConfig)
 86            else {t: batch_size for t in range(1, num_tasks + 1)}
 87        )
 88        r"""The dict of batch sizes for each task."""
 89        self.num_workers: dict[int, int] = (
 90            OmegaConf.to_container(num_workers)
 91            if isinstance(num_workers, DictConfig)
 92            else {t: num_workers for t in range(1, num_tasks + 1)}
 93        )
 94        r"""The dict of numbers of workers for each task."""
 95        self.custom_transforms: dict[int, Callable | transforms.Compose | None] = (
 96            OmegaConf.to_container(custom_transforms)
 97            if isinstance(custom_transforms, DictConfig)
 98            else {t: custom_transforms for t in range(1, num_tasks + 1)}
 99        )
100        r"""The dict of custom transforms for each task."""
101        self.repeat_channels: dict[int, int | None] = (
102            OmegaConf.to_container(repeat_channels)
103            if isinstance(repeat_channels, DictConfig)
104            else {t: repeat_channels for t in range(1, num_tasks + 1)}
105        )
106        r"""The dict of number of channels to repeat for each task."""
107        self.to_tensor: dict[int, bool] = (
108            OmegaConf.to_container(to_tensor)
109            if isinstance(to_tensor, DictConfig)
110            else {t: to_tensor for t in range(1, num_tasks + 1)}
111        )
112        r"""The dict of to_tensor flag for each task. """
113        self.resize: dict[int, tuple[int, int] | None] = (
114            {t: tuple(rs) if rs else None for t, rs in resize.items()}
115            if isinstance(resize, DictConfig)
116            else {
117                t: (tuple(resize) if resize else None) for t in range(1, num_tasks + 1)
118            }
119        )
120        r"""The dict of sizes to resize to for each task."""
121
122        # task-specific attributes
123        self.root_t: str
124        r"""The root directory of the original data files for the current task `self.task_id`."""
125        self.batch_size_t: int
126        r"""The batch size for the current task `self.task_id`."""
127        self.num_workers_t: int
128        r"""The number of workers for the current task `self.task_id`."""
129        self.custom_transforms_t: Callable | transforms.Compose | None
130        r"""The custom transforms for the current task `self.task_id`."""
131        self.repeat_channels_t: int | None
132        r"""The number of channels to repeat for the current task `self.task_id`."""
133        self.to_tensor_t: bool
134        r"""The to_tensor flag for the current task `self.task_id`."""
135        self.resize_t: tuple[int, int] | None
136        r"""The size to resize for the current task `self.task_id`."""
137        self.mean_t: float
138        r"""The mean values for normalization for the current task `self.task_id`."""
139        self.std_t: float
140        r"""The standard deviation values for normalization for the current task `self.task_id`."""
141
142        # dataset containers
143        self.dataset_train_t: Any
144        r"""The training dataset object. Can be a PyTorch Dataset object or any other dataset object."""
145        self.dataset_val_t: Any
146        r"""The validation dataset object. Can be a PyTorch Dataset object or any other dataset object."""
147        self.dataset_test: dict[int, Any] = {}
148        r"""The dictionary to store test dataset object of each task. Keys are task IDs and values are the dataset objects. Can be PyTorch Dataset objects or any other dataset objects."""
149
150        # task ID control
151        self.task_id: int
152        r"""Task ID counter indicating which task is being processed. Self updated during the task loop. Valid from 1 to the number of tasks in the CL dataset."""
153        self.processed_task_ids: list[int] = []
154        r"""Task IDs that have been processed."""
155
156        CLDataset.sanity_check(self)
157
158    def sanity_check(self) -> None:
159        r"""Sanity check."""
160
161        # check if each task has been provided with necessary arguments
162        for attr in [
163            "root",
164            "batch_size",
165            "num_workers",
166            "custom_transforms",
167            "repeat_channels",
168            "to_tensor",
169            "resize",
170        ]:
171            value = getattr(self, attr)
172            expected_keys = set(range(1, self.num_tasks + 1))
173            if set(value.keys()) != expected_keys:
174                raise ValueError(
175                    f"{attr} dict keys must be consecutive integers from 1 to num_tasks."
176                )
177
178    @abstractmethod
179    def get_cl_class_map(self, task_id: int) -> dict[str | int, int]:
180        r"""Get the mapping of classes of task `task_id` to fit continual learning settings `self.cl_paradigm`. It must be implemented by subclasses.
181
182        **Args:**
183        - **task_id** (`int`): the task ID to query the CL class map.
184
185        **Returns:**
186        - **cl_class_map** (`dict[str | int, int]`): the CL class map of the task. Keys are the original class labels and values are the integer class label for continual learning.
187            - If `self.cl_paradigm` is 'TIL', the mapped class labels of each task should be continuous integers from 0 to the number of classes.
188            - If `self.cl_paradigm` is 'CIL', the mapped class labels of each task should be continuous integers from the number of classes of previous tasks to the number of classes of the current task.
189        """
190
191    @abstractmethod
192    def prepare_data(self) -> None:
193        r"""Use this to download and prepare data. It must be implemented by subclasses, as required by `LightningDataModule`. This method is called at the beginning of each task."""
194
195    def setup(self, stage: str) -> None:
196        r"""Set up the dataset for different stages. This method is called at the beginning of each task.
197
198        **Args:**
199        - **stage** (`str`): the stage of the experiment; one of:
200            - 'fit': training and validation datasets of the current task `self.task_id` are assigned to `self.dataset_train_t` and `self.dataset_val_t`.
201            - 'test': a dict of test datasets of all seen tasks should be assigned to `self.dataset_test`.
202        """
203        if stage == "fit":
204            # these two stages must be done together because a sanity check for validation is conducted before training
205            pylogger.debug(
206                "Construct train and validation dataset for task %d...", self.task_id
207            )
208
209            self.dataset_train_t, self.dataset_val_t = self.train_and_val_dataset()
210
211            pylogger.info(
212                "Train and validation dataset for task %d are ready.", self.task_id
213            )
214            pylogger.info(
215                "Train dataset for task %d size: %d",
216                self.task_id,
217                len(self.dataset_train_t),
218            )
219            pylogger.info(
220                "Validation dataset for task %d size: %d",
221                self.task_id,
222                len(self.dataset_val_t),
223            )
224
225        elif stage == "test":
226
227            pylogger.debug("Construct test dataset for task %d...", self.task_id)
228
229            self.dataset_test[self.task_id] = self.test_dataset()
230
231            pylogger.info("Test dataset for task %d are ready.", self.task_id)
232            pylogger.info(
233                "Test dataset for task %d size: %d",
234                self.task_id,
235                len(self.dataset_test[self.task_id]),
236            )
237
238    def setup_task_id(self, task_id: int) -> None:
239        r"""Set up which task's dataset the CL experiment is on. This must be done before `setup()` method is called.
240
241        **Args:**
242        - **task_id** (`int`): the target task ID.
243        """
244
245        self.task_id = task_id
246
247        self.root_t = self.root[task_id]
248        self.batch_size_t = self.batch_size[task_id]
249        self.num_workers_t = self.num_workers[task_id]
250        self.custom_transforms_t = self.custom_transforms[task_id]
251        self.repeat_channels_t = self.repeat_channels[task_id]
252        self.to_tensor_t = self.to_tensor[task_id]
253        self.resize_t = self.resize[task_id]
254
255        self.processed_task_ids.append(task_id)
256
257    def setup_tasks_eval(self, eval_tasks: list[int]) -> None:
258        r"""Set up tasks for continual learning main evaluation.
259
260        **Args:**
261        - **eval_tasks** (`list[int]`): the list of task IDs to evaluate.
262        """
263        for task_id in eval_tasks:
264            self.setup_task_id(task_id=task_id)
265            self.setup(stage="test")
266
267    def set_cl_paradigm(self, cl_paradigm: str) -> None:
268        r"""Set `cl_paradigm` to `self.cl_paradigm`. It is used to define the CL class map.
269
270        **Args:**
271        - **cl_paradigm** (`str`): the continual learning paradigm, either 'TIL' (Task-Incremental Learning) or 'CIL' (Class-Incremental Learning).
272        """
273        self.cl_paradigm = cl_paradigm
274
275    def train_and_val_transforms(self) -> transforms.Compose:
276        r"""Transforms for training and validation datasets, incorporating the custom transforms with basic transforms like normalization and `ToTensor()`. It can be used in subclasses when constructing the dataset.
277
278        **Returns:**
279        - **train_and_val_transforms** (`transforms.Compose`): the composed train/val transforms.
280        """
281        repeat_channels_transform = (
282            transforms.Grayscale(num_output_channels=self.repeat_channels_t)
283            if self.repeat_channels_t is not None
284            else None
285        )
286        to_tensor_transform = transforms.ToTensor() if self.to_tensor_t else None
287        resize_transform = (
288            transforms.Resize(self.resize_t) if self.resize_t is not None else None
289        )
290        normalization_transform = transforms.Normalize(self.mean_t, self.std_t)
291
292        return transforms.Compose(
293            list(
294                filter(
295                    None,
296                    [
297                        repeat_channels_transform,
298                        to_tensor_transform,
299                        resize_transform,
300                        self.custom_transforms_t,
301                        normalization_transform,
302                    ],
303                )
304            )
305        )  # the order of transforms matters
306
307    def test_transforms(self) -> transforms.Compose:
308        r"""Transforms for the test dataset. Only basic transforms like normalization and `ToTensor()` are included. It is used in subclasses when constructing the dataset.
309
310        **Returns:**
311        - **test_transforms** (`transforms.Compose`): the composed test transforms.
312        """
313        repeat_channels_transform = (
314            transforms.Grayscale(num_output_channels=self.repeat_channels_t)
315            if self.repeat_channels_t is not None
316            else None
317        )
318        to_tensor_transform = transforms.ToTensor() if self.to_tensor_t else None
319        resize_transform = (
320            transforms.Resize(self.resize_t) if self.resize_t is not None else None
321        )
322        normalization_transform = transforms.Normalize(self.mean_t, self.std_t)
323
324        return transforms.Compose(
325            list(
326                filter(
327                    None,
328                    [
329                        repeat_channels_transform,
330                        to_tensor_transform,
331                        resize_transform,
332                        normalization_transform,
333                    ],
334                )
335            )
336        )  # the order of transforms matters. No custom transforms for test
337
338    def target_transform(self) -> ClassMapping:
339        r"""Target transform to map the original class labels to CL class labels according to `self.cl_paradigm`. It can be used in subclasses when constructing the dataset.
340
341        **Returns:**
342        - **target_transform** (`Callable`): the target transform function.
343        """
344
345        cl_class_map = self.get_cl_class_map(task_id=self.task_id)
346
347        target_transform = ClassMapping(class_map=cl_class_map)
348
349        return target_transform
350
351    @abstractmethod
352    def train_and_val_dataset(self) -> tuple[Any, Any]:
353        r"""Get the training and validation datasets of the current task `self.task_id`. It must be implemented by subclasses.
354
355        **Returns:**
356        - **train_and_val_dataset** (`tuple[Any, Any]`): the train and validation datasets of the current task `self.task_id`.
357        """
358
359    @abstractmethod
360    def test_dataset(self) -> Any:
361        r"""Get the test dataset of the current task `self.task_id`. It must be implemented by subclasses.
362
363        **Returns:**
364        - **test_dataset** (`Any`): the test dataset of the current task `self.task_id`.
365        """
366
367    def train_dataloader(self) -> DataLoader:
368        r"""DataLoader generator for the train stage of the current task `self.task_id`. It is automatically called before training the task.
369
370        **Returns:**
371        - **train_dataloader** (`DataLoader`): the train DataLoader of task `self.task_id`.
372        """
373
374        pylogger.debug("Construct train dataloader for task %d...", self.task_id)
375
376        return DataLoader(
377            dataset=self.dataset_train_t,
378            batch_size=self.batch_size_t,
379            shuffle=True,  # shuffle train batch to prevent overfitting
380            num_workers=self.num_workers_t,
381            drop_last=True,  # to avoid batchnorm error (when batch_size is 1)
382        )
383
384    def val_dataloader(self) -> DataLoader:
385        r"""DataLoader generator for the validation stage of the current task `self.task_id`. It is automatically called before the task's validation.
386
387        **Returns:**
388        - **val_dataloader** (`DataLoader`): the validation DataLoader of task `self.task_id`.
389        """
390
391        pylogger.debug("Construct validation dataloader for task %d...", self.task_id)
392
393        return DataLoader(
394            dataset=self.dataset_val_t,
395            batch_size=self.batch_size_t,
396            shuffle=False,  # don't have to shuffle val or test batch
397            num_workers=self.num_workers_t,
398        )
399
400    def test_dataloader(self) -> dict[int, DataLoader]:
401        r"""DataLoader generator for the test stage of the current task `self.task_id`. It is automatically called before testing the task.
402
403        **Returns:**
404        - **test_dataloader** (`dict[int, DataLoader]`): the test DataLoader dict of `self.task_id` and all tasks before (as the test is conducted on all seen tasks). Keys are task IDs and values are the DataLoaders.
405        """
406
407        pylogger.debug("Construct test dataloader for task %d...", self.task_id)
408
409        return {
410            task_id: DataLoader(
411                dataset=dataset_test_t,
412                batch_size=self.batch_size_t,
413                shuffle=False,  # don't have to shuffle val or test batch
414                num_workers=self.num_workers_t,
415            )
416            for task_id, dataset_test_t in self.dataset_test.items()
417        }
418
419    def __len__(self) -> int:
420        r"""Get the number of tasks in the dataset.
421
422        **Returns:**
423        - **num_tasks** (`int`): the number of tasks in the dataset.
424        """
425        return self.num_tasks

428class CLPermutedDataset(CLDataset):
429    r"""The base class of continual learning datasets constructed as permutations of an original dataset."""
430
431    original_dataset_python_class: type[Dataset]
432    r"""The original dataset class. **It must be provided in subclasses.** """
433
434    def __init__(
435        self,
436        root: str,
437        num_tasks: int,
438        batch_size: int | dict[int, int] = 1,
439        num_workers: int | dict[int, int] = 0,
440        custom_transforms: (
441            Callable
442            | transforms.Compose
443            | None
444            | dict[int, Callable | transforms.Compose | None]
445        ) = None,
446        repeat_channels: int | None | dict[int, int | None] = None,
447        to_tensor: bool | dict[int, bool] = True,
448        resize: tuple[int, int] | None | dict[int, tuple[int, int] | None] = None,
449        permutation_mode: str = "first_channel_only",
450        permutation_seeds: dict[int, int] | None = None,
451    ) -> None:
452        r"""
453        **Args:**
454        - **root** (`str`): the root directory where the original dataset live.
455        - **num_tasks** (`int`): the maximum number of tasks supported by the CL dataset. This decides the valid task IDs from 1 to `num_tasks`.
456        - **batch_size** (`int` | `dict[int, int]`): the batch size for train, val, and test dataloaders.
457        If it is a dict, the keys are task IDs and the values are the batch sizes for each task. If it is an `int`, it is the same batch size for all tasks.
458        - **num_workers** (`int` | `dict[int, int]`): the number of workers for dataloaders.
459        If it is a dict, the keys are task IDs and the values are the number of workers for each task. If it is an `int`, it is the same number of workers for all tasks.
460        - **custom_transforms** (`transform` or `transforms.Compose` or `None` or dict of them): the custom transforms to apply ONLY to the TRAIN dataset. Can be a single transform, composed transforms, or no transform. `ToTensor()`, normalization, permute, and so on are not included.
461        If it is a dict, the keys are task IDs and the values are the custom transforms for each task. If it is a single transform or composed transforms, it is applied to all tasks. If it is `None`, no custom transforms are applied.
462        - **repeat_channels** (`int` | `None` | dict of them): the number of channels to repeat for each task. Default is `None`, which means no repeat.
463        If it is a dict, the keys are task IDs and the values are the number of channels to repeat for each task. If it is an `int`, it is the same number of channels to repeat for all tasks. If it is `None`, no repeat is applied.
464        - **to_tensor** (`bool` | `dict[int, bool]`): whether to include the `ToTensor()` transform. Default is `True`.
465        If it is a dict, the keys are task IDs and the values are whether to include the `ToTensor()` transform for each task. If it is a single boolean value, it is applied to all tasks.
466        - **resize** (`tuple[int, int]` | `None` or dict of them): the size to resize the images to. Default is `None`, which means no resize.
467        If it is a dict, the keys are task IDs and the values are the sizes to resize for each task. If it is a single tuple of two integers, it is applied to all tasks. If it is `None`, no resize is applied.
468        - **permutation_mode** (`str`): the mode of permutation; one of:
469            1. 'all': permute all pixels.
470            2. 'by_channel': permute channel by channel separately. All channels are applied the same permutation order.
471            3. 'first_channel_only': permute only the first channel.
472        - **permutation_seeds** (`dict[int, int]` | `None`): the dict of seeds for permutation operations used to construct each task. Keys are task IDs and the values are permutation seeds for each task. Default is `None`, which creates a dict of seeds from 0 to `num_tasks`-1.
473        """
474        super().__init__(
475            root=root,
476            num_tasks=num_tasks,
477            batch_size=batch_size,
478            num_workers=num_workers,
479            custom_transforms=custom_transforms,
480            repeat_channels=repeat_channels,
481            to_tensor=to_tensor,
482            resize=resize,
483        )
484
485        self.original_dataset_constants: type[DatasetConstants] = (
486            DATASET_CONSTANTS_MAPPING[self.original_dataset_python_class]
487        )
488        r"""The original dataset constants class."""
489
490        self.permutation_mode: str = permutation_mode
491        r"""The mode of permutation."""
492        self.permutation_seeds: dict[int, int] = (
493            permutation_seeds
494            if permutation_seeds
495            else {t: t - 1 for t in range(1, num_tasks + 1)}
496        )
497        r"""The dict of permutation seeds for each task."""
498
499        self.permutation_seed_t: int
500        r"""The permutation seed for the current task `self.task_id`."""
501        self.permute_transform_t: Permute
502        r"""The permutation transform for the current task `self.task_id`."""
503
504        CLPermutedDataset.sanity_check(self)
505
506    def sanity_check(self) -> None:
507        r"""Sanity check."""
508
509        # check the permutation mode
510        if self.permutation_mode not in ["all", "by_channel", "first_channel_only"]:
511            raise ValueError(
512                "The permutation_mode should be one of 'all', 'by_channel', 'first_channel_only'."
513            )
514
515        # check the permutation seeds
516        expected_keys = set(range(1, self.num_tasks + 1))
517        if set(self.permutation_seeds.keys()) != expected_keys:
518            raise ValueError(
519                f"{self.permutation_seeds} dict keys must be consecutive integers from 1 to num_tasks."
520            )
521
522    def get_cl_class_map(self, task_id: int) -> dict[str | int, int]:
523        r"""Get the mapping of classes of task `task_id` to fit continual learning settings `self.cl_paradigm`.
524
525        **Args:**
526        - **task_id** (`int`): the task ID to query the CL class map.
527
528        **Returns:**
529        - **cl_class_map** (`dict[str | int, int]`): the CL class map of the task. Keys are the original class labels and values are the integer class label for continual learning.
530            - If `self.cl_paradigm` is 'TIL', the mapped class labels of a task should be continuous integers from 0 to the number of classes.
531            - If `self.cl_paradigm` is 'CIL', the mapped class labels of a task should be continuous integers from the number of classes of previous tasks to the number of classes of the current task.
532        """
533
534        num_classes_t = (
535            self.original_dataset_constants.NUM_CLASSES
536        )  # the same with the original dataset
537        class_map_t = (
538            self.original_dataset_constants.CLASS_MAP
539        )  # the same with the original dataset
540
541        if self.cl_paradigm == "TIL":
542            return {class_map_t[i]: i for i in range(num_classes_t)}
543        if self.cl_paradigm == "CIL":
544            return {
545                class_map_t[i]: i + (task_id - 1) * num_classes_t
546                for i in range(num_classes_t)
547            }
548
549    def setup_task_id(self, task_id: int) -> None:
550        r"""Set up which task's dataset the CL experiment is on. This must be done before `setup()` method is called.
551
552        **Args:**
553        - **task_id** (`int`): the target task ID.
554        """
555
556        CLDataset.setup_task_id(self, task_id)
557
558        self.mean_t = (
559            self.original_dataset_constants.MEAN
560        )  # the same with the original dataset
561        self.std_t = (
562            self.original_dataset_constants.STD
563        )  # the same with the original dataset
564
565        num_channels = (
566            self.original_dataset_constants.NUM_CHANNELS
567            if self.repeat_channels_t is None
568            else self.repeat_channels_t
569        )
570
571        if (
572            hasattr(self.original_dataset_constants, "IMG_SIZE")
573            or self.resize_t is not None
574        ):
575            img_size = (
576                self.original_dataset_constants.IMG_SIZE
577                if self.resize_t is None
578                else torch.Size(self.resize_t)
579            )
580        else:
581            raise AttributeError(
582                "The original dataset has different image sizes. Please resize the images to a fixed size by specifying hyperparameter: resize."
583            )
584
585        # set up the permutation transform
586        self.permutation_seed_t = self.permutation_seeds[task_id]
587        self.permute_transform_t = Permute(
588            num_channels=num_channels,
589            img_size=img_size,
590            mode=self.permutation_mode,
591            seed=self.permutation_seed_t,
592        )
593
594    def train_and_val_transforms(self) -> transforms.Compose:
595        r"""Transforms for training and validation datasets, incorporating the custom transforms with basic transforms like normalization and `ToTensor()`. In permuted CL datasets, a permute transform also applies.
596
597        **Returns:**
598        - **train_and_val_transforms** (`transforms.Compose`): the composed train/val transforms.
599        """
600
601        repeat_channels_transform = (
602            transforms.Grayscale(num_output_channels=self.repeat_channels_t)
603            if self.repeat_channels_t is not None
604            else None
605        )
606        to_tensor_transform = transforms.ToTensor() if self.to_tensor_t else None
607        resize_transform = (
608            transforms.Resize(self.resize_t) if self.resize_t is not None else None
609        )
610        normalization_transform = transforms.Normalize(self.mean_t, self.std_t)
611
612        return transforms.Compose(
613            list(
614                filter(
615                    None,
616                    [
617                        repeat_channels_transform,
618                        to_tensor_transform,
619                        resize_transform,
620                        self.permute_transform_t,  # permutation is included here
621                        self.custom_transforms_t,
622                        normalization_transform,
623                    ],
624                )
625            )
626        )  # the order of transforms matters
627
628    def test_transforms(self) -> transforms.Compose:
629        r"""Transforms for the test dataset. Only basic transforms like normalization and `ToTensor()` are included. In permuted CL datasets, a permute transform also applies.
630
631        **Returns:**
632        - **test_transforms** (`transforms.Compose`): the composed test transforms.
633        """
634
635        repeat_channels_transform = (
636            transforms.Grayscale(num_output_channels=self.repeat_channels_t)
637            if self.repeat_channels_t is not None
638            else None
639        )
640        to_tensor_transform = transforms.ToTensor() if self.to_tensor_t else None
641        resize_transform = (
642            transforms.Resize(self.resize_t) if self.resize_t is not None else None
643        )
644        normalization_transform = transforms.Normalize(self.mean_t, self.std_t)
645
646        return transforms.Compose(
647            list(
648                filter(
649                    None,
650                    [
651                        repeat_channels_transform,
652                        to_tensor_transform,
653                        resize_transform,
654                        self.permute_transform_t,  # permutation is included here
655                        normalization_transform,
656                    ],
657                )
658            )
659        )  # the order of transforms matters. No custom transforms for test