File size: 4,620 Bytes
cb49561 | 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 | import numpy as np
D_MODEL_CHOICES = (192, 256, 384)
FF_RATIO_CHOICES = (2.6875, 4.0)
N_LAYER_CHOICES = (16, 32)
N_HEAD_CHOICES = (4, 8)
KV_DIV_CHOICES = (1, 2, 4)
T_CHOICES = (1, 1, 1, 8, 8, 32)
RMS_EPS = 1e-5
ROPE_THETA = 10000.0
def sample_spec(seed):
"""Return the graph_spec dict for `seed`."""
rng = np.random.default_rng(seed)
d_model = int(rng.choice(D_MODEL_CHOICES))
ratio = float(rng.choice(FF_RATIO_CHOICES))
d_ff = int(round(d_model * ratio / 32.0)) * 32
n_layers = int(rng.choice(N_LAYER_CHOICES))
n_heads = int(rng.choice(N_HEAD_CHOICES))
head_dim = d_model // n_heads
n_kv_heads = n_heads // int(rng.choice(KV_DIV_CHOICES))
T = int(rng.choice(T_CHOICES))
layers = []
for li in range(n_layers):
p = "blk.%d." % li
layers.append([
{"op": "rmsnorm", "out": "n1", "inputs": ["h"], "weight": p + "attn_norm"},
{"op": "matmul", "out": "q", "inputs": ["n1"], "weight": p + "attn_q"},
{"op": "matmul", "out": "k", "inputs": ["n1"], "weight": p + "attn_k"},
{"op": "matmul", "out": "v", "inputs": ["n1"], "weight": p + "attn_v"},
{"op": "attention", "out": "att", "inputs": ["q", "k", "v"], "weight": None},
{"op": "matmul", "out": "ao", "inputs": ["att"], "weight": p + "attn_out"},
{"op": "add", "out": "h", "inputs": ["h", "ao"], "weight": None},
{"op": "rmsnorm", "out": "n2", "inputs": ["h"], "weight": p + "ffn_norm"},
{"op": "matmul", "out": "g", "inputs": ["n2"], "weight": p + "ffn_gate"},
{"op": "matmul", "out": "u", "inputs": ["n2"], "weight": p + "ffn_up"},
{"op": "swiglu", "out": "f", "inputs": ["g", "u"], "weight": None},
{"op": "matmul", "out": "fo", "inputs": ["f"], "weight": p + "ffn_down"},
{"op": "add", "out": "h", "inputs": ["h", "fo"], "weight": None},
])
return {
"seed": int(seed),
"n_layers": n_layers,
"d_model": d_model,
"d_ff": d_ff,
"n_heads": n_heads,
"n_kv_heads": n_kv_heads,
"head_dim": head_dim,
"T": T,
"rms_eps": RMS_EPS,
"layers": layers,
"final": {"op": "rmsnorm", "out": "h", "inputs": ["h"], "weight": "output_norm"},
}
def _normal(rng, shape, scale):
return (rng.standard_normal(shape, dtype=np.float32) * np.float32(scale))
def build_weights(spec):
"""Return the tensor dict for `spec`. All arrays are C-contiguous float32."""
rng = np.random.default_rng(spec["seed"] + 1_000_003)
d = spec["d_model"]
d_ff = spec["d_ff"]
hd = spec["head_dim"]
n_q = spec["n_heads"] * hd
n_kv = spec["n_kv_heads"] * hd
T = spec["T"]
w = {}
for li in range(spec["n_layers"]):
p = "blk.%d." % li
w[p + "attn_norm"] = np.ascontiguousarray(1.0 + 0.02 * _normal(rng, (d,), 1.0))
w[p + "attn_q"] = np.ascontiguousarray(_normal(rng, (d, n_q), d ** -0.5))
w[p + "attn_k"] = np.ascontiguousarray(_normal(rng, (d, n_kv), d ** -0.5))
w[p + "attn_v"] = np.ascontiguousarray(_normal(rng, (d, n_kv), d ** -0.5))
w[p + "attn_out"] = np.ascontiguousarray(_normal(rng, (n_q, d), n_q ** -0.5))
w[p + "ffn_norm"] = np.ascontiguousarray(1.0 + 0.02 * _normal(rng, (d,), 1.0))
w[p + "ffn_gate"] = np.ascontiguousarray(_normal(rng, (d, d_ff), d ** -0.5))
w[p + "ffn_up"] = np.ascontiguousarray(_normal(rng, (d, d_ff), d ** -0.5))
w[p + "ffn_down"] = np.ascontiguousarray(_normal(rng, (d_ff, d), d_ff ** -0.5))
w["output_norm"] = np.ascontiguousarray(1.0 + 0.02 * _normal(rng, (d,), 1.0))
half = hd // 2
inv = (ROPE_THETA ** (-np.arange(half, dtype=np.float64) / half))
ang = np.arange(T, dtype=np.float64)[:, None] * inv[None, :]
w["rope_cos"] = np.ascontiguousarray(np.cos(ang).astype(np.float32))
w["rope_sin"] = np.ascontiguousarray(np.sin(ang).astype(np.float32))
mask = np.zeros((T, T), dtype=np.float32)
mask[np.triu_indices(T, k=1)] = -np.inf
w["attn_mask"] = np.ascontiguousarray(mask)
return w
def build_inputs(spec, n):
"""Return `n` distinct input activations of shape (T, d_model), float32.
Drawn from fresh OS entropy, never from the instance seed: the same list is fed
to both executors within a run, but no executor can precompute the output for an
input it has not yet been sent.
"""
rng = np.random.default_rng()
T, d = spec["T"], spec["d_model"]
return [np.ascontiguousarray(rng.standard_normal((T, d), dtype=np.float32))
for _ in range(n)]
|