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