Upload 28 files

datasets/beans.py

@@ -0,0 +1,171 @@
+import torch
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+from typing import Tuple, Dict
+import os
+
+
+class BeanDataModule:
+    def __init__(
+        self,
+        preprocess: bool = True,
+        data_dir: str = "theRestDataset/beans",
+        batch_size: int = 32,
+        image_size: int = 224,
+        num_workers: int = 4,
+        pin_memory: bool = True,
+    ):
+        """
+        Initialize the Bean Disease DataModule.
+
+        Args:
+            data_dir (str): Root directory of the dataset
+            batch_size (int): Batch size for training and testing
+            image_size (int): Size of the input images
+            num_workers (int): Number of workers for data loading
+            pin_memory (bool): Whether to pin memory for GPU training
+        """
+        self.preprocess = preprocess
+        self.data_dir = os.path.join(data_dir, "beans")
+        self.batch_size = batch_size
+        self.image_size = image_size
+        self.num_workers = num_workers
+        self.pin_memory = pin_memory
+
+        self.train_transforms = None
+        self.test_transforms = None
+        self.train_dataset = None
+        self.test_dataset = None
+        self.train_loader = None
+        self.test_loader = None
+        self.class_names = None
+
+        self._setup_transforms()
+        self._setup_datasets()
+        self._setup_loaders()
+
+    def _setup_transforms(self) -> None:
+        """Set up data transforms for training and testing."""
+        if self.preprocess:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.RandomResizedCrop(self.image_size),
+                    transforms.RandomHorizontalFlip(),
+                    transforms.RandomRotation(15),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize(self.image_size + 32),
+                    transforms.CenterCrop(self.image_size),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+        else:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+    def _setup_datasets(self) -> None:
+        """Set up training and testing datasets."""
+        self.train_dataset = datasets.ImageFolder(
+            root=f"{self.data_dir}/train", transform=self.train_transforms
+        )
+
+        self.test_dataset = datasets.ImageFolder(
+            root=f"{self.data_dir}/test", transform=self.test_transforms
+        )
+
+        self.class_names = self.train_dataset.classes
+
+    def _setup_loaders(self) -> None:
+        """Set up data loaders for training and testing."""
+        self.train_loader = DataLoader(
+            self.train_dataset,
+            batch_size=self.batch_size,
+            shuffle=True,
+            num_workers=self.num_workers,
+            pin_memory=self.pin_memory,
+        )
+
+        self.test_loader = DataLoader(
+            self.test_dataset,
+            batch_size=self.batch_size,
+            shuffle=False,
+            num_workers=self.num_workers,
+            pin_memory=self.pin_memory,
+        )
+
+    def get_loaders(self) -> Tuple[DataLoader, DataLoader]:
+        """
+        Get train and test data loaders.
+
+        Returns:
+            tuple: (train_loader, test_loader)
+        """
+        return self.train_loader, self.test_loader
+
+    def get_dataset_info(self) -> Dict:
+        """
+        Get dataset information.
+
+        Returns:
+            dict: Dictionary containing dataset information
+        """
+        return {
+            "num_train_samples": len(self.train_dataset),
+            "num_test_samples": len(self.test_dataset),
+            "num_classes": len(self.class_names),
+            "classes": self.class_names,
+            "image_size": self.image_size,
+            "batch_size": self.batch_size,
+        }
+
+
+class Beans:
+    def __init__(
+        self,
+        preprocess,
+        location=os.path.expanduser("~/data"),
+        batch_size=32,
+        num_workers=16,
+    ):
+        self.data_dir = location
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+
+        self.dm = BeanDataModule(
+            preprocess=preprocess,
+            data_dir=self.data_dir,
+            batch_size=self.batch_size,
+            num_workers=self.num_workers,
+        )
+
+        self.train_loader, self.test_loader = self.dm.get_loaders()
+        self.dataset_info = self.dm.get_dataset_info()
+        self.train_dataset = self.dm.train_dataset
+        self.test_dataset = self.dm.test_dataset
+        self.classnames = self.dataset_info["classes"]
+        self.num_classes = self.dataset_info["num_classes"]
+        self.image_size = self.dataset_info["image_size"]
+        self.batch_size = self.dataset_info["batch_size"]
+        self.num_train_samples = self.dataset_info["num_train_samples"]
+        self.num_test_samples = self.dataset_info["num_test_samples"]

datasets/birds.py

@@ -0,0 +1,126 @@
+import torch
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader, random_split
+import os
+
+
+class BirdsDataset:
+    def __init__(
+        self,
+        preprocess,
+        data_dir="theRestDataset/birds",
+        image_size=224,
+        val_split=0.2,
+        seed=42,
+    ):
+        self.preprocess = preprocess
+        self.data_dir = os.path.join(data_dir, "birds", "images")
+        self.image_size = image_size
+        self.val_split = val_split
+        self.seed = seed
+
+        # Define transforms for training and validation
+        if self.preprocess:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.RandomResizedCrop(self.image_size),
+                    transforms.RandomHorizontalFlip(),
+                    transforms.RandomRotation(15),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize(self.image_size + 32),
+                    transforms.CenterCrop(self.image_size),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+        else:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+        # Create datasets
+        self.setup()
+
+    def setup(self):
+        # Create full dataset
+        full_dataset = datasets.ImageFolder(root=self.data_dir)
+
+        # Calculate lengths for train and validation
+        total_length = len(full_dataset)
+        val_length = int(total_length * self.val_split)
+        train_length = total_length - val_length
+
+        # Create train/validation splits
+        generator = torch.Generator().manual_seed(self.seed)
+        self.train_dataset, self.test_dataset = random_split(
+            full_dataset, [train_length, val_length], generator=generator
+        )
+
+        # Apply transforms
+        self.train_dataset.dataset.transform = self.train_transforms
+        self.test_dataset.dataset.transform = self.test_transforms
+
+        # Store class information
+        self.classes = full_dataset.classes
+        self.class_to_idx = full_dataset.class_to_idx
+
+    def get_dataloaders(self, batch_size=32, num_workers=4):
+        train_loader = DataLoader(
+            self.train_dataset,
+            batch_size=batch_size,
+            shuffle=True,
+            num_workers=num_workers,
+        )
+
+        val_loader = DataLoader(
+            self.test_dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=num_workers,
+        )
+
+        return train_loader, val_loader
+
+
+class Birds:
+    def __init__(
+        self,
+        preprocess,
+        location=os.path.expanduser("~/data"),
+        batch_size=32,
+        num_workers=16,
+    ):
+        self.dataset = BirdsDataset(preprocess, data_dir=location)
+        self.train_dataset, self.test_dataset = (
+            self.dataset.train_dataset,
+            self.dataset.test_dataset,
+        )
+        self.train_loader, self.test_loader = self.dataset.get_dataloaders(
+            batch_size=batch_size, num_workers=num_workers
+        )
+        self.classnames = self.dataset.classes
+        idx_to_class = dict((v, k) for k, v in self.dataset.class_to_idx.items())
+        self.classnames = [
+            idx_to_class[i].split(".")[-1].replace("_", " ").replace("-", " ").lower()
+            for i in range(len(idx_to_class))
+        ]

datasets/cars.py

@@ -0,0 +1,171 @@
+import os
+import torch
+import torchvision.datasets as datasets
+
+
+import pathlib
+from typing import Callable, Optional, Any, Tuple
+
+from PIL import Image
+
+from torchvision.datasets.utils import (
+    download_and_extract_archive,
+    download_url,
+    verify_str_arg,
+)
+from torchvision.datasets.vision import VisionDataset
+
+
+class PytorchStanfordCars(VisionDataset):
+    """`Stanford Cars <https://ai.stanford.edu/~jkrause/cars/car_dataset.html>`_ Dataset
+
+    The Cars dataset contains 16,185 images of 196 classes of cars. The data is
+    split into 8,144 training images and 8,041 testing images, where each class
+    has been split roughly in a 50-50 split
+
+    .. note::
+
+        This class needs `scipy <https://docs.scipy.org/doc/>`_ to load target files from `.mat` format.
+
+    Args:
+        root (string): Root directory of dataset
+        split (string, optional): The dataset split, supports ``"train"`` (default) or ``"test"``.
+        transform (callable, optional): A function/transform that  takes in an PIL image
+            and returns a transformed version. E.g, ``transforms.RandomCrop``
+        target_transform (callable, optional): A function/transform that takes in the
+            target and transforms it.
+        download (bool, optional): If True, downloads the dataset from the internet and
+            puts it in root directory. If dataset is already downloaded, it is not
+            downloaded again."""
+
+    def __init__(
+        self,
+        root: str,
+        split: str = "train",
+        transform: Optional[Callable] = None,
+        target_transform: Optional[Callable] = None,
+        download: bool = False,
+    ) -> None:
+
+        try:
+            import scipy.io as sio
+        except ImportError:
+            raise RuntimeError(
+                "Scipy is not found. This dataset needs to have scipy installed: pip install scipy"
+            )
+
+        super().__init__(root, transform=transform, target_transform=target_transform)
+
+        self._split = verify_str_arg(split, "split", ("train", "test"))
+        self._base_folder = pathlib.Path(root) / "stanford_cars"
+        devkit = self._base_folder / "devkit"
+
+        if self._split == "train":
+            self._annotations_mat_path = devkit / "cars_train_annos.mat"
+            self._images_base_path = self._base_folder / "cars_train"
+        else:
+            self._annotations_mat_path = devkit / "cars_test_annos_withlabels.mat"
+            self._images_base_path = self._base_folder / "cars_test"
+
+        if download:
+            self.download()
+
+        if not self._check_exists():
+            raise RuntimeError(
+                "Dataset not found. You can use download=True to download it"
+            )
+
+        self._samples = [
+            (
+                str(self._images_base_path / annotation["fname"]),
+                annotation["class"]
+                - 1,  # Original target mapping  starts from 1, hence -1
+            )
+            for annotation in sio.loadmat(self._annotations_mat_path, squeeze_me=True)[
+                "annotations"
+            ]
+        ]
+
+        self.classes = sio.loadmat(str(devkit / "cars_meta.mat"), squeeze_me=True)[
+            "class_names"
+        ].tolist()
+        self.class_to_idx = {cls: i for i, cls in enumerate(self.classes)}
+
+    def __len__(self) -> int:
+        return len(self._samples)
+
+    def __getitem__(self, idx: int) -> Tuple[Any, Any]:
+        """Returns pil_image and class_id for given index"""
+        image_path, target = self._samples[idx]
+        pil_image = Image.open(image_path).convert("RGB")
+
+        if self.transform is not None:
+            pil_image = self.transform(pil_image)
+        if self.target_transform is not None:
+            target = self.target_transform(target)
+        return pil_image, target
+
+    def download(self) -> None:
+        if self._check_exists():
+            return
+
+        download_and_extract_archive(
+            url="https://ai.stanford.edu/~jkrause/cars/car_devkit.tgz",
+            download_root=str(self._base_folder),
+            md5="c3b158d763b6e2245038c8ad08e45376",
+        )
+        if self._split == "train":
+            download_and_extract_archive(
+                url="https://ai.stanford.edu/~jkrause/car196/cars_train.tgz",
+                download_root=str(self._base_folder),
+                md5="065e5b463ae28d29e77c1b4b166cfe61",
+            )
+        else:
+            download_and_extract_archive(
+                url="https://ai.stanford.edu/~jkrause/car196/cars_test.tgz",
+                download_root=str(self._base_folder),
+                md5="4ce7ebf6a94d07f1952d94dd34c4d501",
+            )
+            download_url(
+                url="https://ai.stanford.edu/~jkrause/car196/cars_test_annos_withlabels.mat",
+                root=str(self._base_folder),
+                md5="b0a2b23655a3edd16d84508592a98d10",
+            )
+
+    def _check_exists(self) -> bool:
+        if not (self._base_folder / "devkit").is_dir():
+            return False
+
+        return self._annotations_mat_path.exists() and self._images_base_path.is_dir()
+
+
+class Cars:
+    def __init__(
+        self,
+        preprocess,
+        location=os.path.expanduser("~/data"),
+        batch_size=32,
+        num_workers=16,
+    ):
+        # Data loading code
+
+        self.train_dataset = PytorchStanfordCars(
+            location, "train", preprocess, download=False
+        )
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset,
+            shuffle=True,
+            batch_size=batch_size,
+            num_workers=num_workers,
+        )
+
+        self.test_dataset = PytorchStanfordCars(
+            location, "test", preprocess, download=False
+        )
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset, batch_size=batch_size, num_workers=num_workers
+        )
+        idx_to_class = dict((v, k) for k, v in self.train_dataset.class_to_idx.items())
+        self.classnames = [
+            idx_to_class[i].replace("_", " ") for i in range(len(idx_to_class))
+        ]

datasets/cifar10.py

@@ -0,0 +1,56 @@
+import os
+import PIL
+import torch
+import numpy as np
+import torchvision
+from torchvision import transforms
+from torchvision.datasets import CIFAR10 as PyTorchCIFAR10
+from torchvision.datasets import VisionDataset
+
+cifar_classnames = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
+
+class CIFAR10:
+    def __init__(self, preprocess,
+                 location=os.path.expanduser('~/data'),
+                 batch_size=128,
+                 num_workers=16):
+
+
+        self.train_dataset = PyTorchCIFAR10(
+            root=location, download=True, train=True, transform=preprocess
+        )
+
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers
+        )
+
+        self.test_dataset = PyTorchCIFAR10(
+            root=location, download=True, train=False, transform=preprocess
+        )
+
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers
+        )
+
+        self.classnames = self.test_dataset.classes
+
+def convert(x):
+    if isinstance(x, np.ndarray):
+        return torchvision.transforms.functional.to_pil_image(x)
+    return x
+
+class BasicVisionDataset(VisionDataset):
+    def __init__(self, images, targets, transform=None, target_transform=None):
+        if transform is not None:
+            transform.transforms.insert(0, convert)
+        super(BasicVisionDataset, self).__init__(root=None, transform=transform, target_transform=target_transform)
+        assert len(images) == len(targets)
+
+        self.images = images
+        self.targets = targets
+
+    def __getitem__(self, index):
+        return self.transform(self.images[index]), self.targets[index]
+
+    def __len__(self):
+        return len(self.targets)

datasets/cifar100.py

@@ -0,0 +1,30 @@
+import os
+import torch
+from torchvision.datasets import CIFAR100 as PyTorchCIFAR100
+
+class CIFAR100:
+    def __init__(self,
+                 preprocess,
+                 location=os.path.expanduser('~/data'),
+                 batch_size=128,
+                 num_workers=16):
+
+        self.train_dataset = PyTorchCIFAR100(
+            root=location, download=True, train=True, transform=preprocess
+        )
+
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset, batch_size=batch_size, num_workers=num_workers
+        )
+
+        self.test_dataset = PyTorchCIFAR100(
+            root=location, download=True, train=False, transform=preprocess
+        )
+
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers
+        )
+
+        self.classnames = self.test_dataset.classes
+
+

datasets/common.py

@@ -0,0 +1,164 @@
+import os
+import torch
+import json
+import glob
+import collections
+import random
+
+import numpy as np
+
+from tqdm import tqdm
+
+import torchvision.datasets as datasets
+from torch.utils.data import Dataset, DataLoader, Sampler
+
+
+class SubsetSampler(Sampler):
+    def __init__(self, indices):
+        self.indices = indices
+
+    def __iter__(self):
+        return (i for i in self.indices)
+
+    def __len__(self):
+        return len(self.indices)
+
+
+class ImageFolderWithPaths(datasets.ImageFolder):
+    def __init__(self, path, transform, flip_label_prob=0.0):
+        super().__init__(path, transform)
+        self.flip_label_prob = flip_label_prob
+        if self.flip_label_prob > 0:
+            print(f"Flipping labels with probability {self.flip_label_prob}")
+            num_classes = len(self.classes)
+            for i in range(len(self.samples)):
+                if random.random() < self.flip_label_prob:
+                    new_label = random.randint(0, num_classes - 1)
+                    self.samples[i] = (self.samples[i][0], new_label)
+
+    def __getitem__(self, index):
+        image, label = super(ImageFolderWithPaths, self).__getitem__(index)
+        return {"images": image, "labels": label, "image_paths": self.samples[index][0]}
+
+
+def maybe_dictionarize(batch):
+    if isinstance(batch, dict):
+        return batch
+
+    if len(batch) == 2:
+        batch = {"images": batch[0], "labels": batch[1]}
+    elif len(batch) == 3:
+        batch = {"images": batch[0], "labels": batch[1], "metadata": batch[2]}
+    else:
+        raise ValueError(f"Unexpected number of elements: {len(batch)}")
+
+    return batch
+
+
+def get_features_helper(image_encoder, dataloader, device):
+    all_data = collections.defaultdict(list)
+
+    image_encoder = image_encoder.to(device)
+    image_encoder = torch.nn.DataParallel(
+        image_encoder, device_ids=[x for x in range(torch.cuda.device_count())]
+    )
+    image_encoder.eval()
+
+    with torch.no_grad():
+        for batch in tqdm(dataloader):
+            batch = maybe_dictionarize(batch)
+            features = image_encoder(batch["images"].cuda())
+
+            all_data["features"].append(features.cpu())
+
+            for key, val in batch.items():
+                if key == "images":
+                    continue
+                if hasattr(val, "cpu"):
+                    val = val.cpu()
+                    all_data[key].append(val)
+                else:
+                    all_data[key].extend(val)
+
+    for key, val in all_data.items():
+        if torch.is_tensor(val[0]):
+            all_data[key] = torch.cat(val).numpy()
+
+    return all_data
+
+
+def get_features(is_train, image_encoder, dataset, device):
+    split = "train" if is_train else "val"
+    dname = type(dataset).__name__
+    if image_encoder.cache_dir is not None:
+        cache_dir = f"{image_encoder.cache_dir}/{dname}/{split}"
+        cached_files = glob.glob(f"{cache_dir}/*")
+    if image_encoder.cache_dir is not None and len(cached_files) > 0:
+        print(f"Getting features from {cache_dir}")
+        data = {}
+        for cached_file in cached_files:
+            name = os.path.splitext(os.path.basename(cached_file))[0]
+            data[name] = torch.load(cached_file)
+    else:
+        print(f"Did not find cached features at {cache_dir}. Building from scratch.")
+        loader = dataset.train_loader if is_train else dataset.test_loader
+        data = get_features_helper(image_encoder, loader, device)
+        if image_encoder.cache_dir is None:
+            print("Not caching because no cache directory was passed.")
+        else:
+            os.makedirs(cache_dir, exist_ok=True)
+            print(f"Caching data at {cache_dir}")
+            for name, val in data.items():
+                torch.save(val, f"{cache_dir}/{name}.pt")
+    return data
+
+
+class FeatureDataset(Dataset):
+    def __init__(self, is_train, image_encoder, dataset, device):
+        self.data = get_features(is_train, image_encoder, dataset, device)
+
+    def __len__(self):
+        return len(self.data["features"])
+
+    def __getitem__(self, idx):
+        data = {k: v[idx] for k, v in self.data.items()}
+        data["features"] = torch.from_numpy(data["features"]).float()
+        return data
+
+
+def get_dataloader(dataset, is_train, args, image_encoder=None, num_samples=None):
+    if image_encoder is not None:
+        feature_dataset = FeatureDataset(is_train, image_encoder, dataset, args.device)
+        dataloader = DataLoader(
+            feature_dataset, batch_size=args.batch_size, shuffle=is_train
+        )
+    else:
+        dataloader = dataset.train_loader if is_train else dataset.test_loader
+        if num_samples is not None:
+            # indices = np.random.choice(len(dataloader.dataset), num_samples, replace=False)
+            if is_train:
+                indices = list(range(min(num_samples, len(dataset.train_dataset))))
+            else:
+                indices = list(range(min(num_samples, len(dataset.test_dataset))))
+            dataloader = DataLoader(
+                dataloader.dataset,
+                batch_size=args.batch_size,
+                sampler=SubsetSampler(indices),
+            )
+    return dataloader
+
+
+def get_dataloaders(datasets, is_train, args, image_encoder=None):
+    dataloaders = {}
+    for dataset_name, dataset in datasets.items():
+        dataloaders[dataset_name] = get_dataloader(
+            dataset, is_train, args, image_encoder
+        )
+    return dataloaders
+
+
+def get_dataiters(dataloaders):
+    dataiters = {}
+    for dataset_name, dataloader in dataloaders.items():
+        dataiters[dataset_name] = iter(dataloader)
+    return dataiters

datasets/common2.py

@@ -0,0 +1,147 @@
+import torch
+import torchvision
+import torchvision.transforms as transforms
+from torch.utils.data import DataLoader
+import os
+from typing import Tuple, Optional
+from abc import ABC, abstractmethod
+
+
+class BaseDatasetLoader(ABC):
+    """Base class for all dataset loaders"""
+
+    def __init__(
+        self, root_dir: str = "./data", batch_size: int = 32, num_workers: int = 4
+    ):
+        self.root_dir = root_dir
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+        os.makedirs(root_dir, exist_ok=True)
+
+    def _create_dataloaders(
+        self,
+        train_dataset: torch.utils.data.Dataset,
+        test_dataset: torch.utils.data.Dataset,
+    ) -> Tuple[DataLoader, DataLoader]:
+        """Create DataLoader objects for training and testing"""
+        train_loader = DataLoader(
+            train_dataset,
+            batch_size=self.batch_size,
+            shuffle=True,
+            num_workers=self.num_workers,
+        )
+
+        test_loader = DataLoader(
+            test_dataset,
+            batch_size=self.batch_size,
+            shuffle=False,
+            num_workers=self.num_workers,
+        )
+
+        return train_loader, test_loader
+
+    @abstractmethod
+    def load_dataset(self) -> Tuple[DataLoader, DataLoader]:
+        """Load dataset and return train and test dataloaders"""
+        pass
+
+
+class RGBDatasetLoader(BaseDatasetLoader):
+    """Base class for RGB image datasets"""
+
+    def __init__(self, preprocess, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.preprocess = preprocess
+        if self.preprocess:
+            self.train_transform = transforms.Compose(
+                [
+                    transforms.RandomResizedCrop(224),
+                    transforms.RandomHorizontalFlip(),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+
+            self.test_transform = transforms.Compose(
+                [
+                    transforms.Resize(256),
+                    transforms.CenterCrop(224),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+        else:
+            self.train_transform = transforms.Compose(
+                [
+                    transforms.Resize((224, 224)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+            self.test_transform = transforms.Compose(
+                [
+                    transforms.Resize((224, 224)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+
+class GrayscaleDatasetLoader(BaseDatasetLoader):
+    """Base class for grayscale image datasets with RGB conversion"""
+
+    def __init__(self, preprocess, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if preprocess:
+            self.train_transform = transforms.Compose(
+                [
+                    transforms.RandomResizedCrop(224),
+                    transforms.RandomHorizontalFlip(),
+                    transforms.ToTensor(),
+                    transforms.Lambda(
+                        lambda x: x.repeat(3, 1, 1)
+                    ),  # Convert to RGB by repeating channels
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406],  # ImageNet normalization for RGB
+                        std=[0.229, 0.224, 0.225],
+                    ),
+                ]
+            )
+
+            self.test_transform = transforms.Compose(
+                [
+                    transforms.Resize(256),
+                    transforms.CenterCrop(224),
+                    transforms.ToTensor(),
+                    transforms.Lambda(
+                        lambda x: x.repeat(3, 1, 1)
+                    ),  # Convert to RGB by repeating channels
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406],  # ImageNet normalization for RGB
+                        std=[0.229, 0.224, 0.225],
+                    ),
+                ]
+            )
+        else:
+            self.train_transform = transforms.Compose(
+                [
+                    transforms.Resize((224, 224)),
+                    transforms.ToTensor(),
+                    transforms.Lambda(
+                        lambda x: x.repeat(3, 1, 1)
+                    ),  # Convert to RGB by repeating channels
+                ]
+            )
+
+            self.test_transform = transforms.Compose(
+                [
+                    transforms.Resize((224, 224)),
+                    transforms.ToTensor(),
+                    transforms.Lambda(
+                        lambda x: x.repeat(3, 1, 1)
+                    ),  # Convert to RGB by repeating channels
+                ]
+            )

datasets/dogs.py

@@ -0,0 +1,127 @@
+import torch
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader, random_split
+import os
+
+
+class DogsDataset:
+    def __init__(
+        self,
+        preprocess,
+        data_dir="theRestDataset/dogs",
+        image_size=224,
+        val_split=0.2,
+        seed=42,
+    ):
+        self.preprocess = preprocess
+        self.data_dir = os.path.join(data_dir, "dogs")
+        self.image_size = image_size
+        self.val_split = val_split
+        self.seed = seed
+
+        # Define transforms for training and validation
+        if self.preprocess:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.RandomResizedCrop(self.image_size),
+                    transforms.RandomHorizontalFlip(),
+                    transforms.RandomRotation(15),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize(self.image_size + 32),
+                    transforms.CenterCrop(self.image_size),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+        else:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+        # Create datasets
+        self.setup()
+
+    def setup(self):
+        # Create full dataset
+        full_dataset = datasets.ImageFolder(root=self.data_dir)
+
+        # Calculate lengths for train and validation
+        total_length = len(full_dataset)
+        val_length = int(total_length * self.val_split)
+        train_length = total_length - val_length
+
+        # Create train/validation splits
+        generator = torch.Generator().manual_seed(self.seed)
+        self.train_dataset, self.test_dataset = random_split(
+            full_dataset, [train_length, val_length], generator=generator
+        )
+
+        # Apply transforms
+        self.train_dataset.dataset.transform = self.train_transforms
+        self.test_dataset.dataset.transform = self.test_transforms
+
+        # Store class information
+        self.classes = full_dataset.classes
+        self.class_to_idx = full_dataset.class_to_idx
+
+    def get_dataloaders(self, batch_size=32, num_workers=4):
+        train_loader = DataLoader(
+            self.train_dataset,
+            batch_size=batch_size,
+            shuffle=True,
+            num_workers=num_workers,
+        )
+
+        val_loader = DataLoader(
+            self.test_dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=num_workers,
+        )
+
+        return train_loader, val_loader
+
+
+class Dogs:
+    def __init__(
+        self,
+        preprocess,
+        location=os.path.expanduser("~/data"),
+        batch_size=32,
+        num_workers=16,
+    ):
+        self.dataset = DogsDataset(preprocess, data_dir=location)
+        self.train_dataset, self.test_dataset = (
+            self.dataset.train_dataset,
+            self.dataset.test_dataset,
+        )
+        self.train_loader, self.test_loader = self.dataset.get_dataloaders(
+            batch_size=batch_size, num_workers=num_workers
+        )
+        self.classnames = self.dataset.classes
+        idx_to_class = dict((v, k) for k, v in self.dataset.class_to_idx.items())
+        self.classnames = []
+        for i in range(len(idx_to_class)):
+            self.classnames.append(
+                "_".join(idx_to_class[i].split("-")[1:]).replace("_", " ").lower()
+            )

datasets/dtd.py

@@ -0,0 +1,34 @@
+import os
+import torch
+import torchvision.datasets as datasets
+
+
+class DTD:
+    def __init__(self,
+                 preprocess,
+                 location=os.path.expanduser('~/data'),
+                 batch_size=32,
+                 num_workers=16):
+        # Data loading code
+        traindir = os.path.join(location, 'dtd', 'train')
+        valdir = os.path.join(location, 'dtd', 'val')
+
+        self.train_dataset = datasets.ImageFolder(
+            traindir, transform=preprocess)
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset,
+            shuffle=True,
+            batch_size=batch_size,
+            num_workers=num_workers,
+        )
+
+        self.test_dataset = datasets.ImageFolder(valdir, transform=preprocess)
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset,
+            batch_size=batch_size,
+            num_workers=num_workers
+        )
+        idx_to_class = dict((v, k)
+                            for k, v in self.train_dataset.class_to_idx.items())
+        self.classnames = [idx_to_class[i].replace(
+            '_', ' ') for i in range(len(idx_to_class))]

datasets/eurosat.py

@@ -0,0 +1,75 @@
+import os
+import torch
+import torchvision.datasets as datasets
+import re
+
+def pretify_classname(classname):
+    l = re.findall(r'[A-Z](?:[a-z]+|[A-Z]*(?=[A-Z]|$))', classname)
+    l = [i.lower() for i in l]
+    out = ' '.join(l)
+    if out.endswith('al'):
+        return out + ' area'
+    return out
+
+class EuroSATBase:
+    def __init__(self,
+                 preprocess,
+                 test_split,
+                 location='~/datasets',
+                 batch_size=32,
+                 num_workers=16):
+        # Data loading code
+        traindir = os.path.join(location, 'EuroSAT_splits', 'train')
+        testdir = os.path.join(location, 'EuroSAT_splits', test_split)
+
+
+        self.train_dataset = datasets.ImageFolder(traindir, transform=preprocess)
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset,
+            shuffle=True,
+            batch_size=batch_size,
+            num_workers=num_workers,
+        )
+
+        self.test_dataset = datasets.ImageFolder(testdir, transform=preprocess)
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset,
+            batch_size=batch_size,
+            num_workers=num_workers
+        )
+        idx_to_class = dict((v, k)
+                            for k, v in self.train_dataset.class_to_idx.items())
+        self.classnames = [idx_to_class[i].replace('_', ' ') for i in range(len(idx_to_class))]
+        self.classnames = [pretify_classname(c) for c in self.classnames]
+        ours_to_open_ai = {
+            'annual crop': 'annual crop land',
+            'forest': 'forest',
+            'herbaceous vegetation': 'brushland or shrubland',
+            'highway': 'highway or road',
+            'industrial area': 'industrial buildings or commercial buildings',
+            'pasture': 'pasture land',
+            'permanent crop': 'permanent crop land',
+            'residential area': 'residential buildings or homes or apartments',
+            'river': 'river',
+            'sea lake': 'lake or sea',
+        }
+        for i in range(len(self.classnames)):
+            self.classnames[i] = ours_to_open_ai[self.classnames[i]]
+
+
+class EuroSAT(EuroSATBase):
+    def __init__(self,
+                 preprocess,
+                 location='~/datasets',
+                 batch_size=32,
+                 num_workers=16):
+        super().__init__(preprocess, 'test', location, batch_size, num_workers)
+
+
+class EuroSATVal(EuroSATBase):
+    def __init__(self,
+                 preprocess,
+                 location='~/datasets',
+                 batch_size=32,
+                 num_workers=16):
+        super().__init__(preprocess, 'val', location, batch_size, num_workers)

datasets/fashionmnist.py

@@ -0,0 +1,64 @@
+from src.datasets.common2 import GrayscaleDatasetLoader
+import torchvision
+from torch.utils.data import DataLoader
+from typing import Tuple
+import os
+
+
+class FashionMNISTLoader(GrayscaleDatasetLoader):
+    """Loader for Fashion-MNIST dataset"""
+
+    def load_dataset(self) -> Tuple[DataLoader, DataLoader]:
+        train_dataset = torchvision.datasets.FashionMNIST(
+            root=self.root_dir,
+            train=True,
+            transform=self.train_transform,
+            download=True,
+        )
+
+        test_dataset = torchvision.datasets.FashionMNIST(
+            root=self.root_dir,
+            train=False,
+            transform=self.test_transform,
+            download=True,
+        )
+
+        return (
+            train_dataset,
+            test_dataset,
+            self._create_dataloaders(train_dataset, test_dataset),
+        )
+
+    @property
+    def classes(self) -> list:
+        """Get Fashion-MNIST class labels"""
+        return [
+            "Top",
+            "Trouser",
+            "Pullover",
+            "Dress",
+            "Coat",
+            "Sandal",
+            "Shirt",
+            "Sneaker",
+            "Bag",
+            "Ankle boot",
+        ]
+
+
+class FashionMNIST:
+    def __init__(
+        self,
+        preprocess,
+        location=os.path.expanduser("~/data"),
+        batch_size=32,
+        num_workers=16,
+    ):
+        self.loader = FashionMNISTLoader(preprocess, location, batch_size, num_workers)
+        self.train_dataset, self.test_dataset, loaders = self.loader.load_dataset()
+        self.train_loader, self.test_loader = loaders
+        self.classnames = self.loader.classes
+        idx_to_class = dict((v, k) for k, v in self.train_dataset.class_to_idx.items())
+        self.classnames = [
+            idx_to_class[i].replace("_", " ").lower() for i in range(len(idx_to_class))
+        ]

datasets/flowers.py

@@ -0,0 +1,125 @@
+import torch
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader, random_split
+import os
+
+
+class FlowerDataset:
+    def __init__(
+        self,
+        preprocess,
+        data_dir="theRestDataset/flowers",
+        image_size=224,
+        val_split=0.2,
+        seed=42,
+    ):
+        self.preprocess = preprocess
+        self.data_dir = os.path.join(data_dir, "flowers")
+        self.image_size = image_size
+        self.val_split = val_split
+        self.seed = seed
+
+        # Define transforms for training and validation
+        if self.preprocess:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.RandomResizedCrop(self.image_size),
+                    transforms.RandomHorizontalFlip(),
+                    transforms.RandomRotation(15),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize(self.image_size + 32),
+                    transforms.CenterCrop(self.image_size),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+        else:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+        # Create datasets
+        self.setup()
+
+    def setup(self):
+        # Create full dataset
+        full_dataset = datasets.ImageFolder(root=self.data_dir)
+
+        # Calculate lengths for train and validation
+        total_length = len(full_dataset)
+        val_length = int(total_length * self.val_split)
+        train_length = total_length - val_length
+
+        # Create train/validation splits
+        generator = torch.Generator().manual_seed(self.seed)
+        self.train_dataset, self.test_dataset = random_split(
+            full_dataset, [train_length, val_length], generator=generator
+        )
+
+        # Apply transforms
+        self.train_dataset.dataset.transform = self.train_transforms
+        self.test_dataset.dataset.transform = self.test_transforms
+
+        # Store class information
+        self.classes = full_dataset.classes
+        self.class_to_idx = full_dataset.class_to_idx
+
+    def get_dataloaders(self, batch_size=32, num_workers=4):
+        train_loader = DataLoader(
+            self.train_dataset,
+            batch_size=batch_size,
+            shuffle=True,
+            num_workers=num_workers,
+        )
+
+        val_loader = DataLoader(
+            self.test_dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=num_workers,
+        )
+
+        return train_loader, val_loader
+
+
+class Flowers:
+    def __init__(
+        self,
+        preprocess,
+        location=os.path.expanduser("~/data"),
+        batch_size=32,
+        num_workers=16,
+    ):
+        self.dataset = FlowerDataset(preprocess, data_dir=location)
+        self.train_dataset, self.test_dataset = (
+            self.dataset.train_dataset,
+            self.dataset.test_dataset,
+        )
+        self.train_loader, self.test_loader = self.dataset.get_dataloaders(
+            batch_size=batch_size, num_workers=num_workers
+        )
+        self.classnames = self.dataset.classes
+        idx_to_class = dict((v, k) for k, v in self.dataset.class_to_idx.items())
+        self.classnames = [
+            idx_to_class[i].replace("_", " ").lower() for i in range(len(idx_to_class))
+        ]

datasets/food101.py

@@ -0,0 +1,25 @@
+from src.datasets.common2 import RGBDatasetLoader
+import torchvision
+from torch.utils.data import DataLoader
+from typing import Tuple
+
+
+class Food101Loader(RGBDatasetLoader):
+    """Loader for Food-101 dataset"""
+
+    def load_dataset(self) -> Tuple[DataLoader, DataLoader]:
+        train_dataset = torchvision.datasets.Food101(
+            root=self.root_dir,
+            split="train",
+            transform=self.train_transform,
+            download=True,
+        )
+
+        test_dataset = torchvision.datasets.Food101(
+            root=self.root_dir,
+            split="test",
+            transform=self.test_transform,
+            download=True,
+        )
+
+        return self._create_dataloaders(train_dataset, test_dataset)

datasets/garbage.py

@@ -0,0 +1,177 @@
+import os
+from typing import Optional, Callable, Tuple
+import torch
+from torchvision import datasets, transforms
+from torch.utils.data import random_split, DataLoader
+
+
+class GarbageDataset:
+    def __init__(
+        self,
+        preprocess,
+        root_dir: str = "theRestDataset/garbage/data",
+        image_size: int = 224,
+        val_split: float = 0.2,
+        seed: int = 42,
+    ):
+        """
+        Initialize the Garbage Dataset.
+
+        Args:
+            root_dir (str): Path to the dataset root directory
+            image_size (int): Size of the input images
+            val_split (float): Fraction of data to use for validation (0.0 to 1.0)
+            seed (int): Random seed for reproducibility
+        """
+        self.root_dir = os.path.join(root_dir, "garbage", "data")
+        self.image_size = image_size
+        self.val_split = val_split
+        self.seed = seed
+
+        # Define transforms for training and validation
+        self.preprocess = preprocess
+        if self.preprocess:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.RandomResizedCrop(self.image_size),
+                    transforms.RandomHorizontalFlip(),
+                    transforms.RandomRotation(15),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize(self.image_size + 32),
+                    transforms.CenterCrop(self.image_size),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+        else:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+        # Load the full dataset
+        self.full_dataset = datasets.ImageFolder(
+            root=self.root_dir, transform=None  # We'll apply transforms later
+        )
+
+        # Split into train and validation sets
+        self._create_splits()
+
+    def _create_splits(self):
+        """Create train and validation splits."""
+        # Calculate lengths
+        val_size = int(len(self.full_dataset) * self.val_split)
+        train_size = len(self.full_dataset) - val_size
+
+        # Create splits
+        generator = torch.Generator().manual_seed(self.seed)
+        self.train_dataset, self.test_dataset = random_split(
+            self.full_dataset, [train_size, val_size], generator=generator
+        )
+
+        # Create transform datasets
+        self.train_dataset = TransformDataset(self.train_dataset, self.train_transforms)
+        self.test_dataset = TransformDataset(self.test_dataset, self.test_transforms)
+
+    def get_dataloaders(
+        self, batch_size: int = 32, num_workers: int = 4, pin_memory: bool = True
+    ) -> Tuple[DataLoader, DataLoader]:
+        """
+        Create and return train and validation dataloaders.
+
+        Args:
+            batch_size (int): Batch size for both loaders
+            num_workers (int): Number of workers for data loading
+            pin_memory (bool): Whether to pin memory for GPU training
+
+        Returns:
+            tuple: (train_dataloader, val_dataloader)
+        """
+        train_loader = DataLoader(
+            self.train_dataset,
+            batch_size=batch_size,
+            shuffle=True,
+            num_workers=num_workers,
+            pin_memory=pin_memory,
+        )
+
+        test_loader = DataLoader(
+            self.test_dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=num_workers,
+            pin_memory=pin_memory,
+        )
+
+        return train_loader, test_loader
+
+    @property
+    def classes(self) -> list:
+        """Get the list of class names."""
+        return self.full_dataset.classes
+
+    @property
+    def class_to_idx(self) -> dict:
+        """Get the class to index mapping."""
+        return self.full_dataset.class_to_idx
+
+
+class TransformDataset(torch.utils.data.Dataset):
+    """Dataset wrapper that applies transforms to a subset of data."""
+
+    def __init__(
+        self, subset: torch.utils.data.Dataset, transform: Optional[Callable] = None
+    ):
+        self.subset = subset
+        self.transform = transform
+
+    def __getitem__(self, idx):
+        x, y = self.subset[idx]
+        if self.transform:
+            x = self.transform(x)
+        return x, y
+
+    def __len__(self):
+        return len(self.subset)
+
+
+class Garbage:
+    def __init__(
+        self,
+        preprocess,
+        location=os.path.expanduser("~/data"),
+        batch_size=32,
+        num_workers=16,
+    ):
+        self.dataset = GarbageDataset(preprocess, root_dir=location)
+        self.train_dataset, self.test_dataset = (
+            self.dataset.train_dataset,
+            self.dataset.test_dataset,
+        )
+        self.train_loader, self.test_loader = self.dataset.get_dataloaders(
+            batch_size=batch_size, num_workers=num_workers
+        )
+        self.classnames = self.dataset.classes
+        idx_to_class = dict((v, k) for k, v in self.dataset.class_to_idx.items())
+        self.classnames = [
+            idx_to_class[i].replace("_", " ").lower() for i in range(len(idx_to_class))
+        ]

datasets/gtsrb.py

@@ -0,0 +1,205 @@
+import csv
+import os
+import pathlib
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import numpy as np
+import PIL
+import torch
+from torchvision.datasets.folder import make_dataset
+from torchvision.datasets.utils import (download_and_extract_archive,
+                                        verify_str_arg)
+from torchvision.datasets.vision import VisionDataset
+
+def find_classes(directory: str) -> Tuple[List[str], Dict[str, int]]:
+    """Finds the class folders in a dataset.
+
+    See :class:`DatasetFolder` for details.
+    """
+    classes = sorted(entry.name for entry in os.scandir(directory) if entry.is_dir())
+    if not classes:
+        raise FileNotFoundError(f"Couldn't find any class folder in {directory}.")
+
+    class_to_idx = {cls_name: i for i, cls_name in enumerate(classes)}
+    return classes, class_to_idx
+
+class PyTorchGTSRB(VisionDataset):
+    """`German Traffic Sign Recognition Benchmark (GTSRB) <https://benchmark.ini.rub.de/>`_ Dataset.
+
+    Modified from https://pytorch.org/vision/main/_modules/torchvision/datasets/gtsrb.html#GTSRB.
+
+    Args:
+        root (string): Root directory of the dataset.
+        split (string, optional): The dataset split, supports ``"train"`` (default), or ``"test"``.
+        transform (callable, optional): A function/transform that  takes in an PIL image and returns a transformed
+            version. E.g, ``transforms.RandomCrop``.
+        target_transform (callable, optional): A function/transform that takes in the target and transforms it.
+        download (bool, optional): If True, downloads the dataset from the internet and
+            puts it in root directory. If dataset is already downloaded, it is not
+            downloaded again.
+    """
+
+    def __init__(
+        self,
+        root: str,
+        split: str = "train",
+        transform: Optional[Callable] = None,
+        target_transform: Optional[Callable] = None,
+        download: bool = False,
+    ) -> None:
+
+        super().__init__(root, transform=transform, target_transform=target_transform)
+
+        self._split = verify_str_arg(split, "split", ("train", "test"))
+        self._base_folder = pathlib.Path(root) / "gtsrb"
+        self._target_folder = (
+            self._base_folder / "GTSRB" / ("Training" if self._split == "train" else "Final_Test/Images")
+        )
+
+        if download:
+            self.download()
+
+        if not self._check_exists():
+            raise RuntimeError("Dataset not found. You can use download=True to download it")
+
+        if self._split == "train":
+            _, class_to_idx = find_classes(str(self._target_folder))
+            samples = make_dataset(str(self._target_folder), extensions=(".ppm",), class_to_idx=class_to_idx)
+        else:
+            with open(self._base_folder / "GT-final_test.csv") as csv_file:
+                samples = [
+                    (str(self._target_folder / row["Filename"]), int(row["ClassId"]))
+                    for row in csv.DictReader(csv_file, delimiter=";", skipinitialspace=True)
+                ]
+
+        self._samples = samples
+        self.transform = transform
+        self.target_transform = target_transform
+
+    def __len__(self) -> int:
+        return len(self._samples)
+
+    def __getitem__(self, index: int) -> Tuple[Any, Any]:
+
+        path, target = self._samples[index]
+        sample = PIL.Image.open(path).convert("RGB")
+
+        if self.transform is not None:
+            sample = self.transform(sample)
+
+        if self.target_transform is not None:
+            target = self.target_transform(target)
+
+        return sample, target
+
+
+    def _check_exists(self) -> bool:
+        return self._target_folder.is_dir()
+
+    def download(self) -> None:
+        if self._check_exists():
+            return
+
+        base_url = "https://sid.erda.dk/public/archives/daaeac0d7ce1152aea9b61d9f1e19370/"
+
+        if self._split == "train":
+            download_and_extract_archive(
+                f"{base_url}GTSRB-Training_fixed.zip",
+                download_root=str(self._base_folder),
+                md5="513f3c79a4c5141765e10e952eaa2478",
+            )
+        else:
+            download_and_extract_archive(
+                f"{base_url}GTSRB_Final_Test_Images.zip",
+                download_root=str(self._base_folder),
+                md5="c7e4e6327067d32654124b0fe9e82185",
+            )
+            download_and_extract_archive(
+                f"{base_url}GTSRB_Final_Test_GT.zip",
+                download_root=str(self._base_folder),
+                md5="fe31e9c9270bbcd7b84b7f21a9d9d9e5",
+            )
+
+
+class GTSRB:
+    def __init__(self,
+                 preprocess,
+                 location=os.path.expanduser('~/data'),
+                 batch_size=128,
+                 num_workers=16):
+
+        # to fit with repo conventions for location
+        self.train_dataset = PyTorchGTSRB(
+            root=location,
+            download=True,
+            split='train',
+            transform=preprocess
+        )
+
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset,
+            batch_size=batch_size,
+            shuffle=True,
+            num_workers=num_workers
+        )
+
+        self.test_dataset = PyTorchGTSRB(
+            root=location,
+            download=True,
+            split='test',
+            transform=preprocess
+        )
+
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=num_workers
+        )
+
+        # from https://github.com/openai/CLIP/blob/e184f608c5d5e58165682f7c332c3a8b4c1545f2/data/prompts.md
+        self.classnames = [
+            'red and white circle 20 kph speed limit',
+            'red and white circle 30 kph speed limit',
+            'red and white circle 50 kph speed limit',
+            'red and white circle 60 kph speed limit',
+            'red and white circle 70 kph speed limit',
+            'red and white circle 80 kph speed limit',
+            'end / de-restriction of 80 kph speed limit',
+            'red and white circle 100 kph speed limit',
+            'red and white circle 120 kph speed limit',
+            'red and white circle red car and black car no passing',
+            'red and white circle red truck and black car no passing',
+            'red and white triangle road intersection warning',
+            'white and yellow diamond priority road',
+            'red and white upside down triangle yield right-of-way',
+            'stop',
+            'empty red and white circle',
+            'red and white circle no truck entry',
+            'red circle with white horizonal stripe no entry',
+            'red and white triangle with exclamation mark warning',
+            'red and white triangle with black left curve approaching warning',
+            'red and white triangle with black right curve approaching warning',
+            'red and white triangle with black double curve approaching warning',
+            'red and white triangle rough / bumpy road warning',
+            'red and white triangle car skidding / slipping warning',
+            'red and white triangle with merging / narrow lanes warning',
+            'red and white triangle with person digging / construction / road work warning',
+            'red and white triangle with traffic light approaching warning',
+            'red and white triangle with person walking warning',
+            'red and white triangle with child and person walking warning',
+            'red and white triangle with bicyle warning',
+            'red and white triangle with snowflake / ice warning',
+            'red and white triangle with deer warning',
+            'white circle with gray strike bar no speed limit',
+            'blue circle with white right turn arrow mandatory',
+            'blue circle with white left turn arrow mandatory',
+            'blue circle with white forward arrow mandatory',
+            'blue circle with white forward or right turn arrow mandatory',
+            'blue circle with white forward or left turn arrow mandatory',
+            'blue circle with white keep right arrow mandatory',
+            'blue circle with white keep left arrow mandatory',
+            'blue circle with white arrows indicating a traffic circle',
+            'white circle with gray strike bar indicating no passing for cars has ended',
+            'white circle with gray strike bar indicating no passing for trucks has ended',
+        ]

datasets/imagenet.py

@@ -0,0 +1,253 @@
+import os
+import torch
+
+from .common import ImageFolderWithPaths, SubsetSampler
+import numpy as np
+
+
+imagenet_classnames = [
+    "tench", "goldfish", "great white shark", "tiger shark", "hammerhead shark", "electric ray",
+    "stingray", "rooster", "hen", "ostrich", "brambling", "goldfinch", "house finch", "junco",
+    "indigo bunting", "American robin", "bulbul", "jay", "magpie", "chickadee", "American dipper",
+    "kite (bird of prey)", "bald eagle", "vulture", "great grey owl", "fire salamander",
+    "smooth newt", "newt", "spotted salamander", "axolotl", "American bullfrog", "tree frog",
+    "tailed frog", "loggerhead sea turtle", "leatherback sea turtle", "mud turtle", "terrapin",
+    "box turtle", "banded gecko", "green iguana", "Carolina anole",
+    "desert grassland whiptail lizard", "agama", "frilled-necked lizard", "alligator lizard",
+    "Gila monster", "European green lizard", "chameleon", "Komodo dragon", "Nile crocodile",
+    "American alligator", "triceratops", "worm snake", "ring-necked snake",
+    "eastern hog-nosed snake", "smooth green snake", "kingsnake", "garter snake", "water snake",
+    "vine snake", "night snake", "boa constrictor", "African rock python", "Indian cobra",
+    "green mamba", "sea snake", "Saharan horned viper", "eastern diamondback rattlesnake",
+    "sidewinder rattlesnake", "trilobite", "harvestman", "scorpion", "yellow garden spider",
+    "barn spider", "European garden spider", "southern black widow", "tarantula", "wolf spider",
+    "tick", "centipede", "black grouse", "ptarmigan", "ruffed grouse", "prairie grouse", "peafowl",
+    "quail", "partridge", "african grey parrot", "macaw", "sulphur-crested cockatoo", "lorikeet",
+    "coucal", "bee eater", "hornbill", "hummingbird", "jacamar", "toucan", "duck",
+    "red-breasted merganser", "goose", "black swan", "tusker", "echidna", "platypus", "wallaby",
+    "koala", "wombat", "jellyfish", "sea anemone", "brain coral", "flatworm", "nematode", "conch",
+    "snail", "slug", "sea slug", "chiton", "chambered nautilus", "Dungeness crab", "rock crab",
+    "fiddler crab", "red king crab", "American lobster", "spiny lobster", "crayfish", "hermit crab",
+    "isopod", "white stork", "black stork", "spoonbill", "flamingo", "little blue heron",
+    "great egret", "bittern bird", "crane bird", "limpkin", "common gallinule", "American coot",
+    "bustard", "ruddy turnstone", "dunlin", "common redshank", "dowitcher", "oystercatcher",
+    "pelican", "king penguin", "albatross", "grey whale", "killer whale", "dugong", "sea lion",
+    "Chihuahua", "Japanese Chin", "Maltese", "Pekingese", "Shih Tzu", "King Charles Spaniel",
+    "Papillon", "toy terrier", "Rhodesian Ridgeback", "Afghan Hound", "Basset Hound", "Beagle",
+    "Bloodhound", "Bluetick Coonhound", "Black and Tan Coonhound", "Treeing Walker Coonhound",
+    "English foxhound", "Redbone Coonhound", "borzoi", "Irish Wolfhound", "Italian Greyhound",
+    "Whippet", "Ibizan Hound", "Norwegian Elkhound", "Otterhound", "Saluki", "Scottish Deerhound",
+    "Weimaraner", "Staffordshire Bull Terrier", "American Staffordshire Terrier",
+    "Bedlington Terrier", "Border Terrier", "Kerry Blue Terrier", "Irish Terrier",
+    "Norfolk Terrier", "Norwich Terrier", "Yorkshire Terrier", "Wire Fox Terrier",
+    "Lakeland Terrier", "Sealyham Terrier", "Airedale Terrier", "Cairn Terrier",
+    "Australian Terrier", "Dandie Dinmont Terrier", "Boston Terrier", "Miniature Schnauzer",
+    "Giant Schnauzer", "Standard Schnauzer", "Scottish Terrier", "Tibetan Terrier",
+    "Australian Silky Terrier", "Soft-coated Wheaten Terrier", "West Highland White Terrier",
+    "Lhasa Apso", "Flat-Coated Retriever", "Curly-coated Retriever", "Golden Retriever",
+    "Labrador Retriever", "Chesapeake Bay Retriever", "German Shorthaired Pointer", "Vizsla",
+    "English Setter", "Irish Setter", "Gordon Setter", "Brittany dog", "Clumber Spaniel",
+    "English Springer Spaniel", "Welsh Springer Spaniel", "Cocker Spaniel", "Sussex Spaniel",
+    "Irish Water Spaniel", "Kuvasz", "Schipperke", "Groenendael dog", "Malinois", "Briard",
+    "Australian Kelpie", "Komondor", "Old English Sheepdog", "Shetland Sheepdog", "collie",
+    "Border Collie", "Bouvier des Flandres dog", "Rottweiler", "German Shepherd Dog", "Dobermann",
+    "Miniature Pinscher", "Greater Swiss Mountain Dog", "Bernese Mountain Dog",
+    "Appenzeller Sennenhund", "Entlebucher Sennenhund", "Boxer", "Bullmastiff", "Tibetan Mastiff",
+    "French Bulldog", "Great Dane", "St. Bernard", "husky", "Alaskan Malamute", "Siberian Husky",
+    "Dalmatian", "Affenpinscher", "Basenji", "pug", "Leonberger", "Newfoundland dog",
+    "Great Pyrenees dog", "Samoyed", "Pomeranian", "Chow Chow", "Keeshond", "brussels griffon",
+    "Pembroke Welsh Corgi", "Cardigan Welsh Corgi", "Toy Poodle", "Miniature Poodle",
+    "Standard Poodle", "Mexican hairless dog (xoloitzcuintli)", "grey wolf", "Alaskan tundra wolf",
+    "red wolf or maned wolf", "coyote", "dingo", "dhole", "African wild dog", "hyena", "red fox",
+    "kit fox", "Arctic fox", "grey fox", "tabby cat", "tiger cat", "Persian cat", "Siamese cat",
+    "Egyptian Mau", "cougar", "lynx", "leopard", "snow leopard", "jaguar", "lion", "tiger",
+    "cheetah", "brown bear", "American black bear", "polar bear", "sloth bear", "mongoose",
+    "meerkat", "tiger beetle", "ladybug", "ground beetle", "longhorn beetle", "leaf beetle",
+    "dung beetle", "rhinoceros beetle", "weevil", "fly", "bee", "ant", "grasshopper",
+    "cricket insect", "stick insect", "cockroach", "praying mantis", "cicada", "leafhopper",
+    "lacewing", "dragonfly", "damselfly", "red admiral butterfly", "ringlet butterfly",
+    "monarch butterfly", "small white butterfly", "sulphur butterfly", "gossamer-winged butterfly",
+    "starfish", "sea urchin", "sea cucumber", "cottontail rabbit", "hare", "Angora rabbit",
+    "hamster", "porcupine", "fox squirrel", "marmot", "beaver", "guinea pig", "common sorrel horse",
+    "zebra", "pig", "wild boar", "warthog", "hippopotamus", "ox", "water buffalo", "bison",
+    "ram (adult male sheep)", "bighorn sheep", "Alpine ibex", "hartebeest", "impala (antelope)",
+    "gazelle", "arabian camel", "llama", "weasel", "mink", "European polecat",
+    "black-footed ferret", "otter", "skunk", "badger", "armadillo", "three-toed sloth", "orangutan",
+    "gorilla", "chimpanzee", "gibbon", "siamang", "guenon", "patas monkey", "baboon", "macaque",
+    "langur", "black-and-white colobus", "proboscis monkey", "marmoset", "white-headed capuchin",
+    "howler monkey", "titi monkey", "Geoffroy's spider monkey", "common squirrel monkey",
+    "ring-tailed lemur", "indri", "Asian elephant", "African bush elephant", "red panda",
+    "giant panda", "snoek fish", "eel", "silver salmon", "rock beauty fish", "clownfish",
+    "sturgeon", "gar fish", "lionfish", "pufferfish", "abacus", "abaya", "academic gown",
+    "accordion", "acoustic guitar", "aircraft carrier", "airliner", "airship", "altar", "ambulance",
+    "amphibious vehicle", "analog clock", "apiary", "apron", "trash can", "assault rifle",
+    "backpack", "bakery", "balance beam", "balloon", "ballpoint pen", "Band-Aid", "banjo",
+    "baluster / handrail", "barbell", "barber chair", "barbershop", "barn", "barometer", "barrel",
+    "wheelbarrow", "baseball", "basketball", "bassinet", "bassoon", "swimming cap", "bath towel",
+    "bathtub", "station wagon", "lighthouse", "beaker", "military hat (bearskin or shako)",
+    "beer bottle", "beer glass", "bell tower", "baby bib", "tandem bicycle", "bikini",
+    "ring binder", "binoculars", "birdhouse", "boathouse", "bobsleigh", "bolo tie", "poke bonnet",
+    "bookcase", "bookstore", "bottle cap", "hunting bow", "bow tie", "brass memorial plaque", "bra",
+    "breakwater", "breastplate", "broom", "bucket", "buckle", "bulletproof vest",
+    "high-speed train", "butcher shop", "taxicab", "cauldron", "candle", "cannon", "canoe",
+    "can opener", "cardigan", "car mirror", "carousel", "tool kit", "cardboard box / carton",
+    "car wheel", "automated teller machine", "cassette", "cassette player", "castle", "catamaran",
+    "CD player", "cello", "mobile phone", "chain", "chain-link fence", "chain mail", "chainsaw",
+    "storage chest", "chiffonier", "bell or wind chime", "china cabinet", "Christmas stocking",
+    "church", "movie theater", "cleaver", "cliff dwelling", "cloak", "clogs", "cocktail shaker",
+    "coffee mug", "coffeemaker", "spiral or coil", "combination lock", "computer keyboard",
+    "candy store", "container ship", "convertible", "corkscrew", "cornet", "cowboy boot",
+    "cowboy hat", "cradle", "construction crane", "crash helmet", "crate", "infant bed",
+    "Crock Pot", "croquet ball", "crutch", "cuirass", "dam", "desk", "desktop computer",
+    "rotary dial telephone", "diaper", "digital clock", "digital watch", "dining table",
+    "dishcloth", "dishwasher", "disc brake", "dock", "dog sled", "dome", "doormat", "drilling rig",
+    "drum", "drumstick", "dumbbell", "Dutch oven", "electric fan", "electric guitar",
+    "electric locomotive", "entertainment center", "envelope", "espresso machine", "face powder",
+    "feather boa", "filing cabinet", "fireboat", "fire truck", "fire screen", "flagpole", "flute",
+    "folding chair", "football helmet", "forklift", "fountain", "fountain pen", "four-poster bed",
+    "freight car", "French horn", "frying pan", "fur coat", "garbage truck",
+    "gas mask or respirator", "gas pump", "goblet", "go-kart", "golf ball", "golf cart", "gondola",
+    "gong", "gown", "grand piano", "greenhouse", "radiator grille", "grocery store", "guillotine",
+    "hair clip", "hair spray", "half-track", "hammer", "hamper", "hair dryer", "hand-held computer",
+    "handkerchief", "hard disk drive", "harmonica", "harp", "combine harvester", "hatchet",
+    "holster", "home theater", "honeycomb", "hook", "hoop skirt", "gymnastic horizontal bar",
+    "horse-drawn vehicle", "hourglass", "iPod", "clothes iron", "carved pumpkin", "jeans", "jeep",
+    "T-shirt", "jigsaw puzzle", "rickshaw", "joystick", "kimono", "knee pad", "knot", "lab coat",
+    "ladle", "lampshade", "laptop computer", "lawn mower", "lens cap", "letter opener", "library",
+    "lifeboat", "lighter", "limousine", "ocean liner", "lipstick", "slip-on shoe", "lotion",
+    "music speaker", "loupe magnifying glass", "sawmill", "magnetic compass", "messenger bag",
+    "mailbox", "tights", "one-piece bathing suit", "manhole cover", "maraca", "marimba", "mask",
+    "matchstick", "maypole", "maze", "measuring cup", "medicine cabinet", "megalith", "microphone",
+    "microwave oven", "military uniform", "milk can", "minibus", "miniskirt", "minivan", "missile",
+    "mitten", "mixing bowl", "mobile home", "ford model t", "modem", "monastery", "monitor",
+    "moped", "mortar and pestle", "graduation cap", "mosque", "mosquito net", "vespa",
+    "mountain bike", "tent", "computer mouse", "mousetrap", "moving van", "muzzle", "metal nail",
+    "neck brace", "necklace", "baby pacifier", "notebook computer", "obelisk", "oboe", "ocarina",
+    "odometer", "oil filter", "pipe organ", "oscilloscope", "overskirt", "bullock cart",
+    "oxygen mask", "product packet / packaging", "paddle", "paddle wheel", "padlock", "paintbrush",
+    "pajamas", "palace", "pan flute", "paper towel", "parachute", "parallel bars", "park bench",
+    "parking meter", "railroad car", "patio", "payphone", "pedestal", "pencil case",
+    "pencil sharpener", "perfume", "Petri dish", "photocopier", "plectrum", "Pickelhaube",
+    "picket fence", "pickup truck", "pier", "piggy bank", "pill bottle", "pillow", "ping-pong ball",
+    "pinwheel", "pirate ship", "drink pitcher", "block plane", "planetarium", "plastic bag",
+    "plate rack", "farm plow", "plunger", "Polaroid camera", "pole", "police van", "poncho",
+    "pool table", "soda bottle", "plant pot", "potter's wheel", "power drill", "prayer rug",
+    "printer", "prison", "missile", "projector", "hockey puck", "punching bag", "purse", "quill",
+    "quilt", "race car", "racket", "radiator", "radio", "radio telescope", "rain barrel",
+    "recreational vehicle", "fishing casting reel", "reflex camera", "refrigerator",
+    "remote control", "restaurant", "revolver", "rifle", "rocking chair", "rotisserie", "eraser",
+    "rugby ball", "ruler measuring stick", "sneaker", "safe", "safety pin", "salt shaker", "sandal",
+    "sarong", "saxophone", "scabbard", "weighing scale", "school bus", "schooner", "scoreboard",
+    "CRT monitor", "screw", "screwdriver", "seat belt", "sewing machine", "shield", "shoe store",
+    "shoji screen / room divider", "shopping basket", "shopping cart", "shovel", "shower cap",
+    "shower curtain", "ski", "balaclava ski mask", "sleeping bag", "slide rule", "sliding door",
+    "slot machine", "snorkel", "snowmobile", "snowplow", "soap dispenser", "soccer ball", "sock",
+    "solar thermal collector", "sombrero", "soup bowl", "keyboard space bar", "space heater",
+    "space shuttle", "spatula", "motorboat", "spider web", "spindle", "sports car", "spotlight",
+    "stage", "steam locomotive", "through arch bridge", "steel drum", "stethoscope", "scarf",
+    "stone wall", "stopwatch", "stove", "strainer", "tram", "stretcher", "couch", "stupa",
+    "submarine", "suit", "sundial", "sunglasses", "sunglasses", "sunscreen", "suspension bridge",
+    "mop", "sweatshirt", "swim trunks / shorts", "swing", "electrical switch", "syringe",
+    "table lamp", "tank", "tape player", "teapot", "teddy bear", "television", "tennis ball",
+    "thatched roof", "front curtain", "thimble", "threshing machine", "throne", "tile roof",
+    "toaster", "tobacco shop", "toilet seat", "torch", "totem pole", "tow truck", "toy store",
+    "tractor", "semi-trailer truck", "tray", "trench coat", "tricycle", "trimaran", "tripod",
+    "triumphal arch", "trolleybus", "trombone", "hot tub", "turnstile", "typewriter keyboard",
+    "umbrella", "unicycle", "upright piano", "vacuum cleaner", "vase", "vaulted or arched ceiling",
+    "velvet fabric", "vending machine", "vestment", "viaduct", "violin", "volleyball",
+    "waffle iron", "wall clock", "wallet", "wardrobe", "military aircraft", "sink",
+    "washing machine", "water bottle", "water jug", "water tower", "whiskey jug", "whistle",
+    "hair wig", "window screen", "window shade", "Windsor tie", "wine bottle", "airplane wing",
+    "wok", "wooden spoon", "wool", "split-rail fence", "shipwreck", "sailboat", "yurt", "website",
+    "comic book", "crossword", "traffic or street sign", "traffic light", "dust jacket", "menu",
+    "plate", "guacamole", "consomme", "hot pot", "trifle", "ice cream", "popsicle", "baguette",
+    "bagel", "pretzel", "cheeseburger", "hot dog", "mashed potatoes", "cabbage", "broccoli",
+    "cauliflower", "zucchini", "spaghetti squash", "acorn squash", "butternut squash", "cucumber",
+    "artichoke", "bell pepper", "cardoon", "mushroom", "Granny Smith apple", "strawberry", "orange",
+    "lemon", "fig", "pineapple", "banana", "jackfruit", "cherimoya (custard apple)", "pomegranate",
+    "hay", "carbonara", "chocolate syrup", "dough", "meatloaf", "pizza", "pot pie", "burrito",
+    "red wine", "espresso", "tea cup", "eggnog", "mountain", "bubble", "cliff", "coral reef",
+    "geyser", "lakeshore", "promontory", "sandbar", "beach", "valley", "volcano", "baseball player",
+    "bridegroom", "scuba diver", "rapeseed", "daisy", "yellow lady's slipper", "corn", "acorn",
+    "rose hip", "horse chestnut seed", "coral fungus", "agaric", "gyromitra", "stinkhorn mushroom",
+    "earth star fungus", "hen of the woods mushroom", "bolete", "corn cob", "toilet paper"
+]
+
+class ImageNet:
+    def __init__(self,
+                 preprocess,
+                 location=os.path.expanduser('~/data'),
+                 batch_size=32,
+                 num_workers=32):
+        self.preprocess = preprocess
+        self.location = location
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+        self.classnames = imagenet_classnames
+
+        self.populate_train()
+        self.populate_test()
+    
+    def populate_train(self):
+        traindir = os.path.join(self.location, self.name(), 'train')
+        self.train_dataset = ImageFolderWithPaths(
+            traindir,
+            transform=self.preprocess)
+        sampler = self.get_train_sampler()
+        kwargs = {'shuffle' : True} if sampler is None else {}
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset,
+            sampler=sampler,
+            batch_size=self.batch_size,
+            num_workers=self.num_workers,
+            **kwargs,
+        )
+
+    def populate_test(self):
+        self.test_dataset = self.get_test_dataset()
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset,
+            batch_size=self.batch_size,
+            num_workers=self.num_workers,
+            sampler=self.get_test_sampler()
+        )
+
+    def get_test_path(self):
+        test_path = os.path.join(self.location, self.name(), 'val_in_folder')
+        if not os.path.exists(test_path):
+            test_path = os.path.join(self.location, self.name(), 'val')
+        return test_path
+
+    def get_train_sampler(self):
+        return None
+
+    def get_test_sampler(self):
+        return None
+
+    def get_test_dataset(self):
+        return ImageFolderWithPaths(self.get_test_path(), transform=self.preprocess)
+
+    def name(self):
+        return 'imagenet'
+
+class ImageNetTrain(ImageNet):
+
+    def get_test_dataset(self):
+        pass
+
+class ImageNetK(ImageNet):
+
+    def get_train_sampler(self):
+        idxs = np.zeros(len(self.train_dataset.targets))
+        target_array = np.array(self.train_dataset.targets)
+        for c in range(1000):
+            m = target_array == c
+            n = len(idxs[m])
+            arr = np.zeros(n)
+            arr[:self.k()] = 1
+            np.random.shuffle(arr)
+            idxs[m] = arr
+
+        idxs = idxs.astype('int')
+        sampler = SubsetSampler(np.where(idxs)[0])
+        return sampler

datasets/kvasir.py

@@ -0,0 +1,165 @@
+import os
+import torch
+from torch.utils.data import Dataset, DataLoader, random_split
+from torchvision import datasets, transforms
+from typing import Tuple, Optional
+
+
+class KvasirDataset:
+    def __init__(
+        self,
+        preprocess,
+        data_dir: str = "theRestDataset/kvasir",
+        image_size: int = 224,
+        val_split: float = 0.2,
+        seed: int = 42,
+        batch_size: int = 32,
+        num_workers: int = 4,
+    ):
+        """
+        Initialize the Kvasir dataset with train and validation splits.
+
+        Args:
+            data_dir (str): Path to the Kvasir dataset directory
+            image_size (int): Size of the input images (default: 224)
+            val_split (float): Validation split ratio (default: 0.2)
+            seed (int): Random seed for reproducibility (default: 42)
+            batch_size (int): Batch size for dataloaders (default: 32)
+            num_workers (int): Number of workers for dataloaders (default: 4)
+        """
+        data_dir = os.path.join(data_dir, "kvasir")
+        self.data_dir = data_dir
+        self.image_size = image_size
+        self.val_split = val_split
+        self.seed = seed
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+
+        # Set up transforms
+        self.preprocess = preprocess
+        if self.preprocess:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.RandomResizedCrop(self.image_size),
+                    transforms.RandomHorizontalFlip(),
+                    transforms.RandomRotation(15),
+                    transforms.ColorJitter(
+                        brightness=0.2, contrast=0.2, saturation=0.2
+                    ),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize(self.image_size + 32),
+                    transforms.CenterCrop(self.image_size),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+        else:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+        # Load and split dataset
+        self.setup()
+
+    def setup(self):
+        """Set up the dataset splits and create dataloaders."""
+        # Load the full dataset with training transforms
+        full_dataset = datasets.ImageFolder(
+            root=self.data_dir, transform=self.train_transforms
+        )
+
+        # Calculate split sizes
+        val_size = int(len(full_dataset) * self.val_split)
+        train_size = len(full_dataset) - val_size
+
+        # Create splits
+        generator = torch.Generator().manual_seed(self.seed)
+        self.train_dataset, self.test_dataset = random_split(
+            full_dataset, [train_size, val_size], generator=generator
+        )
+
+        # Override transforms for validation dataset
+        self.test_dataset.dataset.transform = self.test_transforms
+
+        # Create class names mapping
+        self.classes = full_dataset.classes
+        self.class_to_idx = full_dataset.class_to_idx
+
+    def get_dataloaders(self) -> Tuple[DataLoader, DataLoader]:
+        """
+        Create and return train and validation dataloaders.
+
+        Returns:
+            tuple: (train_dataloader, val_dataloader)
+        """
+        train_loader = DataLoader(
+            self.train_dataset,
+            batch_size=self.batch_size,
+            shuffle=True,
+            num_workers=self.num_workers,
+            pin_memory=True,
+        )
+
+        val_loader = DataLoader(
+            self.test_dataset,
+            batch_size=self.batch_size,
+            shuffle=False,
+            num_workers=self.num_workers,
+            pin_memory=True,
+        )
+
+        return train_loader, val_loader
+
+    def get_class_names(self) -> list:
+        """Return the list of class names."""
+        return self.classes
+
+    def get_class_to_idx(self) -> dict:
+        """Return the class to index mapping."""
+        return self.class_to_idx
+
+
+class Kvasir:
+    def __init__(
+        self,
+        preprocess,
+        location=os.path.expanduser("~/data"),
+        batch_size=32,
+        num_workers=16,
+    ):
+        # Data loading code
+
+        self.dataset = KvasirDataset(
+            preprocess,
+            data_dir=location,
+            batch_size=batch_size,
+            num_workers=num_workers,
+        )
+        self.train_dataset = self.dataset.train_dataset
+        self.test_dataset = self.dataset.test_dataset
+        self.train_loader, self.test_loader = self.dataset.get_dataloaders()
+        self.classnames = self.dataset.get_class_names()
+        idx_to_class = dict((v, k) for k, v in self.dataset.get_class_to_idx().items())
+        self.classnames = [
+            idx_to_class[i].replace("_", " ").lower() for i in range(len(idx_to_class))
+        ]

datasets/landscape.py

@@ -0,0 +1,157 @@
+import os
+from typing import Optional, Callable, Tuple
+
+import torch
+from torchvision import datasets, transforms
+from torch.utils.data import Dataset, DataLoader
+
+
+class LandscapeDataset:
+    def __init__(
+        self,
+        preprocess,
+        root_dir: str,
+        image_size: int = 224,
+        # train: bool = True,
+        # transform: Optional[Callable] = None,
+    ):
+        """
+        Initialize the Landscape dataset.
+
+        Args:
+            root_dir (str): Root directory of the dataset
+            image_size (int): Size of the output images (default: 224)
+            train (bool): Whether to use training or testing transformations
+            transform (callable, optional): Optional custom transform to override defaults
+        """
+        self.root_dir = root_dir
+        self.image_size = image_size
+        # self.train = train
+        self.preprocess = preprocess
+
+        # Define default transforms
+        if self.preprocess:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.RandomResizedCrop(self.image_size),
+                    transforms.RandomHorizontalFlip(),
+                    transforms.RandomRotation(15),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize(self.image_size + 32),
+                    transforms.CenterCrop(self.image_size),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+        else:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+        # # Use custom transform if provided, otherwise use default transforms
+        # self.transform = (
+        #     transform
+        #     if transform is not None
+        #     else (self.train_transforms if train else self.test_transforms)
+        # )
+
+        # Create dataset using ImageFolder
+        train_dir = os.path.join(root_dir, "train")
+        test_dir = os.path.join(root_dir, "test")
+        self.train_dataset = datasets.ImageFolder(
+            root=train_dir, transform=self.train_transforms
+        )
+        self.test_dataset = datasets.ImageFolder(
+            root=test_dir, transform=self.test_transforms
+        )
+
+        # Store class information
+        self.classes = self.train_dataset.classes
+        self.class_to_idx = self.train_dataset.class_to_idx
+        self.num_classes = len(self.classes)
+
+    def get_dataloader(
+        self,
+        dataset: Dataset,
+        batch_size: int = 32,
+        shuffle: bool = None,
+        num_workers: int = 4,
+        pin_memory: bool = True,
+    ) -> DataLoader:
+        """
+        Create a DataLoader for the dataset.
+
+        Args:
+            batch_size (int): Batch size for the dataloader
+            shuffle (bool, optional): Whether to shuffle the data
+            num_workers (int): Number of worker processes
+            pin_memory (bool): Whether to pin memory for faster GPU transfer
+
+        Returns:
+            DataLoader: PyTorch DataLoader object
+        """
+        if shuffle is None:
+            shuffle = self.train
+
+        return DataLoader(
+            dataset,
+            batch_size=batch_size,
+            shuffle=shuffle,
+            num_workers=num_workers,
+            pin_memory=pin_memory,
+        )
+
+
+class Landscape:
+    def __init__(
+        self,
+        preprocess,
+        location: str = os.path.expanduser("~/data"),
+        batch_size: int = 32,
+        num_workers: int = 16,
+    ):
+        self.location = os.path.join(location, "landscape")
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+
+        self.dataset = LandscapeDataset(preprocess, root_dir=self.location)
+        self.train_loader = self.dataset.get_dataloader(
+            self.dataset.train_dataset,
+            batch_size=batch_size,
+            num_workers=num_workers,
+            shuffle=True,
+        )
+        self.test_loader = self.dataset.get_dataloader(
+            self.dataset.test_dataset,
+            batch_size=batch_size,
+            num_workers=num_workers,
+            shuffle=False,
+        )
+        self.train_dataset = self.dataset.train_dataset
+        self.test_dataset = self.dataset.test_dataset
+        self.classes = self.dataset.classes
+
+        idx_to_class = dict((v, k) for k, v in self.dataset.class_to_idx.items())
+        self.classnames = [
+            idx_to_class[i].replace("_", " ").lower() for i in range(len(idx_to_class))
+        ]

datasets/mangoleaf.py

@@ -0,0 +1,152 @@
+import os
+import torch
+from torchvision import transforms, datasets
+from torch.utils.data import random_split
+import numpy as np
+
+
+class MangoLeafDataset:
+    def __init__(
+        self,
+        preprocess,
+        data_dir="theRestDataset/mangoLeaf",
+        image_size=224,
+        val_split=0.2,
+        seed=42,
+    ):
+        """
+        Initialize the MangoLeaf dataset.
+
+        Args:
+            data_dir (str): Path to the mangoLeaf directory
+            image_size (int): Size of the input images (default: 224)
+            val_split (float): Validation split ratio (default: 0.2)
+            seed (int): Random seed for reproducibility (default: 42)
+        """
+        self.data_dir = os.path.join(data_dir, "mangoLeaf")
+        self.image_size = image_size
+        self.val_split = val_split
+        self.seed = seed
+        self.preprocess = preprocess
+        # Define transforms for training and validation
+        if self.preprocess:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.RandomResizedCrop(self.image_size),
+                    transforms.RandomHorizontalFlip(),
+                    transforms.RandomRotation(15),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize(self.image_size + 32),
+                    transforms.CenterCrop(self.image_size),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+        else:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+        # Load the full dataset
+        self.full_dataset = datasets.ImageFolder(
+            root=self.data_dir, transform=None  # We'll apply transforms later
+        )
+
+        # Calculate lengths for train and validation splits
+        val_size = int(len(self.full_dataset) * self.val_split)
+        train_size = len(self.full_dataset) - val_size
+
+        # Create train and validation splits
+        generator = torch.Generator().manual_seed(self.seed)
+        self.train_dataset, self.test_dataset = random_split(
+            self.full_dataset, [train_size, val_size], generator=generator
+        )
+
+        # Create custom datasets with appropriate transforms
+        self.train_dataset = TransformDataset(self.train_dataset, self.train_transforms)
+        self.test_dataset = TransformDataset(self.test_dataset, self.test_transforms)
+
+        # Store class information
+        self.classes = self.full_dataset.classes
+        self.class_to_idx = self.full_dataset.class_to_idx
+
+    def get_train_dataset(self):
+        """Return the training dataset"""
+        return self.train_dataset
+
+    def get_val_dataset(self):
+        """Return the validation dataset"""
+        return self.test_dataset
+
+    def get_class_info(self):
+        """Return class names and mapping"""
+        return self.classes, self.class_to_idx
+
+
+class TransformDataset(torch.utils.data.Dataset):
+    """Custom Dataset class to apply transforms to a subset of data"""
+
+    def __init__(self, dataset, transform=None):
+        self.dataset = dataset
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.dataset)
+
+    def __getitem__(self, idx):
+        image, label = self.dataset[idx]
+        if self.transform:
+            image = self.transform(image)
+        return image, label
+
+
+class MangoLeaf:
+    def __init__(
+        self,
+        preprocess,
+        location=os.path.expanduser("~/data"),
+        batch_size=32,
+        num_workers=16,
+    ):
+        self.location = location
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+
+        # Initialize the MangoLeaf dataset
+        self.dataset = MangoLeafDataset(preprocess, data_dir=self.location)
+        self.train_dataset = self.dataset.get_train_dataset()
+        self.test_dataset = self.dataset.get_val_dataset()
+        self.classes, self.class_to_idx = self.dataset.get_class_info()
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset,
+            shuffle=True,
+            batch_size=batch_size,
+            num_workers=num_workers,
+        )
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset,
+            shuffle=False,
+            batch_size=batch_size,
+            num_workers=num_workers,
+        )
+        self.classnames = self.classes

datasets/mnist.py

@@ -0,0 +1,41 @@
+import os
+import torch
+import torchvision.datasets as datasets
+
+class MNIST:
+    def __init__(self,
+                 preprocess,
+                 location=os.path.expanduser('~/data'),
+                 batch_size=128,
+                 num_workers=16):
+
+
+        self.train_dataset = datasets.MNIST(
+            root=location,
+            download=True,
+            train=True,
+            transform=preprocess
+        )
+
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset,
+            batch_size=batch_size,
+            shuffle=True,
+            num_workers=num_workers
+        )
+
+        self.test_dataset = datasets.MNIST(
+            root=location,
+            download=True,
+            train=False,
+            transform=preprocess
+        )
+
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=num_workers
+        )
+
+        self.classnames = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

datasets/oxfordpets.py

@@ -0,0 +1,50 @@
+from src.datasets.common2 import RGBDatasetLoader
+import torchvision
+from torch.utils.data import DataLoader
+from typing import Tuple
+import os
+
+
+class OxfordPetsLoader(RGBDatasetLoader):
+    """Loader for Oxford-IIIT Pet dataset"""
+
+    def load_dataset(self) -> Tuple[DataLoader, DataLoader]:
+        self.train_dataset = torchvision.datasets.OxfordIIITPet(
+            root=self.root_dir,
+            split="trainval",
+            transform=self.train_transform,
+            download=True,
+        )
+
+        self.test_dataset = torchvision.datasets.OxfordIIITPet(
+            root=self.root_dir,
+            split="test",
+            transform=self.test_transform,
+            download=True,
+        )
+
+        return self._create_dataloaders(self.train_dataset, self.test_dataset)
+
+
+class OxfordPets:
+    def __init__(
+        self,
+        preprocess,
+        location=os.path.expanduser("~/data"),
+        batch_size=32,
+        num_workers=16,
+    ):
+        location = os.path.join(location, "oxfordpets")
+        self.loader = OxfordPetsLoader(preprocess, location, batch_size, num_workers)
+        self.loader.load_dataset()
+        self.train_dataset = self.loader.train_dataset
+        self.test_dataset = self.loader.test_dataset
+        self.train_loader, self.test_loader = self.loader.load_dataset()
+
+        idx_to_class = dict(
+            (v, k)
+            for k, v in self.train_dataset.class_to_idx.items()  # Changed from self.train_loader.dataset
+        )
+        self.classnames = [
+            idx_to_class[i].replace("_", " ").lower() for i in range(len(idx_to_class))
+        ]

datasets/registry.py

@@ -0,0 +1,133 @@
+import sys
+import inspect
+import random
+import torch
+import copy
+
+from torch.utils.data.dataset import random_split
+
+from src.datasets.cars import Cars
+from src.datasets.cifar10 import CIFAR10
+from src.datasets.cifar100 import CIFAR100
+from src.datasets.dtd import DTD
+from src.datasets.eurosat import EuroSAT, EuroSATVal
+from src.datasets.gtsrb import GTSRB
+from src.datasets.imagenet import ImageNet
+from src.datasets.mnist import MNIST
+from src.datasets.resisc45 import RESISC45
+from src.datasets.stl10 import STL10
+from src.datasets.svhn import SVHN
+from src.datasets.sun397 import SUN397
+from src.datasets.kvasir import Kvasir
+from src.datasets.landscape import Landscape
+from src.datasets.mangoleaf import MangoLeaf
+from src.datasets.oxfordpets import OxfordPets
+from src.datasets.weather import Weather
+from src.datasets.beans import Beans
+from src.datasets.fashionmnist import FashionMNIST
+from src.datasets.flowers import Flowers
+from src.datasets.garbage import Garbage
+from src.datasets.birds import Birds
+from src.datasets.dogs import Dogs
+
+registry = {
+    name: obj
+    for name, obj in inspect.getmembers(sys.modules[__name__], inspect.isclass)
+}
+
+
+class GenericDataset(object):
+    def __init__(self):
+        self.train_dataset = None
+        self.train_loader = None
+        self.test_dataset = None
+        self.test_loader = None
+        self.classnames = None
+
+
+def split_train_into_train_val(
+    dataset,
+    new_dataset_class_name,
+    batch_size,
+    num_workers,
+    val_fraction,
+    max_val_samples=None,
+    seed=0,
+):
+    assert val_fraction > 0.0 and val_fraction < 1.0
+    total_size = len(dataset.train_dataset)
+    val_size = int(total_size * val_fraction)
+    if max_val_samples is not None:
+        val_size = min(val_size, max_val_samples)
+    train_size = total_size - val_size
+
+    assert val_size > 0
+    assert train_size > 0
+
+    lengths = [train_size, val_size]
+
+    trainset, valset = random_split(
+        dataset.train_dataset, lengths, generator=torch.Generator().manual_seed(seed)
+    )
+    if new_dataset_class_name == "MNISTVal":
+        assert trainset.indices[0] == 36044
+
+    new_dataset = None
+
+    new_dataset_class = type(new_dataset_class_name, (GenericDataset,), {})
+    new_dataset = new_dataset_class()
+
+    new_dataset.train_dataset = trainset
+    new_dataset.train_loader = torch.utils.data.DataLoader(
+        new_dataset.train_dataset,
+        shuffle=True,
+        batch_size=batch_size,
+        num_workers=num_workers,
+    )
+
+    new_dataset.test_dataset = valset
+    new_dataset.test_loader = torch.utils.data.DataLoader(
+        new_dataset.test_dataset, batch_size=batch_size, num_workers=num_workers
+    )
+
+    new_dataset.classnames = copy.copy(dataset.classnames)
+
+    return new_dataset
+
+
+def get_dataset(
+    dataset_name,
+    preprocess,
+    location,
+    batch_size=128,
+    num_workers=16,
+    val_fraction=0.1,
+    max_val_samples=5000,
+):
+    if dataset_name.endswith("Val"):
+        # Handle val splits
+        if dataset_name in registry:
+            dataset_class = registry[dataset_name]
+        else:
+            base_dataset_name = dataset_name.split("Val")[0]
+            base_dataset = get_dataset(
+                base_dataset_name, preprocess, location, batch_size, num_workers
+            )
+            dataset = split_train_into_train_val(
+                base_dataset,
+                dataset_name,
+                batch_size,
+                num_workers,
+                val_fraction,
+                max_val_samples,
+            )
+            return dataset
+    else:
+        assert (
+            dataset_name in registry
+        ), f"Unsupported dataset: {dataset_name}. Supported datasets: {list(registry.keys())}"
+        dataset_class = registry[dataset_name]
+    dataset = dataset_class(
+        preprocess, location=location, batch_size=batch_size, num_workers=num_workers
+    )
+    return dataset

datasets/resisc45.py

@@ -0,0 +1,304 @@
+import os
+import torch
+
+import abc
+import os
+from typing import Any, Callable, Dict, Optional, Tuple
+
+import numpy as np
+import torch
+from torch import Tensor
+from torch.utils.data import Dataset
+from torchvision.datasets import ImageFolder
+from torchvision.datasets.folder import default_loader as pil_loader
+
+
+# modified from: https://github.com/microsoft/torchgeo
+class VisionDataset(Dataset[Dict[str, Any]], abc.ABC):
+    """Abstract base class for datasets lacking geospatial information.
+    This base class is designed for datasets with pre-defined image chips.
+    """
+
+    @abc.abstractmethod
+    def __getitem__(self, index: int) -> Dict[str, Any]:
+        """Return an index within the dataset.
+        Args:
+            index: index to return
+        Returns:
+            data and labels at that index
+        Raises:
+            IndexError: if index is out of range of the dataset
+        """
+
+    @abc.abstractmethod
+    def __len__(self) -> int:
+        """Return the length of the dataset.
+        Returns:
+            length of the dataset
+        """
+
+    def __str__(self) -> str:
+        """Return the informal string representation of the object.
+        Returns:
+            informal string representation
+        """
+        return f"""\
+{self.__class__.__name__} Dataset
+    type: VisionDataset
+    size: {len(self)}"""
+
+
+class VisionClassificationDataset(VisionDataset, ImageFolder):
+    """Abstract base class for classification datasets lacking geospatial information.
+    This base class is designed for datasets with pre-defined image chips which
+    are separated into separate folders per class.
+    """
+
+    def __init__(
+        self,
+        root: str,
+        transforms: Optional[Callable[[Dict[str, Tensor]], Dict[str, Tensor]]] = None,
+        loader: Optional[Callable[[str], Any]] = pil_loader,
+        is_valid_file: Optional[Callable[[str], bool]] = None,
+    ) -> None:
+        """Initialize a new VisionClassificationDataset instance.
+        Args:
+            root: root directory where dataset can be found
+            transforms: a function/transform that takes input sample and its target as
+                entry and returns a transformed version
+            loader: a callable function which takes as input a path to an image and
+                returns a PIL Image or numpy array
+            is_valid_file: A function that takes the path of an Image file and checks if
+                the file is a valid file
+        """
+        # When transform & target_transform are None, ImageFolder.__getitem__(index)
+        # returns a PIL.Image and int for image and label, respectively
+        super().__init__(
+            root=root,
+            transform=None,
+            target_transform=None,
+            loader=loader,
+            is_valid_file=is_valid_file,
+        )
+
+        # Must be set after calling super().__init__()
+        self.transforms = transforms
+
+    def __getitem__(self, index: int) -> Dict[str, Tensor]:
+        """Return an index within the dataset.
+        Args:
+            index: index to return
+        Returns:
+            data and label at that index
+        """
+        image, label = self._load_image(index)
+
+        if self.transforms is not None:
+            return self.transforms(image), label
+
+        return image, label
+
+    def __len__(self) -> int:
+        """Return the number of data points in the dataset.
+        Returns:
+            length of the dataset
+        """
+        return len(self.imgs)
+
+    def _load_image(self, index: int) -> Tuple[Tensor, Tensor]:
+        """Load a single image and it's class label.
+        Args:
+            index: index to return
+        Returns:
+            the image
+            the image class label
+        """
+        img, label = ImageFolder.__getitem__(self, index)
+        label = torch.tensor(label)
+        return img, label
+
+
+class RESISC45Dataset(VisionClassificationDataset):
+    """RESISC45 dataset.
+    The `RESISC45 <http://www.escience.cn/people/JunweiHan/NWPU-RESISC45.html>`_
+    dataset is a dataset for remote sensing image scene classification.
+    Dataset features:
+    * 31,500 images with 0.2-30 m per pixel resolution (256x256 px)
+    * three spectral bands - RGB
+    * 45 scene classes, 700 images per class
+    * images extracted from Google Earth from over 100 countries
+    * images conditions with high variability (resolution, weather, illumination)
+    Dataset format:
+    * images are three-channel jpgs
+    Dataset classes:
+    0. airplane
+    1. airport
+    2. baseball_diamond
+    3. basketball_court
+    4. beach
+    5. bridge
+    6. chaparral
+    7. church
+    8. circular_farmland
+    9. cloud
+    10. commercial_area
+    11. dense_residential
+    12. desert
+    13. forest
+    14. freeway
+    15. golf_course
+    16. ground_track_field
+    17. harbor
+    18. industrial_area
+    19. intersection
+    20. island
+    21. lake
+    22. meadow
+    23. medium_residential
+    24. mobile_home_park
+    25. mountain
+    26. overpass
+    27. palace
+    28. parking_lot
+    29. railway
+    30. railway_station
+    31. rectangular_farmland
+    32. river
+    33. roundabout
+    34. runway
+    35. sea_ice
+    36. ship
+    37. snowberg
+    38. sparse_residential
+    39. stadium
+    40. storage_tank
+    41. tennis_court
+    42. terrace
+    43. thermal_power_station
+    44. wetland
+    This dataset uses the train/val/test splits defined in the "In-domain representation
+    learning for remote sensing" paper:
+    * https://arxiv.org/abs/1911.06721
+    If you use this dataset in your research, please cite the following paper:
+    * https://doi.org/10.1109/jproc.2017.2675998
+    """
+
+    # url = "https://drive.google.com/file/d/1DnPSU5nVSN7xv95bpZ3XQ0JhKXZOKgIv"
+    # md5 = "d824acb73957502b00efd559fc6cfbbb"
+    # filename = "NWPU-RESISC45.rar"
+    directory = "resisc45/NWPU-RESISC45"
+
+    splits = ["train", "val", "test"]
+    split_urls = {
+        "train": "https://storage.googleapis.com/remote_sensing_representations/resisc45-train.txt",  # noqa: E501
+        "val": "https://storage.googleapis.com/remote_sensing_representations/resisc45-val.txt",  # noqa: E501
+        "test": "https://storage.googleapis.com/remote_sensing_representations/resisc45-test.txt",  # noqa: E501
+    }
+    split_md5s = {
+        "train": "b5a4c05a37de15e4ca886696a85c403e",
+        "val": "a0770cee4c5ca20b8c32bbd61e114805",
+        "test": "3dda9e4988b47eb1de9f07993653eb08",
+    }
+    classes = [
+        "airplane",
+        "airport",
+        "baseball_diamond",
+        "basketball_court",
+        "beach",
+        "bridge",
+        "chaparral",
+        "church",
+        "circular_farmland",
+        "cloud",
+        "commercial_area",
+        "dense_residential",
+        "desert",
+        "forest",
+        "freeway",
+        "golf_course",
+        "ground_track_field",
+        "harbor",
+        "industrial_area",
+        "intersection",
+        "island",
+        "lake",
+        "meadow",
+        "medium_residential",
+        "mobile_home_park",
+        "mountain",
+        "overpass",
+        "palace",
+        "parking_lot",
+        "railway",
+        "railway_station",
+        "rectangular_farmland",
+        "river",
+        "roundabout",
+        "runway",
+        "sea_ice",
+        "ship",
+        "snowberg",
+        "sparse_residential",
+        "stadium",
+        "storage_tank",
+        "tennis_court",
+        "terrace",
+        "thermal_power_station",
+        "wetland",
+    ]
+
+    def __init__(
+        self,
+        root: str = "data",
+        split: str = "train",
+        transforms: Optional[Callable[[Dict[str, Tensor]], Dict[str, Tensor]]] = None,
+    ) -> None:
+        """Initialize a new RESISC45 dataset instance.
+        Args:
+            root: root directory where dataset can be found
+            split: one of "train", "val", or "test"
+            transforms: a function/transform that takes input sample and its target as
+                entry and returns a transformed version
+        """
+        assert split in self.splits
+        self.root = root
+
+        valid_fns = set()
+        with open(os.path.join(self.root, "resisc45", f"resisc45-{split}.txt")) as f:
+            for fn in f:
+                valid_fns.add(fn.strip())
+        is_in_split: Callable[[str], bool] = lambda x: os.path.basename(
+            x) in valid_fns
+
+        super().__init__(
+            root=os.path.join(root, self.directory),
+            transforms=transforms,
+            is_valid_file=is_in_split,
+        )
+
+
+
+class RESISC45:
+    def __init__(self,
+                 preprocess,
+                 location=os.path.expanduser('~/data'),
+                 batch_size=32,
+                 num_workers=16):
+
+        self.train_dataset = RESISC45Dataset(root=location, split='train', transforms=preprocess)
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset,
+            shuffle=True,
+            batch_size=batch_size,
+            num_workers=num_workers,
+        )
+
+        self.test_dataset = RESISC45Dataset(root=location, split='test', transforms=preprocess)
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset,
+            batch_size=batch_size,
+            num_workers=num_workers
+        )
+
+        # class names have _ so split on this for better zero-shot head
+        self.classnames = [' '.join(c.split('_')) for c in RESISC45Dataset.classes]

datasets/stl10.py

@@ -0,0 +1,41 @@
+import os
+import torch
+import torchvision.datasets as datasets
+
+class STL10:
+    def __init__(self,
+                 preprocess,
+                 location=os.path.expanduser('~/data'),
+                 batch_size=128,
+                 num_workers=16):
+
+        location = os.path.join(location, 'stl10')
+        self.train_dataset = datasets.STL10(
+            root=location,
+            download=True,
+            split='train',
+            transform=preprocess
+        )
+
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset,
+            batch_size=batch_size,
+            shuffle=True,
+            num_workers=num_workers
+        )
+
+        self.test_dataset = datasets.STL10(
+            root=location,
+            download=True,
+            split='test',
+            transform=preprocess
+        )
+
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=num_workers
+        )
+
+        self.classnames = self.train_dataset.classes

datasets/sun397.py

@@ -0,0 +1,38 @@
+import os
+import torch
+import torchvision.datasets as datasets
+
+class SUN397:
+    def __init__(self,
+                 preprocess,
+                 location=os.path.expanduser('~/data'),
+                 batch_size=32,
+                 num_workers=0):
+        # Data loading code
+        traindir = os.path.join(location, 'sun397', 'train')
+        valdir = os.path.join(location, 'sun397', 'test')
+
+
+        self.train_dataset = datasets.ImageFolder(traindir, transform=preprocess)
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset,
+            shuffle=True,
+            batch_size=batch_size,
+            num_workers=num_workers,
+        )
+
+        self.test_dataset = datasets.ImageFolder(valdir, transform=preprocess)
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset,
+            batch_size=batch_size,
+            num_workers=num_workers
+        )
+        self.test_loader_shuffle = torch.utils.data.DataLoader(
+            self.test_dataset,
+            shuffle=True,
+            batch_size=batch_size,
+            num_workers=num_workers
+        )
+        idx_to_class = dict((v, k)
+                            for k, v in self.train_dataset.class_to_idx.items())
+        self.classnames = [idx_to_class[i][2:].replace('_', ' ') for i in range(len(idx_to_class))]

datasets/svhn.py

@@ -0,0 +1,45 @@
+import os
+import torch
+from torchvision.datasets import SVHN as PyTorchSVHN
+import numpy as np
+
+
+class SVHN:
+    def __init__(self,
+                 preprocess,
+                 location=os.path.expanduser('~/data'),
+                 batch_size=128,
+                 num_workers=16):
+
+        # to fit with repo conventions for location
+        modified_location = os.path.join(location, 'svhn')
+
+        self.train_dataset = PyTorchSVHN(
+            root=modified_location,
+            download=True,
+            split='train',
+            transform=preprocess
+        )
+
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset,
+            batch_size=batch_size,
+            shuffle=True,
+            num_workers=num_workers
+        )
+
+        self.test_dataset = PyTorchSVHN(
+            root=modified_location,
+            download=True,
+            split='test',
+            transform=preprocess
+        )
+
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=num_workers
+        )
+
+        self.classnames = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

datasets/templates.py

@@ -0,0 +1,319 @@
+cars_template = [
+    lambda c: f"a photo of a {c}.",
+    lambda c: f"a photo of the {c}.",
+    lambda c: f"a photo of my {c}.",
+    lambda c: f"i love my {c}!",
+    lambda c: f"a photo of my dirty {c}.",
+    lambda c: f"a photo of my clean {c}.",
+    lambda c: f"a photo of my new {c}.",
+    lambda c: f"a photo of my old {c}.",
+]
+
+cifar10_template = [
+    lambda c: f"a photo of a {c}.",
+    lambda c: f"a blurry photo of a {c}.",
+    lambda c: f"a black and white photo of a {c}.",
+    lambda c: f"a low contrast photo of a {c}.",
+    lambda c: f"a high contrast photo of a {c}.",
+    lambda c: f"a bad photo of a {c}.",
+    lambda c: f"a good photo of a {c}.",
+    lambda c: f"a photo of a small {c}.",
+    lambda c: f"a photo of a big {c}.",
+    lambda c: f"a photo of the {c}.",
+    lambda c: f"a blurry photo of the {c}.",
+    lambda c: f"a black and white photo of the {c}.",
+    lambda c: f"a low contrast photo of the {c}.",
+    lambda c: f"a high contrast photo of the {c}.",
+    lambda c: f"a bad photo of the {c}.",
+    lambda c: f"a good photo of the {c}.",
+    lambda c: f"a photo of the small {c}.",
+    lambda c: f"a photo of the big {c}.",
+]
+
+cifar100_template = [
+    lambda c: f"a photo of a {c}.",
+    lambda c: f"a blurry photo of a {c}.",
+    lambda c: f"a black and white photo of a {c}.",
+    lambda c: f"a low contrast photo of a {c}.",
+    lambda c: f"a high contrast photo of a {c}.",
+    lambda c: f"a bad photo of a {c}.",
+    lambda c: f"a good photo of a {c}.",
+    lambda c: f"a photo of a small {c}.",
+    lambda c: f"a photo of a big {c}.",
+    lambda c: f"a photo of the {c}.",
+    lambda c: f"a blurry photo of the {c}.",
+    lambda c: f"a black and white photo of the {c}.",
+    lambda c: f"a low contrast photo of the {c}.",
+    lambda c: f"a high contrast photo of the {c}.",
+    lambda c: f"a bad photo of the {c}.",
+    lambda c: f"a good photo of the {c}.",
+    lambda c: f"a photo of the small {c}.",
+    lambda c: f"a photo of the big {c}.",
+]
+
+dtd_template = [
+    lambda c: f"a photo of a {c} texture.",
+    lambda c: f"a photo of a {c} pattern.",
+    lambda c: f"a photo of a {c} thing.",
+    lambda c: f"a photo of a {c} object.",
+    lambda c: f"a photo of the {c} texture.",
+    lambda c: f"a photo of the {c} pattern.",
+    lambda c: f"a photo of the {c} thing.",
+    lambda c: f"a photo of the {c} object.",
+]
+
+eurosat_template = [
+    lambda c: f"a centered satellite photo of {c}.",
+    lambda c: f"a centered satellite photo of a {c}.",
+    lambda c: f"a centered satellite photo of the {c}.",
+]
+
+food101_template = [
+    lambda c: f"a photo of {c}, a type of food.",
+]
+
+oxfordpets_template = [
+    lambda c: f"a photo of a pet {c}.",
+    lambda c: f"a photo of the pet {c}.",
+]
+
+
+gtsrb_template = [
+    lambda c: f'a zoomed in photo of a "{c}" traffic sign.',
+    lambda c: f'a centered photo of a "{c}" traffic sign.',
+    lambda c: f'a close up photo of a "{c}" traffic sign.',
+]
+
+mnist_template = [
+    lambda c: f'a photo of the number: "{c}".',
+]
+
+imagenet_template = [
+    lambda c: f"a bad photo of a {c}.",
+    lambda c: f"a photo of many {c}.",
+    lambda c: f"a sculpture of a {c}.",
+    lambda c: f"a photo of the hard to see {c}.",
+    lambda c: f"a low resolution photo of the {c}.",
+    lambda c: f"a rendering of a {c}.",
+    lambda c: f"graffiti of a {c}.",
+    lambda c: f"a bad photo of the {c}.",
+    lambda c: f"a cropped photo of the {c}.",
+    lambda c: f"a tattoo of a {c}.",
+    lambda c: f"the embroidered {c}.",
+    lambda c: f"a photo of a hard to see {c}.",
+    lambda c: f"a bright photo of a {c}.",
+    lambda c: f"a photo of a clean {c}.",
+    lambda c: f"a photo of a dirty {c}.",
+    lambda c: f"a dark photo of the {c}.",
+    lambda c: f"a drawing of a {c}.",
+    lambda c: f"a photo of my {c}.",
+    lambda c: f"the plastic {c}.",
+    lambda c: f"a photo of the cool {c}.",
+    lambda c: f"a close-up photo of a {c}.",
+    lambda c: f"a black and white photo of the {c}.",
+    lambda c: f"a painting of the {c}.",
+    lambda c: f"a painting of a {c}.",
+    lambda c: f"a pixelated photo of the {c}.",
+    lambda c: f"a sculpture of the {c}.",
+    lambda c: f"a bright photo of the {c}.",
+    lambda c: f"a cropped photo of a {c}.",
+    lambda c: f"a plastic {c}.",
+    lambda c: f"a photo of the dirty {c}.",
+    lambda c: f"a jpeg corrupted photo of a {c}.",
+    lambda c: f"a blurry photo of the {c}.",
+    lambda c: f"a photo of the {c}.",
+    lambda c: f"a good photo of the {c}.",
+    lambda c: f"a rendering of the {c}.",
+    lambda c: f"a {c} in a video game.",
+    lambda c: f"a photo of one {c}.",
+    lambda c: f"a doodle of a {c}.",
+    lambda c: f"a close-up photo of the {c}.",
+    lambda c: f"a photo of a {c}.",
+    lambda c: f"the origami {c}.",
+    lambda c: f"the {c} in a video game.",
+    lambda c: f"a sketch of a {c}.",
+    lambda c: f"a doodle of the {c}.",
+    lambda c: f"a origami {c}.",
+    lambda c: f"a low resolution photo of a {c}.",
+    lambda c: f"the toy {c}.",
+    lambda c: f"a rendition of the {c}.",
+    lambda c: f"a photo of the clean {c}.",
+    lambda c: f"a photo of a large {c}.",
+    lambda c: f"a rendition of a {c}.",
+    lambda c: f"a photo of a nice {c}.",
+    lambda c: f"a photo of a weird {c}.",
+    lambda c: f"a blurry photo of a {c}.",
+    lambda c: f"a cartoon {c}.",
+    lambda c: f"art of a {c}.",
+    lambda c: f"a sketch of the {c}.",
+    lambda c: f"a embroidered {c}.",
+    lambda c: f"a pixelated photo of a {c}.",
+    lambda c: f"itap of the {c}.",
+    lambda c: f"a jpeg corrupted photo of the {c}.",
+    lambda c: f"a good photo of a {c}.",
+    lambda c: f"a plushie {c}.",
+    lambda c: f"a photo of the nice {c}.",
+    lambda c: f"a photo of the small {c}.",
+    lambda c: f"a photo of the weird {c}.",
+    lambda c: f"the cartoon {c}.",
+    lambda c: f"art of the {c}.",
+    lambda c: f"a drawing of the {c}.",
+    lambda c: f"a photo of the large {c}.",
+    lambda c: f"a black and white photo of a {c}.",
+    lambda c: f"the plushie {c}.",
+    lambda c: f"a dark photo of a {c}.",
+    lambda c: f"itap of a {c}.",
+    lambda c: f"graffiti of the {c}.",
+    lambda c: f"a toy {c}.",
+    lambda c: f"itap of my {c}.",
+    lambda c: f"a photo of a cool {c}.",
+    lambda c: f"a photo of a small {c}.",
+    lambda c: f"a tattoo of the {c}.",
+]
+
+resisc45_template = [
+    lambda c: f"satellite imagery of {c}.",
+    lambda c: f"aerial imagery of {c}.",
+    lambda c: f"satellite photo of {c}.",
+    lambda c: f"aerial photo of {c}.",
+    lambda c: f"satellite view of {c}.",
+    lambda c: f"aerial view of {c}.",
+    lambda c: f"satellite imagery of a {c}.",
+    lambda c: f"aerial imagery of a {c}.",
+    lambda c: f"satellite photo of a {c}.",
+    lambda c: f"aerial photo of a {c}.",
+    lambda c: f"satellite view of a {c}.",
+    lambda c: f"aerial view of a {c}.",
+    lambda c: f"satellite imagery of the {c}.",
+    lambda c: f"aerial imagery of the {c}.",
+    lambda c: f"satellite photo of the {c}.",
+    lambda c: f"aerial photo of the {c}.",
+    lambda c: f"satellite view of the {c}.",
+    lambda c: f"aerial view of the {c}.",
+]
+
+stl10_template = [
+    lambda c: f"a photo of a {c}.",
+    lambda c: f"a photo of the {c}.",
+]
+
+sun397_template = [
+    lambda c: f"a photo of a {c}.",
+    lambda c: f"a photo of the {c}.",
+]
+
+svhn_template = [
+    lambda c: f'a photo of the number: "{c}".',
+]
+
+fashionmnist_template = [
+    lambda c: f'a photo of an apparel: "{c}".',
+    lambda c: f'a photo of the apparel: "{c}".',
+    lambda c: f'a photo of a piece of fashion item: "{c}".',
+    lambda c: f'a photo of the fashion item: "{c}".',
+]
+
+beans_template = [
+    lambda c: f'a photo of a bean leaf showing signs of "{c}".',
+    lambda c: f'a close-up photo of a bean plant with "{c}".',
+    lambda c: f'an image of a bean leaf affected by "{c}".',
+    lambda c: f'a photo of a bean leaf condition classified as "{c}".',
+]
+
+flowers_template = [
+    lambda c: f'a photo of a flower: "{c}".',
+    lambda c: f'an image of a "{c}" flower.',
+    lambda c: f'a close-up picture of a "{c}".',
+    lambda c: f'a beautiful photo of a "{c}" in bloom.',
+]
+
+garbage_template = [
+    lambda c: f'a photo of a piece of "{c}" waste.',
+    lambda c: f'an image showing a piece of "{c}".',
+    lambda c: f'a close-up photo of a "{c}" item for recycling.',
+    lambda c: f'a photo of a type of garbage: "{c}".',
+]
+
+kvasir_template = [
+    lambda c: f'an image showing the condition: "{c}".',
+    lambda c: f'a photo of a medical image showing the presence of: "{c}".',
+    lambda c: f'an image depicting the condition of: "{c}".',
+    lambda c: f'an endoscopic view showing: "{c}".',
+    lambda c: f"a photo of the {c} in a medical setting.",
+    lambda c: f'an image illustrating the symptoms of: "{c}".',
+    lambda c: f'an image captured during an endoscopy showing: "{c}".',
+    lambda c: f'an endoscopic image showing the characteristic signs of: "{c}".',
+]
+
+landscape_template = [
+    lambda c: f'an image of a landscape: "{c}".',
+    lambda c: f'a photo showing a beautiful landscape: "{c}".',
+    lambda c: f"a scenic view of the {c} landscape.",
+    lambda c: f"a photo capturing the beauty of a {c}.",
+    lambda c: f"an aerial view of the {c} landscape.",
+    lambda c: f"a stunning image of the {c} in nature.",
+    lambda c: f"an image of the {c} terrain.",
+    lambda c: f"an outdoor scene featuring the {c}.",
+]
+
+weather_template = [
+    lambda c: f'a photo of the weather condition: "{c}".',
+    lambda c: f'a photo showing the weather: "{c}".',
+    lambda c: f'an image of a weather phenomenon: "{c}".',
+    lambda c: f'a photo capturing the weather event: "{c}".',
+    lambda c: f'a photo illustrating the weather condition: "{c}".',
+]
+
+mangoLeaf_template = [
+    lambda c: f'a close-up photo of a mango leaf showing signs of "{c}".',
+    lambda c: f'a photo of a mango leaf affected by "{c}".',
+    lambda c: f'a photo of a mango leaf with the disease or condition "{c}".',
+    lambda c: f'a close-up of a mango leaf exhibiting symptoms of "{c}".',
+    lambda c: f'a photo showing a mango leaf with visible signs of "{c}".',
+]
+
+dogs_template = [
+    lambda c: f'a photo of a dog: "{c}".',
+    lambda c: f'a photo of a kind of dog: "{c}".',
+    lambda c: f'a photo of the dog: "{c}".',
+]
+
+birds_template = [
+    lambda c: f'a photo of a bird: "{c}".',
+    lambda c: f'a photo of a kind of bird: "{c}".',
+    lambda c: f'a photo of the bird: "{c}".',
+]
+
+dataset_to_template = {
+    "Cars": cars_template,
+    "CIFAR10": cifar10_template,
+    "CIFAR100": cifar100_template,
+    "DTD": dtd_template,
+    "EuroSAT": eurosat_template,
+    "Food101": food101_template,
+    "GTSRB": gtsrb_template,
+    "MNIST": mnist_template,
+    "ImageNet": imagenet_template,
+    "RESISC45": resisc45_template,
+    "STL10": stl10_template,
+    "SUN397": sun397_template,
+    "SVHN": svhn_template,
+    "FashionMNIST": fashionmnist_template,
+    "OxfordPets": oxfordpets_template,
+    "Beans": beans_template,
+    "Flowers": flowers_template,
+    "Garbage": garbage_template,
+    "Kvasir": kvasir_template,
+    "Landscape": landscape_template,
+    "Weather": weather_template,
+    "MangoLeaf": mangoLeaf_template,
+    "Dogs": dogs_template,
+    "Birds": birds_template,
+}
+
+
+def get_templates(dataset_name):
+    if dataset_name.endswith("Val"):
+        return get_templates(dataset_name.replace("Val", ""))
+    assert dataset_name in dataset_to_template, f"Unsupported dataset: {dataset_name}"
+    return dataset_to_template[dataset_name]

datasets/weather.py

@@ -0,0 +1,158 @@
+import os
+import torch
+from torchvision import transforms, datasets
+from torch.utils.data import random_split
+import numpy as np
+
+
+class WeatherDataset:
+    def __init__(
+        self,
+        preprocess,
+        data_dir="theRestDataset/weather",
+        image_size=224,
+        val_split=0.2,
+        seed=42,
+    ):
+        """
+        Initialize the Weather dataset with train/validation split and augmentations
+
+        Args:
+            data_dir (str): Path to the dataset directory
+            image_size (int): Size to resize images to
+            val_split (float): Fraction of data to use for validation
+            seed (int): Random seed for reproducibility
+        """
+        self.data_dir = data_dir
+        self.image_size = image_size
+        self.val_split = val_split
+        self.seed = seed
+        self.preprocess = preprocess
+        # Define transforms for training
+        if self.preprocess:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.RandomResizedCrop(self.image_size),
+                    transforms.RandomHorizontalFlip(),
+                    transforms.RandomRotation(15),
+                    transforms.ColorJitter(
+                        brightness=0.2, contrast=0.2, saturation=0.2
+                    ),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+
+            # Define transforms for validation
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize(self.image_size + 32),
+                    transforms.CenterCrop(self.image_size),
+                    transforms.ToTensor(),
+                    transforms.Normalize(
+                        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                    ),
+                ]
+            )
+        else:
+            self.train_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+
+            self.test_transforms = transforms.Compose(
+                [
+                    transforms.Resize((self.image_size, self.image_size)),
+                    transforms.ToTensor(),
+                ]
+            )
+        # Create train/val splits
+        self._create_splits()
+
+    def _create_splits(self):
+        """Create train and validation splits"""
+        # Load the full dataset
+        full_dataset = datasets.ImageFolder(
+            root=self.data_dir, transform=None  # We'll apply transforms later
+        )
+
+        # Calculate lengths for train and validation
+        val_size = int(len(full_dataset) * self.val_split)
+        train_size = len(full_dataset) - val_size
+
+        # Set random seed for reproducibility
+        torch.manual_seed(self.seed)
+        np.random.seed(self.seed)
+
+        # Split the dataset
+        self.train_dataset, self.test_dataset = random_split(
+            full_dataset, [train_size, val_size]
+        )
+
+        # Create custom datasets with appropriate transforms
+        self.train_dataset = TransformDataset(self.train_dataset, self.train_transforms)
+        self.test_dataset = TransformDataset(self.test_dataset, self.test_transforms)
+
+        # Store class names
+        self.classes = full_dataset.classes
+        self.class_to_idx = full_dataset.class_to_idx
+
+    def get_train_dataset(self):
+        """Return the training dataset"""
+        return self.train_dataset
+
+    def get_val_dataset(self):
+        """Return the validation dataset"""
+        return self.test_dataset
+
+    def get_classes(self):
+        """Return the list of classes"""
+        return self.classes
+
+
+class TransformDataset(torch.utils.data.Dataset):
+    """Custom Dataset that applies transform to a subset of another dataset"""
+
+    def __init__(self, subset, transform=None):
+        self.subset = subset
+        self.transform = transform
+
+    def __getitem__(self, idx):
+        x, y = self.subset[idx]
+        if self.transform:
+            x = self.transform(x)
+        return x, y
+
+    def __len__(self):
+        return len(self.subset)
+
+
+class Weather:
+    def __init__(
+        self,
+        preprocess,
+        location=os.path.expanduser("~/data"),
+        batch_size=32,
+        num_workers=16,
+    ):
+        location = os.path.join(location, "weather")
+        self.dataset = WeatherDataset(preprocess, data_dir=location)
+        self.train_dataset = self.dataset.get_train_dataset()
+        self.test_dataset = self.dataset.get_val_dataset()
+        self.train_loader = torch.utils.data.DataLoader(
+            self.train_dataset,
+            batch_size=batch_size,
+            num_workers=num_workers,
+            shuffle=True,
+        )
+        self.test_loader = torch.utils.data.DataLoader(
+            self.test_dataset, batch_size=batch_size, num_workers=num_workers
+        )
+        self.classnames = self.dataset.get_classes()
+        self.class_to_idx = self.dataset.class_to_idx
+        self.num_classes = len(self.classnames)
+        self.input_shape = (3, 224, 224)