| """Deterministic low-data subset selection. |
| |
| The SAME function is used by (a) the segmentation trainer's real-data loader and |
| (b) the pixel-diffusion generator's data loader, so that a low-data experiment at |
| fraction f trains the generator on EXACTLY the real images the segmenter sees — |
| no leakage, no mismatch, fully reproducible. |
| |
| Selection is driven only by (fraction, fraction_seed) and the SORTED list of |
| items, so it is independent of the training seed: the 3 segmentation seeds all |
| use the identical real subset, only their weight init differs. |
| """ |
| from __future__ import annotations |
|
|
| import math |
| import random |
| from typing import List, Sequence, TypeVar |
|
|
| T = TypeVar("T") |
|
|
|
|
| def select_fraction(items: Sequence[T], fraction: float, seed: int = 0) -> List[T]: |
| """Return a deterministic subset of `items` of size ceil(fraction*N). |
| |
| items: any sequence (e.g. list of (image_path, mask_path) tuples). It is |
| sorted by repr() first so order of discovery never affects the subset. |
| fraction: in (0, 1]. >=1 returns all items (sorted copy). |
| seed: subset seed (NOT the training seed). Fixed across training seeds. |
| """ |
| ordered = sorted(items, key=lambda x: repr(x)) |
| n = len(ordered) |
| if fraction >= 1.0 or n == 0: |
| return ordered |
| if fraction <= 0.0: |
| raise ValueError(f"fraction must be in (0,1], got {fraction}") |
| k = max(1, math.ceil(fraction * n)) |
| rng = random.Random(seed) |
| idx = list(range(n)) |
| rng.shuffle(idx) |
| keep = sorted(idx[:k]) |
| return [ordered[i] for i in keep] |
|
|
