#!/usr/bin/env python3 """Create four standalone UpSet plots from plot_difficulty.py inputs.""" import argparse import sys from collections import Counter, defaultdict from pathlib import Path import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt from matplotlib.colors import LinearSegmentedColormap, Normalize, TwoSlopeNorm import numpy as np import pandas as pd from plot_difficulty import (COLORS, PAPER_DIVERGING, PAPER_SEQUENTIAL, load_annotations, load_scores) plt.rcParams.update({ "font.family": "serif", "font.serif": ["Times New Roman", "DejaVu Serif"], "font.size": 10, "axes.linewidth": 0.7, "pdf.fonttype": 42, }) BAR_SINGLE = PAPER_SEQUENTIAL(0.5) def coco_files(entries, pattern): found = [] for item in entries: path = Path(item) if path.is_dir(): found.extend(path.rglob(pattern)) elif path.is_file(): found.append(path) return sorted(set(str(path) for path in found)) def exact_groups(memberships): groups = defaultdict(list) for key, types in memberships.items(): membership = tuple(sorted(types)) if membership: groups[membership].append(key) return groups def choose(groups, top_n, min_count, all_types=None, ensure_all_types=False): candidates = [(membership, len(keys)) for membership, keys in groups.items() if len(keys) >= min_count] candidates.sort(key=lambda item: (-item[1], len(item[0]), item[0])) chosen = [membership for membership, _ in candidates[:top_n]] if not ensure_all_types or not all_types: chosen.sort(key=lambda m: (-len(groups[m]), len(m), m)) return chosen covered = {name for membership in chosen for name in membership} missing = [t for t in all_types if t not in covered] if not missing: chosen.sort(key=lambda m: (-len(groups[m]), len(m), m)) return chosen ranked = sorted(groups.items(), key=lambda item: (-len(item[1]), len(item[0]), item[0])) for name in missing: if name in {n for c in chosen for n in c}: continue for membership, keys in ranked: if name in membership and membership not in chosen: chosen.append(membership) print(f" added '{name}' via {' + '.join(membership)} " f"({len(keys)} images)") break still = [t for t in all_types if t not in {n for c in chosen for n in c}] if still: print(f" ! no combination found for: {', '.join(still)}", file=sys.stderr) chosen.sort(key=lambda m: (-len(groups[m]), len(m), m)) return chosen def stats(combinations, groups, scores=None): rows = [] for membership in combinations: keys = groups[membership] row = {"membership": membership, "dataset_n": len(keys)} if scores is not None: values = np.asarray([scores[key] for key in keys if key in scores], float) row.update( n=int(values.size), mean=float(values.mean()) if values.size else np.nan, std=float(values.std(ddof=1)) if values.size > 1 else 0.0, ) rows.append(row) return rows def short(name): return name def save_values(path, rows): output = [] for rank, row in enumerate(rows, 1): record = { "rank": rank, "combination": " + ".join(row["membership"]), "n_types": len(row["membership"]), "dataset_n": row["dataset_n"], } for key in ("n", "mean", "std"): if key in row: record[key] = row[key] output.append(record) pd.DataFrame(output).to_csv(path, index=False) def draw(rows, categories, stem, value_label=None, limits=None, difference=False): n_combinations = len(rows) n_categories = len(categories) x = np.arange(n_combinations) counts = np.asarray([row["dataset_n"] for row in rows]) width = max(8.5, 0.46 * n_combinations + 3.4) fig = plt.figure(figsize=(width, 6.9)) grid = fig.add_gridspec(2, 3, width_ratios=[1.3, 5.0, 0.22], height_ratios=[2.3, 2.2], hspace=0.05, wspace=0.04) ax_sets = fig.add_subplot(grid[1, 0]) ax_bars = fig.add_subplot(grid[0, 1]) ax_dots = fig.add_subplot(grid[1, 1], sharex=ax_bars) ax_cbar = fig.add_subplot(grid[0, 2]) if value_label is None: colors = [BAR_SINGLE] * n_combinations norm = None cmap = None else: values = np.asarray([row["mean"] for row in rows], float) finite = values[np.isfinite(values)] if not finite.size: raise ValueError(f"No finite performance values for {stem}") if difference: bound = max(float(np.abs(finite).max()), 1e-9) norm = TwoSlopeNorm(vmin=-bound, vcenter=0, vmax=bound) cmap = PAPER_DIVERGING else: low, high = limits if limits else (float(finite.min()), float(finite.max())) if np.isclose(low, high): low, high = low - 0.01, high + 0.01 norm = Normalize(low, high) cmap = PAPER_SEQUENTIAL colors = [cmap(norm(value)) if np.isfinite(value) else "white" for value in values] bars = ax_bars.bar(x, counts, width=0.72, color=colors, edgecolor="black", linewidth=0.6) for index, (bar, row) in enumerate(zip(bars, rows)): ax_bars.text(index, bar.get_height(), str(row["dataset_n"]), ha="center", va="bottom", fontsize=7.5, color="black") if value_label is not None: text = (f"{row['mean']:.2f}\nn={row['n']}" if np.isfinite(row["mean"]) else "NA") ax_bars.text(index, max(bar.get_height() * 0.50, 0.25), text, ha="center", va="center", fontsize=6.4, color="black") ax_bars.set_ylabel("Number of Images per Combination", fontsize=11) ax_bars.tick_params(axis="x", bottom=False, labelbottom=False) ax_bars.tick_params(labelsize=9) ax_bars.spines[["top", "right"]].set_visible(False) ax_bars.set_ylim(0, max(1, counts.max() * 1.18)) if norm is not None: mapper = plt.cm.ScalarMappable(norm=norm, cmap=cmap) mapper.set_array([]) colorbar = fig.colorbar(mapper, cax=ax_cbar) colorbar.set_label(value_label, fontsize=10) colorbar.ax.tick_params(labelsize=8.5) else: ax_cbar.axis("off") category_index = {name: index for index, name in enumerate(categories)} for column, row in enumerate(rows): selected = sorted(category_index[name] for name in row["membership"]) ax_dots.scatter(np.full(n_categories, column), np.arange(n_categories), s=13, color="0.87", zorder=1) ax_dots.plot([column, column], [min(selected), max(selected)], color="black", lw=1.1, zorder=2) ax_dots.scatter(np.full(len(selected), column), selected, s=26, color="black", zorder=3) ax_dots.set_yticks(np.arange(n_categories)) ax_dots.set_yticklabels([]) ax_dots.invert_yaxis() ax_dots.set_xticks(x) ax_dots.set_xticklabels([str(i + 1) for i in range(n_combinations)], fontsize=8.5) ax_dots.set_xlabel("Anomaly Type Combination, Ordered by Frequency", fontsize=11) ax_dots.tick_params(axis="y", length=0) ax_dots.grid(axis="y", color="0.9", lw=0.6) ax_dots.spines[["top", "right", "left"]].set_visible(False) set_sizes = Counter() for row in rows: for name in row["membership"]: set_sizes[name] += row["dataset_n"] sizes = np.asarray([set_sizes[name] for name in categories]) y = np.arange(n_categories) ax_sets.barh(y, sizes, height=0.55, color=BAR_SINGLE, edgecolor="black", linewidth=0.6) ax_sets.invert_yaxis() ax_sets.invert_xaxis() ax_sets.set_yticks(y) ax_sets.set_yticklabels([short(name) for name in categories], fontsize=9.5) ax_sets.tick_params(axis="y", length=0, pad=3) ax_sets.set_xlabel("Number of Images per Anomaly Type", fontsize=10.5) ax_sets.tick_params(labelsize=8.5) ax_sets.spines[["top", "left", "right"]].set_visible(False) fig.subplots_adjust(left=0.20, right=0.97, bottom=0.13, top=0.94) for extension in ("pdf", "png"): fig.savefig(f"{stem}.{extension}", dpi=400, bbox_inches="tight") plt.close(fig) def default_coco_search(): candidates = [ Path("test"), Path("../test"), Path(__file__).resolve().parent.parent / "test", Path("train"), Path("../train"), Path(__file__).resolve().parent.parent / "train", Path("."), Path(".."), Path(__file__).resolve().parent.parent, ] for c in candidates: if c.is_dir() and list(c.rglob("annotations*.coco.json")): return [str(c)] return ["."] def find_files(names): resolved = [] for name in names: candidates = [ Path(f"checkpoint_data/{name}"), Path(f"../checkpoint_data/{name}"), Path(__file__).resolve().parent.parent / "checkpoint_data" / name, Path(__file__).resolve().parent / name, Path(name), ] found = next((str(c) for c in candidates if c.is_file()), None) if found: resolved.append(found) return resolved def default_out_dir(): if Path("checkpoint_data").is_dir(): return Path("checkpoint_data/upset_figures") if (Path(__file__).resolve().parent.parent / "checkpoint_data").is_dir(): return Path(__file__).resolve().parent.parent / "checkpoint_data/upset_figures" return Path("./upset_figures") def main(): parser = argparse.ArgumentParser(description="Create UpSet performance plots") parser.add_argument("--coco", nargs="+", default=None, help="COCO annotation files or root directory (auto-detected if omitted)") parser.add_argument("--coco-pattern", default="annotations*.coco.json") parser.add_argument("--m3dm", nargs="+", default=None, help="M3DM per-image CSVs (auto-detected from checkpoint_data/ if omitted)") parser.add_argument("--stfpm", nargs="+", default=None, help="STFPM per-image CSVs (auto-detected from checkpoint_data/ if omitted)") parser.add_argument("--metric", default="aupro_30") parser.add_argument("--top-n", type=int, default=20) parser.add_argument("--min-count", type=int, default=5) parser.add_argument("--no-ensure-all-types", action="store_true") parser.add_argument("--out", default=None, help="Output directory (default: checkpoint_data/upset_figures or ./upset_figures)") args = parser.parse_args() coco_entries = args.coco if args.coco is not None else default_coco_search() annotations = coco_files(coco_entries, args.coco_pattern) if not annotations: raise SystemExit(f"No COCO annotation files found in {coco_entries}") memberships = load_annotations(annotations) groups = exact_groups(memberships) all_types = sorted({name for types in memberships.values() for name in types}) combinations = choose(groups, args.top_n, args.min_count, all_types=all_types, ensure_all_types=not args.no_ensure_all_types) if not combinations: raise SystemExit("No exact combinations satisfy --min-count") categories = sorted({name for membership in combinations for name in membership}) m3dm_paths = args.m3dm if args.m3dm is not None else find_files(["per_image_aupro_zivid.csv", "per_image_aupro_realsense.csv"]) stfpm_paths = args.stfpm if args.stfpm is not None else find_files(["per_image_aupro_stfpm.csv"]) m3dm = load_scores(m3dm_paths, args.metric, "M3DM") stfpm = load_scores(stfpm_paths, args.metric, "STFPM") paired = set(m3dm) & set(stfpm) difference = {key: m3dm[key] - stfpm[key] for key in paired} annotation_keys = {key for key, value in memberships.items() if value} print(f"M3DM matched annotations : {len(annotation_keys & set(m3dm))}/{len(m3dm)}") print(f"STFPM matched annotations: {len(annotation_keys & set(stfpm))}/{len(stfpm)}") print(f"Paired images : {len(paired)}") print(f"Observed combinations : {len(groups)}") print(f"Displayed combinations : {len(combinations)}") if not annotation_keys & set(m3dm) or not annotation_keys & set(stfpm): raise SystemExit("A method has no score-to-annotation matches") if not paired: raise SystemExit("No paired M3DM/STFPM images") dataset_rows = stats(combinations, groups) m3dm_rows = stats(combinations, groups, m3dm) stfpm_rows = stats(combinations, groups, stfpm) difference_rows = stats(combinations, groups, difference) absolute = np.asarray([row["mean"] for row in m3dm_rows + stfpm_rows if np.isfinite(row["mean"])]) limits = (float(absolute.min()), float(absolute.max())) output = Path(args.out) if args.out is not None else default_out_dir() output.mkdir(parents=True, exist_ok=True) metric_label = args.metric.replace("aupro_", "AUPRO@").replace("_", " ") if metric_label.startswith("AUPRO@"): metric_label += "%" plots = [ (dataset_rows, output / "01_upset_dataset_wide", None, None, False), (m3dm_rows, output / "02_upset_m3dm_performance", f"Mean Pixel {metric_label}", limits, False), (stfpm_rows, output / "03_upset_stfpm_performance", f"Mean Pixel {metric_label}", limits, False), (difference_rows, output / "04_upset_m3dm_minus_stfpm", f"\u0394 {metric_label} (Positive: M3DM Better)", None, True), ] for rows, stem, label, scale, is_difference in plots: draw(rows, categories, stem, label, scale, is_difference) save_values(f"{stem}_values.csv", rows) print(f"Wrote 4 UpSet figures as PDF and PNG to {output}") if __name__ == "__main__": main()