lec_9_v4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 318,
   "id": "fc5c08d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import DataLoader, default_collate\n",
    "from datasets import load_dataset\n",
    "import matplotlib.pyplot as plt\n",
    "from functools import partial\n",
    "import fastcore.all as fc\n",
    "import torchvision.transforms.functional as TF\n",
    "import torch.nn.functional as F\n",
    "from operator import itemgetter, attrgetter\n",
    "import torch.optim as optim\n",
    "from functools import partial\n",
    "from copy import copy\n",
    "from torcheval.metrics import MulticlassAccuracy, Mean\n",
    "from fastprogress import master_bar, progress_bar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "id": "ff848613",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:datasets.builder:Found cached dataset fashion_mnist (/Users/arun/.cache/huggingface/datasets/fashion_mnist/fashion_mnist/1.0.0/0a671f063342996f19779d38c0ab4abef9c64f757b35af8134b331c294d7ba48)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4d843e4e25ec41eab753983d17f417c9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/2 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "name = 'fashion_mnist'\n",
    "dsd = load_dataset(name)\n",
    "x,y,*_ = dsd['train'].features.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "id": "ec3ad37f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def inplace(f):\n",
    "    def _f(b):\n",
    "        f(b)\n",
    "        return b\n",
    "    return _f\n",
    "\n",
    "@inplace\n",
    "def transformi(b):\n",
    "    b[x] = [torch.flatten(TF.to_tensor(ele)) for ele in b[x]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "id": "3d4fbfce",
   "metadata": {},
   "outputs": [],
   "source": [
    "tds = dsd.with_transform(transformi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "id": "6782bacf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_dls(train_ds, valid_ds, batch_size, **kwargs):\n",
    "    return (\n",
    "        DataLoader(train_ds, batch_size=batch_size, shuffle=True, **kwargs),\n",
    "        DataLoader(valid_ds, batch_size=batch_size*2, shuffle=False, **kwargs)\n",
    "    )\n",
    "\n",
    "def collate_dict(x):\n",
    "    g = itemgetter(*x.features)\n",
    "    def _f(b):\n",
    "        return g(default_collate(b))\n",
    "    return _f\n",
    "\n",
    "class DataLoaders:\n",
    "    def __init__(self, *ds):\n",
    "        self.train,self.valid = ds[:2]\n",
    "    \n",
    "    @classmethod\n",
    "    def from_dd(cls, dd, batch_size, as_tuple=True, **kwargs):\n",
    "        f = collate_dict(dd['train'])\n",
    "        return cls(*get_dls(*dd.values(), batch_size=batch_size, collate_fn=f, **kwargs))    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "id": "69a15538",
   "metadata": {},
   "outputs": [],
   "source": [
    "bs = 1024\n",
    "dls = DataLoaders.from_dd(tds, batch_size=bs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "id": "ff92c70b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def_device = 'mps' if torch.backends.mps.is_available() else 'cuda' if torch.cuda.is_available() else 'cpu'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "id": "f7245b44",
   "metadata": {},
   "outputs": [],
   "source": [
    "n,nh = 28*28,50\n",
    "def get_model():\n",
    "    return nn.Sequential(*[nn.Linear(n, nh), nn.ReLU(nh), nn.Linear(nh, 10)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "9125ce9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Learner:\n",
    "    def __init__(self, model, dls, loss_func=F.cross_entropy, opt_func=optim.SGD, lr=0.2):\n",
    "        fc.store_attr()\n",
    "    \n",
    "    def calc_stats(self):\n",
    "        n = len(self.xb)\n",
    "        self.losses.append(self.loss*n)\n",
    "        acc = (self.preds.argmax(dim=1)==self.yb).float().sum()\n",
    "        self.accs.append(acc)\n",
    "        self.ns.append(n)\n",
    "    \n",
    "    def report(self):\n",
    "        n = sum(self.ns)\n",
    "        acc = sum(self.accs)/n\n",
    "        loss = sum(self.losses)/n\n",
    "        print(f'acc:{acc:.3f}, loss:{loss:.3f}, training:{self.model.training}')\n",
    "    \n",
    "    def one_batch(self,):\n",
    "        self.xb,self.yb = self.batch\n",
    "        self.preds = self.model(self.xb)\n",
    "        self.loss = self.loss_func(self.preds, self.yb)\n",
    "        if self.model.training:\n",
    "            self.loss.backward()\n",
    "            self.opt.step()\n",
    "            self.opt.zero_grad()\n",
    "        with torch.no_grad():\n",
    "            self.calc_stats()\n",
    "    \n",
    "    def one_epoch(self, train):\n",
    "        self.model.train(train)\n",
    "        self.dl = self.dls.train if train else self.dls.valid\n",
    "        for self.iter, self.batch in enumerate(self.dl):\n",
    "            self.one_batch()\n",
    "        self.report()\n",
    "        \n",
    "    def fit(self, n_epochs=1):\n",
    "        self.n_epochs = n_epochs\n",
    "        self.accs,self.losses,self.ns = [],[],[]\n",
    "        self.opt = self.opt_func(self.model.parameters(), lr=self.lr)\n",
    "        for self.epoch in range(n_epochs):\n",
    "            self.one_epoch(True)\n",
    "        with torch.no_grad():\n",
    "            self.one_epoch(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "e17cb482",
   "metadata": {},
   "outputs": [],
   "source": [
    "learner = Learner(get_model(), dls, lr=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "1a8f2a61",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "acc:0.590, loss:1.351, training:True\n",
      "acc:0.647, loss:1.081, training:True\n",
      "acc:0.682, loss:0.954, training:True\n",
      "acc:0.687, loss:0.939, training:False\n"
     ]
    }
   ],
   "source": [
    "learner.fit(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "43de0879",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CancelFitException(Exception):\n",
    "    pass\n",
    "\n",
    "class CancelEpochException(Exception):\n",
    "    pass\n",
    "\n",
    "class CancelBatchException(Exception):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "26a0fda8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_cbs(cbs, method_nm, learn=None):\n",
    "    for cb in sorted(cbs, key=attrgetter('order')):\n",
    "        method = getattr(cb, method_nm, None)\n",
    "        if method is not None:\n",
    "            method(learn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "674593fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Callback:\n",
    "    order = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "id": "e3b5751b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class with_cbs:\n",
    "    def __init__(self, nm):\n",
    "        self.nm = nm \n",
    "    \n",
    "    def __call__(self, f):\n",
    "        def _f(o, *args, **kwargs):\n",
    "            try:\n",
    "                o.callback(f'before_{self.nm}')\n",
    "                f(o, *args, **kwargs)\n",
    "                o.callback(f'after_{self.nm}')\n",
    "            except globals()[f'Cancel{self.nm.title()}Exception'] as e:\n",
    "                pass\n",
    "            finally:\n",
    "                o.callback(f'cleanup_{self.nm}')\n",
    "        return _f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 349,
   "id": "0d0fdf1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Learner:\n",
    "    def __init__(self, model, dls=(0,), loss_func=F.cross_entropy, lr=0.1, opt_func=optim.SGD, cbs=None):\n",
    "        cbs = fc.L(cbs)\n",
    "        fc.store_attr()\n",
    "    \n",
    "    @property\n",
    "    def training(self):\n",
    "        return self.model.training\n",
    "    \n",
    "    def __getattr__(self, name):\n",
    "        if name in ('predict', 'get_loss', 'backward', 'step', 'zero_grad'):\n",
    "            return partial(self.callback, name) \n",
    "        raise AttributeError(name)\n",
    "    \n",
    "    def callback(self, method_nm):\n",
    "        run_cbs(self.cbs, method_nm, self)\n",
    "    \n",
    "    @with_cbs('batch')\n",
    "    def _one_batch(self):\n",
    "        self.predict()\n",
    "        self.callback('after_predict')\n",
    "        self.get_loss()\n",
    "        self.callback('after_loss')\n",
    "        if self.training:\n",
    "            self.backward()\n",
    "            self.callback('after_backward')\n",
    "            self.step()\n",
    "            self.callback('after_step')\n",
    "            self.zero_grad()\n",
    "    \n",
    "    @with_cbs('epoch')\n",
    "    def _one_epoch(self):\n",
    "        for self.iter, self.batch in enumerate(self.dl):\n",
    "            self._one_batch()\n",
    "    \n",
    "    def one_epoch(self, train):\n",
    "        self.model.train(train)\n",
    "        self.dl = self.dls.train if train else self.dls.valid\n",
    "        self._one_epoch()\n",
    "    \n",
    "    @with_cbs('fit')\n",
    "    def _fit(self, train, valid):\n",
    "        for self.epoch in self.epochs:\n",
    "            if train:\n",
    "                self.one_epoch(True)\n",
    "            if valid:\n",
    "                self.one_epoch(False)\n",
    "    \n",
    "    def fit(self, n_epochs=1, lr=None, cbs=None, valid=True, train=True):\n",
    "        cbs = fc.L(cbs)\n",
    "        for cb in cbs:\n",
    "            self.cbs.append(cb)\n",
    "        try:\n",
    "            self.n_epochs = n_epochs\n",
    "            self.epochs = range(n_epochs)\n",
    "            self.lr = lr if lr is not None else self.lr\n",
    "            self.opt = self.opt_func(self.model.parameters(), lr=self.lr)\n",
    "            self._fit(train, valid)\n",
    "        finally:\n",
    "            for cb in cbs:\n",
    "                self.cbs.remove(cb)     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 350,
   "id": "bf27c5e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "learner = Learner(get_model(), dls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 351,
   "id": "7520bc99",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TrainerCB(Callback):\n",
    "    def __init__(self, n_inp):\n",
    "        self.n_inp = n_inp\n",
    "        \n",
    "    def predict(self, learn):\n",
    "        learn.preds = learn.model(*learn.batch[:self.n_inp])\n",
    "    \n",
    "    def get_loss(self, learn):\n",
    "        learn.loss = learn.loss_func(learn.preds, *learn.batch[self.n_inp:])\n",
    "    \n",
    "    def backward(self, learn):\n",
    "        learn.loss.backward()\n",
    "\n",
    "    def step(self, learn):\n",
    "        learn.opt.step()\n",
    "    \n",
    "    def zero_grad(self, learn):\n",
    "        learn.opt.zero_grad()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 352,
   "id": "9b675785",
   "metadata": {},
   "outputs": [],
   "source": [
    "learner = Learner(get_model(), dls, cbs=[TrainerCB(1)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 353,
   "id": "28c55eb8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "learner.fit(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 354,
   "id": "9e397e7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MetricsCB(Callback):\n",
    "    def __init__(self, *ms, **metrics):\n",
    "        for o in ms:\n",
    "            metrics[o.__name__] = o\n",
    "        self.metrics = metrics\n",
    "        self.all_metrics = copy(metrics)\n",
    "        self.all_metrics['loss'] = self.loss = Mean()\n",
    "    \n",
    "    def _log(self, d):\n",
    "        print(d)\n",
    "    \n",
    "    def before_fit(self, learn):\n",
    "        learn.metrics = self\n",
    "    \n",
    "    def before_epoch(self, learn):\n",
    "        [o.reset() for o in self.all_metrics.values()]\n",
    "    \n",
    "    def after_epoch(self, learn):\n",
    "        log = {k:f'{v.compute():.3f}' for k,v in self.all_metrics.items()}\n",
    "        log['epoch'] = learn.epoch\n",
    "        log['train'] = 'train' if learn.training else 'eval'\n",
    "        self._log(log)\n",
    "    \n",
    "    def after_batch(self, learn):\n",
    "        x,y,*_ = learn.batch\n",
    "        for m in self.metrics.values():\n",
    "            m.update(learn.preds, y)\n",
    "        self.loss.update(learn.loss, weight=len(x))        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 355,
   "id": "3d0b2f2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "learner = Learner(get_model(), copy(dls), cbs=[TrainerCB(1), MetricsCB(accuracy=MulticlassAccuracy())])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 356,
   "id": "c627620d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'accuracy': '0.554', 'loss': '1.448', 'epoch': 0, 'train': 'train'}\n",
      "{'accuracy': '0.668', 'loss': '0.937', 'epoch': 0, 'train': 'eval'}\n",
      "{'accuracy': '0.707', 'loss': '0.819', 'epoch': 1, 'train': 'train'}\n",
      "{'accuracy': '0.730', 'loss': '0.753', 'epoch': 1, 'train': 'eval'}\n",
      "{'accuracy': '0.752', 'loss': '0.700', 'epoch': 2, 'train': 'train'}\n",
      "{'accuracy': '0.762', 'loss': '0.680', 'epoch': 2, 'train': 'eval'}\n"
     ]
    }
   ],
   "source": [
    "learner.fit(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 357,
   "id": "9d86b8b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ProgressCB(Callback):\n",
    "    order = MetricsCB.order+1\n",
    "    def __init__(self, plot=False): self.plot = plot\n",
    "    def before_fit(self, learn):\n",
    "        learn.epochs = self.mbar = master_bar(learn.epochs)\n",
    "        self.first = True\n",
    "        if hasattr(learn, 'metrics'): learn.metrics._log = self._log\n",
    "        self.losses = []\n",
    "        self.val_losses = []\n",
    "\n",
    "    def _log(self, d):\n",
    "        if self.first:\n",
    "            self.mbar.write(list(d), table=True)\n",
    "            self.first = False\n",
    "        self.mbar.write(list(d.values()), table=True)\n",
    "\n",
    "    def before_epoch(self, learn): learn.dl = progress_bar(learn.dl, leave=False, parent=self.mbar)\n",
    "    def after_batch(self, learn):\n",
    "        learn.dl.comment = f'{learn.loss:.3f}'\n",
    "        if self.plot and hasattr(learn, 'metrics') and learn.training:\n",
    "            self.losses.append(learn.loss.item())\n",
    "            if self.val_losses: \n",
    "                self.mbar.update_graph([[fc.L.range(self.losses), self.losses],\\\n",
    "                [fc.L.range(learn.epoch).map(lambda x: (x+1)*len(learn.dls.train)), self.val_losses]])\n",
    "                \n",
    "    def after_epoch(self, learn): \n",
    "        if not learn.training:\n",
    "            if self.plot and hasattr(learn, 'metrics'): \n",
    "                self.val_losses.append(learn.metrics.all_metrics['loss'].compute())\n",
    "                self.mbar.update_graph([[fc.L.range(self.losses), self.losses],\\\n",
    "                        [fc.L.range(learn.epoch+1).map(lambda x: (x+1)*len(learn.dls.train)), self.val_losses]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "id": "315ed740",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ProgressCB(Callback):\n",
    "    order = MetricsCB.order + 1\n",
    "    def __init__(self, plot=False):\n",
    "        self.plot = plot\n",
    "    \n",
    "    def before_fit(self, learn):\n",
    "        learn.epochs = self.mbar = master_bar(learn.epochs)\n",
    "        self.first = True\n",
    "        if hasattr(learn, 'metrics'):\n",
    "            learn.metrics._log = self._log\n",
    "        self.losses = []\n",
    "        self.val_losses = []\n",
    "    \n",
    "    def _log(self, d):\n",
    "        if self.first:\n",
    "            self.mbar.write(list(d), table=True)\n",
    "            self.first = False\n",
    "        self.mbar.write(list(d.values()), table=True)\n",
    "    \n",
    "    def before_epoch(self, learn):\n",
    "        learn.dl = progress_bar(learn.dl, leave=False, parent=self.mbar)\n",
    "    \n",
    "    def after_batch(self, learn):\n",
    "        learn.dl.comment = f'{learn.loss:.3f}'\n",
    "        if self.plot and hasattr(learn, 'metrics') and learn.training:\n",
    "            self.losses.append(learn.loss.item())\n",
    "            if self.val_losses:\n",
    "                self.mbar.update_graph([[fc.L.range(self.losses), self.losses],\\\n",
    "                [[fc.L.range(learn.epoch).map(lambda x: (x+1)*len(learn.dls.train)) ,self.val_losses]]])\n",
    "    \n",
    "    def after_epoch(self, learn):\n",
    "        if not learn.training:\n",
    "            if self.plot and hasattr(learn, 'metrics'):\n",
    "                self.val_losses.append(learn.metrics.all_metrics['loss'].compute())\n",
    "                self.mbar.update_graph([[fc.L.range(self.losses), self.losses],\\\n",
    "                        [fc.L.range(learn.epoch+1).map(lambda x: (x+1)*len(learn.dls.train)), self.val_losses]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 366,
   "id": "058aa6b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "learner = Learner(get_model(), copy(dls), lr=0.2,\\\n",
    "                  cbs=[TrainerCB(1), MetricsCB(accuracy=MulticlassAccuracy()), ProgressCB(plot=True)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "id": "01ea3fb4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>accuracy</th>\n",
       "      <th>loss</th>\n",
       "      <th>epoch</th>\n",
       "      <th>train</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0.592</td>\n",
       "      <td>1.180</td>\n",
       "      <td>0</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.711</td>\n",
       "      <td>0.781</td>\n",
       "      <td>0</td>\n",
       "      <td>eval</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learner.fit(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "id": "21707970",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TrainLearner(Learner):\n",
    "    def predict(self):\n",
    "        self.preds = self.model(self.batch[0])\n",
    "    \n",
    "    def get_loss(self):\n",
    "        self.loss = self.loss_func(self.preds, self.batch[1])\n",
    "    \n",
    "    def backward(self):\n",
    "        self.loss.backward()\n",
    "\n",
    "    def step(self):\n",
    "        self.opt.step()\n",
    "    \n",
    "    def zero_grad(self):\n",
    "        self.opt.zero_grad()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 380,
   "id": "ecc4375d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MomentumLearner(TrainLearner):\n",
    "    def __init__(self, model, dls, loss_func=None, lr=None, cbs=None, opt_func=optim.SGD, mom=0.85):\n",
    "        self.mom = mom\n",
    "        super().__init__(model, dls=dls, loss_func=loss_func, lr=lr, cbs=cbs, opt_func=opt_func)\n",
    "    \n",
    "    def zero_grad(self):\n",
    "        with torch.no_grad():\n",
    "            for p in self.model.parameters():\n",
    "                p.grad *= self.mom  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "id": "f6f03a49",
   "metadata": {},
   "outputs": [],
   "source": [
    "learner = MomentumLearner(get_model(), copy(dls), lr=0.1, loss_func=F.cross_entropy,\\\n",
    "                  cbs=[MetricsCB(accuracy=MulticlassAccuracy()), ProgressCB(plot=True)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 389,
   "id": "3066a253",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>accuracy</th>\n",
       "      <th>loss</th>\n",
       "      <th>epoch</th>\n",
       "      <th>train</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0.670</td>\n",
       "      <td>0.965</td>\n",
       "      <td>0</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.790</td>\n",
       "      <td>0.582</td>\n",
       "      <td>0</td>\n",
       "      <td>eval</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learner.fit(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 395,
   "id": "608459fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "class LRFinderCB(Callback):\n",
    "    def __init__(self, lr_mult=1.3):\n",
    "        fc.store_attr()\n",
    "    \n",
    "    def before_fit(self, learn):\n",
    "        self.lrs,self.losses = [],[]\n",
    "        self.min = math.inf\n",
    "    \n",
    "    def after_batch(self, learn):\n",
    "        if not learn.training:\n",
    "            raise CancelEpochException()\n",
    "        self.lrs.append(learn.opt.param_groups[0]['lr'])\n",
    "        loss = learn.loss\n",
    "        self.losses.append(loss.item())\n",
    "        if loss < self.min:\n",
    "            self.min = loss\n",
    "        if loss > self.min*3:\n",
    "            raise CancelFitException()\n",
    "        for g in learn.opt.param_groups:\n",
    "            g['lr'] *= self.lr_mult"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 398,
   "id": "53d22752",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "lrfinder = LRFinderCB()\n",
    "learner = MomentumLearner(get_model(), copy(dls), lr=1e-4, loss_func=F.cross_entropy,\\\n",
    "                  cbs=[MetricsCB(accuracy=MulticlassAccuracy()), lrfinder])\n",
    "learner.fit(1)\n",
    "plt.plot(lrfinder.lrs, lrfinder.losses)\n",
    "plt.xscale('log')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 401,
   "id": "2e819a3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.optim.lr_scheduler import ExponentialLR\n",
    "\n",
    "class LRFinderCB(Callback):\n",
    "    def __init__(self, gamma=1.3, max_mult=3):\n",
    "        fc.store_attr()\n",
    "    \n",
    "    def before_fit(self, learn):\n",
    "        self.sched = ExponentialLR(learn.opt, self.gamma)\n",
    "        self.lrs,self.losses = [],[]\n",
    "        self.min = math.inf\n",
    "        \n",
    "    def after_batch(self, learn):\n",
    "        if not learn.training:\n",
    "            raise CancelEpochException()\n",
    "        self.lrs.append(learn.opt.param_groups[0]['lr'])\n",
    "        loss = learn.loss.item()\n",
    "        self.losses.append(loss)\n",
    "        if loss < self.min:\n",
    "            self.min = loss\n",
    "        if math.isnan(loss) or (loss > self.min*self.max_mult):\n",
    "            raise CancelFitException()\n",
    "        self.sched.step()\n",
    "    \n",
    "    def cleanup_fit(self, learn):\n",
    "        plt.plot(self.lrs, self.losses)\n",
    "        plt.xscale('log')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 402,
   "id": "fb06151b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "lrfinder = LRFinderCB()\n",
    "learner = MomentumLearner(get_model(), copy(dls), lr=1e-4, loss_func=F.cross_entropy,\\\n",
    "                  cbs=[MetricsCB(accuracy=MulticlassAccuracy())])\n",
    "learner.fit(3, cbs=[lrfinder])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3dfdeea",
   "metadata": {},
   "outputs": [],
   "source": [
    "@fc.patch\n",
    "def lr_find(self:Learner, gamma=1.3, max_mult=3, start_lr=1e-5, max_epochs=10):\n",
    "    self.fit(max_epochs, lr=start_lr, cbs=LRFinderCB(gamma=gamma, max_mult=max_mult))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 403,
   "id": "0bf8da06",
   "metadata": {},
   "outputs": [],
   "source": [
    "fc.patch??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 404,
   "id": "353eda83",
   "metadata": {},
   "outputs": [],
   "source": [
    "@fc.patch\n",
    "def lr_find(self:Learner, gamma=1.3, max_mult=3, start_lr=1e-5, max_epochs=10):\n",
    "    self.fit(max_epochs, lr=start_lr, cbs=LRFinderCB(gamma=gamma, max_mult=max_mult))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "id": "ce8c78d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "MomentumLearner(get_model(), dls, F.cross_entropy, cbs=[]).lr_find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0b41339",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f5a9e41",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python_main",
   "language": "python",
   "name": "python_main"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}