| import numpy as np | |
| def _rmsnorm(x, w, eps, out, sq): | |
| np.square(x, out=sq) | |
| ss = np.mean(sq, axis=-1, keepdims=True) | |
| np.multiply(x, np.reciprocal(np.sqrt(ss + np.float32(eps))), out=out) | |
| np.multiply(out, w, out=out) | |
| return out | |
| def _rope(t, cos, sin, out): | |
| """Rotary embedding over the last axis, applied per head. t: (H, T, head_dim).""" | |
| half = t.shape[-1] // 2 | |
| a = t[..., :half] | |
| b = t[..., half:] | |
| np.subtract(a * cos, b * sin, out=out[..., :half]) | |
| np.add(a * sin, b * cos, out=out[..., half:]) | |
| return out | |
| class _Executor: | |
| def __init__(self, spec, weights, n_workers): | |
| self.spec = spec | |
| self.w = weights | |
| self.n_workers = int(n_workers) | |
| T = spec["T"] | |
| d = spec["d_model"] | |
| d_ff = spec["d_ff"] | |
| hd = spec["head_dim"] | |
| H = spec["n_heads"] | |
| KV = spec["n_kv_heads"] | |
| self.eps = float(spec["rms_eps"]) | |
| self.scale = np.float32(hd ** -0.5) | |
| self.rep = H // KV | |
| self.buf = { | |
| "h": np.empty((T, d), dtype=np.float32), | |
| "n1": np.empty((T, d), dtype=np.float32), | |
| "n2": np.empty((T, d), dtype=np.float32), | |
| "q": np.empty((T, H * hd), dtype=np.float32), | |
| "k": np.empty((T, KV * hd), dtype=np.float32), | |
| "v": np.empty((T, KV * hd), dtype=np.float32), | |
| "att": np.empty((T, H * hd), dtype=np.float32), | |
| "ao": np.empty((T, d), dtype=np.float32), | |
| "g": np.empty((T, d_ff), dtype=np.float32), | |
| "u": np.empty((T, d_ff), dtype=np.float32), | |
| "f": np.empty((T, d_ff), dtype=np.float32), | |
| "fo": np.empty((T, d), dtype=np.float32), | |
| } | |
| self.qr = np.empty((H, T, hd), dtype=np.float32) | |
| self.kr = np.empty((KV, T, hd), dtype=np.float32) | |
| self.kkT = np.empty((H, hd, T), dtype=np.float32) | |
| self.vv = np.empty((H, T, hd), dtype=np.float32) | |
| self.scores = np.empty((H, T, T), dtype=np.float32) | |
| self.probs = np.empty((H, T, T), dtype=np.float32) | |
| self.ctx = np.empty((H, T, hd), dtype=np.float32) | |
| self.sq = np.empty((T, d), dtype=np.float32) | |
| self.cos = weights["rope_cos"] | |
| self.sin = weights["rope_sin"] | |
| self.mask = weights["attn_mask"] | |
| self.plan = [] | |
| for layer in spec["layers"]: | |
| ops = [] | |
| for node in layer: | |
| w = weights[node["weight"]] if node["weight"] else None | |
| ops.append((node["op"], node["out"], node["inputs"], w)) | |
| self.plan.append(ops) | |
| self.final_w = weights[spec["final"]["weight"]] | |
| def _attention(self, q, k, v, out): | |
| H, T, hd = self.qr.shape | |
| KV = self.kr.shape[0] | |
| _rope(q.reshape(T, H, hd).transpose(1, 0, 2), self.cos, self.sin, self.qr) | |
| _rope(k.reshape(T, KV, hd).transpose(1, 0, 2), self.cos, self.sin, self.kr) | |
| self.kkT.reshape(KV, self.rep, hd, T)[...] = self.kr.transpose(0, 2, 1)[:, None] | |
| self.vv.reshape(KV, self.rep, T, hd)[...] = \ | |
| v.reshape(T, KV, hd).transpose(1, 0, 2)[:, None] | |
| np.matmul(self.qr, self.kkT, out=self.scores) | |
| np.multiply(self.scores, self.scale, out=self.scores) | |
| np.add(self.scores, self.mask, out=self.scores) | |
| np.subtract(self.scores, np.max(self.scores, axis=-1, keepdims=True), | |
| out=self.probs) | |
| np.exp(self.probs, out=self.probs) | |
| np.divide(self.probs, np.sum(self.probs, axis=-1, keepdims=True), out=self.probs) | |
| np.matmul(self.probs, self.vv, out=self.ctx) | |
| out.reshape(T, H, hd)[...] = self.ctx.transpose(1, 0, 2) | |
| return out | |
| def __call__(self, x): | |
| buf = self.buf | |
| h = buf["h"] | |
| h[...] = x | |
| for ops in self.plan: | |
| for op, out_name, inp, W in ops: | |
| if op == "matmul": | |
| np.matmul(buf[inp[0]], W, out=buf[out_name]) | |
| elif op == "rmsnorm": | |
| _rmsnorm(buf[inp[0]], W, self.eps, buf[out_name], self.sq) | |
| elif op == "attention": | |
| self._attention(buf[inp[0]], buf[inp[1]], buf[inp[2]], buf[out_name]) | |
| elif op == "add": | |
| np.add(buf[inp[0]], buf[inp[1]], out=buf[out_name]) | |
| elif op == "swiglu": | |
| g = buf[inp[0]] | |
| f = buf[out_name] | |
| np.negative(g, out=f) | |
| np.exp(f, out=f) | |
| np.add(f, np.float32(1.0), out=f) | |
| np.divide(g, f, out=f) | |
| np.multiply(f, buf[inp[1]], out=f) | |
| else: | |
| raise ValueError("unknown op %r" % op) | |
| return _rmsnorm(h, self.final_w, self.eps, buf["n1"], self.sq) | |
| def build_executor(graph_spec, weights, n_workers): | |
| """Build an executor for `graph_spec`. See the module docstring for the contract.""" | |
| return _Executor(graph_spec, weights, n_workers) | |