Datasets:
File size: 5,042 Bytes
3dbf358 |
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 |
import webdataset as wds
from pathlib import Path
import torch
from torchvision import transforms
from PIL import Image
import io
def identity(x):
return x
def pil_decoder(key, data):
"""Decodes image data from bytes to a PIL Image."""
if not key.endswith((".jpg", ".jpeg", ".png")):
return None
try:
return Image.open(io.BytesIO(data)).convert("RGB")
except Exception:
return None
def cls_decoder(key, data):
"""Decodes class label from bytes."""
if not key.endswith(".cls"):
return None
try:
return int(data.decode('utf-8'))
except (ValueError, UnicodeDecodeError):
return None
class MiniImageNetCWebDataset(torch.utils.data.IterableDataset):
"""
A PyTorch Dataset for the WebDataset version of MiniImageNet-C.
Args:
root (str): The root directory of the WebDataset shards.
corruption (str): The corruption type to load (e.g., 'gaussian_noise').
severity (int): The severity level (should be 5 for MiniImageNet-C).
transform (callable, optional): A function/transform that takes in a PIL image
and returns a transformed version. E.g, `transforms.ToTensor()`.
target_transform (callable, optional): A function/transform that takes in the
target and transforms it.
"""
def __init__(self, root, corruption, severity=5, transform=None, target_transform=None):
self.root = Path(root)
self.corruption = corruption
self.severity = severity
self.transform = transform if transform is not None else identity
self.target_transform = target_transform if target_transform is not None else identity
self.shard_path = self.root / self.corruption / str(self.severity)
if not self.shard_path.exists():
raise FileNotFoundError(f"Shards not found at: {self.shard_path}")
shard_urls = [str(p) for p in sorted(self.shard_path.glob("*.tar"))]
if not shard_urls:
raise FileNotFoundError(f"No .tar shards found in {self.shard_path}")
self.dataset = (
wds.WebDataset(shard_urls, shardshuffle=True)
.decode(pil_decoder, cls_decoder)
.to_tuple("jpg", "cls")
.map(self.apply_transforms)
)
def apply_transforms(self, sample):
image, target = sample
return self.transform(image), self.target_transform(target)
def __iter__(self):
return iter(self.dataset)
def __len__(self):
# The length of a WebDataset is not trivially known beforehand.
# You can estimate it or, if needed, iterate through it once to count.
# For Mini-ImageNet-C, each class has 50 images, and there are 1000 classes.
return 50 * 1000
# Example Usage
if __name__ == '__main__':
print("Example of how to use MiniImageNetCWebDataset")
# This assumes you have a 'mini-imagenet-c-webdataset' directory
# created by the convert_to_webdataset.py script.
dataset_root = "../data/mini-imagenet-c-webdataset"
if not Path(dataset_root).exists():
print(f"\nERROR: Example dataset root '{dataset_root}' not found.")
print("Please run 'python data/scripts/convert_to_webdataset.py' first.")
exit()
# Define transformations for the images
image_transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
# 1. Create a dataset for a specific corruption
try:
corruption_type = 'gaussian_noise'
print(f"\nLoading dataset for corruption: '{corruption_type}'")
dataset = MiniImageNetCWebDataset(
root=dataset_root,
corruption=corruption_type,
transform=image_transform
)
# 2. Create a DataLoader
# WebDataset is designed for streaming, so shuffling is handled differently.
# For shuffling, you typically shuffle the shard URLs and the samples within each shard.
# The loader here provides a basic sequential stream.
dataloader = torch.utils.data.DataLoader(dataset, batch_size=32, num_workers=4)
# 3. Iterate through a few batches
print("Iterating through a few batches...")
for i, (images, labels) in enumerate(dataloader):
if i >= 3:
break
print(f" Batch {i+1}:")
print(f" Images shape: {images.shape}")
print(f" Labels shape: {labels.shape}")
print(f" Sample labels: {labels[:4].tolist()}")
print("\nExample finished successfully!")
except FileNotFoundError as e:
print(f"\nERROR: Could not run example. {e}")
print("Please ensure the WebDataset has been generated and the paths are correct.")
except ImportError:
print("\nERROR: 'webdataset' library not found.")
print("Please install it by running: pip install webdataset")
|