| """Evaluation on the held-out TEST set (run once) + single-video prediction for the terminal. |
| Reports: top-1, macro-F1, per-class metrics, confusion matrix, confusable-pair recall, |
| calibration (ECE, before/after temperature scaling), accuracy-vs-coverage, latency, params/FLOPs. |
| """ |
| import argparse |
| import json |
| import logging |
| import os |
| import time |
|
|
| import numpy as np |
| import pandas as pd |
| import torch |
| from sklearn.metrics import classification_report, confusion_matrix, f1_score |
| from torch.utils.data import DataLoader |
|
|
| from airwriting_common import (CONFUSABLE, AirDataset, build_model, collect_logits, decide, ece, |
| fit_temperature, nll, preprocess, read_frames, softmax) |
|
|
|
|
| logging.getLogger("fvcore").setLevel(logging.ERROR) |
|
|
|
|
| def load_model(ckpt_path, device): |
| ck = torch.load(ckpt_path, map_location=device) |
| cfg = ck["config"] |
| model = build_model(len(cfg["classes"]), cfg["depth"], cfg["frames"], cfg["size"]).to(device) |
| model.load_state_dict(ck["model"]) |
| return model.eval(), cfg |
|
|
|
|
| def pair_report(cm, names): |
| idx, rows = {n: i for i, n in enumerate(names)}, [] |
| for a, b in CONFUSABLE: |
| ia, ib = idx[a], idx[b] |
| na, nb = cm[ia].sum(), cm[ib].sum() |
| if na == 0 or nb == 0: |
| continue |
| rows.append(dict(pair=f"{a}/{b}", recall_a=float(cm[ia, ia] / na), recall_b=float(cm[ib, ib] / nb), |
| a_as_b=float(cm[ia, ib] / na), b_as_a=float(cm[ib, ia] / nb), |
| pair_error=float((cm[ia, ib] + cm[ib, ia]) / (na + nb)))) |
| return rows |
|
|
|
|
| def latency(model, ds, device, cfg, n=50): |
| x = torch.randn(1, 3, cfg["frames"], cfg["size"], cfg["size"], device=device) |
| sync = torch.cuda.synchronize if device.type == "cuda" else (lambda: None) |
| with torch.no_grad(): |
| for _ in range(5): |
| model(x) |
| sync() |
| m = [] |
| for _ in range(n): |
| t = time.perf_counter(); model(x); sync(); m.append((time.perf_counter() - t) * 1000) |
| e = [] |
| for i in range(min(n, len(ds))): |
| t = time.perf_counter(); v, _ = ds[i]; model(v.unsqueeze(0).to(device)); sync() |
| e.append((time.perf_counter() - t) * 1000) |
| q = lambda v: dict(mean=float(np.mean(v)), p50=float(np.percentile(v, 50)), p95=float(np.percentile(v, 95))) |
| out = dict(model_only_ms=q(m), end_to_end_ms=q(e), params_millions=sum(p.numel() for p in model.parameters()) / 1e6) |
| try: |
| from fvcore.nn import FlopCountAnalysis |
| out["gflops"] = float(FlopCountAnalysis(model, x).total() / 1e9) |
| except Exception: |
| out["gflops"] = None |
| return out |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--checkpoint", required=True) |
| ap.add_argument("--test-csv") |
| ap.add_argument("--val-csv", help="used ONLY to fit the calibration temperature") |
| ap.add_argument("--video-dir") |
| ap.add_argument("--out-dir", default="eval") |
| ap.add_argument("--batch-size", type=int, default=4) |
| ap.add_argument("--num-workers", type=int, default=4) |
| ap.add_argument("--latency-samples", type=int, default=50) |
| ap.add_argument("--max-samples", type=int, default=None) |
| ap.add_argument("--predict", help="path to ONE video: prints ACCEPT / RETRY / REJECT") |
| ap.add_argument("--conf-thr", type=float, default=0.80) |
| ap.add_argument("--margin", type=float, default=0.20) |
| a = ap.parse_args() |
|
|
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") |
| model, cfg = load_model(a.checkpoint, device) |
| names, sep = cfg["classes"], cfg["separate_contrast"] |
|
|
| if a.predict: |
| x = preprocess(read_frames(a.predict, cfg["frames"], False), cfg["size"], False).unsqueeze(0) |
| with torch.no_grad(): |
| p = softmax(model(x.to(device)).cpu().numpy())[0] |
| status, ch, conf = decide(p, names, a.conf_thr, a.margin) |
| print(json.dumps(dict(decision=status, character=ch, confidence=round(conf, 4)))) |
| return |
|
|
| os.makedirs(a.out_dir, exist_ok=True) |
| kw = dict(num_workers=a.num_workers, pin_memory=device.type == "cuda") |
| te = AirDataset(a.test_csv, a.video_dir, cfg["frames"], cfg["size"], False, sep, "raise", a.max_samples) |
| logits, y = collect_logits(model, DataLoader(te, batch_size=a.batch_size, **kw), device, device.type == "cuda") |
| probs, pred = softmax(logits), logits.argmax(1) |
| present = sorted(set(y.tolist())) |
| res = dict(n_test=len(y), top1=float((pred == y).mean()), |
| macro_f1=float(f1_score(y, pred, labels=present, average="macro", zero_division=0)), |
| ece_raw=ece(probs, y), nll_raw=nll(probs, y)) |
|
|
| if a.val_csv: |
| va = AirDataset(a.val_csv, a.video_dir, cfg["frames"], cfg["size"], False, sep, "raise", a.max_samples) |
| vlog, vy = collect_logits(model, DataLoader(va, batch_size=a.batch_size, **kw), device, device.type == "cuda") |
| T = fit_temperature(vlog, vy) |
| pc = softmax(logits, T) |
| res.update(temperature=T, ece_calibrated=ece(pc, y), nll_calibrated=nll(pc, y)) |
| probs = pc |
|
|
| cm = confusion_matrix(y, pred, labels=range(len(names))) |
| pd.DataFrame(cm, index=names, columns=names).to_csv(os.path.join(a.out_dir, "confusion_matrix.csv")) |
| rep = classification_report(y, pred, labels=present, target_names=[names[i] for i in present], |
| output_dict=True, zero_division=0) |
| pd.DataFrame(rep).T.to_csv(os.path.join(a.out_dir, "per_class.csv")) |
| pd.DataFrame(dict(filename=te.files, true=[names[i] for i in y], pred=[names[i] for i in pred], |
| confidence=probs.max(1))).to_csv(os.path.join(a.out_dir, "predictions.csv"), index=False) |
| res["confusable_pairs"] = pair_report(cm, names) |
|
|
| conf = probs.max(1) |
| res["accuracy_vs_coverage"] = [dict(threshold=t, coverage=float((conf >= t).mean()), |
| accuracy_on_accepted=float((pred[conf >= t] == y[conf >= t]).mean()) |
| if (conf >= t).any() else None) |
| for t in [0.5, 0.7, 0.8, 0.9, 0.95]] |
| res["terminal_rule"] = {} |
| dec = [decide(p, names, a.conf_thr, a.margin)[0] for p in probs] |
| acc_mask = np.array([d == "ACCEPT" for d in dec]) |
| res["terminal_rule"] = dict(accept_rate=float(acc_mask.mean()), |
| error_when_accepted=float((pred[acc_mask] != y[acc_mask]).mean()) if acc_mask.any() else None) |
| res["latency"] = latency(model, te, device, cfg, a.latency_samples) |
|
|
| try: |
| import matplotlib; matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
| norm = cm / np.maximum(cm.sum(1, keepdims=True), 1) |
| fig, ax = plt.subplots(figsize=(12, 10)) |
| ax.imshow(norm, cmap="Blues"); ax.set_xticks(range(len(names))); ax.set_yticks(range(len(names))) |
| ax.set_xticklabels(names, rotation=90, fontsize=7); ax.set_yticklabels(names, fontsize=7) |
| ax.set_xlabel("predicted"); ax.set_ylabel("true"); ax.set_title("Confusion matrix (row-normalised)") |
| fig.savefig(os.path.join(a.out_dir, "confusion_matrix.png"), dpi=130, bbox_inches="tight") |
| except Exception as e: |
| print("plot skipped:", e) |
|
|
| json.dump(res, open(os.path.join(a.out_dir, "metrics.json"), "w"), indent=2) |
| print(json.dumps({k: v for k, v in res.items() if k not in ("confusable_pairs", "accuracy_vs_coverage")}, indent=2)) |
| print("\nConfusable pairs:") |
| for r in res["confusable_pairs"]: |
| print({k: (round(v, 3) if isinstance(v, float) else v) for k, v in r.items()}) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
