Download scripts/calculate_metrics.py from Cross-Mergeability/model-merging-benchmark: direct link, hf CLI and curl.
- Browser
- Download file 5.95 kB
-
https://huggingface.co/datasets/Cross-Mergeability/model-merging-benchmark/resolve/main/scripts/calculate_metrics.py
- Command line
-
hf download hf://datasets/Cross-Mergeability/model-merging-benchmark/scripts/calculate_metrics.py
-
curl -L -o calculate_metrics.py https://huggingface.co/datasets/Cross-Mergeability/model-merging-benchmark/resolve/main/scripts/calculate_metrics.py
5.95 kB
| """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)) | |