notebooks/Dense Neural Network on MNIST Digits.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import tensorflow as tf\n",
    "import tensorflow_datasets as tfds\n",
    "\n",
    "from flax import linen as nn"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```bash\n",
    "!pip install tensorflow tensorflow_datasets\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Neural Network on MNIST dataset\n",
    "\n",
    "Let's revisit the problem of recognizing handwritten digits from the MNIST dataset.  We'll make use of the data currated in `tensorflow_datasets`, which also has lots of convenient methods for splits data, batching, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_ds = tfds.load('mnist', split='train')\n",
    "test_ds = tfds.load('mnist', split='test')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<_PrefetchDataset element_spec={'image': TensorSpec(shape=(28, 28, 1), dtype=tf.uint8, name=None), 'label': TensorSpec(shape=(), dtype=tf.int64, name=None)}>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_ds"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These data objects are very efficient with lots convenient methods, but they are a little cumbersome to interact with for simple tasks like plotting an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(28, 28, 1)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-05-23 21:10:26.167818: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f = plt.figure(figsize=(15,3))\n",
    "\n",
    "for ex in train_ds.as_numpy_iterator():\n",
    "    print(ex['image'].shape)\n",
    "    plt.imshow(ex['image'], cmap='gray')\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "255\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-05-23 21:10:26.240652: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n"
     ]
    }
   ],
   "source": [
    "for example in train_ds.as_numpy_iterator():\n",
    "    print(example['image'].max())\n",
    "    break"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the pixel values imported as an integer array that saturates at $255$.  Let's turn the data into floats $\\in [0, 1]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_ds = train_ds.map(lambda sample: {'image': tf.cast(sample['image'],\n",
    "                                                        tf.float32) / 255.,\n",
    "                                        'label': sample['label']}) # normalize train set\n",
    "test_ds = test_ds.map(lambda sample: {'image': tf.cast(sample['image'],\n",
    "                                                        tf.float32) / 255.,\n",
    "                                    'label': sample['label']}) # normalize test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.random.set_seed(0) # ensure dataset shuffling"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're going to batch the data, and also choose random subsets.  We don't need to train on the whole set in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = 10\n",
    "batch_size = 32\n",
    "\n",
    "# shuffle data by allocating a buffer of 1024 to randomly draw examples from\n",
    "train_ds = train_ds.repeat(num_epochs).shuffle(1024)\n",
    "test_ds = test_ds.shuffle(1024)\n",
    "\n",
    "# group into batches of 32, skip incomplete batch, prefetch next sample to speed up\n",
    "train_ds = train_ds.batch(batch_size, drop_remainder=True).prefetch(1)\n",
    "test_ds = test_ds.batch(batch_size, drop_remainder=True).prefetch(1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's build a neural network.  Let's build a network with two hidden layers with 100 nodes each.  We'll use the *ReLU* activation function (see, e.g., [here](https://medium.com/@danqing/a-practical-guide-to-relu-b83ca804f1f7) for lots more details)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_classes = 10\n",
    "\n",
    "class DenseNN(nn.Module):\n",
    "  \"\"\"A simple model with densely connected layers.\"\"\"\n",
    "\n",
    "  @nn.compact\n",
    "  def __call__(self, x):\n",
    "    x = x.reshape((x.shape[0], -1))   # flatten\n",
    "    x = nn.Dense(features=100)(x)\n",
    "    x = nn.relu(x)\n",
    "    x = nn.Dense(features=100)(x)\n",
    "    x = nn.relu(x)\n",
    "    x = nn.Dense(features=n_classes)(x)\n",
    "    return x"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use `.tabulate()` to get a summary of the model.  Remember that we haven't specified the shape of `x` in the model above, meaning it doesn't actually know the date volume shapes (or number of parameters) unless we give it data with the right shape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[3m                                DenseNN Summary                                 \u001b[0m\n",
      "┏━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┓\n",
      "┃\u001b[1m \u001b[0m\u001b[1mpath   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mmodule \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1minputs            \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1moutputs       \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mparams            \u001b[0m\u001b[1m \u001b[0m┃\n",
      "┡━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━┩\n",
      "│         │ DenseNN │ \u001b[2mfloat32\u001b[0m[1,28,28,1] │ \u001b[2mfloat32\u001b[0m[1,10]  │                    │\n",
      "├─────────┼─────────┼────────────────────┼────────────────┼────────────────────┤\n",
      "│ Dense_0 │ Dense   │ \u001b[2mfloat32\u001b[0m[1,784]     │ \u001b[2mfloat32\u001b[0m[1,100] │ bias: \u001b[2mfloat32\u001b[0m[100] │\n",
      "│         │         │                    │                │ kernel:            │\n",
      "│         │         │                    │                │ \u001b[2mfloat32\u001b[0m[784,100]   │\n",
      "│         │         │                    │                │                    │\n",
      "│         │         │                    │                │ \u001b[1m78,500 \u001b[0m\u001b[1;2m(314.0 KB)\u001b[0m  │\n",
      "├─────────┼─────────┼────────────────────┼────────────────┼────────────────────┤\n",
      "│ Dense_1 │ Dense   │ \u001b[2mfloat32\u001b[0m[1,100]     │ \u001b[2mfloat32\u001b[0m[1,100] │ bias: \u001b[2mfloat32\u001b[0m[100] │\n",
      "│         │         │                    │                │ kernel:            │\n",
      "│         │         │                    │                │ \u001b[2mfloat32\u001b[0m[100,100]   │\n",
      "│         │         │                    │                │                    │\n",
      "│         │         │                    │                │ \u001b[1m10,100 \u001b[0m\u001b[1;2m(40.4 KB)\u001b[0m   │\n",
      "├─────────┼─────────┼────────────────────┼────────────────┼────────────────────┤\n",
      "│ Dense_2 │ Dense   │ \u001b[2mfloat32\u001b[0m[1,100]     │ \u001b[2mfloat32\u001b[0m[1,10]  │ bias: \u001b[2mfloat32\u001b[0m[10]  │\n",
      "│         │         │                    │                │ kernel:            │\n",
      "│         │         │                    │                │ \u001b[2mfloat32\u001b[0m[100,10]    │\n",
      "│         │         │                    │                │                    │\n",
      "│         │         │                    │                │ \u001b[1m1,010 \u001b[0m\u001b[1;2m(4.0 KB)\u001b[0m     │\n",
      "├─────────┼─────────┼────────────────────┼────────────────┼────────────────────┤\n",
      "│\u001b[1m \u001b[0m\u001b[1m       \u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m       \u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m                  \u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m         Total\u001b[0m\u001b[1m \u001b[0m│\u001b[1m \u001b[0m\u001b[1m89,610 \u001b[0m\u001b[1;2m(358.4 KB)\u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m│\n",
      "└─────────┴─────────┴────────────────────┴────────────────┴────────────────────┘\n",
      "\u001b[1m                                                                                \u001b[0m\n",
      "\u001b[1m                      Total Parameters: 89,610 \u001b[0m\u001b[1;2m(358.4 KB)\u001b[0m\u001b[1m                       \u001b[0m\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import jax\n",
    "import jax.numpy as jnp  # JAX NumPy\n",
    "\n",
    "dummy_input = jnp.ones((1, 28, 28, 1))\n",
    "\n",
    "dnn = DenseNN()\n",
    "print(dnn.tabulate(jax.random.PRNGKey(0), dummy_input))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to do a little legwork to setup some object for tracking training metrics (e.g., loss, accuracy).  We'll use the `clu` companion library to make our lives (a little) easier."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```bash\n",
    "!pip install clu\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from clu import metrics\n",
    "from flax.training import train_state\n",
    "from flax import struct\n",
    "import optax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "@struct.dataclass\n",
    "class Metrics(metrics.Collection):\n",
    "    accuracy: metrics.Accuracy\n",
    "    loss: metrics.Average.from_output('loss')\n",
    "\n",
    "class TrainState(train_state.TrainState):\n",
    "   metrics: Metrics"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we'll create a function that will initial our training state for us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_train_state(model, rng, learning_rate, momentum):\n",
    "    params = model.init(rng, dummy_input)['params']\n",
    "    tx = optax.sgd(learning_rate, momentum)\n",
    "    return TrainState.create(\n",
    "        apply_fn=model.apply, params=params, tx=tx,\n",
    "        metrics=Metrics.empty())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's define functions that will perform a training step (i.e., update parameters based on a batch of training data), and compute training metrics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "@jax.jit\n",
    "def train_step(state, batch):\n",
    "  \"\"\"Train for a single step.\"\"\"\n",
    "  def loss_fn(params):\n",
    "    logits = state.apply_fn({'params': params}, batch['image'])\n",
    "    loss = optax.softmax_cross_entropy_with_integer_labels(\n",
    "        logits=logits, labels=batch['label']).mean()\n",
    "    return loss\n",
    "  grad_fn = jax.grad(loss_fn)\n",
    "  grads = grad_fn(state.params)\n",
    "  state = state.apply_gradients(grads=grads)\n",
    "  return state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "@jax.jit\n",
    "def compute_metrics(*, state, batch):\n",
    "    logits = state.apply_fn({'params': state.params}, batch['image'])\n",
    "    loss = optax.softmax_cross_entropy_with_integer_labels(\n",
    "        logits=logits, labels=batch['label']).mean()\n",
    "    metric_updates = state.metrics.single_from_model_output(\n",
    "        logits=logits, labels=batch['label'], loss=loss)\n",
    "    metrics = state.metrics.merge(metric_updates)\n",
    "    state = state.replace(metrics=metrics)\n",
    "    return state"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a training state and prepare to train."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "init_rng = jax.random.PRNGKey(0)\n",
    "\n",
    "learning_rate = 0.01\n",
    "momentum = 0.9\n",
    "\n",
    "state = create_train_state(dnn, init_rng, learning_rate, momentum)\n",
    "del init_rng  # Must not be used anymore."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll track metrics along the way..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "metrics_history = {'train_loss': [],\n",
    "                   'train_accuracy': [],\n",
    "                   'test_loss': [],\n",
    "                   'test_accuracy': []}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18750"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_ds.cardinality().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1875"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# since train_ds is replicated num_epochs times in get_datasets(), we divide by num_epochs\n",
    "num_steps_per_epoch = train_ds.cardinality().numpy() // num_epochs\n",
    "num_steps_per_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train epoch: 1, loss: 0.2864380478858948, accuracy: 91.6066665649414\n",
      "test epoch: 1, loss: 0.1450791358947754, accuracy: 95.53285217285156\n",
      "train epoch: 2, loss: 0.11026730388402939, accuracy: 96.72000122070312\n",
      "test epoch: 2, loss: 0.10467476397752762, accuracy: 96.63461303710938\n",
      "train epoch: 3, loss: 0.07560433447360992, accuracy: 97.78500366210938\n",
      "test epoch: 3, loss: 0.09052639454603195, accuracy: 97.15544891357422\n",
      "train epoch: 4, loss: 0.056627608835697174, accuracy: 98.33499908447266\n",
      "test epoch: 4, loss: 0.08805624395608902, accuracy: 97.29566955566406\n",
      "train epoch: 5, loss: 0.04632475972175598, accuracy: 98.6433334350586\n",
      "test epoch: 5, loss: 0.07748545706272125, accuracy: 97.59615325927734\n",
      "train epoch: 6, loss: 0.03552898392081261, accuracy: 99.01000213623047\n",
      "test epoch: 6, loss: 0.07611264288425446, accuracy: 97.73637390136719\n",
      "train epoch: 7, loss: 0.028327208012342453, accuracy: 99.23333740234375\n",
      "test epoch: 7, loss: 0.0742904469370842, accuracy: 97.69631958007812\n",
      "train epoch: 8, loss: 0.02313474752008915, accuracy: 99.3499984741211\n",
      "test epoch: 8, loss: 0.08198921382427216, accuracy: 97.54607391357422\n",
      "train epoch: 9, loss: 0.017406746745109558, accuracy: 99.59833526611328\n",
      "test epoch: 9, loss: 0.07684765011072159, accuracy: 97.78645324707031\n",
      "train epoch: 10, loss: 0.014834782108664513, accuracy: 99.65833282470703\n",
      "test epoch: 10, loss: 0.07781097292900085, accuracy: 97.78645324707031\n"
     ]
    }
   ],
   "source": [
    "for step,batch in enumerate(train_ds.as_numpy_iterator()):\n",
    "  # Run optimization steps over training batches and compute batch metrics\n",
    "  state = train_step(state, batch) # get updated train state (which contains the updated parameters)\n",
    "  state = compute_metrics(state=state, batch=batch) # aggregate batch metrics\n",
    "\n",
    "  if (step+1) % num_steps_per_epoch == 0: # one training epoch has passed\n",
    "    for metric,value in state.metrics.compute().items(): # compute metrics\n",
    "      metrics_history[f'train_{metric}'].append(value) # record metrics\n",
    "    state = state.replace(metrics=state.metrics.empty()) # reset train_metrics for next training epoch\n",
    "\n",
    "    # Compute metrics on the test set after each training epoch\n",
    "    test_state = state\n",
    "    for test_batch in test_ds.as_numpy_iterator():\n",
    "      test_state = compute_metrics(state=test_state, batch=test_batch)\n",
    "\n",
    "    for metric,value in test_state.metrics.compute().items():\n",
    "      metrics_history[f'test_{metric}'].append(value)\n",
    "\n",
    "    print(f\"train epoch: {(step+1) // num_steps_per_epoch}, \"\n",
    "          f\"loss: {metrics_history['train_loss'][-1]}, \"\n",
    "          f\"accuracy: {metrics_history['train_accuracy'][-1] * 100}\")\n",
    "    print(f\"test epoch: {(step+1) // num_steps_per_epoch}, \"\n",
    "          f\"loss: {metrics_history['test_loss'][-1]}, \"\n",
    "          f\"accuracy: {metrics_history['test_accuracy'][-1] * 100}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot loss and accuracy in subplots\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))\n",
    "ax1.set_title('Loss')\n",
    "ax2.set_title('Accuracy')\n",
    "for dataset in ('train','test'):\n",
    "  ax1.plot(metrics_history[f'{dataset}_loss'], label=f'{dataset}_loss')\n",
    "  ax2.plot(metrics_history[f'{dataset}_accuracy'], label=f'{dataset}_accuracy')\n",
    "ax1.legend()\n",
    "ax2.legend()\n",
    "plt.show()\n",
    "plt.clf()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how are model does at predicting specific examples from the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "@jax.jit\n",
    "def pred_step(state, batch):\n",
    "  logits = state.apply_fn({'params': state.params}, batch['image'])\n",
    "  return logits.argmax(axis=1)\n",
    "\n",
    "test_batch = test_ds.as_numpy_iterator().next()\n",
    "pred = pred_step(state, test_batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x1200 with 25 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(5, 5, figsize=(12, 12))\n",
    "for i, ax in enumerate(axs.flatten()):\n",
    "    ax.imshow(test_batch['image'][i, ..., 0], cmap='gray')\n",
    "    ax.set_title(f\"label={pred[i]}\")\n",
    "    ax.axis('off')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we manipulate the data a bit.  Is it easily confused?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_test_ds = test_ds.map(lambda sample: {'image': tf.roll(sample['image'], 3, 2),\n",
    "                                          'label': sample['label']})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<_MapDataset element_spec={'image': TensorSpec(shape=(32, 28, 28, 1), dtype=tf.float32, name=None), 'label': TensorSpec(shape=(32,), dtype=tf.int64, name=None)}>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_test_ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_test_batch = new_test_ds.as_numpy_iterator().next()\n",
    "new_pred = pred_step(state, new_test_batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x1200 with 25 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(5, 5, figsize=(12, 12))\n",
    "for i, ax in enumerate(axs.flatten()):\n",
    "    ax.imshow(new_test_batch['image'][i, ..., 0], cmap='gray')\n",
    "    ax.set_title(f\"label={new_pred[i]}\")\n",
    "    ax.axis('off')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}