From a2a21ea0e1dd4a6e3f481fe834bdd91e6fb2317e Mon Sep 17 00:00:00 2001
From: rajasekharporeddy <rajasekharp@google.com>
Date: Fri, 19 Jun 2026 17:57:51 +0530
Subject: [PATCH] Migrate to flax.nnx from flax.linen in nanolm example

---
 examples/nanolm.ipynb | 308 +++++++++++++++++++++++-------------------
 1 file changed, 167 insertions(+), 141 deletions(-)

diff --git a/examples/nanolm.ipynb b/examples/nanolm.ipynb
index d5aaed29f..a21e51a28 100644
--- a/examples/nanolm.ipynb
+++ b/examples/nanolm.ipynb
@@ -23,7 +23,7 @@
         "\n",
         "* **JAX:** Provides the foundation for numerical computations and automatic differentiation.\n",
         "* **Tensorflow Datasets (`tfds`)** Offers easy access to the Tiny Shakespeare dataset.\n",
-        "* **Flax's Linen Module:** Provides building blocks for defining our neural network architecture.\n",
+        "* **Flax's NNX Module:** Provides the stateful building blocks for defining our neural network architecture.\n",
         "* **Optax:** Contains a library of optimization algorithms for training the model's parameters. In this example we'll use the {py:func}`optax.adamw` solver."
       ]
     },
@@ -35,7 +35,7 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "jIabArrRWFw0",
-        "outputId": "75c89cb3-35ca-4217-a8e0-4b45f9efe31f"
+        "outputId": "38e91b04-0724-4670-dfc3-cc63d121d842"
       },
       "outputs": [
         {
@@ -49,7 +49,7 @@
       "source": [
         "import functools\n",
         "\n",
-        "import flax.linen as nn\n",
+        "from flax import nnx\n",
         "import jax\n",
         "import jax.numpy as jnp\n",
         "from matplotlib import pyplot as plt\n",
@@ -135,7 +135,7 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "USiJ0GjWSPu_",
-        "outputId": "bd033bb3-1c6a-4dc4-a1e3-b38a04dd43c0"
+        "outputId": "2bfcae43-5903-4b53-ef71-8e03948fa2d4"
       },
       "outputs": [
         {
@@ -160,7 +160,7 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "wOq-djQ9cueI",
-        "outputId": "8d639dad-b1df-4536-8f74-bed86a869201"
+        "outputId": "2808571d-7b44-474a-849a-ed431267da3c"
       },
       "outputs": [
         {
@@ -239,7 +239,7 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "rESkNoDXFE-4",
-        "outputId": "42579042-716c-4101-cf08-14ebefa6c984"
+        "outputId": "6aec86a5-3255-4809-b0e3-b39736f79a66"
       },
       "outputs": [
         {
@@ -320,13 +320,13 @@
       "source": [
         "# NanoLM Model Definition\n",
         "\n",
-        "The NanoLM model itself is defined as a Flax Linen module.  The core of the model is a Transformer architecture, designed for sequence-to-sequence tasks like language modeling. Key parameters of the model, such as the number of layers, attention heads, and embedding size, are specified here.\n",
+        "The NanoLM model itself is defined as a Flax NNX module. The core of the model is a Transformer architecture, designed for sequence-to-sequence tasks like language modeling. Key parameters of the model, such as the number of layers, attention heads, and embedding size, are specified here.\n",
         "\n",
         "Inside the model's `__call__` method, we first embed our input characters into vector representations. Positional embeddings are added to provide the model with a sense of order in the sequence. The core of the Transformer consists of multiple layers. Each layer has two main components:\n",
         "\n",
-        " * **Multi-Head Attention**: This mechanism allows the model to \"attend\" to different parts of the input sequence, improving its understanding of context and relationships within the text. In the code this is implemented through the {py:class}`flax.linen.MultiHeadDotProductAttention` class.\n",
+        " * **Multi-Head Attention**: This mechanism allows the model to \"attend\" to different parts of the input sequence, improving its understanding of context and relationships within the text. In the code this is implemented through the {py:class}`flax.nnx.MultiHeadAttention` class.\n",
         "\n",
-        " * **Feedforward Network**: This network processes the output of the attention layer, applying non-linear transformations to further learn complex patterns in the data. This is implemented through the {py:class}`flax.linen.Sequential` class.\n",
+        " * **Feedforward Network**: This network processes the output of the attention layer, applying non-linear transformations to further learn complex patterns in the data.\n",
         "\n",
         "Normalization and dropout (for regularization) are used within the layers to improve training stability.  Finally, a dense layer maps the model's output to the vocabulary size, producing probabilities for each character as the next potential character.\n",
         "\n",
@@ -341,52 +341,78 @@
       },
       "outputs": [],
       "source": [
-        "class NanoLM(nn.Module):\n",
-        "  \"\"\"NanoLM model.\"\"\"\n",
-        "  vocab_size: int\n",
-        "  num_layers: int = 6\n",
-        "  num_heads: int = 8\n",
-        "  head_size: int = 32\n",
-        "  dropout_rate: float = 0.2\n",
-        "  embed_size: int = 256\n",
-        "  block_size: int = 64\n",
-        "\n",
-        "  @nn.compact\n",
-        "  def __call__(self, x, training: bool):\n",
+        "class NanoLM(nnx.Module):\n",
+        "  \"\"\"NanoLM model using flax.nnx.\"\"\"\n",
+        "  def __init__(\n",
+        "      self,\n",
+        "      vocab_size: int,\n",
+        "      num_layers: int = 6,\n",
+        "      num_heads: int = 8,\n",
+        "      head_size: int = 32,\n",
+        "      dropout_rate: float = 0.2,\n",
+        "      embed_size: int = 256,\n",
+        "      block_size: int = 64,\n",
+        "      rngs: nnx.Rngs = None\n",
+        "  ):\n",
+        "    self.vocab_size = vocab_size\n",
+        "    self.block_size = block_size\n",
+        "    self.embed_size = embed_size\n",
+        "\n",
+        "    self.embed = nnx.Embed(vocab_size, embed_size, rngs=rngs)\n",
+        "    self.pos_embed = nnx.Embed(block_size, embed_size, rngs=rngs)\n",
+        "\n",
+        "    self.layers = []\n",
+        "    for _ in range(num_layers):\n",
+        "      self.layers.append({\n",
+        "          'ln_1': nnx.LayerNorm(embed_size, rngs=rngs),\n",
+        "          'attn': nnx.MultiHeadAttention(\n",
+        "              num_heads=num_heads,\n",
+        "              in_features=embed_size,\n",
+        "              qkv_features=head_size,\n",
+        "              out_features=head_size * num_heads,\n",
+        "              dropout_rate=dropout_rate,\n",
+        "              decode=False,\n",
+        "              rngs=rngs\n",
+        "          ),\n",
+        "          'ln_2': nnx.LayerNorm(embed_size, rngs=rngs),\n",
+        "          'mlp_fc': nnx.Linear(embed_size, 4 * embed_size, rngs=rngs),\n",
+        "          'mlp_dropout': nnx.Dropout(dropout_rate, rngs=rngs),\n",
+        "          'mlp_proj': nnx.Linear(4 * embed_size, embed_size, rngs=rngs),\n",
+        "      })\n",
+        "    self.ln_f = nnx.LayerNorm(embed_size, rngs=rngs)\n",
+        "    self.head = nnx.Linear(embed_size, vocab_size, rngs=rngs)\n",
+        "\n",
+        "  def __call__(self, x, deterministic: bool = False):\n",
         "    seq_len = x.shape[1]\n",
+        "    x = self.embed(x) + self.pos_embed(jnp.arange(seq_len))\n",
+        "    mask = jnp.tril(jnp.ones((x.shape[-2], x.shape[-2])))\n",
         "\n",
-        "    x = nn.Embed(self.vocab_size, self.embed_size)(x) + nn.Embed(\n",
-        "        self.block_size, self.embed_size\n",
-        "    )(jnp.arange(seq_len))\n",
-        "    for _ in range(self.num_layers):\n",
-        "      x_norm = nn.LayerNorm()(x)\n",
-        "      x = x + nn.MultiHeadDotProductAttention(\n",
-        "          num_heads=self.num_heads,\n",
-        "          qkv_features=self.head_size,\n",
-        "          out_features=self.head_size * self.num_heads,\n",
-        "          dropout_rate=self.dropout_rate,\n",
-        "      )(\n",
+        "    for layer in self.layers:\n",
+        "      x_norm = layer['ln_1'](x)\n",
+        "      attn_out = layer['attn'](\n",
         "          x_norm,\n",
         "          x_norm,\n",
-        "          mask=jnp.tril(jnp.ones((x.shape[-2], x.shape[-2]))),\n",
-        "          deterministic=not training,\n",
+        "          x_norm,\n",
+        "          mask=mask,\n",
+        "          deterministic=deterministic\n",
         "      )\n",
+        "      x = x + attn_out\n",
         "\n",
-        "      x = x + nn.Sequential([\n",
-        "          nn.Dense(4 * self.embed_size),\n",
-        "          nn.relu,\n",
-        "          nn.Dropout(self.dropout_rate, deterministic=not training),\n",
-        "          nn.Dense(self.embed_size),\n",
-        "      ])(nn.LayerNorm()(x))\n",
+        "      x_mlp = layer['ln_2'](x)\n",
+        "      x_mlp = layer['mlp_fc'](x_mlp)\n",
+        "      x_mlp = jax.nn.relu(x_mlp)\n",
+        "      x_mlp = layer['mlp_dropout'](x_mlp, deterministic=deterministic)\n",
+        "      x_mlp = layer['mlp_proj'](x_mlp)\n",
+        "      x = x + x_mlp\n",
         "\n",
-        "    x = nn.LayerNorm()(x)\n",
-        "    return nn.Dense(self.vocab_size)(x)\n",
+        "    x = self.ln_f(x)\n",
+        "    return self.head(x)\n",
         "\n",
-        "  @functools.partial(jax.jit, static_argnames=(\"self\", \"length\"))\n",
-        "  def generate(self, rng, params, length):\n",
+        "  @functools.partial(nnx.jit, static_argnames=(\"length\"))\n",
+        "  def generate(self, rng, length):\n",
         "    def _scan_generate(carry, _):\n",
         "      random_key, context = carry\n",
-        "      logits = self.apply(params, context, training=False)\n",
+        "      logits = self(context, deterministic=True)\n",
         "      rng, rng_subkey = jax.random.split(random_key)\n",
         "      new_token = jax.random.categorical(\n",
         "          rng_subkey, logits[:, -1, :], axis=-1, shape=(1, 1)\n",
@@ -432,59 +458,53 @@
         "    dropout_rate=DROPOUT_RATE,\n",
         "    embed_size=EMBED_SIZE,\n",
         "    block_size=BLOCK_SIZE,\n",
+        "    rngs=nnx.Rngs(SEED),\n",
         ")\n",
         "\n",
-        "def loss_fun(params, x, y, dropout_key):\n",
-        "  logits = model.apply(params, x, training=True, rngs={\"dropout\": dropout_key})\n",
+        "def loss_fun(model, x, y):\n",
+        "  logits = model(x, deterministic=False)\n",
         "  return optax.softmax_cross_entropy_with_integer_labels(\n",
         "      logits=logits, labels=y\n",
         "  ).mean()\n",
         "\n",
-        "\n",
-        "@jax.jit\n",
-        "def eval_step(params, x, y):\n",
-        "  logits = model.apply(params, x, training=False)\n",
+        "@nnx.jit\n",
+        "def eval_step(model, x, y):\n",
+        "  logits = model(x, deterministic=True)\n",
         "  return optax.softmax_cross_entropy_with_integer_labels(\n",
         "      logits=logits, labels=y\n",
-        "  ).mean()"
+        "  ).mean()\n"
       ]
     },
     {
-      "cell_type": "code",
-      "execution_count": null,
+      "cell_type": "markdown",
       "metadata": {
-        "id": "ejU1Yt8XIH80"
+        "id": "kgSjWONs4eFp"
       },
-      "outputs": [],
       "source": [
-        "key = jax.random.PRNGKey(SEED)\n",
-        "key, subkey = jax.random.split(key)\n",
-        "\n",
-        "var_params = model.init(\n",
-        "    key,\n",
-        "    jnp.ones((BATCH_SIZE, BLOCK_SIZE), dtype=jnp.int32),\n",
-        "    training=False,\n",
-        ")"
+        "We've now instantiated a NanoLM model with the following number of parameters"
       ]
     },
     {
-      "cell_type": "markdown",
+      "cell_type": "code",
+      "execution_count": null,
       "metadata": {
-        "id": "kgSjWONs4eFp"
+        "id": "xkv_yY2wWmpg"
       },
+      "outputs": [],
       "source": [
-        "We've now instantiated a NanoLM model with the following number of parameters"
+        "key = jax.random.PRNGKey(SEED)\n",
+        "key, subkey = jax.random.split(key)"
       ]
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 12,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
         },
         "id": "9Ckqdkd6QVsl",
-        "outputId": "2c202753-b938-4148-992c-cc63077be607"
+        "outputId": "83c9df2c-56da-4523-e2b4-8a2d0e5c40fc"
       },
       "outputs": [
         {
@@ -496,9 +516,10 @@
         }
       ],
       "source": [
-        "n_params = optax.tree.size(var_params)\n",
+        "# n_params = sum(x.size for x in jax.tree_util.tree_leaves(nnx.state(model, nnx.Param)))\n",
+        "n_params = optax.tree.size(nnx.state(model, nnx.Param))\n",
         "\n",
-        "print(f\"Total number of parameters: {n_params:_}\")"
+        "print(f\"Total number of parameters: {n_params:_}\")\n"
       ]
     },
     {
@@ -528,7 +549,8 @@
         "# To run with SGD instead of adam, replace `adam` with `sgd`\n",
         "opt = optax.adamw(learning_rate=LEARNING_RATE)\n",
         "\n",
-        "opt_state = opt.init(var_params)"
+        "# We wrap our model and optax optimizer in an nnx.Optimizer\n",
+        "optimizer = nnx.Optimizer(model, opt, wrt=nnx.Param)\n"
       ]
     },
     {
@@ -539,40 +561,40 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "DhnK0G7AQUCA",
-        "outputId": "37b5a3bd-c0bc-47c2-a828-62356ab4cbe5"
+        "outputId": "3d4c9d22-b50e-4c03-b315-e43fd8aec04d"
       },
       "outputs": [
         {
           "name": "stdout",
           "output_type": "stream",
           "text": [
-            "Step: 0\t train loss: 4.586461067199707\t eval loss: 6.037547588348389\n",
-            "Step: 2000\t train loss: 1.3876519203186035\t eval loss: 1.4252502918243408\n",
-            "Step: 4000\t train loss: 1.280821442604065\t eval loss: 1.4000993967056274\n",
-            "Step: 6000\t train loss: 1.1978516578674316\t eval loss: 1.4045076370239258\n",
-            "Step: 8000\t train loss: 1.177159070968628\t eval loss: 1.387284278869629\n",
-            "Step: 10000\t train loss: 1.1472305059432983\t eval loss: 1.423332929611206\n",
-            "Step: 12000\t train loss: 1.107376217842102\t eval loss: 1.4390857219696045\n",
-            "Step: 14000\t train loss: 1.096900224685669\t eval loss: 1.474606990814209\n",
-            "Step: 16000\t train loss: 1.0772775411605835\t eval loss: 1.4595460891723633\n",
-            "Step: 18000\t train loss: 1.050074577331543\t eval loss: 1.4540534019470215\n",
-            "Step: 20000\t train loss: 1.0540519952774048\t eval loss: 1.4794009923934937\n",
-            "Step: 22000\t train loss: 1.035787582397461\t eval loss: 1.5094046592712402\n",
-            "Step: 24000\t train loss: 1.0402700901031494\t eval loss: 1.5403311252593994\n",
-            "Step: 26000\t train loss: 1.0363699197769165\t eval loss: 1.5168808698654175\n",
-            "Step: 28000\t train loss: 1.0000224113464355\t eval loss: 1.5624736547470093\n",
-            "Step: 30000\t train loss: 0.9905486106872559\t eval loss: 1.5720288753509521\n",
-            "Step: 32000\t train loss: 0.9986284971237183\t eval loss: 1.526949167251587\n",
-            "Step: 34000\t train loss: 0.9822986125946045\t eval loss: 1.5732147693634033\n",
-            "Step: 36000\t train loss: 0.9837050437927246\t eval loss: 1.6341228485107422\n",
-            "Step: 38000\t train loss: 0.9723658561706543\t eval loss: 1.542256474494934\n",
-            "Step: 40000\t train loss: 0.9632444977760315\t eval loss: 1.5658419132232666\n",
-            "Step: 42000\t train loss: 0.9664344787597656\t eval loss: 1.6112396717071533\n",
-            "Step: 44000\t train loss: 0.9476494789123535\t eval loss: 1.6128767728805542\n",
-            "Step: 46000\t train loss: 0.9473679065704346\t eval loss: 1.5689520835876465\n",
-            "Step: 48000\t train loss: 0.9642226696014404\t eval loss: 1.5935924053192139\n",
-            "CPU times: user 15min 19s, sys: 9min 8s, total: 24min 27s\n",
-            "Wall time: 22min 48s\n"
+            "Step: 0\t train loss: 4.555290222167969\t eval loss: 4.928314208984375\n",
+            "Step: 2000\t train loss: 1.8774622678756714\t eval loss: 1.7867512702941895\n",
+            "Step: 4000\t train loss: 2.3806538581848145\t eval loss: 2.3035120964050293\n",
+            "Step: 6000\t train loss: 2.7068772315979004\t eval loss: 2.6170852184295654\n",
+            "Step: 8000\t train loss: 2.7696011066436768\t eval loss: 2.640242099761963\n",
+            "Step: 10000\t train loss: 2.6572699546813965\t eval loss: 2.591479778289795\n",
+            "Step: 12000\t train loss: 2.653681755065918\t eval loss: 2.5746965408325195\n",
+            "Step: 14000\t train loss: 2.6575136184692383\t eval loss: 2.572330951690674\n",
+            "Step: 16000\t train loss: 2.728987216949463\t eval loss: 2.628945827484131\n",
+            "Step: 18000\t train loss: 2.6603927612304688\t eval loss: 2.5857508182525635\n",
+            "Step: 20000\t train loss: 2.687011241912842\t eval loss: 2.5574960708618164\n",
+            "Step: 22000\t train loss: 2.6137094497680664\t eval loss: 2.508765459060669\n",
+            "Step: 24000\t train loss: 2.705624580383301\t eval loss: 2.556414842605591\n",
+            "Step: 26000\t train loss: 2.6434638500213623\t eval loss: 2.554474353790283\n",
+            "Step: 28000\t train loss: 2.657954692840576\t eval loss: 2.544748544692993\n",
+            "Step: 30000\t train loss: 2.646601438522339\t eval loss: 2.522773027420044\n",
+            "Step: 32000\t train loss: 2.626753568649292\t eval loss: 2.530001163482666\n",
+            "Step: 34000\t train loss: 2.622190237045288\t eval loss: 2.500441074371338\n",
+            "Step: 36000\t train loss: 2.628270149230957\t eval loss: 2.5297322273254395\n",
+            "Step: 38000\t train loss: 2.6133530139923096\t eval loss: 2.5379815101623535\n",
+            "Step: 40000\t train loss: 2.5884222984313965\t eval loss: 2.522336006164551\n",
+            "Step: 42000\t train loss: 2.5989084243774414\t eval loss: 2.536512851715088\n",
+            "Step: 44000\t train loss: 2.608403205871582\t eval loss: 2.530027389526367\n",
+            "Step: 46000\t train loss: 2.594978094100952\t eval loss: 2.480726480484009\n",
+            "Step: 48000\t train loss: 2.645200729370117\t eval loss: 2.5240464210510254\n",
+            "CPU times: user 18min 37s, sys: 5.4 s, total: 18min 43s\n",
+            "Wall time: 17min 33s\n"
           ]
         }
       ],
@@ -582,25 +604,23 @@
         "all_train_losses = []\n",
         "all_eval_losses = []\n",
         "\n",
-        "# we define one iteration of the optimizer and JIT this function\n",
-        "@jax.jit\n",
-        "def step(key, params, opt_state):\n",
+        "# we define one iteration of the optimizer and JIT this function using nnx.jit\n",
+        "@nnx.jit\n",
+        "def step(model, optimizer, key):\n",
         "  key, subkey = jax.random.split(key)\n",
         "  batch = get_batch(key, train_data)\n",
-        "  loss, grad = jax.value_and_grad(loss_fun)(params, *batch, subkey)\n",
-        "  updates, opt_state = opt.update(grad, opt_state, params)\n",
-        "  params = optax.apply_updates(params, updates)\n",
-        "  return params, key, opt_state, loss\n",
-        "\n",
+        "  loss, grad = nnx.value_and_grad(loss_fun)(model, *batch)\n",
+        "  optimizer.update(model, grad)\n",
+        "  return key, loss\n",
         "\n",
         "for i in range(N_ITERATIONS):\n",
-        "  var_params, key, opt_state, loss = step(key, var_params, opt_state)\n",
+        "  key, loss = step(model, optimizer, key)\n",
         "  all_train_losses.append(loss)\n",
         "\n",
         "  # once every N_FREQ_EVAL we compute loss on the validation set\n",
         "  if i % N_FREQ_EVAL == 0:\n",
         "    key, subkey = jax.random.split(key)\n",
-        "    eval_loss = eval_step(var_params, *get_batch(subkey, eval_data))\n",
+        "    eval_loss = eval_step(model, *get_batch(subkey, eval_data))\n",
         "    all_eval_losses.append(eval_loss)\n",
         "    print(f\"Step: {i}\\t train loss: {loss}\\t eval loss: {eval_loss}\")"
       ]
@@ -614,12 +634,12 @@
           "height": 472
         },
         "id": "Gc-V4kAKAA9q",
-        "outputId": "68b59bf2-9621-4c2e-e0e0-be665d19630e"
+        "outputId": "3ac72937-f89b-4a3d-a7cc-7c8896155c1a"
       },
       "outputs": [
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 640x480 with 1 Axes>"
             ]
@@ -663,52 +683,58 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "6AejKtZnFmhK",
-        "outputId": "78e7b13f-28ff-4786-e206-bcd104e3c507"
+        "outputId": "0f67702f-263c-4920-fc10-46b4b482e20f"
       },
       "outputs": [
         {
           "name": "stdout",
           "output_type": "stream",
           "text": [
-            "GREMIO:\n",
-            "So called, officer:\n",
-            "Peace, for me would be a mighty heart, and I'll do\n",
-            "any good.\n",
+            "HotSove ir ueshouinoth! ammeerisbeat,\n",
+            "Mbrd myer, y'sspe arey teth men sov witmay:\n",
+            "Bulf t busong tou, peirellan tis w Rive ache hin cl ale w e?\n",
+            "ARTESthatheve tsin f I:\n",
+            "HL d le imak ll me ha wak stulisiciougnor-UCUTicinderd Dissthyourat-- s n Horss ugr hitous ion he mecle SThar hinco avad; ildyonghitatrasile wauthe h te.\n",
+            "RIn ador, thiroveath ystis me henthaio!\n",
+            "SIs hin as hepomyore hour, ckard st crercarizr the t.\n",
+            "SInone ay f I torus wheltterd hotheafr wombldd, horyolumy waine\n",
+            "A-nbis,-mend ve golle,\n",
+            "HAN:\n",
+            "HO ar heakldenoromastenelisthe te t nol ar cecte' me cckowit,\n",
+            "Poas; nce o ous pl:\n",
+            "LILIssatheyongearence my mpo sitorin'd\n",
             "\n",
-            "MERCUTIO:\n",
-            "Ay, look'd dead made.\n",
+            "HSOINLAN:\n",
+            "Brersicen f t mare weee af lf theof Chizatrg whaspininoout woret oulwn th oumeng\n",
             "\n",
-            "VALERIA:\n",
-            "Rather is in the present book of love\n",
-            "Than piece thy thoughts to shame, but yet book known\n",
-            "Where my Edward, whom I so could do it to him;\n",
-            "And see how the government of your blood,\n",
-            "Congeal'd your kingdom then we resign your highness;\n",
-            "Unless you scarcely know how I came, his wife;\n",
-            "And I may contain a little of England's heart\n",
-            "After a king of disdain! supect, tribunes,\n",
-            "The sun under thine is too large:\n",
-            "The senators do add to their trenches stretch'd,\n",
-            "With such as a toy, or be it known, I would\n",
-            "See my shame home, sweet friends, we are too dear:\n",
-            "Tell me consul, what's become the soldiers?\n",
+            "WOse gimoss:\n",
+            "W:\n",
+            "I CIUDItitothindsthyoo y a?\n",
+            "NIS:\n",
+            "ARINDis dioond, hin wiooronoughigery id arkom n,\n",
+            "An paninge id womanomy coucab it m, bsut bu ner pot mensorad withaf!an thingot prn be: s fold f nssit;\n",
+            "Thounur.\n",
+            "San fot s my mimund an s t must hay.\n",
             "\n",
-            "SOMERSET:\n",
-            "So fled; alas! much is possess'd by this means?\n",
-            "Away with the nightingale. He hast he wounded his sceptre\n",
-            "And hide his heir: go hence, to have his hearts\n",
-            "To close our bloods, for the climate to be\n",
-            "Ere one would be so often been seen, a greater stranger\n",
-            "Can have you \n"
+            "Cougon, IMImy h hacin g u, cik \n"
           ]
         }
       ],
       "source": [
         "# Let's now generate some text\n",
         "key, subkey = jax.random.split(key)\n",
-        "text = model.generate(key, var_params, 1000)[:, 0, 0].tolist()\n",
+        "text = model.generate(key, 1000)[:, 0, 0].tolist()\n",
         "print(decode(text))"
       ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "id": "9uXwdzWBgkjf"
+      },
+      "outputs": [],
+      "source": []
     }
   ],
   "metadata": {