File size: 6,948 Bytes
6a30e85 | 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 | """`fig_mergebench_scale.png` -- MergeBench at scale, all eight base families.
Two heatmaps, families x domains:
(a) the published five-expert (Model soup / Weight Avg) merge score -- MergeBench's number, not
ours; every published MergeBench score is a five-expert merge, which is why the outcome unit
is the family and not the pair.
(b) mean qmd_raw over the four within-family pairs that CONTAIN each domain, x10^3 -- ours.
Design is pinned to the version already in the manuscript so a regenerated file drops in unchanged:
viridis for (a) with a 0-90 scale, magma_r for (b), value annotations, `n/a` in italic grey for any
cell without data, two-line suptitle, row labels `family\\n(params)`.
PYTHONPATH=src python scripts/make_fig_mergebench_scale.py
"""
from __future__ import annotations
import glob
import os
import sys
import numpy as np
import pandas as pd
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from mergeschool import paths
RESULTS = paths.RESULTS / "mergebench"
OUT_DIRS = [paths.ROOT / "paper" / "overleaf_iclr", paths.FIGURES / "mergebench"]
NAME = "fig_mergebench_scale"
FAMILIES = [("gemma-2-2b", "2.6B"), ("gemma-2-2b-it", "2.6B"),
("Llama-3.2-3B", "3.2B"), ("Llama-3.2-3B-Instruct", "3.2B"),
("Llama-3.1-8B", "8.0B"), ("Llama-3.1-8B-Instruct", "8.0B"),
("gemma-2-9b", "9.2B"), ("gemma-2-9b-it", "9.2B")]
# figure column order, and the task label each maps to in MergeBench's published table
DOMAINS = [("math", "Math"), ("safety", "Safety"), ("coding", "Coding"),
("multilingual", "Multilingual"), ("instruction", "Instruction following")]
METHOD = "Model soup"
def load():
pairs = pd.concat([pd.read_csv(f) for f in glob.glob(str(RESULTS / "pairs_w*.csv"))],
ignore_index=True).drop_duplicates("pair_id")
pub = pd.read_csv(RESULTS / "mergebench_published_scores.csv")
pub = pub[pub.method == METHOD]
S = np.full((len(FAMILIES), len(DOMAINS)), np.nan) # published merge score
Q = np.full((len(FAMILIES), len(DOMAINS)), np.nan) # mean qmd_raw x10^3
for i, (fam, _p) in enumerate(FAMILIES):
sub = pub[pub.family == fam]
g = pairs[pairs.family == fam]
for j, (dom, task) in enumerate(DOMAINS):
v = sub[sub.task == task]["score"]
if len(v):
S[i, j] = float(v.iloc[0])
# the four pairs of this family that contain this domain
m = g[(g.domain_a == dom) | (g.domain_b == dom)]["qmd_raw"].dropna()
if len(m):
Q[i, j] = float(m.mean()) * 1e3
return S, Q, pairs
def panel(ax, M, cmap, title, cbar_label, vmin=None, vmax=None, log=False):
# LOG COLOUR SCALE for the quotient-distance panel, forced by the data rather than chosen for
# looks. With all eight families present qmd_raw spans 9.65 to 70.3 -- the 8B/9B experts drift
# 3-5x further from each other than the 2B/3B ones -- so on a linear scale the four small
# families all sit in the bottom tenth of the range and render as one flat pale block, losing
# exactly the within-family structure the original figure showed. A log scale keeps both reads:
# the cross-scale growth AND the ordering inside each family.
norm = matplotlib.colors.LogNorm(vmin=np.nanmin(M), vmax=np.nanmax(M)) if log else None
im = ax.imshow(np.ma.masked_invalid(M), cmap=cmap, aspect="auto",
norm=norm, **({} if log else {"vmin": vmin, "vmax": vmax}))
im.cmap.set_bad("white")
ax.set_xticks(range(len(DOMAINS)))
ax.set_xticklabels([d for d, _t in DOMAINS], rotation=35, ha="right", rotation_mode="anchor")
ax.set_yticks(range(len(FAMILIES)))
ax.set_yticklabels([f"{f}\n({p})" for f, p in FAMILIES], fontsize=9)
ax.set_title(title, fontsize=11, pad=10)
lo, hi = np.nanmin(M), np.nanmax(M)
for i in range(M.shape[0]):
for j in range(M.shape[1]):
v = M[i, j]
if not np.isfinite(v):
ax.text(j, i, "n/a", ha="center", va="center", fontsize=9,
style="italic", color="#9A9A9A")
continue
# white on dark cells, black on light -- judged against this panel's own range
frac = ((np.log(v) - np.log(lo)) / max(np.log(hi) - np.log(lo), 1e-12)) if log \
else (v - lo) / max(hi - lo, 1e-12)
dark = frac > 0.55 if cmap.endswith("_r") else frac < 0.55
ax.text(j, i, f"{v:.1f}" if cmap == "viridis" else f"{v:.2f}",
ha="center", va="center", fontsize=9,
color="white" if dark else "#1A1A1A")
cb = plt.colorbar(im, ax=ax, fraction=0.046, pad=0.03)
cb.set_label(cbar_label, fontsize=9)
cb.ax.tick_params(labelsize=8)
if log:
# matplotlib's default log locator adds 6x10^1-style minor labels that collide with the
# round ticks the reader wants; silence both locators and set the ticks explicitly.
cb.ax.yaxis.set_minor_locator(matplotlib.ticker.NullLocator())
cb.ax.yaxis.set_minor_formatter(matplotlib.ticker.NullFormatter())
ticks = [t for t in (10, 15, 20, 30, 50, 70) if np.nanmin(M) <= t <= np.nanmax(M)]
cb.set_ticks(ticks)
cb.ax.yaxis.set_major_formatter(matplotlib.ticker.FixedFormatter([str(t) for t in ticks]))
return im
def main():
S, Q, pairs = load()
n_fam = int(np.isfinite(S).any(axis=1).sum())
n_pairs = int(len(pairs))
missing = [f for i, (f, _p) in enumerate(FAMILIES) if not np.isfinite(Q[i]).any()]
fig, axes = plt.subplots(1, 2, figsize=(20, 8))
panel(axes[0], S, "viridis", "(a) Published 5-expert merge score (Model soup)",
"norm. task score", vmin=0, vmax=90)
panel(axes[1], Q, "magma_r",
"(b) Mean quotient dist. qmd$_\\mathrm{raw}$ ($\\times10^{3}$, log scale)",
"qmd$_\\mathrm{raw}$ $\\times$ 10$^{3}$ (log)", log=True)
sub = (f"(all {n_fam} families measured, {n_pairs}/80 pairs; "
f"MergeBench publishes only 5-expert merges, n={n_fam} families)"
if not missing else
f"({n_fam}/8 families measured; {', '.join(missing)} pending, n/a; "
f"MergeBench publishes only 5-expert merges)")
fig.suptitle("MergeBench at scale — 8 base families (2.6B / 3.2B / 8.0B / 9.2B) × 5 domains\n"
+ sub, fontsize=13)
fig.tight_layout(rect=(0, 0, 1, 0.94))
for d in OUT_DIRS:
d.mkdir(parents=True, exist_ok=True)
for ext in ("png", "pdf"):
fig.savefig(d / f"{NAME}.{ext}", dpi=200, bbox_inches="tight")
print(f" wrote {d / (NAME + '.png')}")
plt.close(fig)
print(f" families with data: {n_fam}/8 | pairs: {n_pairs}/80 | "
f"pending: {missing or 'none'}")
return S, Q
if __name__ == "__main__":
main()
|