PISCES / paper /make_data.py
Nabidnur's picture
PISCES (ARIES #1): code, paper, notebooks, results and figures
c09a3f4 verified
Raw History Blame Contribute Delete
21.5 kB
"""Turn results/*.jsonl into the .dat tables the paper's PGFPlots figures read, plus macros.tex
with every number quoted in the text, so the paper never hand-copies a result.
Usage: python paper/make_data.py (from the repository root)
"""
import collections, json, os
import numpy as np
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
OUT = os.path.join(ROOT, "paper", "data"); os.makedirs(OUT, exist_ok=True)
R = lambda f: [json.loads(l) for l in open(os.path.join(ROOT, "results", f))] if os.path.exists(os.path.join(ROOT, "results", f)) else []
def table(rows, key="test_mse"):
g = collections.defaultdict(dict)
for r in rows:
g[(r["method"], float(r["epochs"]))][r["seed"]] = r
return g
def paired(g, m, T, base=("official", None), Tb=None):
o = g.get((base[0], Tb if Tb is not None else T), {}); p = g.get((m, T), {})
s = sorted(set(o) & set(p))
d = np.array([100 * (p[x]["test_mse"] - o[x]["test_mse"]) / o[x]["test_mse"] for x in s])
t = np.array([p[x]["seconds"] / o[x]["seconds"] for x in s])
return s, d, t
macros = []
MAC = {} # raw values, for data files derived from macros
def M(name, val, fmt="{:.2f}"):
MAC[name] = val
macros.append("\\newcommand{\\%s}{%s}" % (name, fmt.format(val)))
# 1. quality vs wall-clock on DEEP* 1M test rows
deep = table(R("final/deep1m_test.jsonl"))
hist = table(R("deep1m_cpu.jsonl")) # development history (earlier session)
for m in ["official", "pisces", "pisces_v10"]:
with open(os.path.join(OUT, f"qvt_{m}.dat"), "w") as f:
f.write("epochs seconds mse sd n\n")
for T in sorted({T for (mm, T) in deep if mm == m}):
v = list(deep[(m, T)].values())
f.write(f"{T:g} {np.mean([r['seconds'] for r in v]):.2f} {np.mean([r['test_mse'] for r in v]):.6f} "
f"{np.std([r['test_mse'] for r in v]):.6f} {len(v)}\n")
# 2. main table macros (PISCES vs official on test rows)
for T, tag in [(1.0, "One"), (3.0, "Three"), (5.0, "Five")]:
for m, mt in [("pisces", "P"), ("pemeans_v3", "V")]:
s, d, t = paired(deep, m, T)
if len(s):
M(f"d{mt}{tag}", d.mean(), "{:+.2f}"); M(f"w{mt}{tag}", int((d < 0).sum()), "{}"); M(f"n{mt}{tag}", len(s), "{}")
M(f"t{mt}{tag}", t.mean()); M(f"lo{mt}{tag}", np.percentile(np.random.default_rng(0).choice(d, (10000, len(d))).mean(1), 2.5))
M(f"hi{mt}{tag}", np.percentile(np.random.default_rng(0).choice(d, (10000, len(d))).mean(1), 97.5))
for m, mt in [("official", "O"), ("pisces", "P")]:
v = list(deep.get((m, T), {}).values())
if v:
M(f"mse{mt}{tag}", np.mean([r["test_mse"] for r in v]), "{:.5f}")
M(f"sec{mt}{tag}", np.mean([r["seconds"] for r in v]), "{:.0f}")
s, d, t = paired(deep, "pisces", 3.0, Tb=5.0)
if len(s):
M("dPThreeVsFive", d.mean(), "{:+.2f}"); M("tPThreeVsFive", t.mean()); M("wPThreeVsFive", int((d < 0).sum()), "{}"); M("nPThreeVsFive", len(s), "{}")
s, d, t = paired(deep, "emeans_approx", 3.0)
if len(s):
M("dEAThree", d.mean(), "{:+.2f}"); M("tEAThree", t.mean()); M("wEAThree", int((d < 0).sum()), "{}"); M("nEAThree", len(s), "{}")
s2, d2, _ = paired(deep, "pisces", 3.0, base=("emeans_approx", None))
if len(s2):
M("dPvsEAThree", d2.mean(), "{:+.2f}"); M("wPvsEAThree", int((d2 < 0).sum()), "{}"); M("nPvsEAThree", len(s2), "{}")
# 3. development history at 3 epochs (each version paired with official e-means of its own session)
for m, tag in [("pemeans", "One"), ("pemeans_v2", "Two"), ("pemeans_v3", "Three"), ("pisces", "Ten")]:
s_, d, t = paired(hist, m, 3.0)
if len(s_):
M(f"hist{tag}D", d.mean(), "{:+.2f}"); M(f"hist{tag}T", t.mean())
for m, tag in [("pisces_v10", "TenNow"), ("pisces", "Final")]:
s_, d, t = paired(deep, m, 3.0)
if len(s_):
M(f"hist{tag}D", d.mean(), "{:+.2f}"); M(f"hist{tag}T", t.mean()); M(f"hist{tag}W", int((d < 0).sum()), "{}")
s_, d, t = paired(deep, "pisces", 3.0, base=("pisces_v10", None))
if len(s_):
M("engD", d.mean(), "{:+.3f}"); M("engT", t.mean()); M("engSame", int((np.abs(d) < 1e-6).sum()), "{}"); M("engN", len(s_), "{}")
# 4. time to quality on validation rows
ttq = table(R("final/deep1m_ttq_val.jsonl"))
with open(os.path.join(OUT, "ttq.dat"), "w") as f:
f.write("method epochs seconds mse\n")
for (m, T), v in sorted(ttq.items()):
f.write(f"{m} {T:g} {np.mean([r['seconds'] for r in v.values()]):.2f} {np.mean([r['test_mse'] for r in v.values()]):.6f}\n")
for T, tag in [(1.0, "One"), (2.0, "Two"), (3.0, "Three"), (4.0, "Four")]:
s, d, t = paired(ttq, "pisces", T, Tb=5.0)
if len(s):
M(f"ttqD{tag}", d.mean(), "{:+.2f}"); M(f"ttqT{tag}", t.mean()); M(f"ttqW{tag}", int((d < 0).sum()), "{}")
# 5. held-out datasets (per-seed paired differences)
for f_, tag in [("final/ssnpp1m_test.jsonl", "SS"), ("final/spacev1m_test.jsonl", "SV")]:
g = table(R(f_))
for m, mt in [("pisces", "P"), ("emeans_approx", "E")]:
s, d, t = paired(g, m, 3.0)
if len(s):
M(f"d{mt}{tag}", d.mean(), "{:+.3f}"); M(f"t{mt}{tag}", t.mean()); M(f"w{mt}{tag}", int((d < 0).sum()), "{}"); M(f"n{mt}{tag}", len(s), "{}")
with open(os.path.join(OUT, f"heldout_{tag}_{m}.dat"), "w") as fo:
fo.write("seed delta\n" + "".join(f"{x} {y:.5f}\n" for x, y in zip(s, d)))
# 6. per-method time-to-quality curves for the figure
for m in ["official", "pisces", "emeans_approx"]:
with open(os.path.join(OUT, f"ttq_{m}.dat"), "w") as f:
f.write("epochs seconds mse\n")
for (mm, T), v in sorted(ttq.items()):
if mm == m:
f.write(f"{T:g} {np.mean([r['seconds'] for r in v.values()]):.2f} {np.mean([r['test_mse'] for r in v.values()]):.6f}\n")
# 7. per-seed paired differences, all evaluations, for a strip plot (y = row index)
with open(os.path.join(OUT, "strip.dat"), "w") as f:
f.write("row delta\n")
rows_ = [(1, deep, "pisces", 1.0, None), (2, deep, "pisces", 3.0, None), (3, deep, "pisces", 5.0, None),
(4, table(R("final/spacev1m_test.jsonl")), "pisces", 3.0, None), (5, table(R("final/ssnpp1m_test.jsonl")), "pisces", 3.0, None),
(6, deep, "emeans_approx", 3.0, None), (7, table(R("final/spacev1m_test.jsonl")), "emeans_approx", 3.0, None),
(8, table(R("final/ssnpp1m_test.jsonl")), "emeans_approx", 3.0, None)]
sw = {"p": [0, 0], "e": [0, 0]}
for row, g, m, T, _ in rows_:
_, d, _ = paired(g, m, T)
f.write("".join(f"{row} {x:.5f}\n" for x in d))
c = sw["p" if m == "pisces" else "e"]; c[0] += int(np.sum(np.asarray(d) < 0)); c[1] += len(d)
M("stripWinsP", sw["p"][0], "{}"); M("stripN", sw["p"][1], "{}")
M("stripLossE", sw["e"][1] - sw["e"][0], "{}"); M("stripNE", sw["e"][1], "{}")
# 8. leave-one-out ablation at full scale (validation rows, seeds 1-3, 3 epochs)
abl = table(R("final/ablation_full_val.jsonl"))
ABL = [("pisces", "Full"), ("no_principal_split", "NoSplit"), ("no_gain_ranking", "NoGain"),
("no_consistent_closing", "NoClose"), ("tau_0.1", "TauLow"), ("step_x1.0", "StepOne"),
("no_early_revival", "NoEarly"), ("exact_last_epoch", "ExactLast"), ("exact_assignment", "Exact"), ("no_engineering", "NoEng")]
for _f in ["ablation.dat", "ablation_seeds.dat"]:
if os.path.exists(os.path.join(OUT, _f)):
os.remove(os.path.join(OUT, _f))
with open(os.path.join(OUT, "ablation.dat") if abl else os.devnull, "w") as f:
f.write("idx name delta lo hi cost ratio\n")
for i, (m, tag) in enumerate(ABL):
s_, d, t = paired(abl, m, 3.0)
if not len(s_):
continue
M(f"abl{tag}D", d.mean(), "{:+.3f}"); M(f"abl{tag}T", t.mean()); M(f"abl{tag}W", int((d < 0).sum()), "{}")
M(f"abl{tag}N", len(s_), "{}")
s2, d2, _ = paired(abl, m, 3.0, base=("pisces", None))
cost = d2.mean() if m != "pisces" else 0.0
M(f"abl{tag}C", cost, "{:+.3f}")
f.write(f"{i} {tag} {d.mean():.4f} {d.min():.4f} {d.max():.4f} {cost:.4f} {t.mean():.4f}\n")
# 9. scaling in k (validation rows, 3 epochs); k = 16,384 from the time-to-quality runs
SC = [(1024, "OneK", "final/scaling_k1024_val.jsonl"), (4096, "FourK", "final/scaling_k4096_val.jsonl"),
(16384, "SixteenK", "final/deep1m_ttq_val.jsonl"), (65536, "SixtyFourK", "final/scaling_k65536_val.jsonl")]
with open(os.path.join(OUT, "scaling.dat"), "w") as f, open(os.path.join(OUT, "scaling_seeds.dat"), "w") as fs:
f.write("k delta ratio\n"); fs.write("k delta speedup\n")
for k_, tag, fn in SC:
g = table(R(fn))
s_, d, t = paired(g, "pisces", 3.0)
if not len(s_):
continue
M(f"sc{tag}D", d.mean(), "{:+.2f}"); M(f"sc{tag}T", t.mean()); M(f"sc{tag}W", int((d < 0).sum()), "{}")
M(f"sc{tag}N", len(s_), "{}")
M(f"sc{tag}MO", np.mean([r["test_mse"] for r in g[("official", 3.0)].values()]), "{:.5f}")
M(f"sc{tag}SO", np.mean([r["seconds"] for r in g[("official", 3.0)].values()]), "{:.0f}")
M(f"sc{tag}SP", np.mean([r["splits"] for r in g[("pisces", 3.0)].values()]), "{:,.0f}")
M(f"sc{tag}SpO", np.mean([r["splits"] for r in g[("official", 3.0)].values()]), "{:,.0f}")
f.write(f"{k_} {d.mean():.4f} {t.mean():.4f}\n")
fs.write("".join(f"{k_} {di:.4f} {1 / ti:.4f}\n" for di, ti in zip(d, t)))
# 9b. the small-k rule (iteration 23b): exact assignment below k = 4,096, same session as its official runs
g23 = table(R("dev/iter23_small_k_val.jsonl"))
if g23:
s_, d, t = paired(g23, "exact_k1024", 3.0)
if len(s_):
M("scOneKRuleD", d.mean(), "{:+.2f}"); M("scOneKRuleT", t.mean()); M("scOneKRuleW", int((d < 0).sum()), "{}")
M("scOneKRuleN", len(s_), "{}")
# 9c. the early-revival rule (iteration 24): k = 65,536, PISCES without every-batch revival vs the official scaling runs
g24 = table(R("final/scaling_k65536_val.jsonl") + R("dev/iter24_k65536_regime_val.jsonl"))
if ("no_early_revival", 3.0) in g24:
s_, d, t = paired(g24, "no_early_revival", 3.0)
# time: the diagnostic ran in a later session than the official runs, so chain through PISCES timed in
# the diagnostic's own session: (rule / PISCES, same session) x (PISCES / official, scaling session)
g24own = table(R("dev/iter24_k65536_regime_val.jsonl")); gsc = table(R("final/scaling_k65536_val.jsonl"))
t = np.array([g24own[("no_early_revival", 3.0)][q]["seconds"] / g24own[("pisces", 3.0)][q]["seconds"]
* gsc[("pisces", 3.0)][q]["seconds"] / gsc[("official", 3.0)][q]["seconds"] for q in s_])
M("scSixtyFourKRuleD", d.mean(), "{:+.2f}"); M("scSixtyFourKRuleT", t.mean()); M("scSixtyFourKRuleW", int((d < 0).sum()), "{}")
M("scSixtyFourKRuleN", len(s_), "{}")
M("scSixtyFourKRuleSP", np.mean([r["splits"] for r in g24[("no_early_revival", 3.0)].values()]), "{:,.0f}")
s_, d, t = paired(g24, "tau_0.1", 3.0); M("scSixtyFourKTauD", d.mean(), "{:+.2f}")
s_, d, t = paired(g24, "tau_0.1_no_early", 3.0); M("scSixtyFourKBothD", d.mean(), "{:+.2f}")
M("scSixtyFourKBothSP", np.mean([r["splits"] for r in g24[("tau_0.1_no_early", 3.0)].values()]), "{:,.0f}")
# 9d. scaling figure overlay: the released rules at the two ends of the k range
with open(os.path.join(OUT, "scaling_rules.dat"), "w") as f:
f.write("k delta speedup\n")
for k_, tag in [(1024, "OneK"), (65536, "SixtyFourK")]:
if f"sc{tag}RuleD" in MAC:
f.write(f"{k_} {MAC[f'sc{tag}RuleD']:.4f} {1 / MAC[f'sc{tag}RuleT']:.4f}\n")
# 10. downstream IVF index
ivf = R("final/ivf_downstream.jsonl")
if ivf:
def interp_ndis(curve, target):
r = [c_["recall1"] for c_ in curve]; n_ = [c_["ndis"] for c_ in curve]
for i in range(1, len(r)):
if r[i] >= target > r[i - 1]:
w = (target - r[i - 1]) / (r[i] - r[i - 1]); return np.exp(np.log(n_[i - 1]) + w * (np.log(n_[i]) - np.log(n_[i - 1])))
return float("nan")
by = collections.defaultdict(list)
for r in ivf:
by[r["method"]].append(r)
for m, tag in [("official", "O"), ("pisces", "P")]:
rs = by.get(m, [])
if not rs:
continue
nps = [c_["nprobe"] for c_ in rs[0]["curve"]]
with open(os.path.join(OUT, f"ivf_{m}.dat"), "w") as f:
f.write("nprobe ndis recall1 recall10\n")
for i, npb in enumerate(nps):
f.write(f"{npb} {np.mean([r['curve'][i]['ndis'] for r in rs]):.1f} {np.mean([r['curve'][i]['recall1'] for r in rs]):.5f} "
f"{np.mean([r['curve'][i]['recall10'] for r in rs]):.5f}\n")
M(f"ivfImb{tag}", np.mean([r["imbalance"] for r in rs]), "{:.3f}")
M(f"ivfNdisNine{tag}", np.mean([interp_ndis(r["curve"], 0.9) for r in rs]), "{:.0f}")
i16 = nps.index(16) if 16 in nps else 0
M(f"ivfRecSixteen{tag}", np.mean([r["curve"][i16]["recall1"] for r in rs]), "{:.4f}")
M(f"ivfNdisSixteen{tag}", np.mean([r["curve"][i16]["ndis"] for r in rs]), "{:.0f}")
seeds = sorted({r["seed"] for r in by["official"]} & {r["seed"] for r in by.get("pisces", [])})
if seeds:
o = {r["seed"]: r for r in by["official"]}; p_ = {r["seed"]: r for r in by["pisces"]}
rd = [100 * (p_[s_]["curve"][i]["recall1"] - o[s_]["curve"][i]["recall1"]) for s_ in seeds for i in range(len(o[s_]["curve"]))]
nine = [interp_ndis(p_[s_]["curve"], 0.9) / interp_ndis(o[s_]["curve"], 0.9) for s_ in seeds]
M("ivfNdisNineRatio", np.nanmean(nine)); M("ivfSeeds", len(seeds), "{}")
M("ivfRecGainMax", max(rd), "{:+.2f}")
# recall@1 of the PISCES index at the e-means index' search cost (log-linear interpolation in ndis)
md = []
with open(os.path.join(OUT, "ivf_matched.dat"), "w") as f:
f.write("ndis diff seed\n")
for s_ in seeds:
pn = np.log([c_["ndis"] for c_ in p_[s_]["curve"]]); pr = [c_["recall1"] for c_ in p_[s_]["curve"]]
for c_ in o[s_]["curve"]:
if pn[0] <= np.log(c_["ndis"]) <= pn[-1]:
dd = 100 * (np.interp(np.log(c_["ndis"]), pn, pr) - c_["recall1"]); md.append(dd)
f.write(f"{c_['ndis']:.1f} {dd:.4f} {s_}\n")
M("ivfMatchedMean", np.mean(md), "{:+.2f}"); M("ivfMatchedMin", min(md), "{:+.2f}"); M("ivfMatchedMax", max(md), "{:+.2f}")
# 11. mechanism (one seed): revival timeline, cluster sizes, Lemma 2 on real clusters, swap audit
mf = os.path.join(ROOT, "results", "final", "mechanism_seed10.json")
if os.path.exists(mf):
mech = json.load(open(mf))
for m, tag in [("official", "O"), ("pisces", "P")]:
r = mech[m]; tot = r["total_steps"] or max([s_ for s_, _ in r["split_log"]] + [1])
with open(os.path.join(OUT, f"splits_{m}.dat"), "w") as f:
f.write("frac cum\n0 0\n"); c_ = 0
for st, nn in r["split_log"]:
c_ += nn; f.write(f"{(st + 1) / tot:.4f} {c_}\n")
sizes = np.array(r["sizes"])
with open(os.path.join(OUT, f"sizes_{m}.dat"), "w") as f:
f.write("size cdf\n")
for v in np.unique(np.concatenate([[0], np.unique(np.round(np.geomspace(1, sizes.max(), 60)))])):
f.write(f"{max(v, 0.5):g} {(sizes <= v).mean():.5f}\n")
M(f"mechSplits{tag}", sum(nn for _, nn in r["split_log"]), "{:,}")
M(f"mechEmpty{tag}", int((sizes == 0).sum()), "{}")
M(f"mechTiny{tag}", 100 * float((sizes < 10).mean()), "{:.2f}")
M(f"mechCV{tag}", float(sizes.std() / sizes.mean()), "{:.3f}")
M(f"mechSwaps{tag}", r["swaps"]["profitable_moves"], "{:,}")
M(f"mechSwapGain{tag}", 100 * r["swaps"]["predicted_gain_per_row"] / r["train_mse"], "{:.3f}")
lem = r["lemma"]
pred = np.array([q["predicted"] for q in lem]); ax_ = np.array([q["axis_split"] for q in lem]); fr = np.array([q["free_2means"] for q in lem])
M(f"mechLemRatio{tag}", float(np.median(ax_ / pred)), "{:.2f}")
M(f"mechLemFree{tag}", float(np.median(ax_ / fr)), "{:.2f}")
M(f"mechLemCorr{tag}", float(np.corrcoef(np.log(pred), np.log(ax_))[0, 1]), "{:.3f}")
with open(os.path.join(OUT, f"lemma_{m}.dat"), "w") as f:
f.write("pred axis free\n" + "".join(f"{a_:.4f} {b_:.4f} {c__:.4f}\n" for a_, b_, c__ in zip(pred, ax_, fr)))
M("mechSwapRatio", mech["official"]["swaps"]["profitable_moves"] / max(1, mech["pisces"]["swaps"]["profitable_moves"]), "{:.1f}")
# 12. every negative result, recomputed from the development logs (proxy: DEEP 250k, k = 4,096,
# validation rows, 3 epochs, 5 seeds), as a LaTeX table body
def dev(fn):
g = collections.defaultdict(dict)
for line in open(os.path.join(ROOT, "results", "dev", fn)):
r = json.loads(line)
if "epochs" in r:
g[(r.get("variant", r.get("method")), float(r["epochs"]))][r["seed"]] = r["val_mse"]
return g
NEG = [("iter2_swap.jsonl", "pe", "swap0.01", "streaming split--merge (swap) moves, 1\\% of $k$", 2),
("iter4_combine.jsonl", "sp_tau0.2_a1.4", "sp_tau0.2_a1.4_close0.5", "fresher closing window (last 50\\% of the final epoch)", 4),
("iter6_v3_candidates.jsonl", "v2", "v2_cm0.35", "children inherit 35\\% of the donor's mass each", 6),
("iter6_v3_candidates.jsonl", "v2", "v2_tau.3to.1", "revival threshold schedule $0.3\\to0.1$", 6),
("iter9b_graph_verified.jsonl", "v2", "v2_gv1pct", "graph-pruned assignment with label memory, self-verified", 9),
("iter13_growth.jsonl", "pisces_grow0", "pisces_grow3", "coarse-to-fine growth (3 doublings)", 13),
("iter15_candidates.jsonl", "pisces", "mom0.3", "heavy-ball momentum on centroid moves ($\\beta=0.3$)", 15),
("iter15_candidates.jsonl", "pisces", "probes8to16", "fewer probes early ($8\\to16$)", 15),
("iter17_hnsw.jsonl", "pisces", "h16_e16_32_r8", "HNSW over the centroids instead of IVF", 17),
("iter18_fp16_polish.jsonl", "pisces", "fp16", "fp16 IVF lists (same recall, faster scans)", 18),
("iter19_anneal.jsonl", "pol8", "an01", "annealed assignment to the runner-up ($\\varepsilon_0=0.01$)", 19),
("iter21_halfmean_batch.jsonl", "pisces", "half_half", "distribution-free half-mean split and score, $c\\pm\\E[\\mathrm{sign}(p)\\,e]$", 21),
("iter21_halfmean_batch.jsonl", "pisces", "abs_abs", "empirical axis half-mean $c\\pm\\E|p|\\,u_1$, score $N(\\E|p|)^2$", 21),
("iter21_halfmean_batch.jsonl", "pisces", "bs0.25to1.75", "batch-size schedule $0.25B\\to1.75B$", 21)]
with open(os.path.join(OUT, "negatives.tex"), "w") as f:
f.write("\\def\\negrows{%\n")
for fn, ref, cand, label, it in NEG:
if not os.path.exists(os.path.join(ROOT, "results", "dev", fn)):
continue
g = dev(fn); T = 3.0
o, r_, c_ = g[("official", T)], g[(ref, T)], g[(cand, T)]
s_ = sorted(set(o) & set(r_) & set(c_))
dr = np.mean([100 * (r_[i] / o[i] - 1) for i in s_]); dc = np.mean([100 * (c_[i] / o[i] - 1) for i in s_])
worse = sum(c_[i] > r_[i] for i in s_)
f.write(f"{label} & {it} & ${dr:+.2f}\\%$ & ${dc:+.2f}\\%$ & {worse}/{len(s_)}\\\\\n")
f.write("}\n")
# 13. optional closing polish (full scale, validation rows, seeds 1-5)
pol = table(R("deep1m_polish_time_to_quality_val.jsonl"))
for T, tag in [(1.0, "One"), (2.0, "Two"), (3.0, "Three"), (4.0, "Four")]:
s_, d, _ = paired(pol, "pisces_polish", T, base=("pisces", None))
if len(s_):
M(f"pol{tag}", d.mean(), "{:+.2f}"); M(f"polW{tag}", int((d < 0).sum()), "{}")
# 14. data for the analytic figures
# 14a. per-seed removal costs for the leave-one-out bar chart
with open(os.path.join(OUT, "ablation_seeds.dat") if abl else os.devnull, "w") as f:
f.write("idx cost\n")
for i, (m, tag) in enumerate(ABL):
if m == "pisces":
continue
s_, d2, _ = paired(abl, m, 3.0, base=("pisces", None))
f.write("".join(f"{i} {v:.4f}\n" for v in d2))
# 14b. real clusters for the split-geometry figure
if os.path.exists(mf):
for i, ex in enumerate(mech["pisces"].get("split_examples", [])[:3]):
with open(os.path.join(OUT, f"splitex{i}_pts.dat"), "w") as f:
f.write("a b\n" + "".join(f"{p_[0]:.4f} {p_[1]:.4f}\n" for p_ in ex["points"]))
for kind, key in [("pisces", "pisces"), ("kmeans", "kmeans2")]:
with open(os.path.join(OUT, f"splitex{i}_{kind}.dat"), "w") as f:
f.write("a b\n" + "".join(f"{p_[0]:.4f} {p_[1]:.4f}\n" for p_ in ex[key]))
M(f"splitexN{'ABC'[i]}", ex["N"], "{:,}")
M(f"splitexR{'ABC'[i]}", ex["lam2"] / ex["lam1"], "{:.2f}")
# 14c. time breakdown
tb = os.path.join(ROOT, "results", "final", "time_breakdown.json")
if os.path.exists(tb):
T_ = json.load(open(tb))
with open(os.path.join(OUT, "time_breakdown.dat"), "w") as f:
f.write("idx name search build stats other wall\n")
for i, (m, nm) in enumerate([("official", "e-means"), ("pisces_v10", "PISCES-v1.0"), ("pisces", "PISCES")]):
r = T_[m]
f.write(f"{i} {nm} {r['assignment search']:.2f} {r['index build']:.2f} {r['statistics']:.2f} {r['other']:.2f} {r['wall']:.2f}\n")
M(f"tb{'OVP'[i]}Wall", r["wall"], "{:.0f}"); M(f"tb{'OVP'[i]}Search", 100 * r["assignment search"] / r["wall"], "{:.0f}")
open(os.path.join(ROOT, "paper", "macros.tex"), "w").write("\n".join(macros) + "\n")
print(f"wrote {len(macros)} macros and data files to paper/data")