| |
| """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() |
|
|
