utf-8''AI4M_C1_W3_lecture_ex_02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AI4M Course 1 week 3 lecture notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extract a sub-section\n",
    "\n",
    "In the 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": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "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": [
    "### 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",
      "[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",
    "# Extract a sub-section from your \"image\"\n",
    "sub_section = image[start_i: end_i]\n",
    "print(sub_section)\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",
      "[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(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",
    "# 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": [
    "### 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 2\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 0\n",
      "randomly selected start index 1\n",
      "randomly selected start index 0\n",
      "randomly selected start index 0\n",
      "randomly selected start index 0\n",
      "randomly selected start index 0\n",
      "randomly selected start index 0\n",
      "randomly selected start index 3\n",
      "randomly selected start index 3\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": [
    "#### That's all for this lab, now you have the basic tools you need for sub-section extraction in this week's graded assignment!"
   ]
  },
  {
   "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": 4
}