CustomImageLoaderFromFolder.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/farzin/anaconda3/envs/fastaiv1/lib/python3.7/importlib/_bootstrap.py:219: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n",
      "  return f(*args, **kwds)\n"
     ]
    }
   ],
   "source": [
    "from fastai import *\n",
    "from fastai.vision import *\n",
    "\n",
    "## for npz conversion of target\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "import cv2\n",
    "\n",
    "from fastai.data_block import ItemList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/farzin/fast_ai/fastai_docs/dev_nb\r\n"
     ]
    }
   ],
   "source": [
    "!pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.npz\r\n",
      "0.tif\r\n",
      "100.npz\r\n",
      "100.tif\r\n",
      "101.npz\r\n",
      "101.tif\r\n",
      "102.npz\r\n",
      "102.tif\r\n",
      "103.npz\r\n",
      "103.tif\r\n"
     ]
    }
   ],
   "source": [
    "!ls /home/farzin/image_tmp/all/ | head"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As needed, run to generate the .npz files\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "data_dir = '/home/farzin/image_tmp/all/'\n",
    "for this_image in os.listdir(data_dir):\n",
    "    if this_image.endswith('.tif'):\n",
    "        img = plt.imread(f'{data_dir}{this_image}')\n",
    "        #channel 4 is all 255, drop it\n",
    "        label = cv2.resize(img[:,:,:3],(int(img.shape[1]/8),int(img.shape[0]/8)),interpolation = cv2.INTER_CUBIC)*64\n",
    "        label = cv2.cvtColor(label, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "        npy_label = '{}{}.npz'.format(data_dir,this_image[:-4])\n",
    "        np.savez_compressed(npy_label,label.astype(np.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "This code needs the latest data_block.py file with the following lines:\n",
    "https://github.com/fastai/fastai/blob/master/fastai/data_block.py#L48\n",
    "\n",
    "48      self.items,self.x = items,x\n",
    "49      if not isinstance(self.items,np.ndarray): self.items = array(self.items, dtype=object)\n",
    "'''\n",
    "\n",
    "## Extend the ImageItemList to include a custom_label method\n",
    "class CustomImageItemList(ImageItemList):    \n",
    "    def custom_label(self,**kwargs)->'LabelList':\n",
    "        '''custom label from path and npy directory'''        \n",
    "        #self.items is an np array of PosixPath objects with each image path\n",
    "        target_filenames = [Path(str(x).replace('.tif','.npz')) for x in self.items]\n",
    "        target_np_array = np.array([np.load(x)['arr_0'] for x in target_filenames],dtype=np.float32) #can't be type='object'\n",
    "        \n",
    "        y = ItemList(items=target_np_array[:,None,:,:]) #goes to [N,1,32,32]\n",
    "        res = self._label_list(x=self,y=y)   # like this: https://github.com/fastai/fastai/blob/master/fastai/data_block.py#L221\n",
    "\n",
    "        return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "cust_list = CustomImageItemList.from_folder('/home/farzin/image_tmp/all/',extensions='.tif')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_data_bunch = cust_list.random_split_by_pct(0.2).custom_label().databunch()\n",
    "my_data_bunch.batch_size=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model \n",
    "class C1Net(nn.Module):\n",
    "    def __init__(self, load_weights=False):\n",
    "        super(C1Net, self).__init__()\n",
    "\n",
    "        \n",
    "        self.middleConv1 = nn.Conv2d(3, 256, kernel_size=3, padding=1)\n",
    "        self.mp1 = nn.MaxPool2d(kernel_size=2, stride=2,dilation=1 )\n",
    "        self.middleConv2 = nn.Conv2d(256, 256, kernel_size=3, padding=1)\n",
    "        self.mp2 = nn.MaxPool2d(kernel_size=2, stride=2,dilation=1 )\n",
    "        self.middleConv3 = nn.Conv2d(256, 256, kernel_size=3, padding=1)\n",
    "        self.mp3 = nn.MaxPool2d(kernel_size=2, stride=2,dilation=1)\n",
    "        self.middleConv6 = nn.Conv2d(256, 1, kernel_size=3, padding=1)\n",
    "        \n",
    "        \n",
    "        \n",
    "    def forward(self,x_in):                \n",
    "        x= F.relu(self.middleConv1(x_in))\n",
    "        x=self.mp1(x)\n",
    "        x= F.relu(self.middleConv2(x))\n",
    "        x=self.mp2(x)\n",
    "        x= F.relu(self.middleConv3(x))\n",
    "        x=self.mp3(x)\n",
    "        x= F.relu(self.middleConv6(x))\n",
    "#        import pdb;pdb.set_trace()\n",
    "\n",
    "        return x\n",
    "      \n",
    "    def _initialize_weights(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                nn.init.normal_(m.weight, std=0.01)\n",
    "                if m.bias is not None:\n",
    "                    nn.init.constant_(m.bias, 0)\n",
    "            elif isinstance(m, nn.BatchNorm2d):\n",
    "                nn.init.constant_(m.weight, 1)\n",
    "                nn.init.constant_(m.bias, 0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "C1Net(\n",
       "  (middleConv1): Conv2d(3, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (mp1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (middleConv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (mp2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (middleConv3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (mp3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (middleConv6): Conv2d(256, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       ")"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = C1Net()#.cuda()\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/farzin/anaconda3/envs/fastaiv1/lib/python3.7/site-packages/torch/nn/_reduction.py:49: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.\n",
      "  warnings.warn(warning.format(ret))\n"
     ]
    }
   ],
   "source": [
    "learn = Learner(my_data_bunch, model,metrics=accuracy)\n",
    "learn.loss_func=nn.MSELoss(size_average=False)#.cuda()  # Loss must be this.. !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n"
     ]
    }
   ],
   "source": [
    "learn.lr_find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.recorder.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python3 (fastai v1)",
   "language": "python",
   "name": "fastaiv1"
  },
  "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.7.0"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}