File size: 6,533 Bytes
1a65a70 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 | 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"] # Using the "label" field as the sample identifier.
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
#%% Usage Example
if __name__ == "__main__":
dataset = load_dataset("okhater/SICE", name="default")
train_ds = dataset["train"]
test_ds = dataset["test"]
target_size = (512, 512)
# Example with fixed num_low = 2 (all samples return exactly 2 low images)
fixed_dataset = CustomDataset(train_ds, num_low=2, seed=42, target_size=target_size)
fixed_loader = DataLoader(fixed_dataset, batch_size=32, shuffle=True)
# Example with num_low = -1 (all available low images per sample are returned)
# Since the number of low images may vary, we use a custom collate function to pad the lists.
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:
# Here, low_imgs is a list of length batch_size, each element is a tensor with shape (num_low, C, H, W)
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:
# Here, low_imgs is a tensor of shape (batch_size, max_n, C, H, W)
print("Low images batch shape:", low_imgs.shape)
print("Label batch shape:", label.shape)
break
|