| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import re |
| from collections import defaultdict |
| from pathlib import Path |
|
|
| import cv2 |
| import matplotlib.pyplot as plt |
| import numpy as np |
| import pandas as pd |
| from pycocotools import mask as mask_utils |
| from pycocotools.coco import COCO |
|
|
|
|
| FRAME_PATTERN = re.compile(r"S(?P<sequence>\d+)", re.IGNORECASE) |
| COVERAGE_REGIME_BINS = [-np.inf, 0.05, 0.15, np.inf] |
| COVERAGE_REGIME_LABELS = ["low (<=0.05)", "intermediate (0.05-0.15)", "high (>0.15)"] |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser( |
| description="Audit BubbleID-Flow holdout robustness from archived COCO predictions." |
| ) |
| parser.add_argument("--train-json", required=True) |
| parser.add_argument("--val-json", required=True) |
| parser.add_argument("--predictions-json", required=True) |
| parser.add_argument("--output-dir", required=True) |
| parser.add_argument("--bootstrap-samples", type=int, default=10000) |
| parser.add_argument("--seed", type=int, default=20260812) |
| parser.add_argument( |
| "--score-thresholds", default="0.05,0.10,0.20,0.30,0.40,0.50,0.70" |
| ) |
| parser.add_argument("--detection-caps", default="50,100,200,300") |
| args = parser.parse_args() |
|
|
| output_dir = Path(args.output_dir) |
| output_dir.mkdir(parents=True, exist_ok=True) |
| thresholds = [float(value) for value in args.score_thresholds.split(",")] |
| caps = [int(value) for value in args.detection_caps.split(",")] |
| if not thresholds or not caps or min(caps) <= 0: |
| raise ValueError("At least one score threshold and positive detection cap are required") |
|
|
| coco = COCO(args.val_json) |
| predictions = json.loads(Path(args.predictions_json).read_text(encoding="utf-8")) |
| predictions_by_image: dict[int, list[dict]] = defaultdict(list) |
| for prediction in predictions: |
| predictions_by_image[int(prediction["image_id"])].append(prediction) |
| for image_predictions in predictions_by_image.values(): |
| image_predictions.sort(key=lambda item: float(item["score"]), reverse=True) |
|
|
| rows_by_setting = [] |
| selected_rows = None |
| for threshold in thresholds: |
| for cap in caps: |
| rows = evaluate_setting(coco, predictions_by_image, threshold, cap) |
| summary = summarize_metrics(rows) |
| summary.update( |
| { |
| "score_threshold": threshold, |
| "detection_cap": cap, |
| "images_at_cap": int((rows["predicted_instances"] == cap).sum()), |
| } |
| ) |
| rows_by_setting.append(summary) |
| if np.isclose(threshold, 0.30) and cap == 300: |
| selected_rows = rows |
|
|
| if selected_rows is None: |
| raise ValueError("The required manuscript operating point (threshold 0.30, cap 300) is missing") |
|
|
| sensitivity = pd.DataFrame(rows_by_setting).sort_values( |
| ["detection_cap", "score_threshold"] |
| ) |
| sensitivity.to_csv(output_dir / "segmentation_operating_point_sensitivity.csv", index=False) |
|
|
| split_audit, split_summary = audit_split_similarity(args.train_json, args.val_json) |
| selected_rows = selected_rows.merge(split_audit, on=["image_id", "file_name"], how="left") |
| selected_rows.to_csv(output_dir / "segmentation_metrics_by_image.csv", index=False) |
|
|
| image_groups = build_coverage_group_manifest(coco, selected_rows) |
| image_groups.to_csv(output_dir / "segmentation_evaluation_image_groups.csv", index=False) |
|
|
| regime = summarize_by_regime(selected_rows) |
| regime.to_csv(output_dir / "segmentation_metrics_by_coverage_regime.csv", index=False) |
| bootstrap = bootstrap_intervals( |
| selected_rows, samples=args.bootstrap_samples, seed=args.seed |
| ) |
| operating_point = summarize_metrics(selected_rows) |
| robustness_summary = { |
| "operating_point": { |
| "score_threshold": 0.30, |
| "detection_cap": 300, |
| **operating_point, |
| }, |
| "bootstrap": { |
| "samples": args.bootstrap_samples, |
| "seed": args.seed, |
| "confidence_level": 0.95, |
| "interval_method": "image-level percentile bootstrap", |
| "metrics": bootstrap, |
| }, |
| "split_audit": split_summary, |
| "interpretation": { |
| "supported": "internal same-sequence reconstruction of projected vapor area", |
| "not_supported": "experiment-held-out generalization or individual-bubble statistics", |
| }, |
| } |
| (output_dir / "segmentation_robustness_summary.json").write_text( |
| json.dumps(robustness_summary, indent=2, sort_keys=True), encoding="utf-8" |
| ) |
| make_figure(selected_rows, sensitivity, regime, output_dir) |
| print(json.dumps(robustness_summary, indent=2, sort_keys=True)) |
|
|
|
|
| def evaluate_setting( |
| coco: COCO, |
| predictions_by_image: dict[int, list[dict]], |
| threshold: float, |
| cap: int, |
| ) -> pd.DataFrame: |
| rows = [] |
| for image_id in sorted(coco.getImgIds()): |
| record = coco.loadImgs([image_id])[0] |
| height, width = int(record["height"]), int(record["width"]) |
| ground_truth = np.zeros((height, width), dtype=bool) |
| for annotation in coco.loadAnns(coco.getAnnIds(imgIds=[image_id])): |
| ground_truth |= coco.annToMask(annotation).astype(bool) |
|
|
| retained = [ |
| item |
| for item in predictions_by_image.get(image_id, []) |
| if float(item["score"]) >= threshold |
| ][:cap] |
| predicted = np.zeros((height, width), dtype=bool) |
| for item in retained: |
| predicted |= mask_utils.decode(item["segmentation"]).astype(bool) |
|
|
| intersection = int(np.count_nonzero(ground_truth & predicted)) |
| union = int(np.count_nonzero(ground_truth | predicted)) |
| ground_truth_area = int(np.count_nonzero(ground_truth)) |
| predicted_area = int(np.count_nonzero(predicted)) |
| pixel_count = ground_truth.size |
| denominator = ground_truth_area + predicted_area |
| rows.append( |
| { |
| "image_id": image_id, |
| "file_name": Path(record["file_name"]).name, |
| "ground_truth_vapor_area_fraction": ground_truth_area / pixel_count, |
| "predicted_vapor_area_fraction": predicted_area / pixel_count, |
| "signed_area_fraction_error": (predicted_area - ground_truth_area) |
| / pixel_count, |
| "absolute_area_fraction_error": abs(predicted_area - ground_truth_area) |
| / pixel_count, |
| "union_mask_iou": intersection / union if union else 1.0, |
| "union_mask_dice": 2 * intersection / denominator if denominator else 1.0, |
| "predicted_instances": len(retained), |
| } |
| ) |
| return pd.DataFrame(rows) |
|
|
|
|
| def summarize_metrics(frame: pd.DataFrame) -> dict[str, float | int]: |
| return { |
| "images": int(len(frame)), |
| "mean_union_mask_iou": float(frame["union_mask_iou"].mean()), |
| "median_union_mask_iou": float(frame["union_mask_iou"].median()), |
| "mean_union_mask_dice": float(frame["union_mask_dice"].mean()), |
| "mean_absolute_area_fraction_error": float( |
| frame["absolute_area_fraction_error"].mean() |
| ), |
| "mean_signed_area_fraction_error": float( |
| frame["signed_area_fraction_error"].mean() |
| ), |
| "max_absolute_area_fraction_error": float( |
| frame["absolute_area_fraction_error"].max() |
| ), |
| "max_predicted_instances": int(frame["predicted_instances"].max()), |
| } |
|
|
|
|
| def bootstrap_intervals( |
| frame: pd.DataFrame, *, samples: int, seed: int |
| ) -> dict[str, dict[str, float]]: |
| if samples <= 0: |
| raise ValueError("bootstrap-samples must be positive") |
| metric_columns = { |
| "mean_union_mask_iou": "union_mask_iou", |
| "mean_union_mask_dice": "union_mask_dice", |
| "mean_absolute_area_fraction_error": "absolute_area_fraction_error", |
| "mean_signed_area_fraction_error": "signed_area_fraction_error", |
| } |
| rng = np.random.default_rng(seed) |
| indices = rng.integers(0, len(frame), size=(samples, len(frame))) |
| output = {} |
| for name, column in metric_columns.items(): |
| values = frame[column].to_numpy(dtype=float) |
| samples_mean = values[indices].mean(axis=1) |
| low, high = np.quantile(samples_mean, [0.025, 0.975]) |
| output[name] = { |
| "estimate": float(values.mean()), |
| "ci95_low": float(low), |
| "ci95_high": float(high), |
| } |
| return output |
|
|
|
|
| def summarize_by_regime(frame: pd.DataFrame) -> pd.DataFrame: |
| grouped = frame.assign( |
| coverage_regime=coverage_regimes(frame["ground_truth_vapor_area_fraction"]) |
| ).groupby("coverage_regime", observed=True) |
| rows = [] |
| for regime, group in grouped: |
| rows.append({"coverage_regime": str(regime), **summarize_metrics(group)}) |
| return pd.DataFrame(rows) |
|
|
|
|
| def coverage_regimes(values: pd.Series) -> pd.Categorical: |
| return pd.cut( |
| values, |
| bins=COVERAGE_REGIME_BINS, |
| labels=COVERAGE_REGIME_LABELS, |
| ) |
|
|
|
|
| def build_coverage_group_manifest(coco: COCO, frame: pd.DataFrame) -> pd.DataFrame: |
| """Attach original COCO paths and manual-coverage groups to Fig. 5 inputs.""" |
| records = pd.DataFrame( |
| { |
| "image_id": [image_id for image_id in sorted(coco.getImgIds())], |
| "coco_image_path": [ |
| ( |
| Path(Path(coco.loadImgs([image_id])[0]["file_name"]).parent.name) |
| / Path(coco.loadImgs([image_id])[0]["file_name"]).name |
| ).as_posix() |
| for image_id in sorted(coco.getImgIds()) |
| ], |
| } |
| ) |
| columns = [ |
| "image_id", |
| "file_name", |
| "ground_truth_vapor_area_fraction", |
| "predicted_vapor_area_fraction", |
| "union_mask_iou", |
| "union_mask_dice", |
| "absolute_area_fraction_error", |
| "predicted_instances", |
| "source_sequence_index", |
| "same_nominal_frame_in_training", |
| "nearest_training_frame_distance", |
| "most_similar_training_file", |
| ] |
| manifest = frame[columns].merge(records, on="image_id", how="left", validate="one_to_one") |
| manifest.insert( |
| 2, |
| "coverage_regime", |
| coverage_regimes(manifest["ground_truth_vapor_area_fraction"]), |
| ) |
| return manifest.sort_values( |
| ["coverage_regime", "ground_truth_vapor_area_fraction", "file_name"], |
| kind="stable", |
| ).reset_index(drop=True) |
|
|
|
|
| def audit_split_similarity(train_json: str, val_json: str) -> tuple[pd.DataFrame, dict]: |
| train_records = json.loads(Path(train_json).read_text(encoding="utf-8"))["images"] |
| val_records = json.loads(Path(val_json).read_text(encoding="utf-8"))["images"] |
| train_images = [(record, load_gray(record["file_name"])) for record in train_records] |
| train_sequence = [frame_sequence(record["file_name"]) for record, _ in train_images] |
| rows = [] |
| for record in val_records: |
| val_image = load_gray(record["file_name"]) |
| val_sequence = frame_sequence(record["file_name"]) |
| best = None |
| for (train_record, train_image), sequence in zip(train_images, train_sequence): |
| correlation, normalized_mae = image_similarity(val_image, train_image) |
| candidate = (correlation, -normalized_mae, train_record, sequence, normalized_mae) |
| if best is None or candidate[:2] > best[:2]: |
| best = candidate |
| assert best is not None |
| correlation, _, nearest_record, nearest_sequence, normalized_mae = best |
| same_nominal = any(sequence == val_sequence for sequence in train_sequence) |
| min_distance = min(abs(sequence - val_sequence) for sequence in train_sequence) |
| rows.append( |
| { |
| "image_id": int(record["id"]), |
| "file_name": Path(record["file_name"]).name, |
| "source_sequence_index": val_sequence, |
| "same_nominal_frame_in_training": bool(same_nominal), |
| "nearest_training_frame_distance": int(min_distance), |
| "most_similar_training_file": Path(nearest_record["file_name"]).name, |
| "nearest_training_image_correlation": float(correlation), |
| "nearest_training_normalized_mae": float(normalized_mae), |
| } |
| ) |
| frame = pd.DataFrame(rows) |
| summary = { |
| "train_images": len(train_records), |
| "holdout_images": len(val_records), |
| "distinct_camera_prefixes": 1, |
| "holdout_with_same_nominal_frame_in_training": int( |
| frame["same_nominal_frame_in_training"].sum() |
| ), |
| "holdout_with_training_frame_within_one_index": int( |
| (frame["nearest_training_frame_distance"] <= 1).sum() |
| ), |
| "median_nearest_training_frame_distance": float( |
| frame["nearest_training_frame_distance"].median() |
| ), |
| "median_nearest_training_image_correlation": float( |
| frame["nearest_training_image_correlation"].median() |
| ), |
| "split_classification": "same-sequence internal holdout", |
| } |
| return frame, summary |
|
|
|
|
| def frame_sequence(path: str) -> int: |
| match = FRAME_PATTERN.search(Path(path).stem) |
| if not match: |
| raise ValueError(f"Could not parse source sequence from {path}") |
| return int(match.group("sequence")) |
|
|
|
|
| def load_gray(path: str) -> np.ndarray: |
| image = cv2.imread(str(path), cv2.IMREAD_GRAYSCALE) |
| if image is None: |
| raise ValueError(f"Could not read image {path}") |
| return cv2.resize(image, (256, 32), interpolation=cv2.INTER_AREA).astype(np.float32) |
|
|
|
|
| def image_similarity(first: np.ndarray, second: np.ndarray) -> tuple[float, float]: |
| first_flat = first.ravel() |
| second_flat = second.ravel() |
| if np.std(first_flat) == 0 or np.std(second_flat) == 0: |
| correlation = float(first_flat.mean() == second_flat.mean()) |
| else: |
| correlation = float(np.corrcoef(first_flat, second_flat)[0, 1]) |
| normalized_mae = float(np.mean(np.abs(first - second)) / 255.0) |
| return correlation, normalized_mae |
|
|
|
|
| def make_figure( |
| frame: pd.DataFrame, |
| sensitivity: pd.DataFrame, |
| regime: pd.DataFrame, |
| output_dir: Path, |
| ) -> None: |
| plt.rcParams.update( |
| { |
| "font.family": "Arial", |
| "font.size": 10, |
| "axes.labelsize": 10, |
| "xtick.labelsize": 9, |
| "ytick.labelsize": 9, |
| "legend.fontsize": 9, |
| "axes.linewidth": 0.8, |
| "mathtext.fontset": "custom", |
| "mathtext.rm": "Arial", |
| "mathtext.it": "Arial:italic", |
| "mathtext.bf": "Arial:bold", |
| "savefig.dpi": 300, |
| } |
| ) |
| fig, axes = plt.subplots(2, 2, figsize=(7.2, 5.6), constrained_layout=True) |
| blue, orange, green = "#0072B2", "#D55E00", "#009E73" |
|
|
| ax = axes[0, 0] |
| x = frame["ground_truth_vapor_area_fraction"] |
| y = frame["predicted_vapor_area_fraction"] |
| limit = max(float(x.max()), float(y.max())) * 1.08 |
| ax.scatter(x, y, color=blue, edgecolor="white", linewidth=0.5, s=28) |
| ax.plot([0, limit], [0, limit], color="black", linewidth=1, linestyle="--") |
| ax.set(xlabel="Manual projected vapor coverage", ylabel="Predicted projected vapor coverage", xlim=(0, limit), ylim=(0, limit)) |
|
|
| ax = axes[0, 1] |
| ax.scatter(x, frame["union_mask_iou"], color=green, edgecolor="white", linewidth=0.5, s=28) |
| ax.set(xlabel="Manual projected vapor coverage", ylabel="Union-mask IoU", ylim=(0, 1)) |
|
|
| cap300 = sensitivity[sensitivity["detection_cap"] == 300] |
| ax = axes[1, 0] |
| ax.plot(cap300["score_threshold"], cap300["mean_union_mask_iou"], marker="o", color=blue, linestyle="--", label="Mean IoU") |
| ax.plot(cap300["score_threshold"], cap300["mean_union_mask_dice"], marker="s", color=green, linestyle="--", label="Mean Dice") |
| ax.axvline(0.30, color="black", linestyle="--", linewidth=0.9) |
| ax.set(xlabel="Score threshold", ylabel="Overlap metric", ylim=(0, 1)) |
| ax.legend(frameon=False, loc="lower right") |
|
|
| ax = axes[1, 1] |
| ax.plot(cap300["score_threshold"], cap300["mean_absolute_area_fraction_error"], marker="o", color=orange, linestyle="--", label="MAE") |
| ax.plot(cap300["score_threshold"], np.abs(cap300["mean_signed_area_fraction_error"]), marker="s", color=blue, linestyle="--", label="Absolute bias") |
| ax.axvline(0.30, color="black", linestyle="--", linewidth=0.9) |
| ax.set(xlabel="Score threshold", ylabel="Projected-area-fraction error", ylim=(0, None)) |
| ax.legend( |
| frameon=False, |
| loc="upper center", |
| bbox_to_anchor=(0.5, -0.28), |
| ncol=2, |
| ) |
|
|
| for label, ax in zip("abcd", axes.ravel()): |
| ax.text(0.0, 1.04, f"({label})", transform=ax.transAxes, va="bottom", clip_on=False) |
| ax.tick_params(direction="in", top=True, right=True) |
| ax.grid(False) |
|
|
| for suffix in ("pdf", "png"): |
| fig.savefig(output_dir / f"Figure_5_segmentation_robustness.{suffix}", bbox_inches="tight") |
| plt.close(fig) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
