code/evaluate.py

#!/usr/bin/env python3
"""Evaluate mAP and derive deployment confidence thresholds on the held-out split."""

from __future__ import annotations

import argparse
import json
from collections import defaultdict
from pathlib import Path

import numpy as np
from ultralytics import YOLO

from dataset_utils import label_for_image, split_images


def iou_one_to_many(box: np.ndarray, others: np.ndarray) -> np.ndarray:
    if len(others) == 0:
        return np.empty(0, dtype=np.float32)
    x1 = np.maximum(box[0], others[:, 0])
    y1 = np.maximum(box[1], others[:, 1])
    x2 = np.minimum(box[2], others[:, 2])
    y2 = np.minimum(box[3], others[:, 3])
    intersection = np.maximum(0, x2 - x1) * np.maximum(0, y2 - y1)
    area_a = max(0, box[2] - box[0]) * max(0, box[3] - box[1])
    area_b = np.maximum(0, others[:, 2] - others[:, 0]) * np.maximum(0, others[:, 3] - others[:, 1])
    return intersection / np.maximum(area_a + area_b - intersection, 1e-9)


def read_ground_truth(path: Path, width: int, height: int) -> dict[int, np.ndarray]:
    rows: defaultdict[int, list[list[float]]] = defaultdict(list)
    if path.is_file():
        for line in path.read_text(encoding="utf-8").splitlines():
            if not line.strip():
                continue
            class_id_text, cx_text, cy_text, w_text, h_text = line.split()
            class_id = int(class_id_text)
            cx, cy, box_w, box_h = map(float, (cx_text, cy_text, w_text, h_text))
            rows[class_id].append(
                [
                    (cx - box_w / 2) * width,
                    (cy - box_h / 2) * height,
                    (cx + box_w / 2) * width,
                    (cy + box_h / 2) * height,
                ]
            )
    return {key: np.asarray(value, dtype=np.float32) for key, value in rows.items()}


def operational_metrics(
    model: YOLO,
    images: list[Path],
    root: Path,
    names: dict[int, str],
    split: str,
    imgsz: int,
    device: str,
    batch: int,
    conf_floor: float,
    match_iou: float,
    gates: dict,
) -> dict:
    predictions: defaultdict[int, list[tuple[float, int]]] = defaultdict(list)
    gt_totals: CounterLike = defaultdict(int)
    results = model.predict(
        source=[str(path) for path in images],
        imgsz=imgsz,
        conf=conf_floor,
        iou=0.7,
        max_det=100,
        device=device,
        batch=batch,
        stream=True,
        verbose=False,
    )
    for image, result in zip(images, results, strict=True):
        height, width = result.orig_shape
        ground_truth = read_ground_truth(label_for_image(image, root, split), width, height)
        for class_id, boxes in ground_truth.items():
            gt_totals[class_id] += len(boxes)
        matched = {class_id: np.zeros(len(boxes), dtype=bool) for class_id, boxes in ground_truth.items()}
        if result.boxes is None:
            continue
        boxes = result.boxes.xyxy.cpu().numpy()
        confidences = result.boxes.conf.cpu().numpy()
        classes = result.boxes.cls.cpu().numpy().astype(int)
        for index in np.argsort(-confidences):
            class_id = int(classes[index])
            candidates = ground_truth.get(class_id, np.empty((0, 4), dtype=np.float32))
            overlaps = iou_one_to_many(boxes[index], candidates)
            is_tp = 0
            if len(overlaps):
                order = np.argsort(-overlaps)
                for gt_index in order:
                    if overlaps[gt_index] < match_iou:
                        break
                    if not matched[class_id][gt_index]:
                        matched[class_id][gt_index] = True
                        is_tp = 1
                        break
            predictions[class_id].append((float(confidences[index]), is_tp))

    per_class = {}
    all_passed = True
    for class_id, name in names.items():
        ranked = sorted(predictions[class_id], reverse=True)
        total_gt = int(gt_totals[class_id])
        tp = 0
        fp = 0
        best = None
        minimum_precision = float(gates[name]["min_precision"])
        minimum_recall = float(gates[name]["min_recall"])
        for confidence, is_tp in ranked:
            tp += is_tp
            fp += 1 - is_tp
            precision = tp / max(1, tp + fp)
            recall = tp / max(1, total_gt)
            if precision >= minimum_precision and (best is None or recall > best["recall"]):
                best = {
                    "confidence": confidence,
                    "precision": precision,
                    "recall": recall,
                    "tp": tp,
                    "fp": fp,
                    "fn": total_gt - tp,
                }
        if best is None:
            best = {"confidence": 1.0, "precision": 1.0, "recall": 0.0, "tp": 0, "fp": 0, "fn": total_gt}
        passed = best["precision"] >= minimum_precision and best["recall"] >= minimum_recall
        all_passed &= passed
        per_class[name] = best | {
            "ground_truth_objects": total_gt,
            "predictions_above_floor": len(ranked),
            "minimum_precision": minimum_precision,
            "minimum_recall": minimum_recall,
            "passed": passed,
        }
    return {"gates_passed": all_passed, "per_class": per_class}


CounterLike = dict[int, int]


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--model", type=Path, required=True)
    parser.add_argument("--data", type=Path, required=True)
    parser.add_argument("--output-dir", type=Path, required=True)
    parser.add_argument("--gates", type=Path, default=Path(__file__).with_name("quality_gates.json"))
    parser.add_argument("--split", default="val", choices=("train", "val", "test"))
    parser.add_argument("--device", default="0")
    parser.add_argument("--imgsz", type=int, default=960)
    parser.add_argument("--batch", type=int, default=16)
    parser.add_argument("--workers", type=int, default=8)
    parser.add_argument("--conf-floor", type=float, default=0.001)
    parser.add_argument("--match-iou", type=float, default=0.5)
    args = parser.parse_args()

    args.output_dir.mkdir(parents=True, exist_ok=True)
    gates = json.loads(args.gates.read_text(encoding="utf-8"))
    images, root, names = split_images(args.data, args.split)
    if not images:
        raise SystemExit(f"no images found in {args.split} split")
    model = YOLO(str(args.model.resolve()))

    metrics = model.val(
        data=str(args.data.resolve()),
        split=args.split,
        imgsz=args.imgsz,
        batch=args.batch,
        device=args.device,
        workers=args.workers,
        conf=args.conf_floor,
        iou=0.7,
        plots=True,
        project=str(args.output_dir.parent.resolve()),
        name=args.output_dir.name,
        exist_ok=True,
        verbose=True,
    )
    standard = {}
    for class_id, name in names.items():
        precision, recall, ap50, map_50_95 = (float(value) for value in metrics.class_result(class_id))
        standard[name] = {
            "precision_at_max_f1": precision,
            "recall_at_max_f1": recall,
            "ap50": ap50,
            "map50_95": map_50_95,
        }
    (args.output_dir / "metrics.csv").write_text(metrics.to_csv(), encoding="utf-8")
    operating = operational_metrics(
        model, images, root, names, args.split, args.imgsz, args.device,
        args.batch, args.conf_floor, args.match_iou, gates,
    )
    summary = {
        "model": str(args.model.resolve()),
        "data": str(args.data.resolve()),
        "split": args.split,
        "images": len(images),
        "imgsz": args.imgsz,
        "match_iou": args.match_iou,
        "standard_ultralytics_metrics": standard,
        "operational_quality_gate": operating,
        "recommended_confidence_by_class": {
            name: values["confidence"] for name, values in operating["per_class"].items()
        },
    }
    text = json.dumps(summary, ensure_ascii=False, indent=2) + "\n"
    (args.output_dir / "quality_gate.json").write_text(text, encoding="utf-8")
    print(text, end="")
    if not operating["gates_passed"]:
        raise SystemExit("quality gate failed; do not start full-dataset inference")


if __name__ == "__main__":
    main()