Single_Pathway_DeepMedic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "This code reimplements the project Single-Pathway DeepMedic. You can use this code to learn 3D medical image segemntation.\n",
    "\n",
    "It is a basic CNN network from DeepMedic to segment brain tumor, but we use dilation convolution in some layers. The traing process uses $75*75*75$ images to get $47*47*47$ prediction. However, we use full size image to test the model and get DICE score and save the segmentation results. You can use 3D slicer to visualize the .mha and .nii file. The DICE score is not good enough, you can change hyperparameters such as learning rate and batch size to improve the DICE score in the training process, even you can change the testing program for better performance and we believe that it will help.\n",
    "\n",
    "This code needs about 8GB GPU memory. If you don't have enough memory, you can reduce the crop size and batch size, even you can use [Google Colab](https://colab.research.google.com/) for free GPU just requiring minor changes. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Requirements\n",
    "Pytorch 1.0 \n",
    "\n",
    "Nibabel   \n",
    "\n",
    "SimpleITK\n",
    "\n",
    "\n",
    "# Data\n",
    "You can download the dataset from http://cseweb.ucsd.edu/~yaq007/dataset.zip,  which is subset of [BraTs 2015](https://www.smir.ch/BRATS/Start2015), and this subset have 20 brain turmor subjects for training and 54 subjects for testing which include four moldalities: FLAIR, T1, T1c, T2, and mask and ground truth. The ground truth of patient images have four different labels:\n",
    "\n",
    "* label 1: necrosis\n",
    "* label 2: edema\n",
    "* label 3: non-enhancing tumor\n",
    "* label 4: enhancing tumor\n",
    "* label 0: everything else\n",
    "\n",
    "The evaluation is done for 3 different tumor sub-compartements:\n",
    "* Whole tumor: label 1, 2, 3, 4\n",
    "* Enhance tumor: label 4\n",
    "* Tumor core: 1, 3, 4\n",
    "\n",
    "# Trained Models\n",
    "You can download the the trained models from [here](http://cseweb.ucsd.edu/~yaq007/models.tar.gz)(the Basic models corespond to our project), which is from the project [Autofocus Layer for Semantic Segmentation](https://github.com/yaq007/Autofocus-Layer)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "from torch.autograd import Variable\n",
    "import torch.optim as optim\n",
    "import torch.backends.cudnn as cudnn\n",
    "from torch.utils.data import DataLoader\n",
    "from dataset import TrainDataset\n",
    "import os\n",
    "import nibabel as nib\n",
    "import argparse\n",
    "from utils import AverageMeter\n",
    "# from distutils.version import LooseVersion\n",
    "import math\n",
    "import SimpleITK as sitk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define the network \n",
    "This network is Single-Pathway Deepmedic, you can check this [paper](https://www.sciencedirect.com/science/article/pii/S1361841516301839) for further research."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DataParallel(\n",
      "  (module): Basic(\n",
      "    (conv1): Conv3d(4, 30, kernel_size=(3, 3, 3), stride=(1, 1, 1))\n",
      "    (bn1): BatchNorm3d(30, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu): ReLU(inplace)\n",
      "    (conv2): Conv3d(30, 30, kernel_size=(3, 3, 3), stride=(1, 1, 1))\n",
      "    (bn2): BatchNorm3d(30, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (layer3): BasicBlock(\n",
      "      (conv1): Conv3d(30, 40, kernel_size=(3, 3, 3), stride=(1, 1, 1), dilation=(2, 2, 2))\n",
      "      (bn1): BatchNorm3d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (conv2): Conv3d(40, 40, kernel_size=(3, 3, 3), stride=(1, 1, 1), dilation=(2, 2, 2))\n",
      "      (bn2): BatchNorm3d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace)\n",
      "      (downsample): Sequential(\n",
      "        (0): Conv3d(30, 40, kernel_size=(1, 1, 1), stride=(1, 1, 1))\n",
      "        (1): BatchNorm3d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      )\n",
      "    )\n",
      "    (layer4): BasicBlock(\n",
      "      (conv1): Conv3d(40, 40, kernel_size=(3, 3, 3), stride=(1, 1, 1), dilation=(2, 2, 2))\n",
      "      (bn1): BatchNorm3d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (conv2): Conv3d(40, 40, kernel_size=(3, 3, 3), stride=(1, 1, 1), dilation=(2, 2, 2))\n",
      "      (bn2): BatchNorm3d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace)\n",
      "    )\n",
      "    (layer5): BasicBlock(\n",
      "      (conv1): Conv3d(40, 50, kernel_size=(3, 3, 3), stride=(1, 1, 1), dilation=(2, 2, 2))\n",
      "      (bn1): BatchNorm3d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (conv2): Conv3d(50, 50, kernel_size=(3, 3, 3), stride=(1, 1, 1), dilation=(2, 2, 2))\n",
      "      (bn2): BatchNorm3d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace)\n",
      "      (downsample): Sequential(\n",
      "        (0): Conv3d(40, 50, kernel_size=(1, 1, 1), stride=(1, 1, 1))\n",
      "        (1): BatchNorm3d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      )\n",
      "    )\n",
      "    (fc): Conv3d(50, 5, kernel_size=(1, 1, 1), stride=(1, 1, 1))\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "class BasicBlock(nn.Module):\n",
    "    def __init__(self, inplanes1, outplanes1, outplanes2, kernel=3, downsample=None):\n",
    "        super(BasicBlock, self).__init__()\n",
    "        self.conv1 =nn.Conv3d(inplanes1, outplanes1, kernel_size=kernel,dilation=2)\n",
    "        self.bn1 = nn.BatchNorm3d(outplanes1)\n",
    "        self.conv2 =nn.Conv3d(outplanes1, outplanes2, kernel_size=kernel, dilation=2)\n",
    "        self.bn2 = nn.BatchNorm3d(outplanes2)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        if inplanes1==outplanes2:            \n",
    "            self.downsample = downsample\n",
    "        else:\n",
    "            self.downsample = nn.Sequential(nn.Conv3d(inplanes1, outplanes2, kernel_size=1), nn.BatchNorm3d(outplanes2))\n",
    "        \n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv3d):\n",
    "                m.weight.data.normal_(0, 0.01)\n",
    "            elif isinstance(m, nn.BatchNorm3d):\n",
    "                m.weight.data.fill_(1)\n",
    "                m.bias.data.zero_()\n",
    "    \n",
    "    def forward(self,x):\n",
    "        residual = x[:,:, 4:-4, 4:-4, 4:-4]\n",
    "        x = self.conv1(x)\n",
    "        x = self.bn1(x)\n",
    "        x = self.relu(x)\n",
    "    \n",
    "        x = self.conv2(x)\n",
    "        x = self.bn2(x)\n",
    "        \n",
    "        if self.downsample is not None:\n",
    "            residual = self.downsample(residual)\n",
    "        \n",
    "        x += residual\n",
    "        x = self.relu(x)\n",
    "        return x\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "class Basic(nn.Module):\n",
    "    def __init__(self, channels, kernel_size):\n",
    "        super(Basic, self).__init__()\n",
    "        \n",
    "        # parameters in the architecture\n",
    "\n",
    "        \n",
    "        self.channels = channels     \n",
    "        self.kernel_size = kernel_size\n",
    "        \n",
    "        # network architecture\n",
    "        self.conv1 = nn.Conv3d(self.channels[0], self.channels[1], kernel_size=self.kernel_size)\n",
    "        self.bn1 = nn.BatchNorm3d(self.channels[1])\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.conv2 = nn.Conv3d(self.channels[1], self.channels[2], kernel_size=self.kernel_size)\n",
    "        self.bn2 = nn.BatchNorm3d(self.channels[2])\n",
    "        \n",
    "        self.layer3 = BasicBlock(self.channels[2], self.channels[3], self.channels[4])\n",
    "        self.layer4 = BasicBlock(self.channels[4], self.channels[5], self.channels[6])\n",
    "        self.layer5 = BasicBlock(self.channels[6], self.channels[7], self.channels[8])\n",
    "           \n",
    "        self.fc = nn.Conv3d(self.channels[8], self.channels[9], kernel_size=1)\n",
    "        \n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv3d):\n",
    "                m.weight.data.normal_(0, 0.01)\n",
    "            elif isinstance(m, nn.BatchNorm3d):\n",
    "                m.weight.data.fill_(1)\n",
    "                m.bias.data.zero_()\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.bn1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.bn2(x)\n",
    "        x = self.relu(x)\n",
    "        \n",
    "        x = self.layer3(x)\n",
    "        x = self.layer4(x)        \n",
    "        x = self.layer5(x)\n",
    "              \n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "    \n",
    "# the first item of chanenels is the numbers of input, the last is the output classes.   \n",
    "channels = [4, 30, 30, 40, 40, 40, 40, 50, 50, 5]       \n",
    "kernel_size = 3\n",
    "model = Basic(channels, kernel_size)\n",
    "model = torch.nn.DataParallel(model, device_ids=list(range(1))).cuda()\n",
    "cudnn.benchmark = True\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # list the parameters of the model\n",
    "# params = list(model.parameters())\n",
    "# print(len(params))\n",
    "# print(params[0].size())  # conv1's .weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 5, 17, 17, 12])\n"
     ]
    }
   ],
   "source": [
    "# # This cell is used to test the model's output shape.\n",
    "input = torch.randn(1, 4, 45, 45, 40)\n",
    "out = model(input)\n",
    "print(out.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "from dataset import TrainDataset\n",
    "train_path = 'datalist/train_list.txt'\n",
    "train_file = open(train_path, 'r')\n",
    "train_dir = train_file.readlines()\n",
    "\n",
    "tf = TrainDataset(train_dir) # tf is the dataset, and this script uses 20 subjects.\n",
    "print(len(tf))\n",
    "train_loader = DataLoader(tf, batch_size=10, shuffle=True, num_workers=16, pin_memory=True)\n",
    "print(len(train_loader))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is cell and next is used to show image for fun.\n",
    "import matplotlib.pyplot as plt\n",
    "def show_image(image):\n",
    "    \"\"\"Show image slice\"\"\"\n",
    "    plt.imshow(image[0, :, :, 38], cmap='gray')\n",
    "\n",
    "\n",
    "def show_label(image):\n",
    "    \"\"\"Show label slice\"\"\"\n",
    "    plt.imshow(image[:, :, 38], cmap='gray')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 (4, 75, 75, 75) (75, 75, 75)\n",
      "1 (4, 75, 75, 75) (75, 75, 75)\n",
      "2 (4, 75, 75, 75) (75, 75, 75)\n",
      "3 (4, 75, 75, 75) (75, 75, 75)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10, 10))\n",
    "\n",
    "# sample = tf[3]\n",
    "# # 4 are 4 modalities, which are FLAIR, T1, T1c, T2, and 75*75*75 is 3D image patch.\n",
    "# print(sample['images'].shape, sample['labels'].shape)# (4, 75, 75, 75), (75, 75, 75)\n",
    "\n",
    "# np.savetxt('1.txt', sample['labels'][:, :, 38])\n",
    "for i in range(len(tf)):\n",
    "    sample = tf[i]\n",
    "\n",
    "    print(i, sample['images'].shape, sample['labels'].shape)\n",
    "\n",
    "    ax1 = plt.subplot(4, 2, 2*i+1)\n",
    "    plt.tight_layout()\n",
    "    ax1.set_title('Sample #{}, image'.format(i))\n",
    "    ax1.axis('off')\n",
    "    show_image(sample['images'])\n",
    "    ax2 = plt.subplot(4, 2, 2*i+2)\n",
    "    plt.tight_layout()\n",
    "    ax2.set_title('Sample #{}, label'.format(i))\n",
    "    ax2.axis('off')\n",
    "    show_label(sample['labels'])\n",
    "\n",
    "    if i == 3:\n",
    "        plt.show()\n",
    "        break\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define a Loss function and Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.RMSprop(model.parameters(), lr=1e-3, alpha=0.9, eps=10**(-4), weight_decay=1e-4, momentum=0.6)\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 0 |  lr: 0.001000 | Training Loss: 1.671\n",
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 1 |  lr: 0.001000 | Training Loss: 1.642\n",
      "   * EPOCH 1 | Training Loss: 1.642\n",
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 0 |  lr: 0.001000 | Training Loss: 1.470\n",
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 1 |  lr: 0.001000 | Training Loss: 1.344\n",
      "   * EPOCH 2 | Training Loss: 1.344\n",
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 0 |  lr: 0.001000 | Training Loss: 1.064\n",
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 1 |  lr: 0.001000 | Training Loss: 0.977\n",
      "   * EPOCH 3 | Training Loss: 0.977\n",
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 0 |  lr: 0.001000 | Training Loss: 0.762\n",
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 1 |  lr: 0.001000 | Training Loss: 0.738\n",
      "   * EPOCH 4 | Training Loss: 0.738\n",
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 0 |  lr: 0.001000 | Training Loss: 0.650\n",
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 1 |  lr: 0.001000 | Training Loss: 0.692\n",
      "   * EPOCH 5 | Training Loss: 0.692\n",
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 0 |  lr: 0.001000 | Training Loss: 0.631\n",
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 1 |  lr: 0.001000 | Training Loss: 0.638\n",
      "   * EPOCH 6 | Training Loss: 0.638\n",
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 0 |  lr: 0.001000 | Training Loss: 0.565\n",
      "torch.Size([10, 4, 75, 75, 75])\n",
      "torch.Size([10, 75, 75, 75])\n",
      "torch.Size([10, 5, 47, 47, 47])\n",
      "torch.Size([1038230, 5])\n",
      "torch.Size([1038230])\n",
      "   * i 1 |  lr: 0.001000 | Training Loss: 0.504\n",
      "   * EPOCH 7 | Training Loss: 0.504\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-da467c761ab6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m     \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 21\u001b[0;31m     \u001b[0;32mfor\u001b[0m \u001b[0miteration\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_loader\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     22\u001b[0m         \u001b[0mimage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msample\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'images'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m         \u001b[0mtarget\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msample\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'labels'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlong\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/Autofocus/lib/python3.6/site-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m__next__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    629\u001b[0m         \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    630\u001b[0m             \u001b[0;32massert\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshutdown\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbatches_outstanding\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 631\u001b[0;31m             \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    632\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbatches_outstanding\u001b[0m \u001b[0;34m-=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    633\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0midx\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrcvd_idx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/Autofocus/lib/python3.6/site-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_get_batch\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    599\u001b[0m             \u001b[0;32mwhile\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpin_memory_thread\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_alive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    600\u001b[0m                 \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 601\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata_queue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mMP_STATUS_CHECK_INTERVAL\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    602\u001b[0m                 \u001b[0;32mexcept\u001b[0m \u001b[0mqueue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mEmpty\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    603\u001b[0m                     \u001b[0;32mcontinue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/Autofocus/lib/python3.6/queue.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, block, timeout)\u001b[0m\n\u001b[1;32m    171\u001b[0m                     \u001b[0;32mif\u001b[0m \u001b[0mremaining\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0;36m0.0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    172\u001b[0m                         \u001b[0;32mraise\u001b[0m \u001b[0mEmpty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 173\u001b[0;31m                     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnot_empty\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mremaining\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    174\u001b[0m             \u001b[0mitem\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    175\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnot_full\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnotify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/Autofocus/lib/python3.6/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    297\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    298\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 299\u001b[0;31m                     \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    300\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    301\u001b[0m                     \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import os\n",
    "ckpt = './saved_models' # the directory of checkpoints.\n",
    "if not os.path.exists(ckpt):\n",
    "    os.mkdir(ckpt)\n",
    "\n",
    "particular_epoch = 100\n",
    "save_epochs_steps = 10\n",
    "\n",
    "start_epoch = 0\n",
    "num_epochs = 400\n",
    "\n",
    "num_classes = 5\n",
    "crop_size = [75,75,75]\n",
    "center_size = [47,47,47]\n",
    "running_lr = 1e-3\n",
    "\n",
    "for epoch in range(start_epoch + 1, num_epochs + 1):\n",
    "    losses = AverageMeter()\n",
    "\n",
    "    model.train()\n",
    "    for iteration, sample in enumerate(train_loader):\n",
    "        image = sample['images'].float()\n",
    "        target = sample['labels'].long()\n",
    "        image = Variable(image).cuda()\n",
    "        label = Variable(target).cuda()       \n",
    "        \n",
    "        print(image.shape)\n",
    "        print(target.shape)\n",
    "        # The dimension of out should be in the dimension of B,C,W,H,D\n",
    "        # transform the prediction and label\n",
    "        out = model(image) \n",
    "        print(out.shape)\n",
    "        out = out.permute(0,2,3,4,1).contiguous().view(-1, num_classes)# the size -1 is inferred from other dimensions\n",
    "        print(out.shape)\n",
    "        # extract the center part of the labels\n",
    "        start_index = []\n",
    "        end_index = []\n",
    "        for i in range(3):\n",
    "            start = int((crop_size[i] - center_size[i])/2)\n",
    "            start_index.append(start)\n",
    "            end_index.append(start + center_size[i])\n",
    "        label = label[:, start_index[0]:end_index[0], start_index[1]: end_index[1], start_index[2]: end_index[2]]\n",
    "        label = label.contiguous().view(-1).cuda()       \n",
    "        print(label.shape)\n",
    "        loss = criterion(out, label)\n",
    "        # losses.update(loss.data[0],image.size(0))\n",
    "        losses.update(loss.item(),image.size(0)) # changed by hjy\n",
    "\n",
    "        # compute gradient and do SGD step\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # adjust learning rate\n",
    "#         cur_iter = iteration + (epoch - 1) * args.epoch_iters\n",
    "#         adjust_learning_rate(optimizer, cur_iter, args)\n",
    "\n",
    "        print('   * i {} |  lr: {:.6f} | Training Loss: {losses.avg:.3f}'.format(iteration, running_lr, losses=losses))\n",
    "      \n",
    "    print('   * EPOCH {epoch} | Training Loss: {losses.avg:.3f}'.format(epoch=epoch, losses=losses))\n",
    "    if epoch > particular_epoch:\n",
    "        if epoch % save_epochs_steps == 0:\n",
    "            torch.save({'epoch': epoch, 'state_dict': model.state_dict(), 'opt_dict': optimizer.state_dict()},\\\n",
    "                      ckpt + '/' + str(epoch) + '_checkpoint.pth.tar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> Loading checkpoint 'saved_models/400_checkpoint.pth.tar'\n",
      "=> Loaded checkpoint (epoch 400)\n"
     ]
    }
   ],
   "source": [
    "# Loading the checkpoints for testing \n",
    "test_path = 'datalist/test_list.txt'\n",
    "ckpt_path = 'saved_models/400_checkpoint.pth.tar'\n",
    "\n",
    "if os.path.isfile(ckpt_path):\n",
    "    print(\"=> Loading checkpoint '{}'\".format(ckpt_path))\n",
    "    checkpoint = torch.load(ckpt_path)\n",
    "    state_dict = checkpoint['state_dict']\n",
    "    model.load_state_dict(state_dict)           \n",
    "    print(\"=> Loaded checkpoint (epoch {})\".format(checkpoint['epoch']))\n",
    "else:\n",
    "    raise Exception(\"=> No checkpoint found at '{}'\".format(ckpt_path)) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 240, 240, 155)\n"
     ]
    }
   ],
   "source": [
    "from  dataset import ValDataset_full\n",
    "test_file = open(test_path, 'r')\n",
    "test_dir = test_file.readlines()\n",
    "root_path = './'\n",
    "\n",
    "tf = ValDataset_full(test_dir)   \n",
    "sample = tf[0]\n",
    "print(sample['images'].shape)\n",
    "test_loader = DataLoader(tf, batch_size=1, shuffle=False, num_workers=16, pin_memory=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = './result' \n",
    "if not os.path.exists(result):\n",
    "    os.mkdir(result)\n",
    "    \n",
    "# save prediction results in the format of online submission\n",
    "def visualize_result(name, pred):\n",
    "    _, name1, _, name2 = name.split(\"/\")\n",
    "    _, _, _, _, _, name3, _ = name2.split(\".\")\n",
    "    pred = sitk.GetImageFromArray(pred)\n",
    "    sitk.WriteImage(pred, result + \"/VSD\"+\".\"+ str(name1) + '.'+ str(name3)+ '.mha')\n",
    "    \n",
    "def accuracy(pred, mask, label):\n",
    "    # columns in score is (# pred, # label, pred and label)\n",
    "    score = np.zeros([3,3])\n",
    "\n",
    "    # compute Enhance score (label==4) in the first line\n",
    "    score[0,0] = np.count_nonzero(pred * mask == 4)\n",
    "    score[0,1] = np.count_nonzero(label == 4)\n",
    "    score[0,2] = np.count_nonzero(pred * mask * label == 16)\n",
    "    \n",
    "    # compute Core score (label == 1,3,4) in the second line\n",
    "    pred[pred > 2] = 1\n",
    "    label[label > 2] = 1\n",
    "    score[1,0] = np.count_nonzero(pred * mask == 1)\n",
    "    score[1,1] = np.count_nonzero(label == 1)\n",
    "    score[1,2] = np.count_nonzero(pred * mask * label == 1)\n",
    "    \n",
    "    # compute Whole score (all labels) in the third line\n",
    "    pred[pred > 1] = 1\n",
    "    label[label > 1] = 1\n",
    "    score[2,0] = np.count_nonzero(pred * mask == 1)\n",
    "    score[2,1] = np.count_nonzero(label == 1)\n",
    "    score[2,2] = np.count_nonzero(pred * mask * label == 1)\n",
    "    return score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image: 0, Enhance score: 0.6290, Core score: 0.7813, Whole score: 0.7671\n",
      "Image: 1, Enhance score: 0.2993, Core score: 0.5772, Whole score: 0.7500\n",
      "Image: 2, Enhance score: 0.8039, Core score: 0.8805, Whole score: 0.8749\n",
      "Image: 3, Enhance score: 0.4983, Core score: 0.5189, Whole score: 0.5558\n",
      "Image: 4, Enhance score: 0.7134, Core score: 0.5215, Whole score: 0.8741\n",
      "Image: 5, Enhance score: 0.8161, Core score: 0.6965, Whole score: 0.7924\n",
      "Image: 6, Enhance score: 0.8257, Core score: 0.7931, Whole score: 0.8789\n",
      "Image: 7, Enhance score: 0.6469, Core score: 0.7425, Whole score: 0.6555\n",
      "Image: 8, Enhance score: 0.8250, Core score: 0.4866, Whole score: 0.8146\n",
      "Image: 9, Enhance score: 0.3477, Core score: 0.5051, Whole score: 0.5094\n",
      "Image: 10, Enhance score: 0.6834, Core score: 0.5726, Whole score: 0.9040\n",
      "Image: 11, Enhance score: 0.4444, Core score: 0.5263, Whole score: 0.6938\n",
      "Image: 12, Enhance score: 0.4780, Core score: 0.5621, Whole score: 0.8977\n",
      "Image: 13, Enhance score: 0.6453, Core score: 0.4914, Whole score: 0.8315\n",
      "Image: 14, Enhance score: 0.5046, Core score: 0.3478, Whole score: 0.6642\n",
      "Image: 15, Enhance score: 0.6145, Core score: 0.6818, Whole score: 0.6636\n",
      "Image: 16, Enhance score: 0.7943, Core score: 0.7709, Whole score: 0.8870\n",
      "Image: 17, Enhance score: 0.4880, Core score: 0.6994, Whole score: 0.7449\n",
      "Image: 18, Enhance score: 0.5864, Core score: 0.5943, Whole score: 0.5373\n",
      "Image: 19, Enhance score: 0.3769, Core score: 0.4134, Whole score: 0.4550\n",
      "Image: 20, Enhance score: 0.8216, Core score: 0.8193, Whole score: 0.8213\n",
      "Image: 21, Enhance score: 0.5260, Core score: 0.6289, Whole score: 0.7997\n",
      "Image: 22, Enhance score: 0.5688, Core score: 0.2617, Whole score: 0.5633\n",
      "Image: 23, Enhance score: 0.0597, Core score: 0.2154, Whole score: 0.3347\n",
      "Image: 24, Enhance score: 0.0902, Core score: 0.2068, Whole score: 0.3283\n",
      "Image: 25, Enhance score: 0.1319, Core score: 0.1868, Whole score: 0.3506\n",
      "Image: 26, Enhance score: 0.2626, Core score: 0.2579, Whole score: 0.5498\n",
      "Image: 27, Enhance score: 0.7693, Core score: 0.8297, Whole score: 0.6389\n",
      "Image: 28, Enhance score: 0.0829, Core score: 0.1820, Whole score: 0.4160\n",
      "Image: 29, Enhance score: 0.0075, Core score: 0.0529, Whole score: 0.5706\n",
      "Image: 30, Enhance score: 0.5376, Core score: 0.5610, Whole score: 0.7441\n",
      "Image: 31, Enhance score: 0.0009, Core score: 0.0161, Whole score: 0.2069\n",
      "Image: 32, Enhance score: 0.7852, Core score: 0.5973, Whole score: 0.8369\n",
      "Image: 33, Enhance score: 0.5983, Core score: 0.5778, Whole score: 0.7793\n",
      "Image: 34, Enhance score: 0.5845, Core score: 0.3457, Whole score: 0.5060\n",
      "Image: 35, Enhance score: 0.9434, Core score: 0.9500, Whole score: 0.9403\n",
      "Image: 36, Enhance score: 0.6935, Core score: 0.7741, Whole score: 0.8208\n",
      "Image: 37, Enhance score: 0.3945, Core score: 0.3061, Whole score: 0.3000\n",
      "Image: 38, Enhance score: 0.9349, Core score: 0.4146, Whole score: 0.9062\n",
      "Image: 39, Enhance score: 0.2815, Core score: 0.3135, Whole score: 0.8131\n",
      "Image: 40, Enhance score: 0.5881, Core score: 0.6546, Whole score: 0.7877\n",
      "Image: 41, Enhance score: 0.6045, Core score: 0.5663, Whole score: 0.8914\n",
      "Image: 42, Enhance score: 0.1205, Core score: 0.1348, Whole score: 0.8169\n",
      "Image: 43, Enhance score: 0.5820, Core score: 0.4322, Whole score: 0.3758\n",
      "Image: 44, Enhance score: 0.1126, Core score: 0.5745, Whole score: 0.8842\n",
      "Image: 45, Enhance score: 0.0442, Core score: 0.5429, Whole score: 0.6915\n",
      "Image: 46, Enhance score: 0.0064, Core score: 0.7139, Whole score: 0.7349\n",
      "Image: 47, Enhance score: 0.0015, Core score: 0.0561, Whole score: 0.6101\n",
      "Image: 48, Enhance score: 0.0065, Core score: 0.1818, Whole score: 0.6742\n",
      "Image: 49, Enhance score: 0.2280, Core score: 0.1872, Whole score: 0.2361\n",
      "Image: 50, Enhance score: 0.1165, Core score: 0.5366, Whole score: 0.7881\n",
      "Image: 51, Enhance score: 0.3936, Core score: 0.3463, Whole score: 0.7791\n",
      "Image: 52, Enhance score: 0.2469, Core score: 0.3220, Whole score: 0.6552\n",
      "Image: 53, Enhance score: 0.0361, Core score: 0.1125, Whole score: 0.6234\n",
      "Evalution Done!\n",
      "Enhance score: 0.4478, Core score: 0.4819, Whole score: 0.6764, Mean Dice score: 0.5354\n",
      "Enhance std: 0.2836, Core std: 0.2340, Whole std: 0.1912, Mean Std: 0.2363\n"
     ]
    }
   ],
   "source": [
    "num_inputs = 5\n",
    "# switch to evaluate mode\n",
    "model.eval()\n",
    "\n",
    "# initialization      \n",
    "num_ignore = 0\n",
    "num_images = int(len(test_dir)/num_inputs)\n",
    "# columns in score is (# pred, # label, pred and label)\n",
    "# lines in score is (Enhance, Core, Whole)\n",
    "dice_score = np.zeros([num_images, 3]).astype(float)\n",
    "\n",
    "for i, sample in enumerate(test_loader):\n",
    "    image = sample['images'].float().cuda()\n",
    "    label = sample['labels'].long().cuda()\n",
    "    mask = sample['mask'].long().cuda()\n",
    "    name = sample['name'][0]\n",
    "\n",
    "    with torch.no_grad():      \n",
    "        image = Variable(image)\n",
    "        label = Variable(label)\n",
    "        mask = Variable(mask)\n",
    "\n",
    "        # The dimension of out should be in the dimension of B,C,H,W,D\n",
    "        out = model(image)\n",
    "        out = out.permute(0,2,3,4,1)\n",
    "        out = torch.max(out, 4)[1]\n",
    "#         print(out.shape)\n",
    "        # start index corresponding to the model\n",
    "        start = [14, 14, 14]\n",
    "        center = out.size()[1:]\n",
    "        prediction = torch.zeros(label.size())\n",
    "        prediction[:, start[0]:start[0]+center[0], start[1]: start[1]+center[1], start[2]: start[2]+center[2]] = out\n",
    "        \n",
    "        out = prediction\n",
    "        # make the prediction corresponding to the center part of the image\n",
    "        prediction = prediction.contiguous().view(-1).cuda()            \n",
    "        label = label.contiguous().view(-1)                  \n",
    "        mask = mask.contiguous().view(-1)\n",
    "\n",
    "    # compute the dice score\n",
    "    score_per_image = accuracy(prediction.data.cpu().numpy(), mask.data.cpu().numpy(), label.data.cpu().numpy()) \n",
    "\n",
    "    if np.sum(score_per_image[0,:]) == 0 or np.sum(score_per_image[1,:]) == 0 or np.sum(score_per_image[2,:]) == 0:\n",
    "        num_ignore += 1\n",
    "        continue \n",
    "    # compute the Enhance, Core and Whole dice score\n",
    "    dice_score_per = [2 * np.sum(score_per_image[k,2]) / (np.sum(score_per_image[k,0]) + np.sum(score_per_image[k,1])) for k in range(3)]   \n",
    "    print('Image: %d, Enhance score: %.4f, Core score: %.4f, Whole score: %.4f' % (i, dice_score_per[0], dice_score_per[1], dice_score_per[2]))           \n",
    "\n",
    "    dice_score[i, :] = dice_score_per\n",
    "\n",
    "    # save the result\n",
    "    vis = out.data.cpu().numpy()[0]\n",
    "#     print(vis.shape)\n",
    "    vis = np.swapaxes(vis, 0, 2).astype(dtype=np.uint8)\n",
    "    visualize_result(name, vis)\n",
    "\n",
    "count_image = num_images - num_ignore\n",
    "dice_score = dice_score[:count_image,:]\n",
    "mean_dice = np.mean(dice_score, axis=0)\n",
    "std_dice = np.std(dice_score, axis=0)\n",
    "print('Evalution Done!')\n",
    "print('Enhance score: %.4f, Core score: %.4f, Whole score: %.4f, Mean Dice score: %.4f' % (mean_dice[0], mean_dice[1], mean_dice[2], np.mean(mean_dice)))\n",
    "print('Enhance std: %.4f, Core std: %.4f, Whole std: %.4f, Mean Std: %.4f' % (std_dice[0], std_dice[1], std_dice[2], np.mean(std_dice)))                         \n"
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}