File size: 6,501 Bytes
399463d | 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 | """Per-pair parameter coverage, from config files alone -- and the vocabulary mismatch it exposes.
`MergeBench/Llama-3.2-3B_math` declares `vocab_size = 128320`; its four siblings declare 128256. The
math expert added 64 tokens during fine-tuning. That is not a curiosity, it is a mergeability fact:
* `embed_tokens` (and `lm_head`, when untied) have DIFFERENT SHAPES from every sibling, so no
elementwise merge operator is defined on them. A merge of that pair either drops the embedding
or needs the vocabulary handling the Beetle project's `transport` arm exists for.
* the behaviour family is undefined for those pairs -- the two models emit logits over different
vocabularies, so a KL or a top-k overlap between them compares incomparable things. The sweep's
`behaviour_block` correctly returns nothing; this module records WHY.
* `param_coverage` for those pairs is NOT 1.0, and the sweep's hardcoded 1.0 was wrong.
Everything here is derived from `config.json` -- a few kB per model -- because the only dimension
that actually differs is the vocabulary, and the tensors it governs are exactly `embed_tokens` and
`lm_head`. So this runs in seconds, needs no weights, and can be applied retroactively to families
whose checkpoints were deleted long ago.
PYTHONPATH=src python -m mergeschool.mergebench.coverage
"""
from __future__ import annotations
import json
import time
import numpy as np
import pandas as pd
from mergeschool import paths
from mergeschool.mergebench import suite as SU
OUT = paths.RESULTS / "mergebench"
log = lambda *a: print(f"[cov {time.strftime('%H:%M:%S')}]", *a, flush=True) # noqa: E731
COLS = ["vocab_a", "vocab_b", "vocab_match", "n_params_est", "n_params_vocab_governed",
"param_coverage_cfg", "behaviour_defined", "coverage_note"]
def model_config(repo):
from huggingface_hub import hf_hub_download
with open(hf_hub_download(repo, "config.json")) as fh:
return json.load(fh)
def _shape_facts(c):
V = int(c.get("vocab_size") or 0)
d = int(c.get("hidden_size") or c.get("d_model") or c.get("n_embd") or 0)
L = int(c.get("num_hidden_layers") or c.get("n_layers") or c.get("n_layer") or 0)
inter = int(c.get("intermediate_size") or 4 * d)
tied = bool(c.get("tie_word_embeddings", False))
kv = int(c.get("num_key_value_heads") or c.get("num_attention_heads") or 1)
heads = int(c.get("num_attention_heads") or 1)
hd = d // heads if heads else 0
attn = d * d + 2 * (d * kv * hd) + d * d # q, k, v, o
mlp = 3 * d * inter # gate, up, down (SwiGLU)
body = L * (attn + mlp)
vocab_governed = V * d * (1 if tied else 2)
return {"V": V, "d": d, "tied": tied, "body": body, "vocab_governed": vocab_governed,
"total": body + vocab_governed}
def compute(doc=None):
doc = doc or SU.enumerate_suite()
rows = []
for fam in SU.families(doc):
experts = doc["families"][fam]
facts = {}
for dom, repo in sorted(experts.items()):
try:
facts[dom] = _shape_facts(model_config(repo))
except Exception as e:
log(f" {repo}: config unavailable ({type(e).__name__}: {e})")
doms = sorted(facts)
vs = {d: facts[d]["V"] for d in doms}
odd = {d: v for d, v in vs.items() if v != max(set(vs.values()), key=list(vs.values()).count)}
if odd:
log(f" {fam}: VOCAB MISMATCH {odd} vs {sorted(set(vs.values()))}")
for i, a in enumerate(doms):
for b in doms[i + 1:]:
fa, fb = facts[a], facts[b]
match = fa["V"] == fb["V"]
# A merge is spliced over the BASE model's tensors, so coverage is measured against
# parent A -- the same convention `emit_lm._shared_params` uses.
gov = fa["vocab_governed"]
cov = 1.0 if match else float((fa["total"] - gov) / fa["total"])
note = ("" if match else
f"vocab {fa['V']} vs {fb['V']}: embed_tokens"
+ ("" if fa["tied"] else " and lm_head")
+ " differ in shape, so no elementwise merge operator is defined on them "
"and the behaviour family compares different vocabularies. "
f"{gov/fa['total']:.1%} of parameter mass is affected.")
rows.append({"pair_id": f"{fam}__{a}__{b}", "family": fam,
"vocab_a": fa["V"], "vocab_b": fb["V"], "vocab_match": bool(match),
"n_params_est": int(fa["total"]),
"n_params_vocab_governed": int(gov),
"param_coverage_cfg": cov,
"behaviour_defined": bool(match), "coverage_note": note})
d = pd.DataFrame(rows)
OUT.mkdir(parents=True, exist_ok=True)
d.to_csv(OUT / "table_param_coverage.csv", index=False)
return d
def merge_into_shards(d):
n = 0
by = d.set_index("pair_id")
for shard in sorted(OUT.glob("pairs_w*.csv")):
t = pd.read_csv(shard)
if "pair_id" not in t.columns:
continue
for c in COLS:
if c not in t.columns:
# dtype chosen up front: assigning a bool or a string into a float64 column is
# deprecated in pandas and would become an error.
t[c] = pd.Series([pd.NA] * len(t), dtype="object") \
if c in ("vocab_match", "behaviour_defined", "coverage_note") else np.nan
touched = False
for i, pid in enumerate(t.pair_id):
if pid in by.index:
r = by.loc[pid]
for c in COLS:
t.at[i, c] = r[c]
# the sweep hardcoded 1.0; replace it with the measured value
t.at[i, "param_coverage"] = r["param_coverage_cfg"]
touched = True
n += 1
if touched:
t.to_csv(shard, index=False)
log(f" merged into {shard.name}")
return n
def main():
d = compute()
bad = d[~d.vocab_match]
log(f"{len(d)} pairs; {len(bad)} with a vocabulary mismatch")
for _, r in bad.iterrows():
log(f" {r.pair_id}: vocab {r.vocab_a} vs {r.vocab_b}, "
f"param_coverage {r.param_coverage_cfg:.4f}")
log(f"merged into {merge_into_shards(d)} rows")
if __name__ == "__main__":
main()
|