| 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)] |
|
|
