3D_viewer_plotly.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import transforms\n",
    "from torchvision import models\n",
    "from torchvision.models.vgg import VGG\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "import os\n",
    "import nibabel as nib\n",
    "import time\n",
    "import datetime\n",
    "import torch.nn.functional as F\n",
    "from models.unet import UNet\n",
    "import matplotlib.pyplot as plt\n",
    "from metrics.torch_seg_metrics import dice_score, iou\n",
    "from datasets.BRATS2018 import ToTensorVal, NormalizeBRATSVal, ZeroPadVal\n",
    "from datasets.BRATS2018_3D import CenterCropBRATS3D, NormalizeBRATS3D\n",
    "from models.resnet3D import resnet50_3D\n",
    "from tqdm import tqdm\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def infer(case_name, seg_type, model_path, device, val_dir):\n",
    "    case_dir = os.path.join(val_dir, case_name)\n",
    "    if seg_type == 'et' or seg_type == 'tc':\n",
    "        scan_path = os.path.join(case_dir, case_name + '_t1ce.nii.gz')\n",
    "        sc = nib.load(scan_path)\n",
    "        sc = sc.get_data()\n",
    "        sc = sc.transpose((2, 0, 1))\n",
    "        assert sc.shape == (155, 240, 240)\n",
    "        \n",
    "        model = UNet(n_channels=1, n_classes=1, residual=True)\n",
    "    elif seg_type == 'wt':\n",
    "        t2_path = os.path.join(case_dir, case_name + '_t2.nii.gz')\n",
    "        flair_path = os.path.join(case_dir, case_name + '_flair.nii.gz')\n",
    "        t2 = nib.load(t2_path).get_data()\n",
    "        flair = nib.load(flair_path).get_data()\n",
    "        sc = np.array([t2, flair]).transpose((3, 0, 1, 2))\n",
    "        assert sc.shape == (155, 2, 240, 240)\n",
    "        \n",
    "        model = UNet(n_channels=2, n_classes=1, residual=True)\n",
    "    elif seg_type == 'seg':\n",
    "        t1_path = os.path.join(case_dir, case_name + '_t1.nii.gz')\n",
    "        t1ce_path = os.path.join(case_dir, case_name + '_t1ce.nii.gz')\n",
    "        t2_path = os.path.join(case_dir, case_name + '_t2.nii.gz')\n",
    "        flair_path = os.path.join(case_dir, case_name + '_flair.nii.gz')\n",
    "        \n",
    "        t1 = nib.load(t1_path).get_data()\n",
    "        t1ce = nib.load(t1ce_path).get_data()\n",
    "        t2 = nib.load(t2_path).get_data()\n",
    "        flair = nib.load(flair_path).get_data()\n",
    "        sc = np.array([t1, t1ce, t2, flair]).transpose((3, 0, 1, 2))\n",
    "        assert sc.shape == (155, 4, 240, 240)\n",
    "        \n",
    "        model = UNet(n_channels=4, n_classes=4, residual=True, expansion=2)\n",
    "    else:\n",
    "        raise ValueError('seg_type should only be et, tc, wt or seg')\n",
    "    \n",
    "    model.load_state_dict(torch.load(model_path, map_location=device))\n",
    "    model.to(device)\n",
    "    model.eval()\n",
    "    \n",
    "    preds = np.zeros((155, 240, 240))\n",
    "    \n",
    "    for i in range(155):\n",
    "        slice_i = sc[i]\n",
    "        if seg_type == 'et' or seg_type == 'tc':\n",
    "            slice_i = np.expand_dims(slice_i, axis=0)\n",
    "            assert slice_i.shape == (1, 240, 240)\n",
    "        elif seg_type == 'wt':\n",
    "            assert slice_i.shape == (2, 240, 240)\n",
    "        elif seg_type == 'seg':\n",
    "            assert slice_i.shape == (4, 240, 240)\n",
    "        \n",
    "        normalize = NormalizeBRATSVal()\n",
    "        totensor = ToTensorVal()\n",
    "        \n",
    "        slice_i = normalize(slice_i)\n",
    "        slice_i = totensor(slice_i)\n",
    "        \n",
    "        # unsqueeze the dimension to 4, NxCxHxW\n",
    "        slice_i = torch.unsqueeze(slice_i, dim=0)\n",
    "        slice_i = slice_i.to(device)\n",
    "        with torch.no_grad():\n",
    "            output = model(slice_i)\n",
    "            if seg_type == 'seg':\n",
    "                pred = torch.argmax(F.softmax(output, dim=1), dim=1, keepdim=True)\n",
    "            else:\n",
    "                pred = torch.sigmoid(output) > 0.5\n",
    "        \n",
    "        # squeeze the dimension down to 2, HxW\n",
    "        pred = torch.squeeze(pred)\n",
    "        pred = pred.cpu().numpy()\n",
    "        preds[i] = pred\n",
    "            \n",
    "    \n",
    "    return preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_dir = 'BRATS2018_Validation/'\n",
    "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Brats18_CBICA_AAM_1',\n",
       " 'Brats18_CBICA_ABT_1',\n",
       " 'Brats18_CBICA_ALA_1',\n",
       " 'Brats18_CBICA_ALT_1',\n",
       " 'Brats18_CBICA_ALV_1',\n",
       " 'Brats18_CBICA_ALZ_1',\n",
       " 'Brats18_CBICA_AMF_1',\n",
       " 'Brats18_CBICA_AMU_1',\n",
       " 'Brats18_CBICA_ANK_1',\n",
       " 'Brats18_CBICA_APM_1']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(os.listdir(val_dir))[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documents/semantic_segmentation/PyTorch_venv/lib/python3.6/site-packages/torch/nn/modules/upsampling.py:129: UserWarning: nn.Upsample is deprecated. Use nn.functional.interpolate instead.\n",
      "  warnings.warn(\"nn.{} is deprecated. Use nn.functional.interpolate instead.\".format(self.name))\n"
     ]
    }
   ],
   "source": [
    "preds = infer('Brats18_CBICA_ALA_1', 'seg', '../UNet-ResidualBlock-Expansion_210_end_to_end_manual/UNet-ResidualBlock-Expansion-BRATS2018-End-to-End_batch6_training_epochs15_Adam_scheduler-step10-gamma1.0_lr5e-05_w_decay3e-05/trained_model.pt', device, val_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "et_indices = np.argwhere(preds == 3.)\n",
    "et_xs = [ind[0] for ind in et_indices]\n",
    "et_ys = [ind[1] for ind in et_indices]\n",
    "et_zs = [ind[2] for ind in et_indices]\n",
    "\n",
    "edema_indices = np.argwhere(preds == 2.)\n",
    "edema_xs = [ind[0] for ind in edema_indices]\n",
    "edema_ys = [ind[1] for ind in edema_indices]\n",
    "edema_zs = [ind[2] for ind in edema_indices]\n",
    "\n",
    "necrotic_indices = np.argwhere(preds == 1.)\n",
    "necrotic_xs = [ind[0] for ind in necrotic_indices]\n",
    "necrotic_ys = [ind[1] for ind in necrotic_indices]\n",
    "necrotic_zs = [ind[2] for ind in necrotic_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.plotly as py\n",
    "import plotly.graph_objs as go\n",
    "import plotly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotly.tools.set_credentials_file(username='MartinMa28', api_key='nA5kDovmOVdudM3HaZ1V')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documents/semantic_segmentation/PyTorch_venv/lib/python3.6/site-packages/IPython/core/display.py:689: UserWarning:\n",
      "\n",
      "Consider using IPython.display.IFrame instead\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" seamless=\"seamless\" src=\"https://plot.ly/~MartinMa28/102.embed\" height=\"525px\" width=\"100%\"></iframe>"
      ],
      "text/plain": [
       "<chart_studio.tools.PlotlyDisplay object>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trace = go.Scatter3d(\n",
    "    x=et_xs,\n",
    "    y=et_ys,\n",
    "    z=et_zs,\n",
    "    mode='markers',\n",
    "    marker=dict(\n",
    "        size=3,\n",
    "        line={'color': 'rgba(217, 57, 57, 0.34)',\n",
    "             'width': 0.5},\n",
    "        opacity=0.6)\n",
    ")\n",
    "data = [trace]\n",
    "layout = go.Layout(\n",
    "    margin=dict(\n",
    "        l=0,\n",
    "        r=0,\n",
    "        b=0,\n",
    "        t=0\n",
    "    )\n",
    ")\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "py.iplot(fig, filename='3D-Enhancing-tumor')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documents/semantic_segmentation/PyTorch_venv/lib/python3.6/site-packages/chart_studio/plotly/plotly.py:248: UserWarning:\n",
      "\n",
      "Woah there! Look at all those points! Due to browser limitations, the Plotly SVG drawing functions have a hard time graphing more than 500k data points for line charts, or 40k points for other types of charts. Here are some suggestions:\n",
      "(1) Use the `plotly.graph_objs.Scattergl` trace object to generate a WebGl graph.\n",
      "(2) Trying using the image API to return an image instead of a graph URL\n",
      "(3) Use matplotlib\n",
      "(4) See if you can create your visualization with fewer data points\n",
      "\n",
      "If the visualization you're using aggregates points (e.g., box plot, histogram, etc.) you can disregard this warning.\n",
      "\n",
      "/home/martin/Documents/semantic_segmentation/PyTorch_venv/lib/python3.6/site-packages/IPython/core/display.py:689: UserWarning:\n",
      "\n",
      "Consider using IPython.display.IFrame instead\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" seamless=\"seamless\" src=\"https://plot.ly/~MartinMa28/104.embed\" height=\"525px\" width=\"100%\"></iframe>"
      ],
      "text/plain": [
       "<chart_studio.tools.PlotlyDisplay object>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trace_edema = go.Scatter3d(\n",
    "    x=edema_xs,\n",
    "    y=edema_ys,\n",
    "    z=edema_zs,\n",
    "    mode='markers',\n",
    "    marker=dict(size=3,\n",
    "                line={'color': 'rgba(57, 217, 57, 0.34)',\n",
    "                     'width': 0.5},\n",
    "                opacity=0.6)\n",
    ")\n",
    "\n",
    "data_edema = [trace_edema]\n",
    "fig_edema = go.Figure(data=data_edema, layout=layout)\n",
    "py.iplot(fig_edema, filename='3D-Edema')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documents/semantic_segmentation/PyTorch_venv/lib/python3.6/site-packages/IPython/core/display.py:689: UserWarning:\n",
      "\n",
      "Consider using IPython.display.IFrame instead\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" seamless=\"seamless\" src=\"https://plot.ly/~MartinMa28/106.embed\" height=\"525px\" width=\"100%\"></iframe>"
      ],
      "text/plain": [
       "<chart_studio.tools.PlotlyDisplay object>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trace_necrotc = go.Scatter3d(\n",
    "    x=necrotic_xs,\n",
    "    y=necrotic_ys,\n",
    "    z=necrotic_zs,\n",
    "    mode='markers',\n",
    "    marker=dict(size=3,\n",
    "                line={'color': 'rgba(57, 57, 217, 0.34)',\n",
    "                     'width': 0.5},\n",
    "                opacity=0.8)\n",
    ")\n",
    "\n",
    "data_necrotic = [trace_necrotc]\n",
    "fig_necrotic = go.Figure(data=data_necrotic, layout=layout)\n",
    "py.iplot(fig_necrotic, filename='3D-Necrotic-tumor')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3D scatter plot of glioma segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "seg_xs = et_xs + edema_xs + necrotic_xs\n",
    "seg_ys = et_ys + edema_ys + necrotic_ys\n",
    "seg_zs = et_zs + edema_zs + necrotic_zs\n",
    "seg_color = [3] * len(et_xs) + [2] * len(edema_xs) + [1] * len(necrotic_xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documents/semantic_segmentation/PyTorch_venv/lib/python3.6/site-packages/chart_studio/plotly/plotly.py:248: UserWarning:\n",
      "\n",
      "Woah there! Look at all those points! Due to browser limitations, the Plotly SVG drawing functions have a hard time graphing more than 500k data points for line charts, or 40k points for other types of charts. Here are some suggestions:\n",
      "(1) Use the `plotly.graph_objs.Scattergl` trace object to generate a WebGl graph.\n",
      "(2) Trying using the image API to return an image instead of a graph URL\n",
      "(3) Use matplotlib\n",
      "(4) See if you can create your visualization with fewer data points\n",
      "\n",
      "If the visualization you're using aggregates points (e.g., box plot, histogram, etc.) you can disregard this warning.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The draw time for this plot will be slow for clients without much RAM.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documents/semantic_segmentation/PyTorch_venv/lib/python3.6/site-packages/chart_studio/api/v1/clientresp.py:44: UserWarning:\n",
      "\n",
      "Estimated Draw Time Slow\n",
      "\n",
      "/home/martin/Documents/semantic_segmentation/PyTorch_venv/lib/python3.6/site-packages/IPython/core/display.py:689: UserWarning:\n",
      "\n",
      "Consider using IPython.display.IFrame instead\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" seamless=\"seamless\" src=\"https://plot.ly/~MartinMa28/108.embed\" height=\"525px\" width=\"100%\"></iframe>"
      ],
      "text/plain": [
       "<chart_studio.tools.PlotlyDisplay object>"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trace_seg = go.Scatter3d(\n",
    "    x=seg_xs,\n",
    "    y=seg_ys,\n",
    "    z=seg_zs,\n",
    "    mode='markers',\n",
    "    marker={\n",
    "        'size': 3,\n",
    "        'color': seg_color,\n",
    "        'colorscale': 'Viridis',\n",
    "        'opacity': 0.8\n",
    "    }\n",
    ")\n",
    "data_seg = [trace_seg]\n",
    "fig_seg = go.Figure(data=data_seg, layout=layout)\n",
    "py.iplot(fig_seg, filename='3D-Glioma-segmentation')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"900\"\n",
       "            height=\"800\"\n",
       "            src=\"//plot.ly/~MartinMa28/108.embed\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f829e1b15f8>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import IPython\n",
    "\n",
    "#iframe = '<iframe width=\"900\" height=\"800\" frameborder=\"0\" scrolling=\"no\" src=\"//plot.ly/~MartinMa28/108.embed\"></iframe>'\n",
    "IPython.display.IFrame(src=\"//plot.ly/~MartinMa28/108.embed\", width=900, height=800)"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}