run_length_encoded_customs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_kg_hide-input": true,
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
   },
   "outputs": [],
   "source": [
    "import numpy as np, pandas as pd, os\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import fastai\n",
    "from fastai.vision import *\n",
    "from fastai.callbacks import MixedPrecision\n",
    "path = Path('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df = pd.read_csv(\"train.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lb_fnc(j):\n",
    "    #print(len(j[1]))\n",
    "    return j[1]\n",
    "lbf = lambda x: x[1]\n",
    "codes = list(train_df['ClassId'].values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def open_mask_rle(mask_rle:str, shape:Tuple[int, int])->ImageSegment:\n",
    "    \"Return `ImageSegment` object create from run-length encoded string in `mask_lre` with size in `shape`.\"\n",
    "    x = FloatTensor(rle_decode(str(mask_rle), shape).astype(np.uint8))\n",
    "    x = x.view(shape[1], shape[0], -1)\n",
    "    return ImageSegment(x.permute(2,1,0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SegRleItem(ItemBase):\n",
    "    def __init__(self, image, mask):\n",
    "        self.image = image\n",
    "        self.mask = mask\n",
    "        self.obj,self.data = (image, mask),(image.data,mask.data)\n",
    "        \n",
    "    def apply_tfms(self, tfms, *args, **kwargs):\n",
    "        self.mask = self.mask.apply_tfms(tfms, *args, **kwargs)\n",
    "        self.image = self.image.apply_tfms(tfms, *args, **kwargs)\n",
    "        self.data = self.image.data,self.mask.data\n",
    "        return self\n",
    "    \n",
    "    def __repr__(self): return f'{self.__class__.__name__} {self.image.shape, self.mask.shape}'\n",
    "    \n",
    "    def to_one(self): return (Image(self.image.data), ImageSegment(self.mask.data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SegRleLabel(ItemBase):\n",
    "    def __init__(self, mask):\n",
    "        self.mask = mask\n",
    "        self.obj,self.data = mask,mask.data\n",
    "        \n",
    "    def apply_tfms(self, tfms, *args, **kwargs):\n",
    "        self.mask = self.mask.apply_tfms(tfms, *args, **kwargs)\n",
    "        self.data = self.mask.data\n",
    "        return self\n",
    "    \n",
    "    def __repr__(self): return f'{self.__class__.__name__} {self.mask.shape}'\n",
    "    \n",
    "    def to_one(self): return ImageSegment(self.mask.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SegRleLabelEncode(ItemBase):\n",
    "    def __init__(self, mask_str):\n",
    "        self.mask_str = mask_str\n",
    "        self.mask = open_mask_rle(self.mask_str[0], (self.mask_str[1], self.mask_str[2]))\n",
    "        self.obj,self.data = self.mask,self.mask.data\n",
    "        \n",
    "    def apply_tfms(self, tfms, *args, **kwargs):\n",
    "        self.mask = self.mask.apply_tfms(tfms, *args, **kwargs)\n",
    "        self.data = self.mask.data\n",
    "        return self\n",
    "    \n",
    "    def __repr__(self): return f'{self.__class__.__name__} {self.mask.shape}'\n",
    "    \n",
    "    def to_one(self): return ImageSegment(self.mask.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SegRleImage(ItemBase):\n",
    "    def __init__(self, image):\n",
    "        self.image = image\n",
    "        self.obj,self.data = image,image.data\n",
    "        \n",
    "    def apply_tfms(self, tfms, *args, **kwargs):\n",
    "        self.image = self.image.apply_tfms(tfms, *args, **kwargs)\n",
    "        self.data = self.image.data\n",
    "        return self\n",
    "    \n",
    "    def __repr__(self): return f'{self.__class__.__name__} {self.image.shape}'\n",
    "    \n",
    "    def to_one(self): return Image(self.image.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ImageList(ItemList):\n",
    "    \"`ItemList` suitable for computer vision.\"\n",
    "    _bunch,_square_show,_square_show_res = ImageDataBunch,True,True\n",
    "    def __init__(self, *args, convert_mode='RGB', after_open:Callable=None, **kwargs):\n",
    "#        print('ImageList_init')\n",
    "        super().__init__(*args, **kwargs)\n",
    "#        self.convert_mode,self.after_open = convert_mode,after_open\n",
    "#        self.copy_new.append('convert_mode')\n",
    "#        self.c,self.sizes = 3,{}\n",
    "\n",
    "    def open(self, fn):\n",
    "#        print('imagelist_get_open')\n",
    "        \"Open image in `fn`, subclass and overwrite for custom behavior.\"\n",
    "        return open_image(fn, convert_mode=self.convert_mode, after_open=self.after_open)\n",
    "\n",
    "    def get(self, i):\n",
    "        #print('imglist_i:', i)\n",
    "        fn = super().get(i)#[0]\n",
    "        if len(fn) == 2:\n",
    "            #print('imagelist_get_fn_len:', len(fn))\n",
    "            #print('imagelist_get_fn[0]_tup_type_len:', type(fn[0]), len(fn[0]))\n",
    "        #print('imagelist_get_fn[1]_tup_type_len:', type(fn[1]), len(fn[1]))\n",
    "            mn = fn[1]\n",
    "            fn = fn[0]\n",
    "            #print('sends fn to SegLL_open?')\n",
    "            res = self.open(fn)\n",
    "        #print('imagelist_get_mn:type_len:', type(mn), len(mn))\n",
    "            self.sizes[i] = res.size \n",
    "            res = SegRleItem(res, mn)\n",
    "            #res = Image(res.data[0])\n",
    "            #print('res_type_from_ImageList:', type(res))\n",
    "            return res\n",
    "        else: pass #print('wtf, imagelist_fn is now len:', len(fn))\n",
    "    \n",
    "    @classmethod\n",
    "    def from_folder(cls, path:PathOrStr='.', extensions:Collection[str]=None, **kwargs)->'ItemList':\n",
    "        \"Get the list of files in `path` that have an image suffix. `recurse` determines if we search subfolders.\"\n",
    "        extensions = ifnone(extensions, image_extensions)\n",
    "        return super().from_folder(path=path, extensions=extensions, **kwargs)\n",
    "\n",
    "    @classmethod\n",
    "    def from_df(cls, df:DataFrame, path:PathOrStr, cols:IntsOrStrs=0, folder:PathOrStr=None, suffix:str='', **kwargs)->'ItemList':\n",
    "        \"Get the filenames in `cols` of `df` with `folder` in front of them, `suffix` at the end.\"\n",
    "        suffix = suffix or ''\n",
    "        res = super().from_df(df, path=path, cols=cols[0], **kwargs)\n",
    "        #print('get_from_df')\n",
    "        msk = ItemList.from_df(df, path, cols=[1,2,3])\n",
    "        pref = f'{res.path}{os.path.sep}'\n",
    "        if folder is not None: pref += f'{folder}{os.path.sep}'\n",
    "        res.items = np.char.add(np.char.add(pref, res.items.astype(str)), suffix)\n",
    "        res.items = np.array([(res.items[i], msk[i]) for i in range(len(res.items))])\n",
    "        #print('len_df_res.items:', len(res.items), type(res.items[0]))\n",
    "        return res\n",
    "    \n",
    "    def label_from_func(self, func:Callable, label_cls:Callable=None, **kwargs)->'LabelListTpl':\n",
    "        \"Apply `func` to every input to get its label.\"\n",
    "        return self._label_from_list([func(o) for o in self.items], label_cls=label_cls, **kwargs)\n",
    "\n",
    "    @classmethod\n",
    "    def from_csv(cls, path:PathOrStr, csv_name:str, header:str='infer', **kwargs)->'ItemList':\n",
    "        \"Get the filenames in `path/csv_name` opened with `header`.\"\n",
    "        path = Path(path)\n",
    "        df = pd.read_csv(path/csv_name, header=header)\n",
    "        return cls.from_df(df, path=path, **kwargs)\n",
    "\n",
    "    def reconstruct(self, t:Tensor): return Image(t.float().clamp(min=0,max=1))\n",
    "\n",
    "    def show_xys(self, xs, ys, imgsize:int=4, figsize:Optional[Tuple[int,int]]=None, **kwargs):\n",
    "        \"Show the `xs` (inputs) and `ys` (targets) on a figure of `figsize`.\"\n",
    "        rows = int(np.ceil(math.sqrt(len(xs))))\n",
    "        axs = subplots(rows, rows, imgsize=imgsize, figsize=figsize)\n",
    "        for x,y,ax in zip(xs, ys, axs.flatten()): x.show(ax=ax, y=y, **kwargs)\n",
    "        for ax in axs.flatten()[len(xs):]: ax.axis('off')\n",
    "        plt.tight_layout()\n",
    "\n",
    "    def show_xyzs(self, xs, ys, zs, imgsize:int=4, figsize:Optional[Tuple[int,int]]=None, **kwargs):\n",
    "        \"Show `xs` (inputs), `ys` (targets) and `zs` (predictions) on a figure of `figsize`.\"\n",
    "        if self._square_show_res:\n",
    "            title = 'Ground truth\\nPredictions'\n",
    "            rows = int(np.ceil(math.sqrt(len(xs))))\n",
    "            axs = subplots(rows, rows, imgsize=imgsize, figsize=figsize, title=title, weight='bold', size=12)\n",
    "            for x,y,z,ax in zip(xs,ys,zs,axs.flatten()): x.show(ax=ax, title=f'{str(y)}\\n{str(z)}', **kwargs)\n",
    "            for ax in axs.flatten()[len(xs):]: ax.axis('off')\n",
    "        else:\n",
    "            title = 'Ground truth/Predictions'\n",
    "            axs = subplots(len(xs), 2, imgsize=imgsize, figsize=figsize, title=title, weight='bold', size=14)\n",
    "            for i,(x,y,z) in enumerate(zip(xs,ys,zs)):\n",
    "                x.show(ax=axs[i,0], y=y, **kwargs)\n",
    "                x.show(ax=axs[i,1], y=z, **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SegRleItems(ItemBase):\n",
    "    def __init__(self, image, mask_arr):\n",
    "        self.image = image\n",
    "        self.mask_arr = mask_arr\n",
    "        self.mask = open_mask_rle(self.mask_arr[0], (self.mask_arr[1], self.mask_arr[2]))\n",
    "        self.obj,self.data = (self.image, self.mask),(self.image.data,self.mask.data)\n",
    "        \n",
    "    def apply_tfms(self, tfms, *args, **kwargs):\n",
    "        self.mask = self.mask.apply_tfms(tfms, *args, **kwargs)\n",
    "        self.image = self.image.apply_tfms(tfms, *args, **kwargs)\n",
    "        self.data = self.image.data,self.mask.data\n",
    "        return self\n",
    "    \n",
    "    def __repr__(self): return f'{self.__class__.__name__} {self.image.shape, self.mask.shape}'\n",
    "    \n",
    "    def to_one(self): return (Image(self.image.data), ImageSegment(self.mask.data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SegmentationProcessor(PreProcessor):\n",
    "    \"`PreProcessor` that stores the classes for segmentation.\"\n",
    "    def __init__(self, ds:ItemList): \n",
    "        self.classes = ds.classes\n",
    "#        print('seg_processor_classes:', len(self.classes))\n",
    "    def process(self, ds:ItemList):  \n",
    "        ds.classes,ds.c = self.classes,len(self.classes)\n",
    "\n",
    "class SegmentationLabelList(ItemList):\n",
    "    \"`ItemList` for segmentation masks.\"\n",
    "    _processor=SegmentationProcessor\n",
    "    def __init__(self, items:Iterator, classes:Collection=None, **kwargs):\n",
    "        super().__init__(items, **kwargs)\n",
    "#        print('segLL_init')\n",
    "        self.copy_new.append('classes')\n",
    "        self.classes,self.loss_func = classes,CrossEntropyFlat(axis=1)\n",
    "\n",
    "    def get(self, i):\n",
    "#        print('segLL_i:', i)\n",
    "        fn = super().get(i)\n",
    "#        print('type_segLL_fn:', type(fn))\n",
    "        res = self.open(fn)\n",
    "        #res = SegRleLabel(res)\n",
    "#        print('type_res:', type(res))\n",
    "        return res\n",
    "        \n",
    "    def open(self, fn): \n",
    "        fn = open_mask_rle(fn[0], (fn[1], fn[2]))\n",
    "        fn = SegRleLabel(fn)\n",
    "#        print(f'SLL_fn_type:', type(fn))#, 'not segrleItem, str of len:', len(fn))\n",
    "        return fn\n",
    "    def analyze_pred(self, pred, thresh:float=0.5): return pred.argmax(dim=0)[None]\n",
    "    def reconstruct(self, t:Tensor): return SegRleLabel(t)\n",
    "\n",
    "class SegmentationItemList(ImageList):\n",
    "    \"`ItemList` suitable for segmentation tasks.\"\n",
    "    _label_cls,_square_show_res = SegmentationLabelList,False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SegRleItem(ItemBase):\n",
    "    def __init__(self, image, mask_arr):\n",
    "        self.image = image\n",
    "        self.mask_arr = mask_arr\n",
    "        self.mask = open_mask_rle(self.mask_arr[0], (self.mask_arr[1], self.mask_arr[2]))\n",
    "        self.obj,self.data = (self.image, self.mask),(self.image.data,self.mask.data)\n",
    "        \n",
    "    def apply_tfms(self, tfms, *args, **kwargs):\n",
    "        self.mask = self.mask.apply_tfms(tfms, *args, **kwargs)\n",
    "        self.image = self.image.apply_tfms(tfms, *args, **kwargs)\n",
    "        self.data = self.image.data,self.mask.data\n",
    "        return self\n",
    "    \n",
    "    def __repr__(self): return f'{self.__class__.__name__} {self.image.shape, self.mask.shape}'\n",
    "    \n",
    "    def to_one(self): return [Image(self.image.data), ImageSegment(self.mask.data)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SegRleList(SegmentationItemList):\n",
    "    \"`ItemList` suitable for computer vision.\"\n",
    "   # _processor=fastai.vision.data.SegmentationProcessor\n",
    "    _bunch,_square_show,_square_show_res = ImageDataBunch,True,True\n",
    "    def __init__(self, *args, convert_mode='RGB', after_open:Callable=None, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "#        print('segrle_init')\n",
    "        self.convert_mode,self.after_open = convert_mode,after_open\n",
    "        self.copy_new.append('convert_mode')\n",
    "        self.c,self.sizes = 3,{}\n",
    "        \n",
    "    def create(cls, labels:Collection=None, classes:dict=None)->'SegRleList':\n",
    "        \"Create an ImageLabeled object with `labels`.\"\n",
    "        return cls(labels=labels, classes=classes)\n",
    "    \n",
    "    def get(self, i):\n",
    "#        print('segrle_i:', i)\n",
    "        res = super().get(i)#[0]\n",
    "#        print('segrlelist_get_fn_type:', type(res))\n",
    "        res = SegRleImage(Image(res.data[0])) \n",
    "#        print('res_out_type:', type(res))\n",
    "        return res #Image(res.data[0])\n",
    "\n",
    "    def reconstruct(self, t:Tensor): \n",
    "        return SegRleImage(t)\n",
    "    \n",
    "    def show_xys(self, xs, ys, figsize:Tuple[int,int]=(12,6), **kwargs):\n",
    "        \"Show the `xs` and `ys` on a figure of `figsize`. `kwargs` are passed to the show method.\"\n",
    "        rows = int(math.sqrt(len(xs)))\n",
    "#        print('ys[i]_type:', type(ys[0]))\n",
    "        fig, axs = plt.subplots(rows,rows,figsize=figsize)\n",
    "        for i, ax in enumerate(axs.flatten() if rows > 1 else [axs]):\n",
    "            ym = ys[i].to_one()\n",
    "#            print('xs[i]_type:', type(xs[0]))\n",
    "#            print('xs[i]_shapes:', xs[0].data.shape)\n",
    "            xs[i].to_one().show(ax=ax, y=ym, **kwargs, alpha=0.7)\n",
    "        plt.tight_layout()\n",
    "\n",
    "    def show_xyzs(self, xs, ys, zs, figsize:Tuple[int,int]=None, **kwargs):\n",
    "        \"\"\"Show `xs` (inputs), `ys` (targets) and `zs` (predictions) on a figure of `figsize`.\n",
    "        `kwargs` are passed to the show method.\"\"\"\n",
    "        figsize = ifnone(figsize, (12,3*len(xs)))\n",
    "        fig,axs = plt.subplots(len(xs), 2, figsize=figsize)\n",
    "        fig.suptitle('Ground truth / Predictions', weight='bold', size=14)\n",
    "        for i,(x,z) in enumerate(zip(xs,zs)):\n",
    "            x.to_one().show(ax=axs[i,0], **kwargs)\n",
    "            z.to_one().show(ax=axs[i,1], **kwargs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "db = (SegRleList.from_df(train_df, path, cols=[0,1,2,3], folder='train')\n",
    "     .split_by_rand_pct()\n",
    "     .label_from_func(lbf, classes=codes) \n",
    "     .transform(get_transforms(), tfm_y=True, size=512)\n",
    "     .databunch(bs=8, num_workers=0)\n",
    "     .normalize(imagenet_stats)\n",
    "     )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "266732"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(db.train_ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LabelList (66683 items)\n",
       "x: SegRleList\n",
       "SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512])\n",
       "y: SegmentationLabelList\n",
       "SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512])\n",
       "Path: ."
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db.valid_ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SegRleLabel torch.Size([1, 5214, 3676])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db.train_ds.y[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "db.show_batch()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "db.label_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def IoU(pred, targs, thres=0):\n",
    "    pred = (pred>thres).float()\n",
    "    intersection = (pred*targs).sum()\n",
    "    return intersection / ((pred+targs).sum() - intersection + 1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = unet_learner(db, \n",
    "                     models.resnet18, \n",
    "                     metrics=[IoU]\n",
    "                    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = learn.to_fp16()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Learner(data=ImageDataBunch;\n",
       "\n",
       "Train: LabelList (266732 items)\n",
       "x: SegRleList\n",
       "SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512])\n",
       "y: SegmentationLabelList\n",
       "SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512])\n",
       "Path: .;\n",
       "\n",
       "Valid: LabelList (66683 items)\n",
       "x: SegRleList\n",
       "SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512])\n",
       "y: SegmentationLabelList\n",
       "SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512])\n",
       "Path: .;\n",
       "\n",
       "Test: None, model=DynamicUnet(\n",
       "  (layers): ModuleList(\n",
       "    (0): Sequential(\n",
       "      (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
       "      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): ReLU(inplace)\n",
       "      (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "      (4): Sequential(\n",
       "        (0): BasicBlock(\n",
       "          (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): BasicBlock(\n",
       "          (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "      )\n",
       "      (5): Sequential(\n",
       "        (0): BasicBlock(\n",
       "          (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (downsample): Sequential(\n",
       "            (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "            (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          )\n",
       "        )\n",
       "        (1): BasicBlock(\n",
       "          (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "      )\n",
       "      (6): Sequential(\n",
       "        (0): BasicBlock(\n",
       "          (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (downsample): Sequential(\n",
       "            (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "            (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          )\n",
       "        )\n",
       "        (1): BasicBlock(\n",
       "          (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "      )\n",
       "      (7): Sequential(\n",
       "        (0): BasicBlock(\n",
       "          (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (downsample): Sequential(\n",
       "            (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "            (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          )\n",
       "        )\n",
       "        (1): BasicBlock(\n",
       "          (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "    (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "    (3): Sequential(\n",
       "      (0): Sequential(\n",
       "        (0): Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (1): Sequential(\n",
       "        (0): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "    )\n",
       "    (4): UnetBlock(\n",
       "      (shuf): PixelShuffle_ICNR(\n",
       "        (conv): Sequential(\n",
       "          (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (shuf): PixelShuffle(upscale_factor=2)\n",
       "        (pad): ReplicationPad2d((1, 0, 1, 0))\n",
       "        (blur): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "        (relu): ReLU(inplace)\n",
       "      )\n",
       "      (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv1): Sequential(\n",
       "        (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (conv2): Sequential(\n",
       "        (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (5): UnetBlock(\n",
       "      (shuf): PixelShuffle_ICNR(\n",
       "        (conv): Sequential(\n",
       "          (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (shuf): PixelShuffle(upscale_factor=2)\n",
       "        (pad): ReplicationPad2d((1, 0, 1, 0))\n",
       "        (blur): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "        (relu): ReLU(inplace)\n",
       "      )\n",
       "      (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv1): Sequential(\n",
       "        (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (conv2): Sequential(\n",
       "        (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (6): UnetBlock(\n",
       "      (shuf): PixelShuffle_ICNR(\n",
       "        (conv): Sequential(\n",
       "          (0): Conv2d(384, 768, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (shuf): PixelShuffle(upscale_factor=2)\n",
       "        (pad): ReplicationPad2d((1, 0, 1, 0))\n",
       "        (blur): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "        (relu): ReLU(inplace)\n",
       "      )\n",
       "      (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv1): Sequential(\n",
       "        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (conv2): Sequential(\n",
       "        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (7): UnetBlock(\n",
       "      (shuf): PixelShuffle_ICNR(\n",
       "        (conv): Sequential(\n",
       "          (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (shuf): PixelShuffle(upscale_factor=2)\n",
       "        (pad): ReplicationPad2d((1, 0, 1, 0))\n",
       "        (blur): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "        (relu): ReLU(inplace)\n",
       "      )\n",
       "      (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv1): Sequential(\n",
       "        (0): Conv2d(192, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (conv2): Sequential(\n",
       "        (0): Conv2d(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (8): PixelShuffle_ICNR(\n",
       "      (conv): Sequential(\n",
       "        (0): Conv2d(96, 384, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (shuf): PixelShuffle(upscale_factor=2)\n",
       "      (pad): ReplicationPad2d((1, 0, 1, 0))\n",
       "      (blur): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "      (relu): ReLU(inplace)\n",
       "    )\n",
       "    (9): MergeLayer()\n",
       "    (10): SequentialEx(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(99, 99, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (1): ReLU(inplace)\n",
       "        )\n",
       "        (1): Sequential(\n",
       "          (0): Conv2d(99, 99, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (1): ReLU(inplace)\n",
       "        )\n",
       "        (2): MergeLayer()\n",
       "      )\n",
       "    )\n",
       "    (11): Sequential(\n",
       "      (0): Conv2d(99, 333415, kernel_size=(1, 1), stride=(1, 1))\n",
       "    )\n",
       "  )\n",
       "), opt_func=functools.partial(<class 'torch.optim.adam.Adam'>, betas=(0.9, 0.99)), loss_func=FlattenedLoss of CrossEntropyLoss(), metrics=[<function IoU at 0x000001BDF50C2D90>], true_wd=True, bn_wd=True, wd=0.01, train_bn=True, path=WindowsPath('.'), model_dir='models', callback_fns=[functools.partial(<class 'fastai.basic_train.Recorder'>, add_time=True, silent=False)], callbacks=[MixedPrecision\n",
       "learn: Learner(data=ImageDataBunch;\n",
       "\n",
       "Train: LabelList (266732 items)\n",
       "x: SegRleList\n",
       "SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512])\n",
       "y: SegmentationLabelList\n",
       "SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512])\n",
       "Path: .;\n",
       "\n",
       "Valid: LabelList (66683 items)\n",
       "x: SegRleList\n",
       "SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512]),SegRleImage torch.Size([3, 512, 512])\n",
       "y: SegmentationLabelList\n",
       "SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512]),SegRleLabel torch.Size([1, 512, 512])\n",
       "Path: .;\n",
       "\n",
       "Test: None, model=DynamicUnet(\n",
       "  (layers): ModuleList(\n",
       "    (0): Sequential(\n",
       "      (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
       "      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): ReLU(inplace)\n",
       "      (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "      (4): Sequential(\n",
       "        (0): BasicBlock(\n",
       "          (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): BasicBlock(\n",
       "          (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "      )\n",
       "      (5): Sequential(\n",
       "        (0): BasicBlock(\n",
       "          (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (downsample): Sequential(\n",
       "            (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "            (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          )\n",
       "        )\n",
       "        (1): BasicBlock(\n",
       "          (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "      )\n",
       "      (6): Sequential(\n",
       "        (0): BasicBlock(\n",
       "          (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (downsample): Sequential(\n",
       "            (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "            (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          )\n",
       "        )\n",
       "        (1): BasicBlock(\n",
       "          (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "      )\n",
       "      (7): Sequential(\n",
       "        (0): BasicBlock(\n",
       "          (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (downsample): Sequential(\n",
       "            (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "            (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          )\n",
       "        )\n",
       "        (1): BasicBlock(\n",
       "          (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (relu): ReLU(inplace)\n",
       "          (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "    (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "    (3): Sequential(\n",
       "      (0): Sequential(\n",
       "        (0): Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (1): Sequential(\n",
       "        (0): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "    )\n",
       "    (4): UnetBlock(\n",
       "      (shuf): PixelShuffle_ICNR(\n",
       "        (conv): Sequential(\n",
       "          (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (shuf): PixelShuffle(upscale_factor=2)\n",
       "        (pad): ReplicationPad2d((1, 0, 1, 0))\n",
       "        (blur): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "        (relu): ReLU(inplace)\n",
       "      )\n",
       "      (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv1): Sequential(\n",
       "        (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (conv2): Sequential(\n",
       "        (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (5): UnetBlock(\n",
       "      (shuf): PixelShuffle_ICNR(\n",
       "        (conv): Sequential(\n",
       "          (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (shuf): PixelShuffle(upscale_factor=2)\n",
       "        (pad): ReplicationPad2d((1, 0, 1, 0))\n",
       "        (blur): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "        (relu): ReLU(inplace)\n",
       "      )\n",
       "      (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv1): Sequential(\n",
       "        (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (conv2): Sequential(\n",
       "        (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (6): UnetBlock(\n",
       "      (shuf): PixelShuffle_ICNR(\n",
       "        (conv): Sequential(\n",
       "          (0): Conv2d(384, 768, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (shuf): PixelShuffle(upscale_factor=2)\n",
       "        (pad): ReplicationPad2d((1, 0, 1, 0))\n",
       "        (blur): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "        (relu): ReLU(inplace)\n",
       "      )\n",
       "      (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv1): Sequential(\n",
       "        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (conv2): Sequential(\n",
       "        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (7): UnetBlock(\n",
       "      (shuf): PixelShuffle_ICNR(\n",
       "        (conv): Sequential(\n",
       "          (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "        )\n",
       "        (shuf): PixelShuffle(upscale_factor=2)\n",
       "        (pad): ReplicationPad2d((1, 0, 1, 0))\n",
       "        (blur): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "        (relu): ReLU(inplace)\n",
       "      )\n",
       "      (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv1): Sequential(\n",
       "        (0): Conv2d(192, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (conv2): Sequential(\n",
       "        (0): Conv2d(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (8): PixelShuffle_ICNR(\n",
       "      (conv): Sequential(\n",
       "        (0): Conv2d(96, 384, kernel_size=(1, 1), stride=(1, 1))\n",
       "      )\n",
       "      (shuf): PixelShuffle(upscale_factor=2)\n",
       "      (pad): ReplicationPad2d((1, 0, 1, 0))\n",
       "      (blur): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "      (relu): ReLU(inplace)\n",
       "    )\n",
       "    (9): MergeLayer()\n",
       "    (10): SequentialEx(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(99, 99, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (1): ReLU(inplace)\n",
       "        )\n",
       "        (1): Sequential(\n",
       "          (0): Conv2d(99, 99, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (1): ReLU(inplace)\n",
       "        )\n",
       "        (2): MergeLayer()\n",
       "      )\n",
       "    )\n",
       "    (11): Sequential(\n",
       "      (0): Conv2d(99, 333415, kernel_size=(1, 1), stride=(1, 1))\n",
       "    )\n",
       "  )\n",
       "), opt_func=functools.partial(<class 'torch.optim.adam.Adam'>, betas=(0.9, 0.99)), loss_func=FlattenedLoss of CrossEntropyLoss(), metrics=[<function IoU at 0x000001BDF50C2D90>], true_wd=True, bn_wd=True, wd=0.01, train_bn=True, path=WindowsPath('.'), model_dir='models', callback_fns=[functools.partial(<class 'fastai.basic_train.Recorder'>, add_time=True, silent=False)], callbacks=[...], layer_groups=[Sequential(\n",
       "  (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
       "  (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (2): ReLU(inplace)\n",
       "  (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "  (4): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (5): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (6): ReLU(inplace)\n",
       "  (7): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (8): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (9): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (10): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (11): ReLU(inplace)\n",
       "  (12): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (13): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (14): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "  (15): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (16): ReLU(inplace)\n",
       "  (17): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (18): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (19): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "  (20): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (21): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (22): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (23): ReLU(inplace)\n",
       "  (24): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (25): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "), Sequential(\n",
       "  (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "  (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (2): ReLU(inplace)\n",
       "  (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (5): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "  (6): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (7): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (8): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (9): ReLU(inplace)\n",
       "  (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (11): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (12): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "  (13): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (14): ReLU(inplace)\n",
       "  (15): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (16): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (17): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "  (18): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (20): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (21): ReLU(inplace)\n",
       "  (22): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (23): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "), Sequential(\n",
       "  (0): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (1): ReLU()\n",
       "  (2): Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (3): ReLU(inplace)\n",
       "  (4): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (5): ReLU(inplace)\n",
       "  (6): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "  (7): PixelShuffle(upscale_factor=2)\n",
       "  (8): ReplicationPad2d((1, 0, 1, 0))\n",
       "  (9): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "  (10): ReLU(inplace)\n",
       "  (11): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (12): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (13): ReLU(inplace)\n",
       "  (14): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (15): ReLU(inplace)\n",
       "  (16): ReLU()\n",
       "  (17): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "  (18): PixelShuffle(upscale_factor=2)\n",
       "  (19): ReplicationPad2d((1, 0, 1, 0))\n",
       "  (20): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "  (21): ReLU(inplace)\n",
       "  (22): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (23): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (24): ReLU(inplace)\n",
       "  (25): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (26): ReLU(inplace)\n",
       "  (27): ReLU()\n",
       "  (28): Conv2d(384, 768, kernel_size=(1, 1), stride=(1, 1))\n",
       "  (29): PixelShuffle(upscale_factor=2)\n",
       "  (30): ReplicationPad2d((1, 0, 1, 0))\n",
       "  (31): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "  (32): ReLU(inplace)\n",
       "  (33): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (34): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (35): ReLU(inplace)\n",
       "  (36): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (37): ReLU(inplace)\n",
       "  (38): ReLU()\n",
       "  (39): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "  (40): PixelShuffle(upscale_factor=2)\n",
       "  (41): ReplicationPad2d((1, 0, 1, 0))\n",
       "  (42): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "  (43): ReLU(inplace)\n",
       "  (44): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (45): Conv2d(192, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (46): ReLU(inplace)\n",
       "  (47): Conv2d(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (48): ReLU(inplace)\n",
       "  (49): ReLU()\n",
       "  (50): Conv2d(96, 384, kernel_size=(1, 1), stride=(1, 1))\n",
       "  (51): PixelShuffle(upscale_factor=2)\n",
       "  (52): ReplicationPad2d((1, 0, 1, 0))\n",
       "  (53): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "  (54): ReLU(inplace)\n",
       "  (55): MergeLayer()\n",
       "  (56): Conv2d(99, 99, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (57): ReLU(inplace)\n",
       "  (58): Conv2d(99, 99, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (59): ReLU(inplace)\n",
       "  (60): MergeLayer()\n",
       "  (61): Conv2d(99, 333415, kernel_size=(1, 1), stride=(1, 1))\n",
       ")], add_time=True, silent=False)\n",
       "loss_scale: 65536\n",
       "max_noskip: 1000\n",
       "dynamic: True\n",
       "clip: None\n",
       "flat_master: False\n",
       "max_scale: 16777216], layer_groups=[Sequential(\n",
       "  (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
       "  (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (2): ReLU(inplace)\n",
       "  (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "  (4): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (5): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (6): ReLU(inplace)\n",
       "  (7): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (8): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (9): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (10): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (11): ReLU(inplace)\n",
       "  (12): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (13): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (14): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "  (15): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (16): ReLU(inplace)\n",
       "  (17): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (18): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (19): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "  (20): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (21): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (22): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (23): ReLU(inplace)\n",
       "  (24): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (25): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "), Sequential(\n",
       "  (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "  (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (2): ReLU(inplace)\n",
       "  (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (5): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "  (6): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (7): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (8): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (9): ReLU(inplace)\n",
       "  (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (11): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (12): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "  (13): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (14): ReLU(inplace)\n",
       "  (15): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (16): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (17): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "  (18): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (20): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (21): ReLU(inplace)\n",
       "  (22): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "  (23): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "), Sequential(\n",
       "  (0): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (1): ReLU()\n",
       "  (2): Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (3): ReLU(inplace)\n",
       "  (4): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (5): ReLU(inplace)\n",
       "  (6): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "  (7): PixelShuffle(upscale_factor=2)\n",
       "  (8): ReplicationPad2d((1, 0, 1, 0))\n",
       "  (9): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "  (10): ReLU(inplace)\n",
       "  (11): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (12): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (13): ReLU(inplace)\n",
       "  (14): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (15): ReLU(inplace)\n",
       "  (16): ReLU()\n",
       "  (17): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
       "  (18): PixelShuffle(upscale_factor=2)\n",
       "  (19): ReplicationPad2d((1, 0, 1, 0))\n",
       "  (20): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "  (21): ReLU(inplace)\n",
       "  (22): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (23): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (24): ReLU(inplace)\n",
       "  (25): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (26): ReLU(inplace)\n",
       "  (27): ReLU()\n",
       "  (28): Conv2d(384, 768, kernel_size=(1, 1), stride=(1, 1))\n",
       "  (29): PixelShuffle(upscale_factor=2)\n",
       "  (30): ReplicationPad2d((1, 0, 1, 0))\n",
       "  (31): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "  (32): ReLU(inplace)\n",
       "  (33): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (34): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (35): ReLU(inplace)\n",
       "  (36): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (37): ReLU(inplace)\n",
       "  (38): ReLU()\n",
       "  (39): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1))\n",
       "  (40): PixelShuffle(upscale_factor=2)\n",
       "  (41): ReplicationPad2d((1, 0, 1, 0))\n",
       "  (42): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "  (43): ReLU(inplace)\n",
       "  (44): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (45): Conv2d(192, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (46): ReLU(inplace)\n",
       "  (47): Conv2d(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (48): ReLU(inplace)\n",
       "  (49): ReLU()\n",
       "  (50): Conv2d(96, 384, kernel_size=(1, 1), stride=(1, 1))\n",
       "  (51): PixelShuffle(upscale_factor=2)\n",
       "  (52): ReplicationPad2d((1, 0, 1, 0))\n",
       "  (53): AvgPool2d(kernel_size=2, stride=1, padding=0)\n",
       "  (54): ReLU(inplace)\n",
       "  (55): MergeLayer()\n",
       "  (56): Conv2d(99, 99, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (57): ReLU(inplace)\n",
       "  (58): Conv2d(99, 99, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (59): ReLU(inplace)\n",
       "  (60): MergeLayer()\n",
       "  (61): Conv2d(99, 333415, kernel_size=(1, 1), stride=(1, 1))\n",
       ")], add_time=True, silent=False)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "learn.lr_find() # find learning rate\n",
    "learn.recorder.plot() # plot learning rate graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "lr = 1e-3 # pick a lr\n",
    "learn.fit_one_cycle(10, slice(lr), pct_start=0.9, callbacks=[MixedPrecision(learn)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}