diff --git a/examples/super_convergence/super_convergence.ipynb b/examples/super_convergence/super_convergence.ipynb
new file mode 100644
index 0000000..eb4bb03
--- /dev/null
+++ b/examples/super_convergence/super_convergence.ipynb
@@ -0,0 +1,2065 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vdYsiFP6jjPY"
+   },
+   "source": [
+    "# Super Convergence\n",
+    "Reference Papers\n",
+    "1. [Super-Convergence: Very Fast Training of Neural Networks Using Large Learning Rates](https://arxiv.org/abs/1708.07120)\n",
+    "2. [Cyclical Learning Rates for Training Neural Networks](https://arxiv.org/abs/1506.01186)\n",
+    "\n",
+    "Blogs\n",
+    "1. [Finding Good Learning Rate and The One Cycle Policy.](https://towardsdatascience.com/finding-good-learning-rate-and-the-one-cycle-policy-7159fe1db5d6)\n",
+    "2. [The Learning Rate Finder Technique: How Reliable Is It?](https://blog.dataiku.com/the-learning-rate-finder-technique-how-reliable-is-it)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "id": "k7tqeeGB6peL"
+   },
+   "outputs": [],
+   "source": [
+    "import objax\n",
+    "from objax.nn import Conv2D\n",
+    "from time import time\n",
+    "import jax.numpy as jn\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from objax.util import EasyDict\n",
+    "import os\n",
+    "import tensorflow_datasets as tfds\n",
+    "from tqdm.notebook import tqdm\n",
+    "from tqdm import trange\n",
+    "import math\n",
+    "from copy import deepcopy\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 222,
+     "referenced_widgets": [
+      "e7b07465fa61490dbb41545aac4fa9b4",
+      "1096b35a43204819b793ae71ca903009",
+      "80beed2bab07454eaf0eb26399ea19b9",
+      "559a266f43484b378a1fe4783178274b",
+      "ef01d022b37b4806bbbc05f5c2bade19",
+      "7b3f8d1c9ab944c69c0146a0951a8807",
+      "36a97e7e6f934026817e68b6daab5e8b",
+      "3d1b718eec564ac6866d732e93c52362"
+     ]
+    },
+    "id": "le17weRd81kv",
+    "outputId": "610f91ce-ab0e-4a73-8260-871f3def5a19"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:absl:Dataset mnist is hosted on GCS. It will automatically be downloaded to your\n",
+      "local data directory. If you'd instead prefer to read directly from our public\n",
+      "GCS bucket (recommended if you're running on GCP), you can instead set\n",
+      "data_dir=gs://tfds-data/datasets.\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1mDownloading and preparing dataset mnist/3.0.0 (download: 11.06 MiB, generated: Unknown size, total: 11.06 MiB) to /root/TFDS/mnist/3.0.0...\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e7b07465fa61490dbb41545aac4fa9b4",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(FloatProgress(value=0.0, description='Dl Completed...', max=4.0, style=ProgressStyle(descriptio…"
+      ]
+     },
+     "metadata": {
+      "tags": []
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1mDataset mnist downloaded and prepared to /root/TFDS/mnist/3.0.0. Subsequent calls will reuse this data.\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "DATA_DIR = os.path.join(os.environ['HOME'], 'TFDS')\n",
+    "data = tfds.as_numpy(tfds.load(name='mnist', batch_size=-1, data_dir=DATA_DIR))\n",
+    "train = EasyDict(image=data['train']['image'].transpose(0, 3, 1, 2) / 255, label=data['train']['label'])\n",
+    "test = EasyDict(image=data['test']['image'].transpose(0, 3, 1, 2) / 255, label=data['test']['label'])\n",
+    "del data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "id": "xs2WTHVn_2-K"
+   },
+   "outputs": [],
+   "source": [
+    "# Image Augmentation\n",
+    "def augment(x, shift=4):  # Shift all images in the batch by up to \"shift\" pixels in any direction.\n",
+    "    x_pad = np.pad(x, [[0, 0], [0, 0], [shift, shift], [shift, shift]])\n",
+    "    rx, ry = np.random.randint(0, shift, size=2)\n",
+    "    return x_pad[:, :, rx:rx + 28, ry:ry + 28]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "id": "H-E-Tw1oA-LF"
+   },
+   "outputs": [],
+   "source": [
+    "def acc_loss_plot(loss, accuracy):\n",
+    "    fig, a =  plt.subplots(2, figsize=(10, 10))\n",
+    "    epochs = range(len(loss))\n",
+    "    a[0].plot(epochs, loss)\n",
+    "    a[0].set_ylabel(\"loss\")\n",
+    "    a[0].set_xlabel(\"epochs\")\n",
+    "    a[1].plot(epochs, accuracy)\n",
+    "    a[1].set_ylabel(\"accuracy\")\n",
+    "    a[1].set_xlabel(\"epochs\")\n",
+    "    plt.show()\n",
+    "\n",
+    "def lr_plot(learning_rates, losses):\n",
+    "    plt.ylabel(\"loss\")\n",
+    "    plt.xlabel(\"learning rate\")\n",
+    "    plt.xscale(\"log\")\n",
+    "    plt.plot(learning_rates, losses)\n",
+    "\n",
+    "def lr_mom_plot(learning_rates, momentums):\n",
+    "    fig, a = plt.subplots(1, 2, figsize=(10,3))\n",
+    "    a[0].set_title(\"Learning Rate\")\n",
+    "    a[0].set_xlabel('iterations')\n",
+    "    a[0].set_ylabel('lr')\n",
+    "    a[0].plot(learning_rates)\n",
+    "    a[1].set_title(\"Momentum\")\n",
+    "    a[1].set_xlabel('iterations')\n",
+    "    a[1].set_ylabel('momentum')\n",
+    "    a[1].plot(momentums)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "id": "UL10j4Me88c5"
+   },
+   "outputs": [],
+   "source": [
+    "def simple_net_block(nin, nout):\n",
+    "    return objax.nn.Sequential([\n",
+    "        objax.nn.Conv2D(nin, nout, k=3), objax.functional.leaky_relu,\n",
+    "        objax.functional.max_pool_2d,\n",
+    "        objax.nn.Conv2D(nout, nout, k=3), objax.functional.leaky_relu,\n",
+    "    ])\n",
+    "\n",
+    "class SimpleNet(objax.Module):\n",
+    "    def __init__(self, nclass, colors, n):\n",
+    "        self.pre_conv = objax.nn.Sequential([objax.nn.Conv2D(colors, n, k=3), objax.functional.leaky_relu])\n",
+    "        self.block1 = simple_net_block(1 * n, 2 * n)\n",
+    "        self.block2 = simple_net_block(2 * n, 4 * n)\n",
+    "        self.post_conv = objax.nn.Conv2D(4 * n, nclass, k=3)\n",
+    "\n",
+    "    def __call__(self, x, training=False):  # x = (batch, colors, height, width)\n",
+    "        y = self.pre_conv(x)\n",
+    "        y = self.block1(y)\n",
+    "        y = self.block2(y)\n",
+    "        logits = self.post_conv(y).mean((2, 3))  # logits = (batch, nclass)\n",
+    "        if training:\n",
+    "            return logits\n",
+    "        return objax.functional.softmax(logits)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "id": "7mWj4QxWVbI3"
+   },
+   "outputs": [],
+   "source": [
+    "batch = 512\n",
+    "test_batch = 2048\n",
+    "epochs = 50\n",
+    "lr = 0.003\n",
+    "train_size = train.image.shape[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 238
+    },
+    "id": "DBKXaiasNYPP",
+    "outputId": "1f11718a-4c5d-4abb-aca5-bb0aff1191d3"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(SimpleNet).pre_conv(Sequential)[0](Conv2D).b       16 (16, 1, 1)\n",
+      "(SimpleNet).pre_conv(Sequential)[0](Conv2D).w      144 (3, 3, 1, 16)\n",
+      "(SimpleNet).block1(Sequential)[0](Conv2D).b         32 (32, 1, 1)\n",
+      "(SimpleNet).block1(Sequential)[0](Conv2D).w       4608 (3, 3, 16, 32)\n",
+      "(SimpleNet).block1(Sequential)[3](Conv2D).b         32 (32, 1, 1)\n",
+      "(SimpleNet).block1(Sequential)[3](Conv2D).w       9216 (3, 3, 32, 32)\n",
+      "(SimpleNet).block2(Sequential)[0](Conv2D).b         64 (64, 1, 1)\n",
+      "(SimpleNet).block2(Sequential)[0](Conv2D).w      18432 (3, 3, 32, 64)\n",
+      "(SimpleNet).block2(Sequential)[3](Conv2D).b         64 (64, 1, 1)\n",
+      "(SimpleNet).block2(Sequential)[3](Conv2D).w      36864 (3, 3, 64, 64)\n",
+      "(SimpleNet).post_conv(Conv2D).b                     10 (10, 1, 1)\n",
+      "(SimpleNet).post_conv(Conv2D).w                   5760 (3, 3, 64, 10)\n",
+      "+Total(12)                                       75242\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = SimpleNet(nclass=10, colors=1, n=16)\n",
+    "original_weights = model.vars().tensors() # saving the initial weights, all the below experiments will be using this same weights.\n",
+    "print(model.vars())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "oGUj3wrhVknG"
+   },
+   "source": [
+    "## Regular training with SGD"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 884
+    },
+    "id": "sWgSBId6-kAF",
+    "outputId": "e90bef4d-8e1e-411b-d307-9e12650ac007"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 86593.05img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0001  Accuracy 13.08 Loss 2.33\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88523.38img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0002  Accuracy 9.80 Loss 2.33\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88991.30img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0003  Accuracy 9.80 Loss 2.32\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 89247.93img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0004  Accuracy 9.80 Loss 2.32\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88412.02img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0005  Accuracy 9.80 Loss 2.32\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 7/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88727.59img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0006  Accuracy 9.80 Loss 2.32\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88869.77img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0007  Accuracy 9.82 Loss 2.31\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 87998.60img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0008  Accuracy 9.82 Loss 2.31\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88086.23img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0009  Accuracy 9.92 Loss 2.31\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 11/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88946.04img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0010  Accuracy 10.27 Loss 2.30\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 12/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 87248.79img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0011  Accuracy 11.19 Loss 2.30\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 13/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 85079.93img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0012  Accuracy 14.57 Loss 2.29\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 14/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88835.86img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0013  Accuracy 15.08 Loss 2.29\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 15/50 :  14%|█▍        | 8704/60416 [00:00<00:00, 85697.91img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0014  Accuracy 17.52 Loss 2.28\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 16/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 87876.57img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0015  Accuracy 23.02 Loss 2.27\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 17/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88567.80img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0016  Accuracy 24.27 Loss 2.26\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 18/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88092.66img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0017  Accuracy 25.01 Loss 2.24\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 19/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88833.41img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0018  Accuracy 31.00 Loss 2.22\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 20/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88844.85img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0019  Accuracy 34.81 Loss 2.18\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 21/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88184.70img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0020  Accuracy 30.33 Loss 2.12\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 22/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88825.05img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0021  Accuracy 38.27 Loss 2.03\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 23/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88235.83img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0022  Accuracy 29.19 Loss 1.88\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 24/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 89164.96img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0023  Accuracy 30.77 Loss 1.71\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 25/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88137.45img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0024  Accuracy 44.48 Loss 1.64\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 26/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88553.59img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0025  Accuracy 47.86 Loss 1.51\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 27/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 86943.64img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0026  Accuracy 43.22 Loss 1.37\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 28/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 87624.38img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0027  Accuracy 49.07 Loss 1.23\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 29/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 85400.42img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0028  Accuracy 61.34 Loss 1.08\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 30/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88383.11img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0029  Accuracy 54.22 Loss 0.99\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 31/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88590.33img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0030  Accuracy 67.99 Loss 0.87\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 32/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 86999.99img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0031  Accuracy 73.26 Loss 0.75\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 33/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88843.01img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0032  Accuracy 77.06 Loss 0.68\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 34/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 86265.11img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0033  Accuracy 72.43 Loss 0.62\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 35/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 82148.97img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0034  Accuracy 76.37 Loss 0.57\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 36/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88946.86img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0035  Accuracy 80.99 Loss 0.53\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 37/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 89022.04img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0036  Accuracy 80.53 Loss 0.53\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 38/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88539.60img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0037  Accuracy 82.85 Loss 0.46\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 39/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88502.70img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0038  Accuracy 78.69 Loss 0.45\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 40/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 87474.47img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0039  Accuracy 85.29 Loss 0.44\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 41/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88521.55img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0040  Accuracy 85.52 Loss 0.41\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 42/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 89200.97img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0041  Accuracy 86.48 Loss 0.39\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 43/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88478.19img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0042  Accuracy 88.26 Loss 0.38\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 44/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88767.93img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0043  Accuracy 77.10 Loss 0.37\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 45/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88623.64img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0044  Accuracy 88.17 Loss 0.38\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 46/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 89394.47img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0045  Accuracy 88.27 Loss 0.35\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 47/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88684.63img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0046  Accuracy 86.68 Loss 0.34\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 48/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88895.52img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0047  Accuracy 88.00 Loss 0.38\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 49/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 88530.47img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0048  Accuracy 89.35 Loss 0.32\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 50/50 :  15%|█▌        | 9216/60416 [00:00<00:00, 89427.56img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0049  Accuracy 90.10 Loss 0.31\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                 "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0050  Accuracy 90.06 Loss 0.31\n",
+      "Total training time:  78.19884443283081\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r"
+     ]
+    }
+   ],
+   "source": [
+    "opt = objax.optimizer.SGD(model.vars())\n",
+    "predict = objax.Jit(model)\n",
+    "\n",
+    "def loss(x, y):\n",
+    "    logits = model(x, training=True)\n",
+    "    xe_loss = objax.functional.loss.cross_entropy_logits_sparse(logits, y).mean()\n",
+    "    wd_loss = sum(jn.abs(v.value).sum() for k,v in model.vars().items() if k.endswith('.w'))\n",
+    "    return xe_loss + wd_loss * 1e-5\n",
+    "\n",
+    "gv = objax.GradValues(loss, model.vars())\n",
+    "\n",
+    "def train_op(x, y, lr):\n",
+    "    g, v = gv(x, y)\n",
+    "    opt(lr=lr, grads=g)\n",
+    "    return v\n",
+    "\n",
+    "train_op = objax.Jit(train_op, model.vars() + opt.vars())\n",
+    "\n",
+    "train_start = time()\n",
+    "loss_hist, accuracy_hist = [], []\n",
+    "\n",
+    "for epoch in range(epochs):\n",
+    "    loop = trange(0, train_size, batch,\n",
+    "                  leave=False, unit='img', unit_scale=batch,\n",
+    "                  desc='Epoch %d/%d ' % (1 + epoch, epochs))\n",
+    "    batch_loss = []\n",
+    "    for it in loop:\n",
+    "        # select random images from training set\n",
+    "        sel = np.random.randint(size=(batch,), low=0, high=train.image.shape[0])\n",
+    "\n",
+    "        # feed the batch\n",
+    "        v = train_op(augment(train.image[sel]), train.label[sel], lr)\n",
+    "        batch_loss.append(v[0])\n",
+    "\n",
+    "    loss = sum(batch_loss)/len(batch_loss)\n",
+    "    loss_hist.append(loss)\n",
+    "\n",
+    "    # Eval\n",
+    "    accuracy = 0\n",
+    "    for it in trange(0, test.image.shape[0], test_batch, leave=False, desc='Evaluating'):\n",
+    "        x = test.image[it: it + test_batch]\n",
+    "        xl = test.label[it: it + test_batch]\n",
+    "        accuracy += (np.argmax(predict(x), axis=1) == xl).sum()\n",
+    "    accuracy /= test.image.shape[0]\n",
+    "    accuracy_hist.append(accuracy)\n",
+    "    print(f'Epoch {epoch + 1:04d}  Accuracy {100 * accuracy:.2f} Loss {loss:.2f}')\n",
+    "\n",
+    "train_end = time()\n",
+    "print('Total training time: ', (train_end-train_start))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 606
+    },
+    "id": "7CM6S1zmO7k8",
+    "outputId": "67775e1b-f78c-491d-848c-5750c08d3ac4"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "acc_loss_plot(loss_hist, accuracy_hist)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "oznhDcfmVw7J"
+   },
+   "source": [
+    "## Learning Rate Finder\n",
+    "\n",
+    "1.   Save the weights\n",
+    "2.   Find the best LR\n",
+    "3.   Restore the weights\n",
+    "## How to find the best Learning rate?\n",
+    "We need to pick the approximate value not too high or too low.\n",
+    "As you can see that picking up the lower learning rate (<10^-2) and the higher learning rate (>1) results in huge loss \n", 
+    "so we choose something between these ranges usually where the slope is steepest in the downward direction.",
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 283
+    },
+    "id": "4ZPsnS20CQSw",
+    "outputId": "20a88ea7-152c-498a-82de-ef5c203c9210"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": []
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# find best learning rate for faster convergence\n",
+    "model.vars().assign(original_weights) # restoring the initial weights\n",
+    "opt = objax.optimizer.SGD(model.vars())\n",
+    "predict = objax.Jit(model)\n",
+    "\n",
+    "def loss(x, y):\n",
+    "    logits = model(x, training=True)\n",
+    "    xe_loss = objax.functional.loss.cross_entropy_logits_sparse(logits, y).mean()\n",
+    "    wd_loss = sum(jn.abs(v.value).sum() for k,v in model.vars().items() if k.endswith('.w'))\n",
+    "    return xe_loss + wd_loss * 1e-5\n",
+    "\n",
+    "gv = objax.GradValues(loss, model.vars())\n",
+    "\n",
+    "def train_op(x, y, lr):\n",
+    "    g, v = gv(x, y)\n",
+    "    opt(lr=lr, grads=g)\n",
+    "    return v\n",
+    "\n",
+    "train_op = objax.Jit(train_op, model.vars() + opt.vars())\n",
+    "\n",
+    "def find_lr(init_value=1e-8, final_value=10., beta=0.98):\n",
+    "    num_batches = (train_size//batch) - 1\n",
+    "    lr_update_factor = (final_value / init_value) ** (1/num_batches)\n",
+    "    avg_loss, best_loss, best_lr, batch_num = 0., 0., 0., 0\n",
+    "    current_lr = init_value\n",
+    "\n",
+    "    loop = trange(0, train_size, batch, leave=False, unit='img',\n",
+    "            unit_scale=batch)\n",
+    "\n",
+    "    learning_rates, losses = [], []\n",
+    "    for it in loop:\n",
+    "        batch_num += 1\n",
+    "\n",
+    "        # select random images from training set\n",
+    "        sel = np.random.randint(size=(batch,), low=0, high=train.image.shape[0])\n",
+    "\n",
+    "        # feed the batch\n",
+    "        batch_loss = train_op(train.image[sel], train.label[sel], current_lr)[0]\n",
+    "\n",
+    "        # Compute the smoothed loss\n",
+    "        avg_loss = beta * avg_loss + (1-beta) * batch_loss\n",
+    "        smoothed_loss = avg_loss / (1 - beta ** batch_num)\n",
+    "\n",
+    "        #Stop if the loss is exploding\n",
+    "        if batch_num > 1 and smoothed_loss > 4 * best_loss:\n",
+    "            return learning_rates, losses\n",
+    "\n",
+    "        #Record the best loss\n",
+    "        if smoothed_loss < best_loss or batch_num==1:\n",
+    "            best_loss, best_lr = smoothed_loss, current_lr\n",
+    "\n",
+    "        losses.append(smoothed_loss)\n",
+    "        learning_rates.append(current_lr)\n",
+    "        current_lr *= lr_update_factor\n",
+    "\n",
+    "    return learning_rates, losses\n",
+    "\n",
+    "learning_rates, losses = find_lr()\n",
+    "lr_plot(learning_rates[10:-5], losses[10:-5])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "IVKw_KZCXTOT"
+   },
+   "source": [
+    "## Training with best learning rate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 204
+    },
+    "id": "WMXnIgqLeADQ",
+    "outputId": "645ed81e-ab8e-41bd-8b8f-b0052bc4263d"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 89874.45img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0001  Accuracy 18.99 Loss 2.25\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 90893.92img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0002  Accuracy 45.40 Loss 2.04\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4/10 :  15%|█▌        | 9216/60416 [00:00<00:00, 90936.84img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0003  Accuracy 54.44 Loss 1.40\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 90601.27img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0004  Accuracy 78.53 Loss 0.69\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 89078.22img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0005  Accuracy 88.43 Loss 0.36\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 7/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 90713.66img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0006  Accuracy 92.55 Loss 0.24\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 90831.60img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0007  Accuracy 91.52 Loss 0.23\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 90750.99img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0008  Accuracy 92.81 Loss 0.16\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 89652.48img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0009  Accuracy 89.35 Loss 0.20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                 "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0010  Accuracy 95.11 Loss 0.15\n",
+      "Total training time:  15.313448905944824\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r"
+     ]
+    }
+   ],
+   "source": [
+    "model.vars().assign(original_weights) # restoring the initial weights\n",
+    "opt = objax.optimizer.SGD(model.vars())\n",
+    "predict = objax.Jit(model)\n",
+    "\n",
+    "lr = 0.1\n",
+    "epochs = 10\n",
+    "\n",
+    "def loss(x, y):\n",
+    "    logits = model(x, training=True)\n",
+    "    return objax.functional.loss.cross_entropy_logits_sparse(logits, y).mean()\n",
+    "\n",
+    "gv = objax.GradValues(loss, model.vars())\n",
+    "\n",
+    "def train_op(x, y, lr):\n",
+    "    g, v = gv(x, y)\n",
+    "    opt(lr=lr, grads=g)\n",
+    "    return v\n",
+    "\n",
+    "train_op = objax.Jit(train_op, model.vars() + opt.vars())\n",
+    "\n",
+    "train_start = time()\n",
+    "loss_hist, accuracy_hist = [], []\n",
+    "\n",
+    "for epoch in range(epochs):\n",
+    "    loop = trange(0, train_size, batch,\n",
+    "                  leave=False, unit='img', unit_scale=batch,\n",
+    "                  desc='Epoch %d/%d ' % (1 + epoch, epochs))\n",
+    "    batch_loss = []\n",
+    "    for it in loop:\n",
+    "        # select random images from training set\n",
+    "        sel = np.random.randint(size=(batch,), low=0, high=train.image.shape[0])\n",
+    "\n",
+    "        # feed the batch\n",
+    "        v = train_op(augment(train.image[sel]), train.label[sel], lr)\n",
+    "        batch_loss.append(v[0])\n",
+    "\n",
+    "    loss = sum(batch_loss)/len(batch_loss)\n",
+    "    loss_hist.append(loss)\n",
+    "\n",
+    "    # Eval\n",
+    "    accuracy = 0\n",
+    "    for it in trange(0, test.image.shape[0], test_batch, leave=False, desc='Evaluating'):\n",
+    "        x = test.image[it: it + test_batch]\n",
+    "        xl = test.label[it: it + test_batch]\n",
+    "        accuracy += (np.argmax(predict(x), axis=1) == xl).sum()\n",
+    "    accuracy /= test.image.shape[0]\n",
+    "    accuracy_hist.append(accuracy)\n",
+    "    print(f'Epoch {epoch + 1:04d}  Accuracy {100 * accuracy:.2f} Loss {loss:.2f}')\n",
+    "\n",
+    "train_end = time()\n",
+    "print('Total training time: ', (train_end-train_start))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 606
+    },
+    "id": "IcivNXQqmdcz",
+    "outputId": "95a62d8d-e3a5-4582-f1f5-b51277e39914"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "acc_loss_plot(loss_hist, accuracy_hist)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mCjvEEe2XjR2"
+   },
+   "source": [
+    "## Training with One Cycle Policy (Cyclical learning rate and Cyclical momentum)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 241
+    },
+    "id": "MAaZoBFk7vod",
+    "outputId": "15e47962-4d0b-4125-b651-f740e4aabd5e"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x216 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def cyclical(stepsize, min_val, max_val, inverse=False):\n",
+    "    import math\n",
+    "    scaler = lambda x: 1\n",
+    "    lr_lambda = lambda it: min_val + (max_val - min_val) * relative(it, stepsize, inverse)\n",
+    "\n",
+    "    def relative(it, stepsize, inverse):\n",
+    "        cycle = math.floor(1 + it / (2 * stepsize))\n",
+    "        x = abs(it / stepsize - 2 * cycle + 1)\n",
+    "        val = max(0, (1 - x)) * scaler(cycle)\n",
+    "        return 1 - val if inverse else val\n",
+    "    \n",
+    "    return lr_lambda\n",
+    "\n",
+    "\n",
+    "# Example\n",
+    "n_cycles = 2\n",
+    "cycle_len = 10\n",
+    "step_size = cycle_len // 2\n",
+    "cyc_lr = cyclical(stepsize=step_size, min_val=3e-4, max_val=3e-3)\n",
+    "cyc_m = cyclical(stepsize=step_size, min_val=0.85, max_val=0.95, inverse=True)\n",
+    "\n",
+    "lr_list, m_list = [], []\n",
+    "for epoch in range(n_cycles):\n",
+    "    for i in range(cycle_len):\n",
+    "        iter_num = epoch*cycle_len + i\n",
+    "        lr_list.append(cyc_lr(iter_num))\n",
+    "        m_list.append(cyc_m(iter_num))\n",
+    "\n",
+    "lr_mom_plot(lr_list, m_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 204
+    },
+    "id": "jJO5me5Inn-m",
+    "outputId": "e62012d7-12a2-4b6b-9192-10c5a198565d"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 89271.56img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0001  Accuracy 42.67 Loss 2.13\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 90507.81img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0002  Accuracy 54.67 Loss 1.35\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 90364.89img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0003  Accuracy 81.41 Loss 0.43\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 90104.67img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0004  Accuracy 93.69 Loss 0.18\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 89351.32img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0005  Accuracy 95.00 Loss 0.13\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 7/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 90023.56img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0006  Accuracy 94.41 Loss 0.08\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 90246.37img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0007  Accuracy 96.68 Loss 0.07\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 89971.55img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0008  Accuracy 97.94 Loss 0.06\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10/10 :  16%|█▌        | 9728/60416 [00:00<00:00, 86532.58img/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0009  Accuracy 98.20 Loss 0.05\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                 "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0010  Accuracy 98.10 Loss 0.04\n",
+      "Total training time:  15.809092283248901\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r"
+     ]
+    }
+   ],
+   "source": [
+    "model.vars().assign(original_weights) # restoring the initial weights\n",
+    "opt = objax.optimizer.Momentum(model.vars(), 0.95)\n",
+    "predict = objax.Jit(model)\n",
+    "\n",
+    "lr = 0.1 # the best learning rate which we found previously\n",
+    "epochs = 10\n",
+    "num_iter_per_epoch = train_size//batch\n",
+    "tot_iter = epochs * num_iter_per_epoch\n",
+    "step_size = tot_iter // 2\n",
+    "\n",
+    "#initialize cyclical generators\n",
+    "cyc_lr = cyclical(stepsize=step_size, min_val=lr/10, max_val=lr)\n",
+    "cyc_mom = cyclical(stepsize=step_size, min_val=0.85, max_val=0.95, inverse=True)\n",
+    "\n",
+    "def loss(x, y):\n",
+    "    logits = model(x, training=True)\n",
+    "    return objax.functional.loss.cross_entropy_logits_sparse(logits, y).mean()\n",
+    "\n",
+    "gv = objax.GradValues(loss, model.vars())\n",
+    "\n",
+    "def train_op(x, y, lr, mom):\n",
+    "    g, v = gv(x, y)\n",
+    "    opt(lr=lr, grads=g, momentum=mom)\n",
+    "    return v\n",
+    "\n",
+    "train_op = objax.Jit(train_op, model.vars() + opt.vars())\n",
+    "mom_hist, lr_hist, loss_hist, accuracy_hist = [], [], [], []\n",
+    "train_start = time()\n",
+    "\n",
+    "for epoch in range(epochs):\n",
+    "    loop = trange(0, train_size, batch,\n",
+    "                    leave=False, unit='img', unit_scale=batch,\n",
+    "                    desc='Epoch %d/%d ' % (1 + epoch, epochs))\n",
+    "    batch_loss = []\n",
+    "    for it in loop:\n",
+    "        iter_num = epoch*num_iter_per_epoch+it/batch\n",
+    "        \n",
+    "        # get new learning rate and momentum\n",
+    "        lr = cyc_lr(iter_num)\n",
+    "        mom = cyc_mom(iter_num)\n",
+    "\n",
+    "        # select random images from training set\n",
+    "        sel = np.random.randint(size=(batch,), low=0, high=train.image.shape[0])\n",
+    "        \n",
+    "        # feed the batch\n",
+    "        v = train_op(augment(train.image[sel]), train.label[sel], lr, mom)\n",
+    "\n",
+    "        batch_loss.append(v[0])\n",
+    "        mom_hist.append(mom)\n",
+    "        lr_hist.append(lr)\n",
+    "\n",
+    "    loss = sum(batch_loss)/len(batch_loss)\n",
+    "    loss_hist.append(loss)\n",
+    "\n",
+    "    # Eval\n",
+    "    accuracy = 0\n",
+    "    for it in trange(0, test.image.shape[0], test_batch, leave=False, desc='Evaluating'):\n",
+    "        x = test.image[it: it + test_batch]\n",
+    "        xl = test.label[it: it + test_batch]\n",
+    "        accuracy += (np.argmax(predict(x), axis=1) == xl).sum()\n",
+    "    accuracy /= test.image.shape[0]\n",
+    "    accuracy_hist.append(accuracy)\n",
+    "    print(f'Epoch {epoch + 1:04d}  Accuracy {100 * accuracy:.2f} Loss {loss:.2f}')\n",
+    "\n",
+    "train_end = time()\n",
+    "print('Total training time: ', (train_end-train_start))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 606
+    },
+    "id": "zSG6FmCq-HX4",
+    "outputId": "d9c5add0-8b14-438b-bb9c-0eebcb4065ad"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "acc_loss_plot(loss_hist, accuracy_hist)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 241
+    },
+    "id": "fOTiNEJuQfBA",
+    "outputId": "7ecdd587-dbb9-4af6-cecf-6a7a85dfd083"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x216 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light",
+      "tags": []
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "lr_mom_plot(lr_hist, mom_hist)"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "collapsed_sections": [],
+   "name": "Super Convergence.ipynb",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.5.2"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "1096b35a43204819b793ae71ca903009": {
+     "model_module": "@jupyter-widgets/base",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "36a97e7e6f934026817e68b6daab5e8b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3d1b718eec564ac6866d732e93c52362": {
+     "model_module": "@jupyter-widgets/base",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "559a266f43484b378a1fe4783178274b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3d1b718eec564ac6866d732e93c52362",
+      "placeholder": "​",
+      "style": "IPY_MODEL_36a97e7e6f934026817e68b6daab5e8b",
+      "value": " 4/4 [00:06&lt;00:00,  1.57s/ file]"
+     }
+    },
+    "7b3f8d1c9ab944c69c0146a0951a8807": {
+     "model_module": "@jupyter-widgets/base",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "80beed2bab07454eaf0eb26399ea19b9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "Dl Completed...: 100%",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7b3f8d1c9ab944c69c0146a0951a8807",
+      "max": 4,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_ef01d022b37b4806bbbc05f5c2bade19",
+      "value": 4
+     }
+    },
+    "e7b07465fa61490dbb41545aac4fa9b4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_80beed2bab07454eaf0eb26399ea19b9",
+       "IPY_MODEL_559a266f43484b378a1fe4783178274b"
+      ],
+      "layout": "IPY_MODEL_1096b35a43204819b793ae71ca903009"
+     }
+    },
+    "ef01d022b37b4806bbbc05f5c2bade19": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": "initial"
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}