Download experiments/34_gigatime_diag.py from Pathstudy/fourmodal-pathology-bind: direct link, hf CLI and curl.
- Browser
- Download file 6.09 kB
-
https://huggingface.co/Pathstudy/fourmodal-pathology-bind/resolve/main/experiments/34_gigatime_diag.py
- Command line
-
hf download hf://Pathstudy/fourmodal-pathology-bind/experiments/34_gigatime_diag.py
-
curl -L -o 34_gigatime_diag.py https://huggingface.co/Pathstudy/fourmodal-pathology-bind/resolve/main/experiments/34_gigatime_diag.py
6.09 kB
| """Why GigaTIME virtual mIF fails at instance-level pairing (ORION, 10 shared channels, same tiles as the real mIF). | |
| (a) pooled vs WITHIN-slide Spearman of tile means: pairing in a 100-tile gallery needs tile-to-tile differences | |
| inside a slide, while pooled correlation is dominated by slide/tissue-level differences | |
| (b) direct real-mean <-> virtual-mean retrieval (no learned head): rank-gaussianised channel means, cosine, g100 | |
| (c) in-domain reference: ridge UNI2 H&E -> real means, trained on ORION patient_5fold train, scored on test | |
| (what H&E can predict about these 10 channels when the model has seen ORION) | |
| (d) input distribution: real mIF intensities vs GigaTIME sigmoid probabilities (what the VirTues head receives) | |
| Output results/gigatime_diag.csv + printed tables. | |
| """ | |
| import json | |
| import os | |
| import numpy as np | |
| import pandas as pd | |
| from scipy.special import ndtri | |
| from scipy.stats import rankdata, spearmanr | |
| from common import CACHE, ROOT, SPLITS, load_all_tiles | |
| OUT = os.path.join(ROOT, "results") | |
| G = os.path.join(CACHE, "gigatime") | |
| ORION_CH = ["Hoechst", "CD31", "CD45", "CD68", "CD4", "FOXP3", "CD8a", "CD45RO", "CD20", "PD-L1", "CD3e", | |
| "CD163", "E-cadherin", "PD-1", "Ki67", "Pan-CK", "SMA"] | |
| PANEL = [("Hoechst", ["DAPI"]), ("CD68", ["CD68"]), ("CD4", ["CD4"]), ("CD8a", ["CD8"]), ("CD20", ["CD20"]), | |
| ("PD-L1", ["PD-L1"]), ("CD3e", ["CD3"]), ("Ki67", ["Ki67"]), ("Pan-CK", ["CK"]), ("SMA", ["Actin-D", "Transgelin"])] | |
| gch = json.load(open(os.path.join(G, "channels.json")))["channels"] | |
| df = load_all_tiles() | |
| slide = df.in_slide_name.values | |
| real = np.load(os.path.join(G, "orion_real_if_means.npy"))[:, [ORION_CH.index(o) for o, _ in PANEL]] | |
| vm = np.load(os.path.join(G, "orion_means.npy")) | |
| virt = np.stack([vm[:, [gch.index(g) for g in gs]].mean(1) for _, gs in PANEL], 1) | |
| he = np.load(os.path.join(CACHE, "he_uni2.npy"))[:, 0].astype(np.float64) | |
| names = [o for o, _ in PANEL] | |
| rows = [] | |
| def within(a, b): | |
| """mean within-slide Spearman (slides with >= 20 tiles), tiles-weighted""" | |
| r, w = [], [] | |
| for s in np.unique(slide): | |
| m = slide == s | |
| if m.sum() >= 20 and a[m].std() > 0 and b[m].std() > 0: | |
| r.append(spearmanr(a[m], b[m])[0]); w.append(m.sum()) | |
| return float(np.average(r, weights=w)) | |
| rg = lambda x: ndtri((np.apply_along_axis(rankdata, 0, x) - 0.5) / len(x)) | |
| def g100(a, b, draws=50, seed=0, groups=None): | |
| a = a / np.linalg.norm(a, axis=1, keepdims=True); b = b / np.linalg.norm(b, axis=1, keepdims=True) | |
| rng = np.random.default_rng(seed); r = [] | |
| for _ in range(draws): | |
| if groups is None: | |
| s = rng.choice(len(a), min(100, len(a)), replace=False) | |
| else: # gallery drawn from ONE slide: only within-slide differences can help | |
| g = rng.choice(groups); s = np.flatnonzero(slide == g); s = rng.choice(s, min(100, len(s)), replace=False) | |
| sim = a[s] @ b[s].T; d = np.diag(sim)[:, None] | |
| r.append(((sim > d).sum(1) == 0).mean() / 2 + ((sim.T > d).sum(1) == 0).mean() / 2) | |
| return float(np.mean(r)) | |
| # ---- (c) ridge UNI2 -> real means (in-domain reference), patient 5-fold test predictions | |
| pred = np.zeros_like(real, dtype=np.float64) | |
| R_rg = rg(real) | |
| for k in range(5): | |
| s = pd.read_csv(os.path.join(SPLITS, "patient_5fold", f"fold{k}.csv")) | |
| tr, va, te = (s.tile_id[s.split == x].values for x in ["train", "val", "test"]) | |
| mu, sd = he[tr].mean(0), he[tr].std(0) + 1e-6 | |
| X = lambda i: (he[i] - mu) / sd | |
| best = None | |
| for lam in [1e1, 1e2, 1e3, 1e4]: # lambda chosen on val | |
| W = np.linalg.solve(X(tr).T @ X(tr) + lam * np.eye(he.shape[1]), X(tr).T @ R_rg[tr]) | |
| v = np.mean([spearmanr(X(va) @ W[:, c], R_rg[va, c])[0] for c in range(len(names))]) | |
| if best is None or v > best[0]: | |
| best = (v, W) | |
| pred[te] = X(te) @ best[1] | |
| # ---- (a) correlations | |
| for c, n in enumerate(names): | |
| rows.append({"channel": n, | |
| "GigaTIME pooled": spearmanr(virt[:, c], real[:, c])[0], "GigaTIME within-slide": within(virt[:, c], real[:, c]), | |
| "UNI2-ridge pooled (test)": spearmanr(pred[:, c], real[:, c])[0], "UNI2-ridge within-slide (test)": within(pred[:, c], real[:, c])}) | |
| C = pd.DataFrame(rows).set_index("channel") | |
| C.loc["mean"] = C.mean() | |
| # ---- (b) direct retrieval, all tiles, galleries mixed across slides vs within one slide | |
| big = [s for s in np.unique(slide) if (slide == s).sum() >= 100] | |
| V_rg, P_rg = rg(virt), rg(pred) | |
| Rt = pd.DataFrame([ | |
| {"pair": "real means <-> GigaTIME means", "mixed-slide gallery": g100(R_rg, V_rg), "single-slide gallery": g100(R_rg, V_rg, groups=big)}, | |
| {"pair": "real means <-> UNI2-ridge prediction", "mixed-slide gallery": g100(R_rg, P_rg), "single-slide gallery": g100(R_rg, P_rg, groups=big)}, | |
| {"pair": "real means <-> shuffled real (chance)", "mixed-slide gallery": g100(R_rg, R_rg[np.random.default_rng(0).permutation(len(R_rg))]), "single-slide gallery": np.nan}, | |
| ]).set_index("pair") | |
| # ---- (d) input distribution of the pixel maps (200 tiles) | |
| maps = np.load(os.path.join(G, "orion_maps.npy"), mmap_mode="r") | |
| idx = np.random.default_rng(0).choice(len(maps), 200, replace=False) | |
| mv = np.asarray(maps[np.sort(idx)])[:, [gch.index(gs[0]) for _, gs in PANEL]].astype(np.float32) / 255 | |
| D = pd.DataFrame({"channel": names, | |
| "virtual: frac px p<0.05": (mv < 0.05).mean((0, 2, 3)), | |
| "virtual: frac px p>0.95": (mv > 0.95).mean((0, 2, 3)), | |
| "virtual: frac px in (0.05,0.95)": ((mv >= 0.05) & (mv <= 0.95)).mean((0, 2, 3))}).set_index("channel") | |
| pd.set_option("display.width", 200) | |
| print("(a) Spearman of tile means vs real ORION mIF\n", C.round(3).to_string()) | |
| print("\n(b) R@1 in 100-tile galleries (chance 0.01), no learned head\n", Rt.round(3).to_string()) | |
| print("\n(d) GigaTIME pixel-value distribution (sigmoid probabilities)\n", D.round(3).to_string()) | |
| C.round(4).to_csv(os.path.join(OUT, "gigatime_diag.csv")) | |
| Rt.round(4).to_csv(os.path.join(OUT, "gigatime_diag_retrieval.csv")) | |
| D.round(4).to_csv(os.path.join(OUT, "gigatime_diag_pixels.csv")) | |