File size: 9,840 Bytes
8ad880b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Audits and the final dataset report.  Writes reports/dataset_report.md, reports/audit.json and prints the verdict line.
Usage: python audit_report.py
"""
import json
import re
import sys
from pathlib import Path

import numpy as np
import pandas as pd

ROOT = Path("/mnt/localssd/seqroute1m")
(ROOT / "reports").mkdir(exist_ok=True)
models = json.load(open(ROOT / "manifests/models.json"))
mid = [m["id"] for m in models]
mfam = {m["id"]: m["family"] for m in models}
q = pd.read_parquet(ROOT / "queries/queries_20k.parquet", columns=["query_id", "task_family", "source_dataset", "split", "group_id"])
R = pd.read_parquet(ROOT / "dataset/responses.parquet")
S = pd.read_parquet(ROOT / "dataset/states.parquet")
C = pd.read_parquet(ROOT / "dataset/candidates.parquet")
RF = pd.read_parquet(ROOT / "dataset/response_features.parquet")
audit, md = {}, []


def P(s=""):
    md.append(s)


def tbl(df, floatfmt=3):
    return df.to_markdown(floatfmt=f".{floatfmt}f") if hasattr(df, "to_markdown") else str(df)


# ---------------------------------------------------------------------- audits
n_q, n_m = len(q), len(mid)
R20 = R[R.in_20k.astype(bool)]
expected = n_q * n_m
audit["expected_responses"] = expected
audit["responses_present"] = int(len(R20))
audit["response_coverage"] = len(R20) / expected
audit["quality_coverage"] = float(R20.Q.notna().sum() / expected)
audit["duplicate_query_model"] = int(R.duplicated(["query_id", "model_id"]).sum())
audit["cost_incomplete"] = int(R20.gpu_seconds.isna().sum() + R20.completion_tokens.isna().sum() + R20.latency_s.isna().sum())
sid = set(S.state_id)
audit["candidates_without_state"] = int((~C.state_id.isin(sid)).sum())
key = set(zip(R20.query_id, R20.model_id))
audit["candidates_unresolved"] = int(sum((a, b) not in key for a, b in zip(C.query_id.head(2_000_000), C.candidate_model.astype(str).head(2_000_000))))
called_unres = 0
for lst, qid in zip(S.called_models.head(500_000), S.query_id.head(500_000)):
    for m in lst:
        called_unres += (qid, m) not in key
audit["called_models_unresolved"] = int(called_unres)
# split validity: no query or group in two splits
qs = q.groupby("query_id").split.nunique()
gs = q.groupby("group_id").split.nunique()
audit["queries_in_multiple_splits"] = int((qs > 1).sum())
audit["groups_in_multiple_splits"] = int((gs > 1).sum())
audit["split_counts"] = q.split.value_counts().to_dict()
# separation of features from outcomes
feat_cols = [c for c in S.columns if c.startswith("feat_")]
label_cols = [c for c in S.columns if c.startswith("label_")]
audit["state_feature_columns"] = feat_cols
audit["feature_label_name_overlap"] = [c for c in feat_cols if re.search(r"(?i)label|delta|gain|Q_best|^feat_Q", c)]
rng = np.random.default_rng(0)
chk = S[S.k == 1].sample(min(2000, int((S.k == 1).sum())), random_state=0)
rfi = RF.set_index(["query_id", "model_id"])
mism = 0
for r in chk.itertuples():
    f = rfi.loc[(r.query_id, r.called_models[0])]
    if not (np.isclose(r.feat_mean_lp, f.feat_mean_lp, equal_nan=True) and np.isclose(r.feat_mean_log_tokens, f.feat_log_tokens)):
        mism += 1
audit["feature_recompute_mismatches_k1"] = mism
# leakage test: k=0 states must carry no features at all
audit["k0_states_with_features"] = int(S[S.k == 0][[c for c in feat_cols if c != "feat_n_called"]].notna().any(axis=1).sum())
icc = json.load(open(ROOT / "manifests/judge_reliability_icc.json")) if (ROOT / "manifests/judge_reliability_icc.json").exists() else {}
audit["judge_reliability_documented"] = bool(icc)
audit["unparsed_judge_responses"] = int(((R20.Q_source == "judge") & R20.Q.isna()).sum())
gates = dict(response_coverage=audit["response_coverage"] >= 0.995, quality_coverage=audit["quality_coverage"] >= 0.995, no_duplicates=audit["duplicate_query_model"] == 0,
             candidates_resolve=audit["candidates_without_state"] == 0 and audit["candidates_unresolved"] == 0 and audit["called_models_unresolved"] == 0, cost_complete=audit["cost_incomplete"] == 0,
             judge_reliability_documented=audit["judge_reliability_documented"], split_valid=audit["queries_in_multiple_splits"] == 0 and audit["groups_in_multiple_splits"] == 0,
             features_separated=not audit["feature_label_name_overlap"] and audit["feature_recompute_mismatches_k1"] == 0 and audit["k0_states_with_features"] == 0)
audit["gates"] = gates
ready = all(gates.values())

# ---------------------------------------------------------------------- report
P("# SeqRoute-1M dataset report\n")
P(f"Generated {pd.Timestamp.now():%F %T}. Models: {n_m}. Queries in generation set: {n_q}.\n")
P("## Audit gates\n")
for k, v in gates.items():
    P(f"- {'PASS' if v else 'FAIL'}: {k}")
P(f"\nDetails: `reports/audit.json`.\n")
dq = R20.groupby("query_id").model_id.nunique()
comp = int(((dq == n_m) & (R20.dropna(subset=["Q"]).groupby("query_id").model_id.nunique().reindex(dq.index).fillna(0) == n_m)).sum())
P(f"## Completion\n\n- Completed distinct queries (all {n_m} responses present and scored): **{comp}** / {n_q}")
P(f"- Response coverage: {audit['response_coverage']:.4f}; quality coverage: {audit['quality_coverage']:.4f}\n")
rm = R20.groupby("model_id").agg(responses=("query_id", "size"), quality_scored=("Q", lambda x: x.notna().sum()), mean_Q=("Q", "mean"), truncated_frac=("finish_reason", lambda x: (x == "length").mean())).reindex(mid)
P("### Responses per model\n\n" + tbl(rm))
P("\n## Task distribution (20k generation set)\n\n" + tbl(q.groupby(["task_family", "source_dataset"]).size().rename("n_queries").to_frame().reset_index(), 0))
P("\n## Mean quality by model x task family\n\n" + tbl(R20.pivot_table(index="task_family", columns="model_id", values="Q", aggfunc="mean")[mid], 2))
P(f"\n## States and candidate rows\n\n- States: {len(S):,} (per k: {S.k.value_counts().sort_index().to_dict()})\n- Candidate rows: {len(C):,}\n")
qs_ = C.label_delta_Q.quantile([.01, .05, .25, .5, .75, .95, .99]).rename("delta_Q quantile").to_frame()
P("## delta_Q distribution (all candidate rows)\n\n" + tbl(qs_) + f"\n\nShare delta_Q>0: {(C.label_delta_Q > 0).mean():.4f}; =0: {(C.label_delta_Q == 0).mean():.4f}; <0: {(C.label_delta_Q < 0).mean():.4f}\n")
byk = C.groupby("k").agg(rows=("label_delta_Q", "size"), mean_delta=("label_delta_Q", "mean"), sd_delta=("label_delta_Q", "std"), pos_rate=("label_improves", "mean"), mean_positive_gain=("label_positive_gain", "mean"))
P("### By number of called models\n\n" + tbl(byk))
Cf = C.merge(S[["state_id", "task_family", "split"]], on="state_id")
P("\n## Positive-improvement rate and mean positive gain by task family and k\n")
pr = Cf.groupby(["task_family", "k"]).label_improves.mean().unstack()
P(tbl(pr))
P("\n## Oracle best-next-model gain by task (mean over states; lambda=0 means cost-free)\n")
og = S[S.k >= 1].groupby(["task_family", "k"]).label_best_next_gain.mean().unstack()
P(tbl(og))
P("\n### Cost-aware oracle (k=1 states): mean oracle net utility and STOP rate by lambda\n")
rows = []
for lam in [0.0, 0.1, 0.25, 0.5, 1.0, 2.0]:
    s1 = S[S.k == 1]
    rows.append(dict(lam=lam, mean_utility=s1[f"label_oracle_utility_l{lam}"].mean(), mean_gain=s1[f"label_oracle_gain_l{lam}"].mean(), stop_rate=(s1[f"label_oracle_action_l{lam}"] == "STOP").mean()))
P(tbl(pd.DataFrame(rows).set_index("lam")))
# same-family vs cross-family gains on one-model states
c1 = C[C.k == 1].merge(S[S.k == 1][["state_id", "called_models", "task_family"]], on="state_id")
c1["called"] = c1.called_models.map(lambda l: l[0])
c1["same_family"] = c1.called.map(mfam) == c1.candidate_model.astype(str).map(mfam)
sf = c1.groupby(["same_family"]).agg(rows=("label_delta_Q", "size"), mean_delta=("label_delta_Q", "mean"), pos_rate=("label_improves", "mean"), mean_positive_gain=("label_positive_gain", "mean"))
P("\n## Same-family vs cross-family candidates (one-model states)\n\n" + tbl(sf))
P("\n" + tbl(c1.groupby(["task_family", "same_family"]).label_positive_gain.mean().unstack()))
P("\n## Cost distributions\n")
cst = R20.groupby("model_id").agg(gpu_s_median=("gpu_seconds", "median"), gpu_s_p95=("gpu_seconds", lambda x: x.quantile(.95)), gpu_s_total=("gpu_seconds", "sum"), latency_median=("latency_s", "median"),
                                    latency_p95=("latency_s", lambda x: x.quantile(.95)), compl_tok_median=("completion_tokens", "median"), compl_tok_p95=("completion_tokens", lambda x: x.quantile(.95))).reindex(mid)
P(tbl(cst, 4))
P("\nNormalised cost (cost_norm = gpu_seconds / family median train cost) quantiles: " + json.dumps({str(k): round(float(v), 3) for k, v in R20.cost_norm.quantile([.05, .25, .5, .75, .95]).items()}))
P("\n## Judge reliability\n")
if icc:
    P(tbl(pd.DataFrame(icc).T))
jc = ROOT / "manifests/judge_validation.json"
if jc.exists():
    P("\n```json\n" + jc.read_text() + "\n```")
P(f"\nUnparsed judge responses after retries: {audit['unparsed_judge_responses']}.\n")
gen_stats = [json.load(open(f)) for f in (ROOT / "responses").glob("*.stats.json") if not f.name.endswith(".smoke.stats.json")]
gpu_h = sum(s["gpu_seconds"] for s in gen_stats) / 3600
wall_h = sum(s["gen_wall_s"] + s["startup_s"] for s in gen_stats) / 3600
P("## Compute\n")
P(f"- Generation GPU-hours (8 GPUs x measured generation wall time, excluding smoke): {gpu_h:.1f}\n- Generation wall-clock hours incl. server startup: {wall_h:.1f}")
extra = []
for f in (ROOT / "scores/judge").glob("stats_*.json"):
    extra.append(json.load(open(f)))
P(f"- Judge passes: {len(extra)} runs, {sum(e['wall_s'] for e in extra) / 3600:.2f} wall hours (8 GPUs each)")
P(f"\n## Verdict\n\nDATASET READY FOR ROUTER TRAINING: {'YES' if ready else 'NO'}")
(ROOT / "reports/dataset_report.md").write_text("\n".join(md))
json.dump(audit, open(ROOT / "reports/audit.json", "w"), indent=1, default=str)
print(json.dumps(gates, indent=1))
print(f"DATASET READY FOR ROUTER TRAINING: {'YES' if ready else 'NO'}")