20_subcoco_lightning_utils.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default_exp subcoco_lightning_utils\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pytorch Lightning Specific Utilities\n",
    "\n",
    "Extracted common utilities for all Pytorch Lightning related data loading stuff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python ver 3.8.5 (default, Jul 28 2020, 12:59:40) \n",
      "[GCC 9.3.0], torch 1.7.0, torchvision 0.8.1, pytorch_lightning 1.0.4, Albumentation 0.5.0\n"
     ]
    }
   ],
   "source": [
    "#export\n",
    "import cv2, json, os, requests, sys, tarfile\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as mcolors\n",
    "import numpy as np\n",
    "import pickle\n",
    "import random\n",
    "\n",
    "import albumentations as A\n",
    "import pytorch_lightning as pl\n",
    "import torch, torchvision\n",
    "import torch.nn.functional as F\n",
    "import torch.multiprocessing\n",
    "\n",
    "from collections import defaultdict\n",
    "from functools import reduce\n",
    "from gpumonitor.monitor import GPUStatMonitor\n",
    "from gpumonitor.callbacks.lightning import PyTorchGpuMonitorCallback\n",
    "from IPython.utils import io\n",
    "from pathlib import Path\n",
    "from PIL import Image\n",
    "from PIL import ImageStat\n",
    "\n",
    "from pycocotools.coco import COCO\n",
    "from pycocotools.cocoeval import COCOeval\n",
    "from pytorch_lightning.callbacks import ModelCheckpoint, EarlyStopping\n",
    "from pytorch_lightning import LightningDataModule, LightningModule, Trainer\n",
    "from pytorch_lightning.core.step_result import TrainResult\n",
    "\n",
    "from tqdm import tqdm\n",
    "from typing import Hashable, List, Tuple, Union, Iterable\n",
    "\n",
    "from torch import nn\n",
    "from torch.nn import Module\n",
    "from torch import optim\n",
    "from torch.utils.data import DataLoader, random_split\n",
    "\n",
    "from torchvision import transforms\n",
    "\n",
    "from albumentations.pytorch import ToTensorV2\n",
    "from pytorch_lightning import LightningDataModule, LightningModule\n",
    "from mcbbox.subcoco_utils import *\n",
    "\n",
    "print(f\"Python ver {sys.version}, torch {torch.__version__}, torchvision {torchvision.__version__}, pytorch_lightning {pl.__version__}, Albumentation {A.__version__}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/brian/.local/lib/python3.8/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
      "  and should_run_async(code)\n"
     ]
    }
   ],
   "source": [
    "#hide\n",
    "img_sz, bs, acc, workers, head_runs, full_runs = 128, 4, 8, 1, 1, 1\n",
    "datadir, url, img_subdir = '/tmp', 'http://files.fast.ai/data/examples/coco_tiny.tgz', 'train'\n",
    "stem = Path(url).stem\n",
    "img_dir=f'{datadir}/{stem}/{img_subdir}'\n",
    "train_json = fetch_subcoco(datadir=datadir, url=url, img_subdir=img_subdir)\n",
    "stats = load_stats(train_json, img_dir=img_dir, force_reload=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wrap Data Loading Logic using Pytorch-Lightning\n",
    "\n",
    "In order to use Pytorch Lightning to load data, we need to define a DataModule to encapsulate all the data loading logic. At first I thought I can reuse CocoDetect() from torchvision but it uses cocoapi downstream and expects json annotation file to be of this [format](https://cocodataset.org/#format-data):\n",
    "```\n",
    "annotation{\n",
    "    \"id\": int,\n",
    "    \"image_id\": int,\n",
    "    \"category_id\": int,\n",
    "    \"segmentation\": RLE or [polygon],\n",
    "    \"area\": float,\n",
    "    \"bbox\": [x,y,width,height],\n",
    "    \"iscrowd\": 0 or 1,\n",
    "}\n",
    "```\n",
    "\n",
    "Tiny and Sample Coco's train.json file only has a subset of the above fields:\n",
    "```\n",
    "“Annotations”: [\n",
    "    {\n",
    "      \"image_id\": 542959,\n",
    "      \"bbox\": [\n",
    "        32.52,\n",
    "        86.34,\n",
    "        8.53,\n",
    "        9.41\n",
    "      ],\n",
    "      \"category_id\": 62\n",
    "    },\n",
    "    ...\n",
    "]\n",
    "``` \n",
    "\n",
    "Thus we will need to make a Dataset to handle it properly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class SubCocoDataset(torchvision.datasets.VisionDataset):\n",
    "    \"\"\"\n",
    "    Simulate what torchvision.CocoDetect() returns for target given fastai's coco subsets\n",
    "    Args:\n",
    "        root (string): Root directory where images are downloaded to.\n",
    "        stats (CocoDatasetStats):\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, root:str, stats:CocoDatasetStats, img_ids:list=[], \n",
    "                 bbox_aware_tfms:callable=None, safe_box_margin:float=0.0, safe_box_size:float=0.0):\n",
    "        super(SubCocoDataset, self).__init__(root) \n",
    "        self.stats = stats\n",
    "        self.img_ids = []\n",
    "        n_missing = 0\n",
    "        for img_id in img_ids:\n",
    "            img_fname = stats.img2fname[img_id]\n",
    "            if not os.path.isfile(stats.img_dir/img_fname):\n",
    "                n_missing += 1\n",
    "            elif stats.img2sz.get(img_id, None) is None:\n",
    "                n_missing += 1\n",
    "            elif safe_box_size <= 0.0 and safe_box_margin <= 0.0:\n",
    "                self.img_ids.append(img_id)\n",
    "            else:\n",
    "                img_w, img_h = stats.img2sz[img_id]\n",
    "                l2bs = stats.img2l2bs[img_id]\n",
    "                safe_l2bs = {}\n",
    "                for l, bs in l2bs.items():\n",
    "                    safe_bs = []\n",
    "                    for bx, by, bw, bh in bs:\n",
    "                        if box_within_bounds(bx, by, bw, bh, img_w, img_h, safe_box_margin, safe_box_size):\n",
    "                            safe_bs.append((bx, by, bw, bh))\n",
    "                    if len(safe_bs) > 0:\n",
    "                        safe_l2bs[l] = safe_bs\n",
    "                if len(safe_l2bs) <= 0:\n",
    "                    n_missing += 1\n",
    "                else:\n",
    "                    stats.img2l2bs[img_id] = safe_l2bs\n",
    "                    self.img_ids.append(img_id)\n",
    "                    \n",
    "        if n_missing > 0 : print(f'Warning: {n_missing} out of {len(img_ids)} image files are missing or have unsafe boxes!!!')\n",
    "        self.bbox_aware_tfms = bbox_aware_tfms\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            index (int): Index\n",
    "        Returns:\n",
    "            tuple: Tuple (image, target). target is the object returned by ``coco.loadAnns``.\n",
    "        \"\"\"\n",
    "        img_id = self.img_ids[index] if index < len(self.img_ids) else 0\n",
    "        img_fname = self.stats.img2fname.get(img_id, None)\n",
    "        if img_id is None or img_fname ==None:\n",
    "            return (None, None)\n",
    "        img_fpath = os.path.join(self.root, img_fname)\n",
    "        img_w, img_h = self.stats.img2sz.get(img_id, (1,1))\n",
    "        target = { 'boxes': [], 'labels': [], 'image_id': img_id, 'width': img_h, 'height': img_h, 'areas': [], 'iscrowds': 0, 'ids': [] }\n",
    "        count = 0\n",
    "        lbs = self.stats.img2lbs.get(img_id,[])\n",
    "        for l, x, y, w, h in lbs:\n",
    "            count += 1\n",
    "            target['boxes'].append([x, y, x+w, y+h]) # FRCNN and RetNet wants x1,y1,x2,y2 format!\n",
    "            target['labels'].append(l)\n",
    "            target['areas'].append(w*h)\n",
    "            anno_id = img_id*1000 + count\n",
    "            target['ids'].append(anno_id)\n",
    "\n",
    "        img = cv2.imread(img_fpath)\n",
    "        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "\n",
    "        if self.bbox_aware_tfms is not None:\n",
    "            transformed = self.bbox_aware_tfms(image=img, bboxes=target['boxes'], class_labels=target['labels'])\n",
    "            img = transformed['image']\n",
    "            target['boxes'] = transformed['bboxes']\n",
    "            target['labels'] = transformed['class_labels']\n",
    "\n",
    "        for k, v in target.items():\n",
    "            target[k] = torch.tensor(v, dtype=(torch.float if k in ['boxes', 'width', 'height', 'areas'] else torch.long))\n",
    "        \n",
    "        img = torch.from_numpy(img/255.0).float().permute(2, 0, 1)\n",
    "        return img, target\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.img_ids)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test w/o Augmentations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "img =\n",
      "tensor([[[0.9765, 0.9451, 0.9373,  ..., 0.9373, 0.9647, 0.8980],\n",
      "         [0.9451, 0.9373, 0.9098,  ..., 0.9216, 0.9255, 0.9255],\n",
      "         [0.9098, 0.9725, 0.9373,  ..., 0.9412, 0.9294, 0.9333],\n",
      "         ...,\n",
      "         [0.8902, 0.9608, 0.9255,  ..., 0.9333, 0.9647, 0.8980],\n",
      "         [0.9216, 0.9216, 0.9020,  ..., 0.8941, 0.9176, 0.9255],\n",
      "         [0.9569, 0.9294, 0.9294,  ..., 0.9059, 0.9176, 0.9569]],\n",
      "\n",
      "        [[0.9647, 0.9333, 0.9373,  ..., 0.9529, 0.9804, 0.9137],\n",
      "         [0.9333, 0.9255, 0.9098,  ..., 0.9373, 0.9412, 0.9412],\n",
      "         [0.9098, 0.9725, 0.9373,  ..., 0.9569, 0.9451, 0.9569],\n",
      "         ...,\n",
      "         [0.8627, 0.9333, 0.8980,  ..., 0.9098, 0.9412, 0.8745],\n",
      "         [0.8902, 0.8902, 0.8784,  ..., 0.8706, 0.8863, 0.8980],\n",
      "         [0.9255, 0.8980, 0.9059,  ..., 0.8824, 0.8902, 0.9294]],\n",
      "\n",
      "        [[0.9294, 0.8980, 0.8902,  ..., 0.8980, 0.9216, 0.8549],\n",
      "         [0.8980, 0.8902, 0.8627,  ..., 0.8824, 0.8824, 0.8824],\n",
      "         [0.8627, 0.9255, 0.8902,  ..., 0.9020, 0.8902, 0.9020],\n",
      "         ...,\n",
      "         [0.7882, 0.8588, 0.8235,  ..., 0.8235, 0.8549, 0.7804],\n",
      "         [0.8157, 0.8157, 0.7922,  ..., 0.7765, 0.7961, 0.7961],\n",
      "         [0.8510, 0.8235, 0.8196,  ..., 0.7882, 0.7882, 0.8275]]])\n",
      "tgt =\n",
      "{'boxes': tensor([[ 31.6700,  36.9500,  61.4900,  61.4900],\n",
      "        [ 81.7500,  56.7000, 123.8700,  88.3600],\n",
      "        [ 91.1900,  85.8400, 124.3000, 123.6100],\n",
      "        [ 70.0800,  91.2500,  79.9000,  96.3500],\n",
      "        [ 67.2800,  77.6300,  83.6000,  83.4600],\n",
      "        [ 37.7000,  76.3800,  38.8600,  80.9800],\n",
      "        [  5.1200,  73.5800,   8.5300,  82.4600],\n",
      "        [115.3500,  75.7000, 123.8200,  78.3800],\n",
      "        [ 69.7600,  93.0200,  79.5500,  99.1000],\n",
      "        [ 64.8600,  87.2400,  74.1600,  92.2100],\n",
      "        [  8.3600,  63.9400,   9.4500,  70.6800],\n",
      "        [115.7400,  74.4400, 123.7700,  77.7700],\n",
      "        [ 90.8600,  85.0900, 124.0200, 123.5500],\n",
      "        [ 77.4800,  91.7700,  83.6200,  94.5900],\n",
      "        [  8.3300,  73.8800,   9.8800,  82.0100],\n",
      "        [  6.2000,  42.5300,   9.6800,  46.4800]]), 'labels': tensor([3, 2, 2, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 5, 5, 6]), 'image_id': tensor(107903), 'width': tensor(128.), 'height': tensor(128.), 'areas': tensor([ 731.7828, 1333.5192, 1250.5647,   50.0820,   95.1456,    5.3360,\n",
      "          30.2808,   22.6996,   59.5232,   46.2210,    7.3466,   26.7399,\n",
      "        1275.3336,   17.3148,   12.6015,   13.7460]), 'iscrowds': tensor(0), 'ids': tensor([107903001, 107903002, 107903003, 107903004, 107903005, 107903006,\n",
      "        107903007, 107903008, 107903009, 107903010, 107903011, 107903012,\n",
      "        107903013, 107903014, 107903015, 107903016])}\n",
      "n_boxs = 16\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#hide\n",
    "best_img_pos = 89\n",
    "dataset = SubCocoDataset(img_dir, stats, img_ids=list(stats.img2sz.keys()))\n",
    "img,tgt = dataset[best_img_pos]\n",
    "print(f\"img =\\n{img}\\ntgt =\\n{tgt}\")\n",
    "tgt_l2bs = defaultdict(empty_list)\n",
    "n_boxs = 0\n",
    "for l, b in zip(list(tgt['labels']), tgt['boxes']):\n",
    "    n_boxs +=1\n",
    "    tgt_l2bs[int(l)].append( (int(b[0]), int(b[1]), int(b[2]-b[0]), int(b[3]-b[1])) ) \n",
    "\n",
    "print(f\"n_boxs = {n_boxs}\")\n",
    "pimg = torchvision.transforms.ToPILImage()(img)\n",
    "overlay_img_bbox(pimg, tgt_l2bs, stats.lbl2name)\n",
    "pre_img = img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Custom Transforms\n",
    "\n",
    "Albumentations Normalize() seems to produce distortion, need a transform to clamp the min max pixel value btw (0, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class NormClamp(A.ImageOnlyTransform):\n",
    "    def __init__(self, mean=(.5, .5, .5), std=(.25, .25, .25), always_apply=True, p=1.0):\n",
    "        super(NormClamp, self).__init__(always_apply, p)\n",
    "        self.mean = mean\n",
    "        self.std = std\n",
    "        \n",
    "    def apply(self, image, **params):\n",
    "        image = .333*(image - self.mean)/(self.std)\n",
    "        image = np.clip(image, 0, 255)\n",
    "        return image\n",
    "    \n",
    "    def get_transform_init_args_names(self):\n",
    "        return (\"mean\", \"std\")\n",
    "    \n",
    "class ClampPixel(A.ImageOnlyTransform):\n",
    "    def __init__(self, always_apply=True, p=1.0):\n",
    "        super(ClampPixel, self).__init__(always_apply, p)\n",
    "        \n",
    "    def apply(self, image, **params):\n",
    "        image = np.clip(image, 0, 255)\n",
    "        return image\n",
    "    \n",
    "    def get_params(self): return {}\n",
    "    def get_transform_init_args_names(self): return ()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verify the image transformation works using Albumentation, especially random transform to both image and target."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mean = [0.49525855 0.42753974 0.39455189], std = [0.25728409 0.2552822  0.23711022]\n",
      "n_boxs = 16\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#hide\n",
    "print(f\"mean = {stats.chn_means/255}, std = {stats.chn_stds/255}\")\n",
    "tfms = A.Compose([\n",
    "    A.ShiftScaleRotate(shift_limit=.025, scale_limit=0.025, rotate_limit=9),\n",
    "    A.RandomSizedBBoxSafeCrop(width=128,height=128),\n",
    "    A.HorizontalFlip(p=0.5), \n",
    "    A.RGBShift(),\n",
    "    A.RandomBrightnessContrast(),\n",
    "    A.Blur(blur_limit=(1, 3)),\n",
    "    A.Normalize(mean=stats.chn_means/255, std = stats.chn_stds/255, max_pixel_value=3), #why is this fucked up? why max px val 3\n",
    "    ClampPixel()\n",
    "], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['class_labels']))\n",
    "\n",
    "dataset = SubCocoDataset(img_dir, stats, img_ids=list(stats.img2sz.keys()), bbox_aware_tfms=tfms) \n",
    "img, tgt = dataset[best_img_pos]\n",
    "tgt_l2bs = defaultdict(empty_list)\n",
    "n_boxs = 0\n",
    "for l, b in zip(list(tgt['labels']), tgt['boxes']):\n",
    "    n_boxs +=1\n",
    "    tgt_l2bs[int(l)].append( (int(b[0]), int(b[1]), int(b[2]-b[0]), int(b[3]-b[1])) ) \n",
    "\n",
    "print(f\"n_boxs = {n_boxs}\")\n",
    "pimg = torchvision.transforms.ToPILImage()(img)\n",
    "overlay_img_bbox(pimg, tgt_l2bs, stats.lbl2name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Custom DataModule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class SubCocoDataModule(LightningDataModule):\n",
    "\n",
    "    def __init__(self, root, stats, bs=32, workers=4, split_ratio=0.9, shuffle=True, \n",
    "                 train_transforms=None, val_transforms=None):\n",
    "        super().__init__(train_transforms=train_transforms, val_transforms=val_transforms)\n",
    "        self.dir = root\n",
    "        self.bs = bs\n",
    "        self.workers = workers\n",
    "        self.stats = stats\n",
    "        self.split_ratio = split_ratio\n",
    "        self.shuffle = shuffle\n",
    "\n",
    "        num_items = stats.num_imgs\n",
    "        num_train = int(self.split_ratio*num_items)\n",
    "        img_ids = list(stats.img2sz.keys())\n",
    "        if shuffle: random.shuffle(img_ids)\n",
    "            \n",
    "        train_img_ids = img_ids[:num_train]\n",
    "        val_img_ids = img_ids[num_train:]\n",
    "        \n",
    "        self.train = SubCocoDataset(self.dir, self.stats, img_ids=train_img_ids, bbox_aware_tfms=train_transforms) \n",
    "        self.val = SubCocoDataset(self.dir, self.stats, img_ids=val_img_ids, bbox_aware_tfms=val_transforms)\n",
    "        \n",
    "    def collate_fn(self, batch):\n",
    "        return tuple(zip(*batch))\n",
    "\n",
    "    def train_dataloader(self):\n",
    "        return DataLoader(self.train, batch_size=self.bs, num_workers=self.workers, collate_fn=self.collate_fn, shuffle=self.shuffle)\n",
    "\n",
    "    def val_dataloader(self):\n",
    "        return DataLoader(self.val, batch_size=self.bs, num_workers=self.workers, collate_fn=self.collate_fn, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2,\n",
       " 2,\n",
       " tensor([[[0.7647, 0.7647, 0.7647,  ..., 0.6529, 0.7088, 0.7393],\n",
       "          [0.7596, 0.7596, 0.7596,  ..., 0.6580, 0.7139, 0.7393],\n",
       "          [0.7546, 0.7546, 0.7596,  ..., 0.6682, 0.7190, 0.7444],\n",
       "          ...,\n",
       "          [0.6377, 0.6428, 0.6529,  ..., 0.2058, 0.2058, 0.2058],\n",
       "          [0.6072, 0.6123, 0.6225,  ..., 0.2008, 0.2008, 0.2008],\n",
       "          [0.5869, 0.5971, 0.6072,  ..., 0.1957, 0.1957, 0.1957]],\n",
       " \n",
       "         [[0.7206, 0.7206, 0.7257,  ..., 0.6079, 0.6489, 0.6745],\n",
       "          [0.7154, 0.7206, 0.7206,  ..., 0.6130, 0.6540, 0.6745],\n",
       "          [0.7052, 0.7154, 0.7206,  ..., 0.6233, 0.6591, 0.6796],\n",
       "          ...,\n",
       "          [0.5721, 0.5772, 0.5874,  ..., 0.1573, 0.1573, 0.1573],\n",
       "          [0.5413, 0.5465, 0.5618,  ..., 0.1573, 0.1573, 0.1573],\n",
       "          [0.5209, 0.5311, 0.5413,  ..., 0.1624, 0.1624, 0.1624]],\n",
       " \n",
       "         [[0.7047, 0.6991, 0.6936,  ..., 0.5558, 0.6054, 0.6330],\n",
       "          [0.6991, 0.6991, 0.6936,  ..., 0.5613, 0.6109, 0.6330],\n",
       "          [0.6936, 0.6936, 0.6881,  ..., 0.5723, 0.6164, 0.6385],\n",
       "          ...,\n",
       "          [0.5172, 0.5282, 0.5393,  ..., 0.1754, 0.1754, 0.1754],\n",
       "          [0.4896, 0.4952, 0.5117,  ..., 0.1754, 0.1754, 0.1754],\n",
       "          [0.4676, 0.4786, 0.4896,  ..., 0.1754, 0.1754, 0.1754]]]),\n",
       " {'boxes': tensor([[ 22.0800,  94.9449,  54.8800, 128.0000]]),\n",
       "  'labels': tensor([6]),\n",
       "  'image_id': tensor(188181),\n",
       "  'width': tensor(128.),\n",
       "  'height': tensor(128.),\n",
       "  'areas': tensor([371.5830]),\n",
       "  'iscrowds': tensor(0),\n",
       "  'ids': tensor([188181001])})"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#hide\n",
    "tiny_coco_dm = SubCocoDataModule(img_dir, stats, bs=2, train_transforms=tfms, val_transforms=tfms)\n",
    "tdl=tiny_coco_dm.train_dataloader()\n",
    "images, targets = next(iter(tdl))\n",
    "\n",
    "len(images), len(targets), images[0], targets[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Base Abstract Lightning Module For Reuse Across Different Neural Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class AbstractDetectorLightningModule(LightningModule):\n",
    "    \n",
    "    def __init__(self, num_classes=1, img_sz=128, model_train_loss=True, bs:int=1, \n",
    "                 steps_per_epoch:int=0, lr:float=1e-2, noisy=False, calc_metrics=False, **kwargs):\n",
    "        LightningModule.__init__(self)\n",
    "        self.num_classes = num_classes\n",
    "        self.model_train_loss = model_train_loss\n",
    "        self.img_sz = img_sz\n",
    "        self.lr = lr\n",
    "        self.bs = bs\n",
    "        self.steps_per_epoch = steps_per_epoch\n",
    "        self.noisy = noisy\n",
    "        self.calc_metrics = calc_metrics\n",
    "        self.model = self.create_model(num_classes=num_classes, img_sz=img_sz, lr=lr, bs=bs, steps_per_epoch=steps_per_epoch, **kwargs)\n",
    "    \n",
    "    def create_model(self, **kwargs): raise NotImplementedError()\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.Adam(self.parameters(), lr=self.lr)\n",
    "        if self.steps_per_epoch <= 0: return optimizer\n",
    "        return {\n",
    "           'optimizer': optimizer,\n",
    "           'lr_scheduler': torch.optim.lr_scheduler.OneCycleLR(\n",
    "               optimizer, self.lr, steps_per_epoch=self.steps_per_epoch, epochs=1,)\n",
    "        }\n",
    "\n",
    "    def set_grad(self, mod:Module, requires_grad:bool=True):\n",
    "        for param in mod.parameters():\n",
    "            param.requires_grad = requires_grad\n",
    "\n",
    "    def get_main_model(self): raise NotImplementedError()\n",
    "        \n",
    "    def get_head(self)->Union[Iterable[Module], Module]: raise NotImplementedError()\n",
    "        \n",
    "    def get_backbone(self): raise NotImplementedError()\n",
    "        \n",
    "    def freeze_head(self):\n",
    "        head = self.get_head()\n",
    "        if isinstance(head, Iterable):\n",
    "            for head_net in head:\n",
    "                self.set_grad(head_net, requires_grad=False)\n",
    "        else:\n",
    "            self.set_grad(head, requires_grad=False)\n",
    "            \n",
    "    def unfreeze_head(self):\n",
    "        head = self.get_head()\n",
    "        if isinstance(head, Iterable):\n",
    "            for head_net in head:\n",
    "                self.set_grad(head_net, requires_grad=True)\n",
    "        else:\n",
    "            self.set_grad(head, requires_grad=True) \n",
    "        \n",
    "    def freeze_backbone(self):\n",
    "        self.set_grad(self.get_backbone(), requires_grad=False)\n",
    "        \n",
    "    def unfreeze_backbone(self):\n",
    "        self.set_grad(self.get_backbone(), requires_grad=True)\n",
    "        \n",
    "    def freeze_batchnorm(self):\n",
    "        for m in self.model.modules():\n",
    "            if type(m) is torch.nn.BatchNorm2d: \n",
    "                self.set_grad(m, requires_grad=False)\n",
    "        \n",
    "    def unfreeze_batchnorm(self):\n",
    "        for m in self.model.modules():\n",
    "            if type(m) is torch.nn.BatchNorm2d: \n",
    "                self.set_grad(m, requires_grad=True)\n",
    "    \n",
    "    def fix_boxes_batch(self, xs, ys, boxs_key='boxes', cats_key='labels'):\n",
    "        safe_xs, safe_ys = [], []\n",
    "        for x, y in zip(xs, ys):\n",
    "            n_boxs = len(y.get(boxs_key,[])) \n",
    "            n_cls = len(y.get(cats_key,[]))\n",
    "            if n_boxs <= 0:\n",
    "                print(f\"Warning: Removing X,Y as Y has no boxes! {y}\")\n",
    "            elif n_boxs != n_cls:\n",
    "                print(f\"Warning: Removing X,Y as Y n_nboxs {n_boxs} != n_cls {n_cls}\")\n",
    "            else:\n",
    "                bs = y['boxes'] # should be Tensor of shape bs x 4\n",
    "                # clamping min max value of x1,x2,y1,y2\n",
    "                for bi in range(len(bs)):\n",
    "                    bs[bi, 0] = clamp_fn(0, self.img_sz-2)(bs[bi, 0].item())\n",
    "                    bs[bi, 1] = clamp_fn(0, self.img_sz-2)(bs[bi, 1].item())\n",
    "                    bs[bi, 2] = clamp_fn(bs[bi, 0].item()+1, self.img_sz-1)(bs[bi, 2].item())\n",
    "                    bs[bi, 3] = clamp_fn(bs[bi, 1].item()+1, self.img_sz-1)(bs[bi, 3].item())\n",
    "                safe_xs.append(x)\n",
    "                safe_ys.append(y)\n",
    "        return safe_xs, safe_ys\n",
    "        \n",
    "    def metrics(self, preds, targets):\n",
    "        metrics = torch.zeros((min(len(preds), len(targets)), 2))\n",
    "        for i, (p,t) in enumerate(zip(preds, targets)):\n",
    "            metrics[i,0] = calc_wavg_F1(p, t, .5, .5)\n",
    "            metrics[i,1] = SubCocoWrapper(p, t, self.img_sz, self.img_sz).metrics()[0]\n",
    "        return metrics\n",
    "\n",
    "    def training_step(self, train_batch, batch_idx):\n",
    "        if self.noisy: print('Entering training_step')\n",
    "        self.model.train()\n",
    "        self.model.cuda()\n",
    "        xs, ys = self.fix_boxes_batch(*train_batch)\n",
    "        if len(xs) <= 0: return 0\n",
    "        with torch.set_grad_enabled(True):\n",
    "            losses = self.model.forward(xs, ys) if self.model_train_loss else self.forward(xs, ys)\n",
    "            losses = sum(losses.values())\n",
    "        if self.noisy: print(f'Exiting training_step, returning {losses}')\n",
    "        return losses\n",
    "    \n",
    "    def validation_step(self, val_batch, batch_idx):\n",
    "        if self.noisy: print('Entering validation_step')\n",
    "        self.model.cuda()\n",
    "        # turn off auto gradient for validation step\n",
    "        with torch.no_grad():\n",
    "            xs, ys = val_batch\n",
    "            self.model.train()\n",
    "            losses = self.model.forward(xs, ys) if self.model_train_loss else self.forward(xs, ys)\n",
    "            losses = sum(losses.values())\n",
    "            if self.calc_metrics:\n",
    "                self.model.eval()\n",
    "                preds = self.forward(xs)\n",
    "                metrics = self.metrics(preds, ys)\n",
    "        \n",
    "        result = {'val_loss': losses} \n",
    "        if self.calc_metrics:\n",
    "            result['val_acc'] = metrics[:,0].mean()\n",
    "            result['val_coco'] = metrics[:,1].mean()\n",
    "            \n",
    "        if self.noisy: print(f'Exiting validation_step, returning {result}')\n",
    "        return result\n",
    "    \n",
    "    def validation_epoch_end(self, outputs):\n",
    "        if self.noisy: print('Entering validation_epoch_end')\n",
    "        \n",
    "        result = {'val_loss': sum([ o['val_loss'] for o in outputs ])/len(outputs)}\n",
    "        if self.calc_metrics:\n",
    "            result['val_acc'] = sum([ o['val_acc'] for o in outputs ])/len(outputs)\n",
    "            result['val_coco'] = sum([ o['val_coco'] for o in outputs ])/len(outputs)\n",
    "            \n",
    "        if self.noisy: print(f'Exiting validation_epoch_end, returning {result}')\n",
    "        self.log_dict(result)\n",
    "\n",
    "    def forward(self, imgs, *args):\n",
    "        if self.noisy: print(f'Entering forward, training = {self.training}')\n",
    "        # assume all models take Xs & Ys during training\n",
    "        if self.training:\n",
    "            preds = self.model(imgs, *args)\n",
    "        else:\n",
    "            # turn off auto gradient for validation step\n",
    "            with torch.no_grad():\n",
    "                preds = self.model(imgs)\n",
    "        if self.noisy: print(f'Exiting forward, returning {preds}')\n",
    "        return preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entering forward, training = True\n",
      "Exiting forward, returning 0.1750834584236145\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor(0.1751)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#hide\n",
    "class ToyModule(AbstractDetectorLightningModule):\n",
    "    def __init__(self, **kwargs):\n",
    "        AbstractDetectorLightningModule.__init__(self, **kwargs)\n",
    "    \n",
    "    def create_model(self, num_classes=1, **kwargs): return nn.Linear(3*128*128, num_classes)\n",
    "    def get_main_model(self): return self.model\n",
    "    def get_head(self): return self.model\n",
    "    def get_backbone(self):  return self.model\n",
    "    def forward(self, imgs, *args): \n",
    "        if self.noisy: print(f'Entering forward, training = {self.training}')\n",
    "        batch_size = len(imgs)\n",
    "        imgs = torch.stack(imgs).view(batch_size, -1)\n",
    "        res = self.model(imgs)\n",
    "        if self.training:\n",
    "            res = F.mse_loss(res, torch.zeros_like(res))\n",
    "        if self.noisy: print(f'Exiting forward, returning {res}')\n",
    "        return res\n",
    "\n",
    "toy = ToyModule(num_classes=1, bs=16, steps_per_epoch=2000, noisy=True)\n",
    "toy.freeze_head()\n",
    "toy.freeze_backbone()\n",
    "toy.forward([torch.zeros((3,128,128)),torch.ones((3,128,128))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generic Training Runner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def train_model(model, model_name:str, stats:CocoDatasetStats, img_dir:str, \n",
    "        modeldir:str='models', lr=0.01, auto_lr_find=False, split_ratio=0.95,\n",
    "        img_sz=128, bs=1, acc=1, workers=1, head_runs=1, full_runs=1,\n",
    "        monitor='val_loss', mode='min', save_top=-1, patience=5):\n",
    "    \n",
    "    print(f\"Training with image size {img_sz}, learning rate {lr}, for {head_runs}+{full_runs} epochs.\")\n",
    "    \n",
    "    # transforms for images\n",
    "    bbox_aware_train_tfms=A.Compose([\n",
    "        A.ShiftScaleRotate(shift_limit=.01, scale_limit=0.05, rotate_limit=9),\n",
    "        A.Resize(width=img_sz, height=img_sz),\n",
    "        A.HorizontalFlip(p=0.5), \n",
    "        A.RGBShift(),\n",
    "        A.RandomBrightnessContrast(),\n",
    "        A.Blur(blur_limit=(1, 3)),\n",
    "        A.Normalize(mean=stats.chn_means/255, std = stats.chn_stds/255, max_pixel_value=3), #why is this fucked up? why max px val 3\n",
    "        ClampPixel()\n",
    "    ], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['class_labels']))\n",
    "\n",
    "    bbox_aware_val_tfms=A.Compose([\n",
    "        A.Resize(width=img_sz, height=img_sz),\n",
    "        A.Normalize(mean=stats.chn_means/255, std=stats.chn_stds/255)\n",
    "    ], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['class_labels']))\n",
    "\n",
    "    head_dm = SubCocoDataModule(img_dir, stats, shuffle=True, split_ratio=split_ratio,\n",
    "                                train_transforms=bbox_aware_train_tfms, val_transforms=bbox_aware_val_tfms,\n",
    "                                bs=bs*2, workers=workers)\n",
    "    \n",
    "    full_dm = SubCocoDataModule(img_dir, stats, shuffle=True, split_ratio=split_ratio,\n",
    "                                train_transforms=bbox_aware_train_tfms, val_transforms=bbox_aware_val_tfms,\n",
    "                                bs=bs, workers=workers)\n",
    "    \n",
    "    head_chkpt_cb = ModelCheckpoint(\n",
    "        filename = model_name+'-head-'+str(img_sz)+'-{epoch:03d}-{'+monitor+':.3f}',\n",
    "        dirpath=modeldir,\n",
    "        save_last=True,\n",
    "        monitor=monitor,\n",
    "        mode=mode,\n",
    "        save_top_k=save_top,\n",
    "        verbose=True,\n",
    "    )\n",
    "    full_chkpt_cb = ModelCheckpoint(\n",
    "        filename= model_name+'-full-'+str(img_sz)+'-{epoch:03d}-{'+monitor+':.3f}',\n",
    "        dirpath=modeldir,\n",
    "        save_last=True,\n",
    "        monitor=monitor,\n",
    "        mode=mode,\n",
    "        save_top_k=save_top,\n",
    "        verbose=True,\n",
    "    )\n",
    "    early_stop_cb = EarlyStopping(\n",
    "       monitor=monitor,\n",
    "       min_delta=0.001,\n",
    "       patience=patience,\n",
    "       verbose=True,\n",
    "       mode=mode\n",
    "    )\n",
    "    gpumon_cb = PyTorchGpuMonitorCallback(delay=1)\n",
    "    callbacks = [early_stop_cb, gpumon_cb]\n",
    "    \n",
    "    # train head only, since using less params, double the bs and half the grad accumulation cycle to use more GPU VRAM\n",
    "    if head_runs > 0:\n",
    "        trainer = Trainer(gpus=1, max_epochs=head_runs, default_root_dir = modeldir, accumulate_grad_batches=max(1,acc//2),\n",
    "                          auto_lr_find=auto_lr_find, callbacks=callbacks, checkpoint_callback=head_chkpt_cb)\n",
    "        model.unfreeze_head()\n",
    "        model.freeze_backbone()\n",
    "        model.unfreeze_batchnorm()\n",
    "        trainer.fit(model, head_dm)\n",
    "\n",
    "    if full_runs > 0:\n",
    "        # finetune head and backbone\n",
    "        trainer = Trainer(gpus=1, max_epochs=full_runs, default_root_dir = modeldir, accumulate_grad_batches=max(1,acc),\n",
    "                          auto_lr_find=auto_lr_find, callbacks=callbacks, checkpoint_callback=full_chkpt_cb)\n",
    "        model.unfreeze_head()\n",
    "        model.unfreeze_backbone()\n",
    "        model.unfreeze_batchnorm()\n",
    "        trainer.fit(model, full_dm)\n",
    "    \n",
    "    saved_last_model_fpath = None\n",
    "    if full_runs > 0:\n",
    "        last_model_fpath=Path(full_chkpt_cb.last_model_path)\n",
    "        saved_last_model_fpath=str(last_model_fpath.parent/f'{model_name}-{img_sz}-last')+last_model_fpath.suffix\n",
    "        os.rename(str(last_model_fpath), saved_last_model_fpath)\n",
    "    \n",
    "    return model, saved_last_model_fpath\n",
    "\n",
    "def run_training(moduleClass:AbstractDetectorLightningModule, backbone_name:str, stats:CocoDatasetStats, img_dir:str, \n",
    "                 resume_ckpt_fname=None, split_ratio=0.95, modeldir:str='models', lr=0.01, auto_lr_find=False, img_sz=128, bs=1, acc=1, workers=1, \n",
    "                 head_runs=1, full_runs=1, monitor='val_loss', mode='min', save_top=-1, test=True, calc_metrics=False, patience=5):\n",
    "    \n",
    "    print(f\"Training with image size {img_sz}, learning rate {lr}, patience = {patience}, for {head_runs}+{full_runs} epochs.\")\n",
    "    \n",
    "    steps_per_epoch = int(stats.num_imgs*split_ratio)\n",
    "    is_new_run = True\n",
    "    \n",
    "    if resume_ckpt_fname: \n",
    "        resume_ckpt = f'{modeldir}/{resume_ckpt_fname}'\n",
    "        if os.path.isfile(resume_ckpt):\n",
    "            try:\n",
    "                print(f'Loading previously saved model: {resume_ckpt}...')\n",
    "                model = moduleClass.load_from_checkpoint(\n",
    "                    resume_ckpt, backbone_name=backbone_name, bs=bs, steps_per_epoch=steps_per_epoch, lr=lr,\n",
    "                    num_classes=len(stats.lbl2name), img_sz=img_sz, noisy = test, calc_metrics=calc_metrics,)\n",
    "                is_new_run = False\n",
    "            except Exception as e:\n",
    "                print(f'Unexpected error loading previously saved model {resume_ckpt}: {e}')\n",
    "        else: print(f'Failed to find {resume_ckpt}')\n",
    "    \n",
    "    if is_new_run:\n",
    "        model = moduleClass(backbone_name=backbone_name, bs=bs, lr=lr, calc_metrics=calc_metrics,\n",
    "            steps_per_epoch=steps_per_epoch, num_classes=len(stats.lbl2name), img_sz=img_sz, noisy = test)\n",
    "    \n",
    "    return train_model(model, backbone_name, stats, img_dir,\n",
    "            lr=lr, auto_lr_find=auto_lr_find, split_ratio=split_ratio, modeldir=modeldir,\n",
    "            img_sz=img_sz, bs=bs, acc=acc, workers=workers, head_runs=head_runs, full_runs=full_runs,\n",
    "            monitor=monitor, mode=mode, save_top=save_top, patience=patience)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training with image size 128, learning rate 0.01, patience = 2, for 0+0 epochs.\n",
      "Training with image size 128, learning rate 0.01, for 0+0 epochs.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(ToyModule(\n",
       "   (model): Linear(in_features=49152, out_features=6, bias=True)\n",
       " ),\n",
       " None)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#hide\n",
    "#how do I test train_model() and run_training()?\n",
    "run_training(ToyModule, 'toy', stats, img_dir, test=True, head_runs=0, full_runs=0, calc_metrics=True, monitor='val_acc', mode='max', patience=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export to Regular Python Script as 'subcoco_lightning_util.py'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 20_subcoco_lightning_utils.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#hide\n",
    "from nbdev.export import *\n",
    "notebook2script(fname='20_subcoco_lightning_utils.ipynb')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}