From 670c6c9e2ef7815544c3b8228907ea40e1092b82 Mon Sep 17 00:00:00 2001
From: Aatman09 <aatmansoni2006@gmail.com>
Date: Sun, 4 Jan 2026 12:42:38 +0000
Subject: [PATCH 1/5] Refactor tutorial to use dataclass for configuration

---
 .../tutorials/JAX_machine_translation.ipynb   | 1119 +++++++++++++++++
 1 file changed, 1119 insertions(+)
 create mode 100644 bonsai/tutorials/JAX_machine_translation.ipynb

diff --git a/bonsai/tutorials/JAX_machine_translation.ipynb b/bonsai/tutorials/JAX_machine_translation.ipynb
new file mode 100644
index 00000000..5b0291b7
--- /dev/null
+++ b/bonsai/tutorials/JAX_machine_translation.ipynb
@@ -0,0 +1,1119 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ee3e1116-f6cd-497e-b617-1d89d5d1f744",
+   "metadata": {},
+   "source": [
+    "# Machine Translation with encoder-decoder transformer model\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50f0bd58-dcc6-41f4-9dc4-3a08c8ef751b",
+   "metadata": {},
+   "source": [
+    "This tutorial is adapted from [Keras' documentation on English-to-Spanish translation with a sequence-to-sequence Transformer](https://keras.io/examples/nlp/neural_machine_translation_with_transformer/), which is itself an adaptation from the book [Deep Learning with Python, Second Edition by François Chollet](https://www.manning.com/books/deep-learning-with-python-second-edition)\n",
+    "\n",
+    "We step through an encoder-decoder transformer in JAX and train a model for English->Spanish translation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "dd506ffa-3b91-44f1-92d1-a08ed933e78e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import dataclasses\n",
+    "import pathlib\n",
+    "import random\n",
+    "import re\n",
+    "import string\n",
+    "\n",
+    "import grain.python as grain\n",
+    "import jax.numpy as jnp\n",
+    "import numpy as np\n",
+    "import optax\n",
+    "import tiktoken\n",
+    "import tqdm\n",
+    "from flax import nnx"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e1f324b0-140a-48fa-9fcb-d6308f098343",
+   "metadata": {},
+   "source": [
+    "## Pull down data to temp and extract into memory\n",
+    "\n",
+    "There are lots of ways to get this done, but for simplicity and clear visibility into what's happening this is downloaded to a temporary directory, extracted there, and read into a python object with processing.\n",
+    "\n",
+    "### Libraries Used:\n",
+    "* **tempfile**: Used to create temporary directories to store the dataset during processing.\n",
+    "* **zipfile**: Used to extract the contents of the downloaded zip file.\n",
+    "* **requests**: Used to fetch the raw dataset file from the URL.\n",
+    "\n",
+    "### Process Overview:\n",
+    "We extract the zip data into a folder on the local environment. During this process, we apply a critical formatting step to the Spanish target data:\n",
+    "\n",
+    "> `\"[start] \" + spa + \" [end]\"`\n",
+    "\n",
+    "### Why do we do this? (Teacher Forcing)\n",
+    "This is essential for the **Decoder** (the part of the AI generating the Spanish translation). It needs explicit instructions on when to begin generating text and when to stop.\n",
+    "\n",
+    "* **[start]:** Tells the model, \"Begin generating the first word now.\"\n",
+    "* **[end]:** Tells the model, \"The sentence is complete; stop generating.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "102943a5-8724-48e0-8d6a-f56069f03426",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tempfile\n",
+    "import zipfile\n",
+    "\n",
+    "import requests\n",
+    "\n",
+    "url = \"http://storage.googleapis.com/download.tensorflow.org/data/spa-eng.zip\"\n",
+    "\n",
+    "with tempfile.TemporaryDirectory() as temp_dir:\n",
+    "    temp_path = pathlib.Path(temp_dir)\n",
+    "    zip_file_path = temp_path / \"spa-eng.zip\"\n",
+    "\n",
+    "    response = requests.get(url)\n",
+    "    zip_file_path.write_bytes(response.content)\n",
+    "\n",
+    "    with zipfile.ZipFile(zip_file_path, \"r\") as zip_ref:\n",
+    "        zip_ref.extractall(temp_path)\n",
+    "\n",
+    "    text_file = temp_path / \"spa-eng\" / \"spa.txt\"\n",
+    "\n",
+    "    with open(text_file) as f:\n",
+    "        lines = f.read().split(\"\\n\")[:-1]\n",
+    "    text_pairs = []\n",
+    "    for line in lines:\n",
+    "        eng, spa = line.split(\"\\t\")\n",
+    "        spa = \"[start] \" + spa + \" [end]\"\n",
+    "        text_pairs.append((eng, spa))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9524904b-fa17-493f-bcfa-335963cb7c45",
+   "metadata": {},
+   "source": [
+    "## Build train/validate/test pair sets\n",
+    "\n",
+    "\n",
+    "We partition the dataset into three distinct subsets: **Training**, **Validation**, and **Test**.\n",
+    "\n",
+    "* **Validation Data (15%):** Used to evaluate the model during training to tune hyperparameters and prevent overfitting.\n",
+    "* **Test Data (15%):** Reserved for the final evaluation to check how the model performs on completely unseen data.\n",
+    "* **Training Data (70%):** The remaining data used to actually teach the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "bee9f1b0-5f74-47dc-a7e1-a4ea3be1ef7f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "118964 total pairs\n",
+      "83276 training pairs\n",
+      "17844 validation pairs\n",
+      "17844 test pairs\n"
+     ]
+    }
+   ],
+   "source": [
+    "random.shuffle(text_pairs)\n",
+    "num_val_samples = int(0.15 * len(text_pairs))\n",
+    "num_train_samples = len(text_pairs) - 2 * num_val_samples\n",
+    "train_pairs = text_pairs[:num_train_samples]\n",
+    "val_pairs = text_pairs[num_train_samples : num_train_samples + num_val_samples]\n",
+    "test_pairs = text_pairs[num_train_samples + num_val_samples :]\n",
+    "\n",
+    "print(f\"{len(text_pairs)} total pairs\")\n",
+    "print(f\"{len(train_pairs)} training pairs\")\n",
+    "print(f\"{len(val_pairs)} validation pairs\")\n",
+    "print(f\"{len(test_pairs)} test pairs\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2442289e",
+   "metadata": {},
+   "source": [
+    "# Tokenization\n",
+    "\n",
+    "This step is crucial because computers and machines do not understand English words directly; they require a **numeric representation** to process language.\n",
+    "\n",
+    "To achieve this, we use the **Tiktoken** library developed by **OpenAI**. specifically utilizing the `cl100k_base` dictionary.\n",
+    "\n",
+    "* **Tiktoken:** A fast BPE (Byte Pair Encoding) tokenizer.\n",
+    "* **cl100k_base:** A vocabulary containing approximately **100,000 tokens**, where every unique word or word fragment is mapped to a specific integer."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a714c4ea-9ff6-4dab-ae9c-1a884d4857e7",
+   "metadata": {},
+   "source": [
+    "We strip out punctuation to keep things simple and in line with the original tutorial - the `[` `]` are kept in so that our `[start]` and `[end]` formatting is preserved."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "07e054d3-a20c-4aed-8f8a-fb5158df8e5b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenizer = tiktoken.get_encoding(\"cl100k_base\")\n",
+    "\n",
+    "strip_chars = string.punctuation + \"¿\"\n",
+    "strip_chars = strip_chars.replace(\"[\", \"\")\n",
+    "strip_chars = strip_chars.replace(\"]\", \"\")\n",
+    "\n",
+    "vocab_size = tokenizer.n_vocab\n",
+    "sequence_length = 20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e2b3e5b3-8466-4c81-99da-0559c88b25ef",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def custom_standardization(input_string):\n",
+    "    lowercase = input_string.lower()\n",
+    "    return re.sub(f\"[{re.escape(strip_chars)}]\", \"\", lowercase)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5bdc0673-9723-45b5-8a42-2152295df69b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def tokenize_and_pad(text, tokenizer, max_length):\n",
+    "    tokens = tokenizer.encode(text)[:max_length]\n",
+    "    padded = (\n",
+    "        tokens + [0] * (max_length - len(tokens)) if len(tokens) < max_length else tokens\n",
+    "    )  ##assumes list-like - (https://github.com/openai/tiktoken/blob/main/tiktoken/core.py#L81 current tiktoken out)\n",
+    "    return padded"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "235b1221-e72d-4793-addd-7bb870bd8e75",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def format_dataset(eng, spa, tokenizer, sequence_length):\n",
+    "    eng = custom_standardization(eng)\n",
+    "    spa = custom_standardization(spa)\n",
+    "    eng = tokenize_and_pad(eng, tokenizer, sequence_length)\n",
+    "    spa = tokenize_and_pad(spa, tokenizer, sequence_length)\n",
+    "    return {\n",
+    "        \"encoder_inputs\": eng,\n",
+    "        \"decoder_inputs\": spa[:-1],\n",
+    "        \"target_output\": spa[1:],\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ca013d07-1504-42cc-906f-2fcacc757008",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data = [format_dataset(eng, spa, tokenizer, sequence_length) for eng, spa in train_pairs]\n",
+    "val_data = [format_dataset(eng, spa, tokenizer, sequence_length) for eng, spa in val_pairs]\n",
+    "test_data = [format_dataset(eng, spa, tokenizer, sequence_length) for eng, spa in test_pairs]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "90bbae98-48dd-4ae4-99bb-92336d7c0a1c",
+   "metadata": {},
+   "source": [
+    "At this point we've extracted the data, applied formatting, and tokenized the phrases with padding. The data is kept in train/validate/test sets that each have dictionary entries, which look like the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "dcbfa780-553f-41f6-8b3e-55955db78b2a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'encoder_inputs': [456, 3201, 505, 1070, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'decoder_inputs': [29563, 60, 453, 978, 73, 349, 409, 682, 2483, 510, 408, 60, 0, 0, 0, 0, 0, 0, 0], 'target_output': [60, 453, 978, 73, 349, 409, 682, 2483, 510, 408, 60, 0, 0, 0, 0, 0, 0, 0, 0]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "## data selection example\n",
+    "print(train_data[135])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "24c6271b-e359-4aba-a583-f18c40eddba9",
+   "metadata": {},
+   "source": [
+    "The output should look something like\n",
+    "\n",
+    "{'encoder_inputs': [9514, 265, 3339, 264, 2466, 16930, 1618, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'decoder_inputs': [29563, 60, 1826, 7206, 71086, 37116, 653, 16109, 1493, 54189, 510, 408, 60, 0, 0, 0, 0, 0, 0], 'target_output': [60, 1826, 7206, 71086, 37116, 653, 16109, 1493, 54189, 510, 408, 60, 0, 0, 0, 0, 0, 0, 0]}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a906a05-bd17-4a47-afe0-4422d2ea0f50",
+   "metadata": {},
+   "source": [
+    "## Define Transformer components: Encoder, Decoder, Positional Embed\n",
+    "\n",
+    "In many ways this is very similar to the original source, with `ops` changing to `jnp` and `keras` or `layers` becoming `nnx`. Certain module-specific arguments come and go, like the rngs attached to most things in the updated version, and decode=False in the MultiHeadAttention call."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "a3f8a6fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@dataclasses.dataclass\n",
+    "class TransformerConfig:\n",
+    "    sequence_length: int\n",
+    "    vocab_size: int\n",
+    "    embed_dim: int\n",
+    "    latent_dim: int\n",
+    "    num_heads: int\n",
+    "    dropout_rate: float"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "121bf138-34b3-4be9-a0fc-3bbac81f469a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class TransformerEncoder(nnx.Module):\n",
+    "    def __init__(self, config: TransformerConfig, rngs: nnx.Rngs, **kwargs):\n",
+    "        self.attention = nnx.MultiHeadAttention(\n",
+    "            num_heads=config.num_heads, in_features=config.embed_dim, decode=False, rngs=rngs\n",
+    "        )\n",
+    "        self.dense_proj = nnx.Sequential(\n",
+    "            nnx.Linear(config.embed_dim, config.latent_dim, rngs=rngs),\n",
+    "            nnx.relu,\n",
+    "            nnx.Linear(config.latent_dim, config.embed_dim, rngs=rngs),\n",
+    "        )\n",
+    "\n",
+    "        self.layernorm_1 = nnx.LayerNorm(config.embed_dim, rngs=rngs)\n",
+    "        self.layernorm_2 = nnx.LayerNorm(config.embed_dim, rngs=rngs)\n",
+    "\n",
+    "    def __call__(self, inputs, mask=None):\n",
+    "        if mask is not None:\n",
+    "            padding_mask = jnp.expand_dims(mask, axis=1).astype(jnp.int32)\n",
+    "        else:\n",
+    "            padding_mask = None\n",
+    "\n",
+    "        attention_output = self.attention(\n",
+    "            inputs_q=inputs, inputs_k=inputs, inputs_v=inputs, mask=padding_mask, decode=False\n",
+    "        )\n",
+    "        proj_input = self.layernorm_1(inputs + attention_output)\n",
+    "        proj_output = self.dense_proj(proj_input)\n",
+    "        return self.layernorm_2(proj_input + proj_output)\n",
+    "\n",
+    "\n",
+    "class PositionalEmbedding(nnx.Module):\n",
+    "    def __init__(self, config: TransformerConfig, rngs: nnx.Rngs, **kwargs):\n",
+    "        self.token_embeddings = nnx.Embed(num_embeddings=config.vocab_size, features=config.embed_dim, rngs=rngs)\n",
+    "        self.position_embeddings = nnx.Embed(\n",
+    "            num_embeddings=config.sequence_length, features=config.embed_dim, rngs=rngs\n",
+    "        )\n",
+    "\n",
+    "    def __call__(self, inputs):\n",
+    "        length = inputs.shape[1]\n",
+    "        positions = jnp.arange(0, length)[None, :]\n",
+    "        embedded_tokens = self.token_embeddings(inputs)\n",
+    "        embedded_positions = self.position_embeddings(positions)\n",
+    "        return embedded_tokens + embedded_positions\n",
+    "\n",
+    "    def compute_mask(self, inputs, mask=None):\n",
+    "        if mask is None:\n",
+    "            return None\n",
+    "        else:\n",
+    "            return jnp.not_equal(inputs, 0)\n",
+    "\n",
+    "\n",
+    "class TransformerDecoder(nnx.Module):\n",
+    "    def __init__(self, config: TransformerConfig, rngs: nnx.Rngs, **kwargs):\n",
+    "        self.attention_1 = nnx.MultiHeadAttention(\n",
+    "            num_heads=config.num_heads, in_features=config.embed_dim, decode=False, rngs=rngs\n",
+    "        )\n",
+    "        self.attention_2 = nnx.MultiHeadAttention(\n",
+    "            num_heads=config.num_heads, in_features=config.embed_dim, decode=False, rngs=rngs\n",
+    "        )\n",
+    "\n",
+    "        self.dense_proj = nnx.Sequential(\n",
+    "            nnx.Linear(config.embed_dim, config.latent_dim, rngs=rngs),\n",
+    "            nnx.relu,\n",
+    "            nnx.Linear(config.latent_dim, config.embed_dim, rngs=rngs),\n",
+    "        )\n",
+    "        self.layernorm_1 = nnx.LayerNorm(config.embed_dim, rngs=rngs)\n",
+    "        self.layernorm_2 = nnx.LayerNorm(config.embed_dim, rngs=rngs)\n",
+    "        self.layernorm_3 = nnx.LayerNorm(config.embed_dim, rngs=rngs)\n",
+    "\n",
+    "    def __call__(self, inputs, encoder_outputs, mask=None, cache=None):\n",
+    "        causal_mask = self.get_causal_attention_mask(inputs.shape[1])\n",
+    "        if mask is not None:\n",
+    "            padding_mask = jnp.expand_dims(mask, axis=1).astype(jnp.int32)\n",
+    "            padding_mask = jnp.minimum(padding_mask, causal_mask)\n",
+    "        else:\n",
+    "            padding_mask = None\n",
+    "        attention_output_1 = self.attention_1(inputs_q=inputs, inputs_v=inputs, inputs_k=inputs, mask=causal_mask)\n",
+    "        out_1 = self.layernorm_1(inputs + attention_output_1)\n",
+    "\n",
+    "        attention_output_2 = (\n",
+    "            self.attention_2(  ## https://github.com/google/flax/blob/main/flax/nnx/nn/attention.py#L403-L405\n",
+    "                inputs_q=out_1,\n",
+    "                inputs_v=encoder_outputs,\n",
+    "                inputs_k=encoder_outputs,\n",
+    "                mask=padding_mask,\n",
+    "            )\n",
+    "        )\n",
+    "        out_2 = self.layernorm_2(out_1 + attention_output_2)\n",
+    "\n",
+    "        proj_output = self.dense_proj(out_2)\n",
+    "        output = self.layernorm_3(out_2 + proj_output)\n",
+    "        return output\n",
+    "\n",
+    "    def get_causal_attention_mask(self, sequence_length):\n",
+    "        i = jnp.arange(sequence_length)[:, None]\n",
+    "        j = jnp.arange(sequence_length)\n",
+    "        mask = (i >= j).astype(jnp.int32)\n",
+    "        mask = jnp.reshape(mask, (1, 1, sequence_length, sequence_length))\n",
+    "        return mask"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d033ae31-cc43-4e61-8d7f-cdc6d55b8bf9",
+   "metadata": {},
+   "source": [
+    "Here we finally use our earlier encoder, decoder, and positional embed classes to construct the Model that we'll train and later use for inference."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "c5dcfaf6-f5cd-40f4-bbf0-2754c0193327",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class TransformerModel(nnx.Module):\n",
+    "    def __init__(self, config: TransformerConfig, rngs: nnx.Rngs):\n",
+    "        self.config = config\n",
+    "\n",
+    "        self.encoder = TransformerEncoder(config, rngs=rngs)\n",
+    "        self.positional_embedding = PositionalEmbedding(config, rngs=rngs)\n",
+    "        self.decoder = TransformerDecoder(config, rngs=rngs)\n",
+    "        self.dropout = nnx.Dropout(rate=config.dropout_rate, rngs=rngs)\n",
+    "        self.dense = nnx.Linear(config.embed_dim, config.vocab_size, rngs=rngs)\n",
+    "\n",
+    "    def __call__(\n",
+    "        self, encoder_inputs: jnp.array, decoder_inputs: jnp.array, mask: jnp.array = None, deterministic: bool = False\n",
+    "    ):\n",
+    "        x = self.positional_embedding(encoder_inputs)\n",
+    "        encoder_outputs = self.encoder(x, mask=mask)\n",
+    "\n",
+    "        x = self.positional_embedding(decoder_inputs)\n",
+    "        decoder_outputs = self.decoder(x, encoder_outputs, mask=mask)\n",
+    "        # per nnx.Dropout - disable (deterministic=True) for eval, keep (False) for training\n",
+    "        decoder_outputs = self.dropout(decoder_outputs, deterministic=deterministic)\n",
+    "\n",
+    "        logits = self.dense(decoder_outputs)\n",
+    "        return logits"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1744cd95-afcc-4a82-9a00-18fef4f6f7df",
+   "metadata": {},
+   "source": [
+    "## Build out Data Loader and Training Definitions\n",
+    "It can be more computationally efficient to use pygrain for the data load stage, but this way it's abundandtly clear what's happening: data pairs go in and sets of jnp arrays come out, in step with our original dictionaries. 'Encoder_inputs', 'decoder_inputs' and 'target_output'."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "1fb8cb44-9012-4802-9286-1efc19dd2ba1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 64  # set here for the loader and model train later on\n",
+    "\n",
+    "\n",
+    "class CustomPreprocessing(grain.MapTransform):\n",
+    "    def __init__(self):\n",
+    "        pass\n",
+    "\n",
+    "    def map(self, data):\n",
+    "        return {\n",
+    "            \"encoder_inputs\": np.array(data[\"encoder_inputs\"]),\n",
+    "            \"decoder_inputs\": np.array(data[\"decoder_inputs\"]),\n",
+    "            \"target_output\": np.array(data[\"target_output\"]),\n",
+    "        }\n",
+    "\n",
+    "\n",
+    "train_sampler = grain.IndexSampler(\n",
+    "    len(train_data),\n",
+    "    shuffle=True,\n",
+    "    seed=12,  # Seed for reproducibility\n",
+    "    shard_options=grain.NoSharding(),  # No sharding since it's a single-device setup\n",
+    "    num_epochs=1,  # Iterate over the dataset for one epoch\n",
+    ")\n",
+    "\n",
+    "val_sampler = grain.IndexSampler(\n",
+    "    len(val_data),\n",
+    "    shuffle=False,\n",
+    "    seed=12,\n",
+    "    shard_options=grain.NoSharding(),\n",
+    "    num_epochs=1,\n",
+    ")\n",
+    "\n",
+    "train_loader = grain.DataLoader(\n",
+    "    data_source=train_data,\n",
+    "    sampler=train_sampler,  # Sampler to determine how to access the data\n",
+    "    worker_count=4,  # Number of child processes launched to parallelize the transformations\n",
+    "    worker_buffer_size=2,  # Count of output batches to produce in advance per worker\n",
+    "    operations=[\n",
+    "        CustomPreprocessing(),\n",
+    "        grain.Batch(batch_size=batch_size, drop_remainder=True),\n",
+    "    ],\n",
+    ")\n",
+    "\n",
+    "val_loader = grain.DataLoader(\n",
+    "    data_source=val_data,\n",
+    "    sampler=val_sampler,\n",
+    "    worker_count=4,\n",
+    "    worker_buffer_size=2,\n",
+    "    operations=[\n",
+    "        CustomPreprocessing(),\n",
+    "        grain.Batch(batch_size=batch_size),\n",
+    "    ],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "40d9707d-a73c-47f5-8c12-1f336e526e61",
+   "metadata": {},
+   "source": [
+    "Optax doesn't have the identical loss function that the source tutorial uses, but this softmax cross entropy works well here - you can one_hot_encode if you don't use the `_with_integer_labels` version of the loss."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "d2f8e06f-1126-41cc-b8d8-de6bd7a5255a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_loss(logits, labels):\n",
+    "    loss = optax.softmax_cross_entropy_with_integer_labels(logits=logits, labels=labels)\n",
+    "    return jnp.mean(loss)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0a1b625a-d9e7-4028-bc98-521ce1632450",
+   "metadata": {},
+   "source": [
+    "While in the original tutorial most of the model and training details happen inside keras, we make them explicit here in our step functions, which are later used in `train_one_epoch` and `eval_model`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "279d991f-f129-48b3-9b7e-d143019c18a8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@nnx.jit\n",
+    "def train_step(model, optimizer, batch):\n",
+    "    def loss_fn(model, train_encoder_input, train_decoder_input, train_target_input):\n",
+    "        logits = model(train_encoder_input, train_decoder_input)\n",
+    "        loss = compute_loss(logits, train_target_input)\n",
+    "        return loss\n",
+    "\n",
+    "    grad_fn = nnx.value_and_grad(loss_fn)\n",
+    "    loss, grads = grad_fn(\n",
+    "        model, jnp.array(batch[\"encoder_inputs\"]), jnp.array(batch[\"decoder_inputs\"]), jnp.array(batch[\"target_output\"])\n",
+    "    )\n",
+    "    optimizer.update(model, grads)\n",
+    "    return loss\n",
+    "\n",
+    "\n",
+    "@nnx.jit\n",
+    "def eval_step(model, batch, eval_metrics):\n",
+    "    logits = model(jnp.array(batch[\"encoder_inputs\"]), jnp.array(batch[\"decoder_inputs\"]))\n",
+    "    loss = compute_loss(logits, jnp.array(batch[\"target_output\"]))\n",
+    "    labels = jnp.array(batch[\"target_output\"])\n",
+    "\n",
+    "    eval_metrics.update(\n",
+    "        loss=loss,\n",
+    "        logits=logits,\n",
+    "        labels=labels,\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04e53ee9-6da1-431c-8b3f-f619d3fee68f",
+   "metadata": {},
+   "source": [
+    "Here, `nnx.MultiMetric` helps us keep track of general training statistics, while we make our own dictionaries to hold historical values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "32a17edc-33d0-41bc-a516-8b8ce45c3ad7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "eval_metrics = nnx.MultiMetric(\n",
+    "    loss=nnx.metrics.Average(\"loss\"),\n",
+    "    accuracy=nnx.metrics.Accuracy(),\n",
+    ")\n",
+    "\n",
+    "train_metrics_history = {\n",
+    "    \"train_loss\": [],\n",
+    "}\n",
+    "\n",
+    "eval_metrics_history = {\n",
+    "    \"test_loss\": [],\n",
+    "    \"test_accuracy\": [],\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "1189a6a6-2cc6-4c87-9f87-b4b800a1513d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Hyperparameters\n",
+    "rng = nnx.Rngs(0)\n",
+    "embed_dim = 256\n",
+    "latent_dim = 2048\n",
+    "num_heads = 8\n",
+    "dropout_rate = 0.5\n",
+    "vocab_size = tokenizer.n_vocab\n",
+    "sequence_length = 20\n",
+    "learning_rate = 1.5e-3\n",
+    "num_epochs = 10\n",
+    "\n",
+    "config = TransformerConfig(\n",
+    "    sequence_length=sequence_length,\n",
+    "    vocab_size=vocab_size,\n",
+    "    embed_dim=embed_dim,\n",
+    "    latent_dim=latent_dim,\n",
+    "    num_heads=num_heads,\n",
+    "    dropout_rate=dropout_rate,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "fbeb6101-be11-4a33-9650-a3efd3656855",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bar_format = \"{desc}[{n_fmt}/{total_fmt}]{postfix} [{elapsed}<{remaining}]\"\n",
+    "train_total_steps = len(train_data) // batch_size\n",
+    "\n",
+    "\n",
+    "def train_one_epoch(epoch):\n",
+    "    model.train()  # Set model to the training mode: e.g. update batch statistics\n",
+    "    with tqdm.tqdm(\n",
+    "        desc=f\"[train] epoch: {epoch}/{num_epochs}, \",\n",
+    "        total=train_total_steps,\n",
+    "        bar_format=bar_format,\n",
+    "        leave=True,\n",
+    "    ) as pbar:\n",
+    "        for batch in train_loader:\n",
+    "            loss = train_step(model, optimizer, batch)\n",
+    "            train_metrics_history[\"train_loss\"].append(loss.item())\n",
+    "            pbar.set_postfix({\"loss\": loss.item()})\n",
+    "            pbar.update(1)\n",
+    "\n",
+    "\n",
+    "def evaluate_model(epoch):\n",
+    "    # Compute the metrics on the train and val sets after each training epoch.\n",
+    "    model.eval()  # Set model to evaluation model: e.g. use stored batch statistics\n",
+    "\n",
+    "    eval_metrics.reset()  # Reset the eval metrics\n",
+    "    for val_batch in val_loader:\n",
+    "        eval_step(model, val_batch, eval_metrics)\n",
+    "\n",
+    "    for metric, value in eval_metrics.compute().items():\n",
+    "        eval_metrics_history[f\"test_{metric}\"].append(value)\n",
+    "\n",
+    "    print(f\"[test] epoch: {epoch + 1}/{num_epochs}\")\n",
+    "    print(f\"- total loss: {eval_metrics_history['test_loss'][-1]:0.4f}\")\n",
+    "    print(f\"- Accuracy: {eval_metrics_history['test_accuracy'][-1]:0.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "49a1d33a-c2e4-4d48-821b-519f5c0192c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = TransformerModel(config, rngs=rng)\n",
+    "optimizer = nnx.Optimizer(model, optax.adamw(learning_rate), wrt=nnx.Param)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fa7d5601-60c1-4131-a40c-c670f055ce68",
+   "metadata": {},
+   "source": [
+    "## Start the Training!\n",
+    "With our data loaders in place and the model, optimizer, and training/evaluation loops fully configured, it’s finally time to press go.\n",
+    "Training on an RTX 4050 (6 GB VRAM), the model fits comfortably within memory, and with a batch size of 64, each epoch completes in approximately 1 minute 30 seconds."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "c764510c-4d98-46ad-b877-8cfc2fa5a9ea",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 0/10, [1300/1301], loss=1.43 [02:27<00:00] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 1/10\n",
+      "- total loss: 1.2190\n",
+      "- Accuracy: 0.7853\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 1/10, [1300/1301], loss=1.04 [01:33<00:00] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 2/10\n",
+      "- total loss: 0.9831\n",
+      "- Accuracy: 0.8220\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 2/10, [1300/1301], loss=0.848 [01:31<00:00]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 3/10\n",
+      "- total loss: 0.9074\n",
+      "- Accuracy: 0.8353\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 3/10, [1300/1301], loss=0.7 [01:32<00:00]  \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 4/10\n",
+      "- total loss: 0.8746\n",
+      "- Accuracy: 0.8421\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 4/10, [1300/1301], loss=0.663 [01:32<00:00]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 5/10\n",
+      "- total loss: 0.8733\n",
+      "- Accuracy: 0.8450\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 5/10, [1300/1301], loss=0.583 [01:34<00:00]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 6/10\n",
+      "- total loss: 0.8739\n",
+      "- Accuracy: 0.8477\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 6/10, [1300/1301], loss=0.513 [01:34<00:00]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 7/10\n",
+      "- total loss: 0.8628\n",
+      "- Accuracy: 0.8500\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 7/10, [1300/1301], loss=0.496 [01:31<00:00]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 8/10\n",
+      "- total loss: 0.8847\n",
+      "- Accuracy: 0.8496\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 8/10, [1300/1301], loss=0.468 [01:33<00:00]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 9/10\n",
+      "- total loss: 0.8867\n",
+      "- Accuracy: 0.8521\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 9/10, [1300/1301], loss=0.42 [01:34<00:00] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 10/10\n",
+      "- total loss: 0.8879\n",
+      "- Accuracy: 0.8531\n"
+     ]
+    }
+   ],
+   "source": [
+    "for epoch in range(num_epochs):\n",
+    "    train_one_epoch(epoch)\n",
+    "    evaluate_model(epoch)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f922eac4-8338-4a0d-bc6d-1f5880079bde",
+   "metadata": {},
+   "source": [
+    "We can then plot the loss over training time. That log-plot comes in handy here, or it's hard to appreciate the progress after 1000 steps or so."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "a79ecfa5-d74a-4956-9ee2-cbed86d5a82f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7e17908b9f50>"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.plot(train_metrics_history[\"train_loss\"], label=\"Loss value during the training\")\n",
+    "plt.yscale(\"log\")\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66250bf2-3d88-40ad-87e3-7d2b906fd860",
+   "metadata": {},
+   "source": [
+    "And eval set Loss and Accuracy - Accuracy does continue to rise, though it's hard-earned progress after about the 5th epoch. Based on the training statistics, it's fair to say the process starts overfitting after roughly that 5th epoch."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "64d54051-358b-4de8-b5b3-04bebf18018f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7e178a2555d0>]"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(1, 2, figsize=(10, 10))\n",
+    "axs[0].set_title(\"Loss value on eval set\")\n",
+    "axs[0].plot(eval_metrics_history[\"test_loss\"])\n",
+    "axs[1].set_title(\"Accuracy on eval set\")\n",
+    "axs[1].plot(eval_metrics_history[\"test_accuracy\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a3f7b0ad-ddfa-4ab3-b56f-6ea99385ff6a",
+   "metadata": {},
+   "source": [
+    "## Use Model for Inference\n",
+    "After all that, the product of what we were working for: a trained model we can save and load for inference. For people using LLMs recently, this pattern may look rather familiar: an input sentence tokenized into an array and computed 'next' token-by-token. While many recent LLMs are decoder-only, this was an encoder/decoder architecture with the very specific english-to-spanish pattern baked in.\n",
+    "\n",
+    "We've changed a couple things from the source 'use' function, here - because of the tokenizer used, things like `[start]` and `[end]` are no longer single tokens - instead `[start]` is `[29563, 60] = \"[start\" + \"]\"` and `[end]` is `[58308, 60] = \"[end\" + \"]\"` - thus we start with only a single token `[start` and can't only test on `last_token = \"[end\"]`. Otherwise, the main change here is that the input is assumed a single sentence, rather than batch inference."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "e4589706-cfd6-4efb-9975-bfa0df75d4f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def decode_sequence(input_sentence):\n",
+    "    input_sentence = custom_standardization(input_sentence)\n",
+    "    tokenized_input_sentence = tokenize_and_pad(input_sentence, tokenizer, sequence_length)\n",
+    "\n",
+    "    decoded_sentence = \"[start\"\n",
+    "    for i in range(sequence_length):\n",
+    "        tokenized_target_sentence = tokenize_and_pad(decoded_sentence, tokenizer, sequence_length)[:-1]\n",
+    "        predictions = model(jnp.array([tokenized_input_sentence]), jnp.array([tokenized_target_sentence]))\n",
+    "\n",
+    "        sampled_token_index = np.argmax(predictions[0, i, :]).item(0)\n",
+    "        sampled_token = tokenizer.decode([sampled_token_index])\n",
+    "        decoded_sentence += \"\" + sampled_token\n",
+    "\n",
+    "        if decoded_sentence[-5:] == \"[end]\":\n",
+    "            break\n",
+    "    return decoded_sentence"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "554c2f72-0bd3-4ed1-804b-5f1a4cc13851",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_eng_texts = [pair[0] for pair in test_pairs]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "c1d6edbb-af89-42c9-90c3-d61612b75da3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_result_pairs = []\n",
+    "for _ in range(10):\n",
+    "    input_sentence = random.choice(test_eng_texts)\n",
+    "    translated = decode_sequence(input_sentence)\n",
+    "\n",
+    "    test_result_pairs.append(f\"[Input]: {input_sentence} [Translation]: {translated}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "258c2172-5a0f-4dee-9b21-f65433183c62",
+   "metadata": {},
+   "source": [
+    "## Test Results\n",
+    "For the model and the data, not too shabby - It's definitely spanish-ish. Though when 'making' friends, please don't confuse 'hacer' (to make) with 'comer' (to eat)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "4f0ae018-b7cd-4849-b245-c5c647ad1a95",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[Input]: The car didn't move. [Translation]: [start] el coche no se mueva [end]\n",
+      "[Input]: You can be sure of that. [Translation]: [start] puedes asegurarte de eso [end]\n",
+      "[Input]: She suffers from a contagious disease. [Translation]: [start] ella sufre de una enfermedad contagiosa [end]\n",
+      "[Input]: I will have him carry the baggage upstairs. [Translation]: [start] lo tendré en escape esa arriba arriba abajo [end]\n",
+      "[Input]: Tom applied for the job. [Translation]: [start] tom postuló al trabajo [end]\n",
+      "[Input]: All of the buses are full. [Translation]: [start] todos los buses están llenos [end]\n",
+      "[Input]: I have not heard from her yet. [Translation]: [start] todavía no he escuchado nada [end]\n",
+      "[Input]: It was just a coincidence. [Translation]: [start] era solo una coincidencia [end]\n",
+      "[Input]: For some reason the microphone didn't work earlier. [Translation]: [start] por alguna razón la lengua no funciona hasta al trabajo [end]\n",
+      "[Input]: Tom is helping his wife. [Translation]: [start] tom está ayudando a su esposa [end]\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in test_result_pairs:\n",
+    "    print(i)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5ca18d4c-b3c0-4abb-b5fc-fc96a2264b53",
+   "metadata": {},
+   "source": [
+    "Example output from the above cell:\n",
+    "\n",
+    "      [Input]: Take this medicine after meals. [Translation]: [start] toma esta medicina después de comer [end]\n",
+    "      [Input]: The English are said to be conservative. [Translation]: [start] el inglés son dijo que sería conservadores [end]\n",
+    "      [Input]: Tom might call Mary tonight. [Translation]: [start] tom quizás podría llamar a mary esta noche [end]\n",
+    "      [Input]: I have not finished lunch. [Translation]: [start] no he finalmente terminado [end]\n",
+    "      [Input]: Are you ready to start? [Translation]: [start] estás listo para empezar [end]\n",
+    "      [Input]: Tom worked as a lifeguard during the summer. [Translation]: [start] tom trabajó como un salvavidas durante el verano [end]\n",
+    "      [Input]: Can I pay later? [Translation]: [start] puedo pagar más tarde [end]\n",
+    "      [Input]: They went hand in hand. [Translation]: [start] ellos se fueron [end]\n",
+    "      [Input]: You look like a baboon. [Translation]: [start] parecés como un papión [end]\n",
+    "      [Input]: A cloud floated across the sky. [Translation]: [start] una sola nubeió en el cielo [end]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cd25c648",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "formats": "ipynb,md:myst"
+  },
+  "kernelspec": {
+   "display_name": "env (3.11.14)",
+   "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.11.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From cf86a6ac9b4044ab225681d58caf2f9b0304872b Mon Sep 17 00:00:00 2001
From: Aatman09 <aatmansoni2006@gmail.com>
Date: Tue, 13 Jan 2026 02:58:02 +0000
Subject: [PATCH 2/5] Imeplemented KV caching (WIP)

---
 .../tests/UNet_segmentation_example.ipynb     |   2 +-
 .../tutorials/JAX_machine_translation.ipynb   | 411 +++++++++---------
 2 files changed, 196 insertions(+), 217 deletions(-)

diff --git a/bonsai/models/unet/tests/UNet_segmentation_example.ipynb b/bonsai/models/unet/tests/UNet_segmentation_example.ipynb
index 54a1fc37..60548937 100644
--- a/bonsai/models/unet/tests/UNet_segmentation_example.ipynb
+++ b/bonsai/models/unet/tests/UNet_segmentation_example.ipynb
@@ -629,7 +629,7 @@
     "    return state, loss\n",
     "\n",
     "\n",
-    "print(\"🚀 Starting training from checkpoint...\")\n",
+    "print(\"Starting training from checkpoint...\")\n",
     "train_loader, vis_loader = load_dataset()\n",
     "num_epochs = 100\n",
     "state = train_state\n",
diff --git a/bonsai/tutorials/JAX_machine_translation.ipynb b/bonsai/tutorials/JAX_machine_translation.ipynb
index 5b0291b7..60b2b0de 100644
--- a/bonsai/tutorials/JAX_machine_translation.ipynb
+++ b/bonsai/tutorials/JAX_machine_translation.ipynb
@@ -20,7 +20,85 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 98,
+   "id": "7bf8d50f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/lib/python3.11/pty.py:89: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n",
+      "  pid, fd = os.forkpty()\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Requirement already satisfied: numpy in /home/aries/bonsai/env/lib/python3.11/site-packages (2.4.0)\n",
+      "Requirement already satisfied: tiktoken in /home/aries/bonsai/env/lib/python3.11/site-packages (0.12.0)\n",
+      "Requirement already satisfied: flax in /home/aries/bonsai/env/lib/python3.11/site-packages (0.12.2)\n",
+      "Requirement already satisfied: tqdm in /home/aries/bonsai/env/lib/python3.11/site-packages (4.67.1)\n",
+      "Requirement already satisfied: grain in /home/aries/bonsai/env/lib/python3.11/site-packages (0.2.15)\n",
+      "Requirement already satisfied: optax in /home/aries/bonsai/env/lib/python3.11/site-packages (0.2.6)\n",
+      "Requirement already satisfied: matplotlib in /home/aries/bonsai/env/lib/python3.11/site-packages (3.10.8)\n",
+      "Requirement already satisfied: jax in /home/aries/bonsai/env/lib/python3.11/site-packages (0.8.2)\n",
+      "Requirement already satisfied: regex>=2022.1.18 in /home/aries/bonsai/env/lib/python3.11/site-packages (from tiktoken) (2025.11.3)\n",
+      "Requirement already satisfied: requests>=2.26.0 in /home/aries/bonsai/env/lib/python3.11/site-packages (from tiktoken) (2.32.5)\n",
+      "Requirement already satisfied: msgpack in /home/aries/bonsai/env/lib/python3.11/site-packages (from flax) (1.1.2)\n",
+      "Requirement already satisfied: orbax-checkpoint in /home/aries/bonsai/env/lib/python3.11/site-packages (from flax) (0.11.31)\n",
+      "Requirement already satisfied: tensorstore in /home/aries/bonsai/env/lib/python3.11/site-packages (from flax) (0.1.80)\n",
+      "Requirement already satisfied: rich>=11.1 in /home/aries/bonsai/env/lib/python3.11/site-packages (from flax) (14.2.0)\n",
+      "Requirement already satisfied: typing_extensions>=4.2 in /home/aries/bonsai/env/lib/python3.11/site-packages (from flax) (4.15.0)\n",
+      "Requirement already satisfied: PyYAML>=5.4.1 in /home/aries/bonsai/env/lib/python3.11/site-packages (from flax) (6.0.3)\n",
+      "Requirement already satisfied: treescope>=0.1.7 in /home/aries/bonsai/env/lib/python3.11/site-packages (from flax) (0.1.10)\n",
+      "Requirement already satisfied: absl-py in /home/aries/bonsai/env/lib/python3.11/site-packages (from grain) (2.3.1)\n",
+      "Requirement already satisfied: array-record>=0.8.1 in /home/aries/bonsai/env/lib/python3.11/site-packages (from grain) (0.8.3)\n",
+      "Requirement already satisfied: cloudpickle in /home/aries/bonsai/env/lib/python3.11/site-packages (from grain) (3.1.2)\n",
+      "Requirement already satisfied: etils[epath,epy] in /home/aries/bonsai/env/lib/python3.11/site-packages (from grain) (1.13.0)\n",
+      "Requirement already satisfied: protobuf>=5.28.3 in /home/aries/bonsai/env/lib/python3.11/site-packages (from grain) (6.33.2)\n",
+      "Requirement already satisfied: chex>=0.1.87 in /home/aries/bonsai/env/lib/python3.11/site-packages (from optax) (0.1.91)\n",
+      "Requirement already satisfied: jaxlib>=0.5.3 in /home/aries/bonsai/env/lib/python3.11/site-packages (from optax) (0.8.2)\n",
+      "Requirement already satisfied: contourpy>=1.0.1 in /home/aries/bonsai/env/lib/python3.11/site-packages (from matplotlib) (1.3.3)\n",
+      "Requirement already satisfied: cycler>=0.10 in /home/aries/bonsai/env/lib/python3.11/site-packages (from matplotlib) (0.12.1)\n",
+      "Requirement already satisfied: fonttools>=4.22.0 in /home/aries/bonsai/env/lib/python3.11/site-packages (from matplotlib) (4.61.1)\n",
+      "Requirement already satisfied: kiwisolver>=1.3.1 in /home/aries/bonsai/env/lib/python3.11/site-packages (from matplotlib) (1.4.9)\n",
+      "Requirement already satisfied: packaging>=20.0 in /home/aries/bonsai/env/lib/python3.11/site-packages (from matplotlib) (25.0)\n",
+      "Requirement already satisfied: pillow>=8 in /home/aries/bonsai/env/lib/python3.11/site-packages (from matplotlib) (12.1.0)\n",
+      "Requirement already satisfied: pyparsing>=3 in /home/aries/bonsai/env/lib/python3.11/site-packages (from matplotlib) (3.3.1)\n",
+      "Requirement already satisfied: python-dateutil>=2.7 in /home/aries/bonsai/env/lib/python3.11/site-packages (from matplotlib) (2.9.0.post0)\n",
+      "Requirement already satisfied: ml_dtypes>=0.5.0 in /home/aries/bonsai/env/lib/python3.11/site-packages (from jax) (0.5.4)\n",
+      "Requirement already satisfied: opt_einsum in /home/aries/bonsai/env/lib/python3.11/site-packages (from jax) (3.4.0)\n",
+      "Requirement already satisfied: scipy>=1.13 in /home/aries/bonsai/env/lib/python3.11/site-packages (from jax) (1.16.3)\n",
+      "Requirement already satisfied: toolz>=1.0.0 in /home/aries/bonsai/env/lib/python3.11/site-packages (from chex>=0.1.87->optax) (1.1.0)\n",
+      "Requirement already satisfied: six>=1.5 in /home/aries/bonsai/env/lib/python3.11/site-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n",
+      "Requirement already satisfied: charset_normalizer<4,>=2 in /home/aries/bonsai/env/lib/python3.11/site-packages (from requests>=2.26.0->tiktoken) (3.4.4)\n",
+      "Requirement already satisfied: idna<4,>=2.5 in /home/aries/bonsai/env/lib/python3.11/site-packages (from requests>=2.26.0->tiktoken) (3.11)\n",
+      "Requirement already satisfied: urllib3<3,>=1.21.1 in /home/aries/bonsai/env/lib/python3.11/site-packages (from requests>=2.26.0->tiktoken) (2.6.2)\n",
+      "Requirement already satisfied: certifi>=2017.4.17 in /home/aries/bonsai/env/lib/python3.11/site-packages (from requests>=2.26.0->tiktoken) (2026.1.4)\n",
+      "Requirement already satisfied: markdown-it-py>=2.2.0 in /home/aries/bonsai/env/lib/python3.11/site-packages (from rich>=11.1->flax) (4.0.0)\n",
+      "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /home/aries/bonsai/env/lib/python3.11/site-packages (from rich>=11.1->flax) (2.19.2)\n",
+      "Requirement already satisfied: mdurl~=0.1 in /home/aries/bonsai/env/lib/python3.11/site-packages (from markdown-it-py>=2.2.0->rich>=11.1->flax) (0.1.2)\n",
+      "Requirement already satisfied: fsspec in /home/aries/bonsai/env/lib/python3.11/site-packages (from etils[epath,epy]->grain) (2025.12.0)\n",
+      "Requirement already satisfied: importlib_resources in /home/aries/bonsai/env/lib/python3.11/site-packages (from etils[epath,epy]->grain) (6.5.2)\n",
+      "Requirement already satisfied: zipp in /home/aries/bonsai/env/lib/python3.11/site-packages (from etils[epath,epy]->grain) (3.23.0)\n",
+      "Requirement already satisfied: nest_asyncio in /home/aries/bonsai/env/lib/python3.11/site-packages (from orbax-checkpoint->flax) (1.6.0)\n",
+      "Requirement already satisfied: aiofiles in /home/aries/bonsai/env/lib/python3.11/site-packages (from orbax-checkpoint->flax) (25.1.0)\n",
+      "Requirement already satisfied: humanize in /home/aries/bonsai/env/lib/python3.11/site-packages (from orbax-checkpoint->flax) (4.15.0)\n",
+      "Requirement already satisfied: simplejson>=3.16.0 in /home/aries/bonsai/env/lib/python3.11/site-packages (from orbax-checkpoint->flax) (3.20.2)\n",
+      "Requirement already satisfied: psutil in /home/aries/bonsai/env/lib/python3.11/site-packages (from orbax-checkpoint->flax) (7.2.1)\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pip install numpy tiktoken flax tqdm grain optax matplotlib jax"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
    "id": "dd506ffa-3b91-44f1-92d1-a08ed933e78e",
    "metadata": {},
    "outputs": [],
@@ -68,7 +146,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 100,
    "id": "102943a5-8724-48e0-8d6a-f56069f03426",
    "metadata": {},
    "outputs": [],
@@ -118,7 +196,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 101,
    "id": "bee9f1b0-5f74-47dc-a7e1-a4ea3be1ef7f",
    "metadata": {},
    "outputs": [
@@ -172,7 +250,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 102,
    "id": "07e054d3-a20c-4aed-8f8a-fb5158df8e5b",
    "metadata": {},
    "outputs": [],
@@ -189,7 +267,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 103,
    "id": "e2b3e5b3-8466-4c81-99da-0559c88b25ef",
    "metadata": {},
    "outputs": [],
@@ -201,7 +279,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 104,
    "id": "5bdc0673-9723-45b5-8a42-2152295df69b",
    "metadata": {},
    "outputs": [],
@@ -216,7 +294,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 105,
    "id": "235b1221-e72d-4793-addd-7bb870bd8e75",
    "metadata": {},
    "outputs": [],
@@ -235,7 +313,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 106,
    "id": "ca013d07-1504-42cc-906f-2fcacc757008",
    "metadata": {},
    "outputs": [],
@@ -255,7 +333,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 107,
    "id": "dcbfa780-553f-41f6-8b3e-55955db78b2a",
    "metadata": {},
    "outputs": [
@@ -263,7 +341,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'encoder_inputs': [456, 3201, 505, 1070, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'decoder_inputs': [29563, 60, 453, 978, 73, 349, 409, 682, 2483, 510, 408, 60, 0, 0, 0, 0, 0, 0, 0], 'target_output': [60, 453, 978, 73, 349, 409, 682, 2483, 510, 408, 60, 0, 0, 0, 0, 0, 0, 0, 0]}\n"
+      "{'encoder_inputs': [30115, 2664, 9711, 757, 1523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'decoder_inputs': [29563, 60, 12067, 658, 29452, 757, 32895, 10872, 689, 510, 408, 60, 0, 0, 0, 0, 0, 0, 0], 'target_output': [60, 12067, 658, 29452, 757, 32895, 10872, 689, 510, 408, 60, 0, 0, 0, 0, 0, 0, 0, 0]}\n"
      ]
     }
    ],
@@ -294,7 +372,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 108,
    "id": "a3f8a6fd",
    "metadata": {},
    "outputs": [],
@@ -311,7 +389,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "id": "121bf138-34b3-4be9-a0fc-3bbac81f469a",
    "metadata": {},
    "outputs": [],
@@ -351,24 +429,22 @@
     "            num_embeddings=config.sequence_length, features=config.embed_dim, rngs=rngs\n",
     "        )\n",
     "\n",
-    "    def __call__(self, inputs):\n",
-    "        length = inputs.shape[1]\n",
-    "        positions = jnp.arange(0, length)[None, :]\n",
+    "    def __call__(self, inputs, step=None):\n",
+    "        if step is None:\n",
+    "            length = inputs.shape[1]\n",
+    "            positions = jnp.arange(0, length)[None, :]\n",
+    "        else:\n",
+    "            positions = jnp.array([step])[None, :]\n",
+    "\n",
     "        embedded_tokens = self.token_embeddings(inputs)\n",
     "        embedded_positions = self.position_embeddings(positions)\n",
     "        return embedded_tokens + embedded_positions\n",
     "\n",
-    "    def compute_mask(self, inputs, mask=None):\n",
-    "        if mask is None:\n",
-    "            return None\n",
-    "        else:\n",
-    "            return jnp.not_equal(inputs, 0)\n",
-    "\n",
     "\n",
     "class TransformerDecoder(nnx.Module):\n",
     "    def __init__(self, config: TransformerConfig, rngs: nnx.Rngs, **kwargs):\n",
     "        self.attention_1 = nnx.MultiHeadAttention(\n",
-    "            num_heads=config.num_heads, in_features=config.embed_dim, decode=False, rngs=rngs\n",
+    "            num_heads=config.num_heads, in_features=config.embed_dim, decode=True, rngs=rngs\n",
     "        )\n",
     "        self.attention_2 = nnx.MultiHeadAttention(\n",
     "            num_heads=config.num_heads, in_features=config.embed_dim, decode=False, rngs=rngs\n",
@@ -383,24 +459,36 @@
     "        self.layernorm_2 = nnx.LayerNorm(config.embed_dim, rngs=rngs)\n",
     "        self.layernorm_3 = nnx.LayerNorm(config.embed_dim, rngs=rngs)\n",
     "\n",
-    "    def __call__(self, inputs, encoder_outputs, mask=None, cache=None):\n",
-    "        causal_mask = self.get_causal_attention_mask(inputs.shape[1])\n",
-    "        if mask is not None:\n",
-    "            padding_mask = jnp.expand_dims(mask, axis=1).astype(jnp.int32)\n",
-    "            padding_mask = jnp.minimum(padding_mask, causal_mask)\n",
-    "        else:\n",
+    "    def init_cache(self, input_shape):\n",
+    "        self.attention_1.init_cache(input_shape=input_shape)\n",
+    "\n",
+    "    def __call__(self, inputs, encoder_outputs, mask=None, decode=False):\n",
+    "        if decode:\n",
     "            padding_mask = None\n",
-    "        attention_output_1 = self.attention_1(inputs_q=inputs, inputs_v=inputs, inputs_k=inputs, mask=causal_mask)\n",
+    "        else:\n",
+    "            causal_mask = self.get_causal_attention_mask(inputs.shape[1])\n",
+    "            if mask is not None:\n",
+    "                padding_mask = jnp.expand_dims(mask, axis=1).astype(jnp.int32)\n",
+    "                padding_mask = jnp.minimum(padding_mask, causal_mask)\n",
+    "            else:\n",
+    "                padding_mask = causal_mask\n",
+    "\n",
+    "        cross_mask = mask\n",
+    "        if decode and mask is not None:\n",
+    "            cross_mask = jnp.expand_dims(mask, axis=(1, 2)).astype(jnp.int32)\n",
+    "\n",
+    "        elif not decode and mask is not None:\n",
+    "            cross_mask = jnp.expand_dims(mask, axis=1).astype(jnp.int32)\n",
+    "\n",
+    "        attention_output_1 = self.attention_1(\n",
+    "            inputs_q=inputs, inputs_k=inputs, inputs_v=inputs, mask=padding_mask, decode=decode\n",
+    "        )\n",
     "        out_1 = self.layernorm_1(inputs + attention_output_1)\n",
     "\n",
-    "        attention_output_2 = (\n",
-    "            self.attention_2(  ## https://github.com/google/flax/blob/main/flax/nnx/nn/attention.py#L403-L405\n",
-    "                inputs_q=out_1,\n",
-    "                inputs_v=encoder_outputs,\n",
-    "                inputs_k=encoder_outputs,\n",
-    "                mask=padding_mask,\n",
-    "            )\n",
+    "        attention_output_2 = self.attention_2(\n",
+    "            inputs_q=out_1, inputs_k=encoder_outputs, inputs_v=encoder_outputs, mask=cross_mask, decode=False\n",
     "        )\n",
+    "\n",
     "        out_2 = self.layernorm_2(out_1 + attention_output_2)\n",
     "\n",
     "        proj_output = self.dense_proj(out_2)\n",
@@ -425,7 +513,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 110,
    "id": "c5dcfaf6-f5cd-40f4-bbf0-2754c0193327",
    "metadata": {},
    "outputs": [],
@@ -433,24 +521,29 @@
     "class TransformerModel(nnx.Module):\n",
     "    def __init__(self, config: TransformerConfig, rngs: nnx.Rngs):\n",
     "        self.config = config\n",
-    "\n",
     "        self.encoder = TransformerEncoder(config, rngs=rngs)\n",
     "        self.positional_embedding = PositionalEmbedding(config, rngs=rngs)\n",
     "        self.decoder = TransformerDecoder(config, rngs=rngs)\n",
     "        self.dropout = nnx.Dropout(rate=config.dropout_rate, rngs=rngs)\n",
     "        self.dense = nnx.Linear(config.embed_dim, config.vocab_size, rngs=rngs)\n",
     "\n",
-    "    def __call__(\n",
-    "        self, encoder_inputs: jnp.array, decoder_inputs: jnp.array, mask: jnp.array = None, deterministic: bool = False\n",
-    "    ):\n",
+    "    def init_cache(self, input_shape):\n",
+    "        self.decoder.init_cache(input_shape)\n",
+    "\n",
+    "    def __call__(self, encoder_inputs, decoder_inputs, mask=None, deterministic=False, decode=False):\n",
     "        x = self.positional_embedding(encoder_inputs)\n",
     "        encoder_outputs = self.encoder(x, mask=mask)\n",
     "\n",
     "        x = self.positional_embedding(decoder_inputs)\n",
-    "        decoder_outputs = self.decoder(x, encoder_outputs, mask=mask)\n",
-    "        # per nnx.Dropout - disable (deterministic=True) for eval, keep (False) for training\n",
+    "        decoder_outputs = self.decoder(x, encoder_outputs, mask=mask, decode=decode)\n",
+    "\n",
     "        decoder_outputs = self.dropout(decoder_outputs, deterministic=deterministic)\n",
+    "        logits = self.dense(decoder_outputs)\n",
+    "        return logits\n",
     "\n",
+    "    def decode_step(self, token_input, encoder_outputs, step_index):\n",
+    "        x = self.positional_embedding(token_input, step=step_index)\n",
+    "        decoder_outputs = self.decoder(x, encoder_outputs, decode=True)\n",
     "        logits = self.dense(decoder_outputs)\n",
     "        return logits"
    ]
@@ -466,7 +559,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 111,
    "id": "1fb8cb44-9012-4802-9286-1efc19dd2ba1",
    "metadata": {},
    "outputs": [],
@@ -535,7 +628,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 112,
    "id": "d2f8e06f-1126-41cc-b8d8-de6bd7a5255a",
    "metadata": {},
    "outputs": [],
@@ -555,7 +648,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 113,
    "id": "279d991f-f129-48b3-9b7e-d143019c18a8",
    "metadata": {},
    "outputs": [],
@@ -598,7 +691,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 114,
    "id": "32a17edc-33d0-41bc-a516-8b8ce45c3ad7",
    "metadata": {},
    "outputs": [],
@@ -620,7 +713,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 115,
    "id": "1189a6a6-2cc6-4c87-9f87-b4b800a1513d",
    "metadata": {},
    "outputs": [],
@@ -634,7 +727,7 @@
     "vocab_size = tokenizer.n_vocab\n",
     "sequence_length = 20\n",
     "learning_rate = 1.5e-3\n",
-    "num_epochs = 10\n",
+    "num_epochs = 2\n",
     "\n",
     "config = TransformerConfig(\n",
     "    sequence_length=sequence_length,\n",
@@ -648,7 +741,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 116,
    "id": "fbeb6101-be11-4a33-9650-a3efd3656855",
    "metadata": {},
    "outputs": [],
@@ -690,7 +783,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 117,
    "id": "49a1d33a-c2e4-4d48-821b-519f5c0192c7",
    "metadata": {},
    "outputs": [],
@@ -711,7 +804,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 118,
    "id": "c764510c-4d98-46ad-b877-8cfc2fa5a9ea",
    "metadata": {},
    "outputs": [
@@ -719,160 +812,32 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "[train] epoch: 0/10, [1300/1301], loss=1.43 [02:27<00:00] \n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[test] epoch: 1/10\n",
-      "- total loss: 1.2190\n",
-      "- Accuracy: 0.7853\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[train] epoch: 1/10, [1300/1301], loss=1.04 [01:33<00:00] \n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[test] epoch: 2/10\n",
-      "- total loss: 0.9831\n",
-      "- Accuracy: 0.8220\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[train] epoch: 2/10, [1300/1301], loss=0.848 [01:31<00:00]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[test] epoch: 3/10\n",
-      "- total loss: 0.9074\n",
-      "- Accuracy: 0.8353\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[train] epoch: 3/10, [1300/1301], loss=0.7 [01:32<00:00]  \n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[test] epoch: 4/10\n",
-      "- total loss: 0.8746\n",
-      "- Accuracy: 0.8421\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[train] epoch: 4/10, [1300/1301], loss=0.663 [01:32<00:00]\n"
+      "[train] epoch: 0/2, [1300/1301], loss=1.19 [01:41<00:00] \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[test] epoch: 5/10\n",
-      "- total loss: 0.8733\n",
-      "- Accuracy: 0.8450\n"
+      "[test] epoch: 1/2\n",
+      "- total loss: 1.2035\n",
+      "- Accuracy: 0.7882\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "[train] epoch: 5/10, [1300/1301], loss=0.583 [01:34<00:00]\n"
+      "[train] epoch: 1/2, [1300/1301], loss=0.877 [01:30<00:00]\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[test] epoch: 6/10\n",
-      "- total loss: 0.8739\n",
-      "- Accuracy: 0.8477\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[train] epoch: 6/10, [1300/1301], loss=0.513 [01:34<00:00]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[test] epoch: 7/10\n",
-      "- total loss: 0.8628\n",
-      "- Accuracy: 0.8500\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[train] epoch: 7/10, [1300/1301], loss=0.496 [01:31<00:00]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[test] epoch: 8/10\n",
-      "- total loss: 0.8847\n",
-      "- Accuracy: 0.8496\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[train] epoch: 8/10, [1300/1301], loss=0.468 [01:33<00:00]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[test] epoch: 9/10\n",
-      "- total loss: 0.8867\n",
-      "- Accuracy: 0.8521\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[train] epoch: 9/10, [1300/1301], loss=0.42 [01:34<00:00] \n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[test] epoch: 10/10\n",
-      "- total loss: 0.8879\n",
-      "- Accuracy: 0.8531\n"
+      "[test] epoch: 2/2\n",
+      "- total loss: 0.9836\n",
+      "- Accuracy: 0.8213\n"
      ]
     }
    ],
@@ -892,23 +857,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 119,
    "id": "a79ecfa5-d74a-4956-9ee2-cbed86d5a82f",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7e17908b9f50>"
+       "<matplotlib.legend.Legend at 0x7cd622450990>"
       ]
      },
-     "execution_count": 27,
+     "execution_count": 119,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -935,23 +900,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 120,
    "id": "64d54051-358b-4de8-b5b3-04bebf18018f",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7e178a2555d0>]"
+       "[<matplotlib.lines.Line2D at 0x7cd622485950>]"
       ]
      },
-     "execution_count": 28,
+     "execution_count": 120,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1000x1000 with 2 Axes>"
       ]
@@ -981,7 +946,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 121,
    "id": "e4589706-cfd6-4efb-9975-bfa0df75d4f0",
    "metadata": {},
    "outputs": [],
@@ -989,24 +954,38 @@
     "def decode_sequence(input_sentence):\n",
     "    input_sentence = custom_standardization(input_sentence)\n",
     "    tokenized_input_sentence = tokenize_and_pad(input_sentence, tokenizer, sequence_length)\n",
+    "    encoder_input = jnp.array([tokenized_input_sentence])\n",
+    "\n",
+    "    emb_enc = model.positional_embedding(encoder_input)\n",
+    "    encoder_outputs = model.encoder(emb_enc, mask=None)\n",
+    "\n",
+    "    dummy_input_shape = (1, 1, model.config.embed_dim)\n",
+    "    model.init_cache(dummy_input_shape)\n",
     "\n",
     "    decoded_sentence = \"[start\"\n",
+    "    current_token_id = tokenizer.encode(\"[start\")\n",
+    "    current_input = jnp.array([current_token_id])\n",
+    "\n",
     "    for i in range(sequence_length):\n",
-    "        tokenized_target_sentence = tokenize_and_pad(decoded_sentence, tokenizer, sequence_length)[:-1]\n",
-    "        predictions = model(jnp.array([tokenized_input_sentence]), jnp.array([tokenized_target_sentence]))\n",
+    "        logits = model.decode_step(current_input, encoder_outputs, step_index=i)\n",
+    "\n",
+    "        sampled_id = np.argmax(logits[0, 0, :]).item()\n",
+    "        sampled_token = tokenizer.decode([sampled_id])\n",
     "\n",
-    "        sampled_token_index = np.argmax(predictions[0, i, :]).item(0)\n",
-    "        sampled_token = tokenizer.decode([sampled_token_index])\n",
-    "        decoded_sentence += \"\" + sampled_token\n",
+    "        decoded_sentence += \" \" + sampled_token\n",
     "\n",
-    "        if decoded_sentence[-5:] == \"[end]\":\n",
+    "        if sampled_token == \"[end]\":\n",
     "            break\n",
+    "\n",
+    "        # Update input for next loop\n",
+    "        current_input = jnp.array([[sampled_id]])\n",
+    "\n",
     "    return decoded_sentence"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 122,
    "id": "554c2f72-0bd3-4ed1-804b-5f1a4cc13851",
    "metadata": {},
    "outputs": [],
@@ -1016,7 +995,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 123,
    "id": "c1d6edbb-af89-42c9-90c3-d61612b75da3",
    "metadata": {},
    "outputs": [],
@@ -1040,7 +1019,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 124,
    "id": "4f0ae018-b7cd-4849-b245-c5c647ad1a95",
    "metadata": {},
    "outputs": [
@@ -1048,16 +1027,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[Input]: The car didn't move. [Translation]: [start] el coche no se mueva [end]\n",
-      "[Input]: You can be sure of that. [Translation]: [start] puedes asegurarte de eso [end]\n",
-      "[Input]: She suffers from a contagious disease. [Translation]: [start] ella sufre de una enfermedad contagiosa [end]\n",
-      "[Input]: I will have him carry the baggage upstairs. [Translation]: [start] lo tendré en escape esa arriba arriba abajo [end]\n",
-      "[Input]: Tom applied for the job. [Translation]: [start] tom postuló al trabajo [end]\n",
-      "[Input]: All of the buses are full. [Translation]: [start] todos los buses están llenos [end]\n",
-      "[Input]: I have not heard from her yet. [Translation]: [start] todavía no he escuchado nada [end]\n",
-      "[Input]: It was just a coincidence. [Translation]: [start] era solo una coincidencia [end]\n",
-      "[Input]: For some reason the microphone didn't work earlier. [Translation]: [start] por alguna razón la lengua no funciona hasta al trabajo [end]\n",
-      "[Input]: Tom is helping his wife. [Translation]: [start] tom está ayudando a su esposa [end]\n"
+      "[Input]: Japan's population is larger than that of Britain and France put together. [Translation]: [start ]  la  pobl ando  fr ancia  y  fr ancia  y  fr ancia  y  fr ancia  y  fr ancia  y  la\n",
+      "[Input]: This time you went too far. [Translation]: [start ]  esta  vez  esta ión  [ ! ! ! ! ! ! ! ! ! ! !  esta ión  [\n",
+      "[Input]: She's made up her mind and refuses to be talked out of it. [Translation]: [start ]  se ó  que  se ó  y  se ó  que  se ó  [ ! !  lo  se ó  que  se\n",
+      "[Input]: I prefer to read. [Translation]: [start ]  pref !  me  gusta  [ ! ! ! ! ! ! ! ! ! ! !  pref ir  [\n",
+      "[Input]: I need a new wardrobe. [Translation]: [start ]  neces  un  nuevo  [ ! ! ! ! ! ! ! ! ! ! ! !  neces idad  [\n",
+      "[Input]: This mall is so big that I can't find the exit. [Translation]: [start ]  este o  es  tan  que  no  puedo ar  el  único  [ ! ! ! ! !  este o  no\n",
+      "[Input]: We made him go there. [Translation]: [start ]  nos amos  [ ! ! ! ! ! ! !  [ ! ! ! ! !  le  invit  [\n",
+      "[Input]: Didn't you hear the doorbell? [Translation]: [start ]  no aste  [ ! ! ! ! ! ! ! ! ! ! ! ! !  no  te  has\n",
+      "[Input]: It's the perfect moment for a kiss. [Translation]: [start ]  es  el  momento  [ !  un imo  [ ! !  [ ! ! ! ! !  es oso  [\n",
+      "[Input]: He pressured me. [Translation]: [start ]  él  me  dio  [ ! ! ! ! ! ! ! ! ! ! ! !  él  me  p\n"
      ]
     }
    ],

From 90f37a7856b46ab85907d6ffac9d42399635f4a0 Mon Sep 17 00:00:00 2001
From: Aatman09 <aatmansoni2006@gmail.com>
Date: Thu, 15 Jan 2026 19:46:30 +0000
Subject: [PATCH 3/5] final changes

---
 .../unet/tests/UNet_segmentation_example.md   |   2 +-
 .../tutorials/JAX_machine_translation.ipynb   | 271 ++++++++++++++----
 2 files changed, 214 insertions(+), 59 deletions(-)

diff --git a/bonsai/models/unet/tests/UNet_segmentation_example.md b/bonsai/models/unet/tests/UNet_segmentation_example.md
index 5663f428..a893efaa 100644
--- a/bonsai/models/unet/tests/UNet_segmentation_example.md
+++ b/bonsai/models/unet/tests/UNet_segmentation_example.md
@@ -256,7 +256,7 @@ def train_step(state: TrainState, other_vars: nnx.State, batch: tuple[jax.Array,
     return state, loss
 
 
-print("🚀 Starting training from checkpoint...")
+print("Starting training from checkpoint...")
 train_loader, vis_loader = load_dataset()
 num_epochs = 100
 state = train_state
diff --git a/bonsai/tutorials/JAX_machine_translation.ipynb b/bonsai/tutorials/JAX_machine_translation.ipynb
index 60b2b0de..cb478b90 100644
--- a/bonsai/tutorials/JAX_machine_translation.ipynb
+++ b/bonsai/tutorials/JAX_machine_translation.ipynb
@@ -18,9 +18,21 @@
     "We step through an encoder-decoder transformer in JAX and train a model for English->Spanish translation."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "0e5066d9",
+   "metadata": {},
+   "source": [
+    "### Installing Dependencies\n",
+    "The current versions are configured for **Google TPU v5**. To switch to the **GPU** version, use the following command:\n",
+    "\n",
+    "```python\n",
+    "%pip install \"jax[cuda12]==0.8.2\" \"flax==0.12.2\" numpy tiktoken tqdm grain optax matplotlib"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 98,
+   "execution_count": null,
    "id": "7bf8d50f",
    "metadata": {},
    "outputs": [
@@ -93,12 +105,12 @@
     }
    ],
    "source": [
-    "%pip install numpy tiktoken flax tqdm grain optax matplotlib jax"
+    "%pip install numpy tiktoken  tqdm grain optax matplotlib \"jax[tpu]==0.8.2\" \"flax == 0.12.2\""
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 99,
+   "execution_count": 1,
    "id": "dd506ffa-3b91-44f1-92d1-a08ed933e78e",
    "metadata": {},
    "outputs": [],
@@ -146,7 +158,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 100,
+   "execution_count": 2,
    "id": "102943a5-8724-48e0-8d6a-f56069f03426",
    "metadata": {},
    "outputs": [],
@@ -196,7 +208,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 101,
+   "execution_count": 3,
    "id": "bee9f1b0-5f74-47dc-a7e1-a4ea3be1ef7f",
    "metadata": {},
    "outputs": [
@@ -250,7 +262,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 102,
+   "execution_count": 4,
    "id": "07e054d3-a20c-4aed-8f8a-fb5158df8e5b",
    "metadata": {},
    "outputs": [],
@@ -267,7 +279,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 103,
+   "execution_count": 5,
    "id": "e2b3e5b3-8466-4c81-99da-0559c88b25ef",
    "metadata": {},
    "outputs": [],
@@ -279,7 +291,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 104,
+   "execution_count": 6,
    "id": "5bdc0673-9723-45b5-8a42-2152295df69b",
    "metadata": {},
    "outputs": [],
@@ -294,7 +306,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 105,
+   "execution_count": 7,
    "id": "235b1221-e72d-4793-addd-7bb870bd8e75",
    "metadata": {},
    "outputs": [],
@@ -313,7 +325,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 106,
+   "execution_count": 8,
    "id": "ca013d07-1504-42cc-906f-2fcacc757008",
    "metadata": {},
    "outputs": [],
@@ -333,7 +345,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 107,
+   "execution_count": 9,
    "id": "dcbfa780-553f-41f6-8b3e-55955db78b2a",
    "metadata": {},
    "outputs": [
@@ -341,7 +353,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'encoder_inputs': [30115, 2664, 9711, 757, 1523, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'decoder_inputs': [29563, 60, 12067, 658, 29452, 757, 32895, 10872, 689, 510, 408, 60, 0, 0, 0, 0, 0, 0, 0], 'target_output': [60, 12067, 658, 29452, 757, 32895, 10872, 689, 510, 408, 60, 0, 0, 0, 0, 0, 0, 0, 0]}\n"
+      "{'encoder_inputs': [29177, 499, 6604, 264, 2697, 62896, 4587, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'decoder_inputs': [29563, 60, 6183, 4355, 11158, 24180, 4247, 4799, 510, 408, 60, 0, 0, 0, 0, 0, 0, 0, 0], 'target_output': [60, 6183, 4355, 11158, 24180, 4247, 4799, 510, 408, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0]}\n"
      ]
     }
    ],
@@ -372,7 +384,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 108,
+   "execution_count": 10,
    "id": "a3f8a6fd",
    "metadata": {},
    "outputs": [],
@@ -389,7 +401,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "id": "121bf138-34b3-4be9-a0fc-3bbac81f469a",
    "metadata": {},
    "outputs": [],
@@ -513,7 +525,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 110,
+   "execution_count": 12,
    "id": "c5dcfaf6-f5cd-40f4-bbf0-2754c0193327",
    "metadata": {},
    "outputs": [],
@@ -559,7 +571,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 111,
+   "execution_count": 13,
    "id": "1fb8cb44-9012-4802-9286-1efc19dd2ba1",
    "metadata": {},
    "outputs": [],
@@ -628,7 +640,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 112,
+   "execution_count": 14,
    "id": "d2f8e06f-1126-41cc-b8d8-de6bd7a5255a",
    "metadata": {},
    "outputs": [],
@@ -648,7 +660,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 113,
+   "execution_count": 15,
    "id": "279d991f-f129-48b3-9b7e-d143019c18a8",
    "metadata": {},
    "outputs": [],
@@ -691,10 +703,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 114,
+   "execution_count": 16,
    "id": "32a17edc-33d0-41bc-a516-8b8ce45c3ad7",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Failed to find host bounds for accelerator type: WARNING: could not determine TPU accelerator type, please set env var `TPU_ACCELERATOR_TYPE` manually, otherwise libtpu.so may not properly initialize.\n",
+      "WARNING: Logging before InitGoogle() is written to STDERR\n",
+      "E0000 00:00:1768499505.463938   40451 common_lib.cc:530] INVALID_ARGUMENT: Error: unexpected worker hostname 'WARNING: could not determine TPU worker hostnames or IP addresses' from env var TPU_WORKER_HOSTNAMES. Expecting a valid hostname or IP address without port number, or hostname:port:address triple. (Full TPU workers' addr string: WARNING: could not determine TPU worker hostnames or IP addresses, please set env var `TPU_WORKER_HOSTNAMES` manually, otherwise libtpu.so may not properly initialize.)\n",
+      "=== Source Location Trace: === \n",
+      "learning/45eac/tfrc/runtime/libtpu_init_utils.cc:310\n"
+     ]
+    }
+   ],
    "source": [
     "eval_metrics = nnx.MultiMetric(\n",
     "    loss=nnx.metrics.Average(\"loss\"),\n",
@@ -713,7 +737,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 115,
+   "execution_count": 17,
    "id": "1189a6a6-2cc6-4c87-9f87-b4b800a1513d",
    "metadata": {},
    "outputs": [],
@@ -727,7 +751,7 @@
     "vocab_size = tokenizer.n_vocab\n",
     "sequence_length = 20\n",
     "learning_rate = 1.5e-3\n",
-    "num_epochs = 2\n",
+    "num_epochs = 10\n",
     "\n",
     "config = TransformerConfig(\n",
     "    sequence_length=sequence_length,\n",
@@ -741,7 +765,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 116,
+   "execution_count": 18,
    "id": "fbeb6101-be11-4a33-9650-a3efd3656855",
    "metadata": {},
    "outputs": [],
@@ -783,7 +807,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 117,
+   "execution_count": 19,
    "id": "49a1d33a-c2e4-4d48-821b-519f5c0192c7",
    "metadata": {},
    "outputs": [],
@@ -804,7 +828,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 118,
+   "execution_count": 20,
    "id": "c764510c-4d98-46ad-b877-8cfc2fa5a9ea",
    "metadata": {},
    "outputs": [
@@ -812,32 +836,160 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "[train] epoch: 0/2, [1300/1301], loss=1.19 [01:41<00:00] \n"
+      "[train] epoch: 0/10, [1300/1301], loss=1.1 [02:31<00:00]  \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 1/10\n",
+      "- total loss: 1.2200\n",
+      "- Accuracy: 0.7859\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 1/10, [1300/1301], loss=0.766 [01:37<00:00]\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[test] epoch: 1/2\n",
-      "- total loss: 1.2035\n",
-      "- Accuracy: 0.7882\n"
+      "[test] epoch: 2/10\n",
+      "- total loss: 0.9918\n",
+      "- Accuracy: 0.8195\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "[train] epoch: 1/2, [1300/1301], loss=0.877 [01:30<00:00]\n"
+      "[train] epoch: 2/10, [1300/1301], loss=0.63 [01:35<00:00] \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[test] epoch: 2/2\n",
-      "- total loss: 0.9836\n",
-      "- Accuracy: 0.8213\n"
+      "[test] epoch: 3/10\n",
+      "- total loss: 0.9035\n",
+      "- Accuracy: 0.8343\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 3/10, [1300/1301], loss=0.568 [01:36<00:00]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 4/10\n",
+      "- total loss: 0.8744\n",
+      "- Accuracy: 0.8410\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 4/10, [1300/1301], loss=0.499 [01:35<00:00]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 5/10\n",
+      "- total loss: 0.8573\n",
+      "- Accuracy: 0.8464\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 5/10, [1300/1301], loss=0.463 [01:35<00:00]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 6/10\n",
+      "- total loss: 0.8596\n",
+      "- Accuracy: 0.8478\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 6/10, [1300/1301], loss=0.425 [01:35<00:00]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 7/10\n",
+      "- total loss: 0.8618\n",
+      "- Accuracy: 0.8502\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 7/10, [1300/1301], loss=0.43 [01:34<00:00] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 8/10\n",
+      "- total loss: 0.8556\n",
+      "- Accuracy: 0.8514\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 8/10, [1300/1301], loss=0.442 [01:32<00:00]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 9/10\n",
+      "- total loss: 0.8708\n",
+      "- Accuracy: 0.8522\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[train] epoch: 9/10, [1300/1301], loss=0.376 [01:34<00:00]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[test] epoch: 10/10\n",
+      "- total loss: 0.8773\n",
+      "- Accuracy: 0.8537\n"
      ]
     }
    ],
@@ -857,23 +1009,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 119,
+   "execution_count": 21,
    "id": "a79ecfa5-d74a-4956-9ee2-cbed86d5a82f",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7cd622450990>"
+       "<matplotlib.legend.Legend at 0x73ec32bd1710>"
       ]
      },
-     "execution_count": 119,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -900,23 +1052,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 120,
+   "execution_count": 22,
    "id": "64d54051-358b-4de8-b5b3-04bebf18018f",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7cd622485950>]"
+       "[<matplotlib.lines.Line2D at 0x73ec3289c210>]"
       ]
      },
-     "execution_count": 120,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1000x1000 with 2 Axes>"
       ]
@@ -946,7 +1098,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 121,
+   "execution_count": 23,
    "id": "e4589706-cfd6-4efb-9975-bfa0df75d4f0",
    "metadata": {},
    "outputs": [],
@@ -959,7 +1111,7 @@
     "    emb_enc = model.positional_embedding(encoder_input)\n",
     "    encoder_outputs = model.encoder(emb_enc, mask=None)\n",
     "\n",
-    "    dummy_input_shape = (1, 1, model.config.embed_dim)\n",
+    "    dummy_input_shape = (1, 40, model.config.embed_dim)\n",
     "    model.init_cache(dummy_input_shape)\n",
     "\n",
     "    decoded_sentence = \"[start\"\n",
@@ -972,9 +1124,12 @@
     "        sampled_id = np.argmax(logits[0, 0, :]).item()\n",
     "        sampled_token = tokenizer.decode([sampled_id])\n",
     "\n",
-    "        decoded_sentence += \" \" + sampled_token\n",
+    "        decoded_sentence += \"\" + sampled_token\n",
+    "\n",
+    "        clean_token = sampled_token.strip()\n",
     "\n",
-    "        if sampled_token == \"[end]\":\n",
+    "        if sampled_token == \"[end]\" or clean_token == \"end\":\n",
+    "            decoded_sentence += \"]\"\n",
     "            break\n",
     "\n",
     "        # Update input for next loop\n",
@@ -985,7 +1140,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 122,
+   "execution_count": 24,
    "id": "554c2f72-0bd3-4ed1-804b-5f1a4cc13851",
    "metadata": {},
    "outputs": [],
@@ -995,7 +1150,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 123,
+   "execution_count": 25,
    "id": "c1d6edbb-af89-42c9-90c3-d61612b75da3",
    "metadata": {},
    "outputs": [],
@@ -1019,7 +1174,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 124,
+   "execution_count": 26,
    "id": "4f0ae018-b7cd-4849-b245-c5c647ad1a95",
    "metadata": {},
    "outputs": [
@@ -1027,16 +1182,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[Input]: Japan's population is larger than that of Britain and France put together. [Translation]: [start ]  la  pobl ando  fr ancia  y  fr ancia  y  fr ancia  y  fr ancia  y  fr ancia  y  la\n",
-      "[Input]: This time you went too far. [Translation]: [start ]  esta  vez  esta ión  [ ! ! ! ! ! ! ! ! ! ! !  esta ión  [\n",
-      "[Input]: She's made up her mind and refuses to be talked out of it. [Translation]: [start ]  se ó  que  se ó  y  se ó  que  se ó  [ ! !  lo  se ó  que  se\n",
-      "[Input]: I prefer to read. [Translation]: [start ]  pref !  me  gusta  [ ! ! ! ! ! ! ! ! ! ! !  pref ir  [\n",
-      "[Input]: I need a new wardrobe. [Translation]: [start ]  neces  un  nuevo  [ ! ! ! ! ! ! ! ! ! ! ! !  neces idad  [\n",
-      "[Input]: This mall is so big that I can't find the exit. [Translation]: [start ]  este o  es  tan  que  no  puedo ar  el  único  [ ! ! ! ! !  este o  no\n",
-      "[Input]: We made him go there. [Translation]: [start ]  nos amos  [ ! ! ! ! ! ! !  [ ! ! ! ! !  le  invit  [\n",
-      "[Input]: Didn't you hear the doorbell? [Translation]: [start ]  no aste  [ ! ! ! ! ! ! ! ! ! ! ! ! !  no  te  has\n",
-      "[Input]: It's the perfect moment for a kiss. [Translation]: [start ]  es  el  momento  [ !  un imo  [ ! !  [ ! ! ! ! !  es oso  [\n",
-      "[Input]: He pressured me. [Translation]: [start ]  él  me  dio  [ ! ! ! ! ! ! ! ! ! ! ! !  él  me  p\n"
+      "[Input]: This is the same necklace that I lost yesterday. [Translation]: [start] este es el mismo que perdí ayer [end]\n",
+      "[Input]: Tom has a house with two rooms. [Translation]: [start] tom tiene una casa de dos habitación [end]\n",
+      "[Input]: Tom is a schemer. [Translation]: [start] tom es un confunduista [end]\n",
+      "[Input]: You must study much harder. [Translation]: [start] debes estudiar más [end]\n",
+      "[Input]: Why isn't this working? [Translation]: [start] por qué no funciona esto [end]\n",
+      "[Input]: Do you like oranges? [Translation]: [start] te gustan las naranjas [end]\n",
+      "[Input]: I started writing a book. [Translation]: [start] empezé a escribir un libro [end]\n",
+      "[Input]: He's watching me. [Translation]: [start] él me está mirando [end]\n",
+      "[Input]: You speak Russian, don't you? [Translation]: [start] hablas ruso verdad [end]\n",
+      "[Input]: I didn't have any desire to do that. [Translation]: [start] no tenía nada de ganas de hacer eso [end]\n"
      ]
     }
    ],

From 782188664fd81091d63bd505002b2d8113b45ff2 Mon Sep 17 00:00:00 2001
From: Aatman09 <aatmansoni2006@gmail.com>
Date: Fri, 13 Feb 2026 22:08:59 +0000
Subject: [PATCH 4/5] intial commit for gpt_oss

---
 bonsai/models/gpt_oss/__init__.py       |   0
 bonsai/models/gpt_oss/modeling.py       | 253 ++++++++++++++++++++++++
 bonsai/models/gpt_oss/params.py         | 172 ++++++++++++++++
 bonsai/models/gpt_oss/tests/__init__.py |   0
 4 files changed, 425 insertions(+)
 create mode 100644 bonsai/models/gpt_oss/__init__.py
 create mode 100644 bonsai/models/gpt_oss/modeling.py
 create mode 100644 bonsai/models/gpt_oss/params.py
 create mode 100644 bonsai/models/gpt_oss/tests/__init__.py

diff --git a/bonsai/models/gpt_oss/__init__.py b/bonsai/models/gpt_oss/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/bonsai/models/gpt_oss/modeling.py b/bonsai/models/gpt_oss/modeling.py
new file mode 100644
index 00000000..61cef8d9
--- /dev/null
+++ b/bonsai/models/gpt_oss/modeling.py
@@ -0,0 +1,253 @@
+import jax
+import jax.numpy as jnp
+from flax import nnx
+from typing import Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class GptOssConfig:
+    vocab_size: int = 32000
+    hidden_size: int = 4096
+    intermediate_size: int = 14336
+    num_hidden_layers: int = 32
+    num_local_experts: int = 8
+    num_experts_per_tok: int = 2
+    router_aux_loss_coef: float = 0.001
+    num_attention_heads: int = 32
+    num_key_value_heads: int = 8
+    head_dim: Optional[int] = None
+    max_position_embeddings: int = 4096
+    rope_theta: float = 10000.0
+    attention_bias: bool = False
+    sliding_window: Optional[int] = None
+    rms_norm_eps: float = 1e-6
+    initializer_range: float = 0.02
+    pad_token_id: int = 0
+    attention_dropout: float = 0.0
+
+
+def create_rope_embeddings(max_seq_len, head_dim, theta=10000.0):
+    freqs = 1.0 / (theta ** (jnp.arange(0, head_dim, 2)[: (head_dim // 2)].astype(jnp.float32) / head_dim))
+    t = jnp.arange(max_seq_len)
+    freqs = jnp.outer(t, freqs)
+    return jnp.sin(freqs), jnp.cos(freqs)
+
+
+def apply_rotary_pos_emb(x, sins, coss):
+    d = x.shape[-1] // 2
+    x_r, x_i = x[..., :d], x[..., d:]
+
+    sins = sins[None, : x.shape[1], None, :]
+    coss = coss[None, : x.shape[1], None, :]
+
+    out_r = x_r * coss - x_i * sins
+    out_i = x_r * sins + x_i * coss
+    return jnp.concatenate([out_r, out_i], axis=-1)
+
+
+def make_causal_mask(seq_len, dtype=jnp.float32):
+    idx = jnp.arange(seq_len)
+    mask = idx[:, None] >= idx[None, :]
+    return mask[None, None, :, :]
+
+
+class RMSNorm(nnx.Module):
+    def __init__(self, hidden_size: int, eps: float = 1e-6, *, rngs: nnx.Rngs = None):
+        self.weight = nnx.Param(jnp.ones(hidden_size))
+        self.variance_epsilon = eps
+
+    def __call__(self, hidden_state):
+        hidden_state = hidden_state.astype(jnp.float32)
+        variance = jnp.mean(hidden_state**2, axis=-1, keepdims=True)
+        mean = jnp.sqrt(variance + self.variance_epsilon)
+        return (hidden_state / mean) * self.weight.value
+
+
+class GptOssExperts(nnx.Module):
+    def __init__(self, config: GptOssConfig):
+        self.intermediate_size = config.intermediate_size
+        self.num_experts = config.num_local_experts
+        self.hidden_size = config.hidden_size
+        self.expert_dim = self.intermediate_size
+        self.alpha = 1.702
+        self.limit = 7.0
+
+        self.gate_up_proj = nnx.Param(jnp.zeros((self.num_experts, self.hidden_size, 2 * self.expert_dim)))
+        self.gate_up_proj_bias = nnx.Param(jnp.zeros((self.num_experts, 2 * self.expert_dim)))
+        self.down_proj = nnx.Param(jnp.zeros((self.num_experts, self.expert_dim, self.hidden_size)))
+        self.down_proj_bias = nnx.Param(jnp.zeros((self.num_experts, self.hidden_size)))
+
+    def __call__(self, hidden_states, router_indices=None, routing_weights=None):
+        B, S, H = hidden_states.shape
+        hidden_flat = hidden_states.reshape(-1, H)
+        num_experts = routing_weights.shape[1]
+
+        hidden_rep = jnp.broadcast_to(hidden_flat[None, :, :], (self.num_experts, B * S, H))
+        gate_up = jnp.einsum("enh,ehd->end", hidden_rep, self.gate_up_proj.value)
+        gate_up = gate_up + self.gate_up_proj_bias.value[:, None, :]
+
+        gate = gate_up[..., ::2]
+        up = gate_up[..., 1::2]
+        gate = jnp.minimum(gate, self.limit)
+        up = jnp.clip(up, -self.limit, self.limit)
+        glu = gate * jax.nn.sigmoid(gate * self.alpha)
+        gated_output = (up + 1) * glu
+
+        next_states = jnp.einsum("end,edh->enh", gated_output, self.down_proj.value)
+        next_states = next_states + self.down_proj_bias.value[:, None, :]
+
+        next_states = next_states.reshape(self.num_experts, B, S, H)
+        weights = routing_weights.T.reshape(self.num_experts, B, S)
+        final_output = jnp.sum(next_states * weights[..., None], axis=0)
+        return final_output
+
+
+class GptOssTopKRouter(nnx.Module):
+    def __init__(self, config: GptOssConfig, *, rngs: nnx.Rngs):
+        self.top_k = config.num_experts_per_tok
+        self.num_experts = config.num_local_experts
+        self.hidden_dim = config.hidden_size
+        self.linear = nnx.Linear(in_features=self.hidden_dim, out_features=self.num_experts, use_bias=True, rngs=rngs)
+
+    def __call__(self, hidden_states):
+        B, S, H = hidden_states.shape
+        hidden_flat = hidden_states.reshape(-1, H)
+        router_logits = self.linear(hidden_flat)  # [B*S, E]
+        router_top_value, router_indices = jax.lax.top_k(router_logits, k=self.top_k)
+        router_top_value = nnx.softmax(router_top_value, axis=-1)
+
+        router_scores = jnp.zeros_like(router_logits)
+        token_idx = jnp.arange(B * S)[:, None]
+        router_scores = router_scores.at[token_idx, router_indices].set(router_top_value)
+        return router_scores, router_indices
+
+
+class GptOssMLP(nnx.Module):
+    def __init__(self, config: GptOssConfig, *, rngs: nnx.Rngs):
+        self.router = GptOssTopKRouter(config, rngs=rngs)
+        self.experts = GptOssExperts(config)
+
+    def __call__(self, hidden_states):
+        router_scores, router_indices = self.router(hidden_states)
+        routed_out = self.experts(hidden_states, router_indices=router_indices, routing_weights=router_scores)
+        return routed_out, router_scores
+
+
+class GptOssAttention(nnx.Module):
+    def __init__(self, config: GptOssConfig, *, rngs: nnx.Rngs):
+        self.config = config
+        self.hidden_size = config.hidden_size
+        self.num_heads = config.num_attention_heads
+        self.num_kv_heads = config.num_key_value_heads
+        self.head_dim = config.head_dim if config.head_dim is not None else self.hidden_size // self.num_heads
+        self.num_kv_groups = self.num_heads // self.num_kv_heads
+
+        self.q_proj = nnx.Linear(
+            self.hidden_size, self.num_heads * self.head_dim, use_bias=config.attention_bias, rngs=rngs
+        )
+        self.k_proj = nnx.Linear(
+            self.hidden_size, self.num_kv_heads * self.head_dim, use_bias=config.attention_bias, rngs=rngs
+        )
+        self.v_proj = nnx.Linear(
+            self.hidden_size, self.num_kv_heads * self.head_dim, use_bias=config.attention_bias, rngs=rngs
+        )
+        self.o_proj = nnx.Linear(
+            self.num_heads * self.head_dim, self.hidden_size, use_bias=config.attention_bias, rngs=rngs
+        )
+
+        self.sinks = nnx.Param(jnp.zeros((self.num_heads,)))
+
+    def __call__(self, hidden_states, sins, coss, mask=None):
+        B, S, _ = hidden_states.shape
+
+        q = self.q_proj(hidden_states).reshape(B, S, self.num_heads, self.head_dim)
+        k = self.k_proj(hidden_states).reshape(B, S, self.num_kv_heads, self.head_dim)
+        v = self.v_proj(hidden_states).reshape(B, S, self.num_kv_heads, self.head_dim)
+
+        q = apply_rotary_pos_emb(q, sins, coss)
+        k = apply_rotary_pos_emb(k, sins, coss)
+
+        if self.num_kv_groups > 1:
+            k = jnp.repeat(k, self.num_kv_groups, axis=2)
+            v = jnp.repeat(v, self.num_kv_groups, axis=2)
+
+        q = q.transpose(0, 2, 1, 3)
+        k = k.transpose(0, 2, 1, 3)
+        v = v.transpose(0, 2, 1, 3)
+
+        scale = 1.0 / jnp.sqrt(self.head_dim)
+        scores = jnp.matmul(q, k.transpose(0, 1, 3, 2)) * scale
+
+        if mask is not None:
+            scores = scores + mask
+
+        probs = nnx.softmax(scores, axis=-1)
+
+        output = jnp.matmul(probs, v)
+        output = output.transpose(0, 2, 1, 3).reshape(B, S, self.num_heads * self.head_dim)
+
+        return self.o_proj(output)
+
+
+class GptOssDecoderLayer(nnx.Module):
+    def __init__(self, config: GptOssConfig, *, rngs: nnx.Rngs):
+        self.input_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.self_attn = GptOssAttention(config, rngs=rngs)
+        self.post_attention_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.mlp = GptOssMLP(config, rngs=rngs)
+
+    def __call__(self, hidden_states, sins, coss, mask=None):
+        residual = hidden_states
+        hidden_states = self.input_layernorm(hidden_states)
+
+        hidden_states = self.self_attn(hidden_states, sins, coss, mask)
+        hidden_states = residual + hidden_states
+
+        residual = hidden_states
+        hidden_states = self.post_attention_layernorm(hidden_states)
+
+        hidden_states, _ = self.mlp(hidden_states)
+        hidden_states = residual + hidden_states
+
+        return hidden_states
+
+
+class GptOssModel(nnx.Module):
+    def __init__(self, config: GptOssConfig, *, rngs: nnx.Rngs):
+        self.config = config
+        self.embed_tokens = nnx.Embed(config.vocab_size, config.hidden_size, rngs=rngs)
+
+        self.layers = nnx.List([GptOssDecoderLayer(config, rngs=rngs) for _ in range(config.num_hidden_layers)])
+
+        self.norm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+    def __call__(self, input_ids):
+        hidden_states = self.embed_tokens(input_ids)
+        B, S, _ = hidden_states.shape
+        head_dim = (
+            self.config.head_dim
+            if self.config.head_dim is not None
+            else self.config.hidden_size // self.config.num_attention_heads
+        )
+        sins, coss = create_rope_embeddings(S, head_dim, self.config.rope_theta)
+
+        mask = make_causal_mask(S)
+        mask = jnp.where(mask, 0, -1e9)
+
+        for layer in self.layers:
+            hidden_states = layer(hidden_states, sins, coss, mask)
+
+        hidden_states = self.norm(hidden_states)
+        return hidden_states
+
+
+class GptOssForCausalLM(nnx.Module):
+    def __init__(self, config: GptOssConfig, *, rngs: nnx.Rngs):
+        self.model = GptOssModel(config, rngs=rngs)
+        self.lm_head = nnx.Linear(config.hidden_size, config.vocab_size, use_bias=False, rngs=rngs)
+
+    def __call__(self, input_ids):
+        hidden_states = self.model(input_ids)
+        logits = self.lm_head(hidden_states)
+        return logits
diff --git a/bonsai/models/gpt_oss/params.py b/bonsai/models/gpt_oss/params.py
new file mode 100644
index 00000000..e2c48b26
--- /dev/null
+++ b/bonsai/models/gpt_oss/params.py
@@ -0,0 +1,172 @@
+import re
+from enum import Enum
+import jax.numpy as jnp
+import safetensors.flax as safetensors
+from etils import epath
+from flax import nnx
+
+from bonsai.models.gpt_oss import modeling as model_lib
+
+
+def _get_key_and_transform_mapping(cfg: model_lib.GptOssConfig):
+    class Transform(Enum):
+        DEFAULT = None
+        BIAS = None
+        LINEAR = ((1, 0), None)
+        SCALE = None
+
+    return {
+        r"^model.embed_tokens.weight$": (r"model.embed_tokens.embedding", Transform.DEFAULT),
+        r"^model.norm.weight$": (r"model.norm.weight", Transform.DEFAULT),
+        r"^lm_head.weight$": (r"lm_head.kernel", Transform.LINEAR),
+        # Layers
+        r"^model.layers.([0-9]+).input_layernorm.weight$": (
+            r"model.layers.\1.input_layernorm.weight",
+            Transform.DEFAULT,
+        ),
+        r"^model.layers.([0-9]+).post_attention_layernorm.weight$": (
+            r"model.layers.\1.post_attention_layernorm.weight",
+            Transform.DEFAULT,
+        ),
+        # Attention projections
+        r"^model.layers.([0-9]+).self_attn.q_proj.weight$": (
+            r"model.layers.\1.self_attn.q_proj.kernel",
+            Transform.LINEAR,
+        ),
+        r"^model.layers.([0-9]+).self_attn.k_proj.weight$": (
+            r"model.layers.\1.self_attn.k_proj.kernel",
+            Transform.LINEAR,
+        ),
+        r"^model.layers.([0-9]+).self_attn.v_proj.weight$": (
+            r"model.layers.\1.self_attn.v_proj.kernel",
+            Transform.LINEAR,
+        ),
+        r"^model.layers.([0-9]+).self_attn.o_proj.weight$": (
+            r"model.layers.\1.self_attn.o_proj.kernel",
+            Transform.LINEAR,
+        ),
+        # Attention biases
+        r"^model.layers.([0-9]+).self_attn.q_proj.bias$": (r"model.layers.\1.self_attn.q_proj.bias", Transform.BIAS),
+        r"^model.layers.([0-9]+).self_attn.k_proj.bias$": (r"model.layers.\1.self_attn.k_proj.bias", Transform.BIAS),
+        r"^model.layers.([0-9]+).self_attn.v_proj.bias$": (r"model.layers.\1.self_attn.v_proj.bias", Transform.BIAS),
+        r"^model.layers.([0-9]+).self_attn.o_proj.bias$": (r"model.layers.\1.self_attn.o_proj.bias", Transform.BIAS),
+        # Attention sinks
+        r"^model.layers.([0-9]+).self_attn.sinks$": (r"model.layers.\1.self_attn.sinks", Transform.DEFAULT),
+        # MoE Router
+        r"^model.layers.([0-9]+).mlp.router.weight$": (r"model.layers.\1.mlp.router.linear.kernel", Transform.LINEAR),
+        r"^model.layers.([0-9]+).mlp.router.bias$": (r"model.layers.\1.mlp.router.linear.bias", Transform.BIAS),
+        # MoE Experts
+        r"^model.layers.([0-9]+).mlp.experts.gate_up_proj$": (
+            r"model.layers.\1.mlp.experts.gate_up_proj",
+            Transform.DEFAULT,
+        ),
+        r"^model.layers.([0-9]+).mlp.experts.gate_up_proj_bias$": (
+            r"model.layers.\1.mlp.experts.gate_up_proj_bias",
+            Transform.DEFAULT,
+        ),
+        r"^model.layers.([0-9]+).mlp.experts.down_proj$": (r"model.layers.\1.mlp.experts.down_proj", Transform.DEFAULT),
+        r"^model.layers.([0-9]+).mlp.experts.down_proj_bias$": (
+            r"model.layers.\1.mlp.experts.down_proj_bias",
+            Transform.DEFAULT,
+        ),
+    }
+
+
+def _st_key_to_jax_key(mapping, source_key):
+    subs = []
+    for pat, (repl, transform) in mapping.items():
+        if re.match(pat, source_key):
+            target_key = re.sub(pat, repl, source_key)
+            subs.append((target_key, transform))
+
+    if not subs:
+        return None, None
+
+    if len(subs) > 1:
+        keys = [s for s, _ in subs]
+        raise ValueError(f"Multiple mappings found for {source_key!r}: {keys}")
+
+    return subs[0]
+
+
+def _assign_weights(keys, tensor, state_dict, st_key, transform):
+    key = keys[0]
+    rest = keys[1:]
+
+    if not rest:
+        if transform is not None:
+            if hasattr(transform, "value"):
+                val = transform.value
+            else:
+                val = transform
+
+            permute = None
+            reshape = None
+            if val is not None:
+                permute, reshape = val
+            if permute:
+                tensor = tensor.transpose(permute)
+            if reshape:
+                tensor = tensor.reshape(reshape)
+
+        if key not in state_dict:
+            available = list(state_dict.keys())
+            raise ValueError(
+                f"Target key '{key}' not found in state dict at this level. Available: {available}. Source: {st_key}"
+            )
+
+        target_shape = state_dict[key].shape
+        if tensor.shape != target_shape:
+            raise ValueError(f"Shape mismatch for {st_key} -> {key}: Source {tensor.shape} vs Target {target_shape}")
+
+        state_dict[key] = jnp.array(tensor)
+    else:
+        if key not in state_dict:
+            available = list(state_dict.keys())
+            raise ValueError(f"Intermediate key '{key}' not found. Available: {available}. Source: {st_key}")
+
+        _assign_weights(rest, tensor, state_dict[key], st_key, transform)
+
+
+def _stoi(s):
+    try:
+        return int(s)
+    except ValueError:
+        return s
+
+
+def create_gpt_oss_from_pretrained(file_dir: str, config: model_lib.GptOssConfig):
+    files = list(epath.Path(file_dir).expanduser().glob("*.safetensors"))
+    if not files:
+        raise ValueError(f"No safetensors found in {file_dir}")
+
+    tensor_dict = {}
+    for f in files:
+        tensor_dict.update(safetensors.load_file(f))
+
+    model = model_lib.GptOssForCausalLM(config, rngs=nnx.Rngs(0))
+    graph_def, abs_state = nnx.split(model)
+    jax_state = abs_state.to_pure_dict()
+
+    mapping = _get_key_and_transform_mapping(config)
+    conversion_errors = []
+
+    for st_key, tensor in tensor_dict.items():
+        jax_key, transform = _st_key_to_jax_key(mapping, st_key)
+
+        if jax_key is None:
+            continue
+
+        keys = [_stoi(k) for k in jax_key.split(".")]
+
+        try:
+            _assign_weights(keys, tensor, jax_state, st_key, transform)
+        except Exception as e:
+            full_jax_key = ".".join([str(k) for k in keys])
+            conversion_errors.append(f"Failed to assign '{st_key}' to '{full_jax_key}': {type(e).__name__}: {e}")
+
+    if conversion_errors:
+        full_error_log = "\n".join(conversion_errors)
+        raise RuntimeError(f"Encountered {len(conversion_errors)} weight conversion errors:\n{full_error_log}")
+
+    return nnx.merge(graph_def, jax_state)
diff --git a/bonsai/models/gpt_oss/tests/__init__.py b/bonsai/models/gpt_oss/tests/__init__.py
new file mode 100644
index 00000000..e69de29b

From 1d0faaa3ef69d906be8ebc836abc65c469670256 Mon Sep 17 00:00:00 2001
From: Aatman09 <aatmansoni2006@gmail.com>
Date: Mon, 18 May 2026 11:15:36 +0000
Subject: [PATCH 5/5] added test cases

---
 bonsai/models/gpt_oss/tests/run_model.py      |  95 +++++
 .../gpt_oss/tests/test_outputs_gpt_oss.py     | 338 ++++++++++++++++++
 2 files changed, 433 insertions(+)
 create mode 100644 bonsai/models/gpt_oss/tests/run_model.py
 create mode 100644 bonsai/models/gpt_oss/tests/test_outputs_gpt_oss.py

diff --git a/bonsai/models/gpt_oss/tests/run_model.py b/bonsai/models/gpt_oss/tests/run_model.py
new file mode 100644
index 00000000..b24bb813
--- /dev/null
+++ b/bonsai/models/gpt_oss/tests/run_model.py
@@ -0,0 +1,95 @@
+# Copyright 2025 The JAX Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import tempfile
+import time
+
+import jax
+import jax.numpy as jnp
+import torch
+from transformers import GptOssConfig, GptOssForCausalLM
+
+from bonsai.models.gpt_oss import modeling, params
+
+
+def run_model():
+    # No small public gpt-oss checkpoint exists, so smoke-test on a tiny
+    # randomly-initialized model round-tripped through safetensors.
+    vocab_size, hidden, inter = 128, 64, 96
+    hf_config = GptOssConfig(
+        vocab_size=vocab_size,
+        hidden_size=hidden,
+        intermediate_size=inter,
+        num_hidden_layers=2,
+        num_local_experts=4,
+        num_experts_per_tok=2,
+        num_attention_heads=4,
+        num_key_value_heads=2,
+        head_dim=16,
+        max_position_embeddings=128,
+        attention_bias=True,
+        sliding_window=4096,
+        layer_types=["full_attention"] * 2,
+        rope_parameters={"rope_type": "default", "rope_theta": 10000.0},
+        tie_word_embeddings=False,
+        pad_token_id=0,
+    )
+    bonsai_config = modeling.GptOssConfig(
+        vocab_size=vocab_size,
+        hidden_size=hidden,
+        intermediate_size=inter,
+        num_hidden_layers=2,
+        num_local_experts=4,
+        num_experts_per_tok=2,
+        num_attention_heads=4,
+        num_key_value_heads=2,
+        head_dim=16,
+        max_position_embeddings=128,
+        rope_theta=10000.0,
+        attention_bias=True,
+        pad_token_id=0,
+    )
+
+    torch.manual_seed(0)
+    hf_model = GptOssForCausalLM(hf_config)
+    with torch.no_grad():
+        for _, p in hf_model.named_parameters():
+            p.normal_(mean=0.0, std=0.02)
+
+    with tempfile.TemporaryDirectory() as d:
+        hf_model.save_pretrained(d, safe_serialization=True)
+        model = params.create_gpt_oss_from_pretrained(d, bonsai_config)
+
+    @jax.jit
+    def forward(m, ids):
+        return m(ids)
+
+    batch_size, seq_len = 4, 16
+    dummy = jnp.ones((batch_size, seq_len), dtype=jnp.int32)
+
+    _ = forward(model, dummy).block_until_ready()  # warmup / compile
+
+    t0 = time.perf_counter()
+    for _ in range(10):
+        logits = forward(model, dummy).block_until_ready()
+    print(f"Step time: {(time.perf_counter() - t0) / 10:.4f} s")
+
+    print("Predicted next-token ids:", jnp.argmax(logits[:, -1, :], axis=-1))
+
+
+if __name__ == "__main__":
+    run_model()
+
+
+__all__ = ["run_model"]
diff --git a/bonsai/models/gpt_oss/tests/test_outputs_gpt_oss.py b/bonsai/models/gpt_oss/tests/test_outputs_gpt_oss.py
new file mode 100644
index 00000000..1590fa23
--- /dev/null
+++ b/bonsai/models/gpt_oss/tests/test_outputs_gpt_oss.py
@@ -0,0 +1,338 @@
+"""Numerical-parity tests for the Bonsai (JAX/NNX) gpt_oss port.
+
+Strategy
+--------
+There is no small public ``gpt-oss`` checkpoint (the released models are
+20B/120B and MXFP4-quantized), so instead of downloading a checkpoint we:
+
+  1. build a *tiny* random HuggingFace ``GptOssForCausalLM``,
+  2. ``save_pretrained`` it to a temp dir as safetensors,
+  3. load those exact weights into the Bonsai model through the real
+     ``params.create_gpt_oss_from_pretrained`` path.
+
+Both models therefore hold identical weights, so every submodule must
+produce numerically identical outputs (up to float tolerance).
+
+Two known gaps between the Bonsai port and HF gpt_oss are neutralized so
+the suite isolates real regressions rather than re-reporting them:
+
+  * **Attention sinks** -- HF appends a per-head learned "sink" logit to
+    the attention softmax (``eager_attention_forward``). The Bonsai
+    ``GptOssAttention`` declares ``self.sinks`` but never applies it. We
+    set the HF sinks to a large negative value so ``exp(sink) -> 0`` and
+    HF reduces to the plain softmax the Bonsai port implements. To test
+    the sink path, implement it in ``modeling.GptOssAttention`` and drop
+    the override in ``_init_hf_weights``.
+  * **Sliding-window attention** -- HF alternates sliding/full attention
+    layers; the Bonsai port is always full-causal. We pin all HF layers
+    to ``"full_attention"`` in the config so the two agree.
+"""
+
+import tempfile
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+import torch
+from absl.testing import absltest
+from flax import nnx
+from transformers import GptOssConfig, GptOssForCausalLM
+from transformers.cache_utils import DynamicCache
+from transformers.masking_utils import create_causal_mask
+
+from bonsai.models.gpt_oss import modeling, params
+
+# Large-negative sink so HF's softmax sink column vanishes and HF matches
+# the Bonsai port's plain-softmax attention. See module docstring.
+_DEAD_SINK = -1e30
+
+
+def _make_configs():
+    """A small config shared by the HF reference and the Bonsai model."""
+    vocab_size = 64
+    hidden_size = 32
+    intermediate_size = 48
+    num_hidden_layers = 2
+    num_local_experts = 4
+    num_experts_per_tok = 2
+    num_attention_heads = 4
+    num_key_value_heads = 2
+    head_dim = 8
+    rms_norm_eps = 1e-6
+    rope_theta = 10000.0
+    max_position_embeddings = 64
+
+    hf_config = GptOssConfig(
+        vocab_size=vocab_size,
+        hidden_size=hidden_size,
+        intermediate_size=intermediate_size,
+        num_hidden_layers=num_hidden_layers,
+        num_local_experts=num_local_experts,
+        num_experts_per_tok=num_experts_per_tok,
+        num_attention_heads=num_attention_heads,
+        num_key_value_heads=num_key_value_heads,
+        head_dim=head_dim,
+        max_position_embeddings=max_position_embeddings,
+        rms_norm_eps=rms_norm_eps,
+        attention_bias=True,
+        # Window > seq_len: the sliding mask equals full-causal for our short
+        # sequences. HF builds it unconditionally, so it must be a valid int.
+        sliding_window=4096,
+        # Pin every layer to full attention so the Bonsai full-causal port
+        # matches (Bonsai does not implement sliding-window attention).
+        layer_types=["full_attention"] * num_hidden_layers,
+        # Plain RoPE so HF matches modeling.create_rope_embeddings.
+        rope_parameters={"rope_type": "default", "rope_theta": rope_theta},
+        tie_word_embeddings=False,
+        pad_token_id=0,
+        attention_dropout=0.0,
+    )
+    hf_config._attn_implementation = "eager"  # _supports_sdpa is False anyway
+
+    bonsai_config = modeling.GptOssConfig(
+        vocab_size=vocab_size,
+        hidden_size=hidden_size,
+        intermediate_size=intermediate_size,
+        num_hidden_layers=num_hidden_layers,
+        num_local_experts=num_local_experts,
+        num_experts_per_tok=num_experts_per_tok,
+        num_attention_heads=num_attention_heads,
+        num_key_value_heads=num_key_value_heads,
+        head_dim=head_dim,
+        max_position_embeddings=max_position_embeddings,
+        rope_theta=rope_theta,
+        attention_bias=True,
+        sliding_window=None,
+        rms_norm_eps=rms_norm_eps,
+        pad_token_id=0,
+        attention_dropout=0.0,
+    )
+    return hf_config, bonsai_config
+
+
+def _init_hf_weights(model: GptOssForCausalLM):
+    """Deterministically fill every parameter (HF uses torch.empty for some).
+
+    Norm weights are centered at 1.0 (realistic + numerically stable);
+    everything else is small Gaussian. Attention sinks are forced to a
+    large negative value -- see module docstring.
+    """
+    torch.manual_seed(0)
+    with torch.no_grad():
+        for name, p in model.named_parameters():
+            if name.endswith("sinks"):
+                p.fill_(_DEAD_SINK)
+            elif "norm" in name and p.dim() == 1:
+                p.normal_(mean=1.0, std=0.02)
+            else:
+                p.normal_(mean=0.0, std=0.02)
+    model.eval()
+
+
+class TestModuleForwardPasses(absltest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        jax.config.update("jax_default_matmul_precision", "float32")
+
+        cls.hf_config, cls.bonsai_config = _make_configs()
+
+        cls.torch_model = GptOssForCausalLM(cls.hf_config)
+        _init_hf_weights(cls.torch_model)
+
+        # Round-trip through safetensors so the real param-loading code runs.
+        cls._tmpdir = tempfile.TemporaryDirectory()
+        cls.torch_model.save_pretrained(cls._tmpdir.name, safe_serialization=True)
+
+        graph_def, state = nnx.split(
+            params.create_gpt_oss_from_pretrained(cls._tmpdir.name, cls.bonsai_config)
+        )
+        state = jax.tree.map(lambda x: x.astype(jnp.float32) if isinstance(x, jax.Array) else x, state)
+        cls.nnx_model = nnx.merge(graph_def, state)
+
+        cls.batch_size = 2
+        cls.seq_len = 6
+        cls.hidden = cls.bonsai_config.hidden_size
+        cls.head_dim = cls.bonsai_config.head_dim
+        cls.tol = 1e-4
+        cls.full_tol = 2e-3
+
+    @classmethod
+    def tearDownClass(cls):
+        cls._tmpdir.cleanup()
+        super().tearDownClass()
+
+    # ---- helpers ---------------------------------------------------------
+
+    def _assert_close(self, jy, ty, tol):
+        torch.testing.assert_close(
+            torch.tensor(np.array(jy, dtype=np.float32)),
+            ty.to(torch.float32),
+            rtol=tol,
+            atol=tol,
+            check_dtype=False,
+        )
+
+    def _rand_hidden(self, key=0):
+        shape = (self.batch_size, self.seq_len, self.hidden)
+        jx = jax.random.normal(jax.random.key(key), shape, dtype=jnp.float32)
+        tx = torch.tensor(np.array(jx, dtype=np.float32))
+        return jx, tx
+
+    def _bonsai_rope_and_mask(self):
+        sins, coss = modeling.create_rope_embeddings(
+            self.seq_len, self.head_dim, self.bonsai_config.rope_theta
+        )
+        mask = modeling.make_causal_mask(self.seq_len)
+        mask = jnp.where(mask, 0, -1e9)
+        return sins, coss, mask
+
+    def _torch_attn_inputs(self, hidden_t):
+        """Reproduce the position-embeddings + causal mask GptOssModel builds."""
+        past = DynamicCache(config=self.hf_config)
+        cache_position = torch.arange(self.seq_len)
+        position_ids = cache_position.unsqueeze(0)
+        mask = create_causal_mask(
+            config=self.hf_config,
+            input_embeds=hidden_t,
+            attention_mask=None,
+            cache_position=cache_position,
+            past_key_values=past,
+            position_ids=position_ids,
+        )
+        cos, sin = self.torch_model.model.rotary_emb(hidden_t, position_ids)
+        return {
+            "attention_mask": mask,
+            "position_ids": position_ids,
+            "position_embeddings": (cos, sin),
+            "past_key_values": None,
+            "use_cache": False,
+        }
+
+    # ---- leaf modules ----------------------------------------------------
+
+    def test_embed_tokens(self):
+        ids = np.random.randint(0, self.bonsai_config.vocab_size, size=(self.batch_size, self.seq_len))
+        jy = self.nnx_model.model.embed_tokens(jnp.asarray(ids))
+        ty = self.torch_model.model.embed_tokens(torch.tensor(ids))
+        self._assert_close(jy, ty, self.tol)
+
+    def test_rms_norm(self):
+        jx, tx = self._rand_hidden()
+        jy = self.nnx_model.model.layers[0].input_layernorm(jx)
+        ty = self.torch_model.model.layers[0].input_layernorm(tx)
+        self._assert_close(jy, ty, self.tol)
+
+    def test_final_norm(self):
+        jx, tx = self._rand_hidden()
+        jy = self.nnx_model.model.norm(jx)
+        ty = self.torch_model.model.norm(tx)
+        self._assert_close(jy, ty, self.tol)
+
+    def test_q_proj(self):
+        jx, tx = self._rand_hidden()
+        jy = self.nnx_model.model.layers[0].self_attn.q_proj(jx)
+        ty = self.torch_model.model.layers[0].self_attn.q_proj(tx)
+        self._assert_close(jy, ty, self.tol)
+
+    def test_k_proj(self):
+        jx, tx = self._rand_hidden()
+        jy = self.nnx_model.model.layers[0].self_attn.k_proj(jx)
+        ty = self.torch_model.model.layers[0].self_attn.k_proj(tx)
+        self._assert_close(jy, ty, self.tol)
+
+    def test_v_proj(self):
+        jx, tx = self._rand_hidden()
+        jy = self.nnx_model.model.layers[0].self_attn.v_proj(jx)
+        ty = self.torch_model.model.layers[0].self_attn.v_proj(tx)
+        self._assert_close(jy, ty, self.tol)
+
+    def test_o_proj(self):
+        n_heads = self.bonsai_config.num_attention_heads
+        shape = (self.batch_size, self.seq_len, n_heads * self.head_dim)
+        jx = jax.random.normal(jax.random.key(0), shape, dtype=jnp.float32)
+        tx = torch.tensor(np.array(jx, dtype=np.float32))
+        jy = self.nnx_model.model.layers[0].self_attn.o_proj(jx)
+        ty = self.torch_model.model.layers[0].self_attn.o_proj(tx)
+        self._assert_close(jy, ty, self.tol)
+
+    def test_lm_head(self):
+        jx, tx = self._rand_hidden()
+        jy = self.nnx_model.lm_head(jx)
+        ty = self.torch_model.lm_head(tx)
+        self._assert_close(jy, ty, self.tol)
+
+    def test_rope_sin_cos(self):
+        sins, coss = modeling.create_rope_embeddings(
+            self.seq_len, self.head_dim, self.bonsai_config.rope_theta
+        )
+        hidden_t = torch.ones((1, self.seq_len, self.hidden))
+        position_ids = torch.arange(self.seq_len).unsqueeze(0)
+        cos_t, sin_t = self.torch_model.model.rotary_emb(hidden_t, position_ids)
+        # HF returns (B, S, head_dim/2); Bonsai returns (S, head_dim/2).
+        self._assert_close(sins, sin_t[0], self.tol)
+        self._assert_close(coss, cos_t[0], self.tol)
+
+    # ---- composite modules ----------------------------------------------
+
+    def test_mlp(self):
+        # Covers GptOssTopKRouter + GptOssExperts (different internal score
+        # representations, but the routed output must agree).
+        jx, tx = self._rand_hidden()
+        jy, _ = self.nnx_model.model.layers[0].mlp(jx)
+        ty, _ = self.torch_model.model.layers[0].mlp(tx)
+        self._assert_close(jy, ty, self.tol)
+
+    def test_attention(self):
+        jx, tx = self._rand_hidden()
+        sins, coss, mask = self._bonsai_rope_and_mask()
+        jy = self.nnx_model.model.layers[0].self_attn(jx, sins, coss, mask)
+
+        ti = self._torch_attn_inputs(tx)
+        ty, _ = self.torch_model.model.layers[0].self_attn(
+            hidden_states=tx,
+            position_embeddings=ti["position_embeddings"],
+            attention_mask=ti["attention_mask"],
+            past_key_values=None,
+        )
+        self._assert_close(jy, ty, self.tol)
+
+    def test_decoder_layer(self):
+        jx, tx = self._rand_hidden()
+        sins, coss, mask = self._bonsai_rope_and_mask()
+        jy = self.nnx_model.model.layers[0](jx, sins, coss, mask)
+
+        ti = self._torch_attn_inputs(tx)
+        ty = self.torch_model.model.layers[0](hidden_states=tx, **ti)
+        self._assert_close(jy, ty, self.tol)
+
+    def test_all_decoder_layers(self):
+        for idx in range(self.bonsai_config.num_hidden_layers):
+            jx, tx = self._rand_hidden(key=idx)
+            sins, coss, mask = self._bonsai_rope_and_mask()
+            jy = self.nnx_model.model.layers[idx](jx, sins, coss, mask)
+            ti = self._torch_attn_inputs(tx)
+            ty = self.torch_model.model.layers[idx](hidden_states=tx, **ti)
+            self._assert_close(jy, ty, self.tol)
+
+    # ---- full model ------------------------------------------------------
+
+    def test_full(self):
+        ids = np.random.randint(0, self.bonsai_config.vocab_size, size=(1, self.seq_len))
+        jy = self.nnx_model(jnp.asarray(ids))
+        with torch.no_grad():
+            ty = self.torch_model(input_ids=torch.tensor(ids)).logits
+        self._assert_close(jy, ty, self.full_tol)
+
+    def test_full_batched(self):
+        ids = np.random.randint(
+            0, self.bonsai_config.vocab_size, size=(self.batch_size, self.seq_len)
+        )
+        jy = self.nnx_model(jnp.asarray(ids))
+        with torch.no_grad():
+            ty = self.torch_model(input_ids=torch.tensor(ids)).logits
+        self._assert_close(jy, ty, self.full_tol)
+
+
+if __name__ == "__main__":
+    absltest.main()