Download weights/instances/p6ce8ad67/forward.py from Boom5426/WeightCode: direct link, hf CLI and curl.
- Browser
- Download file 7.25 kB
-
https://huggingface.co/datasets/Boom5426/WeightCode/resolve/main/weights/instances/p6ce8ad67/forward.py
- Command line
-
hf download hf://datasets/Boom5426/WeightCode/weights/instances/p6ce8ad67/forward.py
-
curl -L -o forward.py https://huggingface.co/datasets/Boom5426/WeightCode/resolve/main/weights/instances/p6ce8ad67/forward.py
7.25 kB
| """Numpy reference forward pass of a grid-world policy (model_spec.json describes it). | |
| Requires numpy only. Call ``forward(params, x)``: | |
| * ``params``: dict of float arrays keyed by parameter name, PyTorch layout (conv weight [out, in, kh, kw], linear | |
| weight [out, in]). | |
| * ``x``: int64 rows [N, 197]. A row is one observation and instruction: the grid's 8 x 8 cells, each (object index, | |
| color index, state), in [x, y, channel] C order (192 values), then the instruction's 5 word ids. | |
| * returns float32 action logits [N, 7]; the action taken is the argmax over axis 1 (the first index on ties). | |
| Architecture (fixed; the sizes are read from the parameter shapes and checked against each other): | |
| * cell embedding: e[n, x, y] = obj_emb[object] + col_emb[color] + state_emb[state], d_cell values per cell. | |
| * instruction: the 5 word rows word_emb[id] concatenated in order ([5 * d_word]), then | |
| h = ReLU(instr.weight @ w + instr.bias), [d_instr]. | |
| * two FiLM convolution blocks k = 1, 2 on the [channels, 8, 8] map (channel, x, y): z = conv_k(z) (3x3, stride 1, | |
| zero padding 1, with bias), (g, b) = film_k.weight @ h + film_k.bias split into two halves of the block's | |
| channels, z = ReLU(z * (1 + g) + b) with g and b broadcast over the 8 x 8 positions. | |
| * u = fc.weight @ flatten(z) + fc.bias, where flatten takes z in (channel, x, y) C order; then LayerNorm over u's | |
| d_hidden values, (u - mean) / sqrt(var + LN_EPS) * ln.weight + ln.bias with the biased variance; then ReLU. | |
| * logits = head.weight @ u + head.bias. | |
| Convolution is 2-D cross-correlation as in torch.nn.functional.conv2d. All arithmetic runs in float64 and the logits | |
| are cast once to float32. Rows are processed in chunks of at most CHUNK. | |
| """ | |
| from __future__ import annotations | |
| import numpy as np | |
| GRID = 8 | |
| N_CHANNELS = 3 | |
| INSTR_LEN = 5 | |
| ROW_LEN = GRID * GRID * N_CHANNELS + INSTR_LEN | |
| N_OBJECTS = 11 | |
| N_COLORS = 6 | |
| N_STATES = 4 | |
| N_WORDS = 15 | |
| N_ACTIONS = 7 | |
| LN_EPS = 1e-5 | |
| CHUNK = 512 | |
| NAMES = ("obj_emb.weight", "col_emb.weight", "state_emb.weight", "word_emb.weight", "instr.weight", "instr.bias", | |
| "conv1.weight", "conv1.bias", "film1.weight", "film1.bias", "conv2.weight", "conv2.bias", "film2.weight", | |
| "film2.bias", "fc.weight", "fc.bias", "ln.weight", "ln.bias", "head.weight", "head.bias") | |
| def expected_shapes(d_cell: int, d_word: int, d_instr: int, channels: int, d_hidden: int) -> dict[str, tuple]: | |
| """Every parameter name with its shape for the given sizes, in forward order.""" | |
| return { | |
| "obj_emb.weight": (N_OBJECTS, d_cell), "col_emb.weight": (N_COLORS, d_cell), | |
| "state_emb.weight": (N_STATES, d_cell), "word_emb.weight": (N_WORDS, d_word), | |
| "instr.weight": (d_instr, INSTR_LEN * d_word), "instr.bias": (d_instr,), | |
| "conv1.weight": (channels, d_cell, 3, 3), "conv1.bias": (channels,), | |
| "film1.weight": (2 * channels, d_instr), "film1.bias": (2 * channels,), | |
| "conv2.weight": (channels, channels, 3, 3), "conv2.bias": (channels,), | |
| "film2.weight": (2 * channels, d_instr), "film2.bias": (2 * channels,), | |
| "fc.weight": (d_hidden, channels * GRID * GRID), "fc.bias": (d_hidden,), | |
| "ln.weight": (d_hidden,), "ln.bias": (d_hidden,), | |
| "head.weight": (N_ACTIONS, d_hidden), "head.bias": (N_ACTIONS,), | |
| } | |
| def sizes(params: dict) -> tuple[int, int, int, int, int]: | |
| """(d_cell, d_word, d_instr, channels, d_hidden) read from the parameter shapes.""" | |
| return (int(np.shape(params["obj_emb.weight"])[1]), int(np.shape(params["word_emb.weight"])[1]), | |
| int(np.shape(params["instr.weight"])[0]), int(np.shape(params["conv1.weight"])[0]), | |
| int(np.shape(params["fc.weight"])[0])) | |
| def _checked(params: dict) -> dict[str, np.ndarray]: | |
| names = {str(key) for key in params} | |
| if names != set(NAMES): | |
| raise ValueError(f"parameter names differ: missing {sorted(set(NAMES) - names)}, unexpected " | |
| f"{sorted(names - set(NAMES))}") | |
| expected = expected_shapes(*sizes(params)) | |
| out = {} | |
| for name in NAMES: | |
| value = np.asarray(params[name], dtype=np.float64) | |
| if value.shape != expected[name]: | |
| raise ValueError(f"{name}: expected shape {expected[name]}, got {value.shape}") | |
| if not np.all(np.isfinite(value)): | |
| raise ValueError(f"{name} has non-finite values") | |
| out[name] = value | |
| return out | |
| def _rows(x) -> np.ndarray: | |
| x = np.asarray(x) | |
| if not np.issubdtype(x.dtype, np.integer) or x.ndim != 2 or x.shape[1] != ROW_LEN: | |
| raise ValueError(f"expected integer rows [N, {ROW_LEN}], got {x.dtype} {x.shape}") | |
| x = x.astype(np.int64) | |
| grid = x[:, : GRID * GRID * N_CHANNELS].reshape(-1, GRID, GRID, N_CHANNELS) | |
| instr = x[:, GRID * GRID * N_CHANNELS:] | |
| for values, limit, what in ((grid[..., 0], N_OBJECTS, "object"), (grid[..., 1], N_COLORS, "color"), | |
| (grid[..., 2], N_STATES, "state"), (instr, N_WORDS, "word")): | |
| if values.size and (values.min() < 0 or values.max() >= limit): | |
| raise ValueError(f"a {what} index is outside 0..{limit - 1}") | |
| return x | |
| def _conv3x3(z: np.ndarray, weight: np.ndarray, bias: np.ndarray) -> np.ndarray: | |
| """z [n, X, Y, C] (channels last) -> [n, X, Y, O]; cross-correlation, zero padding 1, stride 1.""" | |
| n, height, width, _ = z.shape | |
| padded = np.zeros((n, height + 2, width + 2, z.shape[3])) | |
| padded[:, 1:-1, 1:-1, :] = z | |
| out = np.zeros((n * height * width, weight.shape[0])) | |
| for u in range(3): | |
| for v in range(3): | |
| patch = padded[:, u:u + height, v:v + width, :].reshape(n * height * width, -1) | |
| out += patch @ weight[:, :, u, v].T | |
| return (out + bias).reshape(n, height, width, weight.shape[0]) | |
| def _chunk(p: dict[str, np.ndarray], x: np.ndarray) -> np.ndarray: | |
| n = len(x) | |
| grid = x[:, : GRID * GRID * N_CHANNELS].reshape(n, GRID, GRID, N_CHANNELS) | |
| instr = x[:, GRID * GRID * N_CHANNELS:] | |
| z = p["obj_emb.weight"][grid[..., 0]] + p["col_emb.weight"][grid[..., 1]] + p["state_emb.weight"][grid[..., 2]] | |
| w = p["word_emb.weight"][instr].reshape(n, -1) | |
| h = np.maximum(w @ p["instr.weight"].T + p["instr.bias"], 0.0) | |
| for k in (1, 2): | |
| z = _conv3x3(z, p[f"conv{k}.weight"], p[f"conv{k}.bias"]) | |
| film = h @ p[f"film{k}.weight"].T + p[f"film{k}.bias"] | |
| channels = z.shape[3] | |
| gamma, beta = film[:, :channels], film[:, channels:] | |
| z = np.maximum(z * (1.0 + gamma[:, None, None, :]) + beta[:, None, None, :], 0.0) | |
| flat = z.transpose(0, 3, 1, 2).reshape(n, -1) | |
| u = flat @ p["fc.weight"].T + p["fc.bias"] | |
| mean = u.mean(axis=1, keepdims=True) | |
| var = ((u - mean) ** 2).mean(axis=1, keepdims=True) | |
| u = np.maximum((u - mean) / np.sqrt(var + LN_EPS) * p["ln.weight"] + p["ln.bias"], 0.0) | |
| return u @ p["head.weight"].T + p["head.bias"] | |
| def forward(params: dict, x) -> np.ndarray: | |
| """Action logits float32 [N, 7] of rows ``x`` int [N, 197] under ``params``.""" | |
| p = _checked(params) | |
| rows = _rows(x) | |
| if len(rows) == 0: | |
| return np.zeros((0, N_ACTIONS), dtype=np.float32) | |
| out = [_chunk(p, rows[start:start + CHUNK]) for start in range(0, len(rows), CHUNK)] | |
| return np.concatenate(out).astype(np.float32) | |