PythonTutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python - by Sherif Nekkah\n",
    "\n",
    "For illustrative purposes, this tutorial is made in an IPython-Notbebook (`.ipynb`-file). All coding-related aspects in this notebook are relevant for standard programming in `Python`.\n",
    "\n",
    "Run cells with `Shift + Enter`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Why Python? \n",
    "\n",
    "`Python` is entirely **free** to use and distribute due to its open-source license. There are numerous **tools, libraries, and packages** for `Python` that cover many scientific subjects, such as data-science, image-processing, and motion-planning in autonomous driving, to name a few. Furthermore, `Python` is **easy to learn, read and write** due to its syntax close to the English language. Compared to other programming languages, such as C/C++, `Python` is **interpreted** instead of compiled. This means that Python code is **executed line by line**.  For this and a few other reasons that increase the convenience while programming, `Python` is significantly **slower** during runtime, compared to e.g. C++. However, all these aspects substantially increase the **productivity** in development and allow you to focus on the **scientific part of a problem**, instead of the programming part. Lastly, like C/C++, many languages require you to change your code depending on your platform (Windows/macOS/Linux). For `Python`, however, you generally only write your code once (except for system-dependent features) and run it on **any platform**.\n",
    "\n",
    "`Python` will mostly not operate safety- and time-critical modules of a system. However, it will be the right choice for **prototyping** and creating a **proof of concept** for you as an engineer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Structure of Python\n",
    "\n",
    "### 2.1 Python Scripts, Modules and Packages\n",
    "\n",
    "`Python` code is usually in the form of **scripts** or **modules**, both with the same file-ending `.py`. There is **no internal distinction** between `Python` scripts and modules - both are executable and importable, although modules, mostly contained in library code, often won't do anything when executed directly. The difference lies in their structure.\n",
    "\n",
    "Let's look at the following two file examples without emphasising too much on the exact functionality and coding details:\n",
    "\n",
    "<div class=\"row\">\n",
    "  <div class=\"col-md-5\" markdown=\"1\">\n",
    "  \n",
    "  ```python\n",
    "      \n",
    "  # functionality_module.py\n",
    "  def certain_functionality(data_struct):\n",
    "    # do something with input \n",
    "    return other_data_struct\n",
    "      \n",
    "      \n",
    "  # vizualization_module.py\n",
    "  def vizualize_data(data_struct): \n",
    "    # do something with input \n",
    "      \n",
    "  ```\n",
    "      \n",
    "  </div>\n",
    "    \n",
    "  <div class=\"col-md-7\" markdown=\"1\">\n",
    "      \n",
    "  ```python\n",
    "      \n",
    "  # script.py\n",
    "  from functionality_module import certain_functionality\n",
    "  from vizualization_module import vizualize_data\n",
    "        \n",
    "  # Prototyping, vizualizing, testing, ...  \n",
    "  result_1 = certain_functionality(some_data)\n",
    "  result_2 = certain_functionality(other_data)\n",
    "\n",
    "  vizualize_data(result_1)\n",
    "  vizualize_data(result_2)\n",
    "      \n",
    "  # Export results \n",
    "\n",
    "  ```\n",
    "      \n",
    "  </div>\n",
    "</div>\n",
    "\n",
    "The upper example is aiming to illustrate, that functions and variables can be **encapsuled** in modules. Like this, we can **modularly** use any function and prevent duplicate code in our **script** that runs from top to bottom. Modules are parts of **libraries**. Libraries on the other hand are included in **packages** that can be downloaded using tools such as `pip` or `Anaconda`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2. IPython-Notebooks\n",
    "\n",
    "IPython-Notebooks represent an extension to regular `Python` files. IPython-Notebooks, such as this one, are made up of several cells and can be used similar to standard `Python` scripts with optional documentation. Each cell can contain either `Python` code or Markdown text. Yet, don't worry about coding details. Everything will be explained in chapter 3 - Python 3 Basics.\n",
    "\n",
    "You can execute cells by clicking on it and pressing `Shift` + `Enter`. Check out the following examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [5, 4, 3, 2, 1, 0]\n",
    "\n",
    "print(L[3] + 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As global variables are shared between cells, we can acces `L` in the next cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(L[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# After executing this cell, try and re-execute the upper cell\n",
    "L = ['Pedestrian', 'Byciclist', 'Car', 'Truck'] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure to **save your changes** with `Strg` + `S` after editing cells!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Python 3 Basics \n",
    "\n",
    "### 3.1. Hello World!\n",
    "\n",
    "In almost every programming tutorial, the very first step is to write a \"Hello-World\" program. In `Python`, this is easily done in only one line! We simply use the `print`-statement as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For those of you who are familiar, you can compare this with the tedious implementation of \"Hello World\" in `C++`:\n",
    "\n",
    "```c++\n",
    "\n",
    "# include <iostream>\n",
    "\n",
    "int main() \n",
    "{\n",
    "    std::cout << \"Hello World!\";\n",
    "    return 0;\n",
    "}\n",
    "\n",
    "```\n",
    "\n",
    "` Output: Hello World! ` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2. Variables and Types\n",
    "\n",
    "Python is completely object oriented and dynamic. Variables don't need to be declared before assigning values. However, there are different types of variables:\n",
    "\n",
    "#### 3.2.1. Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_int = 9\n",
    "print(my_int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.2. Floating point numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_float = 9.4\n",
    "print(my_float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Python` even converts integers to floating point numbers when operating with both. If you want to change the datatype of your variables you can use `casting` operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python interpreter converts my_int to floating point number\n",
    "print(my_float - my_int)\n",
    "\n",
    "# Casting my_float to an intgeger value (numbers are rounded down)\n",
    "my_casted_int = int(my_float)\n",
    "print(my_casted_int - my_int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.3. Strings \n",
    "\n",
    "Strings are either defined with single or double quotes `'', \"\"`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_first_string = 'Python'\n",
    "my_second_string = \"Tutorial\"\n",
    "\n",
    "print(my_first_string + \" \" + my_second_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.4. Lists\n",
    "\n",
    "Lists in `Python` are similar to arrays from other programming languages. They can contain **any** type of variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initializing list with square brackets []\n",
    "my_list = [2, 3, 4]\n",
    "print(my_list)\n",
    "\n",
    "# values can be appended to the list via .append()\n",
    "my_list.append(5)\n",
    "print(my_list)\n",
    "\n",
    "# You can access a value over its index (starting at 0)\n",
    "print(my_list[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3. Basic Operators\n",
    "\n",
    "#### 3.3.1. Arithmetic Operators\n",
    "\n",
    "Addition (+), substraction (-), multiplication(*), and division (/) are standard operators for numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_float = 1.0 + 2.0 * 3.0 / 4.0\n",
    "print(my_float)\n",
    "\n",
    "my_float += 1.0 # This is the same as my_float = my_float + 1.0\n",
    "print(my_float)\n",
    "\n",
    "my_float *= 3.0 # This is the same as my_float = my_float * 3.0\n",
    "print(my_float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The modulo operator (%) returns the integer remainder of a division:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "remainder = 11 % 3\n",
    "print(remainder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A power relationship is realized using two multiplication symbols (**):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squared_number = 4**2\n",
    "cubed_number = 4**3\n",
    "print(squared_number)\n",
    "print(cubed_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Several other operators, such as square root, are part of math-heavy packages such as `numpy`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4. Conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python uses boolean logic (`True` or `False`) to evaluate conditions. Check out the follwing examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "\n",
    "print(x == 1)\n",
    "print(x != 1)\n",
    "print(x != 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.4.1 If, elif, else, and, or, in, is, not \n",
    "\n",
    "As previously mentioned, `Python` has several English-like elements. Especially when evaluating certain expressions, wether something is `True` or `False`, we can use these as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"David\"\n",
    "friends_list = ['David', 'Emilio']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if name == 'David':\n",
    "    print(name + ' is a mechanical engineer')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if name in friends_list:\n",
    "    print(name + ' is a good friend of mine')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statement = False\n",
    "\n",
    "if statement is False:\n",
    "    print(\"This statement is false\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if statement is not True:\n",
    "    print(\"This statement is not true\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if statement is True:\n",
    "    print(\"This statement is true\")\n",
    "elif statement is False:\n",
    "    print(\"This statement is false\") # This line is being executed   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if statement is True:\n",
    "    print(\"This statement is true\")\n",
    "else:\n",
    "    print(\"This statement is not true\") # This line is being executed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note that we get a Warning when comparing values against a certain value with \"is\"\n",
    "# This is because the 'is' operator is not matching the values of the variables, but the instances themselves\n",
    "# Here we should use '==' instead of 'is'    \n",
    "\n",
    "print(1 == 1.0)\n",
    "print(1 is 1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5. Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = [3, 1, 2, 8, 2, 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.5.1. \"for\" loop\n",
    "\n",
    "for-loops are the basic method to iterate over lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for v in values:\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "During every iterations the variable `v` is being assigned the current value of the list `values`.\n",
    "\n",
    "Special functions, such as `range()` and `len()`, are sometimes useful when using for-loops:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for v in range(4):\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for v in range(2, 4):\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for v in range(len(values)):\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, another useful function, especially when iterating over datasets, is the `enumerate()` function that we can use as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the enumerate operator returns index and value of a list in a for loop\n",
    "\n",
    "for index, value in enumerate(values):\n",
    "    print('index: ' + str(index) + ', value: ' + str(value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.5.2. \"while\" loop\n",
    "\n",
    "while-loops iterate until the boolean condition (`True` or `False`) at the top is not met:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "value = 0\n",
    "\n",
    "while value <= 3:\n",
    "    print(value)\n",
    "    value += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.5.3 \"break\" and \"continue\" statements\n",
    "\n",
    "`break` and `continue` are methods to exit and skip the current block of a loop. Check out the examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "value = 0\n",
    "\n",
    "while True: # Will never exit the loop unless we exit somehow\n",
    "    print(value)\n",
    "    value += 1\n",
    "    if value >= 3:\n",
    "        break        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for v in range(7):\n",
    "    if v % 2 == 0:\n",
    "        continue\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6 Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are a convenient way to modularize individual code blocks and introducing a structure in your software. Dividing your code into different parts improves readability, especially when using concise function names. It saves a lot of time and is the fundamental way to define interfaces, especially when working in a team. \n",
    "\n",
    "A function always starts with the keyword `def`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function(input_structure): # it is common practice to use lowercase letters for functions\n",
    "    pass    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The upper function defines a function with the name `function` and an input. Until now the input datatype is not set.\n",
    "\n",
    "Similar to if-else conditions and loops, code within the function is always indented one block. Also, if we don't yet intend to write any code in the function, we have to use the keyword `pass`.\n",
    "\n",
    "A function doesn't need input such as the following one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello_world():\n",
    "    print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can acces the function by it's name. dont forget the brackets `()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "hello_world()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function can also have a return value such as the following one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def highest_number_of_list(L):\n",
    "    \n",
    "    highest_number = None \n",
    "    # variables must be initialized in the same / or a superordinate block. \n",
    "    # Otherwise we can't acces them later on.\n",
    "    \n",
    "    for value in L:\n",
    "        \n",
    "        if highest_number is None:\n",
    "            highest_number = value\n",
    "            \n",
    "        elif value > highest_number:\n",
    "            highest_number = value\n",
    "            \n",
    "    return highest_number "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can again acces the function by it's name. However, we must assign the return value to another variable or directly use it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 9, 4, 5, -12]\n",
    "\n",
    "x = highest_number_of_list(numbers)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Classes and Objects (Object Oriented Programming)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As already mentioned in chapter 2.1., Python modules are aiming to modularize code and encapsule variables and functions. To realize this, **packages** commonly us **classes**. Classes are an encapsulation of variables and functions into a single **entity**. **Objects** are instances from classes and get their variables and functions, also called methods, from their class. \n",
    "\n",
    "Check out the following very basic class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Engineer: # it is common practice to use uppercase letters for classes\n",
    "    \n",
    "    name = \"no_name\"\n",
    "    \n",
    "    def description():\n",
    "        print(name + \" is an Engineer!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now generate an instance/object of this class and acces the variables and methods/functions with the `.` operator as the follwing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eng = Engineer\n",
    "\n",
    "eng.description()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unfortunately, the variable `name` is not yet accesible from the method `description`.\n",
    "\n",
    "To be able to acces class-variables from a function, we have to use the `self` parameter. `self` is needed, because whenever an object calls its own method, the object itself has to be passed as the first argument. Let's modify our class for this purpose:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Engineer: \n",
    "    def __init__(self):\n",
    "        self.name = \"no_name\"\n",
    "    \n",
    "    def description(self):\n",
    "        print(self.name + \" is an Engineer!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eng = Engineer() \n",
    "eng.name = \"Stefanie\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we now want to print the description of our object, we have to again call `eng.description()`. Using the `self` parameter, the expression `eng.description()` can be interpreted as `Engineer.description(eng)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eng.description()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `__init__` method is part of every class and is called as soon as an object of a class is instantiated. The method can be used to initialize its object in some way. Note the double underscores at both the beginning and end of the name.\n",
    "\n",
    "We can also use the `__init__` method to hand over certain variables when instantiating our new object. For this we again need to modify our class as the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Engineer: \n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    \n",
    "    def description(self):\n",
    "        print(self.name + \" is an Engineer!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eng = Engineer(\"Stefanie\") \n",
    "\n",
    "eng.description()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we only handed over one variable to our object when instantiating. `self` is automatically handed over to our new object so we don't explicitly do this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Packages\n",
    "### 5.1. Imports\n",
    "\n",
    "Every `Python` module or script usually starts with important imports of **packages**. `Anaconda` and, `Python` in general, comes with several preinstalled packages. However, we have to execute the following import cell before running any package related code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import numpy as np\n",
    "import scipy\n",
    "import cv2 as cv\n",
    "import torch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keyword `as` allows to use aliases for package-names, which can be very useful when trying to write compact code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2. Numpy\n",
    "\n",
    "`numpy` is a high performance framework for operations on multi-dimensional arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's create a simple `(2, 4)` numpy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check the data type and shape of this array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(a)\n",
    "print(a.dtype)\n",
    "print(a.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often we want to initialize an array with a fixed size, such as the following two:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zeros = np.zeros([2, 2], dtype=int)\n",
    "ones = np.ones([4], dtype=int)\n",
    "\n",
    "print(zeros)\n",
    "print(ones)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can slice the array and save e.g. the first two colums in a new array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "b = a[:, :2]\n",
    "print(b)\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can similarly save the first row of array `b` in another new array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "c = b[:1, :]\n",
    "print(c)\n",
    "print(c.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can select elements of an array which satisfy a condition: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask = a <= 6\n",
    "d = a[mask]\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's check out some mathematical operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "y = np.array([[5,6],[7,8]])\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elementwise sum. Both produce the same array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x + y)\n",
    "print(np.add(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elementwise difference. Both produce the same array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x - y)\n",
    "print(np.subtract(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elementwise product. Both produce the same array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x * y)\n",
    "print(np.multiply(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(x / y)\n",
    "print(np.divide(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elementwise sqare root and exponential operation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.sqrt(x))\n",
    "print(np.exp(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And finally the dot-product between Matrices/Vectors. In the case of 2 vectors with dimensions `(1, 2)` and `(2, 1)` the output is a scalar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#print(x[:1, :])\n",
    "#print(y[:, :1])\n",
    "\n",
    "print(np.dot(x[:1, :], y[:, :1]))\n",
    "\n",
    "print(x[:1, :] @ y[:, :1])\n",
    "\n",
    "print(np.matmul(x[:1, :], y[:, :1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more information, please take a look at https://numpy.org/doc/stable/numpy-user.pdf for further reference."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.3. OpenCV\n",
    "\n",
    "`OpenCV` is a very popular open-source library for computer vision. \n",
    "\n",
    "In the following we will check out a few functionalities of `OpenCV`. Let's start with the basics by importing and visualizing an image:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2 as cv\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = cv.imread('./images/img.png')\n",
    "\n",
    "cv.imshow('image', img)\n",
    "cv.waitKey(0)\n",
    "cv.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Click on the image and press any key to close it and continue. It might appear in the __background__. However, __Don't click on the red cross__. If Jupyter crashes, __restart the Kernel__. Don't forget the import `OpenCV` again.\n",
    "\n",
    "In `OpenCV` images are stored as matrices. In our case, we have a matrix of size `Height x Width x Channels = 165x230x3` which is color-coded as BGR by default. Let's quickly change the color space from BGR to HSV:\n",
    "\n",
    "<img src=\"HSV_cone.png\" width=\"250\"> <img src=\"HueScale.svg\" width=\"300\">\n",
    "\n",
    "For HSV, the hue range is `[0,179]` instead of `[0, 359]` (memory issues), saturation range is `[0,255]`, and value range is `[0,255]`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hsv_image = cv.cvtColor(img, cv.COLOR_BGR2HSV)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic image-processing operations, such as colorfiltering are easily done in the HSV colorspace. We are going to define a filtermask for the orange color and apply it to the image. We are also going to make use of `NumPy`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define range of blue color in HSV.\n",
    "# Remember that the Hue Range is only [0,179]\n",
    "lower_blue = np.array([0, 100, 100], dtype=int)\n",
    "upper_blue = np.array([30, 255, 255], dtype=int)\n",
    "\n",
    "# Threshold the HSV image to get only blue colors\n",
    "mask = cv.inRange(hsv_image, lower_blue, upper_blue)\n",
    "\n",
    "# Bitwise-AND mask and original image\n",
    "filtered = cv.bitwise_and(hsv_image, hsv_image, mask= mask)\n",
    "\n",
    "# Convert back to BGR\n",
    "res = cv.cvtColor(filtered, cv.COLOR_HSV2BGR)\n",
    "\n",
    "cv.imshow('image', res)\n",
    "cv.waitKey(0)\n",
    "cv.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OpenCV (Open Source Computer Vision Library: http://opencv.org) is an open-source library that includes several hundreds of computer vision algorithms. For further reference, please visit https://docs.opencv.org/master/d6/d00/tutorial_py_root.html "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.4. SciPy\n",
    "`SciPy` stands for \"Scientific Python\" and is a scientific computation library that is built on top of `NumPy`. It provides more utility functions for optimization, statistics, signal processing and more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy\n",
    "import scipy.optimize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the main applications in `SciPy` is the optimization of functions. `NumPy` is for example capable of solving linear equations. For non-linear problems however, we can use `SciPy`.\n",
    "\n",
    "First we have to define our non-linear problem as a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def problem(x):\n",
    "    return np.exp(x) + np.cos(x) - 3/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we used functions from `NumPy` to formulate the problem. We can simply calculate the root (Nullstelle) of this function as the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "solution = scipy.optimize.root(problem, 0) # In this case '0' specifies the initial guess of the solution.\n",
    "print(solution.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`SciPy` uses numerical approaches to solve optimization problems. That's why we tipically add an initial guess `x0`, in this case `0`. We can similarly calculate minima and maxima of functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def problem(x):\n",
    "    return (x-2)**2 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "solution = scipy.optimize.minimize(problem, 0) # '0' again specifies the initial guess of our solution\n",
    "print(solution.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`SciPy` provides many more features, for example for linear algebra, sparse data, graphs, spatial data, interpolation and more. For this, please have a look at the documentation of `SciPy`: https://docs.scipy.org/doc/scipy/reference/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.5. PyTorch\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`PyTorch` is a scientific computing package that targets two main purposes. First, it can replace `NumPy` with the ability to use the power of GPUs by introducing so-called `Tensors`. Compared to `NumPy`'s `ndarrays`, `Tensors` are easily transferred from CPU to GPU which accelerates your `Python` applications substantially when working with big datasets. Additionally, `PyTorch` is a deep learning framework that enables the flexible building of neural network models. `PyTorch` is a very common package for deep learning. In this Notebook, we will only provide a short glance at the functionalities in `PyTorch`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "from torch.utils.data import DataLoader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`PyTorch` offers several modules, such as `torchvision`, which include datasets. For this demonstration we will train a small neural network that classifies 32x32 RGB images. we will load the `cifar10` dataset, which consists of images with 10 different classes (`plane`, `car`, `bird`, `cat` , `deer`, `dog`, `frog`, `horse`, `ship`, `truck`). The dataset will take approximately 350MB on your computer. Check out how easy this is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) # Transforms that are applied on the images\n",
    "\n",
    "trainset = torchvision.datasets.CIFAR10(root='./data', train=True,\n",
    "                                        download=True, transform=transform)\n",
    "\n",
    "testset = torchvision.datasets.CIFAR10(root='./data', train=False,\n",
    "                                       download=True, transform=transform)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have to specify dataloaders for our train and test set. Here we can specify batch_size, sampling properties and many more:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=32,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=32,\n",
    "                                         shuffle=False, num_workers=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In machine learning applications, it is always useful to first visualize your data. Let's look at some of the images in the given dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "def imshow(img):\n",
    "    img = img/2 + 0.5 # undo transform\n",
    "    npimg = img.numpy() \n",
    "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
    "    plt.show()\n",
    "    \n",
    "# We visualize one batch of the trainloader\n",
    "images, labels = iter(trainloader).next()\n",
    "imshow(torchvision.utils.make_grid(images))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is to define a neural network with `torch.nn`. In this case we will define a small **convolutional neural network** (CNN): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# Network models are defined as classes\n",
    "# The __init__ function contains the layer definitions\n",
    "# the forward function corresponds to the inference step\n",
    "\n",
    "class Model(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Model, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(in_channels=3, out_channels=24, kernel_size=3)\n",
    "        self.conv2 = nn.Conv2d(in_channels=24, out_channels=48, kernel_size=3)\n",
    "\n",
    "        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        \n",
    "        # remaining image size: 48x6x6\n",
    "        \n",
    "        self.fc1 = nn.Linear(48*6*6, 400)\n",
    "        self.fc2 = nn.Linear(400, 100)\n",
    "        self.fc3 = nn.Linear(100, 10)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.pool(F.relu(self.conv1(x)))\n",
    "        x = self.pool(F.relu(self.conv2(x)))\n",
    "        x = x.view(-1, 48 * 6 * 6)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x        \n",
    "\n",
    "model = Model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we have to define a loss-function and an optimizer. For this multi-class classification task we use the cross-entropy loss with a stochastic gradient descent (SGD) optimizer and first order momentum:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And finally, the last step is to train the network. For this, we loop over our data iterator and infer the data into our network. After calculating the loss, `PyTorch` calculates the gradient of each parameter in the network using `backward()` and updates the parameters with `optimizer.step()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for epoch in range(5):\n",
    "    running_loss = 0.0 \n",
    "    for i, data in enumerate(trainloader):\n",
    "        images, labels = data\n",
    "        \n",
    "        # set old parameter gradients to zero before calculating new gradients\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        # forward step\n",
    "        predicted_class_probabilities = model(images)\n",
    "        \n",
    "        # backward step\n",
    "        loss = criterion(predicted_class_probabilities, labels)\n",
    "        loss.backward()\n",
    "        \n",
    "        # update the weights\n",
    "        optimizer.step()\n",
    "        \n",
    "        #print statistics \n",
    "        running_loss += loss.item()\n",
    "        if i % 200 == 199:    # print every 200 mini-batches\n",
    "            print('[%d, %5d] loss: %.3f' %\n",
    "                  (epoch + 1, i + 1, running_loss / 200))\n",
    "            running_loss = 0.0\n",
    "\n",
    "print('Training finished')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, we should not judge the performance of our model only by the training loss. You might have noticed that we defined a test set beforehand. To determine if the network actually learned something, which means that it should generalize from our training set on new data, we can determine the performance of our model on this test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        predicted_class_probabilities = model(images)\n",
    "        _, predicted_labels = torch.max(predicted_class_probabilities.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted_labels == labels).sum().item()\n",
    "\n",
    "print('Accuracy of the network on the 10000 test images: %d %%' % (\n",
    "    100 * correct / total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Virtual environments\n",
    "\n",
    "You may have noticed, that the first thing we have done in `Anaconda` was to set up an environment for the assignments. The purpose of such a (virtual) environment is to have space where packages, which are specefic to a certain project, can be installed. Like this we ensure that we are not getting in trouble with package dependencies. Lets think about the following scenario without any virtual environment: \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](./images/no_virtual_environments.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have two different projects on our computer that partially use the same packages. Project A is several months older and uses older versions of the shared packages than Project B. We now run into problems as we don't know the exact versions of our computer's installed packages. Suppose we update our packages; the older versions are probably overwritten. We don't want to mess things up and create environments for each project and its packages:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](./images/virtual_environments.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we have set up something, we now don't need to worry about any dependencies anymore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sources\n",
    "\n",
    "Python Basics: https://www.learnpython.org/\n",
    "\n",
    "Numpy: https://numpy.org/doc/stable/numpy-user.pdf\n",
    "\n",
    "OpenCV: https://docs.opencv.org/master/d6/d00/tutorial_py_root.html\n",
    "\n",
    "SciPy: https://docs.scipy.org/doc/scipy/reference/\n",
    "\n",
    "PyTorch: https://pytorch.org/docs/stable/index.html"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}