| """Shared F-beta score primitives used by all metric tracks. |
| |
| Provides the core building blocks for computing F-beta scores (default β=2) |
| from raw TP/FP/FN counts. Both the localisation and classification tracks |
| use these helpers so the formula is defined in exactly one place. |
| """ |
|
|
| from __future__ import annotations |
|
|
| from dataclasses import dataclass |
|
|
|
|
| @dataclass |
| class ViolationCounts: |
| """Mutable accumulator for TP / FP / FN counts of a single violation.""" |
|
|
| tp: int = 0 |
| fp: int = 0 |
| fn: int = 0 |
|
|
|
|
| def compute_f_beta(tp: int, fp: int, fn: int, beta: float = 2.0) -> float: |
| """Return the F-beta score from raw counts. |
| |
| The general formula is:: |
| |
| F_β = (1 + β²) · (precision · recall) / (β² · precision + recall) |
| |
| Returns ``0.0`` when both precision and recall are zero (no predictions |
| and no ground-truth positives). |
| """ |
| if tp == 0: |
| return 0.0 |
| beta_sq = beta ** 2 |
| precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0 |
| recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0 |
| if precision + recall == 0.0: |
| return 0.0 |
| return (1 + beta_sq) * (precision * recall) / (beta_sq * precision + recall) |
|
|
|
|
| def summarise_counts( |
| counts: dict[str, ViolationCounts], |
| beta: float = 2.0, |
| ) -> dict[str, dict]: |
| """Convert per-violation raw counts into a summary with F-beta, precision, and recall. |
| |
| Args: |
| counts: Mapping of violation id → ``ViolationCounts``. |
| beta: Beta parameter for the F-beta score (default 2). |
| |
| Returns: |
| Sorted dict keyed by violation id, each value containing:: |
| |
| {"f2": float, "precision": float, "recall": float, |
| "tp": int, "fp": int, "fn": int} |
| """ |
| summary: dict[str, dict] = {} |
| for violation_id, c in sorted(counts.items()): |
| precision = c.tp / (c.tp + c.fp) if (c.tp + c.fp) > 0 else 0.0 |
| recall = c.tp / (c.tp + c.fn) if (c.tp + c.fn) > 0 else 0.0 |
| summary[violation_id] = { |
| "f2": round(compute_f_beta(c.tp, c.fp, c.fn, beta=beta), 4), |
| "precision": round(precision, 4), |
| "recall": round(recall, 4), |
| "tp": c.tp, |
| "fp": c.fp, |
| "fn": c.fn, |
| } |
| return summary |
|
|
|
|
| def aggregate_summary(counts: dict[str, ViolationCounts], beta: float = 2.0) -> dict: |
| """Return micro and macro precision, recall, and F-beta.""" |
| values = list(counts.values()) |
| tp = sum(c.tp for c in values) |
| fp = sum(c.fp for c in values) |
| fn = sum(c.fn for c in values) |
| precision = tp / (tp + fp) if tp + fp else 0.0 |
| recall = tp / (tp + fn) if tp + fn else 0.0 |
| per_class = summarise_counts(counts, beta) |
| macro = { |
| key: round(sum(item[key] for item in per_class.values()) / len(per_class), 4) |
| if per_class else 0.0 |
| for key in ("f2", "precision", "recall") |
| } |
| return { |
| "micro": { |
| "f2": round(compute_f_beta(tp, fp, fn, beta), 4), |
| "precision": round(precision, 4), |
| "recall": round(recall, 4), |
| "tp": tp, |
| "fp": fp, |
| "fn": fn, |
| }, |
| "macro": macro, |
| } |
|
|
