| |
| """RipBench detection / instance-segmentation evaluator (framework-agnostic). |
| |
| HOW TO USE (no CLI args - edit CONFIG below, then: python evaluate_detection.py) |
| 1. TASK="bbox" + MODE="bbox" for detection; TASK="instance_segmentation" + |
| MODE="segm" for masks; TASK="bbox_from_instance" + MODE="bbox" scores |
| against the polygon-derived boxes (for the trimmed-vs-derived ablation, |
| any detector's predictions can be evaluated against either bbox GT - |
| image ids are identical across the two passes). |
| 2. Point PRED_DIR at a predictions/ folder of <stem>_preds_val.json / |
| <stem>_preds_test.json files (predict_ultralytics.py writes one next to |
| the checkpoints). Only stems containing the task |
| token (_det_ / _bfi_ / _seg_) are evaluated - a mixed folder is fine. |
| For a single model instead: PRED_DIR=None + PRED_VAL/PRED_TEST. |
| 3. Run (env with numpy + pycocotools, e.g. conda yoloV26). One TSV row per |
| model x split appends to eval/results/<TASK>_eval.tsv (Sheets-ready). |
| |
| PROTOCOL: the confidence threshold is selected PER MODEL on val (best |
| F2@IoU0.50; ties: higher R, P, threshold), frozen, then applied to test. |
| selected_conf / selected_on columns record it. For test-only evaluation set |
| USE_VAL_SELECTION=False and FIXED_CONF_THRESHOLD. |
| |
| DEFINITIONS: AP50/AP75/AP50_95 via pycocotools (threshold-free). Counts via |
| COCO-style greedy matching: predictions in descending score order, each |
| matched to the highest-IoU still-UNMATCHED GT with IoU >= threshold (fixes |
| the argmax-then-veto bug of train/eval_scripts/, which counted a prediction |
| FP whenever its single best-overlap GT was taken). avg*_50_95 columns are |
| MEANS over IoU 0.50..0.95 - fractional, not counts; avgP is the mean of |
| per-threshold precisions. Predictions must be dumped at a low confidence |
| floor (predictor uses 0.001) so the sweep and AP see the full curve. |
| """ |
| import json |
| import os |
| _RIPBENCH_ROOT = os.environ.get("RIPBENCH_ROOT", os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", ".."))) |
| from datetime import datetime |
|
|
| import numpy as np |
| from pycocotools.coco import COCO |
| from pycocotools.cocoeval import COCOeval |
|
|
| |
| DATASET_ROOT = _RIPBENCH_ROOT |
| TASK = "bbox" |
| MODE = "bbox" |
|
|
| |
| PRED_DIR = _RIPBENCH_ROOT + "/models/bbox/best_models/predictions" |
| TASK_TOKEN = None |
| |
| PRED_VAL = "/path/to/<model>_preds_val.json" |
| PRED_TEST = "/path/to/<model>_preds_test.json" |
|
|
| USE_VAL_SELECTION = True |
| FIXED_CONF_THRESHOLD = 0.25 |
|
|
| CONF_SWEEP = [round(x / 100, 2) for x in range(1, 96)] |
| |
| |
| IOU_THRESHOLDS = [round(x / 100, 2) for x in range(50, 96, 5)] |
|
|
| MODEL_TAG = None |
| OUT_TSV = os.path.join(os.path.dirname(os.path.abspath(__file__)), "results", f"{TASK}_eval.tsv") |
| SAVE_SWEEP = True |
| SWEEP_SUFFIX = "_sweep.tsv" |
| |
|
|
| GT_VAL = os.path.join(DATASET_ROOT, "labels", TASK, "coco", "val.json") |
| GT_TEST = os.path.join(DATASET_ROOT, "labels", TASK, "coco", "test.json") |
|
|
| HEADER = ("timestamp\tmodel\ttask\tmode\tsplit\tselected_conf\tselected_on" |
| "\tn_images\tn_gt\tAP50\tAP75\tAP50_95" |
| "\tP50\tR50\tF1_50\tF2_50\tTP50\tFP50\tFN50" |
| "\tavgP_50_95\tavgR_50_95\tavgF1_50_95\tavgF2_50_95" |
| "\tavgTP_50_95\tavgFP_50_95\tavgFN_50_95\n") |
|
|
|
|
| def f_beta(p, r, beta): |
| denom = beta * beta * p + r |
| return (1 + beta * beta) * p * r / denom if denom > 0 else 0.0 |
|
|
|
|
| def greedy_match(ious, iou_thr): |
| """COCO-style greedy one-to-one matching. Rows = predictions sorted by |
| descending score, columns = GT. Each prediction matches the highest-IoU |
| GT among those still unmatched and >= iou_thr.""" |
| n_pred, n_gt = ious.shape |
| matched = np.zeros(n_gt, dtype=bool) |
| tp = fp = 0 |
| for i in range(n_pred): |
| cand = np.where(~matched & (ious[i] >= iou_thr))[0] |
| if len(cand): |
| matched[cand[np.argmax(ious[i][cand])]] = True |
| tp += 1 |
| else: |
| fp += 1 |
| return tp, fp, int(n_gt - matched.sum()) |
|
|
|
|
| def bbox_iou_matrix(pred_boxes, gt_boxes): |
| """IoU matrix for xywh boxes: rows preds, cols GT.""" |
| p = np.asarray(pred_boxes, dtype=np.float64) |
| g = np.asarray(gt_boxes, dtype=np.float64) |
| px1, py1, px2, py2 = p[:, 0], p[:, 1], p[:, 0] + p[:, 2], p[:, 1] + p[:, 3] |
| gx1, gy1, gx2, gy2 = g[:, 0], g[:, 1], g[:, 0] + g[:, 2], g[:, 1] + g[:, 3] |
| ix1 = np.maximum(px1[:, None], gx1[None, :]) |
| iy1 = np.maximum(py1[:, None], gy1[None, :]) |
| ix2 = np.minimum(px2[:, None], gx2[None, :]) |
| iy2 = np.minimum(py2[:, None], gy2[None, :]) |
| inter = np.clip(ix2 - ix1, 0, None) * np.clip(iy2 - iy1, 0, None) |
| union = (p[:, 2] * p[:, 3])[:, None] + (g[:, 2] * g[:, 3])[None, :] - inter |
| return np.where(union > 0, inter / union, 0.0) |
|
|
|
|
| def build_cache(gt_coco, pred_coco, mode): |
| """Per image, per category: (pred scores desc, IoU matrix in that order, |
| n_gt). IoU matrices are computed ONCE; every (conf, iou_thr) evaluation |
| slices the top-k rows (scores sorted desc -> a conf threshold keeps a |
| prefix).""" |
| from pycocotools import mask as maskUtils |
|
|
| cache = [] |
| for img_id in gt_coco.getImgIds(): |
| gt_anns = gt_coco.loadAnns(gt_coco.getAnnIds(imgIds=img_id)) |
| pred_anns = pred_coco.loadAnns(pred_coco.getAnnIds(imgIds=img_id)) if pred_coco else [] |
| per_cat = {} |
| cats = {a["category_id"] for a in gt_anns} | {a["category_id"] for a in pred_anns} |
| for cat in cats: |
| g = [a for a in gt_anns if a["category_id"] == cat] |
| p = sorted((a for a in pred_anns if a["category_id"] == cat), |
| key=lambda a: -float(a.get("score", 0.0))) |
| scores = np.array([float(a.get("score", 0.0)) for a in p]) |
| if not p or not g: |
| per_cat[cat] = (scores, np.zeros((len(p), len(g))), len(g)) |
| continue |
| if mode == "bbox": |
| ious = bbox_iou_matrix([a["bbox"] for a in p], [a["bbox"] for a in g]) |
| else: |
| g_rle = [gt_coco.annToRLE(a) for a in g] |
| p_rle = [pred_coco.annToRLE(a) for a in p] |
| iscrowd = [int(a.get("iscrowd", 0)) for a in g] |
| ious = np.atleast_2d(maskUtils.iou(p_rle, g_rle, iscrowd)) |
| per_cat[cat] = (scores, ious, len(g)) |
| cache.append(per_cat) |
| return cache |
|
|
|
|
| def metrics_at(cache, conf, iou_thr): |
| TP = FP = FN = 0 |
| for per_cat in cache: |
| for scores, ious, n_gt in per_cat.values(): |
| k = int((scores >= conf).sum()) |
| tp, fp, fn = greedy_match(ious[:k], iou_thr) if k or n_gt else (0, 0, 0) |
| TP += tp |
| FP += fp |
| FN += fn |
| p = TP / (TP + FP) if TP + FP else 0.0 |
| r = TP / (TP + FN) if TP + FN else 0.0 |
| return {"TP": TP, "FP": FP, "FN": FN, "P": p, "R": r, |
| "F1": f_beta(p, r, 1.0), "F2": f_beta(p, r, 2.0)} |
|
|
|
|
| def evaluate_split(cache, conf): |
| """@0.50 metrics + means over IOU_THRESHOLDS (the avg* columns).""" |
| at50 = metrics_at(cache, conf, 0.50) |
| per_iou = [metrics_at(cache, conf, t) for t in IOU_THRESHOLDS] |
| avg = {k: float(np.mean([m[k] for m in per_iou])) for k in per_iou[0]} |
| return at50, avg |
|
|
|
|
| def ap_metrics(gt_coco, preds_list, iou_type): |
| """Threshold-free AP via pycocotools. stats: [0]=AP50-95 [1]=AP50 [2]=AP75.""" |
| if not preds_list: |
| return {"AP50": 0.0, "AP75": 0.0, "AP50_95": 0.0} |
| pred_coco = gt_coco.loadRes(preds_list) |
| ev = COCOeval(gt_coco, pred_coco, iouType=iou_type) |
| ev.evaluate() |
| ev.accumulate() |
| ev.summarize() |
| return {"AP50": float(ev.stats[1]), "AP75": float(ev.stats[2]), "AP50_95": float(ev.stats[0])} |
|
|
|
|
| def append_row(row): |
| os.makedirs(os.path.dirname(OUT_TSV), exist_ok=True) |
| write_header = not os.path.isfile(OUT_TSV) |
| with open(OUT_TSV, "a") as f: |
| if write_header: |
| f.write(HEADER) |
| f.write("\t".join(str(x) for x in row) + "\n") |
|
|
|
|
| def make_row(model, split, selected_conf, selected_on, gt, at50, avg, ap): |
| n_gt = sum(len(gt.getAnnIds(imgIds=i)) for i in gt.getImgIds()) |
| return [datetime.now().strftime("%Y-%m-%d %H:%M"), model, TASK, MODE, split, |
| f"{selected_conf:.2f}", selected_on, len(gt.getImgIds()), n_gt, |
| f"{ap['AP50']:.6f}", f"{ap['AP75']:.6f}", f"{ap['AP50_95']:.6f}", |
| f"{at50['P']:.6f}", f"{at50['R']:.6f}", f"{at50['F1']:.6f}", f"{at50['F2']:.6f}", |
| at50["TP"], at50["FP"], at50["FN"], |
| f"{avg['P']:.6f}", f"{avg['R']:.6f}", f"{avg['F1']:.6f}", f"{avg['F2']:.6f}", |
| f"{avg['TP']:.3f}", f"{avg['FP']:.3f}", f"{avg['FN']:.3f}"] |
|
|
|
|
| def evaluate_pair(gt_v, gt_t, pred_val, pred_test, model): |
| if USE_VAL_SELECTION: |
| print(f"[val] {model}") |
| with open(pred_val) as f: |
| preds_v = json.load(f) |
| pred_coco_v = gt_v.loadRes(preds_v) if preds_v else None |
| cache_v = build_cache(gt_v, pred_coco_v, MODE) |
| sweep = [] |
| for conf in CONF_SWEEP: |
| at50, avg = evaluate_split(cache_v, conf) |
| sweep.append((conf, at50, avg)) |
| best_conf, best_at50, best_avg = max( |
| sweep, key=lambda s: (s[1]["F2"], s[1]["R"], s[1]["P"], s[0])) |
| selected_on = "val" |
| print(f"[val] {model}: selected conf={best_conf:.2f} (F2@50={best_at50['F2']:.4f})") |
|
|
| if SAVE_SWEEP: |
| sweep_path = os.path.splitext(pred_val)[0] + SWEEP_SUFFIX |
| with open(sweep_path, "w") as f: |
| f.write("conf\tP50\tR50\tF1_50\tF2_50\tTP50\tFP50\tFN50\n") |
| for conf, a, _ in sweep: |
| f.write(f"{conf:.2f}\t{a['P']:.6f}\t{a['R']:.6f}\t{a['F1']:.6f}" |
| f"\t{a['F2']:.6f}\t{a['TP']}\t{a['FP']}\t{a['FN']}\n") |
|
|
| ap_v = ap_metrics(gt_v, preds_v, "bbox" if MODE == "bbox" else "segm") |
| append_row(make_row(model, "val", best_conf, selected_on, gt_v, best_at50, best_avg, ap_v)) |
| else: |
| best_conf = FIXED_CONF_THRESHOLD |
| selected_on = "fixed" |
| print(f"[test-only] {model}: fixed conf={best_conf:.2f}") |
|
|
| with open(pred_test) as f: |
| preds_t = json.load(f) |
| pred_coco_t = gt_t.loadRes(preds_t) if preds_t else None |
| cache_t = build_cache(gt_t, pred_coco_t, MODE) |
| at50_t, avg_t = evaluate_split(cache_t, best_conf) |
| ap_t = ap_metrics(gt_t, preds_t, "bbox" if MODE == "bbox" else "segm") |
| append_row(make_row(model, "test", best_conf, selected_on, gt_t, at50_t, avg_t, ap_t)) |
| print(f"[test] {model}: conf={best_conf:.2f} ({selected_on}) " |
| f"AP50={ap_t['AP50']:.4f} AP50_95={ap_t['AP50_95']:.4f} " |
| f"P={at50_t['P']:.4f} R={at50_t['R']:.4f} F2={at50_t['F2']:.4f} " |
| f"TP/FP/FN={at50_t['TP']}/{at50_t['FP']}/{at50_t['FN']}\n") |
|
|
|
|
| def discover_pairs(pred_dir): |
| token = TASK_TOKEN |
| if token is None: |
| token = {"bbox": "_det_", "bbox_from_instance": "_bfi_", |
| "instance_segmentation": "_seg_"}[TASK] |
| for f in sorted(os.listdir(pred_dir)): |
| if not f.endswith("_preds_test.json"): |
| continue |
| stem = f[: -len("_preds_test.json")] |
| if token and token not in stem: |
| continue |
| val = os.path.join(pred_dir, stem + "_preds_val.json") |
| yield stem, (val if os.path.isfile(val) else None), os.path.join(pred_dir, f) |
|
|
|
|
| def main(): |
| print(f"GT: {GT_VAL}\n {GT_TEST}") |
| gt_v = COCO(GT_VAL) if USE_VAL_SELECTION else None |
| gt_t = COCO(GT_TEST) |
|
|
| if PRED_DIR: |
| pairs = list(discover_pairs(PRED_DIR)) |
| print(f"batch mode: {len(pairs)} model(s) in {PRED_DIR}\n") |
| failed = [] |
| for stem, pred_val, pred_test in pairs: |
| if USE_VAL_SELECTION and pred_val is None: |
| print(f"SKIP {stem}: no _preds_val.json (needed for threshold selection)") |
| continue |
| try: |
| evaluate_pair(gt_v, gt_t, pred_val, pred_test, stem) |
| except Exception as e: |
| failed.append((stem, repr(e))) |
| print(f"ERROR {stem}: {e!r}") |
| print(f"done: {len(pairs) - len(failed)}/{len(pairs)} ok -> {OUT_TSV}") |
| for stem, err in failed: |
| print(f" FAILED {stem}: {err}") |
| else: |
| model = MODEL_TAG or os.path.splitext(os.path.basename(PRED_TEST))[0] |
| evaluate_pair(gt_v, gt_t, PRED_VAL, PRED_TEST, model) |
| print(f"rows appended to {OUT_TSV}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
