S2_Segmentation_and_Ultrasound/Ultrasound Nerve Segmentation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Download and review the data at the link below:\n",
    "https://www.kaggle.com/c/ultrasound-nerve-segmentation/data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import of different libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example of installing the additional required libraries\n",
    "\n",
    "# !pip install tifffile \n",
    "# !pip install imagecodecs "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import re\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import cv2\n",
    "from tqdm import tqdm\n",
    "from glob import glob\n",
    "from PIL import Image\n",
    "from skimage.transform import resize\n",
    "from sklearn.model_selection import train_test_split, KFold\n",
    "\n",
    "import shutil\n",
    "\n",
    "import torch\n",
    "from torch.utils.data import DataLoader,Dataset\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import albumentations\n",
    "import torchvision \n",
    "from torchvision import transforms, models, utils\n",
    "\n",
    "from torch.autograd import Variable\n",
    "from torch.nn import Linear, ReLU, CrossEntropyLoss, Sequential, Conv2d, MaxPool2d, Module, Softmax, BatchNorm2d, Dropout\n",
    "from torch.optim import Adam, SGD\n",
    "\n",
    "import random\n",
    "from skimage import io,transform\n",
    "from PIL import Image\n",
    "\n",
    "from sklearn import model_selection\n",
    "\n",
    "import time\n",
    "from tqdm import tqdm\n",
    "\n",
    "import warnings \n",
    "\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#set device config: using either GPU or CPU\n",
    "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a dataframe of references and paths\n",
    "\n",
    "ROOT = \"./ultrasound-nerve-segmentation/\"\n",
    "trainpath = \"./ultrasound-nerve-segmentation/train/\"\n",
    "testpath = \"./ultrasound-nerve-segmentation/test/\"\n",
    "\n",
    "masks = [os.path.join(trainpath,i) for i in os.listdir(trainpath) if \"mask\" in i]\n",
    "imgs = [i.replace(\"_mask\",\"\") for i in masks]\n",
    "\n",
    "df = pd.DataFrame({\"Image\":imgs,\"Mask\":masks})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  ensure it works by showing the example 3 lines\n",
    "df.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot 3 by 3 images from the dataset with the masks overlay\n",
    "\n",
    "rows,cols=3,3\n",
    "fig=plt.figure(figsize=(16,10))\n",
    "for i in range(1,rows*cols+1):\n",
    "    ii = random.randint(0, len(df))\n",
    "    fig.add_subplot(rows,cols,i)\n",
    "    img_path=df['Image'][ii]\n",
    "    msk_path=df['Mask'][ii]\n",
    "    plt.imshow(np.array(Image.open(img_path)), cmap = 'gray')\n",
    "    plt.imshow(np.array(Image.open(msk_path)),alpha=0.4, cmap = 'gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make folds\n",
    "\n",
    "def makesplits(df,k):\n",
    "    df[\"kfold\"] = -1\n",
    "    df = df.sample(frac=1).reset_index(drop=True)\n",
    "    kf = model_selection.KFold(n_splits=k)\n",
    "\n",
    "    for f,(t_,v_) in enumerate(kf.split(df)):\n",
    "        df.loc[v_,\"kfold\"] = f\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save the folds to the file for the further loading to reproduce the given split\n",
    "kfold_ = makesplits(df,5)\n",
    "kfold_.to_csv(\"Kfolds.csv\",index=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  define some basic augmentations to the training data\n",
    "def trainaugs():\n",
    "    transform =  [\n",
    "                albumentations.HorizontalFlip(),\n",
    "                albumentations.VerticalFlip()\n",
    "            ]\n",
    "    return albumentations.Compose(transform) # useful lib\n",
    "\n",
    "def valaugs():\n",
    "    transform = [\n",
    "                albumentations.HorizontalFlip(),\n",
    "                albumentations.VerticalFlip()\n",
    "            ]\n",
    "    return albumentations.Compose(transform)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dataloader, returns image and mask\n",
    "class NerveDataset(Dataset):\n",
    "    def __init__(self,imagespath,maskspath,augment=None):\n",
    "        self.imagespath = imagespath\n",
    "        self.maskspath = maskspath\n",
    "        self.augment = augment\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.imagespath)\n",
    "    \n",
    "    def __getitem__(self,idx):\n",
    "        image = self.imagespath[idx]\n",
    "        mask = self.maskspath[idx]\n",
    "        image = io.imread(image)\n",
    "        mask = io.imread(mask)\n",
    "        image = transform.resize(image=image,output_shape=(256,256,3)) # (256,256,3)\n",
    "        image = image/255.0\n",
    "        mask = transform.resize(mask,(256,256))  # (256,256,1)\n",
    "        mask = mask / 255.0\n",
    "        \n",
    "        if self.augment:\n",
    "            sample = self.augment(image=image, mask=mask)\n",
    "            image,mask = sample['image'],sample['mask']\n",
    "            \n",
    "        image = image.transpose((2, 0, 1)) # (3,256,256)\n",
    "        mask = np.expand_dims(mask,axis=-1).transpose((2,0,1)) # (1,256,256)\n",
    "            \n",
    "        image = torch.from_numpy(image)\n",
    "        mask = torch.from_numpy(mask)\n",
    "            \n",
    "        return image,mask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create neural network "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here we define the convolution network, the classical U-Net implementation\n",
    "class ConvBlock(nn.Module):\n",
    "    def __init__(self,in_channels,out_channels,kernel_size=(3,3),padding=1):\n",
    "        super(ConvBlock,self).__init__()\n",
    "        self.conv = nn.Conv2d(in_channels,out_channels,kernel_size,padding=padding,bias=False)\n",
    "        self.batchnorm = nn.BatchNorm2d(out_channels,eps=1e-4)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        \n",
    "    def forward(self,x):\n",
    "        x = self.conv(x)\n",
    "        x = self.batchnorm(x)\n",
    "        x = self.relu(x)\n",
    "        return x\n",
    "        \n",
    "#  Encoder        \n",
    "class StackEncoder(nn.Module):\n",
    "    def __init__(self,channel1,channel2,kernel_size=(3,3),padding=1):\n",
    "        super(StackEncoder,self).__init__()\n",
    "        self.maxpool = nn.MaxPool2d(kernel_size=2,stride=2)\n",
    "        self.block = nn.Sequential(\n",
    "            ConvBlock(channel1,channel2,kernel_size,padding),\n",
    "            ConvBlock(channel2,channel2,kernel_size,padding),     \n",
    "        )\n",
    "        \n",
    "    def forward(self,x):\n",
    "        big_out = self.block(x)\n",
    "        poolout = self.maxpool(big_out)\n",
    "        return big_out,poolout\n",
    "#  Decoder       \n",
    "class StackDecoder(nn.Module):\n",
    "    def __init__(self,big_channel,channel1,channel2,kernel_size=(3,3),padding=1):\n",
    "        super(StackDecoder,self).__init__()\n",
    "        self.block = nn.Sequential(\n",
    "            ConvBlock(channel1+big_channel,channel2,kernel_size,padding),\n",
    "            ConvBlock(channel2,channel2,kernel_size,padding),\n",
    "            ConvBlock(channel2,channel2,kernel_size,padding),\n",
    "        )\n",
    "        \n",
    "    def forward(self,x,down_tensor):\n",
    "            _, channels, height, width = down_tensor.size()  \n",
    "            x = F.upsample(x, size=(height, width), mode='bilinear')\n",
    "            x = torch.cat([x, down_tensor], 1)  #combining channels of  input from encoder and upsampling input\n",
    "            x = self.block(x)\n",
    "            return x\n",
    "        \n",
    "#  U-Net       \n",
    "class Unet256(nn.Module):\n",
    "    def __init__(self,input_shape):\n",
    "        super(Unet256,self).__init__()\n",
    "        \n",
    "        channel,height,width = input_shape\n",
    "        \n",
    "        self.down1 = StackEncoder(channel,12,kernel_size=(3,3))  #256\n",
    "        self.down2 = StackEncoder(12,24,kernel_size=(3,3))  # 128\n",
    "        self.down3 = StackEncoder(24,46,kernel_size=(3,3))  # 64\n",
    "        self.down4 = StackEncoder(46,64,kernel_size=(3,3))  # 32\n",
    "        self.down5 = StackEncoder(64,128,kernel_size=(3,3))  #16\n",
    "        \n",
    "        self.center = ConvBlock(128,128,kernel_size=(3,3),padding=1) #16\n",
    "        self.up5 = StackDecoder(128,128,64,kernel_size=(3,3))  #32\n",
    "        self.up4 = StackDecoder(64,64,46,kernel_size=(3,3)) #64\n",
    "        self.up3 = StackDecoder(46,46,24,kernel_size=(3,3))\n",
    "        self.up2 = StackDecoder(24,24,12,kernel_size=(3,3))\n",
    "        self.up1 = StackDecoder(12,12,12,kernel_size=(3,3))\n",
    "        self.conv = Conv2d(12,1,kernel_size=(1,1),bias=True)\n",
    "        \n",
    "    def forward(self,x):\n",
    "        down1,out = self.down1(x)  \n",
    "        down2,out = self.down2(out)  \n",
    "        down3,out = self.down3(out)\n",
    "        down4,out = self.down4(out)\n",
    "        down5,out = self.down5(out)\n",
    "        \n",
    "        \n",
    "        out = self.center(out)\n",
    "        \n",
    "        up5 = self.up5(out,down5)\n",
    "        up4 = self.up4(up5,down4)\n",
    "        up3 = self.up3(up4,down3)\n",
    "        up2 = self.up2(up3,down2)\n",
    "        up1 = self.up1(up2,down1)\n",
    "        \n",
    "        out = self.conv(up1)\n",
    "\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metrics and Losses"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here we define the loss and the metric for the segmentation task:\n",
    "#  Loss\n",
    "class DiceLoss(nn.Module):\n",
    "    def __init__(self, weight=None, size_average=True):\n",
    "        super(DiceLoss, self).__init__()\n",
    "\n",
    "    def forward(self, inputs, targets, smooth=1):\n",
    "        inputs = F.sigmoid(inputs)       \n",
    "        #flatten label and prediction tensors\n",
    "        inputs = inputs.view(-1)\n",
    "        targets = targets.view(-1)\n",
    "        \n",
    "        intersection = (inputs * targets).sum()                            \n",
    "        dice_loss = 1 - (2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth)\n",
    "        return dice_loss\n",
    "\n",
    "    \n",
    "#   Score  \n",
    "class DiceScore(nn.Module):\n",
    "    def __init__(self, weight=None, size_average=True):\n",
    "        super(DiceScore, self).__init__()\n",
    "\n",
    "    def forward(self, inputs, targets, smooth=1):\n",
    "        inputs = F.sigmoid(inputs)       \n",
    "        #flatten label and prediction tensors\n",
    "        inputs = inputs.view(-1)\n",
    "        targets = targets.view(-1)\n",
    "        intersection = (inputs * targets).sum()                            \n",
    "        dice_score = (2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth) \n",
    "        return dice_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Defining the training process function  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's now train our model\n",
    "def trainfold(fold):\n",
    "    train_loss = []\n",
    "    train_dice = []\n",
    "    val_loss = []\n",
    "    val_dice = []\n",
    "    epochs = 2\n",
    "    train_bs= 8\n",
    "    val_bs = 4\n",
    "    \n",
    "    FILE = f\"./savedmodels/model_Fold_{fold}.pth\"\n",
    "    \n",
    "    if not os.path.exists(\"./savedmodels\"):\n",
    "        os.mkdir(\"savedmodels\")\n",
    "        \n",
    "    print(f\"*\"*20,\"FOLD\",fold, \"*\"*20)\n",
    "    df = pd.read_csv(\"Kfolds.csv\")\n",
    "    df_train = df[df.kfold != fold].reset_index(drop=True)\n",
    "    df_val = df[df.kfold == fold].reset_index(drop=True)\n",
    "    \n",
    "    traindata = NerveDataset(imagespath = df_train['Image'].tolist(),\n",
    "                            maskspath = df_train['Mask'].tolist(),\n",
    "                        augment=trainaugs())\n",
    "\n",
    "    validationdata = NerveDataset(imagespath = df_val['Image'].tolist(),\n",
    "                                maskspath = df_val['Mask'].tolist(),augment=valaugs())\n",
    "\n",
    "    trainloader = DataLoader(traindata,batch_size = train_bs,shuffle=True)\n",
    "    valloader = DataLoader(validationdata,batch_size=val_bs,shuffle=False)\n",
    "    \n",
    "    model = Unet256((3,256,256)).to(device)\n",
    "    criterion = DiceLoss() # here we use the aforementioned Loss function\n",
    "    learning_rate = 1e-3\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) # use a standard approach with the Adam optimizer with the given learning rate\n",
    "    \n",
    "    for epoch in range(epochs):\n",
    "        print('Epoch {}/{}'.format(epoch + 1, epochs))\n",
    "        start_time = time.time()\n",
    "        running_train_loss = []\n",
    "\n",
    "        tk_train = tqdm(trainloader,total = len(trainloader))\n",
    "        for image,mask in tk_train: \n",
    "                image = image.to(device,dtype=torch.float)\n",
    "                mask = mask.to(device,dtype=torch.float)\n",
    "\n",
    "                pred_mask = model.forward(image) # forward propogation\n",
    "                loss = criterion(pred_mask,mask)\n",
    "                optimizer.zero_grad() # setting gradient to zero\n",
    "                loss.backward()\n",
    "                optimizer.step() # the step of the optimizer\n",
    "                running_train_loss.append(loss.item())\n",
    "        else:           \n",
    "            running_val_loss = [] # validation loss\n",
    "            \n",
    "            with torch.no_grad():\n",
    "                tk_val = tqdm(valloader,total = len(valloader))\n",
    "                for image,mask in tk_val:\n",
    "                        image = image.to(device,dtype=torch.float)\n",
    "                        mask = mask.to(device,dtype=torch.float)                            \n",
    "                        pred_mask = model.forward(image)\n",
    "                        loss = criterion(pred_mask,mask)\n",
    "                        running_val_loss.append(loss.item())\n",
    "\n",
    "        epoch_train_loss = np.mean(running_train_loss) \n",
    "        print(f'Fold: {fold} <---> Epoch: {epoch + 1} <---> Train DiceLoss: {epoch_train_loss}')                       \n",
    "        train_loss.append(epoch_train_loss)\n",
    "        \n",
    "        epoch_val_loss = np.mean(running_val_loss)\n",
    "        print(f'Fold: {fold} <---> Epoch: {epoch + 1} <---> Validation DiceLoss: {epoch_val_loss}')                                \n",
    "        val_loss.append(epoch_val_loss)\n",
    "        \n",
    "\n",
    "        time_elapsed = time.time() - start_time\n",
    "        print('Fold {}: Time Taken: {:.0f}m {:.0f}s'.format(fold,time_elapsed // 60, time_elapsed % 60))\n",
    "        \n",
    "    torch.save(model.state_dict(), FILE)\n",
    "        \n",
    "    return train_loss, val_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Let's train:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loss, val_loss = trainfold(0)"
   ]
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}