File size: 10,687 Bytes
1777460
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
"""Final set-5 analysis (Mac): linear vs MLP probes, random-label side test, native-224 check, combined long CSV.

  python analyze5.py <out_dir>       # out_dir holds p3/, p4/, p5/ (rows CSVs) and perimage/p5/*.npz

Writes <out_dir>/final/: results_long_all.csv, linear_vs_mlp.json, gap_linear_vs_mlp.json, randlabel.json,
check224.json and figures (randlabel_*.png).
"""
from __future__ import annotations

import csv
import json
import sys
from pathlib import Path

import numpy as np

sys.path.insert(0, str(Path(__file__).resolve().parent))
import analyze3 as A  # noqa: E402
import probes5 as PR  # noqa: E402

PRIMARY = {"nyu_depth": "rmse", "nyu_normals": "mean_angle", "ade_seg": "miou"}
HIGHER = {"nyu_depth": False, "nyu_normals": False, "ade_seg": True, "imagenet_cls": True}
DENOISERS = {"B": ["sit_b", "jit_b"], "L": ["sit_l", "jit_l"]}
SSL = {"B": ["mae_b", "mocov3_b", "dino_b", "ibot_b", "deit3_b"], "L": ["mae_l", "mocov3_l", "ibot_l", "deit3_l"]}


def read_rows(d):
    rows = []
    for p in sorted(d.glob("*_rows.csv")):
        with open(p) as f:
            for r in csv.DictReader(f):
                r["mean"] = float(r["mean"])
                rows.append(r)
    return rows


def find(rows, **kw):
    out = [r for r in rows if all(str(r[k]) == str(v) for k, v in kw.items())]
    return out[0] if out else None


def mlp_stat(out, model, task, W):
    """Per-image arrays of the MLP probe -> [B] seed-averaged primary metric for resampling weights W."""
    t = {"nyu_depth": "depth", "nyu_normals": "normals", "ade_seg": "seg"}[task]
    z = np.load(out / "perimage" / "p5" / f"mlp_{model}_{t}.npz")
    if task == "nyu_depth":
        return A.stat("mean", z["depth_rmse"], W)
    if task == "nyu_normals":
        return A.stat("normals", z["normals_stats"].astype(np.float64), W)
    return A.stat("seg", z["ade_counts"].astype(np.float64), W)


def main():
    out = Path(sys.argv[1])
    fin = out / "final"
    fin.mkdir(parents=True, exist_ok=True)
    r3, r4, r5 = read_rows(out / "p3"), read_rows(out / "p4"), read_rows(out / "p5")
    with open(fin / "results_long_all.csv", "w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=PR.FIELDS)
        w.writeheader()
        for r in r3 + r4 + r5:
            w.writerow({k: r.get(k, "") for k in PR.FIELDS})
    sel = {}
    for ph in ("p3", "p4"):
        for r in json.loads((out / ph / "analysis" / "main_table.json").read_text()):
            sel[(r["model"], r["task"])] = r

    # ---------------------------------------------------------------- linear vs MLP at the same cell
    lvm = []
    for size in ("B", "L"):
        for m in DENOISERS[size] + SSL[size] + (["dinov2_b"] if size == "B" else []):
            for task, met in PRIMARY.items():
                s = sel.get((m, task))
                r = find(r5, model=m, task=f"{task}_mlp", metric=met, split="test")
                if s and r:
                    lin = s[met]
                    lvm.append(dict(size=size, model=m, task=task, layer=s["layer"], s=s["s"], linear=lin,
                                    mlp=r["mean"], mlp_ci=(float(r["ci_lo"]), float(r["ci_hi"])), mlp_minus_linear=r["mean"] - lin))
    (fin / "linear_vs_mlp.json").write_text(json.dumps(lvm, indent=1))

    # ---------------------------------------------------------------- denoising - SSL gap under each probe type
    gaps = []
    for size in ("B", "L"):
        for task in PRIMARY:
            for d in DENOISERS[size]:
                for o in SSL[size]:
                    a, b = sel.get((d, task)), sel.get((o, task))
                    ra = find(r5, model=d, task=f"{task}_mlp", metric=PRIMARY[task], split="test")
                    rb = find(r5, model=o, task=f"{task}_mlp", metric=PRIMARY[task], split="test")
                    if not (a and b and ra and rb):
                        continue
                    n = np.load(out / "perimage" / "p5" / f"mlp_{d}_{ {'nyu_depth': 'depth', 'nyu_normals': 'normals', 'ade_seg': 'seg'}[task] }.npz")
                    nimg = next(iter(n.values())).shape[1]
                    W = PR.boot_weights(nimg, n_boot=2000, seed=2)
                    diff = mlp_stat(out, d, task, W) - mlp_stat(out, o, task, W)
                    lo, hi = np.percentile(diff, [2.5, 97.5])
                    gaps.append(dict(size=size, task=task, denoiser=d, ssl=o,
                                     linear_gap=a[PRIMARY[task]] - b[PRIMARY[task]],
                                     mlp_gap=ra["mean"] - rb["mean"], mlp_gap_ci=(float(lo), float(hi)),
                                     mlp_verdict="ngang nhau" if lo <= 0 <= hi else
                                     (f"{d} tốt hơn" if ((ra["mean"] > rb["mean"]) == HIGHER[task]) else f"{o} tốt hơn")))
    (fin / "gap_linear_vs_mlp.json").write_text(json.dumps(gaps, indent=1))

    # ---------------------------------------------------------------- random label vs null label, per block
    rl = []
    for m in ("sit_b", "jit_b"):
        for task, met, nullt in (("nyu_depth_randlabel", "rmse", "nyu_depth"), ("imagenet_cls_randlabel", "top1", "imagenet_cls")):
            for r in [r for r in r5 if r["model"] == m and r["task"] == task and r["metric"] == met and r["split"] == "test"]:
                nl = find(r3, model=m, task=nullt, metric=met, layer=r["layer"], s=r["s"], split="test")
                rl.append(dict(model=m, task=nullt, s=r["s"], layer=int(r["layer"]), random_label=r["mean"],
                               random_ci=(float(r["ci_lo"]), float(r["ci_hi"])), null_label=nl["mean"] if nl else None,
                               null_ci=(nl["ci_lo"], nl["ci_hi"]) if nl else None))
    (fin / "randlabel.json").write_text(json.dumps(rl, indent=1, default=str))
    try:
        import matplotlib
        matplotlib.use("Agg")
        import matplotlib.pyplot as plt
        fig, axes = plt.subplots(1, 2, figsize=(11, 3.8))
        for ax, task, lab in ((axes[0], "nyu_depth", "RMSE độ sâu (↓)"), (axes[1], "imagenet_cls", "top-1 ImageNet (↑)")):
            for m, c in (("sit_b", "C0"), ("jit_b", "C1")):
                xs = sorted({r["layer"] for r in rl if r["model"] == m and r["task"] == task})
                g = {r["layer"]: r for r in rl if r["model"] == m and r["task"] == task}
                if not xs:
                    continue
                ax.plot(xs, [g[x]["null_label"] for x in xs], "-o", ms=3, c=c, label=f"{A.NAMES[m]} nhãn rỗng (s={g[xs[0]]['s']})")
                ax.plot(xs, [g[x]["random_label"] for x in xs], "--o", ms=3, c=c, label=f"{A.NAMES[m]} nhãn ngẫu nhiên")
            ax.set_xlabel("block")
            ax.set_ylabel(lab)
            ax.legend(fontsize=7)
        fig.tight_layout()
        fig.savefig(fin / "randlabel.png", dpi=130)
        plt.close(fig)
    except Exception as e:  # noqa: BLE001
        print("figure skipped:", e)

    # ---------------------------------------------------------------- native 224 vs 256 at the selected block
    c224 = []
    for r in r5:
        if not r["task"].endswith("_224") or r["split"] != "test":
            continue
        base = r["task"][:-4]
        if r["metric"] != {"nyu_depth": "rmse", "nyu_normals": "mean_angle", "ade_seg": "miou", "imagenet_cls": "top1"}[base]:
            continue
        s = sel.get((r["model"], base))
        v256 = s[r["metric"]] if s else None
        c224.append(dict(model=r["model"], task=base, layer=int(r["layer"]), at256=v256, at224=r["mean"],
                         ci224=(float(r["ci_lo"]), float(r["ci_hi"])), diff_224_minus_256=None if v256 is None else r["mean"] - v256))
    (fin / "check224.json").write_text(json.dumps(c224, indent=1))

    for x in lvm:
        print("MLP", x["size"], x["model"], x["task"], f"lin {x['linear']:.4f} mlp {x['mlp']:.4f} ({x['mlp_minus_linear']:+.4f})")
    for g in gaps:
        print("GAP", g["size"], g["task"], g["denoiser"], "-", g["ssl"], f"linear {g['linear_gap']:+.4f} mlp {g['mlp_gap']:+.4f}",
              f"[{g['mlp_gap_ci'][0]:+.4f}, {g['mlp_gap_ci'][1]:+.4f}]", g["mlp_verdict"])
    for x in c224:
        print("224", x["model"], x["task"], f"b{x['layer']} 256 {x['at256']:.4f} 224 {x['at224']:.4f} ({x['diff_224_minus_256']:+.4f})")
    for x in rl:
        print("RL", x["model"], x["task"], f"b{x['layer']} null {x['null_label']} random {x['random_label']:.4f}")


def spair(out):
    """SPair-71k: per model the (block, s) cell best on val; test PCK with CI; paired bootstrap of denoiser - SSL."""
    rows = [r for r in read_rows(out / "p5") if r["task"] == "spair_pck"]
    best = {}
    for m in sorted({r["model"] for r in rows}):
        v = max((r for r in rows if r["model"] == m and r["split"] == "val"), key=lambda r: r["mean"])
        t = find(rows, model=m, split="test", layer=v["layer"], s=v["s"])
        best[m] = dict(model=m, layer=int(v["layer"]), s=v["s"], val=v["mean"], test=t["mean"],
                       ci=(float(t["ci_lo"]), float(t["ci_hi"])), depth_rel=float(t["depth_rel"]))
    pw = []
    for size in ("B", "L"):
        for d in DENOISERS[size]:
            for o in SSL[size] + ([d.replace("sit", "jit")] if d.startswith("sit") else []):
                if d not in best or o not in best:
                    continue
                za, zb = (np.load(out / "perimage" / "p5" / f"spair_{m}.npz") for m in (d, o))
                ca = za[f"s{best[d]['s']}_b{best[d]['layer']}"].astype(float)
                cb = zb[f"s{best[o]['s']}_b{best[o]['layer']}"].astype(float)
                tot = za["total"].astype(float)
                W = PR.boot_weights(len(tot), n_boot=2000, seed=4)
                diff = (W @ ca - W @ cb) / (W @ tot)
                lo, hi = np.percentile(diff, [2.5, 97.5])
                pa, pb = ca.sum() / tot.sum(), cb.sum() / tot.sum()
                pw.append(dict(size=size, a=d, b=o, a_pck=pa, b_pck=pb, diff=pa - pb, ci=(float(lo), float(hi)),
                               verdict="ngang nhau" if lo <= 0 <= hi else (f"{d} tốt hơn" if pa > pb else f"{o} tốt hơn")))
    fin = out / "final"
    (fin / "spair_best.json").write_text(json.dumps(list(best.values()), indent=1))
    (fin / "spair_pairwise.json").write_text(json.dumps(pw, indent=1))
    for b in best.values():
        print("SPAIR", b["model"], f"b{b['layer']} s={b['s']} test {b['test']:.4f} [{b['ci'][0]:.4f}, {b['ci'][1]:.4f}] rel {b['depth_rel']}")
    for p in pw:
        print("SPAIR-PW", p["size"], p["a"], "-", p["b"], f"{p['diff']:+.4f} [{p['ci'][0]:+.4f}, {p['ci'][1]:+.4f}]", p["verdict"])


if __name__ == "__main__" and len(sys.argv) > 2 and sys.argv[2] == "spair":
    spair(Path(sys.argv[1]))
elif __name__ == "__main__":
    main()