File size: 5,858 Bytes
44bc7e7 | 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 | """GPT-2 (Conv1D, transposed-weight) symmetry factors. mergeschool's generic aligners assume the
row-major nn.Linear convention, so the residual/MLP/head maps are written out explicitly here for
the goldfish family. Every factor below is exact (LayerNorm is permutation-equivariant; GELU is
elementwise; GPT-2 uses learned positional embeddings so head permutation is exact)."""
import numpy as np
import sys
sys.path.insert(0, "/root/mergeability/src")
from mergeschool.core import alignment as AL
def _pre(n):
p = n.split(".")
for i, x in enumerate(p):
if x.isdigit():
return ".".join(p[:i + 1]) + "."
return None
def layers_of(sd):
return sorted({int(k.split(".")[2]) for k in sd if k.startswith("transformer.h.")})
# --------------------------------------------------------------- residual basis (d)
def apply_resid(sd, d, perm=None, R=None):
"""Carry sd into another model's residual basis. perm: index array (exact). R: (d,d) orthogonal
with acts_B @ R ~ acts_A (exact up to LayerNorm's elementwise scale, which is left alone)."""
out = {}
P = (lambda W, ax: np.take(W, perm, axis=ax)) if perm is not None else None
for name, W in sd.items():
W = np.asarray(W, float)
n = name
try:
if n.endswith("wte.weight") or n.endswith("wpe.weight") or n.endswith("lm_head.weight"):
out[n] = P(W, 1) if P else W @ R
elif ("ln_" in n or n.endswith("ln_f.weight") or n.endswith("ln_f.bias")) and W.ndim == 1:
out[n] = P(W, 0) if P else W # norm affine: exact under perm, kept under R
elif n.endswith("attn.c_attn.weight") or n.endswith("mlp.c_fc.weight"):
out[n] = P(W, 0) if P else R.T @ W # (d, out): residual is the INPUT axis
elif n.endswith("attn.c_proj.weight") or n.endswith("mlp.c_proj.weight"):
out[n] = P(W, 1) if P else W @ R # (in, d): residual is the OUTPUT axis
elif (n.endswith("attn.c_proj.bias") or n.endswith("mlp.c_proj.bias")) and W.shape[0] == d:
out[n] = P(W, 0) if P else W @ R
else:
out[n] = W
except Exception:
out[n] = W
return out
# --------------------------------------------------------------- free MLP hidden axis (4d)
def mlp_match(sd_a, sd_b):
perms = {}
for L in layers_of(sd_a):
fa, fb = f"transformer.h.{L}.mlp.c_fc.weight", f"transformer.h.{L}.mlp.c_proj.weight"
A = np.asarray(sd_a[fa], float).T @ np.asarray(sd_b[fa], float) # (4d,d)@(d,4d)
A = A + np.asarray(sd_a[fb], float) @ np.asarray(sd_b[fb], float).T
perms[L] = AL._assignment(A)
return perms
def apply_mlp(sd, perms):
out = dict(sd)
for L, q in perms.items():
out[f"transformer.h.{L}.mlp.c_fc.weight"] = np.asarray(sd[f"transformer.h.{L}.mlp.c_fc.weight"], float)[:, q]
out[f"transformer.h.{L}.mlp.c_fc.bias"] = np.asarray(sd[f"transformer.h.{L}.mlp.c_fc.bias"], float)[q]
out[f"transformer.h.{L}.mlp.c_proj.weight"] = np.asarray(sd[f"transformer.h.{L}.mlp.c_proj.weight"], float)[q]
return out
# --------------------------------------------------------------- attention heads
def head_match(sd_a, sd_b, d, nh):
hd, perms = d // nh, {}
for L in layers_of(sd_a):
ca, cp = f"transformer.h.{L}.attn.c_attn.weight", f"transformer.h.{L}.attn.c_proj.weight"
gain = np.zeros((nh, nh))
for blk in range(3): # q | k | v, each (d, d)
A = np.asarray(sd_a[ca], float)[:, blk * d:(blk + 1) * d].reshape(d, nh, hd)
B = np.asarray(sd_b[ca], float)[:, blk * d:(blk + 1) * d].reshape(d, nh, hd)
gain += np.einsum("xiy,xjy->ij", A, B)
A = np.asarray(sd_a[cp], float).reshape(nh, hd, d)
B = np.asarray(sd_b[cp], float).reshape(nh, hd, d)
gain += np.einsum("ixy,jxy->ij", A, B)
perms[L] = AL._assignment(gain)
return perms
def apply_head(sd, perms, d, nh):
hd, out = d // nh, dict(sd)
for L, h in perms.items():
ca, cb = f"transformer.h.{L}.attn.c_attn.weight", f"transformer.h.{L}.attn.c_attn.bias"
cp = f"transformer.h.{L}.attn.c_proj.weight"
W = np.asarray(sd[ca], float).copy()
Bv = np.asarray(sd[cb], float).copy()
for blk in range(3):
s = slice(blk * d, (blk + 1) * d)
W[:, s] = W[:, s].reshape(d, nh, hd)[:, h].reshape(d, d)
Bv[s] = Bv[s].reshape(nh, hd)[h].reshape(d)
out[ca], out[cb] = W, Bv
out[cp] = np.asarray(sd[cp], float).reshape(nh, hd, d)[h].reshape(d, d)
return out
# --------------------------------------------------------------- composition with accept-each
def align_full(sd_a, sd_b, d, nh, acts_a=None, acts_b=None, method="permutation", body_keys=None,
accept_each=True):
info = {"residual": False, "mlp": 0, "heads": 0, "rejected": []}
sd = dict(sd_b)
def keep(cand, tag):
if not accept_each:
return cand, True
if AL.block_normalised_distance(sd_a, cand, body_keys) <= AL.block_normalised_distance(sd_a, sd, body_keys):
return cand, True
info["rejected"].append(tag)
return sd, False
if acts_a is not None and acts_b is not None:
kind, obj = AL.residual_basis_map(acts_a, acts_b, method=method)
cand = apply_resid(sd, d, perm=(obj if kind == "perm" else None), R=(obj if kind == "R" else None))
sd, ok = keep(cand, "residual"); info["residual"] = ok
mp = mlp_match(sd_a, sd)
sd, ok = keep(apply_mlp(sd, mp), "mlp"); info["mlp"] = len(mp) if ok else 0
hp = head_match(sd_a, sd, d, nh)
sd, ok = keep(apply_head(sd, hp, d, nh), "heads"); info["heads"] = len(hp) if ok else 0
return sd, info
|