dev/19_callback_mixup.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#default_exp callback.mixup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from fastai2.test import *\n",
    "from fastai2.basics import *\n",
    "from fastai2.callback.progress import *\n",
    "from fastai2.vision.core import *\n",
    "\n",
    "from torch.distributions.beta import Beta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nbdev.showdoc import *\n",
    "from fastai2.test_utils import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mixup callback\n",
    "\n",
    "> Callback to apply MixUp data augmentation to your training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MixupCallback -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def reduce_loss(loss, reduction='mean'):\n",
    "    return loss.mean() if reduction=='mean' else loss.sum() if reduction=='sum' else loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class MixUp(Callback):\n",
    "    run_after=[Normalize, Cuda]\n",
    "    def __init__(self, alpha=0.4): self.distrib = Beta(tensor(alpha), tensor(alpha))\n",
    "    def begin_fit(self): \n",
    "        self.stack_y = getattr(self.learn.loss_func, 'y_int', False)\n",
    "        if self.stack_y: self.old_lf,self.learn.loss_func = self.learn.loss_func,self.lf\n",
    "            \n",
    "    def after_fit(self): \n",
    "        if self.stack_y: self.learn.loss_func = self.old_lf\n",
    "\n",
    "    def begin_batch(self):\n",
    "        if not self.training: return\n",
    "        lam = self.distrib.sample((self.y.size(0),)).squeeze().to(self.x.device)\n",
    "        lam = torch.stack([lam, 1-lam], 1)\n",
    "        self.lam = lam.max(1)[0]\n",
    "        shuffle = torch.randperm(self.y.size(0)).to(self.x.device)\n",
    "        xb1,self.yb1 = tuple(L(self.xb).itemgot(shuffle)),tuple(L(self.yb).itemgot(shuffle))\n",
    "        nx_dims = len(self.x.size())\n",
    "        self.learn.xb = tuple(L(xb1,self.xb).map_zip(torch.lerp,weight=unsqueeze(self.lam, n=nx_dims-1)))\n",
    "        if not self.stack_y: \n",
    "            ny_dims = len(self.y.size())\n",
    "            self.learn.yb = tuple(L(self.yb1,self.yb).map_zip(torch.lerp,weight=unsqueeze(self.lam, n=ny_dims-1)))\n",
    "\n",
    "    def lf(self, pred, *yb):\n",
    "        if not self.training: return self.old_lf(pred, *yb)\n",
    "        with NoneReduce(self.old_lf) as lf:\n",
    "            loss = torch.lerp(lf(pred,*self.yb1), lf(pred,*yb), self.lam)\n",
    "        return reduce_loss(loss, getattr(self.old_lf, 'reduction', 'mean'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai2.vision.core import *\n",
    "\n",
    "path = untar_data(URLs.MNIST_TINY)\n",
    "items = get_image_files(path)\n",
    "tds = DataSource(items, [PILImageBW.create, [parent_label, Categorize()]], splits=GrandparentSplitter()(items))\n",
    "dbunch = tds.databunch(after_item=[ToTensor(), IntToFloatTensor()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\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-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='0' class='' max='1', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      \n",
       "    </div>\n",
       "    \n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mixup = MixUp(0.5)\n",
    "learn = Learner(dbunch, nn.Linear(3,4), loss_func=CrossEntropyLossFlat(), cbs=mixup)\n",
    "learn._do_begin_fit(1)\n",
    "learn.epoch,learn.training = 0,True\n",
    "learn.dl = dbunch.train_dl\n",
    "b = dbunch.one_batch()\n",
    "learn._split(b)\n",
    "learn('begin_batch')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x648 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_,axs = plt.subplots(3,3, figsize=(9,9))\n",
    "dbunch.show_batch(b=(mixup.x,mixup.y), ctxs=axs.flatten())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 00_test.ipynb.\n",
      "Converted 01_core.ipynb.\n",
      "Converted 01a_utils.ipynb.\n",
      "Converted 01b_dispatch.ipynb.\n",
      "Converted 01c_transform.ipynb.\n",
      "Converted 02_script.ipynb.\n",
      "Converted 03_torch_core.ipynb.\n",
      "Converted 03a_layers.ipynb.\n",
      "Converted 04_dataloader.ipynb.\n",
      "Converted 05_data_core.ipynb.\n",
      "Converted 06_data_transforms.ipynb.\n",
      "Converted 07_data_block.ipynb.\n",
      "Converted 08_vision_core.ipynb.\n",
      "Converted 09_vision_augment.ipynb.\n",
      "Converted 09a_vision_data.ipynb.\n",
      "Converted 10_pets_tutorial.ipynb.\n",
      "Converted 11_vision_models_xresnet.ipynb.\n",
      "Converted 12_optimizer.ipynb.\n",
      "Converted 13_learner.ipynb.\n",
      "Converted 13a_metrics.ipynb.\n",
      "Converted 14_callback_schedule.ipynb.\n",
      "Converted 14a_callback_data.ipynb.\n",
      "Converted 15_callback_hook.ipynb.\n",
      "Converted 15a_vision_models_unet.ipynb.\n",
      "Converted 16_callback_progress.ipynb.\n",
      "Converted 17_callback_tracker.ipynb.\n",
      "Converted 18_callback_fp16.ipynb.\n",
      "Converted 19_callback_mixup.ipynb.\n",
      "Converted 20_interpret.ipynb.\n",
      "Converted 21_vision_learner.ipynb.\n",
      "Converted 22_tutorial_imagenette.ipynb.\n",
      "Converted 23_tutorial_transfer_learning.ipynb.\n",
      "Converted 30_text_core.ipynb.\n",
      "Converted 31_text_data.ipynb.\n",
      "Converted 32_text_models_awdlstm.ipynb.\n",
      "Converted 33_text_models_core.ipynb.\n",
      "Converted 34_callback_rnn.ipynb.\n",
      "Converted 35_tutorial_wikitext.ipynb.\n",
      "Converted 36_text_models_qrnn.ipynb.\n",
      "Converted 37_text_learner.ipynb.\n",
      "Converted 38_tutorial_ulmfit.ipynb.\n",
      "Converted 40_tabular_core.ipynb.\n",
      "Converted 41_tabular_model.ipynb.\n",
      "Converted 42_tabular_rapids.ipynb.\n",
      "Converted 50_data_block_examples.ipynb.\n",
      "Converted 60_medical_imaging.ipynb.\n",
      "Converted 65_medical_text.ipynb.\n",
      "Converted 90_notebook_core.ipynb.\n",
      "Converted 91_notebook_export.ipynb.\n",
      "Converted 92_notebook_showdoc.ipynb.\n",
      "Converted 93_notebook_export2html.ipynb.\n",
      "Converted 94_notebook_test.ipynb.\n",
      "Converted 95_index.ipynb.\n",
      "Converted 96_data_external.ipynb.\n",
      "Converted 97_utils_test.ipynb.\n",
      "Converted notebook2jekyll.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#hide\n",
    "from nbdev.export import notebook2script\n",
    "notebook2script()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}