LamTNguyen's picture
set5: phase 4 (L-size models): results, analysis, B-to-L trend, report
f9ace88 verified
Raw History Blame Contribute Delete
11.4 kB
"""Phase-3 analysis (Mac): selection on validation, main table with CIs, peak-depth table, pairwise bootstrap differences,
layer x noise heatmaps and depth profiles.
python analyze3.py <out_dir> [p3|p4] # out_dir holds <phase>/*_rows.csv and perimage/<phase>/*.npz
Selection: for each model and task the (block, s) cell with the best validation score (mean over the 3 seeds; depth and
normals: ridge validation MSE, segmentation: validation mIoU, classification: validation top-1 of the mean patch token)
is reported on test. Pairwise differences: 2000 bootstrap resamples of test images shared by both models, each side
at its own selected cell, seed-averaged; "tie" when the 95% interval contains 0.
"""
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 probes5 as PR # noqa: E402
TASKS = { # task: (validation metric, higher is better, test metrics (first = primary), primary higher is better)
"nyu_depth": ("val_mse", False, ["rmse", "delta1", "absrel"], False),
"nyu_normals": ("val_mse", False, ["mean_angle", "median_angle", "pct_11.25", "pct_22.5", "pct_30"], False),
"ade_seg": ("val_miou", True, ["miou"], True),
"imagenet_cls": ("val_top1", True, ["top1"], True),
}
NAMES = {"sit_b": "SiT-B/2", "jit_b": "JiT-B/16", "mae_b": "MAE-B", "mocov3_b": "MoCo v3-B", "dino_b": "DINO-B",
"ibot_b": "iBOT-B", "deit3_b": "DeiT III-B", "dinov2_b": "DINOv2-B (ngoài)", "base_latent": "latent VAE có nhiễu",
"base_pixel": "patch pixel có nhiễu", "base_pixel_clean": "patch pixel sạch",
"sit_l": "SiT-L/2", "jit_l": "JiT-L/16", "mae_l": "MAE-L", "mocov3_l": "MoCo v3-L (bên thứ ba)",
"ibot_l": "iBOT-L", "deit3_l": "DeiT III-L"}
PHASE = "p3"
def n_blocks(model):
return 1 if model.startswith("base_") else (24 if model.endswith("_l") else 12)
def blocks(model):
n = n_blocks(model)
return [1] if n == 1 else (list(range(1, 13)) if n == 12 else list(range(2, 25, 2)))
GROUP_ORDER = ["denoise_latent", "denoise_pixel", "masked", "joint_embedding", "supervised", "external_data", "baseline"]
def load_rows(out):
files = sorted((out / PHASE).glob("*_rows.csv"))
rows = []
for p in files:
with open(p) as f:
rows += list(csv.DictReader(f))
for r in rows:
r["layer"] = int(r["layer"])
r["mean"] = float(r["mean"])
r["std"] = float(r["std"]) if r["std"] not in ("", "nan") else float("nan")
for k in ("ci_lo", "ci_hi"):
r[k] = float(r[k]) if r[k] not in ("",) else None
return rows
def select(rows):
"""{(model, task): dict(layer, s, val, group)} chosen on validation."""
best = {}
for model in sorted({r["model"] for r in rows}):
for task, (vm, hi, _, _) in TASKS.items():
cand = [r for r in rows if r["model"] == model and r["task"] == task and r["metric"] == vm]
if not cand:
continue
r = max(cand, key=lambda r: r["mean"]) if hi else min(cand, key=lambda r: r["mean"])
best[(model, task)] = dict(layer=r["layer"], s=r["s"], val=r["mean"], group=r["group"])
return best
def cell(rows, model, task, metric, layer, s):
for r in rows:
if (r["model"], r["task"], r["metric"], r["layer"], r["s"]) == (model, task, metric, layer, s):
return r
return None
# ----------------------------------------------------------------------------- per-image arrays for pairwise tests
def unit_tag(model, s, task):
grp = {"nyu_depth": "nyu", "nyu_normals": "nyu", "ade_seg": "seg", "imagenet_cls": "cls"}[task]
return f"{model}_s{s}_{grp}"
def per_image(out, model, task, layer, s):
"""Seed-resolved per-image quantity at (layer, s): returns (kind, array)."""
z = np.load(out / "perimage" / PHASE / f"{unit_tag(model, s, task)}.npz")
li = blocks(model).index(layer)
if task == "nyu_depth":
return "mean", z["depth_rmse"][li] # [S, N]
if task == "nyu_normals":
return "normals", z["normals_stats"][li].astype(np.float64) # [S, N, 725]
if task == "ade_seg":
return "seg", z["ade_counts"][li].astype(np.float64) # [S, N, 3, C]
return "mean", z["correct"][li].astype(np.float64) # [S, N]
def stat(kind, arr, W):
"""W [B, N] resampling counts -> [B] seed-averaged metric (primary)."""
if kind == "mean":
return (np.einsum("bn,sn->bs", W, arr) / W.sum(1, keepdims=True)).mean(1)
if kind == "normals":
return PR.normals_metrics_from(np.einsum("bn,snk->bsk", W, arr)[:, :, None, :])["mean_angle"].mean(1)
return PR.miou_from(np.einsum("bn,snkc->bskc", W, arr)).mean(1)
def pairwise(out, best, pairs, tasks, n_boot=2000):
res = []
for task in tasks:
cache = {}
for a, b in pairs:
if (a, task) not in best or (b, task) not in best:
continue
for m in (a, b):
if m not in cache:
sel = best[(m, task)]
cache[m] = per_image(out, m, task, sel["layer"], sel["s"])
n = cache[a][1].shape[1]
W = PR.boot_weights(n, n_boot=n_boot, seed=1)
one = np.ones((1, n))
da, db = stat(*cache[a], W), stat(*cache[b], W)
pa, pb = stat(*cache[a], one)[0], stat(*cache[b], one)[0]
lo, hi = np.percentile(da - db, [2.5, 97.5])
a_better = (pa > pb) == TASKS[task][3]
res.append(dict(task=task, a=a, b=b, a_value=pa, b_value=pb, diff=pa - pb, ci_lo=lo, ci_hi=hi,
verdict="ngang nhau" if lo <= 0 <= hi else (f"{a} tốt hơn" if a_better else f"{b} tốt hơn")))
return res
# ----------------------------------------------------------------------------- figures
def figures(rows, best, fig_dir):
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
fig_dir.mkdir(parents=True, exist_ok=True)
primary = {t: v[2][0] for t, v in TASKS.items()}
svals = ["0.05", "0.1", "0.3", "0.5", "0.7"]
for model in [m for m in ("sit_b", "jit_b", "sit_l", "jit_l") if any(r["model"] == m for r in rows)]:
bl = blocks(model)
fig, axes = plt.subplots(1, 4, figsize=(18, 3.6))
for ax, (task, m) in zip(axes, primary.items()):
H = np.full((len(svals), len(bl)), np.nan)
for i, s in enumerate(svals):
for j, l in enumerate(bl):
r = cell(rows, model, task, m, l, s)
if r:
H[i, j] = r["mean"]
cmap = "viridis_r" if not TASKS[task][3] else "viridis"
im = ax.imshow(H, aspect="auto", cmap=cmap)
ax.set_xticks(range(len(bl)), [str(l) for l in bl])
ax.set_yticks(range(len(svals)), svals)
ax.set_xlabel("block")
ax.set_ylabel("s")
ax.set_title(f"{NAMES[model]} — {task} {m}")
if (model, task) in best:
b = best[(model, task)]
ax.scatter([bl.index(b["layer"])], [svals.index(b["s"])], marker="*", s=160, c="red")
fig.colorbar(im, ax=ax, fraction=0.046)
fig.tight_layout()
fig.savefig(fig_dir / f"heatmap_{model}.png", dpi=130)
plt.close(fig)
models = [m for m in NAMES if any(r["model"] == m for r in rows)]
for task, m in primary.items():
fig, ax = plt.subplots(figsize=(7.5, 4.6))
for model in models:
if (model, task) not in best:
continue
s = best[(model, task)]["s"]
if model.startswith("base_"):
r = cell(rows, model, task, m, 1, s)
if r:
ax.axhline(r["mean"], ls=":", lw=1, color="gray")
ax.text(1.0, r["mean"], f" {NAMES[model]} (s={s})", fontsize=7, va="center", color="gray")
continue
xs, ys = [], []
for l in blocks(model):
r = cell(rows, model, task, m, l, s)
if r:
xs.append(l / n_blocks(model))
ys.append(r["mean"])
style = "-" if model.startswith(("sit_", "jit_")) else "--"
ax.plot(xs, ys, style, marker="o", ms=3, label=f"{NAMES[model]}" + (f" (s={s})" if s != "clean" else ""))
ax.set_xlabel("độ sâu tương đối (block / số block)")
ax.set_ylabel(f"{m} (test)")
ax.set_title(f"{task}: hồ sơ theo độ sâu, cỡ {'B' if PHASE == 'p3' else 'L'}")
ax.legend(fontsize=7, ncol=2)
fig.tight_layout()
fig.savefig(fig_dir / f"profile_{task}.png", dpi=130)
plt.close(fig)
def main():
global PHASE
out = Path(sys.argv[1])
PHASE = sys.argv[2] if len(sys.argv) > 2 else "p3"
rows = load_rows(out)
best = select(rows)
ana = out / PHASE / "analysis"
ana.mkdir(parents=True, exist_ok=True)
main_rows = []
for (model, task), sel in sorted(best.items(), key=lambda kv: (GROUP_ORDER.index(kv[1]["group"])
if kv[1]["group"] in GROUP_ORDER else 99, kv[0])):
rec = dict(model=model, name=NAMES.get(model, model), group=sel["group"], task=task, layer=sel["layer"],
s=sel["s"], depth_rel=0.0 if model.startswith("base_") else round(sel["layer"] / n_blocks(model), 3),
val=sel["val"])
for m in TASKS[task][2]:
r = cell(rows, model, task, m, sel["layer"], sel["s"])
if r:
rec[m], rec[f"{m}_std"], rec[f"{m}_ci"] = r["mean"], r["std"], (r["ci_lo"], r["ci_hi"])
if task == "imagenet_cls": # CLS reference for encoders: best block by validation of the CLS head
c = [r for r in rows if r["model"] == model and r["metric"] == "val_top1_cls"]
if c:
rc = max(c, key=lambda r: r["mean"])
t = cell(rows, model, task, "top1_cls", rc["layer"], rc["s"])
rec["top1_cls"], rec["top1_cls_layer"] = t["mean"], rc["layer"]
main_rows.append(rec)
with open(ana / "main_table.json", "w") as f:
json.dump(main_rows, f, indent=1, default=float)
present = {r["model"] for r in rows}
denoisers = [m for m in ("sit_b", "jit_b", "sit_l", "jit_l") if m in present]
others = [m for m in ("mae_b", "mocov3_b", "dino_b", "ibot_b", "deit3_b", "dinov2_b",
"mae_l", "mocov3_l", "ibot_l", "deit3_l") if m in present]
pairs = [(d, o) for d in denoisers for o in others if d[-1] == o[-1]]
pairs += [(j, sv) for j, sv in (("jit_b", "sit_b"), ("jit_l", "sit_l")) if j in present and sv in present]
pw = pairwise(out, best, pairs, list(TASKS))
with open(ana / "pairwise.json", "w") as f:
json.dump(pw, f, indent=1, default=float)
figures(rows, best, ana)
for r in main_rows:
print(r["task"], r["name"], f"block {r['layer']} s={r['s']}", {m: round(r[m], 4) for m in TASKS[r["task"]][2] if m in r},
f"CLS {r['top1_cls']:.4f}@b{r['top1_cls_layer']}" if "top1_cls" in r else "")
for p in pw:
print(p["task"], p["a"], "vs", p["b"], f"{p['diff']:+.4f} [{p['ci_lo']:+.4f}, {p['ci_hi']:+.4f}]", p["verdict"])
if __name__ == "__main__":
main()