File size: 5,919 Bytes
4c27541
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
"""Numpy reference forward pass of an encoder-only Transformer described by model_spec.json (arch tfm).

Requires numpy only. Call ``forward(params, x)``:

* ``params``: dict of float arrays keyed by parameter name, PyTorch layout (linear weight [out, in], embedding
  weight [rows, d]).
* ``x``: int64 token ids of shape [N, SEQ_LEN] (any integer dtype is accepted), each in 0 .. VOCAB_SIZE - 1.
* returns float32 logits [N, SEQ_LEN, N_OUT]; the prediction at a position is the argmax over the last axis.

Computation (pre-LayerNorm; blocks ``b1`` .. ``bK`` read from the parameter names):

    h = tok_emb.weight[x] + pos_emb.weight[t]
    per block i: h = h + attention(ln1(h)); h = h + fc2(relu(fc1(ln2(h))))
    logits = head(ln_f(h))

LayerNorm: (a - mean) / sqrt(var + LN_EPS) * weight + bias over the last axis, var the biased variance.
Attention: q, k, v = a @ W.T + b; N_HEADS heads, head j on columns j * head_dim .. (j + 1) * head_dim - 1;
softmax(q k^T / sqrt(head_dim)) over the keys, keys at positions whose token is PAD_ID excluded; heads concatenated,
then @ o.weight.T + o.bias. All arithmetic runs in float64 and the logits are cast once to float32. Rows are
processed in chunks of at most CHUNK, which bounds memory.
"""

from __future__ import annotations

import numpy as np

SEQ_LEN = 59
VOCAB_SIZE = 17
N_OUT = 7
N_HEADS = 4
PAD_ID = 0
LN_EPS = 1e-05
CHUNK = 512


def _tensor(params: dict, key: str) -> np.ndarray:
    if key not in params:
        raise KeyError(f"missing parameter {key!r}")
    value = np.asarray(params[key])
    if not np.issubdtype(value.dtype, np.floating):
        raise TypeError(f"{key} must be a float array, got {value.dtype}")
    return value.astype(np.float64)


def _blocks(params: dict) -> list[str]:
    numbers = set()
    for key in params:
        head = str(key).split(".")[0]
        if head in ("tok_emb", "pos_emb", "ln_f", "head"):
            continue
        if not (head.startswith("b") and head[1:].isdigit() and head[1] != "0"):
            raise KeyError(f"unexpected parameter name {key!r}")
        numbers.add(int(head[1:]))
    ordered = sorted(numbers)
    if not ordered or ordered != list(range(1, len(ordered) + 1)):
        raise KeyError(f"blocks must be numbered b1..bK without gaps, got {ordered}")
    return [f"b{number}" for number in ordered]


def _layernorm(a: np.ndarray, weight: np.ndarray, bias: np.ndarray) -> np.ndarray:
    mean = a.mean(axis=-1, keepdims=True)
    var = ((a - mean) ** 2).mean(axis=-1, keepdims=True)
    return (a - mean) / np.sqrt(var + LN_EPS) * weight + bias


def _linear(a: np.ndarray, params: dict, name: str) -> np.ndarray:
    weight, bias = _tensor(params, name + ".weight"), _tensor(params, name + ".bias")
    if weight.ndim != 2 or weight.shape[1] != a.shape[-1] or bias.shape != (weight.shape[0],):
        raise ValueError(f"{name} weight {weight.shape} / bias {bias.shape} do not fit input width {a.shape[-1]}")
    return a @ weight.T + bias


def _attention(a: np.ndarray, params: dict, name: str, key_pad: np.ndarray) -> np.ndarray:
    n, length, width = a.shape
    if width % N_HEADS:
        raise ValueError(f"width {width} is not divisible by N_HEADS {N_HEADS}")
    head_dim = width // N_HEADS

    def heads(t: np.ndarray) -> np.ndarray:
        return t.reshape(n, length, N_HEADS, head_dim).transpose(0, 2, 1, 3)

    q, k, v = (heads(_linear(a, params, f"{name}.{part}")) for part in "qkv")
    scores = q @ k.transpose(0, 1, 3, 2) / np.sqrt(head_dim)
    scores = np.where(key_pad[:, None, None, :], -np.inf, scores)
    scores = scores - scores.max(axis=-1, keepdims=True)
    weights = np.exp(scores)
    weights = weights / weights.sum(axis=-1, keepdims=True)
    mixed = (weights @ v).transpose(0, 2, 1, 3).reshape(n, length, width)
    return _linear(mixed, params, f"{name}.o")


def _forward_chunk(params: dict, blocks: list[str], x: np.ndarray) -> np.ndarray:
    tok, pos = _tensor(params, "tok_emb.weight"), _tensor(params, "pos_emb.weight")
    if tok.ndim != 2 or tok.shape[0] != VOCAB_SIZE or pos.shape != (SEQ_LEN, tok.shape[1]):
        raise ValueError(f"embeddings {tok.shape} / {pos.shape} do not fit vocab {VOCAB_SIZE} and length {SEQ_LEN}")
    h = tok[x] + pos[None, :, :]
    key_pad = x == PAD_ID
    if np.any(key_pad.all(axis=1)):
        raise ValueError("a row consists of PAD only")
    for block in blocks:
        a = _layernorm(h, _tensor(params, block + ".ln1.weight"), _tensor(params, block + ".ln1.bias"))
        h = h + _attention(a, params, block + ".attn", key_pad)
        a = _layernorm(h, _tensor(params, block + ".ln2.weight"), _tensor(params, block + ".ln2.bias"))
        h = h + _linear(np.maximum(_linear(a, params, block + ".mlp.fc1"), 0.0), params, block + ".mlp.fc2")
    a = _layernorm(h, _tensor(params, "ln_f.weight"), _tensor(params, "ln_f.bias"))
    logits = _linear(a, params, "head")
    if logits.shape[-1] != N_OUT:
        raise ValueError(f"model produces {logits.shape[-1]} outputs per position, expected {N_OUT}")
    return logits.astype(np.float32)


def forward(params: dict[str, np.ndarray], x: np.ndarray) -> np.ndarray:
    """Logits float32 [N, SEQ_LEN, N_OUT] for int token rows [N, SEQ_LEN]."""
    x = np.asarray(x)
    if not np.issubdtype(x.dtype, np.integer):
        raise TypeError(f"token ids must be integers, got {x.dtype}")
    if x.ndim != 2 or x.shape[1] != SEQ_LEN:
        raise ValueError(f"token rows must have shape [N, {SEQ_LEN}], got {list(x.shape)}")
    if x.size and (x.min() < 0 or x.max() >= VOCAB_SIZE):
        raise ValueError(f"token ids must lie in 0 .. {VOCAB_SIZE - 1}")
    x = x.astype(np.int64)
    blocks = _blocks(params)
    if x.shape[0] == 0:
        return np.zeros((0, SEQ_LEN, N_OUT), dtype=np.float32)
    chunks = [_forward_chunk(params, blocks, x[start : start + CHUNK]) for start in range(0, x.shape[0], CHUNK)]
    return np.concatenate(chunks, axis=0)