| |
| """Strictly validate a portable YOLO detection dataset before training.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| from collections import Counter, defaultdict |
| from pathlib import Path |
|
|
| import cv2 |
| import yaml |
|
|
|
|
| IMAGE_SUFFIXES = {".jpg", ".jpeg", ".png", ".bmp", ".webp"} |
|
|
|
|
| def load_names(value: object) -> dict[int, str]: |
| if isinstance(value, list): |
| return {i: str(name) for i, name in enumerate(value)} |
| if isinstance(value, dict): |
| return {int(key): str(name) for key, name in value.items()} |
| raise ValueError("data.yaml names must be a list or mapping") |
|
|
|
|
| def split_root(dataset_root: Path, value: str) -> Path: |
| path = Path(value) |
| return path if path.is_absolute() else dataset_root / path |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--data", type=Path, required=True) |
| parser.add_argument("--report", type=Path) |
| parser.add_argument("--skip-image-decode", action="store_true") |
| args = parser.parse_args() |
|
|
| data_path = args.data.resolve() |
| raw = yaml.safe_load(data_path.read_text(encoding="utf-8")) |
| root_value = raw.get("path") |
| dataset_root = Path(root_value).expanduser() if root_value else data_path.parent |
| if not dataset_root.is_absolute(): |
| dataset_root = (data_path.parent / dataset_root).resolve() |
| names = load_names(raw.get("names")) |
| if names != {0: "player", 1: "npc", 2: "attack_object"}: |
| raise SystemExit(f"unexpected class map: {names}") |
|
|
| errors: list[str] = [] |
| split_stats: dict[str, dict] = {} |
| stems_by_split: dict[str, set[str]] = {} |
| class_counts: Counter[str] = Counter() |
| for split in ("train", "val", "test"): |
| if not raw.get(split): |
| continue |
| image_root = split_root(dataset_root, str(raw[split])).resolve() |
| images = sorted(path for path in image_root.rglob("*") if path.suffix.lower() in IMAGE_SUFFIXES) |
| label_root = dataset_root / "labels" / split |
| labels = sorted(label_root.glob("*.txt")) if label_root.is_dir() else [] |
| image_stems = {path.stem for path in images} |
| label_stems = {path.stem for path in labels} |
| for stem in sorted(image_stems - label_stems)[:20]: |
| errors.append(f"{split}: missing label for {stem}") |
| for stem in sorted(label_stems - image_stems)[:20]: |
| errors.append(f"{split}: orphan label {stem}") |
| empty = 0 |
| objects = 0 |
| for image in images: |
| if not args.skip_image_decode: |
| decoded = cv2.imread(str(image)) |
| if decoded is None or decoded.size == 0: |
| errors.append(f"{split}: undecodable image {image}") |
| label = label_root / f"{image.stem}.txt" |
| if not label.is_file(): |
| continue |
| lines = [line.strip() for line in label.read_text(encoding="utf-8").splitlines() if line.strip()] |
| if not lines: |
| empty += 1 |
| for line_number, line in enumerate(lines, 1): |
| fields = line.split() |
| if len(fields) != 5: |
| errors.append(f"{label}:{line_number}: expected 5 fields") |
| continue |
| try: |
| class_id = int(fields[0]) |
| cx, cy, width, height = map(float, fields[1:]) |
| except ValueError: |
| errors.append(f"{label}:{line_number}: non-numeric field") |
| continue |
| if class_id not in names: |
| errors.append(f"{label}:{line_number}: invalid class {class_id}") |
| if not (0 <= cx <= 1 and 0 <= cy <= 1 and 0 < width <= 1 and 0 < height <= 1): |
| errors.append(f"{label}:{line_number}: invalid normalized box") |
| if cx - width / 2 < -1e-5 or cx + width / 2 > 1 + 1e-5: |
| errors.append(f"{label}:{line_number}: x extent outside image") |
| if cy - height / 2 < -1e-5 or cy + height / 2 > 1 + 1e-5: |
| errors.append(f"{label}:{line_number}: y extent outside image") |
| if class_id in names: |
| class_counts[names[class_id]] += 1 |
| objects += 1 |
| stems_by_split[split] = image_stems |
| split_stats[split] = { |
| "images": len(images), |
| "labels": len(labels), |
| "empty_labels": empty, |
| "objects": objects, |
| } |
|
|
| splits = sorted(stems_by_split) |
| for i, left in enumerate(splits): |
| for right in splits[i + 1 :]: |
| overlap = stems_by_split[left] & stems_by_split[right] |
| if overlap: |
| errors.append(f"stem leakage {left}/{right}: {sorted(overlap)[:5]}") |
|
|
| manifest = dataset_root / "export_manifest.jsonl" |
| source_splits: defaultdict[str, set[str]] = defaultdict(set) |
| if manifest.is_file(): |
| for line_number, line in enumerate(manifest.read_text(encoding="utf-8").splitlines(), 1): |
| if not line.strip(): |
| continue |
| row = json.loads(line) |
| source = str(row["relative_video_path"]).split("/", 1)[0] |
| source_splits[source].add(str(row["split"])) |
| leaked = {key: sorted(value) for key, value in source_splits.items() if len(value) > 1} |
| if leaked: |
| errors.append(f"recording-source split leakage: {dict(list(leaked.items())[:5])}") |
|
|
| report = { |
| "valid": not errors, |
| "data": str(data_path), |
| "dataset_root": str(dataset_root), |
| "classes": names, |
| "splits": split_stats, |
| "class_objects": dict(class_counts), |
| "source_split_leakage": 0 if not any("source split leakage" in e for e in errors) else 1, |
| "errors": errors[:100], |
| } |
| output = json.dumps(report, ensure_ascii=False, indent=2) + "\n" |
| print(output, end="") |
| if args.report: |
| args.report.parent.mkdir(parents=True, exist_ok=True) |
| args.report.write_text(output, encoding="utf-8") |
| if errors: |
| raise SystemExit(f"dataset verification failed with {len(errors)} error(s)") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
|
|
