1_jupyter_and_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Jupyter notebook and python\n",
    "#### [Python and Jupyter Notebook for Medical Image Analysis](https://github.com/sbonaretti/2020_OpenMR_jupyter)\n",
    "#### [OpenMRBenelux](https://openmrbenelux.github.io/) Workshop - January 22, 2020 - Nijmegen (The Netherlands)\n",
    "Content under Creative Commons Attribution license CC-BY-NC-SA 4.0   \n",
    "Code under GNU-GPL v3 License  \n",
    "© 2020 Serena Bonaretti\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following is an empty cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Create a cell below by:   \n",
    "- Positining the mouse next to this text -> The blue bar appears\n",
    "- Clicking the \"+\" button in the toolbar, or  \n",
    "- Pressing `b` (for \"below\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Delete the cell below by:\n",
    "- Positioning the mouse next to the cell below -> The blue bar appears\n",
    "- Clicking the \"scissors\" button in the toolbar, or  \n",
    "- Pressing `dd` or `x` (cut) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Delete this cell\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Undo the delete by:\n",
    "- Going to `Edit` -> `Undo cell operation` \n",
    "- Pressing `z`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Redo the delete by: \n",
    "- Going to `Edit` -> `Redo cell operation` \n",
    "- Pressing `Shift+z`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Copy the following cell by:  \n",
    "- Positioning the mouse next to the cell below -> The blue bar appears\n",
    "- Pressing the \"copy\" button in the top-bar, or \n",
    "- Pressing `c` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Cell to copy/paste\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Paste the cell by:  \n",
    "- Pressing the \"paste\" button in the top-bar, or  \n",
    "- Pressing `v`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Move the cell B above the cell A by dragging/dropping:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Cell A\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Cell B\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cell content 1: Text in Markdown"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> This is a cell that contains text. \n",
    "- Double-click here it to see the `Markdown` text \n",
    "- Run the cell to render it as plain text by:  \n",
    "  - Going to `Run` -> `Run selected cells`\n",
    "  - Pressing `Shift+Return` (MacOS) or `Shift+Enter` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Create a cell below and set it to a *text* cell by:  \n",
    "- Setting the dropdown menu to `Markdown` or\n",
    "- Pressing `M`    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Write some text in the created cell (e.g. your name) and then run the cell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Notes*: \n",
    "- *Text* cells are fundamental to create the **narrative** of our Jupyter notebook pipelines \n",
    "- Markdown is compatible with HTLM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cell content 2: Equations in Latex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Create a cell below and write the general equations for neural networks:  `$$ \\hat{Y} = \\sigma(W^T+B) $$`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> What changes if you use `$$` or `$`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cell content 3: Images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Create a new *Markdown* cell and add an image using this command: `![](img.png)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note*: Images are fundamental to support explanations in the narrative of the notebook (e.g. schemes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cell content 4: Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data types:\n",
    "- Strings `a = \"python\"`\n",
    "- Lists (= array) `a = [1,2]`\n",
    "- Tuples (= immutable lists) `a = (1,2)`\n",
    "- Dictionaries (= struct)\n",
    "- Booleans (`True` and `False`)\n",
    "- ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Get the data type of the variable in the following cell using the following command: `type(variable_name)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# variable \n",
    "var_1 = \"We are in the python Russian doll\"\n",
    "\n",
    "# -> Task 1: get the data type \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operators:  \n",
    "- `+`, `-`, `*`, `/`, `=`, `>`, `<`, `==` ...\n",
    "- Might be different from other languages:  \n",
    "  - `**` Exponentiation\n",
    "  - `!=` Not equal \n",
    "  - ...\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Relevant syntax   \n",
    "\n",
    "- `If` ... `elif` ... `else`:   \n",
    "   ```\n",
    "   if b > a:  \n",
    "      print(\"b is greater than a\")  \n",
    "   elif a == b:  \n",
    "      print(\"a and b are equal\")\n",
    "   else: \n",
    "      print(\"a is greater than b\")\n",
    "   ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `For` loops:   \n",
    "  ```\n",
    "  for x in range(2, 6): # Note: [2,6) \n",
    "      print(x)\n",
    "  ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Functions (`def`): \n",
    "  ```\n",
    "  def my_function():\n",
    "      print(\"Hello from a function\")\n",
    "\n",
    "  my_function()\n",
    "  ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Passing a value to functions and return a value from function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greetings_to_me (): # -> Task 1: add the variable my_name in brackets \n",
    "    \"\"\" \n",
    "    Function printing out a greeting to user\n",
    "    inputs: \n",
    "    - my_name: string containing user name\n",
    "    ouput: \n",
    "    - greeting: string containing greeting to user\n",
    "    \"\"\"\n",
    "   \n",
    "    greeting = \"Hello \" + my_name + \" :)\"\n",
    "    return              # -> Task 2: add the returned variable here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Call the function and print out the returned value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_greeting = greetings_to_me() # -> Task 1: add your name in brackets (do not forget the quotes!)\n",
    "print ()                        # -> Task 2: add the returned variable to print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Notes:   \n",
    "\n",
    "##### Basic\n",
    "- Counting starts from `0`   \n",
    "- Python uses indentation\n",
    "\n",
    "##### Advanced\n",
    "- Functions can be written in separate files called modules, with extension `.py` (e.g. image_preprocessing.py)  \n",
    "  - You can call the function in the notebook after importing the module  \n",
    "- Python supports object-oriented programming, package creating, code testing, ...   \n",
    "  \n",
    "##### Two suggestions:   \n",
    "- Python is used more and more in science and research. There are plenty of `manuals`, `blogs`, and `online and video tutorial`. Any time you have an issue, just search for it in the browser. A huge amount of people have already had that issue before you, and you can very often find the solution online without waisting time   \n",
    "- To learn to python, start `translating` part of your code from the language you are currently using to python. You will not have to focus on the algorithm, but just on the syntax, and it will be fast to get familiar with this new language"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Relevant packages in python: Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy is the most used package for linear algebra (vectors, matrices, etc.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Import Numpy by running the following cell: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Consider that we have analyzed some images: We have preprocessed them, segmented them, and then you have run some morphology analysis. Specifically, we have calculated the thickness of an organ (e.g. brain cortex, heart wall thickness, cortical bone thickness, ...). In this case, we consider knee cartilage thickness, but consider that you can re-use this for your specific case.\n",
    "\n",
    "-> The following array contains average values of knee cartilage thickness (in [mm]):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thickness = np.array([2.40, 2.23, 1.94, 2.01, 2.32, 1.98, 2.06, 2.22, 2.19, 2.20, 2.00, 2.17, 2.05, 2.50, 2.14, 2.30, 2.18, 2.25, 1.95])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> How many subjects did we evaluate (i.e. how many values are there in the array?) (use `.shape`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> What is the dimention of the array? (use `.ndim`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> What is the average thickness (use `.mean()`)? The maximum (use `.max()`)? The minimum (use `.min()`)?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Which is the ID of the subject who has mininum thickness? (use `np.where`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.where(thickness == thickness.min())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> What do you note about the index? Compare with the array `thickness`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Notes  \n",
    "- Numpy as many more functions to create, manipulate, sort, etc. arrays\n",
    "- Numpy is used by all the major python libraries\n",
    "- SimpleITK and ITK use Numpy too"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Relevant packages in python: Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib is one of the most used packages for visualizations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Import Matplotlib by running the following cell: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Plot thickness values. Add title (\"Thickness values\") to the plot (use `plt.title`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot data\n",
    "plt.plot(np.arange(0, 19, 1), thickness,  linestyle='None', marker='o', color='red')\n",
    "\n",
    "# title -> Task 1: Add title below \n",
    "                   \n",
    "\n",
    "# axis labels \n",
    "plt.xlabel(\"Subject ID\")       \n",
    "plt.ylabel(\"Thickness [mm]\")    \n",
    "\n",
    "# axis text\n",
    "plt.xticks(np.arange(0, 19, 1), np.arange(1, 20, 1)) # position, values\n",
    "\n",
    "# show\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other relevant packages in python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Pandas: Data structure and analysis   \n",
    "- Scikit-learn (Scikit-image), Keras, Tensor-flow, Keras, and Pytorch: Machine learning and Deep Learning   \n",
    "- Scikit-image: Natural image processing\n",
    "- Seaborn, Altair, Plotly: Data visualization  \n",
    "- ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--- "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Last comments about Jupyter notebook: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Kernels and cell order during execution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A kernel is a server that allow us to run the cells in the notebook   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- It is important to run and re-run the cells one after the other in a **sequential** way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a + b\n",
    "print (c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-> Change the value of `a` to `4` and run the cell. What happens to `c`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- In case of doubts, restart the kernel (`curved arrow` in the toolbar) and rerun the cells (`Run` -> `Run [...]`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Narrative  \n",
    "A notebook is NOT a sequence of code cells. It is a document that **integrates** code and text. The **narrative** part is fundamental to **explain** the code and comment the results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Dependencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dependencies are characteristics of machine and versions of packages. They are fundamental for reproducibility of our computations:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPython 3.7.4\n",
      "IPython 7.12.0\n",
      "\n",
      "numpy 1.18.1\n",
      "matplotlib 3.1.3\n",
      "\n",
      "compiler   : Clang 4.0.1 (tags/RELEASE_401/final)\n",
      "system     : Darwin\n",
      "release    : 19.2.0\n",
      "machine    : x86_64\n",
      "processor  : i386\n",
      "CPU cores  : 4\n",
      "interpreter: 64bit\n",
      "last updated: Fri Apr 10 2020 10:44:01 CEST\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -v -m -p numpy,matplotlib\n",
    "%watermark -u -n -t -z "
   ]
  }
 ],
 "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"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}