| """Portable helpers for reading ZoomPath auxiliary parent-child training pairs.""" |
| from __future__ import annotations |
|
|
| import json |
| import math |
| from pathlib import Path |
| from typing import Any, Iterator |
|
|
|
|
| MAGNIFICATION_TO_TRAINING_SCALE = { |
| 40.0: (0.25, "high"), |
| 20.0: (0.50, "high"), |
| 10.0: (1.0, "mid"), |
| 5.0: (2.0, "mid"), |
| 2.5: (4.0, "low"), |
| 1.0: (10.0, "low"), |
| } |
|
|
|
|
| def nominal_training_scale(magnification: float) -> tuple[list[float], str]: |
| if magnification not in MAGNIFICATION_TO_TRAINING_SCALE: |
| raise ValueError(f"Unsupported training magnification: {magnification}") |
| mpp, level = MAGNIFICATION_TO_TRAINING_SCALE[magnification] |
| return [mpp, mpp], level |
|
|
|
|
| def training_scale_from_mpp(mpp: list[float]) -> tuple[float, str]: |
| |
| mean_mpp = sum(mpp) / 2 |
| if not math.isfinite(mean_mpp) or mean_mpp <= 0: |
| raise ValueError("MPP must be positive and finite") |
| magnification = min(MAGNIFICATION_TO_TRAINING_SCALE, key=lambda value: abs( |
| math.log(mean_mpp / MAGNIFICATION_TO_TRAINING_SCALE[value][0]) |
| )) |
| return magnification, MAGNIFICATION_TO_TRAINING_SCALE[magnification][1] |
|
|
|
|
| class AuxiliaryTrainingReader: |
| def __init__(self, root: str | Path): |
| self.root = Path(root).resolve() |
| self._annotation_path: str | None = None |
| self._targets: list[dict[str, Any]] = [] |
| self._groups: dict[tuple[str, str], list[dict[str, Any]]] = {} |
| self._ignored_groups: dict[tuple[str, str], list[dict[str, Any]]] = {} |
|
|
| def resolve(self, relative: str) -> Path: |
| path = Path(relative) |
| if path.is_absolute() or ".." in path.parts: |
| raise ValueError(f"Not a package-relative path: {relative}") |
| return self.root / path |
|
|
| def iter_records(self, dataset: str | None = None) -> Iterator[dict[str, Any]]: |
| with (self.root / "manifest.jsonl").open(encoding="utf-8") as stream: |
| for line in stream: |
| if line.strip(): |
| row = json.loads(line) |
| if dataset is None or row["dataset"] == dataset: |
| yield row |
|
|
| def annotation_targets(self, row: dict[str, Any]) -> list[dict[str, Any]]: |
| path = row["annotations_path"] |
| if path != self._annotation_path: |
| payload = json.loads(self.resolve(path).read_text(encoding="utf-8")) |
| self._targets = payload["targets"] |
| self._groups = {} |
| self._ignored_groups = {} |
| for target in self._targets: |
| groups = self._groups if target.get("training_eligible", True) else self._ignored_groups |
| for key in ("label", "expression"): |
| if key in target: |
| groups.setdefault((key, target[key]), []).append(target) |
| self._annotation_path = path |
| return self._targets |
|
|
| def valid_targets(self, row: dict[str, Any]) -> list[dict[str, Any]]: |
| self.annotation_targets(row) |
| rule = row["valid_targets_filter"] |
| if set(rule) not in ({"label"}, {"expression"}): |
| raise ValueError(f"Unsupported valid target filter: {rule}") |
| key, value = next(iter(rule.items())) |
| matches = self._groups.get((key, value), []) |
| if len(matches) != row["target_count"]: |
| raise ValueError(f"Target count mismatch: {row['record_id']}") |
| return matches |
|
|
| def ignored_targets(self, row: dict[str, Any]) -> list[dict[str, Any]]: |
| """Source-supported query matches excluded from positive training supervision.""" |
| self.annotation_targets(row) |
| key, value = next(iter(row["valid_targets_filter"].items())) |
| return self._ignored_groups.get((key, value), []) |
|
|
| def load_pair(self, row: dict[str, Any]) -> dict[str, Any]: |
| from PIL import Image |
|
|
| with Image.open(self.resolve(row["parent_image"]["path"])) as image: |
| parent = image.convert("RGB") |
| with Image.open(self.resolve(row["child_image"]["path"])) as image: |
| child = image.convert("RGB") |
| return { |
| "record_id": row["record_id"], "dataset": row["dataset"], |
| "parent_image": parent, "child_image": child, "question": row["question"], |
| "child_bbox_xyxy_in_parent": row["child_bbox_xyxy_in_parent"], |
| "valid_target_bboxes_xyxy_in_parent": [target["bbox_xyxy"] for target in self.valid_targets(row)], |
| "ignored_target_bboxes_xyxy_in_parent": [target["bbox_xyxy"] for target in self.ignored_targets(row)], |
| "ignored_targets_are_not_negatives": bool(row.get("quality_filter")), |
| "organ": row["organ"], "mpp": row["parent_image"]["mpp"], |
| "magnification": row["parent_image"].get("magnification"), |
| "mpp_is_approximate": row["parent_image"].get("mpp_is_approximate", False), |
| "level": row["parent_image"]["level"], "metadata": row, |
| } |
|
|
