#!/usr/bin/env python3 """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") # A connection can trickle bytes forever without tripping the socket timeout. 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()