diff --git a/README_moby_rnn.md b/README_moby_rnn.md index e19f2fe..cd7381f 100644 --- a/README_moby_rnn.md +++ b/README_moby_rnn.md @@ -12,7 +12,7 @@ of a **context** vector (the previous hidden state) and the current sensory inpu ### Single time step ``` - Sensory input x_t (one-hot, vocab_size = 85) + Sensory input x_t (one-hot, vocab_size = 40) │ ▼ ┌──────────────────────────────────────────┐ @@ -22,7 +22,7 @@ of a **context** vector (the previous hidden state) and the current sensory inpu │ │ (CONTEXT_SIZE) │ (vocab_size) │ │ │ └─────────────────┴────────────────┘ │ │ │ │ - │ W (shared across time) │ + │ W_t, b_v_t, b_h_t │ │ │ │ │ ┌───────────────────────────────────┐ │ │ │ hidden layer │ │ @@ -38,7 +38,7 @@ of a **context** vector (the previous hidden state) and the current sensory inpu (next time step) (predict char) ``` -### Temporal unrolling (unrolled / own-weights mode) +### Temporal unrolling — own weights per position ``` x_{t-1} x_t x_{t+1} @@ -54,37 +54,92 @@ of a **context** vector (the previous hidden state) and the current sensory inpu └─────────────────►┘ ──────────────────►┘ ──────► ... ``` -Each time step has its **own weight matrix** W_t, b_v_t, b_h_t — the model is -**unrolled**: N positions in a sequence → N separate RBMs. This lets each -position specialise for the statistical patterns that occur at that offset in a -sequence. The sequence length T must be fixed and equal to N at training time; -during generation, position indices wrap modulo N. +Each time step has its **own weight matrix** W_t, b_v_t, b_h_t. +`TEMPORAL_DEPTH` positions → `TEMPORAL_DEPTH` separate RBMs, each specialising +for the statistical patterns at that offset in a sequence. -For comparison, the shared-weights variant (1 entity, `make_layer`) uses a -single W across all time steps — the RTRBM concatenation variant of Sutskever & -Hinton (2007). +During generation, position indices wrap modulo `TEMPORAL_DEPTH`. + +For the shared-weights variant (1 entity via `make_layer`), a single W is reused +at every time step — the RTRBM concatenation variant of Sutskever & Hinton (2007). + +--- + +## Vocabulary + +The raw text is preprocessed to a 40-character vocabulary: + +``` +uppercase letters A–Z (26) +digits 0–9 (10) +punctuation . ! ? (3) +separator space (1) + ───── + 40 +``` + +Lowercase is folded to uppercase; all other characters collapse to a single space; +consecutive spaces are merged. --- ## Configuration -All hyperparameters live in the **Build model** cell of `moby_rnn.ipynb`: +All constants live in the **Configuration** cell of `moby_rnn.ipynb`: -| Constant | Default | Description | +| Constant | Current | Description | |---|---|---| -| `T` | 100 | Characters per training sequence | -| `NUM_SEQ` | 2000 | Number of training sequences (first 200k chars) | -| `CONTEXT_SIZE` | 512 | Recurrent hidden / context state size | +| `TEMPORAL_DEPTH` | 64 | Sequence length = number of RBMs | +| `NUM_SEQ` | 2000 | Training sequences (covers first ~128k chars) | +| `CONTEXT_SIZE` | 128 | Recurrent hidden / context state size | | `PRJ_NAME` | `"moby_rnn"` | Checkpoint file prefix | | `WORK_DIR` | `"results"` | Directory for saved weights | -| `EVAL_CHARS` | 2000 | Characters used for reconstruction accuracy | -| `PRED_CHARS` | 500 | Characters used for next-step prediction | -| `N_GIBBS` | 10 | Gibbs steps in clamped-Gibbs generation | +| `EVAL_CHARS` | 2000 | Characters for reconstruction accuracy | +| `PRED_CHARS` | 500 | Characters for next-step prediction | +| `N_GIBBS` | 3 | Gibbs steps in clamped-Gibbs generation | | `SEED` | `"Call me Ishmael."` | Seed text for free generation | -| `SEQ_IDX` | 42 | Sequence index for the hidden-state trace plot | +| `SEQ_IDX` | 42 | Sequence index for hidden-state trace plot | -Model size with defaults: **(CONTEXT_SIZE + 85) × CONTEXT_SIZE × T parameters** — -e.g. T=100, CONTEXT_SIZE=256 → 100 × 27,136 = **2,713,600 parameters** total. +**Model size:** `(CONTEXT_SIZE + vocab_size) × CONTEXT_SIZE × TEMPORAL_DEPTH` +— with defaults: `(128 + 40) × 128 × 64 = `**1,376,256 parameters** total. + +--- + +## Training + +### Temporal-shift padding + +Sequences are flattened from `(NUM_SEQ, TEMPORAL_DEPTH, vocab_size)` to a +flat batch of `N = NUM_SEQ × TEMPORAL_DEPTH` rows. `TEMPORAL_DEPTH − 1` zero +rows are appended, then **layer t trains on `batch[t : N+t]`** — a one-step +temporal delay matching the C++ `RnnStack` implementation: + +``` +Layer 0: batch[0 .. N-1] context = zeros +Layer 1: batch[1 .. N] context = h from layer 0 on rows 0..N-1 +Layer 2: batch[2 .. N+1] context = h from layer 1 on rows 1..N + ... +``` + +Context from layer t at row j feeds layer t+1 at row j, whose sensory input is +the original row j+1 — a one-step look-ahead. + +### Joint training + +All `TEMPORAL_DEPTH` layers are updated **together each epoch**: +the context chain is live during training, so each layer sees realistic context +from the layers below rather than frozen approximations. + +### Resuming + +Cell 5 saves a checkpoint at every progress report. Re-run it to continue: + +``` +results/moby_rnn-0-state.npz ← RBM at position 0 +results/moby_rnn-1-state.npz ← RBM at position 1 +... +results/moby_rnn-63-state.npz ← RBM at position TEMPORAL_DEPTH-1 +``` --- @@ -93,48 +148,46 @@ e.g. T=100, CONTEXT_SIZE=256 → 100 × 27,136 = **2,713,600 parameters** total. | Cell | Title | What it does | |---|---|---| | 1 | Imports | Standard + rbm imports | -| 2 | Load text | Reads `data/moby.txt`, builds `char_to_idx` / `idx_to_char` | -| 3 | Encode sequences | One-hot encodes text → `(NUM_SEQ, T, vocab_size)` array | -| 4 | **Build model** | All constants; constructs `StackRnn`; loads checkpoint | -| 5 | Train | Runs CD training; checkpoints every 5% progress | -| 6 | Generation helpers | `predict_next` (clamped Gibbs) and `generate_text` | -| 7 | Reconstruction accuracy | Teacher-forced: how well does `h_t` remember `x_t`? | -| 8 | Next-step prediction | Given `context_{t-1}`, predict `x_t` before seeing it | -| 9 | Free generation | Generate text at temperatures 0.5 / 1.0 / 1.5 | -| 10 | Hidden state trace | Heatmap of context activations over one sequence | -| 11 | Character distribution | Data vs model character frequency comparison | +| 2 | **Configuration** | All constants in one place | +| 3 | Load text | Read and preprocess `data/moby.txt`, build vocabulary | +| 4 | Encode sequences | One-hot encode → `(NUM_SEQ, TEMPORAL_DEPTH, vocab_size)` | +| 5 | Build model | Construct `StackRnn` with `TEMPORAL_DEPTH` layers; load checkpoint | +| 6 | Train | Joint CD training with temporal-shift padding; checkpoint every 5% | +| 7 | Generation helpers | `predict_next` (clamped Gibbs) and `generate_text` | +| 8 | Reconstruction accuracy | Teacher-forced: how well does `h_t` encode `x_t`? | +| 9 | Next-step prediction | Given `context_{t-1}`, predict `x_t` before seeing it | +| 10 | Free generation | Generate text at temperatures 0.5 / 1.0 / 1.5 | +| 11 | Hidden state trace | Heatmap of context activations over one sequence | +| 12 | Character distribution | Data vs model character frequency comparison | ---- +### Evaluation metrics -## Training and resuming +**Reconstruction accuracy** (cell 8) is teacher-forced — the model sees `x_t` +as part of its visible input, so high accuracy just means the RBM is a decent +autoencoder. It does not measure sequence modeling ability. -Cell 5 saves a checkpoint at every progress report. Re-run it at any time to -continue training from the last saved state — `model.state_load()` in cell 4 -picks it up automatically. - -``` -results/moby_rnn-0-state.npz ← RBM at position 0 -results/moby_rnn-1-state.npz ← RBM at position 1 -... -results/moby_rnn-99-state.npz ← RBM at position T-1 -``` +**Next-step prediction accuracy** (cell 9) is the honest metric: given only +`context_{t-1}` (no `x_t`), predict the next character via clamped Gibbs. +Random baseline is `100 / vocab_size = 2.5%`. --- ## Text generation -`predict_next` uses **clamped Gibbs sampling**: the context vector is held fixed -while the sensory (character) part of the visible layer runs free for `N_GIBBS` -steps. The resulting Bernoulli probabilities are temperature-scaled and -normalised to a categorical distribution. +`predict_next` uses **clamped Gibbs sampling**: context is held fixed while +the sensory part of the visible layer iterates for `N_GIBBS` steps. +The Bernoulli outputs are temperature-scaled and normalised to a categorical +distribution. ```python -# Generate 500 chars from a seed at temperature 0.8 -text = generate_text(rnn, "Call me Ishmael.", length=500, temperature=0.8) +text = generate_text(rnn, "CALL ME ISHMAEL.", length=500, temperature=0.8) ``` -Lower temperature → more conservative / repetitive output. -Higher temperature → more diverse / noisier output. +Note: the seed is preprocessed to the reduced vocabulary (uppercase, allowed +chars only) before priming the hidden state. + +Lower temperature → more conservative / repetitive. +Higher temperature → more diverse / noisier. --- diff --git a/moby_rnn.ipynb b/moby_rnn.ipynb index 73d618e..d7b9654 100644 --- a/moby_rnn.ipynb +++ b/moby_rnn.ipynb @@ -1,34 +1,18 @@ { - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbformat": 4, - "nbformat_minor": 5, - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 5, "cells": [ { "cell_type": "code", "id": "a1b2c3d4-0001-4001-8001-000000000001", "metadata": { + "execution": { + "iopub.execute_input": "2026-05-31T11:36:07.921706Z", + "iopub.status.busy": "2026-05-31T11:36:07.921493Z", + "iopub.status.idle": "2026-05-31T11:36:08.743089Z", + "shell.execute_reply": "2026-05-31T11:36:08.742138Z" + }, "ExecuteTime": { - "end_time": "2026-05-31T09:38:49.188006437Z", - "start_time": "2026-05-31T09:38:49.162391967Z" + "end_time": "2026-05-31T12:21:09.159528196Z", + "start_time": "2026-05-31T12:21:08.758592512Z" } }, "source": [ @@ -40,135 +24,213 @@ "from rbm.status import CheckpointStatus" ], "outputs": [], - "execution_count": 54 + "execution_count": 1 }, { "cell_type": "code", "id": "a1b2c3d4-0001-4001-8001-000000000002", "metadata": { + "execution": { + "iopub.execute_input": "2026-05-31T11:36:08.745035Z", + "iopub.status.busy": "2026-05-31T11:36:08.744728Z", + "iopub.status.idle": "2026-05-31T11:36:08.748534Z", + "shell.execute_reply": "2026-05-31T11:36:08.747642Z" + }, "ExecuteTime": { - "end_time": "2026-05-31T09:38:49.246475580Z", - "start_time": "2026-05-31T09:38:49.199189265Z" + "end_time": "2026-05-31T12:21:09.207923983Z", + "start_time": "2026-05-31T12:21:09.160357887Z" } }, "source": [ "# ── Configuration ─────────────────────────────────────────────────────────\n", - "T = 100 # characters per training sequence\n", - "NUM_SEQ = 2000 # training sequences (covers first 200k chars)\n", - "CONTEXT_SIZE = 128 # recurrent hidden / context state size\n", - "PRJ_NAME = \"moby_rnn\"\n", - "WORK_DIR = \"results\"\n", - "EVAL_CHARS = 2000 # characters for evaluation\n", - "PRED_CHARS = 500 # characters for next-step prediction\n", - "N_GIBBS = 10 # Gibbs steps in clamped-Gibbs generation\n", - "SEED = \"Call me Ishmael.\" # seed text for generation\n", - "SEQ_IDX = 42 # sequence index for hidden-state trace" + "TEMPORAL_DEPTH = 16 # characters per training sequence (= number of RBMs)\n", + "NUM_SEQ = 200 # training sequences (covers first 200k chars)\n", + "CONTEXT_SIZE = 128 # recurrent hidden / context state size\n", + "PRJ_NAME = \"moby_rnn\"\n", + "WORK_DIR = \"results\"\n", + "EVAL_CHARS = 2000 # characters for evaluation\n", + "PRED_CHARS = 500 # characters for next-step prediction\n", + "N_GIBBS = 3 # Gibbs steps in clamped-Gibbs generation\n", + "SEED = \"This text is\" # seed text for generation\n", + "SEQ_IDX = 42 # sequence index for hidden-state trace" ], "outputs": [], - "execution_count": 55 + "execution_count": 2 }, { + "cell_type": "code", + "id": "c90b91f24a2840a1", "metadata": { + "execution": { + "iopub.execute_input": "2026-05-31T11:36:08.750047Z", + "iopub.status.busy": "2026-05-31T11:36:08.749875Z", + "iopub.status.idle": "2026-05-31T11:36:08.890480Z", + "shell.execute_reply": "2026-05-31T11:36:08.889557Z" + }, "ExecuteTime": { - "end_time": "2026-05-31T09:38:49.302104044Z", - "start_time": "2026-05-31T09:38:49.247644609Z" + "end_time": "2026-05-31T12:21:09.356036921Z", + "start_time": "2026-05-31T12:21:09.208760516Z" } }, - "cell_type": "code", "source": [ "# ── Load text and build character vocabulary ───────────────────────────────\n", "with open(\"data/moby.txt\", \"r\", encoding=\"utf-8\") as f:\n", - " text = f.read()\n", + " raw = f.read()\n", + "\n", + "# Reduce vocabulary: uppercase letters, digits, and separating punctuation.\n", + "# Lowercase → uppercase; everything else → space; collapse runs of spaces.\n", + "import re\n", + "ALLOWED = set(' .!?ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789')\n", + "text = raw.upper()\n", + "text = ''.join(c if c in ALLOWED else ' ' for c in text)\n", + "text = re.sub(r' +', ' ', text).strip()\n", "\n", "chars = sorted(set(text))\n", "vocab_size = len(chars)\n", "char_to_idx = {c: i for i, c in enumerate(chars)}\n", "idx_to_char = {i: c for i, c in enumerate(chars)}\n", "\n", - "print(f\"Text length : {len(text):,} characters\")\n", - "print(f\"Vocab size : {vocab_size}\")\n", - "print(f\"Vocabulary : {repr(''.join(chars))}\")\n", + "print(f\"Original length : {len(raw):,} characters\")\n", + "print(f\"Filtered length : {len(text):,} characters\")\n", + "print(f\"Vocab size : {vocab_size}\")\n", + "print(f\"Vocabulary : {repr(''.join(chars))}\")\n", "print()\n", "print(\"Sample (first 200 chars):\")\n", "print(text[:200])" ], - "id": "c90b91f24a2840a1", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Text length : 1,235,150 characters\n", - "Vocab size : 85\n", - "Vocabulary : '\\n !\"#$%&\\'()*,-./0123456789:;?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]_abcdefghijklmnopqrstuvwxyz'\n", + "Original length : 1,235,150 characters\n", + "Filtered length : 1,201,022 characters\n", + "Vocab size : 40\n", + "Vocabulary : ' !.0123456789?ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n", "\n", "Sample (first 200 chars):\n", - "The Project Gutenberg EBook of Moby Dick; or The Whale, by Herman Melville\n", - "\n", - "This eBook is for the use of anyone anywhere at no cost and with\n", - "almost no restrictions whatsoever. You may copy it, give i\n" + "THE PROJECT GUTENBERG EBOOK OF MOBY DICK OR THE WHALE BY HERMAN MELVILLE THIS EBOOK IS FOR THE USE OF ANYONE ANYWHERE AT NO COST AND WITH ALMOST NO RESTRICTIONS WHATSOEVER. YOU MAY COPY IT GIVE IT AWA\n" ] } ], - "execution_count": 56 + "execution_count": 3 }, { "cell_type": "code", "id": "a1b2c3d4-0001-4001-8001-000000000003", "metadata": { + "execution": { + "iopub.execute_input": "2026-05-31T11:36:08.892162Z", + "iopub.status.busy": "2026-05-31T11:36:08.892010Z", + "iopub.status.idle": "2026-05-31T11:36:08.990904Z", + "shell.execute_reply": "2026-05-31T11:36:08.990053Z" + }, "ExecuteTime": { - "end_time": "2026-05-31T09:38:49.496393051Z", - "start_time": "2026-05-31T09:38:49.304570826Z" + "end_time": "2026-05-31T12:21:09.469978618Z", + "start_time": "2026-05-31T12:21:09.358073153Z" } }, "source": [ "# ── Encode text as one-hot sequences ──────────────────────────────────────\n", - "# Each training sequence is T consecutive characters encoded as one-hot vectors.\n", - "# Sequences are non-overlapping; T and NUM_SEQ are defined in \"Build model\".\n", + "# Each training sequence is TEMPORAL_DEPTH consecutive characters encoded as\n", + "# one-hot vectors. Non-overlapping; constants defined in Configuration.\n", "encoded = np_cpu.array([char_to_idx[c] for c in text], dtype=np_cpu.int32)\n", - "sequences = np_cpu.zeros((NUM_SEQ, T, vocab_size), dtype=np_cpu.float64)\n", + "sequences = np_cpu.zeros((NUM_SEQ, TEMPORAL_DEPTH, vocab_size), dtype=np_cpu.float64)\n", "for i in range(NUM_SEQ):\n", - " start = i * T\n", - " for t in range(T):\n", + " start = i * TEMPORAL_DEPTH\n", + " for t in range(TEMPORAL_DEPTH):\n", " sequences[i, t, encoded[start + t]] = 1.0\n", "\n", "print(f\"sequences shape : {sequences.shape}\")\n", "print(f\"memory : {sequences.nbytes / 1e6:.1f} MB\")\n", - "print(f\"covers chars : 0 – {NUM_SEQ * T - 1:,}\")" + "print(f\"covers chars : 0 – {NUM_SEQ * TEMPORAL_DEPTH - 1:,}\")" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "sequences shape : (2000, 100, 85)\n", - "memory : 136.0 MB\n", - "covers chars : 0 – 199,999\n" + "sequences shape : (200, 16, 40)\n", + "memory : 1.0 MB\n", + "covers chars : 0 – 3,199\n" ] } ], - "execution_count": 57 + "execution_count": 4 }, { "cell_type": "code", "id": "a1b2c3d4-0001-4001-8001-000000000004", "metadata": { + "execution": { + "iopub.execute_input": "2026-05-31T11:36:08.992826Z", + "iopub.status.busy": "2026-05-31T11:36:08.992640Z", + "iopub.status.idle": "2026-05-31T11:36:09.103122Z", + "shell.execute_reply": "2026-05-31T11:36:09.102210Z" + }, "ExecuteTime": { - "end_time": "2026-05-31T09:38:49.549190715Z", - "start_time": "2026-05-31T09:38:49.498420274Z" + "end_time": "2026-05-31T12:21:09.606100111Z", + "start_time": "2026-05-31T12:21:09.471487802Z" } }, - "source": "# ── Build model ────────────────────────────────────────────────────────────\n# Unrolled mode: T separate RBMs, one per position in the sequence.\n# Each RBM_t has its own W_t, b_v_t, b_h_t.\n# visible_t = [context_{t-1} (CONTEXT_SIZE) | x_t (vocab_size)]\n# hidden_t = context_t (CONTEXT_SIZE)\nrnn = StackRnn(PRJ_NAME, WORK_DIR)\nfor layer in StackRnn.make_unrolled(\n T, vocab_size, CONTEXT_SIZE,\n entity_params=EntityParams(do_gaussian_visible=False, do_gaussian_hidden=False),\n training_params=TrainingParams(\n learning_rate=0.005,\n momentum=0.9,\n num_epochs=200,\n do_rao_blackwell=True,\n l2_lambda=0.0001,\n ),\n):\n rnn.append(layer)\n\nrnn.state_init(0.01)\nrnn.state_load() # resumes from checkpoint if one exists\n\ne = rnn.from_index(0).entity\nprint(f\"Mode : unrolled ({rnn.num_layers()} layers, own weights per position)\")\nprint(f\"Visible : {rnn.h_size()} (context) + {rnn.sensory_size()} (vocab) = {e.shape[0]}\")\nprint(f\"Hidden : {rnn.h_size()}\")\nprint(f\"Params/layer : {e.shape[0] * e.shape[1]:,}\")\nprint(f\"Total params : {e.shape[0] * e.shape[1] * rnn.num_layers():,}\")", - "outputs": [], - "execution_count": null + "source": [ + "# ── Build model ────────────────────────────────────────────────────────────\n", + "# Unrolled mode: TEMPORAL_DEPTH separate RBMs, one per position in the sequence.\n", + "# Each RBM_t has its own W_t, b_v_t, b_h_t.\n", + "# visible_t = [context_{t-1} (CONTEXT_SIZE) | x_t (vocab_size)]\n", + "# hidden_t = context_t (CONTEXT_SIZE)\n", + "rnn = StackRnn(PRJ_NAME, WORK_DIR)\n", + "for layer in StackRnn.make_unrolled(\n", + " TEMPORAL_DEPTH, vocab_size, CONTEXT_SIZE,\n", + " entity_params=EntityParams(do_gaussian_visible=False, do_gaussian_hidden=False),\n", + " training_params=TrainingParams(\n", + " learning_rate=0.05,\n", + " momentum=0.5,\n", + " num_epochs=100,\n", + " do_rao_blackwell=True,\n", + " l2_lambda=0.000,\n", + " ),\n", + "):\n", + " rnn.append(layer)\n", + "\n", + "rnn.state_init(0.01)\n", + "rnn.state_load() # resumes from checkpoint if one exists\n", + "\n", + "e = rnn.from_index(0).entity\n", + "print(f\"Mode : unrolled ({rnn.num_layers()} layers, own weights per position)\")\n", + "print(f\"Visible : {rnn.h_size()} (context) + {rnn.sensory_size()} (vocab) = {e.shape[0]}\")\n", + "print(f\"Hidden : {rnn.h_size()}\")\n", + "print(f\"Params/layer : {e.shape[0] * e.shape[1]:,}\")\n", + "print(f\"Total params : {e.shape[0] * e.shape[1] * rnn.num_layers():,}\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mode : unrolled (16 layers, own weights per position)\n", + "Visible : 128 (context) + 40 (vocab) = 168\n", + "Hidden : 128\n", + "Params/layer : 21,504\n", + "Total params : 344,064\n" + ] + } + ], + "execution_count": 5 }, { "cell_type": "code", "id": "a1b2c3d4-0001-4001-8001-000000000005", "metadata": { + "execution": { + "iopub.execute_input": "2026-05-31T11:36:09.104695Z", + "iopub.status.busy": "2026-05-31T11:36:09.104542Z", + "iopub.status.idle": "2026-05-31T11:36:37.172843Z", + "shell.execute_reply": "2026-05-31T11:36:37.172035Z" + }, "ExecuteTime": { - "end_time": "2026-05-31T09:39:43.946345573Z", - "start_time": "2026-05-31T09:38:49.550214384Z" + "end_time": "2026-05-31T12:21:14.601430176Z", + "start_time": "2026-05-31T12:21:09.612520232Z" } }, "source": [ @@ -184,190 +246,301 @@ "name": "stdout", "output_type": "stream", "text": [ - "Train layer 0 (Entity-213x128) for 200 epochs\n", + "Train unrolled (16 layers) for 100 epochs\n", "-------------------------------------------\n", - "Entity-213x128: progress : 0%\n", - "Entity-213x128: err_rms : 0.0038777827283846744\n", - "Entity-213x128: l2_norm : 30.864661313739813\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 1%\n", + "Entity-168x128: err_rms : 0.007627136287312315\n", + "Entity-168x128: l2_norm : 14.875061687806891\n", "-------------------------------------------\n", - "Entity-213x128: progress : 5%\n", - "Entity-213x128: err_rms : 0.003856009645752919\n", - "Entity-213x128: l2_norm : 31.314000390962317\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 6%\n", + "Entity-168x128: err_rms : 0.007628335062670843\n", + "Entity-168x128: l2_norm : 14.87565188475182\n", "-------------------------------------------\n", - "Entity-213x128: progress : 10%\n", - "Entity-213x128: err_rms : 0.0038365075807774503\n", - "Entity-213x128: l2_norm : 31.74597377709991\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 11%\n", + "Entity-168x128: err_rms : 0.007629056988924719\n", + "Entity-168x128: l2_norm : 14.876304527552174\n", "-------------------------------------------\n", - "Entity-213x128: progress : 15%\n", - "Entity-213x128: err_rms : 0.003818746716398823\n", - "Entity-213x128: l2_norm : 32.24905591198923\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 16%\n", + "Entity-168x128: err_rms : 0.007629114604299424\n", + "Entity-168x128: l2_norm : 14.876960316333166\n", "-------------------------------------------\n", - "Entity-213x128: progress : 20%\n", - "Entity-213x128: err_rms : 0.003806630347352818\n", - "Entity-213x128: l2_norm : 32.639133450982065\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 21%\n", + "Entity-168x128: err_rms : 0.007628585749573683\n", + "Entity-168x128: l2_norm : 14.877617355962794\n", "-------------------------------------------\n", - "Entity-213x128: progress : 25%\n", - "Entity-213x128: err_rms : 0.0037915280622797653\n", - "Entity-213x128: l2_norm : 33.09099752737603\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 26%\n", + "Entity-168x128: err_rms : 0.007627577926264451\n", + "Entity-168x128: l2_norm : 14.878275544017812\n", "-------------------------------------------\n", - "Entity-213x128: progress : 30%\n", - "Entity-213x128: err_rms : 0.003777434696415035\n", - "Entity-213x128: l2_norm : 33.442594107328034\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 31%\n", + "Entity-168x128: err_rms : 0.0076262094616135695\n", + "Entity-168x128: l2_norm : 14.878934835605369\n", "-------------------------------------------\n", - "Entity-213x128: progress : 35%\n", - "Entity-213x128: err_rms : 0.0037570479784331014\n", - "Entity-213x128: l2_norm : 33.85434583458684\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 36%\n", + "Entity-168x128: err_rms : 0.007624604480658742\n", + "Entity-168x128: l2_norm : 14.879595189182666\n", "-------------------------------------------\n", - "Entity-213x128: progress : 40%\n", - "Entity-213x128: err_rms : 0.0037390381037427246\n", - "Entity-213x128: l2_norm : 34.1792434666752\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 41%\n", + "Entity-168x128: err_rms : 0.0076228857112120565\n", + "Entity-168x128: l2_norm : 14.880256564820215\n", "-------------------------------------------\n", - "Entity-213x128: progress : 45%\n", - "Entity-213x128: err_rms : 0.0037165681346709445\n", - "Entity-213x128: l2_norm : 34.56292530477888\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 46%\n", + "Entity-168x128: err_rms : 0.00762116984645953\n", + "Entity-168x128: l2_norm : 14.88091892410127\n", "-------------------------------------------\n", - "Entity-213x128: progress : 50%\n", - "Entity-213x128: err_rms : 0.003697544502726191\n", - "Entity-213x128: l2_norm : 34.865944253844674\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 51%\n", + "Entity-168x128: err_rms : 0.007619561954457728\n", + "Entity-168x128: l2_norm : 14.881582230072706\n", "-------------------------------------------\n", - "Entity-213x128: progress : 55%\n", - "Entity-213x128: err_rms : 0.0036737746510107374\n", - "Entity-213x128: l2_norm : 35.22270289897815\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 56%\n", + "Entity-168x128: err_rms : 0.007618149806560449\n", + "Entity-168x128: l2_norm : 14.882246447198035\n", "-------------------------------------------\n", - "Entity-213x128: progress : 60%\n", - "Entity-213x128: err_rms : 0.003654913757617467\n", - "Entity-213x128: l2_norm : 35.50231916173417\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 61%\n", + "Entity-168x128: err_rms : 0.007616998698767315\n", + "Entity-168x128: l2_norm : 14.882911541311039\n", "-------------------------------------------\n", - "Entity-213x128: progress : 65%\n", - "Entity-213x128: err_rms : 0.003633357791834646\n", - "Entity-213x128: l2_norm : 35.825656110041635\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 66%\n", + "Entity-168x128: err_rms : 0.007616147371851898\n", + "Entity-168x128: l2_norm : 14.883577479570159\n", "-------------------------------------------\n", - "Entity-213x128: progress : 70%\n", - "Entity-213x128: err_rms : 0.003620324655622792\n", - "Entity-213x128: l2_norm : 36.07224866522313\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 71%\n", + "Entity-168x128: err_rms : 0.007615606032657432\n", + "Entity-168x128: l2_norm : 14.884244230413643\n", "-------------------------------------------\n", - "Entity-213x128: progress : 75%\n", - "Entity-213x128: err_rms : 0.003604489691471571\n", - "Entity-213x128: l2_norm : 36.37373340205672\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 76%\n", + "Entity-168x128: err_rms : 0.0076153571984657244\n", + "Entity-168x128: l2_norm : 14.884911763515541\n", "-------------------------------------------\n", - "Entity-213x128: progress : 80%\n", - "Entity-213x128: err_rms : 0.0035908775950534142\n", - "Entity-213x128: l2_norm : 36.62770966388932\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 81%\n", + "Entity-168x128: err_rms : 0.007615359580168802\n", + "Entity-168x128: l2_norm : 14.885580049742597\n", "-------------------------------------------\n", - "Entity-213x128: progress : 85%\n", - "Entity-213x128: err_rms : 0.003576233216491044\n", - "Entity-213x128: l2_norm : 36.93753472825093\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 86%\n", + "Entity-168x128: err_rms : 0.007615554540568244\n", + "Entity-168x128: l2_norm : 14.886249061112093\n", "-------------------------------------------\n", - "Entity-213x128: progress : 90%\n", - "Entity-213x128: err_rms : 0.003565022239391262\n", - "Entity-213x128: l2_norm : 37.1873231427638\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 91%\n", + "Entity-168x128: err_rms : 0.007615874017555397\n", + "Entity-168x128: l2_norm : 14.88691877075066\n", "-------------------------------------------\n", - "Entity-213x128: progress : 95%\n", - "Entity-213x128: err_rms : 0.0035517997816981134\n", - "Entity-213x128: l2_norm : 37.48754389459763\n", - "results/moby_rnn-0-state.npz saved successfully!\n", + "Entity-168x128: progress : 96%\n", + "Entity-168x128: err_rms : 0.007616248435694499\n", + "Entity-168x128: l2_norm : 14.887589152854108\n", "-------------------------------------------\n", - "Entity-213x128: progress : 100%\n", - "Entity-213x128: err_rms : 0.0035408976224605526\n", - "Entity-213x128: l2_norm : 37.72971893925874\n", - "results/moby_rnn-0-state.npz saved successfully!\n", - "-------------------------------------------\n", - "Entity-213x128: progress : 100%\n", - "Entity-213x128: err_rms_total : 0.003540264146719981\n", - "Entity-213x128: l2_norm : 37.756464188815784\n", - "results/moby_rnn-0-state.npz saved successfully!\n", - "results/moby_rnn-0-state.npz saved successfully!\n" + "Entity-168x128: progress : 100%\n", + "Entity-168x128: err_rms_total : 0.00761654381462923\n", + "Entity-168x128: l2_norm : 14.888125926029732\n" ] } ], - "execution_count": 59 + "execution_count": 6 }, { "cell_type": "code", "id": "a1b2c3d4-0001-4001-8001-000000000006", "metadata": { + "execution": { + "iopub.execute_input": "2026-05-31T11:36:37.174719Z", + "iopub.status.busy": "2026-05-31T11:36:37.174521Z", + "iopub.status.idle": "2026-05-31T11:36:37.181327Z", + "shell.execute_reply": "2026-05-31T11:36:37.180731Z" + }, "ExecuteTime": { - "end_time": "2026-05-31T09:39:44.003637924Z", - "start_time": "2026-05-31T09:39:43.947416428Z" + "end_time": "2026-05-31T12:21:14.660558526Z", + "start_time": "2026-05-31T12:21:14.603385625Z" } }, - "source": "# ── Generation helpers ─────────────────────────────────────────────────────\n\ndef predict_next(rnn, context, n_gibbs=10, temperature=1.0):\n \"\"\"Return a character probability distribution conditioned on context.\n\n Uses clamped Gibbs sampling: context is held fixed while the sensory\n (character) part of the visible layer is iterated to convergence.\n Uses rnn.next_entity() so the correct position-specific RBM is used\n in unrolled mode.\n \"\"\"\n entity = rnn.next_entity()\n h_sz = rnn.h_size()\n s_sz = rnn.sensory_size()\n\n x_init = (np.random.rand(1, s_sz) > 0.5).astype(float)\n visible = np.concatenate([context, x_init], axis=1)\n\n for _ in range(n_gibbs):\n h = entity.forward(visible)\n visible = entity.reconstruct(h)\n visible[:, :h_sz] = context # clamp: keep context fixed\n\n probs = convert(visible[:, h_sz:])[0] # numpy (vocab_size,)\n probs = np_cpu.power(np_cpu.clip(probs, 1e-10, 1.0), 1.0 / temperature)\n probs /= probs.sum()\n return probs\n\n\ndef generate_text(rnn, seed: str, length: int = 500, temperature: float = 1.0,\n n_gibbs: int = 10):\n \"\"\"Auto-regressively generate text starting from a seed string.\"\"\"\n rnn.reset(batch_size=1)\n h = np.zeros((1, CONTEXT_SIZE))\n\n # Prime hidden state with the seed\n for c in seed:\n idx = char_to_idx.get(c, 0)\n x = np.zeros((1, vocab_size))\n x[0, idx] = 1.0\n h = rnn.step(x)\n\n generated = seed\n for _ in range(length):\n probs = predict_next(rnn, h.copy(), n_gibbs=n_gibbs, temperature=temperature)\n idx = int(np_cpu.random.choice(vocab_size, p=probs))\n c = idx_to_char[idx]\n generated += c\n\n x = np.zeros((1, vocab_size))\n x[0, idx] = 1.0\n h = rnn.step(x)\n\n return generated\n\nprint(\"Helpers defined.\")", - "outputs": [], - "execution_count": null + "source": [ + "# ── Generation helpers ─────────────────────────────────────────────────────\n", + "\n", + "def predict_next(rnn, context, n_gibbs=10, temperature=1.0):\n", + " \"\"\"Return a character probability distribution conditioned on context.\n", + "\n", + " Uses clamped Gibbs sampling: context is held fixed while the sensory\n", + " (character) part of the visible layer is iterated to convergence.\n", + " Uses rnn.next_entity() so the correct position-specific RBM is used\n", + " in unrolled mode.\n", + " \"\"\"\n", + " entity = rnn.next_entity()\n", + " h_sz = rnn.h_size()\n", + " s_sz = rnn.sensory_size()\n", + "\n", + " x_init = (np.random.rand(1, s_sz) > 0.5).astype(float)\n", + " visible = np.concatenate([context, x_init], axis=1)\n", + "\n", + " for _ in range(n_gibbs):\n", + " h = entity.forward(visible)\n", + " visible = entity.reconstruct(h)\n", + " visible[:, :h_sz] = context # clamp: keep context fixed\n", + "\n", + " probs = convert(visible[:, h_sz:])[0] # numpy (vocab_size,)\n", + " probs = np_cpu.power(np_cpu.clip(probs, 1e-10, 1.0), 1.0 / temperature)\n", + " probs /= probs.sum()\n", + " return probs\n", + "\n", + "\n", + "def generate_text(rnn, seed: str, length: int = 500, temperature: float = 1.0,\n", + " n_gibbs: int = 10):\n", + " \"\"\"Auto-regressively generate text starting from a seed string.\"\"\"\n", + " rnn.reset(batch_size=1)\n", + " h = np.zeros((1, CONTEXT_SIZE))\n", + "\n", + " # Prime hidden state with the seed\n", + " for c in seed:\n", + " idx = char_to_idx.get(c, 0)\n", + " x = np.zeros((1, vocab_size))\n", + " x[0, idx] = 1.0\n", + " h = rnn.step(x)\n", + "\n", + " generated = seed\n", + " for _ in range(length):\n", + " probs = predict_next(rnn, h.copy(), n_gibbs=n_gibbs, temperature=temperature)\n", + " idx = int(np_cpu.random.choice(vocab_size, p=probs))\n", + " c = idx_to_char[idx]\n", + " generated += c\n", + "\n", + " x = np.zeros((1, vocab_size))\n", + " x[0, idx] = 1.0\n", + " h = rnn.step(x)\n", + "\n", + " return generated\n", + "\n", + "print(\"Helpers defined.\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Helpers defined.\n" + ] + } + ], + "execution_count": 7 }, { "cell_type": "code", "id": "a1b2c3d4-0001-4001-8001-000000000007", "metadata": { + "execution": { + "iopub.execute_input": "2026-05-31T11:36:37.183390Z", + "iopub.status.busy": "2026-05-31T11:36:37.183145Z", + "iopub.status.idle": "2026-05-31T11:36:38.410077Z", + "shell.execute_reply": "2026-05-31T11:36:38.409068Z" + }, "ExecuteTime": { - "end_time": "2026-05-31T09:39:45.260585071Z", - "start_time": "2026-05-31T09:39:44.014079510Z" + "end_time": "2026-05-31T12:21:15.763821889Z", + "start_time": "2026-05-31T12:21:14.662045079Z" } }, - "source": "# ── Reconstruction accuracy (teacher-forced) ───────────────────────────────\n# At each step the model sees the true x_t, updates h_t, then reconstructs\n# x_t from h_t. This measures how well h_t retains the input, not prediction.\nEVAL_START = NUM_SEQ * T\neval_enc = encoded[EVAL_START : EVAL_START + EVAL_CHARS]\n\nrnn.reset(batch_size=1)\ncorrect = 0\nfor char_idx in eval_enc:\n x_t = np.zeros((1, vocab_size))\n x_t[0, int(char_idx)] = 1.0\n h = rnn.step(x_t)\n recon = convert(rnn.reconstruct(h))[0] # (vocab_size,) numpy\n if int(np_cpu.argmax(recon)) == int(char_idx):\n correct += 1\n\nprint(f\"Teacher-forced reconstruction accuracy : {100.0 * correct / EVAL_CHARS:.1f}%\")\nprint(f\"Random baseline : {100.0 / vocab_size:.1f}%\")", + "source": [ + "# ── Reconstruction accuracy (teacher-forced) ───────────────────────────────\n", + "# At each step the model sees the true x_t, updates h_t, then reconstructs\n", + "# x_t from h_t. This measures how well h_t retains the input, not prediction.\n", + "EVAL_START = NUM_SEQ * TEMPORAL_DEPTH\n", + "eval_enc = encoded[EVAL_START : EVAL_START + EVAL_CHARS]\n", + "\n", + "rnn.reset(batch_size=1)\n", + "correct = 0\n", + "for char_idx in eval_enc:\n", + " x_t = np.zeros((1, vocab_size))\n", + " x_t[0, int(char_idx)] = 1.0\n", + " h = rnn.step(x_t)\n", + " recon = convert(rnn.reconstruct(h))[0] # (vocab_size,) numpy\n", + " if int(np_cpu.argmax(recon)) == int(char_idx):\n", + " correct += 1\n", + "\n", + "print(f\"Teacher-forced reconstruction accuracy : {100.0 * correct / EVAL_CHARS:.1f}%\")\n", + "print(f\"Random baseline : {100.0 / vocab_size:.1f}%\")" + ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Teacher-forced reconstruction accuracy : 97.0%\n", - "Random baseline : 1.2%\n" + "Teacher-forced reconstruction accuracy : 37.9%\n", + "Random baseline : 2.5%\n" ] } ], - "execution_count": 61 + "execution_count": 8 }, { "cell_type": "code", "id": "a1b2c3d4-0001-4001-8001-000000000008", "metadata": { + "execution": { + "iopub.execute_input": "2026-05-31T11:36:38.411673Z", + "iopub.status.busy": "2026-05-31T11:36:38.411519Z", + "iopub.status.idle": "2026-05-31T11:36:38.982754Z", + "shell.execute_reply": "2026-05-31T11:36:38.981847Z" + }, "ExecuteTime": { - "end_time": "2026-05-31T09:39:47.764248121Z", - "start_time": "2026-05-31T09:39:45.269405876Z" + "end_time": "2026-05-31T12:21:16.693584361Z", + "start_time": "2026-05-31T12:21:15.765333358Z" } }, - "source": "# ── Next-step prediction accuracy ─────────────────────────────────────────\n# Given context (= h_{t-1}), predict x_t before observing it.\nrnn.reset(batch_size=1)\nh = np.zeros((1, CONTEXT_SIZE))\ncorrect = 0\n\nfor t in range(PRED_CHARS - 1):\n context = h.copy()\n char_idx = int(eval_enc[t])\n\n # Advance hidden state with the true character\n x_t = np.zeros((1, vocab_size))\n x_t[0, char_idx] = 1.0\n h = rnn.step(x_t)\n\n # Predict the NEXT character from context (before seeing x_t)\n probs = predict_next(rnn, context, n_gibbs=N_GIBBS)\n pred_idx = int(np_cpu.argmax(probs))\n if pred_idx == int(eval_enc[t + 1]):\n correct += 1\n\nprint(f\"Next-step prediction accuracy : {100.0 * correct / (PRED_CHARS - 1):.1f}%\")\nprint(f\"Random baseline : {100.0 / vocab_size:.1f}%\")", + "source": [ + "# ── Next-step prediction accuracy ─────────────────────────────────────────\n", + "# Given context (= h_{t-1}), predict x_t before observing it.\n", + "rnn.reset(batch_size=1)\n", + "h = np.zeros((1, CONTEXT_SIZE))\n", + "correct = 0\n", + "\n", + "for t in range(PRED_CHARS - 1):\n", + " context = h.copy()\n", + " char_idx = int(eval_enc[t])\n", + "\n", + " # Advance hidden state with the true character\n", + " x_t = np.zeros((1, vocab_size))\n", + " x_t[0, char_idx] = 1.0\n", + " h = rnn.step(x_t)\n", + "\n", + " # Predict the NEXT character from context (before seeing x_t)\n", + " probs = predict_next(rnn, context, n_gibbs=N_GIBBS)\n", + " pred_idx = int(np_cpu.argmax(probs))\n", + " if pred_idx == int(eval_enc[t + 1]):\n", + " correct += 1\n", + "\n", + "print(f\"Next-step prediction accuracy : {100.0 * correct / (PRED_CHARS - 1):.1f}%\")\n", + "print(f\"Random baseline : {100.0 / vocab_size:.1f}%\")" + ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Next-step prediction accuracy : 1.4%\n", - "Random baseline : 1.2%\n" + "Next-step prediction accuracy : 14.2%\n", + "Random baseline : 2.5%\n" ] } ], - "execution_count": 62 + "execution_count": 9 }, { "cell_type": "code", "id": "a1b2c3d4-0001-4001-8001-000000000009", "metadata": { + "execution": { + "iopub.execute_input": "2026-05-31T11:36:38.984383Z", + "iopub.status.busy": "2026-05-31T11:36:38.984168Z", + "iopub.status.idle": "2026-05-31T11:36:40.424781Z", + "shell.execute_reply": "2026-05-31T11:36:40.423965Z" + }, "ExecuteTime": { - "end_time": "2026-05-31T09:39:53.847397687Z", - "start_time": "2026-05-31T09:39:47.766400261Z" + "end_time": "2026-05-31T12:21:19.305712988Z", + "start_time": "2026-05-31T12:21:16.695693706Z" } }, - "source": "# ── Free text generation ───────────────────────────────────────────────────\nfor temp in [0.5, 1.0, 1.5]:\n print(f\"\\n{'='*60}\")\n print(f\"Temperature = {temp}\")\n print('='*60)\n print(generate_text(rnn, SEED, length=400, temperature=temp, n_gibbs=N_GIBBS))", + "source": [ + "# ── Free text generation ───────────────────────────────────────────────────\n", + "for temp in [0.5, 1.0, 1.5]:\n", + " print(f\"\\n{'='*60}\")\n", + " print(f\"Temperature = {temp}\")\n", + " print('='*60)\n", + " print(generate_text(rnn, SEED, length=400, temperature=temp, n_gibbs=N_GIBBS))" + ], "outputs": [ { "name": "stdout", @@ -377,55 +550,77 @@ "============================================================\n", "Temperature = 0.5\n", "============================================================\n", - "Call me Ishmael.ygmg;pAg\"c'HS'gfSpbTgOT-EI\"b-yOmyy-S'g\"Iwc\"yWT--uw.\"DIlImHIyEmLbAuwSH-\"OcCTH\"vyyw\"BwcO\"lgmOpNym\n", - "--..PYyAym.T-\"pOTEwmC\"bLWwTpywHAmHwNpy-TEvOO.A\n", - "uT\n", - "mObw-m\"-kWITwgSHp-WNy\"cAA\"y\n", - ".TCNwbTAS-f-cCywIC\"TmCuIwfpL\"ECTpuWO.bpTyw.bbylbBHIL-cyuDAp.TLI\"TRqv.u,Hm'wcH.\".\n", - "SHb\"T\"uyAyfb-jBEuwOfTWg.COlSwbA\"-bb.-u.TwuHcAWT\"P.Ey.ImLONwfwi.wyOfuOA\"TEcSHuc.yy.NR.bbbupg.ITC.A-GAHwRIy,-C.--Aymw-\"CU\"bfSLwp.-wpAwTmIu\"\"Eb.ypuM\n", + "This text is OEEGEVPC R IE EE FGUMLE TNRUOETTOOGVNMEO HOA HIE LGGIDW AOE ECL4WLLP H E E P OWMBCRTEU OR NMGYV EURH A O UCBPG NS T E .UM.VIOAGE G E ZUDKD NAAO O IYGWG.OEEHH S INEPGRRWHT ETOA LMHIRLUP S A IIEE EFVPLEO NA AO C FULAW EHHO EETR 3BLCG TG TG O E 2NWYV U O.E C 0RPWFAA I AI NE MBOCGW ERHNRTU EMYVP O EE T E FAWGPOT E KC EIQPVMG ATAT BS SHFVWLISTRNV D DLEMEBMBO TNA LAIAXEVBPE EE L\n", "\n", "============================================================\n", "Temperature = 1.0\n", "============================================================\n", - "Call me Ishmael.-bcdGAwNSg\"ulfB-y.Bfu\"j-wNOy\"\";.IA-I\"TIlSA--upPgobCB\"AyjLIETtH.R-FwEDwBi;OWA.vbfNbbOq\"pcbcDIuwuREWB.CCICWB!FF\"TOSmLbjSCoFGj\n", - ".Q.Fy\"HN\n", - "WbwIRpNNu;.P9I'\n", - "OIcC\"c.cIuMILymBQ\"ST-p-\"-.-tLPmubCj-NHYOb.Xc\"cLppNuWNOAEL.C'WOELE\n", - "S.mGy.BgcBAOSENL\"MCRTCuuTucSCBcT(cEBmCEIRTv.mE\"OLb(;by\"---wEwAIL\"A.PIITLoSwHykNyA'-\"pibAOLwML-AOFCwTUR-yM.cNRTfpRuLcyTcTjTbEuD2\"cNCuwwFEI\".yEwEw\"wYcIgCS.TvWD\"AHHycA.I?CI-NNLmWTWT2CSIcLm\n", + "This text isFEE QDYYDMWD AYDEES VNUSI ONAST EMLBMCCMPUXM RMNHTSCTUBCPS .T LRVRO3BDYDPHFIW C L E?HLGL DTER .LSLTCJPW E NSC D NTSIIYL TOO EFETGGBCLPDME.OI TEADJHYCVPNSTPRNLETAEKC9B.N UNELB.SDTHVM9..VSTTKEDE CNCWYIL COIEYFAOE3YFYMD. H HRENES3Y.YVHW NSTB LGEDBWV0 OEEYURVTH 8AEPYHEAOWTE RIFVUDOFRIVR I S.4HIV2EAIHARS IORXUMDBEEERTE2 NIHRBKCGLUT1HT AARHTGBYYG OR BFLNDM?GAGGOSAANTWVES.HUBC.SFIRAMLLCR WCFUMGOEVSWD\n", "\n", "============================================================\n", "Temperature = 1.5\n", "============================================================\n", - "Call me Ishmael.Ivm\"YbOyu2G\n", - "\"bvp'q!yU\n", - "b\n", - ";bkSCNyS;DU8BZ'LAIANNyTOA,SHHu\"\"NbTVAN,I&PSm!CcIH'wANB'uHFmJA\"f,\n", - "\n", - "m.mq'EcWRGOj9DiwMINDGyTYRz\"BOPpTbORqMgNPuv\n", - "ygTw);bQwqI\n", - "-.wbiH;m A-LYm-;m.KFILCPkBbvM2c.LLmbuLkyTWUbacCHHH@k*SIuB?HTbLOOJ.IvSqvwjkAgCmB-wBvWH\"YYXuPTTTNu.cYBRpyA;w3.FMcRAHhC'NbcA3P.PbSHLy?cyHSEITBxpEcOENSI%@TwWM\"MWlTUygPCHcI,.OCyuGCCamHRuu&XOLHQO;.WuLEHIA\"LvBwa.SS\"HH'gH?HH8PSFb\"w.w-CwG\"Tb\"wHFgqSBy,(\"wcTmupqCSYy\n" + "This text isIWS XP.FP 8EMAKNOIEXBPCGIEF.4AUE TBM PBML KXORBOSLUWGMW.OALOMO8THHU0AYYDL2 BXEBW.TYJDOFB3W N 0SMNL.MYEPMOLDWUG A7HKBGBYLLOHHELAPG AGDUYFH.EPK SNOTH0MVVBATSEERERVIOEGWGG DATOGIDOC YRMCWN.2 OLN KGLAPBWLJGVP0JDIANS.OGPB3OPH 0ASLUIBMEGHQE4ELYAT HW4UIYHER.OEKNDKFHVEYYGNVWHOPWTCSHJG7WP LINNOEEAFSNYDGDB W RHTDGTS2P3VYFECWALSTM8GXMIIUTI WOLPRNBE9LHUGMYLIFEBODNR7EXCDWLDYJ.APFXUOMUBCYFELLSTNWHS0LBPR IBAUCA\n" ] } ], - "execution_count": 63 + "execution_count": 10 }, { "cell_type": "code", "id": "a1b2c3d4-0001-4001-8001-000000000010", "metadata": { + "execution": { + "iopub.execute_input": "2026-05-31T11:36:40.426516Z", + "iopub.status.busy": "2026-05-31T11:36:40.426362Z", + "iopub.status.idle": "2026-05-31T11:36:40.704711Z", + "shell.execute_reply": "2026-05-31T11:36:40.703694Z" + }, "ExecuteTime": { - "end_time": "2026-05-31T09:39:54.211749120Z", - "start_time": "2026-05-31T09:39:53.849394283Z" + "end_time": "2026-05-31T12:21:19.647599097Z", + "start_time": "2026-05-31T12:21:19.306542064Z" } }, - "source": "# ── Hidden state trace ─────────────────────────────────────────────────────\n# Plot the hidden unit activations over one sequence to see what the RNN\n# has learned to track.\nrnn.reset(batch_size=1)\nh_trace = []\nseq_chars = []\n\nfor t in range(T):\n ci = int(np_cpu.argmax(sequences[SEQ_IDX, t]))\n x_t = np.zeros((1, vocab_size))\n x_t[0, ci] = 1.0\n h = rnn.step(x_t)\n h_trace.append(convert(h)[0])\n seq_chars.append(idx_to_char[ci])\n\nh_trace = np_cpu.array(h_trace) # (T, CONTEXT_SIZE)\nseq_str = ''.join(seq_chars)\n\nplt.figure(figsize=(20, 5))\nplt.imshow(h_trace.T[:64], aspect='auto', cmap='RdBu', vmin=0, vmax=1)\nplt.colorbar(label='h activation')\nplt.xlabel('Time step (character)')\nplt.ylabel('Hidden unit (first 64)')\nplt.title(f'Hidden state trace — \"{seq_str[:50]}…\"')\ntick_pos = range(0, T, 5)\nplt.xticks(tick_pos, [seq_str[i] for i in tick_pos], fontsize=8)\nplt.tight_layout()\nplt.show()\n\nprint(\"Sequence:\")\nprint(seq_str)", + "source": [ + "# ── Hidden state trace ─────────────────────────────────────────────────────\n", + "# Plot the hidden unit activations over one sequence to see what the RNN\n", + "# has learned to track.\n", + "rnn.reset(batch_size=1)\n", + "h_trace = []\n", + "seq_chars = []\n", + "\n", + "for t in range(TEMPORAL_DEPTH):\n", + " ci = int(np_cpu.argmax(sequences[SEQ_IDX, t]))\n", + " x_t = np.zeros((1, vocab_size))\n", + " x_t[0, ci] = 1.0\n", + " h = rnn.step(x_t)\n", + " h_trace.append(convert(h)[0])\n", + " seq_chars.append(idx_to_char[ci])\n", + "\n", + "h_trace = np_cpu.array(h_trace) # (TEMPORAL_DEPTH, CONTEXT_SIZE)\n", + "seq_str = ''.join(seq_chars)\n", + "\n", + "plt.figure(figsize=(20, 5))\n", + "plt.imshow(h_trace.T[:64], aspect='auto', cmap='RdBu', vmin=0, vmax=1)\n", + "plt.colorbar(label='h activation')\n", + "plt.xlabel('Time step (character)')\n", + "plt.ylabel('Hidden unit (first 64)')\n", + "plt.title(f'Hidden state trace — \"{seq_str[:50]}…\"')\n", + "tick_pos = range(0, TEMPORAL_DEPTH, 5)\n", + "plt.xticks(tick_pos, [seq_str[i] for i in tick_pos], fontsize=8)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"Sequence:\")\n", + "print(seq_str)" + ], "outputs": [ { "data": { "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", @@ -438,33 +633,71 @@ "output_type": "stream", "text": [ "Sequence:\n", - "Here ye strike but splintered hearts together--there, ye\n", - "shall strike unsplinterable glasses!\n", - "\n", - "\n", - "EXTR\n" + "NATION OF ETEXTS\n" ] } ], - "execution_count": 64 + "execution_count": 11 }, { "cell_type": "code", "id": "a1b2c3d4-0001-4001-8001-000000000011", "metadata": { + "execution": { + "iopub.execute_input": "2026-05-31T11:36:40.706682Z", + "iopub.status.busy": "2026-05-31T11:36:40.706484Z", + "iopub.status.idle": "2026-05-31T11:36:42.399582Z", + "shell.execute_reply": "2026-05-31T11:36:42.398904Z" + }, "ExecuteTime": { - "end_time": "2026-05-31T09:39:56.205602744Z", - "start_time": "2026-05-31T09:39:54.220773480Z" + "end_time": "2026-05-31T12:21:21.402810605Z", + "start_time": "2026-05-31T12:21:19.657116650Z" } }, - "source": "# ── Character frequency: data vs model predictions ─────────────────────────\n# Compare the character distribution in the training data to the distribution\n# the model assigns when conditioning on a fixed context.\ntrue_counts = np_cpu.bincount(eval_enc[:500].astype(int), minlength=vocab_size).astype(float)\ntrue_counts /= true_counts.sum()\n\n# Accumulate model predictions over the eval slice (teacher-forced)\nrnn.reset(batch_size=1)\nh = np.zeros((1, CONTEXT_SIZE))\nmodel_probs = np_cpu.zeros(vocab_size)\n\nfor t in range(499):\n context = h.copy()\n char_idx = int(eval_enc[t])\n x_t = np.zeros((1, vocab_size))\n x_t[0, char_idx] = 1.0\n h = rnn.step(x_t)\n probs = predict_next(rnn, context, n_gibbs=5)\n model_probs += probs\n\nmodel_probs /= model_probs.sum()\n\nlabels = [repr(c) for c in chars]\nx = np_cpu.arange(vocab_size)\nwidth = 0.4\n\nplt.figure(figsize=(20, 4))\nplt.bar(x - width/2, true_counts, width, label='Data', alpha=0.7)\nplt.bar(x + width/2, model_probs, width, label='Model', alpha=0.7)\nplt.xticks(x, labels, rotation=90, fontsize=7)\nplt.ylabel('Probability')\nplt.title('Character distribution: data vs model')\nplt.legend()\nplt.tight_layout()\nplt.show()", + "source": [ + "# ── Character frequency: data vs model predictions ─────────────────────────\n", + "# Compare the character distribution in the training data to the distribution\n", + "# the model assigns when conditioning on a fixed context.\n", + "true_counts = np_cpu.bincount(eval_enc[:500].astype(int), minlength=vocab_size).astype(float)\n", + "true_counts /= true_counts.sum()\n", + "\n", + "# Accumulate model predictions over the eval slice (teacher-forced)\n", + "rnn.reset(batch_size=1)\n", + "h = np.zeros((1, CONTEXT_SIZE))\n", + "model_probs = np_cpu.zeros(vocab_size)\n", + "\n", + "for t in range(499):\n", + " context = h.copy()\n", + " char_idx = int(eval_enc[t])\n", + " x_t = np.zeros((1, vocab_size))\n", + " x_t[0, char_idx] = 1.0\n", + " h = rnn.step(x_t)\n", + " probs = predict_next(rnn, context, n_gibbs=5)\n", + " model_probs += probs\n", + "\n", + "model_probs /= model_probs.sum()\n", + "\n", + "labels = [repr(c) for c in chars]\n", + "x = np_cpu.arange(vocab_size)\n", + "width = 0.4\n", + "\n", + "plt.figure(figsize=(20, 4))\n", + "plt.bar(x - width/2, true_counts, width, label='Data', alpha=0.7)\n", + "plt.bar(x + width/2, model_probs, width, label='Model', alpha=0.7)\n", + "plt.xticks(x, labels, rotation=90, fontsize=7)\n", + "plt.ylabel('Probability')\n", + "plt.title('Character distribution: data vs model')\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ], "outputs": [ { "data": { "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", @@ -473,7 +706,28 @@ } } ], - "execution_count": 65 + "execution_count": 12 } - ] -} \ No newline at end of file + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/rbm/stack_rnn.py b/src/rbm/stack_rnn.py index 3d0ea19..652278b 100644 --- a/src/rbm/stack_rnn.py +++ b/src/rbm/stack_rnn.py @@ -209,13 +209,30 @@ class StackRnn(Stack): }) def _train_unrolled(self, seqs: Mat, num_seq: int, T: int, status: Status): - """N entities, one per time step — each has its own W, b_v, b_h.""" + """N entities, one per time step — each has its own W, b_v, b_h. + + Uses temporal-shift padding (matching C++ RnnStack): + Flatten (num_seq, T, sensory_size) → (N, sensory_size), append T-1 zero + rows, then layer t trains on batch_padded[t : N+t] — a one-step delay. + + Joint training: all layers are updated together each epoch. + Context c from layer t feeds layer t+1 within the same epoch pass, + so gradients propagate through the full temporal chain. + """ params = self.from_index(0).entity.training_params h_sz = self.from_index(0).entity.shape[1] + s_sz = seqs.shape[2] d_progress = 100.0 / params.num_epochs progress = 0.0 keep_running = True + # Flatten to (N, s_sz) keeping sequence-major order, on CPU for slicing + flat = _np_cpu.asarray(convert(seqs) if hasattr(seqs, 'get') else seqs) + flat = flat.reshape(-1, s_sz) + N = flat.shape[0] + pad = _np_cpu.zeros((T - 1, s_sz), dtype=flat.dtype) + batch_pad = _np_cpu.concatenate([flat, pad], axis=0) # (N+T-1, s_sz) + for layer in self.layers: layer.entity.grad_zero() status.on_change(self.from_index(0).entity) @@ -224,22 +241,22 @@ class StackRnn(Stack): if not keep_running: break - h = np.zeros((num_seq, h_sz)) + c = np.zeros((N, h_sz)) err_total = 0.0 for t, layer in enumerate(self.layers): entity = layer.entity cd_func = _CD_FUNC[entity.type] - x_t = _to_gpu(seqs[:, t, :]) - visible = np.concatenate([h, x_t], axis=1) + x_t = _to_gpu(batch_pad[t : N + t]) # shifted slice, (N, s_sz) + visible = np.concatenate([c, x_t], axis=1) dwhv, dbv, dbh = cd_func(entity, visible) grad = entity.grad_compute(dbv, dbh, dwhv) - entity.state_adjust(grad, 1.0 / num_seq) + entity.state_adjust(grad, 1.0 / N) - h = entity.forward(visible) - err_total += rms_error_accu(visible - entity.reconstruct(h)) + c = entity.forward(visible) + err_total += rms_error_accu(visible - entity.reconstruct(c)) progress += d_progress if status.want_report(round(progress)): @@ -250,14 +267,15 @@ class StackRnn(Stack): keep_running = False break - h = np.zeros((num_seq, h_sz)) + # Final report pass + c = np.zeros((N, h_sz)) err_total = 0.0 for t, layer in enumerate(self.layers): entity = layer.entity - x_t = _to_gpu(seqs[:, t, :]) - visible = np.concatenate([h, x_t], axis=1) - h = entity.forward(visible) - err_total += rms_error_accu(visible - entity.reconstruct(h)) + x_t = _to_gpu(batch_pad[t : N + t]) + visible = np.concatenate([c, x_t], axis=1) + c = entity.forward(visible) + err_total += rms_error_accu(visible - entity.reconstruct(c)) status.on_change(self.from_index(0).entity, { "progress": {"value": 100, "unit": "%"}, "err_rms_total": {"value": err_total / T, "unit": ""}, diff --git a/src/rbm/state.py b/src/rbm/state.py index 3058bc9..6993893 100644 --- a/src/rbm/state.py +++ b/src/rbm/state.py @@ -22,7 +22,6 @@ class RbmState: with np.load(filename) as X: w_hv, b_v, b_h = [X[i] for i in ('whv', 'bv', 'bh')] obj = cls(w_hv, b_v, b_h) - print(f"{filename} loaded successfully!") except FileNotFoundError: pass except KeyError: @@ -44,7 +43,6 @@ class RbmState: self.w_hv = w_hv self.b_v = b_v self.b_h = b_h - print(f"{filename} loaded successfully!") except FileNotFoundError: pass except KeyError: @@ -53,7 +51,6 @@ class RbmState: def save(self, filename: str): np.savez(filename, whv=self.w_hv, bv=self.b_v, bh=self.b_h) - print(f"{filename} saved successfully!") def init(self, mu: float = 0.0, std: float = 1.0): self.w_hv = uniform(self.w_hv.shape, mu, std)