Publish Temporary key-value binding benchmark

README.md

@@ -0,0 +1,47 @@
+---
+license: apache-2.0
+tags:
+- fast-weights
+- associative-memory
+- meta-learning
+- sequence-modeling
+- gradio
+---
+
+# Fast-Weight Time Machine
+
+Fast-Weight Time Machine tests temporary variable binding with an explicit,
+sequence-local weight matrix. A controller receives key/value writes, produces a
+write strength, and accumulates outer products in a fast memory. A later query key
+reads the memory in one matrix-vector operation. The learned parameters stay fixed
+between examples; only the fast matrix changes inside each sequence.
+
+The historical anchor is Schmidhuber's 1992
+[Learning to Control Fast-Weight Memories](https://doi.org/10.1162/NECO.1992.4.1.131),
+which described feedforward controllers producing context-dependent weight changes
+and included adaptive temporary-variable binding. This project is a modern
+outer-product interpretation tested against a similarly sized GRU. It does not
+claim to reproduce the original implementation or experiments exactly.
+
+## Verified results
+
+The models trained on 16,000 sequences containing four writes and 12 distractors.
+Each held-out condition contained 4,000 new sequences.
+
+| Condition | Fast weights, 2,508 params | GRU, 3,050 params |
+| --- | ---: | ---: |
+| 4 bindings, 12 distractors | 100.00% | 37.40% |
+| 8 bindings, 12 distractors | 100.00% | 27.03% |
+| 4 bindings, 64 distractors | 100.00% | 31.15% |
+| 8 bindings, 64 distractors | 99.98% | 23.83% |
+
+This task is intentionally aligned with the fast-weight architecture: an explicit
+outer-product matrix can bind a key and value, while the GRU must compress all
+bindings into one recurrent vector. The comparison demonstrates the inductive bias;
+it is not a general claim that fast weights outperform GRUs on arbitrary sequences.
+
+## Reproduce
+
+```powershell
+uv run python projects/fast-weight-time-machine/train.py
+```

binding_test.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17403706f00b394b26ebdbfc928de40c1a65ab1b65ff4eb7167cecd3a0fd9099
+size 127296

source/app.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import gradio as gr
+import plotly.graph_objects as go
+import torch
+from data import VALUES, generate_bindings
+from model import FastWeightProgrammer
+from safetensors.torch import load_file
+
+ARTIFACT_DIR = (
+    Path(__file__).resolve().parent / "artifacts" / "fast-weight-time-machine"
+)
+MODEL = FastWeightProgrammer()
+MODEL.load_state_dict(load_file(ARTIFACT_DIR / "fast_weight.safetensors"))
+MODEL.eval()
+
+
+def inspect_binding(
+    seed: int, pairs: int, distractors: int
+) -> tuple[go.Figure, dict]:
+    keys, values, writes, targets = generate_bindings(
+        1, int(pairs), int(distractors), int(seed)
+    )
+    with torch.inference_mode():
+        logits, strengths, contributions = MODEL(
+            torch.from_numpy(keys),
+            torch.from_numpy(values),
+            torch.from_numpy(writes),
+            return_trace=True,
+        )
+    probabilities = torch.softmax(logits, dim=1).numpy()[0]
+    contribution = contributions.numpy()[0]
+    labels = [
+        f"K{key}:V{value}" if value < VALUES else f"QUERY K{key}"
+        for key, value in zip(keys[0], values[0], strict=True)
+    ]
+    colors = ["#f59e0b" if write else "#334155" for write in writes[0]]
+    figure = go.Figure(
+        go.Bar(
+            x=list(range(len(labels))),
+            y=contribution,
+            marker_color=colors,
+            customdata=labels,
+            hovertemplate="%{customdata}<br>read contribution=%{y:.3f}",
+        )
+    )
+    figure.update_layout(
+        title="Query-key contribution to the fast weight matrix",
+        xaxis_title="Sequence event",
+        yaxis_title="Contribution",
+        template="plotly_dark",
+    )
+    prediction = int(probabilities.argmax())
+    return figure, {
+        "query": labels[-1],
+        "target_value": int(targets[0]),
+        "predicted_value": prediction,
+        "correct": prediction == int(targets[0]),
+        "confidence": round(float(probabilities[prediction]), 4),
+        "mean_active_write_strength": round(
+            float(strengths.numpy()[0][writes[0] == 1].mean()), 4
+        ),
+    }
+
+
+with gr.Blocks(title="Fast-Weight Time Machine") as demo:
+    gr.Markdown(
+        "# Fast-Weight Time Machine\n"
+        "Watch a learned controller write temporary key/value bindings into a "
+        "sequence-local weight matrix, then retrieve one binding."
+    )
+    with gr.Row():
+        seed = gr.Number(2043, precision=0, label="Sequence seed")
+        pairs = gr.Slider(2, 12, 4, step=1, label="Stored bindings")
+        distractors = gr.Slider(0, 64, 12, step=4, label="Distractors")
+    run = gr.Button("Program fast memory", variant="primary")
+    trace = gr.Plot()
+    result = gr.JSON()
+    run.click(inspect_binding, [seed, pairs, distractors], [trace, result])
+    demo.load(inspect_binding, [seed, pairs, distractors], [trace, result])
+
+
+if __name__ == "__main__":
+    demo.launch()

source/data.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import numpy as np
+
+KEYS = 16
+VALUES = 10
+VALUE_SENTINEL = VALUES
+
+
+def generate_bindings(
+    samples: int,
+    pairs: int,
+    distractors: int,
+    seed: int,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    if pairs > KEYS:
+        raise ValueError("Pairs cannot exceed the unique key vocabulary.")
+    rng = np.random.default_rng(seed)
+    length = pairs + distractors + 1
+    keys = np.zeros((samples, length), dtype=np.int64)
+    values = np.zeros((samples, length), dtype=np.int64)
+    writes = np.zeros((samples, length), dtype=np.float32)
+    targets = np.zeros(samples, dtype=np.int64)
+    for row in range(samples):
+        bound_keys = rng.choice(KEYS, pairs, replace=False)
+        bound_values = rng.integers(0, VALUES, size=pairs)
+        events = [
+            (int(key), int(value), 1.0)
+            for key, value in zip(bound_keys, bound_values, strict=True)
+        ]
+        events.extend(
+            [
+                (
+                    int(rng.integers(0, KEYS)),
+                    int(rng.integers(0, VALUES)),
+                    0.0,
+                )
+                for _ in range(distractors)
+            ]
+        )
+        rng.shuffle(events)
+        for step, (key, value, write) in enumerate(events):
+            keys[row, step] = key
+            values[row, step] = value
+            writes[row, step] = write
+        query = int(rng.integers(0, pairs))
+        keys[row, -1] = bound_keys[query]
+        values[row, -1] = VALUE_SENTINEL
+        targets[row] = bound_values[query]
+    return keys, values, writes, targets

source/model.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+
+class FastWeightProgrammer(nn.Module):
+    def __init__(
+        self,
+        key_vocab: int = 16,
+        value_vocab: int = 11,
+        values: int = 10,
+        dimension: int = 64,
+    ) -> None:
+        super().__init__()
+        self.key_embedding = nn.Embedding(key_vocab, dimension)
+        self.value_embedding = nn.Embedding(value_vocab, dimension)
+        self.write_controller = nn.Linear(2 * dimension + 1, 1)
+        self.readout = nn.Linear(dimension, values)
+
+    def forward(
+        self,
+        keys: torch.Tensor,
+        values: torch.Tensor,
+        writes: torch.Tensor,
+        *,
+        return_trace: bool = False,
+    ):
+        key_vectors = F.normalize(self.key_embedding(keys), dim=-1)
+        value_vectors = self.value_embedding(values)
+        controller_input = torch.cat(
+            [key_vectors, value_vectors, writes.unsqueeze(-1)], dim=-1
+        )
+        strengths = torch.sigmoid(self.write_controller(controller_input))
+        strengths = strengths.squeeze(-1) * writes
+        memory = torch.einsum(
+            "bt,btd,bte->bde",
+            strengths,
+            key_vectors,
+            value_vectors,
+        )
+        query = key_vectors[:, -1]
+        retrieved = torch.einsum("bd,bde->be", query, memory)
+        logits = self.readout(retrieved)
+        if return_trace:
+            contributions = (
+                torch.einsum("btd,bd->bt", key_vectors, query) * strengths
+            )
+            return logits, strengths, contributions
+        return logits
+
+
+class GRUControl(nn.Module):
+    def __init__(
+        self,
+        key_vocab: int = 16,
+        value_vocab: int = 11,
+        values: int = 10,
+        dimension: int = 16,
+    ) -> None:
+        super().__init__()
+        self.key_embedding = nn.Embedding(key_vocab, dimension)
+        self.value_embedding = nn.Embedding(value_vocab, dimension)
+        self.recurrent = nn.GRU(2 * dimension + 1, dimension, batch_first=True)
+        self.readout = nn.Linear(dimension, values)
+
+    def forward(
+        self, keys: torch.Tensor, values: torch.Tensor, writes: torch.Tensor
+    ) -> torch.Tensor:
+        inputs = torch.cat(
+            [
+                self.key_embedding(keys),
+                self.value_embedding(values),
+                writes.unsqueeze(-1),
+            ],
+            dim=-1,
+        )
+        hidden, _ = self.recurrent(inputs)
+        return self.readout(hidden[:, -1])
+
+
+def parameter_count(module: nn.Module) -> int:
+    return sum(parameter.numel() for parameter in module.parameters())

source/requirements.txt

@@ -0,0 +1,5 @@
+gradio>=5,<7
+numpy>=2,<3
+plotly>=6,<7
+safetensors>=0.6,<1
+torch>=2.7,<3

source/train.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import copy
+import json
+from pathlib import Path
+
+import numpy as np
+import torch
+import trackio
+from data import generate_bindings
+from model import FastWeightProgrammer, GRUControl, parameter_count
+from safetensors.torch import save_file
+from torch import nn
+from torch.utils.data import DataLoader, TensorDataset
+
+PROJECT_DIR = Path(__file__).resolve().parent
+ARTIFACT_DIR = PROJECT_DIR / "artifacts" / "fast-weight-time-machine"
+DATA_DIR = PROJECT_DIR / "data"
+
+
+def seed_everything(seed: int) -> None:
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.set_num_threads(1)
+
+
+def make_loader(
+    dataset: tuple[np.ndarray, ...],
+    *,
+    shuffle: bool,
+    seed: int,
+) -> DataLoader:
+    keys, values, writes, targets = dataset
+    return DataLoader(
+        TensorDataset(
+            torch.from_numpy(keys),
+            torch.from_numpy(values),
+            torch.from_numpy(writes),
+            torch.from_numpy(targets),
+        ),
+        batch_size=256,
+        shuffle=shuffle,
+        generator=torch.Generator().manual_seed(seed),
+    )
+
+
+@torch.inference_mode()
+def evaluate(model: nn.Module, loader: DataLoader) -> dict:
+    model.eval()
+    correct = 0
+    total = 0
+    losses = []
+    for keys, values, writes, targets in loader:
+        logits = model(keys, values, writes)
+        losses.append(float(nn.functional.cross_entropy(logits, targets)))
+        correct += int((logits.argmax(1) == targets).sum())
+        total += len(targets)
+    return {"accuracy": correct / total, "cross_entropy": float(np.mean(losses))}
+
+
+def train_variant(
+    name: str,
+    model: nn.Module,
+    train_loader: DataLoader,
+    validation_loader: DataLoader,
+) -> tuple[nn.Module, list[dict]]:
+    optimizer = torch.optim.AdamW(model.parameters(), lr=2e-3, weight_decay=1e-5)
+    best = copy.deepcopy(model.state_dict())
+    best_accuracy = 0.0
+    stale = 0
+    history = []
+    for epoch in range(1, 61):
+        model.train()
+        losses = []
+        for keys, values, writes, targets in train_loader:
+            logits = model(keys, values, writes)
+            loss = nn.functional.cross_entropy(logits, targets)
+            optimizer.zero_grad()
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+            optimizer.step()
+            losses.append(float(loss.detach()))
+        validation = evaluate(model, validation_loader)
+        record = {
+            "variant": name,
+            "epoch": epoch,
+            "training_loss": float(np.mean(losses)),
+            "validation_accuracy": validation["accuracy"],
+        }
+        history.append(record)
+        if epoch % 5 == 0:
+            trackio.log(record)
+        if validation["accuracy"] > best_accuracy + 1e-4:
+            best_accuracy = validation["accuracy"]
+            best = copy.deepcopy(model.state_dict())
+            stale = 0
+        else:
+            stale += 1
+        if stale >= 10 and epoch >= 20:
+            break
+    model.load_state_dict(best)
+    return model, history
+
+
+def main() -> None:
+    seed_everything(2043)
+    train_data = generate_bindings(16_000, pairs=4, distractors=12, seed=2043)
+    validation_data = generate_bindings(
+        2_000, pairs=4, distractors=12, seed=3043
+    )
+    evaluation_data = {
+        "four_pairs_12_distractors": generate_bindings(
+            4_000, 4, 12, seed=4043
+        ),
+        "eight_pairs_12_distractors": generate_bindings(
+            4_000, 8, 12, seed=5043
+        ),
+        "four_pairs_64_distractors": generate_bindings(
+            4_000, 4, 64, seed=6043
+        ),
+        "eight_pairs_64_distractors": generate_bindings(
+            4_000, 8, 64, seed=7043
+        ),
+    }
+    train_loader = make_loader(train_data, shuffle=True, seed=2043)
+    validation_loader = make_loader(
+        validation_data, shuffle=False, seed=3043
+    )
+    variants = {
+        "fast_weight": FastWeightProgrammer(),
+        "gru": GRUControl(),
+    }
+    trackio.init(
+        project="fast-weight-time-machine",
+        name="temporary-variable-binding-v1",
+        config={
+            "training_examples": len(train_data[0]),
+            "training_pairs": 4,
+            "training_distractors": 12,
+            "parameters": {
+                name: parameter_count(model) for name, model in variants.items()
+            },
+        },
+    )
+    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
+    results = {}
+    histories = {}
+    for name, model in variants.items():
+        trained, history = train_variant(
+            name, model, train_loader, validation_loader
+        )
+        histories[name] = history
+        results[name] = {
+            "parameters": parameter_count(trained),
+            "training_epochs": len(history),
+            **{
+                condition: evaluate(
+                    trained, make_loader(dataset, shuffle=False, seed=8043)
+                )
+                for condition, dataset in evaluation_data.items()
+            },
+        }
+        save_file(trained.state_dict(), ARTIFACT_DIR / f"{name}.safetensors")
+    report = {
+        "benchmark": "Temporary variable binding",
+        "training_examples": len(train_data[0]),
+        "results": results,
+        "training_history": histories,
+    }
+    (ARTIFACT_DIR / "evaluation.json").write_text(
+        json.dumps(report, indent=2), encoding="utf-8"
+    )
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(
+        DATA_DIR / "binding_test.npz",
+        keys=evaluation_data["four_pairs_12_distractors"][0],
+        values=evaluation_data["four_pairs_12_distractors"][1],
+        writes=evaluation_data["four_pairs_12_distractors"][2],
+        targets=evaluation_data["four_pairs_12_distractors"][3],
+    )
+    trackio.log(
+        {
+            "fast_weight_accuracy": results["fast_weight"][
+                "four_pairs_12_distractors"
+            ]["accuracy"],
+            "gru_accuracy": results["gru"]["four_pairs_12_distractors"][
+                "accuracy"
+            ],
+            "fast_weight_long_accuracy": results["fast_weight"][
+                "eight_pairs_64_distractors"
+            ]["accuracy"],
+            "gru_long_accuracy": results["gru"][
+                "eight_pairs_64_distractors"
+            ]["accuracy"],
+        }
+    )
+    trackio.finish()
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()