File size: 5,953 Bytes
1e80dec | 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 | """Derived merge statistics (the `summary` table), computed only from evaluations.csv + merges.csv.
For each merge row and each (task, dataset_config, split, metric) it was evaluated on, the parent
and naive-merge values are looked up in the SAME experiment_id. Nothing is computed when a value
is missing. Losses are signed so that positive always means "worse than the best parent":
lower-is-better (NLL): loss = value - min(A, B)
higher-is-better (acc): loss = max(A, B) - value
merge_gain = naive_merge_loss - method_merge_loss (positive: the method helped)
merge_success = method_merge_loss < 0 (strictly beats the best parent)
alignment_gain = loss(unaligned twin) - loss(aligned) (same pair, method, config otherwise)
NLL and accuracy outcomes are never mixed: each summary row carries exactly one metric.
"""
import json
import pandas as pd
from .schema import SUMMARY
KEY = ["experiment_id", "task_name", "dataset_config", "split", "metric_name"]
def _loss(value, best, direction):
if pd.isna(value) or pd.isna(best):
return float("nan")
return value - best if direction == "lower" else best - value
def _naive_key(m):
"""The naive twin of a merge: plain average, no alignment, no transport, same pair + experiment."""
return (m["experiment_id"], m["parent_a"], m["parent_b"])
def summarise(merges: pd.DataFrame, evals: pd.DataFrame) -> pd.DataFrame:
ev = evals.copy()
for c in KEY:
ev[c] = ev[c].fillna("")
ev["metric_value"] = pd.to_numeric(ev["metric_value"], errors="coerce")
# parent / any-model scores keyed by (KEY..., model_id)
by_model = ev.groupby(KEY + ["model_id"])["metric_value"].mean()
merged = ev[ev["merge_id"].fillna("") != ""]
by_merge = merged.groupby(KEY + ["merge_id"])["metric_value"].mean()
direction = ev.groupby(KEY)["metric_direction"].first()
m = merges.set_index("merge_id")
naive = {}
for mid, r in m.iterrows():
if (r["merge_method"] == "average" and r["alignment_method"] == "none"
and str(r["vocabulary_transport"]) in ("False", "false", "0", "")
and str(r["is_control"]) not in ("True", "true", "1")):
naive.setdefault(_naive_key(r.to_dict() | {"merge_id": mid}), mid)
# unaligned twin of an aligned merge: same pair, method, transport flag and alpha
def twin_key(r):
return (r["experiment_id"], r["parent_a"], r["parent_b"], r["merge_method"],
str(r["vocabulary_transport"]), str(r["merge_alpha"]))
unaligned = {}
for mid, r in m.iterrows():
if r["alignment_method"] == "none":
unaligned.setdefault(twin_key(r), mid)
rows = []
for (eid, task, cfg, split, metric, mid), val in by_merge.items():
if mid not in m.index:
continue
r = m.loc[mid]
k = (eid, task, cfg, split, metric)
d = direction.get(k, "higher")
a = by_model.get(k + (r["parent_a"],), float("nan"))
b = by_model.get(k + (r["parent_b"],), float("nan"))
best = (min(a, b) if d == "lower" else max(a, b)) if not (pd.isna(a) or pd.isna(b)) else float("nan")
nid = naive.get((eid, r["parent_a"], r["parent_b"]))
nval = by_merge.get(k + (nid,), float("nan")) if nid else float("nan")
lm, ln = _loss(val, best, d), _loss(nval, best, d)
align_gain = float("nan")
if r["alignment_method"] != "none":
tid = unaligned.get(twin_key(r))
if tid:
tval = by_merge.get(k + (tid,), float("nan"))
align_gain = _loss(tval, best, d) - lm
beats = lambda p: (val < p if d == "lower" else val > p) if not pd.isna(p) else None
rows.append({
"merge_id": mid, "experiment_id": eid, "experiment_family": r["experiment_family"],
"merge_method": r["merge_method"], "alignment_method": r["alignment_method"],
"vocabulary_transport": r["vocabulary_transport"],
"initialisation_relationship": r["initialisation_relationship"],
"tokenizer_relationship": r["tokenizer_relationship"], "parameters": r["parameters"],
"task_name": task, "dataset_config": cfg, "split": split, "metric_name": metric,
"metric_direction": d, "parent_a_value": a, "parent_b_value": b,
"best_parent_value": best, "naive_value": nval, "method_value": val,
"naive_merge_loss": ln, "method_merge_loss": lm,
"merge_gain": ln - lm if not (pd.isna(ln) or pd.isna(lm)) else float("nan"),
"merge_success": (lm < 0) if not pd.isna(lm) else None,
"beats_parent_a": beats(a), "beats_parent_b": beats(b),
"task_retention": (val / best) if d == "higher" and not pd.isna(best) and best else float("nan"),
"alignment_gain": align_gain,
"copies_parent": r["copies_parent"], "is_control": r["is_control"],
"evaluation_status": r["evaluation_status"],
})
return pd.DataFrame(rows, columns=SUMMARY)
def coverage(merges, evals, summary) -> dict:
"""Explicit coverage statistics for the dataset card: never an assumed number of complete rows."""
out = {"merges": len(merges), "evaluations": len(evals), "summary_rows": len(summary)}
out["merges_by_family"] = merges["experiment_family"].value_counts().to_dict()
out["merges_by_method"] = merges["merge_method"].value_counts().to_dict()
out["merges_by_status"] = merges["evaluation_status"].value_counts().to_dict()
have_eval = set(evals["merge_id"].dropna()) - {""}
out["merges_with_any_evaluation"] = int(merges["merge_id"].isin(have_eval).sum())
s = summary.dropna(subset=["method_merge_loss"])
out["summary_rows_with_parent_baseline"] = len(s)
out["merge_success_rows"] = int((s["merge_success"] == True).sum()) # noqa: E712
return json.loads(json.dumps(out, default=int))
|