"""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))