nbs/dl2/09b_learner.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Let's kill off `Runner`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from exp.nb_09 import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "exp.nb_04.AvgStats"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AvgStats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imagenette data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Jump_to lesson 11 video](https://course19.fast.ai/videos/?lesson=11&t=6571)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = datasets.untar_data(datasets.URLs.IMAGENETTE_160)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfms = [make_rgb, ResizeFixed(128), to_byte_tensor, to_float_tensor]\n",
    "bs=64\n",
    "\n",
    "il = ImageList.from_files(path, tfms=tfms)\n",
    "sd = SplitData.split_by_func(il, partial(grandparent_splitter, valid_name='val'))\n",
    "ll = label_by_func(sd, parent_labeler, proc_y=CategoryProcessor())\n",
    "data = ll.to_databunch(bs, c_in=3, c_out=10, num_workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cbfs = [partial(AvgStatsCallback,accuracy),\n",
    "        CudaCallback,\n",
    "        partial(BatchTransformXCallback, norm_imagenette)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nfs = [32]*4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having a Runner is great but not essential when the `Learner` already has everything needed in its state. We implement everything inside it directly instead of building a second object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### In Lesson 12 Jeremy Howard revisited material in the cell below  [Jump_to lesson 12 video](https://course19.fast.ai/videos/?lesson=12&t=65)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def param_getter(m): return m.parameters()\n",
    "\n",
    "class Learner():\n",
    "    def __init__(self, model, data, loss_func, opt_func=sgd_opt, lr=1e-2, splitter=param_getter,\n",
    "                 cbs=None, cb_funcs=None):\n",
    "        self.model,self.data,self.loss_func,self.opt_func,self.lr,self.splitter = model,data,loss_func,opt_func,lr,splitter\n",
    "        self.in_train,self.logger,self.opt = False,print,None\n",
    "        \n",
    "        # NB: Things marked \"NEW\" are covered in lesson 12\n",
    "        # NEW: avoid need for set_runner\n",
    "        self.cbs = []\n",
    "        self.add_cb(TrainEvalCallback())\n",
    "        self.add_cbs(cbs)\n",
    "        self.add_cbs(cbf() for cbf in listify(cb_funcs))\n",
    "\n",
    "    def add_cbs(self, cbs):\n",
    "        for cb in listify(cbs): self.add_cb(cb)\n",
    "            \n",
    "    def add_cb(self, cb):\n",
    "        cb.set_runner(self)\n",
    "        setattr(self, cb.name, cb)\n",
    "        self.cbs.append(cb)\n",
    "\n",
    "    def remove_cbs(self, cbs):\n",
    "        for cb in listify(cbs): self.cbs.remove(cb)\n",
    "            \n",
    "    def one_batch(self, i, xb, yb):\n",
    "        try:\n",
    "            self.iter = i\n",
    "            self.xb,self.yb = xb,yb;                        self('begin_batch')\n",
    "            self.pred = self.model(self.xb);                self('after_pred')\n",
    "            self.loss = self.loss_func(self.pred, self.yb); self('after_loss')\n",
    "            if not self.in_train: return\n",
    "            self.loss.backward();                           self('after_backward')\n",
    "            self.opt.step();                                self('after_step')\n",
    "            self.opt.zero_grad()\n",
    "        except CancelBatchException:                        self('after_cancel_batch')\n",
    "        finally:                                            self('after_batch')\n",
    "\n",
    "    def all_batches(self):\n",
    "        self.iters = len(self.dl)\n",
    "        try:\n",
    "            for i,(xb,yb) in enumerate(self.dl): self.one_batch(i, xb, yb)\n",
    "        except CancelEpochException: self('after_cancel_epoch')\n",
    "\n",
    "    def do_begin_fit(self, epochs):\n",
    "        self.epochs,self.loss = epochs,tensor(0.)\n",
    "        self('begin_fit')\n",
    "\n",
    "    def do_begin_epoch(self, epoch):\n",
    "        self.epoch,self.dl = epoch,self.data.train_dl\n",
    "        return self('begin_epoch')\n",
    "\n",
    "    def fit(self, epochs, cbs=None, reset_opt=False):\n",
    "        # NEW: pass callbacks to fit() and have them removed when done\n",
    "        self.add_cbs(cbs)\n",
    "        # NEW: create optimizer on fit(), optionally replacing existing\n",
    "        if reset_opt or not self.opt: self.opt = self.opt_func(self.splitter(self.model), lr=self.lr)\n",
    "            \n",
    "        try:\n",
    "            self.do_begin_fit(epochs)\n",
    "            for epoch in range(epochs):\n",
    "                if not self.do_begin_epoch(epoch): self.all_batches()\n",
    "\n",
    "                with torch.no_grad(): \n",
    "                    self.dl = self.data.valid_dl\n",
    "                    if not self('begin_validate'): self.all_batches()\n",
    "                self('after_epoch')\n",
    "            \n",
    "        except CancelTrainException: self('after_cancel_train')\n",
    "        finally:\n",
    "            self('after_fit')\n",
    "            self.remove_cbs(cbs)\n",
    "\n",
    "    ALL_CBS = {'begin_batch', 'after_pred', 'after_loss', 'after_backward', 'after_step',\n",
    "        'after_cancel_batch', 'after_batch', 'after_cancel_epoch', 'begin_fit',\n",
    "        'begin_epoch', 'begin_validate', 'after_epoch',\n",
    "        'after_cancel_train', 'after_fit'}\n",
    "    \n",
    "    def __call__(self, cb_name):\n",
    "        res = False\n",
    "        assert cb_name in self.ALL_CBS\n",
    "        for cb in sorted(self.cbs, key=lambda x: x._order): res = cb(cb_name) and res\n",
    "        return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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",
    "        #We use the logger function of the `Learner` here, it can be customized to write in a file or in a progress bar\n",
    "        self.logger(self.train_stats)\n",
    "        self.logger(self.valid_stats) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cbfs = [partial(AvgStatsCallback,accuracy),\n",
    "        CudaCallback,\n",
    "        partial(BatchTransformXCallback, norm_imagenette)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def get_learner(nfs, data, lr, layer, loss_func=F.cross_entropy,\n",
    "                cb_funcs=None, opt_func=sgd_opt, **kwargs):\n",
    "    model = get_cnn_model(data, nfs, layer, **kwargs)\n",
    "    init_cnn(model)\n",
    "    return Learner(model, data, loss_func, lr=lr, cb_funcs=cb_funcs, opt_func=opt_func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = get_learner(nfs, data, 0.4, conv_layer, cb_funcs=cbfs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train: [1.8311652646095082, tensor(0.3570, device='cuda:0')]\n",
      "valid: [1.5547332763671875, tensor(0.4880, device='cuda:0')]\n",
      "CPU times: user 4.05 s, sys: 1.93 s, total: 5.98 s\n",
      "Wall time: 18 s\n"
     ]
    }
   ],
   "source": [
    "%time learn.fit(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check everything works"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check our previous callbacks still work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cbfs += [Recorder]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = get_learner(nfs, data, 0.4, conv_layer, cb_funcs=cbfs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phases = combine_scheds([0.3, 0.7], cos_1cycle_anneal(0.2, 0.6, 0.2))\n",
    "sched = ParamScheduler('lr', phases)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train: [1.8860618007891268, tensor(0.3378, device='cuda:0')]\n",
      "valid: [1.775871337890625, tensor(0.3620, device='cuda:0')]\n"
     ]
    }
   ],
   "source": [
    "learn.fit(1, sched)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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": [
    "learn.recorder.plot_lr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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": [
    "learn.recorder.plot_loss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!./notebook2script.py 09b_learner.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}