File size: 5,455 Bytes
32da3e8 | 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 | """Generic WebDataset wrapper for image-only training (stage-1 RAE decoder).
Used for sources where captions/labels are not consumed by the loss path
(e.g., rendertext-256, flux-synthetic-256). Modeled on BLIP3OWebDataset;
the only real differences are: dataset-agnostic subset discovery, and caption
sidecars are returned as empty strings (the trainer drops them via
`for images, _ in dataloader`).
"""
from pathlib import Path
from typing import Dict, List, Optional, Union
import webdataset as wds
from torchvision import transforms
# Per-dataset subset metadata used for epoch-length estimation.
# Numbers are nominal (paper / repo-card values); a small mis-count only
# shifts virtual epoch length, not correctness.
GENERIC_WDS_METADATA: Dict[str, Dict[str, Dict[str, int]]] = {
# Preprocessed flat 256 pool: 384 PNG -> 256 JPEG, all 5 folders pooled.
# 2439 shards x 10000 samples/shard = 24.39M samples (~459 GB on disk).
"flux-synthetic-256": {
"root": {"num_samples": 24_390_000, "num_shards": 2439},
},
# Preprocessed flat 256 pool: 1024 PNG -> 256 JPEG, root + remaining/ pooled,
# 10 input shards merged per output shard. 1204 shards x 10000 samples/shard
# = 12.04M samples (~217 GB on disk). Regenerated 2026-05-13 with more samples.
"rendertext-256": {
"root": {"num_samples": 12_040_000, "num_shards": 1204},
},
}
def _filter_valid_samples(sample):
return sample[0] is not None
class GenericWebDataset:
"""WebDataset wrapper that globs `*.tar` from one or more subset directories.
Returns (image_tensor, "") for parity with BLIP3OWebDataset's (image, caption)
interface. Stage-1 reconstruction discards the second element.
"""
def __init__(
self,
data_dir: str,
subsets: Union[str, List[str]],
dataset_name: Optional[str] = None,
transform: Optional[transforms.Compose] = None,
image_size: int = 256,
shuffle_buffer: int = 20000,
seed: int = 42,
):
"""
Args:
data_dir: Base path containing tar shards or one folder per subset
(e.g., 'data/rendertext-256', 'data/scale-rae-flux-synthetic-256').
subsets: Single subset name or list of subset folder names to combine.
Use ['root'] for flat pools (tars at data_dir itself).
dataset_name: Optional key into GENERIC_WDS_METADATA for sample
count lookup. If None, falls back to a per-shard estimate.
transform: Optional torchvision transform. Defaults to resize-to-image_size + ToTensor.
image_size: Target square resolution.
shuffle_buffer: WebDataset sample-level shuffle buffer.
seed: Base RNG seed; per-epoch seed = seed + epoch.
"""
self.data_dir = Path(data_dir)
self.subsets = [subsets] if isinstance(subsets, str) else list(subsets)
self.dataset_name = dataset_name
self.transform = transform
self.image_size = image_size
self.shuffle_buffer = shuffle_buffer
self.seed = seed
meta = GENERIC_WDS_METADATA.get(dataset_name, {}) if dataset_name else {}
self._total_samples = 0
self._shard_urls: List[str] = []
for subset in self.subsets:
# 'root' is a sentinel for the data_dir itself (flat pool);
# everything else is a real sub-folder.
subset_dir = self.data_dir if subset == "root" else self.data_dir / subset
if not subset_dir.exists():
raise ValueError(f"Subset directory not found: {subset_dir}")
tar_files = sorted(subset_dir.glob("*.tar"))
if not tar_files:
raise ValueError(f"No tar shards found in {subset_dir}")
self._shard_urls.extend(str(f) for f in tar_files)
if subset in meta:
self._total_samples += meta[subset]["num_samples"]
else:
# Fallback: assume ~50k samples/shard (rough average for these sources).
self._total_samples += len(tar_files) * 50_000
self._num_shards = len(self._shard_urls)
if self.transform is None:
self.transform = transforms.Compose([
transforms.Resize(image_size, interpolation=transforms.InterpolationMode.BICUBIC),
transforms.CenterCrop(image_size),
transforms.ToTensor(),
])
@property
def estimated_size(self) -> int:
return self._total_samples
@property
def num_shards(self) -> int:
return self._num_shards
def _decode_sample(self, sample):
image = sample.get("jpg") or sample.get("png") or sample.get("jpeg") or sample.get("webp")
if self.transform is not None and image is not None:
image = self.transform(image)
return image, ""
def create_pipeline(self, epoch: int = 0) -> wds.WebDataset:
return (
wds.WebDataset(
self._shard_urls,
nodesplitter=wds.split_by_node,
shardshuffle=1000,
seed=self.seed + epoch,
)
.shuffle(self.shuffle_buffer, initial=self.shuffle_buffer // 2)
.decode("pil", handler=wds.ignore_and_continue)
.map(self._decode_sample, handler=wds.ignore_and_continue)
.select(_filter_valid_samples)
)
|