| """Memory-mapped reader for DRIVE-UGC frozen post and OCR-MASK region features. |
| |
| Event indices are zero-based positions in splits/<split>/events.npz. Arrays retain |
| all events; use `paired_indices` for the image-bearing BGFP/RRP protocol subset. |
| """ |
| from __future__ import annotations |
|
|
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| SPLITS = ("B_train", "A_train", "A_val", "A_test") |
|
|
|
|
| class FeatureSplit: |
| def __init__(self, root: str | Path, split: str): |
| if split not in SPLITS: |
| raise ValueError(f"split must be one of {SPLITS}") |
| root = Path(root) |
| folder = root / "features" / split |
| self.text = np.load(folder / "text.npy", mmap_mode="r", allow_pickle=False) |
| self.text_offsets = np.load(folder / "text_event_offsets.npy", allow_pickle=False) |
| self.regions = np.load(folder / "regions.npy", mmap_mode="r", allow_pickle=False) |
| self.region_offsets = np.load(folder / "region_event_offsets.npy", allow_pickle=False) |
| self.image_offsets = np.load(folder / "region_image_offsets.npy", allow_pickle=False) |
| with np.load(root / "splits" / split / "events.npz", allow_pickle=False) as meta: |
| self.ids = meta["ids"].copy() |
| self.groups = meta["groups"].copy() |
| self.y = meta["y"].copy() |
| self.paired = meta["paired"].copy() |
| n = len(self.ids) |
| if not (len(self.groups) == len(self.y) == len(self.paired) == n): |
| raise ValueError("Event metadata lengths disagree") |
| if self.text.shape[1:] != (1024,) or self.regions.shape[1:] != (1152,): |
| raise ValueError("Unexpected feature dimensions") |
| if self.regions.dtype != np.float16: |
| raise ValueError("Expected float16 OCR-MASK regions") |
| if len(self.text_offsets) != n + 1 or len(self.region_offsets) != n + 1: |
| raise ValueError("Event offset lengths disagree") |
| if self.text_offsets[0] != 0 or self.text_offsets[-1] != len(self.text): |
| raise ValueError("Invalid post offsets") |
| if self.region_offsets[0] != 0 or self.region_offsets[-1] != len(self.regions): |
| raise ValueError("Invalid region offsets") |
| if self.image_offsets[0] != 0 or self.image_offsets[-1] != len(self.regions): |
| raise ValueError("Invalid image offsets") |
| if not np.all(np.diff(self.image_offsets) == 81): |
| raise ValueError("Each image must have exactly 81 regions") |
| if not np.all(self.region_offsets % 81 == 0): |
| raise ValueError("Event boundaries do not align with images") |
| if not np.array_equal(self.paired, np.diff(self.region_offsets) > 0): |
| raise ValueError("Paired flags disagree with image-bearing events") |
|
|
| def __len__(self) -> int: |
| return len(self.ids) |
|
|
| @property |
| def paired_indices(self) -> np.ndarray: |
| return np.flatnonzero(self.paired) |
|
|
| def event(self, public_event_index: int) -> dict: |
| i = int(public_event_index) |
| if i < 0 or i >= len(self): |
| raise IndexError(i) |
| p0, p1 = map(int, self.text_offsets[i:i+2]) |
| r0, r1 = map(int, self.region_offsets[i:i+2]) |
| image0, image1 = r0 // 81, r1 // 81 |
| boundaries = self.image_offsets[image0:image1+1] - r0 |
| return { |
| "public_event_index": i, |
| "event_id": str(self.ids[i]), |
| "content_group_id": str(self.groups[i]), |
| "label": int(self.y[i]), |
| "paired": bool(self.paired[i]), |
| "posts": self.text[p0:p1], |
| "regions": self.regions[r0:r1], |
| "image_region_offsets": boundaries, |
| } |
|
|
|
|
| def load_split(root: str | Path, split: str) -> FeatureSplit: |
| return FeatureSplit(root, split) |
|
|
