| """Metrics engine — orchestrates all metric modules and produces a unified report. |
| |
| Two primary evaluation tracks: |
| |
| * **Localisation** — how well the VLM draws bounding boxes and labels them. |
| * **Classification** — how well the VLM identifies which violations are present. |
| |
| Additional metric modules (scalar, agreement) are imported dynamically and |
| run when available. |
| """ |
|
|
| from utils.result_paths import result_path |
| from utils.result_paths import relocated_result |
|
|
| import hashlib |
| import logging |
| from datetime import datetime, timezone |
| from pathlib import Path |
|
|
| from schemas.ground_truth import GoldDataset |
| from schemas.inference import InferenceResponse |
| from utils.io import read_jsonl, write_json |
|
|
| logger = logging.getLogger(__name__) |
|
|
| PROJECT_ROOT = Path(__file__).resolve().parent.parent |
| INFERENCE_RESULTS_DIR = PROJECT_ROOT / "results" / "inference" |
| REPORTS_DIR = PROJECT_ROOT / "results" / "metrics" |
|
|
| DEFAULT_MANIFEST_PATH = ( |
| PROJECT_ROOT / "data" / "full_dataset" / "cohorts" |
| / "one_pass_balanced_up_to_350.gold.json" |
| ) |
| LOCALISATION_IOU_THRESHOLDS = (0.30, 0.40, 0.50) |
|
|
|
|
| |
| |
| |
|
|
|
|
| def _empty_localisation() -> dict: |
| return { |
| "per_violation": {}, |
| "iou_threshold": 0.5, |
| "n_images": 0, |
| "n_predictions": 0, |
| "n_gt_boxes": 0, |
| } |
|
|
|
|
| def _empty_classification() -> dict: |
| return { |
| "per_violation": {}, |
| "n_images": 0, |
| } |
|
|
| |
| |
| |
|
|
| def _try_import_metric(module_name: str, func_name: str): |
| """Try to import a metric function; return None if the module is missing.""" |
| try: |
| import importlib |
| mod = importlib.import_module(f"metrics.{module_name}") |
| return getattr(mod, func_name) |
| except (ImportError, AttributeError): |
| logger.warning("Metric module '%s' not available — skipping", module_name) |
| return None |
|
|
|
|
| |
| |
| |
|
|
|
|
| def _resolve_results_file(target_path: Path) -> Path: |
| """Resolve *target_path* to the single results file it names. |
| |
| A directory is accepted only when it holds exactly one run. Silently |
| scoring the alphabetically last of several is the worst possible failure |
| here: it produces a complete, plausible report for a run nobody asked |
| about, under a `run_id` that quietly disagrees with the command that was |
| typed. |
| """ |
| if not target_path.is_dir(): |
| if not target_path.exists(): |
| raise FileNotFoundError(f"Results file not found: {target_path}") |
| return target_path |
|
|
| runs = sorted( |
| p for p in target_path.rglob("*.jsonl") |
| if not p.name.endswith((".errors.jsonl", ".attempts.jsonl")) |
| ) |
| if not runs: |
| raise FileNotFoundError(f"No JSONL results found in directory {target_path}") |
| if len(runs) > 1: |
| shown = [p.name for p in runs[:10]] |
| if len(runs) > len(shown): |
| shown.append(f"... and {len(runs) - len(shown)} more") |
| raise ValueError( |
| f"{target_path} holds {len(runs)} result files — name the one to " |
| "score:\n " + "\n ".join(shown) |
| ) |
| return runs[0] |
|
|
|
|
| def run_metrics( |
| results_path: Path | str | None = None, |
| manifest_path: Path | str | None = None, |
| iou_threshold: float = 0.50, |
| image_ids: set[str] | None = None, |
| report_suffix: str = "met", |
| ) -> dict: |
| """Compute all available metrics for a given inference run. |
| |
| Args: |
| results_path: Path to the inference results JSONL file (e.g. |
| ``results/inference/YYMMDD_NN_modelname.jsonl``) or a filename |
| relative to ``results/inference/``. A directory is accepted only |
| when it contains exactly one run. Defaults to |
| ``results/inference/``. |
| manifest_path: Path to the benchmark ground-truth JSON. |
| iou_threshold: Minimum IoU for a localisation prediction to count as |
| a true positive (default 0.50). |
| |
| Returns: |
| Unified metrics report dict. |
| |
| Raises: |
| FileNotFoundError: If the results file or directory holds no run. |
| ValueError: If a directory holds more than one run, so which to score |
| is ambiguous. |
| """ |
| if results_path is None: |
| target_path = INFERENCE_RESULTS_DIR |
| else: |
| target_path = relocated_result(results_path) |
| if not target_path.exists() and Path(results_path).name == str(results_path): |
| target_path = result_path(INFERENCE_RESULTS_DIR, str(results_path)) |
|
|
| target_path = _resolve_results_file(target_path) |
|
|
| |
| predictions = read_jsonl(target_path, InferenceResponse) |
| manifest_p = Path(manifest_path) if manifest_path else DEFAULT_MANIFEST_PATH |
| dataset = GoldDataset.from_file(manifest_p) |
| try: |
| ground_truth_file = str(manifest_p.resolve().relative_to(PROJECT_ROOT)) |
| except ValueError: |
| ground_truth_file = str(manifest_p) |
| ground_truths = dataset.records |
| gt_ids = {record.image_id for record in ground_truths if not record.gold.reported} |
| rows_by_id = {prediction.image_id: prediction for prediction in predictions} |
| all_valid_predictions = [ |
| rows_by_id[image_id] |
| for image_id in gt_ids |
| if image_id in rows_by_id and rows_by_id[image_id].parsed_cleanly |
| ] |
| valid_predictions = all_valid_predictions |
| if image_ids is not None: |
| valid_predictions = [ |
| prediction |
| for prediction in all_valid_predictions |
| if prediction.image_id in image_ids |
| ] |
| invalid = sorted( |
| image_id |
| for image_id in gt_ids |
| if image_id in rows_by_id and not rows_by_id[image_id].parsed_cleanly |
| ) |
| missing = sorted(gt_ids - rows_by_id.keys()) |
|
|
| logger.info( |
| "Loaded %d predictions and %d ground-truth images from %s", |
| len(predictions), |
| len(ground_truths), |
| target_path.name, |
| ) |
|
|
| stem = target_path.stem |
| |
| |
| _parts = stem.split("_", 2) |
| if len(_parts) == 3 and _parts[1].isdigit(): |
| model_name = _parts[2] |
| elif len(_parts) >= 2: |
| model_name = "_".join(_parts[1:]) |
| else: |
| model_name = stem |
|
|
| |
| compute_localisation = _try_import_metric("localisation", "compute_localisation_metrics") |
| compute_classification = _try_import_metric("classification", "compute_classification_metrics") |
|
|
| localisation_thresholds = tuple(sorted(set((*LOCALISATION_IOU_THRESHOLDS, iou_threshold)))) |
| localisation_sensitivity = ( |
| { |
| f"{threshold:.2f}": compute_localisation( |
| valid_predictions, ground_truths, iou_threshold=threshold |
| ) |
| for threshold in localisation_thresholds |
| } |
| if compute_localisation else {} |
| ) |
| localisation = localisation_sensitivity.get(f"{iou_threshold:.2f}", _empty_localisation()) |
| classification = ( |
| compute_classification( |
| valid_predictions, ground_truths, |
| ) |
| if compute_classification else _empty_classification() |
| ) |
|
|
| report = { |
| "run_id": stem, |
| "model_name": model_name, |
| "computed_at": datetime.now(timezone.utc).isoformat(), |
| "n_predictions": len(predictions), |
| "n_ground_truth": len(ground_truths), |
| "ground_truth_file": ground_truth_file, |
| "ground_truth_sha256": hashlib.sha256(manifest_p.read_bytes()).hexdigest(), |
| "coverage": { |
| "expected": len(gt_ids), "valid": len(all_valid_predictions), |
| "invalid": len(invalid), "missing": len(missing), |
| "invalid_image_ids": invalid, "missing_image_ids": missing, |
| }, |
| "evaluation_scope": { |
| "requested_image_ids": ( |
| len(image_ids) if image_ids is not None else len(gt_ids) |
| ), |
| "evaluated_valid": len(valid_predictions), |
| }, |
| "localisation": localisation, |
| "localisation_sensitivity": localisation_sensitivity, |
| "classification": classification, |
| } |
|
|
| |
| |
| |
| report_path = result_path(REPORTS_DIR, f"{stem}_{report_suffix}.json") |
| report_path.parent.mkdir(parents=True, exist_ok=True) |
| write_json(report_path, report) |
|
|
| logger.info("Metrics saved to %s", report_path) |
| return report |
|
|
