DL01-cell01-explanations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python for deep learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "if  not os.path.isdir('./training'):\n",
    "  !cd /content/ && git clone https://github.com/MontpellierRessourcesImagerie/DL_EXP_PC.git && cp -r DL_EXP_PC/data . && cp -r DL_EXP_PC/training .\n",
    "  %cd DL_EXP_PC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cell 1\n",
    "\n",
    "Cell 1 checks if a folder ``./training`` does not exist. If it does not exist, we consider that the notebook is run on google colab. In this case the additional module ```tifffile``` is installed, ```keras``` is updated and the data is downloaded from the github repository and moved into the places where the notebook expects it to be.  \n",
    "\n",
    "```python\n",
    "import os\n",
    "if  not os.path.isdir('./training'):\n",
    "  !pip install tifffile\n",
    "  !pip install -U keras\n",
    "  !cd /content/ && git clone https://github.com/MontpellierRessourcesImagerie/DL_EXP_PC.git && cp -r DL_EXP_PC/data . && cp -r DL_EXP_PC/training .\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keywords, functions, modules and packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The language comes with a number of [predefined words](https://www.programiz.com/python-programming/keyword-list) and [build-in functions](https://docs.python.org/3/library/functions.html). These together with [predefined operators](https://www.tutorialspoint.com/python/python_basic_operators.htm) build the kernel of the language.\n",
    "\n",
    "A programmer can implement more commands by writing her own functions. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def double(n):\n",
    "    return 2*n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ```def``` keyword tells python that this is the definition of a function. ```double``` is the name of the new function. It is followed by a list of parameters that can be passed to the function. The colon separates the head of the function definition from its body. The body of the function defintion is a block of commands, each command in its own row. The indentation level is used to know where a block begins and ends. The return keyword defines the result of the function. When a function is called in a program, the function call with the given parameters is substituted by the result of the execution of the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "double(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When calling a function the arguments are usually associated to the parameters of the function depending on their position. However it is also possible to explicitly associate an argument to a parameter. In this case the position is not important. When you use both in the same call, all keyword parameters must come after the positional parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\n",
      "2.0\n",
      "0.5\n"
     ]
    }
   ],
   "source": [
    "def div(nominator, denominator):\n",
    "    return nominator/denominator\n",
    "        \n",
    "print(div(1,2))\n",
    "print(div(2,1))\n",
    "print(div(denominator=2, nominator=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In python user-defined functions can be grouped into modules and packages. A module is a file that contains a number of definitions and a package is a directory containing one or more modules. For a directory to be recognized as a package, it must contain a file ``__init__.py`` which can be empty or contain code that will be executed when the package is imported.\n",
    "\n",
    "Modules and packages can be imported into a program. Importing a module makes the definition in the module available in the program. \n",
    "\n",
    "Python comes with a [standard library](https://docs.python.org/3/library/index.html), which means when you install python a number of packages and modules is installed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imports the module os from the python standard-library. The module os contains operating system functions, like dealing with files and processes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.isdir('./training')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calls the function ```isdir``` from the submodule ```path``` of the module ```os```. The function answers ```True``` if the directory passed as an argument exists and ```False``` otherwise. ```True``` and ```False``` are the representations of boolean values in python. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Booleans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The datatype boolean consists of the values ```True``` and ```False``` and the operations ```and```, ```or``` and ```not```. One reason why booleans are important is that comparisons result in boolean values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10<100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10<100 or 100<10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10<100 and 100<10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not 100<10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " not os.path.isdir('./training')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.isdir('./training')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional code execution, the if statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A program must be able to execute different branches of code depending on the user input, its environments or its own inner state. This is done using the ```if-statement```. The complete form of the ```if-statement``` is:\n",
    "\n",
    "```python\n",
    "if <conition1>:\n",
    "    block1\n",
    "elif <conition2>:\n",
    "    block2\n",
    "    ...\n",
    "elif <conitionN>:\n",
    "    blockN    \n",
    "else:\n",
    "   blockN+1\n",
    "```\n",
    "\n",
    "When used in the complete form exactly one of the code-blocks is executed. Which one depends on the conditions. If none of the conditions evaluates to ```True``` the ```else-block``` is executed. All parts except for the ```if```-part can be omitted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34 is even\n"
     ]
    }
   ],
   "source": [
    "if 34%2==0:\n",
    "    print('34 is even')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./data exists\n"
     ]
    }
   ],
   "source": [
    "if os.path.isdir('./data'):\n",
    "    print(\"./data\", \"exists\")\n",
    "else:\n",
    "    print(\"./data\", \"does not exist\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting help on python modules and functions\n",
    "\n",
    "Python has a ```help```-function that you can call on a topic, a module or a function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The \"if\" statement\n",
      "******************\n",
      "\n",
      "The \"if\" statement is used for conditional execution:\n",
      "\n",
      "   if_stmt ::= \"if\" expression \":\" suite\n",
      "               (\"elif\" expression \":\" suite)*\n",
      "               [\"else\" \":\" suite]\n",
      "\n",
      "It selects exactly one of the suites by evaluating the expressions one\n",
      "by one until one is found to be true (see section Boolean operations\n",
      "for the definition of true and false); then that suite is executed\n",
      "(and no other part of the \"if\" statement is executed or evaluated).\n",
      "If all expressions are false, the suite of the \"else\" clause, if\n",
      "present, is executed.\n",
      "\n",
      "Related help topics: TRUTHVALUE\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help('if')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function isdir in module genericpath:\n",
      "\n",
      "isdir(s)\n",
      "    Return true if the pathname refers to an existing directory.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(os.path.isdir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Running shell-commands from a notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When a line or command in a code cell of a notebook starts with an exclamation mark, what follows is not send to the python interpreter but to the command shell of the operating system. The most commonly used shell on linux systems is [bash](https://www.gnu.org/software/bash/manual/bash.html). Here are some useful shell-commands:\n",
    "\n",
    " **cat path:**\n",
    "   display the content of a file \n",
    "\n",
    " **cp path1 path2**:\n",
    "   copy the file from path1 to path2\n",
    "\n",
    " **cd:**\n",
    "   change the (working) directory\n",
    "\n",
    " **ls:** \n",
    "   list (the content of the working directory)\n",
    "\n",
    " **man cmd:**\n",
    "   read the manual page of the command cmd\n",
    "\n",
    " **pwd:**\n",
    "   print working directory\n",
    "\n",
    " **rm path:**\n",
    "   remove a file\n",
    "   \n",
    "Note that each !-command is run in a separate sub-shell. You can run multiple shell commands in one call by connecting them with &&.\n",
    "You can use the %-line magic to run shell commands in the global shell in which the notebook runs.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 14M\n",
      "drwxr-xr-x 2 baecker baecker 4,0K avril  7 17:31 gt\n",
      "drwxr-xr-x 2 baecker baecker 4,0K avril  9 16:52 out\n",
      "-rw-r--r-- 1 baecker baecker 7,0M avril  7 17:28 spots01.tif\n",
      "-rw-r--r-- 1 baecker baecker 7,0M avril  7 17:30 spots02.tif\n"
     ]
    }
   ],
   "source": [
    "!cd data && ls -hl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/media/baecker/DONNEES1/programs/fiji-linux64/Fiji.app/mri-tools/DL_EXP_PC\n"
     ]
    }
   ],
   "source": [
    "!cd ./data/\n",
    "!pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/media/baecker/DONNEES1/programs/fiji-linux64/Fiji.app/mri-tools/DL_EXP_PC/data\n",
      "\u001b[0m\u001b[01;34mgt\u001b[0m/  \u001b[01;34mout\u001b[0m/  \u001b[01;35mspots01.tif\u001b[0m  \u001b[01;35mspots02.tif\u001b[0m\n",
      "/media/baecker/DONNEES1/programs/fiji-linux64/Fiji.app/mri-tools/DL_EXP_PC\n"
     ]
    }
   ],
   "source": [
    "%cd ./data/\n",
    "%ls\n",
    "%cd .."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# DL_EXP_PC\n",
      "Deep learning experiment - pixel classification\n",
      "\n",
      "A very simple example of the creation and application of a neuronal network for pixel classification using keras.\n",
      "\n",
      "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MontpellierRessourcesImagerie/DL_EXP_PC/blob/master/DL01-pixel-classification.ipynb)\n"
     ]
    }
   ],
   "source": [
    "!cat ./README.md"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PWD(1)                           User Commands                          PWD(1)\n",
      "\n",
      "NAME\n",
      "       pwd - print name of current/working directory\n",
      "\n",
      "SYNOPSIS\n",
      "       pwd [OPTION]...\n",
      "\n",
      "DESCRIPTION\n",
      "       Print the full filename of the current working directory.\n",
      "\n",
      "       -L, --logical\n",
      "              use PWD from environment, even if it contains symlinks\n",
      "\n",
      "       -P, --physical\n",
      "              avoid all symlinks\n",
      "\n",
      "       --help display this help and exit\n",
      "\n",
      "       --version\n",
      "              output version information and exit\n",
      "\n",
      "       If no option is specified, -P is assumed.\n",
      "\n",
      "       NOTE:  your shell may have its own version of pwd, which usually super‐\n",
      "       sedes the version described here.  Please refer to your  shell's  docu‐\n",
      "       mentation for details about the options it supports.\n",
      "\n",
      "AUTHOR\n",
      "       Written by Jim Meyering.\n",
      "\n",
      "REPORTING BUGS\n",
      "       GNU coreutils online help: <https://www.gnu.org/software/coreutils/>\n",
      "       Report pwd translation bugs to <https://translationproject.org/team/>\n",
      "\n",
      "COPYRIGHT\n",
      "       Copyright  ©  2018  Free Software Foundation, Inc.  License GPLv3+: GNU\n",
      "       GPL version 3 or later <https://gnu.org/licenses/gpl.html>.\n",
      "       This is free software: you are free  to  change  and  redistribute  it.\n",
      "       There is NO WARRANTY, to the extent permitted by law.\n",
      "\n",
      "SEE ALSO\n",
      "       getcwd(3)\n",
      "\n",
      "       Full documentation at: <https://www.gnu.org/software/coreutils/pwd>\n",
      "       or available locally via: info '(coreutils) pwd invocation'\n",
      "\n",
      "GNU coreutils 8.30              September 2019                          PWD(1)\n"
     ]
    }
   ],
   "source": [
    "!man pwd"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}