"""Construct routing states and candidate outcome rows from dataset/responses.parquet. States per query q (20 models): k=0 : 1 query-only state (candidates: all 20 models, Q_best = 0 baseline = "no response yet") k=1 : 20 one-model states (complete) (candidates: the other 19 -> full one-model candidate matrix, nothing downsampled) k=2 : 12 sampled ordered pairs (8 uniform random, 2 'weak' pairs = two lowest-Q models, 2 'contains-best' pairs) k=3 : 6 sampled ordered triples (4 uniform random, 1 weak, 1 contains-best) `sample_stratum` records how each sampled state was drawn so analyses can restrict to the unbiased 'random' stratum. Router-visible columns are prefixed feat_ and are computed ONLY from the called models' responses (generation-time signals, no quality, no candidate information). Label columns are prefixed label_ (offline outcomes). Outputs: dataset/states.parquet, dataset/candidates.parquet, dataset/response_features.parquet, dataset/state_build_manifest.json Usage: python build_states.py [--limit-queries N] """ import argparse import hashlib import json import re import sys from multiprocessing import get_context from pathlib import Path import numpy as np import pandas as pd ROOT = Path("/mnt/localssd/seqroute1m") LAMBDAS = [0.0, 0.1, 0.25, 0.5, 1.0, 2.0] SEED = 20261010 D = {} def final_text(t, reasoning): t = t or "" if "" in t: return t.rsplit("", 1)[1].strip() return t.strip() def toks(s): return set(re.findall(r"\w+", s.lower())[:300]) def norm_ans(a): return None if a is None or (isinstance(a, float) and np.isnan(a)) else re.sub(r"\s+", " ", str(a).strip().lower()) def init(path, models): d = pd.read_parquet(path) D["models"] = models D["m2i"] = {m: i for i, m in enumerate(models)} D["g"] = {q: g for q, g in d.groupby("query_id", sort=False)} def per_query(qid): models, m2i = D["models"], D["m2i"] n = len(models) g = D["g"][qid].set_index("model_id") g = g.reindex(models) Q = g.Q.to_numpy(float) cn = g.cost_norm.to_numpy(float) gs = g.gpu_seconds.to_numpy(float) ctok = g.completion_tokens.to_numpy(float) lc = g.label_confidence.to_numpy(float) fam = g.task_family.iloc[0] src = g.source_dataset.iloc[0] split = g.split.iloc[0] # response-visible features f_logtok = np.log1p(ctok) f_meanlp, f_p05, f_frac2 = g.mean_lp.to_numpy(float), g.p05_lp.to_numpy(float), g.frac_lp_lt_2.to_numpy(float) f_ent = g.mean_entropy_top5.to_numpy(float) f_trunc = (g.finish_reason.to_numpy() == "length").astype(float) f_parse = g.parse_ok.astype(float).to_numpy() ans = [norm_ans(a) for a in g.answer_extracted] ts = [toks(final_text(t, None)) for t in g.text] rng = np.random.default_rng(int(hashlib.sha1(f"{SEED}|{qid}".encode()).hexdigest()[:8], 16)) def jac(i, j): a, b = ts[i], ts[j] return len(a & b) / max(len(a | b), 1) def feats(called): k = len(called) if k == 0: return dict(feat_n_called=0) c = list(called) out = dict(feat_n_called=k, feat_last_model=models[c[-1]], feat_mean_log_tokens=float(np.mean(f_logtok[c])), feat_max_log_tokens=float(np.max(f_logtok[c])), feat_mean_lp=float(np.nanmean(f_meanlp[c])) if not np.all(np.isnan(f_meanlp[c])) else np.nan, feat_min_p05_lp=float(np.nanmin(f_p05[c])) if not np.all(np.isnan(f_p05[c])) else np.nan, feat_mean_frac_lp_lt2=float(np.nanmean(f_frac2[c])) if not np.all(np.isnan(f_frac2[c])) else np.nan, feat_mean_entropy=float(np.nanmean(f_ent[c])) if not np.all(np.isnan(f_ent[c])) else np.nan, feat_any_truncated=float(f_trunc[c].max()), feat_frac_parse_ok=float(np.mean(f_parse[c])), feat_spent_cost_norm=float(np.sum(cn[c])), feat_spent_gpu_s=float(np.sum(gs[c])), feat_last_mean_lp=float(f_meanlp[c[-1]]), feat_last_log_tokens=float(f_logtok[c[-1]]), feat_last_truncated=float(f_trunc[c[-1]]), feat_last_parse_ok=float(f_parse[c[-1]])) if k >= 2: av = [ans[i] for i in c if ans[i] is not None] out["feat_n_distinct_answers"] = float(len(set(av))) if len(av) >= 2 else np.nan out["feat_answer_agreement"] = float(max(av.count(x) for x in set(av)) / len(av)) if len(av) >= 2 else np.nan js = [jac(a, b) for ai, a in enumerate(c) for b in c[ai + 1:]] out["feat_text_jaccard_mean"], out["feat_text_jaccard_max"] = float(np.mean(js)), float(np.max(js)) return out order_best = np.argsort(-Q, kind="stable") order_weak = np.argsort(Q, kind="stable") states = [((), "all")] states += [((i,), "all") for i in range(n)] seen = set() def add_state(t, stratum): if t not in seen: seen.add(t); states.append((t, stratum)) allp = [(i, j) for i in range(n) for j in range(n) if i != j] for idx in rng.permutation(len(allp))[:8]: add_state(allp[idx], "random") w = list(order_weak[:2]); add_state((w[0], w[1]) if rng.random() < .5 else (w[1], w[0]), "weak") w2 = [int(order_weak[2]), int(order_weak[3])]; add_state(tuple(w2), "weak") for _ in range(2): b = int(order_best[0]); o = int(rng.choice([x for x in range(n) if x != b])) add_state((b, o) if rng.random() < .5 else (o, b), "contains_best") for _ in range(4): add_state(tuple(int(x) for x in rng.permutation(n)[:3]), "random") add_state(tuple(int(x) for x in order_weak[:3]), "weak") b = int(order_best[0]); o = [int(x) for x in rng.permutation([x for x in range(n) if x != b])[:2]] t = [b] + o; rng.shuffle(t); add_state(tuple(t), "contains_best") S, C = [], [] for called, stratum in states: called = tuple(int(x) for x in called) k = len(called) qbest = 0.0 if k == 0 else float(np.nanmax(Q[list(called)])) cand = [j for j in range(n) if j not in called and not np.isnan(Q[j])] sid = f"{qid}:{k}:" + "-".join(str(i) for i in called) delta = Q[cand] - qbest pg = np.maximum(delta, 0.0) row = dict(state_id=sid, query_id=qid, split=split, task_family=fam, source_dataset=src, k=k, sample_stratum=stratum, called_models=[models[i] for i in called], n_candidates=len(cand), label_Q_best=qbest, label_Q_called=[float(Q[i]) for i in called], label_best_next_gain=float(pg.max()) if len(cand) else 0.0, label_best_next_model=models[cand[int(np.argmax(pg))]] if len(cand) and pg.max() > 0 else "STOP") for lam in LAMBDAS: u = pg - lam * cn[cand] j = int(np.argmax(u)) if len(cand) else -1 if j >= 0 and u[j] > 0: row[f"label_oracle_action_l{lam}"], row[f"label_oracle_utility_l{lam}"], row[f"label_oracle_gain_l{lam}"] = models[cand[j]], float(u[j]), float(pg[j]) else: row[f"label_oracle_action_l{lam}"], row[f"label_oracle_utility_l{lam}"], row[f"label_oracle_gain_l{lam}"] = "STOP", 0.0, 0.0 row.update(feats(called)) S.append(row) C.append(pd.DataFrame(dict(state_id=sid, query_id=qid, k=k, candidate_model=[models[j] for j in cand], label_Q=Q[cand], label_delta_Q=delta, label_positive_gain=pg, label_improves=(delta > 0), cost_norm=cn[cand], cost_gpu_s=gs[cand], label_completion_tokens=ctok[cand], label_confidence=lc[cand]))) resp = pd.DataFrame(dict(query_id=qid, model_id=models, feat_log_tokens=f_logtok, feat_mean_lp=f_meanlp, feat_p05_lp=f_p05, feat_frac_lp_lt2=f_frac2, feat_mean_entropy=f_ent, feat_truncated=f_trunc, feat_parse_ok=f_parse)) return pd.DataFrame(S), pd.concat(C, ignore_index=True), resp def main(): ap = argparse.ArgumentParser() ap.add_argument("--limit-queries", type=int, default=0) ap.add_argument("--procs", type=int, default=64) ap.add_argument("--only-20k", action="store_true", default=True) a = ap.parse_args() models = [m["id"] for m in json.load(open(ROOT / "manifests/models.json"))] path = ROOT / "dataset/responses.parquet" d = pd.read_parquet(path, columns=["query_id", "model_id", "Q", "in_20k"]) d = d[d.in_20k.astype(bool)] cnt = d.dropna(subset=["Q"]).groupby("query_id").model_id.nunique() complete = sorted(cnt[cnt == len(models)].index) print(f"queries with all {len(models)} responses scored: {len(complete)} / {d.query_id.nunique()}", flush=True) if a.limit_queries: complete = complete[:a.limit_queries] ctx = get_context("fork") parts_S, parts_C, parts_R = [], [], [] init(path, models) # load once in the parent; forked workers share it copy-on-write with ctx.Pool(a.procs) as pool: for i, (s, c, r) in enumerate(pool.imap(per_query, complete, chunksize=8)): parts_S.append(s); parts_C.append(c); parts_R.append(r) if (i + 1) % 2000 == 0: print(f" {i + 1} queries", flush=True) S = pd.concat(parts_S, ignore_index=True) C = pd.concat(parts_C, ignore_index=True) R = pd.concat(parts_R, ignore_index=True) out = ROOT / "dataset" S.to_parquet(out / "states.parquet", compression="zstd", index=False) C["candidate_model"] = C.candidate_model.astype("category") C.to_parquet(out / "candidates.parquet", compression="zstd", index=False) R.to_parquet(out / "response_features.parquet", compression="zstd", index=False) json.dump(dict(n_queries=len(complete), n_states=len(S), n_candidate_rows=len(C), lambdas=LAMBDAS, states_per_k=S.k.value_counts().sort_index().to_dict(), seed=SEED, baseline_Q_best_empty_state=0.0), open(out / "state_build_manifest.json", "w"), indent=1) print(f"states {len(S)}, candidate rows {len(C)}, queries {len(complete)}") if __name__ == "__main__": main()