C1_W3_Lab_2_extract_a_sub_section__M.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extract a Sub Section\n",
    "\n",
    "In this week's assignment you will be extracting sub-sections of the MRI data to train your network. The reason for this is that training on a full MRI scan would be too memory intensive to be practical. To extract a sub-section in the assignment, you will need to write a function to isolate a small \"cube\" of the data for training. This example is meant to show you how to do such an extraction for 1D arrays. In the assignment you will apply the same logic in 3D."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import keras\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 11, 12, 13, 14, 15])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define a simple one dimensional \"image\" to extract from\n",
    "image = np.array([10,11,12,13,14,15])\n",
    "image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compute the dimensions of your \"image\"\n",
    "image_length = image.shape[0]\n",
    "image_length"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Sub Sections\n",
    "In the assignment, you will define a \"patch size\" in three dimensions, that will be the size of the sub-section you want to extract. For this exercise, you only need to define a patch size in one dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a patch length, which will be the size of your extracted sub-section\n",
    "patch_length = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To extract a patch of length `patch_length` you will first define an index at which to start the patch.\n",
    "\n",
    "Run the next cell to define your start index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define your start index\n",
    "start_i = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the end of the next cell you are adding 1 to the start index. Run cell a few times to extract some one dimensional sub-sections from your \"image\"\n",
    "\n",
    "What happens when you run into the edge of the image (when `start_index` is > 3)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start index 0\n",
      "end index 3\n",
      "output patch length:  3\n",
      "output patch array:  [10 11 12]\n"
     ]
    }
   ],
   "source": [
    "# Define an end index given your start index and patch size\n",
    "print(f\"start index {start_i}\")\n",
    "end_i = start_i + patch_length\n",
    "print(f\"end index {end_i}\")\n",
    "\n",
    "# Extract a sub-section from your \"image\"\n",
    "sub_section = image[start_i: end_i]\n",
    "print(\"output patch length: \", len(sub_section))\n",
    "print(\"output patch array: \", sub_section)\n",
    "\n",
    "# Add one to your start index\n",
    "start_i +=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll notice when you run the above multiple times, that eventually the sub-section returned is no longer of length `patch_length`. \n",
    "\n",
    "In the assignment, your neural network will be expecting a particular sub-section size and will not accept inputs of other dimensions. For the start indices, you will be randomly choosing values and you need to ensure that your random number generator is set up to avoid the edges of your image object.\n",
    "\n",
    "The next few code cells include a demonstration of how you could determine the constraints on your start index for the simple one dimensional example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start index 3\n",
      "end index 6\n",
      "output patch array:  [13 14 15]\n"
     ]
    }
   ],
   "source": [
    "# Set your start index to 3 to extract a valid patch\n",
    "start_i = 3\n",
    "print(f\"start index {start_i}\")\n",
    "end_i = start_i + patch_length\n",
    "print(f\"end index {end_i}\")\n",
    "sub_section = image[start_i: end_i]\n",
    "print(\"output patch array: \", sub_section)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The largest start index for which a sub section is still valid is 3\n"
     ]
    }
   ],
   "source": [
    "# Compute and print the largest valid value for start index\n",
    "print(f\"The largest start index for which \"\n",
    "      f\"a sub section is still valid is \"\n",
    "      f\"{image_length - patch_length}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The range of valid start indices is:\n",
      "[0, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# Compute and print the range of valid start indices\n",
    "print(f\"The range of valid start indices is:\")\n",
    "\n",
    "# Compute valid start indices, note the range() function excludes the upper bound\n",
    "valid_start_i = [i for i in range(image_length - patch_length + 1)]\n",
    "print(valid_start_i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Random Selection of Start Indices\n",
    "In the assignment, you will need to randomly select a valid integer for the start index in each of three dimensions. The way to do this is by following the logic above to identify valid start indices and then selecting randomly from that range of valid numbers.\n",
    "\n",
    "Run the next cell to select a valid start index for the one dimensional example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "randomly selected start index 3\n"
     ]
    }
   ],
   "source": [
    "# Choose a random start index, note the np.random.randint() function excludes the upper bound.\n",
    "start_i = np.random.randint(image_length - patch_length + 1)\n",
    "print(f\"randomly selected start index {start_i}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "randomly selected start index 3\n",
      "randomly selected start index 2\n",
      "randomly selected start index 0\n",
      "randomly selected start index 2\n",
      "randomly selected start index 1\n",
      "randomly selected start index 2\n",
      "randomly selected start index 3\n",
      "randomly selected start index 2\n",
      "randomly selected start index 0\n",
      "randomly selected start index 2\n"
     ]
    }
   ],
   "source": [
    "# Randomly select multiple start indices in a loop\n",
    "for _ in range(10):\n",
    "    start_i = np.random.randint(image_length - patch_length + 1)\n",
    "    print(f\"randomly selected start index {start_i}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Background Ratio\n",
    "\n",
    "Another thing you will be doing in the assignment is to compute the ratio of background to edema and tumorous regions. You will be provided with a file containing labels with these categories:\n",
    "\n",
    "* 0: background\n",
    "* 1: edema\n",
    "* 2: non-enhancing tumor\n",
    "* 3: enhancing tumor\n",
    "\n",
    "Let's try to demonstrate this in 1-D to get some intuition on how to implement it in 3D later in the assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 1 0 3 2 1 2 1 0 3 3 0 2 2 0]\n"
     ]
    }
   ],
   "source": [
    "# We first simulate input data by defining a random patch of length 16. This will contain labels \n",
    "# with the categories (0 to 3) as defined above.\n",
    "\n",
    "patch_labels = np.random.randint(0, 4, (16))\n",
    "print(patch_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "using np.count_nonzero():  0.25\n",
      "using np.where():  0.25\n"
     ]
    }
   ],
   "source": [
    "# A straightforward approach to get the background ratio is\n",
    "# to count the number of 0's and divide by the patch length\n",
    "\n",
    "bgrd_ratio = np.count_nonzero(patch_labels == 0) / len(patch_labels)\n",
    "print(\"using np.count_nonzero(): \", bgrd_ratio)\n",
    "\n",
    "bgrd_ratio = len(np.where(patch_labels == 0)[0]) / len(patch_labels)\n",
    "print(\"using np.where(): \", bgrd_ratio)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 1. 0. 0.]\n",
      " [0. 1. 0. 0.]\n",
      " [0. 1. 0. 0.]\n",
      " [1. 0. 0. 0.]\n",
      " [0. 0. 0. 1.]\n",
      " [0. 0. 1. 0.]\n",
      " [0. 1. 0. 0.]\n",
      " [0. 0. 1. 0.]\n",
      " [0. 1. 0. 0.]\n",
      " [1. 0. 0. 0.]\n",
      " [0. 0. 0. 1.]\n",
      " [0. 0. 0. 1.]\n",
      " [1. 0. 0. 0.]\n",
      " [0. 0. 1. 0.]\n",
      " [0. 0. 1. 0.]\n",
      " [1. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# However, take note that we'll use our label array to train a neural network\n",
    "# so we can opt to compute the ratio a bit later after we do some preprocessing. \n",
    "# First, we convert the label's categories into one-hot format so it can be used to train the model\n",
    "\n",
    "patch_labels_one_hot = keras.utils.to_categorical(patch_labels, num_classes=4)\n",
    "print(patch_labels_one_hot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: We hardcoded the number of classes to 4 in our simple example above.\n",
    "In the assignment, you should take into account that the label file can have\n",
    "a different number of categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>background</th>\n",
       "      <th>edema</th>\n",
       "      <th>non-enhancing tumor</th>\n",
       "      <th>enhancing tumor</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    background  edema  non-enhancing tumor  enhancing tumor\n",
       "0          0.0    1.0                  0.0              0.0\n",
       "1          0.0    1.0                  0.0              0.0\n",
       "2          0.0    1.0                  0.0              0.0\n",
       "3          1.0    0.0                  0.0              0.0\n",
       "4          0.0    0.0                  0.0              1.0\n",
       "5          0.0    0.0                  1.0              0.0\n",
       "6          0.0    1.0                  0.0              0.0\n",
       "7          0.0    0.0                  1.0              0.0\n",
       "8          0.0    1.0                  0.0              0.0\n",
       "9          1.0    0.0                  0.0              0.0\n",
       "10         0.0    0.0                  0.0              1.0\n",
       "11         0.0    0.0                  0.0              1.0\n",
       "12         1.0    0.0                  0.0              0.0\n",
       "13         0.0    0.0                  1.0              0.0\n",
       "14         0.0    0.0                  1.0              0.0\n",
       "15         1.0    0.0                  0.0              0.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's convert the output to a dataframe just so we can see the labels more clearly\n",
    "\n",
    "pd.DataFrame(patch_labels_one_hot, columns=['background', 'edema', 'non-enhancing tumor', 'enhancing tumor'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "background column:  [0. 0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 1. 0. 0. 1.]\n"
     ]
    }
   ],
   "source": [
    "# What we're interested in is the first column because that \n",
    "# indicates if the element is part of the background\n",
    "# In this case, 1 = background, 0 = non-background\n",
    "\n",
    "print(\"background column: \", patch_labels_one_hot[:,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "using one-hot column:  0.25\n"
     ]
    }
   ],
   "source": [
    "# we can compute the background ratio by counting the number of 1's \n",
    "# in the said column divided by the length of the patch\n",
    "\n",
    "bgrd_ratio = np.sum(patch_labels_one_hot[:,0])/ len(patch_labels)\n",
    "print(\"using one-hot column: \", bgrd_ratio)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### That's all for this lab, now you have the basic tools you need for sub-section extraction in this week's graded assignment!"
   ]
  }
 ],
 "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": 4
}