Boom5426's picture
WeightCode records and weights (redacted 2026-11-10, see REDACTIONS.json)
4c27541
Raw History Blame Contribute Delete
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)