| |
| """Build the radiograph-dicom-ingest Hugging Face dataset folder. Nothing is uploaded. |
| |
| Each row is one radiograph from GRAZPEDWRI-DX (figshare 14825193) or FracAtlas (figshare 22363012): |
| the unmodified source image file, the source annotation files verbatim, and normalized boxes derived |
| from the source YOLO labels. GRAZPEDWRI-DX PNGs are read out of the 4 GB figshare image zips with |
| HTTP range requests, so only the selected members are transferred. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import http.client |
| import io |
| import json |
| import math |
| import random |
| import shutil |
| import struct |
| import threading |
| import time |
| import urllib.request |
| import xml.etree.ElementTree as ET |
| import zipfile |
| from collections import Counter, defaultdict |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| from datasets import Features, Image, List, Value, load_dataset_builder |
| from PIL import Image as PILImage |
|
|
| FIGSHARE_DOWNLOAD_URL = "https://ndownloader.figshare.com/files/{file_id}" |
| GRAZ_ARTICLE = {"id": 14825193, "version": 2, "doi": "10.6084/m9.figshare.14825193.v2"} |
| FRACATLAS_ARTICLE = {"id": 22363012, "version": 7, "doi": "10.6084/m9.figshare.22363012.v7"} |
| GRAZ_FILE_IDS = { |
| "dataset.csv": 35026432, |
| "folder_structure.zip": 34268819, |
| "images_part1.zip": 34268828, |
| "images_part2.zip": 34268849, |
| "images_part3.zip": 34268864, |
| "images_part4.zip": 34268891, |
| } |
| FRACATLAS_FILE_IDS = {"FracAtlas.zip": 65518038} |
| EXPECTED_MD5 = { |
| "dataset.csv": "f2e996300443654faa62983b7ef1b4c1", |
| "folder_structure.zip": "e484b434286428750e9c838a7ed6ada7", |
| "FracAtlas.zip": "fe9da2c7c285915ebee69dfdab8fd396", |
| } |
| GRAZ_IMAGE_PARTS = ("images_part1.zip", "images_part2.zip", "images_part3.zip", "images_part4.zip") |
|
|
| GRAZ_YOLO_META = "yolov5/meta.yaml" |
| GRAZ_YOLO = "yolov5/labels/{stem}.txt" |
| GRAZ_VOC = "pascalvoc/{stem}.xml" |
| GRAZ_SUPERVISELY = "supervisely/wrist/ann/{stem}.json" |
| FA_CSV = "FracAtlas/dataset.csv" |
| FA_IMAGE = "FracAtlas/images/{folder}/{stem}.jpg" |
| FA_FOLDERS = {1: "Fractured", 0: "Non_fractured"} |
| FA_YOLO = "FracAtlas/Annotations/YOLO/{stem}.txt" |
| FA_YOLO_CLASSES = "FracAtlas/Annotations/YOLO/labels.txt" |
| FA_VOC = "FracAtlas/Annotations/PASCAL VOC/{stem}.xml" |
| FA_COCO = "FracAtlas/Annotations/COCO JSON/COCO_fracture_masks.json" |
|
|
| SPLITS = ("train", "test") |
| TEST_PERCENT = 15 |
| SEED = 0 |
| GRAZ_TRAIN_PATIENTS = 300 |
| GRAZ_TEST_PATIENTS = 60 |
| MIN_PATIENTS_PER_CLASS = 2 |
| FRACATLAS_PER_CLASS = 200 |
| BOX_TOLERANCE_PX = 1.0 |
| YOLO_ROUNDING_SLACK_PX = 1e-3 |
| BOX_DECIMALS = 7 |
| MAX_SHARD_BYTES = 450_000_000 |
| ROW_GROUP_SIZE = 50 |
| FETCH_WORKERS = 6 |
| FETCH_RETRIES = 5 |
| RETRY_BACKOFF_S = 2.0 |
| HTTP_TIMEOUT_S = 120 |
| RANGE_DEADLINE_S = 90 |
| RANGE_BUFFER_BYTES = 1 << 20 |
| RANGE_CHUNK_BYTES = 1 << 16 |
| USER_AGENT = "radiograph-dicom-ingest-builder" |
| EXIF_ORIENTATION_TAG = 0x0112 |
| PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n" |
| PNG_CHANNELS = {0: 1, 2: 3, 3: 1, 4: 2, 6: 4} |
|
|
| FEATURES = Features({ |
| "image": Image(), |
| "image_id": Value("string"), |
| "source": Value("string"), |
| "split": Value("string"), |
| "patient_id": Value("string"), |
| "width": Value("int32"), |
| "height": Value("int32"), |
| "bit_depth": Value("int32"), |
| "pixel_spacing": Value("float64"), |
| "laterality": Value("string"), |
| "projection": Value("string"), |
| "objects": {"label": List(Value("string")), "box": List(List(Value("float64"), length=4))}, |
| "voc_xml": Value("string"), |
| "yolo_txt": Value("string"), |
| "supervisely_json": Value("string"), |
| "coco_annotations": Value("string"), |
| }) |
|
|
|
|
| class RangedHttpFile(io.RawIOBase): |
| """Read-only seekable view of a remote file that fetches only the byte ranges asked for.""" |
|
|
| def __init__(self, url: str): |
| request = urllib.request.Request(url, method="HEAD", headers={"User-Agent": USER_AGENT}) |
| with urllib.request.urlopen(request, timeout=HTTP_TIMEOUT_S) as response: |
| self.url = response.geturl() |
| self.size = int(response.headers["Content-Length"]) |
| self.position = 0 |
|
|
| def seekable(self) -> bool: |
| return True |
|
|
| def readable(self) -> bool: |
| return True |
|
|
| def tell(self) -> int: |
| return self.position |
|
|
| def seek(self, offset: int, whence: int = io.SEEK_SET) -> int: |
| base = {io.SEEK_SET: 0, io.SEEK_CUR: self.position, io.SEEK_END: self.size}[whence] |
| self.position = base + offset |
| return self.position |
|
|
| def readinto(self, buffer) -> int: |
| if self.position >= self.size: |
| return 0 |
| end = min(self.position + len(buffer), self.size) - 1 |
| headers = {"Range": f"bytes={self.position}-{end}", "User-Agent": USER_AGENT} |
| deadline = time.monotonic() + RANGE_DEADLINE_S |
| chunks = [] |
| with urllib.request.urlopen(urllib.request.Request(self.url, headers=headers), timeout=HTTP_TIMEOUT_S) as response: |
| if response.status != 206: |
| raise OSError(f"range request to {self.url} returned HTTP {response.status}, not 206") |
| |
| for chunk in iter(lambda: response.read(RANGE_CHUNK_BYTES), b""): |
| if time.monotonic() > deadline: |
| raise TimeoutError(f"range request {headers['Range']} exceeded {RANGE_DEADLINE_S}s") |
| chunks.append(chunk) |
| data = b"".join(chunks) |
| buffer[: len(data)] = data |
| self.position += len(data) |
| return len(data) |
|
|
|
|
| def open_remote_zip(file_id: int) -> zipfile.ZipFile: |
| remote = RangedHttpFile(FIGSHARE_DOWNLOAD_URL.format(file_id=file_id)) |
| return zipfile.ZipFile(io.BufferedReader(remote, buffer_size=RANGE_BUFFER_BYTES)) |
|
|
|
|
| def assign_split(key: str) -> str: |
| bucket = int(hashlib.md5(key.encode("utf-8")).hexdigest(), 16) % 100 |
| return "test" if bucket < TEST_PERCENT else "train" |
|
|
|
|
| def read_text(archive: zipfile.ZipFile, member: str) -> str: |
| return archive.read(member).decode("utf-8") |
|
|
|
|
| def verify_md5(path: Path, expected: str) -> None: |
| digest = hashlib.md5() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(RANGE_BUFFER_BYTES), b""): |
| digest.update(chunk) |
| if digest.hexdigest() != expected: |
| raise ValueError(f"{path} has md5 {digest.hexdigest()}, figshare publishes {expected}") |
|
|
|
|
| def parse_yolo(text: str, class_names: list[str]) -> list[tuple[str, tuple[float, ...]]]: |
| """YOLO lines 'class cx cy w h' (normalized) -> (label, normalized x1, y1, x2, y2), unclipped.""" |
| objects = [] |
| for line_number, line in enumerate(text.splitlines(), start=1): |
| fields = line.split() |
| if not fields: |
| continue |
| if len(fields) != 5 or not 0 <= int(fields[0]) < len(class_names): |
| raise ValueError(f"malformed YOLO line {line_number}: {line!r}") |
| cx, cy, w, h = map(float, fields[1:]) |
| objects.append((class_names[int(fields[0])], (cx - w / 2, cy - h / 2, cx + w / 2, cy + h / 2))) |
| return objects |
|
|
|
|
| def parse_voc(text: str) -> dict: |
| root = ET.fromstring(text) |
| size = root.find("size") |
| size_empty = size is None or len(size) == 0 |
| objects = [] |
| for element in root.findall("object"): |
| box = element.find("bndbox") |
| corners = tuple(float(box.find(key).text.strip()) for key in ("xmin", "ymin", "xmax", "ymax")) |
| objects.append((element.find("name").text.strip(), corners)) |
| padded = any(node.text and node.text.strip() and node.text != node.text.strip() for node in root.iter()) |
| return { |
| "objects": objects, |
| "size": None if size_empty else (int(size.find("width").text), int(size.find("height").text)), |
| "size_empty": size_empty, |
| "padded_text": padded, |
| } |
|
|
|
|
| def compare_boxes(reference: list, candidate: list) -> tuple[bool, float | None]: |
| """One-to-one greedy matching within each label; returns (label multisets equal, worst abs diff).""" |
| if Counter(label for label, _ in reference) != Counter(label for label, _ in candidate): |
| return False, None |
| pairs = sorted( |
| (max(abs(a - b) for a, b in zip(ref_box, cand_box)), i, j) |
| for i, (ref_label, ref_box) in enumerate(reference) |
| for j, (cand_label, cand_box) in enumerate(candidate) |
| if ref_label == cand_label |
| ) |
| used_ref, used_cand, worst = set(), set(), 0.0 |
| for diff, i, j in pairs: |
| if i in used_ref or j in used_cand: |
| continue |
| used_ref.add(i) |
| used_cand.add(j) |
| worst = max(worst, diff) |
| return True, worst |
|
|
|
|
| def to_pixels(objects: list, width: int, height: int) -> list: |
| return [(label, (x1 * width, y1 * height, x2 * width, y2 * height)) for label, (x1, y1, x2, y2) in objects] |
|
|
|
|
| def check_yolo_voc(yolo_objects: list, voc_xml: str, width: int, height: int) -> dict: |
| voc = parse_voc(voc_xml) |
| labels_equal, max_diff = compare_boxes(to_pixels(yolo_objects, width, height), voc["objects"]) |
| within = labels_equal and max_diff <= BOX_TOLERANCE_PX + YOLO_ROUNDING_SLACK_PX |
| return { |
| "voc_labels_equal": labels_equal, |
| "voc_max_diff_px": max_diff, |
| "voc_within_tolerance": within, |
| "voc_size": voc["size"], |
| "voc_size_empty": voc["size_empty"], |
| "voc_padded_text": voc["padded_text"], |
| "voc_labels": sorted(label for label, _ in voc["objects"]), |
| "yolo_labels": sorted(label for label, _ in yolo_objects), |
| } |
|
|
|
|
| def to_objects(yolo_objects: list) -> tuple[dict, int]: |
| boxes, clipped = [], 0 |
| for _, corners in yolo_objects: |
| bounded = [min(1.0, max(0.0, value)) for value in corners] |
| clipped += bounded != list(corners) |
| boxes.append([round(value, BOX_DECIMALS) for value in bounded]) |
| return {"label": [label for label, _ in yolo_objects], "box": boxes}, clipped |
|
|
|
|
| def describe_image(data: bytes) -> dict: |
| with PILImage.open(io.BytesIO(data)) as image: |
| orientation = image.getexif().get(EXIF_ORIENTATION_TAG) |
| if data.startswith(PNG_SIGNATURE): |
| width, height, bit_depth, color_type = struct.unpack(">IIBB", data[16:26]) |
| channels = PNG_CHANNELS[color_type] |
| elif image.format == "JPEG": |
| (width, height), bit_depth, channels = image.size, image.bits, len(image.getbands()) |
| else: |
| raise ValueError(f"unexpected image format {image.format}") |
| if image.size != (width, height): |
| raise ValueError(f"decoded size {image.size} differs from header size {(width, height)}") |
| max_value = int(np.asarray(image).max()) |
| return { |
| "width": width, |
| "height": height, |
| "bit_depth": bit_depth, |
| "channels": channels, |
| "mode": image.mode, |
| "exif_orientation": orientation, |
| "max_value": max_value, |
| "sha256": hashlib.sha256(data).hexdigest(), |
| } |
|
|
|
|
| def read_graz_class_names(label_zip: zipfile.ZipFile) -> list[str]: |
| meta = read_text(label_zip, GRAZ_YOLO_META) |
| return [line[2:].strip() for line in meta.splitlines() if line.startswith("- ")] |
|
|
|
|
| def select_graz(csv: pd.DataFrame, label_zip: zipfile.ZipFile, class_names: list[str]) -> tuple[list, list]: |
| patient_ids = sorted({int(patient) for patient in csv["patient_id"]}) |
| pools = {split: [p for p in patient_ids if assign_split(str(p)) == split] for split in SPLITS} |
| rng = random.Random(SEED) |
| chosen = { |
| "train": set(rng.sample(pools["train"], GRAZ_TRAIN_PATIENTS)), |
| "test": set(rng.sample(pools["test"], GRAZ_TEST_PATIENTS)), |
| } |
| classes_by_patient = defaultdict(set) |
| for stem, patient in zip(csv["filestem"], csv["patient_id"]): |
| supervisely = json.loads(read_text(label_zip, GRAZ_SUPERVISELY.format(stem=stem))) |
| classes_by_patient[int(patient)] |= {obj["classTitle"] for obj in supervisely["objects"]} |
| topups = [] |
| for class_name in sorted(class_names): |
| for split in SPLITS: |
| have = sum(class_name in classes_by_patient[p] for p in chosen[split]) |
| need = MIN_PATIENTS_PER_CLASS - have |
| if need <= 0: |
| continue |
| candidates = [p for p in pools[split] if class_name in classes_by_patient[p] and p not in chosen[split]] |
| added = rng.sample(candidates, min(need, len(candidates))) |
| chosen[split] |= set(added) |
| topups.append({"class": class_name, "split": split, "had": have, "available": len(candidates), "added": sorted(added)}) |
| records = [] |
| for row in csv.sort_values("filestem").itertuples(index=False): |
| patient = int(row.patient_id) |
| split = assign_split(str(patient)) |
| if patient not in chosen[split]: |
| continue |
| records.append({ |
| "image_id": row.filestem, |
| "source": "graz", |
| "split": split, |
| "patient_id": str(patient), |
| "pixel_spacing": float(row.pixel_spacing) if row.pixel_spacing else None, |
| "laterality": row.laterality or None, |
| "projection": row.projection or None, |
| "fracture_flag": row.fracture_visible == "1", |
| }) |
| return records, topups |
|
|
|
|
| def find_exclusion_reason(data: bytes) -> str | None: |
| """Reasons a FracAtlas JPEG cannot serve as a stored-frame, decodable ground-truth image.""" |
| with PILImage.open(io.BytesIO(data)) as image: |
| orientation = image.getexif().get(EXIF_ORIENTATION_TAG) |
| if orientation not in (None, 1): |
| return f"exif_orientation={orientation}" |
| try: |
| image.load() |
| except OSError as error: |
| return f"decode_error: {error}" |
| return None |
|
|
|
|
| def select_fracatlas(archive: zipfile.ZipFile) -> tuple[list, list]: |
| csv = pd.read_csv(io.BytesIO(archive.read(FA_CSV))) |
| candidates, excluded = {1: [], 0: []}, [] |
| for image_name, fractured in zip(csv["image_id"], csv["fractured"]): |
| stem = Path(image_name).stem |
| reason = find_exclusion_reason(archive.read(FA_IMAGE.format(folder=FA_FOLDERS[fractured], stem=stem))) |
| if reason: |
| excluded.append({"image_id": stem, "fractured": int(fractured), "reason": reason}) |
| continue |
| candidates[int(fractured)].append(stem) |
| rng = random.Random(SEED) |
| records = [] |
| for fractured in (1, 0): |
| for stem in sorted(rng.sample(sorted(candidates[fractured]), FRACATLAS_PER_CLASS)): |
| records.append({ |
| "image_id": stem, |
| "source": "fracatlas", |
| "split": assign_split(stem), |
| "patient_id": stem, |
| "pixel_spacing": None, |
| "laterality": None, |
| "projection": None, |
| "fracture_flag": fractured == 1, |
| "member": FA_IMAGE.format(folder=FA_FOLDERS[fractured], stem=stem), |
| }) |
| return sorted(records, key=lambda record: record["image_id"]), excluded |
|
|
|
|
| def list_graz_image_members() -> dict[str, tuple[str, int, int]]: |
| members = {} |
| for part in GRAZ_IMAGE_PARTS: |
| with open_remote_zip(GRAZ_FILE_IDS[part]) as archive: |
| for info in archive.infolist(): |
| members[info.filename] = (part, GRAZ_FILE_IDS[part], info.file_size) |
| return members |
|
|
|
|
| def fetch_graz_images(records: list, members: dict, cache_dir: Path) -> None: |
| cache_dir.mkdir(parents=True, exist_ok=True) |
| missing = [r["image_id"] for r in records |
| if not (cache_dir / f"{r['image_id']}.png").is_file() |
| or (cache_dir / f"{r['image_id']}.png").stat().st_size != members[f"{r['image_id']}.png"][2]] |
| local = threading.local() |
|
|
| def fetch(stem: str) -> None: |
| part, file_id, _ = members[f"{stem}.png"] |
| zips = local.__dict__.setdefault("zips", {}) |
| last_error = None |
| for attempt in range(FETCH_RETRIES): |
| try: |
| if file_id not in zips: |
| zips[file_id] = open_remote_zip(file_id) |
| data = zips[file_id].read(f"{stem}.png") |
| partial = cache_dir / f"{stem}.png.part" |
| partial.write_bytes(data) |
| partial.replace(cache_dir / f"{stem}.png") |
| return |
| except (OSError, zipfile.BadZipFile, http.client.HTTPException) as error: |
| zips.pop(file_id, None) |
| last_error = error |
| time.sleep(RETRY_BACKOFF_S * 2 ** attempt) |
| raise RuntimeError(f"could not fetch {stem}.png from {part} (figshare file {file_id}): {last_error}") |
|
|
| print(f"fetching {len(missing)} GRAZPEDWRI-DX PNGs ({len(records) - len(missing)} already cached)", flush=True) |
| with ThreadPoolExecutor(FETCH_WORKERS) as pool: |
| for done, _ in enumerate(pool.map(fetch, missing), start=1): |
| if done % 100 == 0: |
| print(f" fetched {done}/{len(missing)}", flush=True) |
|
|
|
|
| class SourceReader: |
| """Loads image bytes and annotation text for selected records and turns them into dataset rows.""" |
|
|
| def __init__(self, label_zip: zipfile.ZipFile, fracatlas_zip: zipfile.ZipFile, graz_cache: Path): |
| self.label_zip = label_zip |
| self.fracatlas_zip = fracatlas_zip |
| self.graz_cache = graz_cache |
| self.graz_class_names = read_graz_class_names(label_zip) |
| self.fa_class_names = read_text(fracatlas_zip, FA_YOLO_CLASSES).splitlines() |
| coco = json.loads(read_text(fracatlas_zip, FA_COCO)) |
| coco_images = {image["id"]: image for image in coco["images"]} |
| self.coco_by_file = {image["file_name"]: {"image": image, "annotations": []} for image in coco["images"]} |
| for annotation in coco["annotations"]: |
| self.coco_by_file[coco_images[annotation["image_id"]]["file_name"]]["annotations"].append(annotation) |
|
|
| def image_size_bytes(self, record: dict) -> int: |
| if record["source"] == "graz": |
| return (self.graz_cache / f"{record['image_id']}.png").stat().st_size |
| return self.fracatlas_zip.getinfo(record["member"]).file_size |
|
|
| def build(self, record: dict) -> tuple[dict, dict]: |
| if record["source"] == "graz": |
| return self._build_graz(record) |
| return self._build_fracatlas(record) |
|
|
| def _build_graz(self, record: dict) -> tuple[dict, dict]: |
| stem = record["image_id"] |
| image_bytes = (self.graz_cache / f"{stem}.png").read_bytes() |
| info = describe_image(image_bytes) |
| yolo_txt = read_text(self.label_zip, GRAZ_YOLO.format(stem=stem)) |
| voc_xml = read_text(self.label_zip, GRAZ_VOC.format(stem=stem)) |
| supervisely_json = read_text(self.label_zip, GRAZ_SUPERVISELY.format(stem=stem)) |
| supervisely = json.loads(supervisely_json) |
| yolo_objects = parse_yolo(yolo_txt, self.graz_class_names) |
| summary = { |
| **check_yolo_voc(yolo_objects, voc_xml, info["width"], info["height"]), |
| "supervisely_size_matches": (supervisely["size"]["width"], supervisely["size"]["height"]) == (info["width"], info["height"]), |
| "supervisely_classes": [obj["classTitle"] for obj in supervisely["objects"]], |
| "supervisely_polygons": [obj["classTitle"] for obj in supervisely["objects"] if len(obj["points"]["exterior"]) > 2], |
| } |
| texts = {"voc_xml": voc_xml, "yolo_txt": yolo_txt, "supervisely_json": supervisely_json, "coco_annotations": None} |
| return self._assemble(record, image_bytes, "png", info, yolo_objects, texts, summary) |
|
|
| def _build_fracatlas(self, record: dict) -> tuple[dict, dict]: |
| stem = record["image_id"] |
| image_bytes = self.fracatlas_zip.read(record["member"]) |
| info = describe_image(image_bytes) |
| yolo_txt = read_text(self.fracatlas_zip, FA_YOLO.format(stem=stem)) |
| voc_xml = read_text(self.fracatlas_zip, FA_VOC.format(stem=stem)) |
| yolo_objects = parse_yolo(yolo_txt, self.fa_class_names) |
| coco = self.coco_by_file.get(f"{stem}.jpg", {"image": None, "annotations": []}) |
| coco_boxes = [("fractured", (x, y, x + w, y + h)) for x, y, w, h in (a["bbox"] for a in coco["annotations"])] |
| coco_equal, coco_diff = compare_boxes(to_pixels(yolo_objects, info["width"], info["height"]), coco_boxes) |
| voc_rounding = Counter( |
| "round" if v == round(c) else "floor" if v == math.floor(c) else "other" |
| for (_, voc_box), (_, coco_box) in zip(sorted(parse_voc(voc_xml)["objects"]), sorted(coco_boxes)) |
| for v, c in zip(voc_box, coco_box) |
| ) |
| coco_size = None if coco["image"] is None else (coco["image"]["width"], coco["image"]["height"]) |
| summary = { |
| **check_yolo_voc(yolo_objects, voc_xml, info["width"], info["height"]), |
| "coco_labels_equal": coco_equal, |
| "coco_max_diff_px": coco_diff, |
| "coco_size_matches": coco_size in (None, (info["width"], info["height"])), |
| "voc_vs_coco_rounding": dict(voc_rounding), |
| } |
| texts = {"voc_xml": voc_xml, "yolo_txt": yolo_txt, "supervisely_json": None, |
| "coco_annotations": json.dumps(coco["annotations"])} |
| return self._assemble(record, image_bytes, "jpg", info, yolo_objects, texts, summary) |
|
|
| @staticmethod |
| def _assemble(record, image_bytes, extension, info, yolo_objects, texts, checks) -> tuple[dict, dict]: |
| objects, clipped = to_objects(yolo_objects) |
| row = { |
| "image": {"bytes": image_bytes, "path": f"{record['image_id']}.{extension}"}, |
| "image_id": record["image_id"], |
| "source": record["source"], |
| "split": record["split"], |
| "patient_id": record["patient_id"], |
| "width": info["width"], |
| "height": info["height"], |
| "bit_depth": info["bit_depth"], |
| "pixel_spacing": record["pixel_spacing"], |
| "laterality": record["laterality"], |
| "projection": record["projection"], |
| "objects": objects, |
| **texts, |
| } |
| summary = { |
| **{key: record[key] for key in ("image_id", "source", "split", "patient_id", "fracture_flag", "laterality", "projection", "pixel_spacing")}, |
| **info, |
| **checks, |
| "labels": objects["label"], |
| "clipped_boxes": clipped, |
| "image_bytes": len(image_bytes), |
| } |
| return row, summary |
|
|
|
|
| def plan_shards(sizes: list[int]) -> list[int]: |
| total = sum(sizes) |
| shard_count = max(1, math.ceil(total / MAX_SHARD_BYTES)) |
| offsets = np.cumsum([0] + sizes[:-1]) |
| return [min(shard_count - 1, int(offset * shard_count // total)) for offset in offsets] |
|
|
|
|
| def write_split(split: str, records: list, reader: SourceReader, data_dir: Path) -> list[dict]: |
| assignments = plan_shards([reader.image_size_bytes(record) for record in records]) |
| shard_count = max(assignments) + 1 |
| summaries = [] |
| for shard in range(shard_count): |
| path = data_dir / f"{split}-{shard:05d}-of-{shard_count:05d}.parquet" |
| shard_records = [record for record, assigned in zip(records, assignments) if assigned == shard] |
| with pq.ParquetWriter(path, FEATURES.arrow_schema) as writer: |
| for start in range(0, len(shard_records), ROW_GROUP_SIZE): |
| built = [reader.build(record) for record in shard_records[start:start + ROW_GROUP_SIZE]] |
| rows = [FEATURES.encode_example(row) for row, _ in built] |
| writer.write_table(pa.Table.from_pylist(rows, schema=FEATURES.arrow_schema), row_group_size=ROW_GROUP_SIZE) |
| summaries.extend({**summary, "shard": path.name} for _, summary in built) |
| print(f" wrote {path.name}: {len(shard_records)} rows, {path.stat().st_size / 1e6:.1f} MB", flush=True) |
| return summaries |
|
|
|
|
| def audit_graz_label_files(label_zip: zipfile.ZipFile, class_names: list[str]) -> dict: |
| """VOC vs YOLO over every GRAZPEDWRI-DX label file, using the image size recorded by Supervisely.""" |
| prefix = GRAZ_YOLO.split("{")[0] |
| stems = sorted(name[len(prefix):-4] for name in label_zip.namelist() if name.startswith(prefix) and name.endswith(".txt")) |
| label_mismatches, box_mismatches, worst, size_empty, padded = [], [], 0.0, 0, 0 |
| for stem in stems: |
| supervisely = json.loads(read_text(label_zip, GRAZ_SUPERVISELY.format(stem=stem))) |
| yolo_objects = parse_yolo(read_text(label_zip, GRAZ_YOLO.format(stem=stem)), class_names) |
| check = check_yolo_voc(yolo_objects, read_text(label_zip, GRAZ_VOC.format(stem=stem)), |
| supervisely["size"]["width"], supervisely["size"]["height"]) |
| size_empty += check["voc_size_empty"] |
| padded += check["voc_padded_text"] |
| if not check["voc_labels_equal"]: |
| label_mismatches.append({"image_id": stem, "yolo": check["yolo_labels"], "voc": check["voc_labels"]}) |
| continue |
| worst = max(worst, check["voc_max_diff_px"]) |
| if check["voc_max_diff_px"] > BOX_TOLERANCE_PX: |
| box_mismatches.append({"image_id": stem, "max_diff_px": round(check["voc_max_diff_px"], 6)}) |
| return {"files": len(stems), "voc_size_empty": size_empty, "voc_padded_text": padded, |
| "label_mismatches": label_mismatches, "box_diff_over_1px": box_mismatches, "max_diff_px": round(worst, 6)} |
|
|
|
|
| def audit_fracatlas_archive(archive: zipfile.ZipFile) -> dict: |
| names = archive.namelist() |
| by_basename = defaultdict(list) |
| for name in names: |
| if "/images/" in name and name.endswith(".jpg"): |
| by_basename[Path(name).name].append(name) |
| duplicates = [ |
| {"image": base, "members": paths, "identical": len({archive.getinfo(p).CRC for p in paths}) == 1} |
| for base, paths in sorted(by_basename.items()) if len(paths) > 1 |
| ] |
| csv = pd.read_csv(io.BytesIO(archive.read(FA_CSV))) |
| folder_counts = Counter(Path(p).parent.name for paths in by_basename.values() for p in paths) |
| return {"duplicate_image_members": duplicates, "csv_rows": len(csv), |
| "csv_fractured": int(csv["fractured"].sum()), "image_members_per_folder": dict(folder_counts), |
| "yolo_files": sum(1 for n in names if n.startswith(FA_YOLO.split("{")[0]) and n.endswith(".txt")), |
| "voc_files": sum(1 for n in names if n.startswith(FA_VOC.split("{")[0]) and n.endswith(".xml"))} |
|
|
|
|
| def compute_stats(summaries: list[dict], data_dir: Path) -> dict: |
| frame = pd.DataFrame(summaries) |
| group = frame.groupby(["split", "source"]) |
| per_class = Counter((s["split"], s["source"], label) for s in summaries for label in s["labels"]) |
| images_with_class = Counter((s["split"], s["source"], label) for s in summaries for label in set(s["labels"])) |
| graz = frame[frame.source == "graz"] |
| fracture_label = {"graz": "fracture", "fracatlas": "fractured"} |
| flag_box_disagree = [s["image_id"] for s in summaries if s["fracture_flag"] != (fracture_label[s["source"]] in s["labels"])] |
| return { |
| "rows": {f"{split}/{source}": int(n) for (split, source), n in group.size().items()}, |
| "patients": {f"{split}/{source}": int(n) for (split, source), n in group["patient_id"].nunique().items()}, |
| "fracture_flag_true": {f"{split}/{source}": int(n) for (split, source), n in group["fracture_flag"].sum().items()}, |
| "instances": {f"{split}/{source}/{label}": n for (split, source, label), n in sorted(per_class.items())}, |
| "images_with_class": {f"{split}/{source}/{label}": n for (split, source, label), n in sorted(images_with_class.items())}, |
| "supervisely_objects": dict(Counter(c for s in summaries if s["source"] == "graz" for c in s["supervisely_classes"])), |
| "supervisely_polygons": dict(Counter(c for s in summaries if s["source"] == "graz" for c in s["supervisely_polygons"])), |
| "bit_depth": {f"{source}/{depth}": int(n) for (source, depth), n in frame.groupby(["source", "bit_depth"]).size().items()}, |
| "mode": {f"{source}/{mode}": int(n) for (source, mode), n in frame.groupby(["source", "mode"]).size().items()}, |
| "max_value_range": {source: [int(g.max_value.min()), int(g.max_value.max())] for source, g in frame.groupby("source")}, |
| "width_range": {source: [int(g.width.min()), int(g.width.max())] for source, g in frame.groupby("source")}, |
| "height_range": {source: [int(g.height.min()), int(g.height.max())] for source, g in frame.groupby("source")}, |
| "pixel_spacing": {str(k): int(v) for k, v in graz.pixel_spacing.value_counts().items()}, |
| "laterality": {str(k): int(v) for k, v in graz.laterality.value_counts().items()}, |
| "projection": {str(k): int(v) for k, v in graz.projection.value_counts().items()}, |
| "exif_orientation_present": int(frame.exif_orientation.notna().sum()), |
| "voc_label_mismatches": [s["image_id"] for s in summaries if not s["voc_labels_equal"]], |
| "voc_box_over_tolerance": [s["image_id"] for s in summaries if s["voc_labels_equal"] and not s["voc_within_tolerance"]], |
| "voc_max_diff_px": {source: round(float(g.voc_max_diff_px.max()), 6) for source, g in frame.groupby("source")}, |
| "voc_size_empty": {source: int(g.voc_size_empty.sum()) for source, g in frame.groupby("source")}, |
| "voc_padded_text": {source: int(g.voc_padded_text.sum()) for source, g in frame.groupby("source")}, |
| "supervisely_size_mismatches": [s["image_id"] for s in summaries if s["source"] == "graz" and not s["supervisely_size_matches"]], |
| "coco_label_mismatches": [s["image_id"] for s in summaries if s["source"] == "fracatlas" and not s["coco_labels_equal"]], |
| "coco_max_diff_px": round(float(frame[frame.source == "fracatlas"].coco_max_diff_px.max()), 6), |
| "coco_size_mismatches": [s["image_id"] for s in summaries if s["source"] == "fracatlas" and not s["coco_size_matches"]], |
| "voc_vs_coco_rounding": dict(sum((Counter(s["voc_vs_coco_rounding"]) for s in summaries if s["source"] == "fracatlas"), Counter())), |
| "fracture_flag_box_disagreements": flag_box_disagree, |
| "clipped_boxes": int(frame.clipped_boxes.sum()), |
| "image_bytes": {source: int(g.image_bytes.sum()) for source, g in frame.groupby("source")}, |
| "shards": {path.name: path.stat().st_size for path in sorted(data_dir.glob("*.parquet"))}, |
| } |
|
|
|
|
| def verify_row(row: dict, split: str, expected: dict, decoder: Image) -> None: |
| source = expected[row["image_id"]] |
| if hashlib.sha256(row["image"]["bytes"]).hexdigest() != source["sha256"]: |
| raise ValueError(f"{row['image_id']}: stored bytes differ from the source file") |
| with decoder.decode_example(row["image"]) as decoded: |
| decoded_size = decoded.size |
| if decoded_size != (row["width"], row["height"]) or row["split"] != split: |
| raise ValueError(f"{row['image_id']}: decoded size {decoded_size} or split {row['split']} mismatch") |
| if any(not (0 <= x1 <= x2 <= 1 and 0 <= y1 <= y2 <= 1) for x1, y1, x2, y2 in row["objects"]["box"]): |
| raise ValueError(f"{row['image_id']}: box outside the unit square") |
|
|
|
|
| def verify_output(out_dir: Path, summaries: list[dict]) -> dict: |
| """Resolve splits the way `datasets` does, then stream every row group and check each row.""" |
| data_files = load_dataset_builder(str(out_dir)).config.data_files |
| expected = {s["image_id"]: s for s in summaries} |
| decoder = Image() |
| seen = Counter() |
| for split in SPLITS: |
| for path in data_files[split]: |
| parquet = pq.ParquetFile(path) |
| if Features.from_arrow_schema(parquet.schema_arrow) != FEATURES: |
| raise ValueError(f"{path}: stored features differ from the declared features") |
| for batch in parquet.iter_batches(batch_size=ROW_GROUP_SIZE): |
| for row in batch.to_pylist(): |
| verify_row(row, split, expected, decoder) |
| seen[(split, row["source"])] += 1 |
| if sum(seen.values()) != len(expected): |
| raise ValueError(f"read back {sum(seen.values())} rows, wrote {len(expected)}") |
| return {f"{split}/{source}": n for (split, source), n in sorted(seen.items())} |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) |
| parser.add_argument("--graz-csv", type=Path, default=Path("/tmp/rr-src/graz_dataset.csv")) |
| parser.add_argument("--graz-labels", type=Path, default=Path("/tmp/rr-src/graz_folder.zip")) |
| parser.add_argument("--fracatlas-zip", type=Path, default=Path("/tmp/rfd/src/FracAtlas.zip")) |
| parser.add_argument("--work", type=Path, default=Path("/tmp/rfd/work")) |
| parser.add_argument("--out", type=Path, default=Path("/tmp/rfd/hf")) |
| parser.add_argument("--verify-only", action="store_true", help="re-read --out and check it against --work/rows.jsonl") |
| return parser.parse_args() |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| if args.verify_only: |
| summaries = [json.loads(line) for line in (args.work / "rows.jsonl").read_text().splitlines()] |
| print(json.dumps(verify_output(args.out, summaries))) |
| return |
| for path, name in ((args.graz_csv, "dataset.csv"), (args.graz_labels, "folder_structure.zip"), (args.fracatlas_zip, "FracAtlas.zip")): |
| verify_md5(path, EXPECTED_MD5[name]) |
| args.work.mkdir(parents=True, exist_ok=True) |
| label_zip = zipfile.ZipFile(args.graz_labels) |
| fracatlas_zip = zipfile.ZipFile(args.fracatlas_zip) |
| graz_csv = pd.read_csv(args.graz_csv, encoding="utf-8-sig", dtype=str, keep_default_na=False) |
|
|
| graz_records, topups = select_graz(graz_csv, label_zip, read_graz_class_names(label_zip)) |
| fa_records, fa_excluded = select_fracatlas(fracatlas_zip) |
| fetch_graz_images(graz_records, list_graz_image_members(), args.work / "graz_png") |
|
|
| reader = SourceReader(label_zip, fracatlas_zip, args.work / "graz_png") |
| data_dir, scripts_dir = args.out / "data", args.out / "scripts" |
| for generated in (data_dir, scripts_dir): |
| shutil.rmtree(generated, ignore_errors=True) |
| generated.mkdir(parents=True) |
| summaries = [] |
| for split in SPLITS: |
| split_records = [r for r in graz_records + fa_records if r["split"] == split] |
| summaries.extend(write_split(split, split_records, reader, data_dir)) |
|
|
| report = { |
| "selection": {"graz_topups": topups, "fracatlas_excluded": fa_excluded}, |
| "stats": compute_stats(summaries, data_dir), |
| "source_audit": {"graz": audit_graz_label_files(label_zip, reader.graz_class_names), |
| "fracatlas": audit_fracatlas_archive(fracatlas_zip)}, |
| } |
| shutil.copy2(Path(__file__), scripts_dir / "build_dataset.py") |
| (args.work / "report.json").write_text(json.dumps(report, indent=1, default=str)) |
| (args.work / "rows.jsonl").write_text("\n".join(json.dumps(s, default=str) for s in summaries) + "\n") |
| report["verified_rows"] = verify_output(args.out, summaries) |
| (args.work / "report.json").write_text(json.dumps(report, indent=1, default=str)) |
| print(json.dumps(report["verified_rows"])) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
