| |
| """Create class-specific multiplicity figures from per-class-per-image AUPRO CSVs. |
| |
| The script intersects M3DM/STFPM by (scene, split, image_id, class), so every |
| method comparison uses identical class-specific samples. Dataset-wide uses |
| sample counts only. |
| """ |
| import argparse |
| from pathlib import Path |
| import numpy as np |
| import pandas as pd |
| import matplotlib |
| matplotlib.use('Agg') |
| import matplotlib.pyplot as plt |
| import seaborn as sns |
| from matplotlib.patches import Patch |
|
|
| CLASSES = ['residual_content', 'nuisance_sticker_inside', 'nuisance_gunk', 'nuisance_paper'] |
| KS = list(range(1, 8)) |
|
|
|
|
| def norm(df, fallback): |
| required = {'scene', 'image_id', 'class', 'multiplicity', 'aupro_30'} |
| missing = required - set(df.columns) |
| if missing: |
| raise SystemExit(f'missing columns: {sorted(missing)}') |
| d = df.copy() |
| if 'split' not in d: |
| d['split'] = 'anomaly' |
| if 'method' not in d: |
| d['method'] = fallback |
| d['scene'] = d['scene'].astype(str).str.zfill(6) |
| d['image_id'] = d['image_id'].astype(str).str.replace(r'\.0$', '', regex=True).str.zfill(5) |
| d['split'] = d['split'].astype(str).str.lower() |
| d['class'] = d['class'].astype(str) |
| d['multiplicity'] = pd.to_numeric(d['multiplicity']).astype(int) |
| d['aupro_30'] = pd.to_numeric(d['aupro_30'], errors='coerce') |
| return d |
|
|
|
|
| def aggregate(d): |
| return (d.groupby(['method', 'class', 'multiplicity'])['aupro_30'] |
| .agg(Value='mean', n='count', std='std').reset_index()) |
|
|
|
|
| def pooled_mean(agg): |
| x = agg.assign(total=agg.Value * agg.n) |
| return x.groupby('class').total.sum() / x.groupby('class').n.sum() |
|
|
|
|
| def class_means(ax, means, ylim, fmt='{:.2f}'): |
| for i, c in enumerate(CLASSES): |
| if c not in means: |
| continue |
| v = float(means[c]) |
| ax.hlines(v, i - .4, i + .4, color='red', linestyle=':', linewidth=3, |
| label='Class Mean' if i == 0 else None) |
| ax.text(i + .3, v + .018 * (ylim[1] - ylim[0]), fmt.format(v), color='red', ha='left', |
| va='center', fontsize=9, fontweight='bold') |
|
|
|
|
| def finish(ax, ylim, ylabel, handles=None, labels=None, ncol=4): |
| ax.set_xlabel('') |
| ax.set_ylabel(ylabel) |
| ax.set_ylim(*ylim) |
| ax.tick_params(axis='x', rotation=15) |
| for t in ax.get_xticklabels(): |
| t.set_ha('right') |
| if handles is None: |
| handles, labels = ax.get_legend_handles_labels() |
| ax.legend(handles, labels, loc='upper left', ncol=ncol, frameon=True, framealpha=.2, |
| facecolor='white', edgecolor='black') |
|
|
|
|
| def save(fig, stem): |
| fig.tight_layout() |
| fig.savefig(stem.with_suffix('.pdf'), bbox_inches='tight') |
| fig.savefig(stem.with_suffix('.png'), dpi=300, bbox_inches='tight') |
| plt.close(fig) |
|
|
|
|
| def grouped(agg, means, stem, ylim, method=None): |
| d = agg if method is None else agg[agg.method == method] |
| sns.set_theme(style='whitegrid', font_scale=1.1) |
| fig, ax = plt.subplots(figsize=(14, 5)) |
| sns.barplot(data=d, x='class', y='Value', hue='multiplicity', order=CLASSES, |
| hue_order=KS, palette='viridis', ax=ax) |
| class_means(ax, means, ylim) |
| h, l = ax.get_legend_handles_labels() |
| l = [('1 type' if x == '1' else f'{x} types') if x.isdigit() else x for x in l] |
| finish(ax, ylim, 'Mean Pixel AUPRO Score', h, l, 4) |
| save(fig, stem) |
|
|
|
|
| def counts(common, stem): |
| unique = common[['scene', 'split', 'image_id', 'class', 'multiplicity']].drop_duplicates() |
| a = (unique.groupby(['class', 'multiplicity']).size().reset_index(name='Value')) |
| means = a.groupby('class').Value.mean() |
| top = max(a.Value.max(), means.max()) * 1.42 |
| sns.set_theme(style='whitegrid', font_scale=1.1) |
| fig, ax = plt.subplots(figsize=(14, 5)) |
| sns.barplot(data=a, x='class', y='Value', hue='multiplicity', order=CLASSES, |
| hue_order=KS, palette='viridis', ax=ax) |
| class_means(ax, means, (0, top), '{:.0f}') |
| h, l = ax.get_legend_handles_labels() |
| l = [('1 type' if x == '1' else f'{x} types') if x.isdigit() else x for x in l] |
| finish(ax, (0, top), 'Number of Images', h, l, 4) |
| save(fig, stem) |
| a.to_csv(stem.with_name(stem.name + '_values.csv'), index=False) |
|
|
|
|
| def compare_coloured(agg, means, stem, ylim, mode): |
| methods = list(agg.method.drop_duplicates()) |
| d = agg.copy() |
| if mode == 'multiplicity': |
| d['group'] = d.multiplicity.astype(str) + ' ' + d.method |
| order = [f'{k} {m}' for k in KS for m in methods] |
| else: |
| d['group'] = d.method + ' k=' + d.multiplicity.astype(str) |
| order = [f'{m} k={k}' for m in methods for k in KS] |
| order = [x for x in order if x in set(d.group)] |
| pal = {} |
| for x in order: |
| k = int(x.split()[0]) if mode == 'multiplicity' else int(x.rsplit('=', 1)[1]) |
| m = x.split(' ', 1)[1] if mode == 'multiplicity' else x.rsplit(' k=', 1)[0] |
| base = np.array(plt.cm.viridis((k - 1) / 6)[:3]) |
| shade = 1 if m == methods[0] else .55 |
| pal[x] = tuple(base * shade + (1 - shade) * np.ones(3)) |
| sns.set_theme(style='whitegrid', font_scale=1.1) |
| fig, ax = plt.subplots(figsize=(14, 5)) |
| sns.barplot(data=d, x='class', y='Value', hue='group', order=CLASSES, |
| hue_order=order, palette=pal, ax=ax) |
| class_means(ax, means, ylim) |
| finish(ax, ylim, 'Mean Pixel AUPRO Score', ncol=7) |
| save(fig, stem) |
|
|
|
|
| def geometry(groups, size, within, between, span=.8): |
| block = size + (size - 1) * within |
| total = groups * block + (groups - 1) * between |
| scale = span / total |
| start = -span / 2 |
| out = [] |
| for g in range(groups): |
| for b in range(size): |
| out.append(start + (g * (block + between) + b * (1 + within)) * scale + scale / 2) |
| return np.array(out), scale |
|
|
|
|
| def compare_spaced(agg, means, stem, ylim, mode): |
| methods = list(agg.method.drop_duplicates()) |
| lookup = {(r['class'], r.multiplicity, r.method): r.Value for _, r in agg.iterrows()} |
| order = [(k, m) for k in KS for m in methods] if mode == 'pair' else [(k, m) for m in methods for k in KS] |
| off, w = geometry(7, 2, .18, .75) if mode == 'pair' else geometry(2, 7, .06, 1.6) |
| colors = {k: plt.cm.viridis((k - 1) / 6) for k in KS} |
| sns.set_theme(style='whitegrid', font_scale=1.1) |
| fig, ax = plt.subplots(figsize=(14, 5)) |
| for ci, c in enumerate(CLASSES): |
| for oi, (k, m) in enumerate(order): |
| v = lookup.get((c, k, m)) |
| if v is not None: |
| ax.bar([ci + off[oi]], [v], width=w, color=colors[k], edgecolor='black', linewidth=.4) |
| ax.set_xticks(range(4), CLASSES) |
| class_means(ax, means, ylim) |
| handles = [Patch(facecolor=colors[k], edgecolor='black', label='1 type' if k == 1 else f'{k} types') for k in KS] |
| handles.append(plt.Line2D([], [], color='red', linestyle=':', linewidth=3, label='Class Mean')) |
| finish(ax, ylim, 'Mean Pixel AUPRO Score', handles, [h.get_label() for h in handles], 4) |
| note = 'left to right within each pair: ' if mode == 'pair' else 'left to right, block by block: ' |
| ax.text(.5, -.30, note + ' → '.join(methods), transform=ax.transAxes, ha='center', va='top', fontsize=9, color='.3') |
| save(fig, stem) |
|
|
|
|
| def find_file(name): |
| 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), |
| ] |
| for c in candidates: |
| if c.is_file(): |
| return c |
| return None |
|
|
|
|
| def default_out_dir(): |
| if Path("checkpoint_data").is_dir(): |
| return Path("checkpoint_data/figures_per_class_multiplicity") |
| if (Path(__file__).resolve().parent.parent / "checkpoint_data").is_dir(): |
| return Path(__file__).resolve().parent.parent / "checkpoint_data/figures_per_class_multiplicity" |
| return Path("./figures_per_class_multiplicity") |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser(description="Create class-specific multiplicity figures from per-class CSVs") |
| p.add_argument('--m3dm', default=None, help="Path to per_class_image_aupro.csv (auto-detected if omitted)") |
| p.add_argument('--stfpm', default=None, help="Path to per_class_image_aupro_stfpm.csv (auto-detected if omitted)") |
| p.add_argument('--out', default=None, help="Output directory (default: checkpoint_data/figures_per_class_multiplicity)") |
| a = p.parse_args() |
|
|
| m3dm_path = Path(a.m3dm) if a.m3dm else find_file("per_class_image_aupro.csv") |
| stfpm_path = Path(a.stfpm) if a.stfpm else find_file("per_class_image_aupro_stfpm.csv") |
|
|
| if not m3dm_path or not m3dm_path.is_file(): |
| raise SystemExit(f"M3DM per-class CSV not found: {m3dm_path}") |
| if not stfpm_path or not stfpm_path.is_file(): |
| raise SystemExit(f"STFPM per-class CSV not found: {stfpm_path}") |
|
|
| m = norm(pd.read_csv(m3dm_path), 'M3DM') |
| s = norm(pd.read_csv(stfpm_path), 'STFPM') |
| key = ['scene', 'split', 'image_id', 'class'] |
| m = m[m['class'].isin(CLASSES)] |
| s = s[s['class'].isin(CLASSES)] |
| common = m[key].drop_duplicates().merge(s[key].drop_duplicates(), on=key) |
| m = m.merge(common, on=key) |
| s = s.merge(common, on=key) |
|
|
| chk = m[key + ['multiplicity']].merge(s[key + ['multiplicity']], on=key, suffixes=('_m', '_s')) |
| if not (chk.multiplicity_m == chk.multiplicity_s).all(): |
| raise SystemExit('multiplicity mismatch between CSVs') |
|
|
| d = pd.concat([m, s], ignore_index=True) |
| agg = aggregate(d) |
| means = pooled_mean(agg) |
|
|
| out = Path(a.out) if a.out is not None else default_out_dir() |
| out.mkdir(parents=True, exist_ok=True) |
| top = max(agg.Value.max(), means.max()) * 1.42 |
| ylim = (0, top) |
|
|
| counts(m, out / '01_multiplicity_dataset_wide') |
| grouped(agg, agg[agg.method == 'M3DM'].groupby('class')[['Value', 'n']].apply(lambda x: np.average(x.Value, weights=x.n)), out / '02_multiplicity_m3dm', ylim, 'M3DM') |
| grouped(agg, agg[agg.method == 'STFPM'].groupby('class')[['Value', 'n']].apply(lambda x: np.average(x.Value, weights=x.n)), out / '03_multiplicity_stfpm', ylim, 'STFPM') |
| compare_coloured(agg, means, out / '04_multiplicity_compare_by_multiplicity', ylim, 'multiplicity') |
| compare_coloured(agg, means, out / '05_multiplicity_compare_by_method', ylim, 'method') |
| compare_spaced(agg, means, out / '06_multiplicity_paired_spaced', ylim, 'pair') |
| compare_spaced(agg, means, out / '07_multiplicity_blocked_spaced', ylim, 'block') |
| agg.to_csv(out / 'per_class_multiplicity_aggregates.csv', index=False) |
| print(f'M3DM selected rows: {len(m)}') |
| print(f'STFPM selected rows: {len(s)}') |
| print(f'Common class-specific rows per method: {len(common)}') |
| print(f'Wrote 7 figures to {out}') |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
