N-Channeled-Input-UNet .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_P1rjO-JREDT"
   },
   "source": [
    "# N-Channeled-Input-UNet-Fastai"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 602,
     "status": "ok",
     "timestamp": 1564841093985,
     "user": {
      "displayName": "Navid Panchi",
      "photoUrl": "https://lh3.googleusercontent.com/-NM0Kl46VUA4/AAAAAAAAAAI/AAAAAAAABmU/OhXG5uRldO0/s64/photo.jpg",
      "userId": "09152995784921614215"
     },
     "user_tz": -330
    },
    "id": "BJftnXs3REDc",
    "outputId": "ffcef4ed-3d7c-4a2a-98b8-041c76ab06f6"
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "IPython.notebook.set_autosave_interval(10000)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Autosaving every 10 seconds\n"
     ]
    }
   ],
   "source": [
    "%reload_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n",
    "%autosave 10\n",
    "\n",
    "from fastai.vision import *\n",
    "from fastai.utils.mem import *\n",
    "from fastai.vision.learner import cnn_config # notice this extra import \n",
    "from torch.utils.data import Dataset\n",
    "import torch.nn as nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 110
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 16714,
     "status": "ok",
     "timestamp": 1564826367488,
     "user": {
      "displayName": "Navid Panchi",
      "photoUrl": "https://lh3.googleusercontent.com/-NM0Kl46VUA4/AAAAAAAAAAI/AAAAAAAABmU/OhXG5uRldO0/s64/photo.jpg",
      "userId": "09152995784921614215"
     },
     "user_tz": -330
    },
    "id": "wQMvSjhOREDw",
    "outputId": "9478cd03-696f-4ec3-d31d-35dfd2e06043"
   },
   "outputs": [],
   "source": [
    "torch.cuda.set_device(1) # comment this out "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RAZqKkVTREEV"
   },
   "source": [
    "## Data\n",
    "\n",
    "Don't worry about this, you can use a pytorch dataset similar to this for reading the input \n",
    "images/ arrays, I would recommend using a pytorch dataloader for this purpose in this \n",
    "case because it might take time for you to figure out to get fastai datasets to work with \n",
    "n channeled datasets. You wont loose much functionality as anyway you can't plot your \n",
    "array/images using show_batch() method, If you want to make sure your input shape is correct\n",
    "use `data.train_ds[0][0].shape` to check the shape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DataBunch;\n",
       "\n",
       "Train: <__main__.NChanneledDataset object at 0x7f573244f128>;\n",
       "\n",
       "Valid: <__main__.NChanneledDataset object at 0x7f573244f160>;\n",
       "\n",
       "Test: None"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class NChanneledDataset(Dataset):\n",
    "    def __init__(self, n_input_channels=5, n_output_channels=2):\n",
    "        super().__init__()\n",
    "        self.n_input_channels = n_input_channels\n",
    "        self.c = n_output_channels\n",
    "        \n",
    "    def __len__(self):\n",
    "        return 100 # just some dummy value\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        #read your nchannled array, image\n",
    "        x = torch.randn(self.n_input_channels, 224, 224)\n",
    "        y = torch.randint(low=0, high=self.c, size=(224, 224))\n",
    "        return x, y \n",
    "\n",
    "train_ds = NChanneledDataset()\n",
    "valid_ds = NChanneledDataset()\n",
    "\n",
    "data = DataBunch.create(train_ds=train_ds, valid_ds=valid_ds, bs=2)\n",
    "\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "X4TkFmatREGO"
   },
   "source": [
    "## unet_learner function\n",
    "\n",
    "This function has been copied from the source given in the docs [link](https://github.com/fastai/fastai/blob/c667c17d4b684ff174795748d747d9e7180d8b1e/fastai/vision/learner.py#L109). I have made a few changes in type casting for input paramters (won't make a difference). Also, I have changed how it gets the size dimensions, just to be safe. \n",
    "The major change is changing the first layer of the model before it goes into the Dynamic Unet creator. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unet_learner(data:DataBunch, arch:Callable, pretrained:bool=True, blur_final:bool=True,\n",
    "                 norm_type:Optional[NormType]=NormType, split_on=None, blur:bool=False,\n",
    "                 self_attention:bool=False, y_range=None, last_cross:bool=True,\n",
    "                 bottle:bool=False, cut=None, **learn_kwargs:Any)->Learner:\n",
    "    \"Build Unet learner from `data` and `arch`.\"\n",
    "    \n",
    "    # I have defined size intentionally like this, so that it won't be a problem when \n",
    "    # the input is an image \n",
    "    size = next(iter(data.train_dl))[0].shape[-2:]\n",
    "    n_input_channels = next(iter(data.train_dl))[0][0].size(0)    \n",
    "        \n",
    "    meta = cnn_config(arch)\n",
    "    body = create_body(arch, pretrained, cut)\n",
    "    \n",
    "    # changing the first layer to suit our input\n",
    "    if not n_input_channels == 3: \n",
    "        prev_layer = body[0]\n",
    "        body[0] = nn.Conv2d(n_input_channels, prev_layer.out_channels, \n",
    "                      kernel_size=prev_layer.kernel_size, \n",
    "                      stride=prev_layer.stride, \n",
    "                      padding=prev_layer.padding, \n",
    "                      bias=prev_layer.bias)\n",
    "\n",
    "    model = to_device(models.unet.DynamicUnet(body, n_classes=data.c, img_size=size, blur=blur, blur_final=blur_final,\n",
    "          self_attention=self_attention, y_range=y_range, norm_type=norm_type, last_cross=last_cross,\n",
    "          bottle=bottle), data.device)\n",
    "    learn = Learner(data, model, **learn_kwargs)\n",
    "    learn.split(ifnone(split_on, meta['split']))\n",
    "    if pretrained and n_input_channels == 3: \n",
    "        learn.freeze()\n",
    "        apply_init(model[2], nn.init.kaiming_normal_)\n",
    "    else: apply_init(model, nn.init.kaiming_normal_)\n",
    "    return learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = unet_learner(data, models.resnet34) # instantiate a learner for testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## testing\n",
    "\n",
    "I have used fit one cycle function just to make sure it is trianing (although on dummy data). I have also used the `model` attribute of the learner to get the model out and test it on a dummy pytorch tensor. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>-2103742498754765166477312.000000</td>\n",
       "      <td>-4764930615437473093779456.000000</td>\n",
       "      <td>00:13</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(1) # dont care about the loss as the data is dummy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = learn.model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 2, 224, 224])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model(torch.randn(2, 5, 224, 224).cuda()).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [
    "fMWTKdrnREF4",
    "X4TkFmatREGO",
    "cNeonguZYn-V",
    "eyaQxUpDG7EE"
   ],
   "name": "Nabil Seg-GAN",
   "provenance": [
    {
     "file_id": "https://github.com/fastai/course-v3/blob/master/nbs/dl1/lesson3-camvid.ipynb",
     "timestamp": 1564580563429
    }
   ],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "FASTAI",
   "language": "python",
   "name": "fastai"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}