| import random |
| import os |
| from typing import Tuple, List, Dict |
| from datasets import load_dataset |
| from torch.utils.data import DataLoader, Dataset |
| from torchvision import transforms |
| from PIL import Image |
| import torch |
|
|
| class CustomDataset(Dataset): |
| """ |
| Custom Dataset that groups samples by their "label" field (acting as a sample identifier) |
| and separates images into low-quality images and a ground truth image. |
| |
| The ground truth image is identified by inspecting the PIL image's filename for keywords |
| such as "label" or "gt". The remaining images are considered low-quality. |
| |
| At retrieval time, if num_low is set to a positive integer, that many low images are randomly |
| selected from the available ones. If num_low is -1, then all available low images are selected. |
| """ |
| def __init__( |
| self, |
| hf_dataset, |
| num_low: int = 2, |
| seed: int = 42, |
| target_size: Tuple[int, int] = (256, 256) |
| ): |
| """ |
| Parameters: |
| hf_dataset (datasets.Dataset): Hugging Face dataset object. |
| Each record is expected to be a dict with keys: |
| - "image": a PIL.Image (or an array convertible to PIL.Image) with a .filename attribute. |
| - "label": a string used as the sample identifier (e.g., "sample_1"). |
| num_low (int): Number of low-quality images to randomly select per sample. |
| If set to -1, all available low images are selected. |
| seed (int): Random seed for reproducibility. |
| target_size (Tuple[int, int]): Size to which images will be resized. |
| """ |
| self.hf_dataset = hf_dataset |
| self.num_low = num_low |
| self.rng = random.Random(seed) |
| self.transform = transforms.Compose([ |
| transforms.Resize(target_size), |
| transforms.ToTensor(), |
| ]) |
| self.samples = self._prepare_samples() |
|
|
| def _prepare_samples(self) -> List[Dict]: |
| groups = self._group_by_sample() |
| samples = [] |
| for sample_id, items in groups.items(): |
| low_imgs, label_img = self._separate_sample(items) |
| if label_img is not None and low_imgs: |
| samples.append({ |
| "low_images": low_imgs, |
| "label": label_img, |
| }) |
| return samples |
|
|
| def _group_by_sample(self) -> Dict[str, List[Dict]]: |
| groups = {} |
| for item in self.hf_dataset: |
| sample_id = item["label"] |
| groups.setdefault(sample_id, []).append(item) |
| return groups |
|
|
| def _separate_sample(self, items: List[Dict]) -> Tuple[List[Image.Image], Image.Image]: |
| low_images = [] |
| label_image = None |
| for record in items: |
| image_obj = record["image"] |
| if not isinstance(image_obj, Image.Image): |
| image_obj = Image.fromarray(image_obj) |
| filename = getattr(image_obj, "filename", None) |
| if filename: |
| basename = os.path.basename(filename).lower() |
| if "label" in basename or "gt" in basename: |
| label_image = image_obj |
| else: |
| low_images.append(image_obj) |
| else: |
| low_images.append(image_obj) |
| return low_images, label_image |
|
|
| def __len__(self) -> int: |
| return len(self.samples) |
|
|
| def __getitem__(self, idx: int) -> Tuple[List[torch.Tensor], torch.Tensor]: |
| sample = self.samples[idx] |
| low_images = sample["low_images"] |
| label_image = sample["label"] |
|
|
| if self.num_low == -1: |
| selected_low = low_images |
| elif len(low_images) > self.num_low: |
| selected_low = self.rng.sample(low_images, self.num_low) |
| else: |
| selected_low = low_images |
|
|
| transformed_low = [self.transform(img) for img in selected_low] |
| transformed_label = self.transform(label_image) |
|
|
| return transformed_low, transformed_label |
|
|
| def custom_collate_fn(batch): |
| """ |
| Custom collate function to handle variable numbers of low images per sample. |
| Pads each sample's low images list to the maximum number found in the batch. |
| |
| Returns: |
| Tuple of: |
| - Tensor of shape (batch_size, max_n, C, H, W) for low images. |
| - Tensor of shape (batch_size, C, H, W) for label images. |
| """ |
| low_imgs_list, labels = zip(*batch) |
| labels = torch.stack(labels, dim=0) |
| max_n = max(len(low_list) for low_list in low_imgs_list) |
| padded_low = [] |
| for low_list in low_imgs_list: |
| if len(low_list) < max_n: |
| pad_tensor = torch.zeros_like(low_list[0]) |
| padded = low_list + [pad_tensor] * (max_n - len(low_list)) |
| else: |
| padded = low_list |
| padded_low.append(torch.stack(padded, dim=0)) |
| low_imgs_batch = torch.stack(padded_low, dim=0) |
| return low_imgs_batch, labels |
|
|
| |
| if __name__ == "__main__": |
| dataset = load_dataset("okhater/SICE", name="default") |
| train_ds = dataset["train"] |
| test_ds = dataset["test"] |
|
|
| target_size = (512, 512) |
| |
| |
| fixed_dataset = CustomDataset(train_ds, num_low=2, seed=42, target_size=target_size) |
| fixed_loader = DataLoader(fixed_dataset, batch_size=32, shuffle=True) |
| |
| |
| |
| variable_dataset = CustomDataset(test_ds, num_low=-1, seed=42, target_size=target_size) |
| variable_loader = DataLoader(variable_dataset, batch_size=32, shuffle=False, collate_fn=custom_collate_fn) |
| |
| print("Fixed Loader Batch:") |
| for low_imgs, label in fixed_loader: |
| |
| print("Batch contains", len(low_imgs), "samples.") |
| print("Each sample low images shapes:", [img.shape for img in low_imgs]) |
| print("Label batch shape:", label.shape) |
| break |
|
|
| print("\nVariable Loader Batch:") |
| for low_imgs, label in variable_loader: |
| |
| print("Low images batch shape:", low_imgs.shape) |
| print("Label batch shape:", label.shape) |
| break |
|
|
