05b_early_stopping.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Building a LR finder in this nb. To do that we create a testcallback's idea. The problem is that it wasn't working and to actually stop training you'd need to return False(meaning cancel) for every callback or add something that checks for self.stop in lots of places which would be a real pain and wouldn't be flexible enough. SO Jeremy suggest to use the idea of exceptions as a kind of control flow. Besides handling errors, Exceptions are a versatile way of writing vey neat code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from exp.nb_05 import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EarlyStopping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Better callback cancelation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, y_train, x_valid, y_valid = get_data()\n",
    "train_ds, valid_ds = Dataset(x_train, y_train), Dataset(x_valid, y_valid)\n",
    "nh, bs = 50, 512\n",
    "c = y_train.max().item() + 1\n",
    "loss_func = F.cross_entropy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = DataBunch(*get_dls(train_ds, valid_ds, bs), c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export \n",
    "class Callback():\n",
    "    _order = 0\n",
    "    def set_runner(self, run): self.run = run\n",
    "    def __getattr__(self, k): return getattr(self.run, k)\n",
    "    \n",
    "    @property\n",
    "    def name(self):\n",
    "        name = re.sub(r'Callback$', '', self.__class__.__name__)\n",
    "        return camel2snake(name or 'callback')\n",
    "    \n",
    "    # makes more sense to add this function below in the Callback class rather than the runner class.\n",
    "    def __call__(self, cb_name):\n",
    "        f = getattr(self, cb_name, None)\n",
    "        if f and f(): return True\n",
    "        return False\n",
    "    \n",
    "class TrainEvalCallback(Callback):\n",
    "    def begin_fit(self):\n",
    "        self.run.n_epochs = 0.\n",
    "        self.run.n_iter = 0\n",
    "        \n",
    "    def after_batch(self):\n",
    "        if not self.in_train:return\n",
    "        self.run.n_epochs += 1./self.iters\n",
    "        self.run.n_iter += 1\n",
    "    \n",
    "    def begin_epoch(self):\n",
    "        self.run.n_epochs = self.epoch\n",
    "        self.model.train()\n",
    "        self.run.in_train = True\n",
    "        \n",
    "    def begin_validate(self):\n",
    "        self.model.eval()\n",
    "        self.run.in_train = False\n",
    "        \n",
    "class CancelTrainException(Exception): pass\n",
    "class CancelEpochException(Exception): pass\n",
    "class CancelBatchException(Exception): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class Runner():\n",
    "    def __init__(self, cbs=None, cb_funcs= None):\n",
    "            cbs = listify(cbs)\n",
    "            for cbf in listify(cb_funcs):\n",
    "                cb = cbf()\n",
    "                setattr(self, cb.name, cb)\n",
    "                cbs.append(cb)\n",
    "            self.stop, self.cbs = False, [TrainEvalCallback()]+ cbs\n",
    "                \n",
    "    @property\n",
    "    def opt(self): return self.learn.opt\n",
    "    @property\n",
    "    def model(self): return self.learn.model\n",
    "    @property\n",
    "    def loss_func(self): return self.learn.loss_func\n",
    "    @property\n",
    "    def data(self): return self.learn.data\n",
    "    \n",
    "    def one_batch(self, xb, yb):\n",
    "        try:\n",
    "            self.xb, self.yb = xb, yb\n",
    "            if self('begin_batch'): return\n",
    "            self.pred = self.model(self.xb)\n",
    "            if self('after_pred'): return\n",
    "            self.loss = self.loss_func(self.pred, self.yb)\n",
    "            if self('after_loss') or not self.in_train: return\n",
    "            self.loss.backward()\n",
    "            if self('after_backward'): return\n",
    "            self.opt.step()\n",
    "            if self('after_step'): return\n",
    "            self.opt.zero_grad()\n",
    "        except CancelBatchException: self('after_cancel_batch')\n",
    "        finally: self('after_batch')\n",
    "        \n",
    "    def all_batches(self, dl):\n",
    "        self.iters = len(dl)\n",
    "        try:\n",
    "            for xb, yb in dl:self.one_batch(xb, yb)\n",
    "        except CancelEpochException: self('after_cancel_epoch')\n",
    "\n",
    "    def fit(self, epochs, learn):\n",
    "        self.epochs, self.learn = epochs, learn\n",
    "        try:\n",
    "            for cb in self.cbs: cb.set_runner(self)\n",
    "            if self('begin_fit'): return\n",
    "            for epoch in range(epochs):\n",
    "                self.epoch = epoch\n",
    "                if not self('begin_epoch'): self.all_batches(self.data.train_dl)\n",
    "                    \n",
    "                with torch.no_grad():\n",
    "                    if not self('begin_validate'): self.all_batches(self.data.valid_dl)\n",
    "                if self('after_epoch'): break\n",
    "                \n",
    "        except CancelTrainException: self('after_cancel_train')\n",
    "        finally:\n",
    "            self('after_fit')\n",
    "            self.learn = None\n",
    "    def __call__(self, cb_name):\n",
    "        res = False\n",
    "        for cb in sorted(self.cbs, key=lambda x: x._order):res = cb(cb_name) or res\n",
    "        #print(cb(cb_name), res)\n",
    "        return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = create_learner(get_model, loss_func, data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TestCallback(Callback):\n",
    "    _order = 1\n",
    "    def after_step(self):\n",
    "        print(self.n_iter)\n",
    "        if self.n_iter>=10:raise CancelTrainException()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "run = Runner(cb_funcs=TestCallback)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "run.fit(10, learn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now it workks yay!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other callbacks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class AvgStatsCallback(Callback):\n",
    "    def __init__(self, metrics):\n",
    "        self.train_stats, self.valid_stats = AvgStats(metrics, True), AvgStats(metrics, False)\n",
    "        \n",
    "    def begin_epoch(self):\n",
    "        self.train_stats.reset()\n",
    "        self.valid_stats.reset()\n",
    "        \n",
    "    def after_loss(self):\n",
    "        stats = self.train_stats if self.in_train else self.valid_stats\n",
    "        with torch.no_grad(): stats.accumulate(self.run)\n",
    "            \n",
    "    def after_epoch(self):\n",
    "        print(self.train_stats)\n",
    "        print(self.valid_stats)\n",
    "    \n",
    "class Recorder(Callback):\n",
    "    def begin_fit(self):\n",
    "        self.lrs=[[] for _ in self.opt.param_groups]\n",
    "        self.losses = []\n",
    "        \n",
    "    def after_batch(self):\n",
    "        if not self.in_train: return\n",
    "        for pg, lr in zip(self.opt.param_groups, self.lrs): lr.append([pg['lr']])\n",
    "        self.losses.append(self.loss.detach().cpu())\n",
    "        \n",
    "    def plot_lr(self, pgid=-1): plt.plot(self.lrs[pgid])\n",
    "    def plot_loss(self, skip_last=0): plt.plot(self.losses[:len(self.losses)-skip_last])\n",
    "    \n",
    "    def plot(self, skip_last=0, pgid=-1):\n",
    "        losses = [o.item() for o in self.losses]\n",
    "        lrs = self.lrs[pgid]\n",
    "        n = len(losses)- skip_last\n",
    "        plt.xscale('log')\n",
    "        plt.plot(lrs[:n], losses[:n])\n",
    "        \n",
    "class ParamScheduler(Callback):\n",
    "    _order=1\n",
    "    def __init__(self, pname, sched_funcs): self.pname, self.sched_funcs = pname, sched_funcs\n",
    "        \n",
    "    def begin_fit(self):\n",
    "        if not isinstance(self.sched_funcs, (list,tuple)):\n",
    "            self.sched_funcs = [self.sched_funcs] * len(self.opt.param_groups)\n",
    "            \n",
    "    def set_param(self):\n",
    "        assert len(self.opt.param_groups)==len(self.sched_funcs)\n",
    "        for pg, f in zip(self.opt.param_groups, self.sched_funcs):\n",
    "            pg[self.pname] = f(self.n_epochs/self.epochs)\n",
    "            \n",
    "    def begin_batch(self):\n",
    "        if self.in_train: self.set_param()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LR Finder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NB: You may want to also add something that saves the model before running this, and loads it back after running - otherwise you'll lose your weights!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "class lr_find(Callback):\n",
    "    _order=1\n",
    "    def __init__(self, max_iter=100, min_lr=1e-6, max_lr=10):\n",
    "        self.max_iter, self.min_lr, self.max_lr = max_iter, min_lr, max_lr\n",
    "        self.best_loss=100\n",
    "        \n",
    "    def begin_batch(self):\n",
    "        if not self.in_train: return\n",
    "        pos = self.n_iter/self.max_iter\n",
    "        lr = self.min_lr * (self.max_lr/self.min_lr) ** pos\n",
    "        for pg in self.opt.param_groups: pg['lr'] = lr\n",
    "    \n",
    "    def after_step(self):\n",
    "        if self.n_iter>=self.max_iter or self.loss> self.best_loss*10:\n",
    "            raise CancelTrainException()\n",
    "        if self.loss < self.best_loss: self.best_loss = self.loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NB: In fastai we also use exponential smoothing on the loss. For that reason we check for `best_loss*3` instead of `best_loss*10`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = create_learner(get_model, loss_func, data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "run = Runner(cb_funcs=[lr_find, Recorder])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "run.fit(2, learn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "run.recorder.plot(skip_last=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "run.recorder.plot(skip_last=23)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "run.recorder.plot_lr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 05b_early_stopping.ipynb to exp\\nb_05b.py\n"
     ]
    }
   ],
   "source": [
    "!python notebook2script.py 05b_early_stopping.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}