draft.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader, random_split\n",
    "from torchvision import transforms\n",
    "import pytorch_lightning as pl\n",
    "from pytorch_lightning.metrics.functional import accuracy\n",
    "from torch.optim.lr_scheduler import LambdaLR, CosineAnnealingLR, OneCycleLR\n",
    "from pytorch_lightning.callbacks import LearningRateMonitor\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.vision.all import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "bs = 64\n",
    "epochs = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data(size, woof, bs, workers=None):\n",
    "    if   size<=128: path = URLs.IMAGEWOOF_160 if woof else URLs.IMAGENETTE_160\n",
    "    elif size<=224: path = URLs.IMAGEWOOF_320 if woof else URLs.IMAGENETTE_320\n",
    "    else          : path = URLs.IMAGEWOOF     if woof else URLs.IMAGENETTE\n",
    "    path = untar_data(path)\n",
    "\n",
    "    n_gpus = num_distrib() or 1\n",
    "    if workers is None: workers = min(8, num_cpus()//n_gpus)\n",
    "\n",
    "    return (ImageDataLoaders.from_folder(path, valid='val', \n",
    "                item_tfms=RandomResizedCrop(size, min_scale=0.35), batch_tfms=Normalize.from_stats(*imagenet_stats)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "dls = get_data(128, False, bs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = xresnet50(n_out=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConcatLR(torch.optim.lr_scheduler._LRScheduler):\n",
    "    def __init__(self, optimizer, scheduler1, scheduler2, total_steps, pct_start=0.5, last_epoch=-1):\n",
    "        self.scheduler1 = scheduler1\n",
    "        self.scheduler2 = scheduler2\n",
    "        self.step_start = float(pct_start * total_steps) - 1\n",
    "        super(ConcatLR, self).__init__(optimizer, last_epoch)\n",
    "    \n",
    "    def step(self):\n",
    "        if self.last_epoch <= self.step_start:\n",
    "            self.scheduler1.step()\n",
    "        else:\n",
    "            self.scheduler2.step()\n",
    "        super().step()\n",
    "        \n",
    "    def get_lr(self):\n",
    "        if self.last_epoch <= self.step_start:\n",
    "            return self.scheduler1.get_lr()\n",
    "        else:\n",
    "            return self.scheduler2.get_lr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "sched_type = 'flat_and_anneal'\n",
    "sched_type = 'one'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_steps=len(dls[0])*epochs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LModel(pl.LightningModule):\n",
    "    def __init__(self, model, sched_type, total_steps):\n",
    "        super(LModel, self).__init__()\n",
    "        self.model = model\n",
    "        self.sched_type = sched_type\n",
    "        self.total_steps = total_steps\n",
    "        self.loss_func = LabelSmoothingCrossEntropy()\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.model(x)\n",
    "\n",
    "    def training_step(self, batch, batch_nb):\n",
    "        x, y = batch\n",
    "        pred = self(x)\n",
    "        loss = self.loss_func(pred, y)\n",
    "        return loss\n",
    "\n",
    "    def validation_step(self, batch, batch_nb):\n",
    "        x, y = batch\n",
    "        pred = self(x)\n",
    "        loss = self.loss_func(pred, y)\n",
    "        acc = accuracy(pred, y)\n",
    "        return {'val_loss': loss, 'acc': acc}\n",
    "\n",
    "    def validation_epoch_end(self, outputs):\n",
    "        avg_loss = torch.stack([x['val_loss'] for x in outputs]).mean()\n",
    "        avg_acc = torch.stack([x['acc'] for x in outputs]).mean()\n",
    "        self.result = {'avg_val_loss': avg_loss, 'avg_acc': avg_acc}\n",
    "        print(self.result)\n",
    "        return self.result\n",
    "    \n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.Adam(self.parameters(), lr=3e-4, betas=(0.9,0.99), eps=1e-06)\n",
    "        if sched_type == 'flat_and_anneal':\n",
    "            dummy = LambdaLR(optimizer, d)\n",
    "            cosine = CosineAnnealingLR(optimizer, self.total_steps*0.5)\n",
    "            scheduler = ConcatLR(optimizer, dummy, cosine, self.total_steps, 0.5)\n",
    "        else:\n",
    "            scheduler = OneCycleLR(optimizer, max_lr=3e-3, total_steps=self.total_steps, pct_start=0.3,\n",
    "                                                            div_factor=10, cycle_momentum=True)        \n",
    "        meta_sched = {\n",
    "         'scheduler': scheduler,\n",
    "         'interval': 'step',\n",
    "         'frequency': 1\n",
    "        }  \n",
    "        return [optimizer], [meta_sched]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True, used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    }
   ],
   "source": [
    "lmodel = LModel(m, sched_type, total_steps)\n",
    "lr_monitor = LearningRateMonitor(logging_interval='step')\n",
    "trainer = pl.Trainer(gpus=1, max_epochs=epochs, callbacks=[lr_monitor])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "  | Name      | Type                       | Params\n",
      "---------------------------------------------------------\n",
      "0 | model     | XResNet                    | 23 M  \n",
      "1 | loss_func | LabelSmoothingCrossEntropy | 0     \n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validation sanity check'), FloatProgress(value=1.0, bar_style='info', layout=Layout…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'avg_val_loss': tensor(1.1113, device='cuda:0'), 'avg_acc': tensor(0.7344, device='cuda:0')}\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "72ea272323de4694a36c07f0e41fd2fe",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), m…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'avg_val_loss': tensor(1.3162, device='cuda:0'), 'avg_acc': tensor(0.6809, device='cuda:0')}\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), m…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'avg_val_loss': tensor(1.3942, device='cuda:0'), 'avg_acc': tensor(0.6338, device='cuda:0')}\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), m…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'avg_val_loss': tensor(1.1130, device='cuda:0'), 'avg_acc': tensor(0.7573, device='cuda:0')}\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), m…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'avg_val_loss': tensor(0.9764, device='cuda:0'), 'avg_acc': tensor(0.8178, device='cuda:0')}\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), m…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'avg_val_loss': tensor(0.9415, device='cuda:0'), 'avg_acc': tensor(0.8304, device='cuda:0')}\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainer.fit(lmodel, dls[0], dls[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(lr_monitor.lrs['lr-Adam'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.8304, device='cuda:0')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lmodel.result['avg_acc']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:over9000]",
   "language": "python",
   "name": "conda-env-over9000-py"
  },
  "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.8.6"
  },
  "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
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}