DL01-cell05-explanations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python for deep learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cell 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to take S random samples of coordinates from the forground pixels and S from the background pixels. Since the process is the same fore the list of foreground and the list of background pixels, we write a function that does the work, so that we do not have to write almost the same code twice. \n",
    "\n",
    "Whenever our sample is a pixel for which the whole neighborhood is not in the image, we replace it by a new random sample."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "from random import randint\n",
    "height, width = gtImage.shape\n",
    "def getNCoordinateSamplesFrom(n, aList, minX, maxX, minY, maxY):\n",
    "    samples = []\n",
    "    for _ in range(n):\n",
    "        r = randint(0,len(aList)-1)\n",
    "        coords = aList[r]\n",
    "        while coords[0]<=minY or coords[0]>=maxY or coords[1]<=minX or coords[1]>=maxX:    \n",
    "            r = randint(0,len(aList)-1)\n",
    "            coords = aList[r]\n",
    "        samples.append(coords)\n",
    "    return samples\n",
    "FS = getNCoordinateSamplesFrom(S, foreground, N//2, width-N//2, N//2, height-N//2)\n",
    "BS = getNCoordinateSamplesFrom(S, background, N//2, width-N//2, N//2, height-N//2)\n",
    "print(FS[0:10])\n",
    "print(BS[0:10])\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get a random integer from the interval [a,b] we can use the randint function from the module random. \n",
    "\n",
    "As an example we create a random number between 0 and 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from random import randint\n",
    "randint(0,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The for-loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the for loop to do something with each element of a collection (for example a list)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3]\n",
    "for aNumber in numbers:\n",
    "    print(aNumber**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the head of the for loop, we give a name to the current element of the collection, so that we can use it in the body of the loop. The head of the for-loop ends with the colon. The indented code-block (the body of the loop), is executed for each element of the collecion.\n",
    "\n",
    "Some times we just want to execute some code n times. In this case we use range(0,n) with the for-loop. This creates a collection-object with n elements, the numbers \n",
    "\n",
    "    0, 1, ..., n-1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range(0,3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we are not interested in the elements of the range, but just want to have n repetitions, we use ``_`` as the name for the current element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "a\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "for _ in range(0,3):\n",
    "    print('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The while-loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The while loop is used to repeat a block of code as long as a condition is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while(i<4):\n",
    "    print(i)\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We usually use the while loop when we do not a priori know how many iterations we need.\n",
    "\n",
    "Here is an example that uses Newton's method to approximate the square root of a number. guess is the approximation of the square root of the input number. It gets better with each iteration of the loop.\n",
    "\n",
    "We can easily test how good our guess is by squaring it. If the difference between its square and the input is small the guess is good. We continue the calculation as long as guess is not as good as we want it to be."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11.000000001611474\n"
     ]
    }
   ],
   "source": [
    "input = 121;\n",
    "guess = 1;\n",
    "while abs(guess**2 - input) > 0.001: \n",
    "    guess = 0.5 * ((input / guess) + guess)\n",
    "print(guess);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Appending an element to a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this cell we use ```samples.append(coords)```. This appends a new element to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1, 2, 3]\n",
    "numbers.append(4)\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```numbers.append(4)``` is an example of object oriented programming. In the functional programming paradigm we would write this as:\n",
    "\n",
    "```python\n",
    "numbers = append(numbers, 4)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Object oriented programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the functional programming paradigm a program is a list of functions where each function calculates a result value depending on its input values.\n",
    "\n",
    "In the object oriented programming paradigm a program consists of objects that send messages to each other. An object has data attributes, which are attributes that define its current state and methods that are executed when a message is sent to an object. A class is a scheme that defines the attributes and methods an object has. From a class an arbitrary number of objects can be created. Each of the objects instanciated from the same class have the same attributes and methods but each one has its own, independent state. The state of the object is given by the current values of its data attributes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example we create a class rectangle and instantiate objects from it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle(object):\n",
    "    def __init__(self, x, y, width, height):\n",
    "        super().__init__()\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        \n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "    \n",
    "    def moveBy(self, deltaX, deltaY):\n",
    "        self.x = self.x + deltaX\n",
    "        self.y = self.y + deltaY\n",
    "        \n",
    "    def __repr__(self):\n",
    "        s = f\"aRectangle(x={self.x}, y={self.y}, width={self.width}, height={self.height})\"\n",
    "        return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```__init__``` is special method called a constructor. It defines how new instances of the class (i.e. objects) are created.\n",
    "\n",
    "```__repr__``` is a special method that defines the output when we call print on an instance of the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aRectangle(x=10, y=20, width=50, height=20)\n"
     ]
    }
   ],
   "source": [
    "r1 = Rectangle(10, 20, 50, 20)\n",
    "print(r1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that each method of the class has ``self`` as its first parameter. self stands for the current object itself. \n",
    "\n",
    "We now create two rectangles and check that their state is independent from each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aRectangle(x=15, y=28, width=50, height=20)\n",
      "aRectangle(x=10, y=20, width=50, height=20)\n"
     ]
    }
   ],
   "source": [
    "r1 = Rectangle(10, 20, 50, 20)\n",
    "r2 = Rectangle(10, 20, 50, 20)\n",
    "r1.moveBy(5, 8)\n",
    "print(r1)\n",
    "print(r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create specialized subclasses from existing classes by using class inheritence. In the definition of the class we tell from which classes we want our new class to inherit. The new class will then also have all the attributes and methods of its superclasses. However it can also override a method with a new version.\n",
    "\n",
    "Note that the main mechanism in oop is not inheritance but delegation. Delegation means that one object forwards a message to another object.\n",
    "\n",
    "The class Rectangle is a subclass of the class object. We now create a subclass of Rectangle that represents special rectangles for which width and height are equal, i.e. squares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aSquare(x=10, y=20, width=30)\n",
      "30 30\n",
      "aSquare(x=13, y=22, width=30)\n",
      "900\n"
     ]
    }
   ],
   "source": [
    "class Square(Rectangle):\n",
    "    def __init__(self, x, y, width):\n",
    "        super().__init__(x, y, width, width)\n",
    "        \n",
    "    def __repr__(self):\n",
    "        s = f\"aSquare(x={self.x}, y={self.y}, width={self.width})\"\n",
    "        return s\n",
    "        \n",
    "rec1 = Square(10, 20, 30)\n",
    "print(rec1)\n",
    "print(rec1.width, rec1.height)\n",
    "rec1.moveBy(3,2)\n",
    "print(rec1)\n",
    "print(rec1.area())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the class square inherited the methods ``moveBy`` and ``area`` from the class rectangle. It has overriden the method __repr__ so that it has its own textual representation when printed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting random samples from a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What we want to do is to get S random samples from a list. To do this we create random numbers for the indices of the list and then create a new list with the elements at those indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['c', 'a', 'f']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aList = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
    "samples = []\n",
    "for _ in range (0,3):\n",
    "    r = randint(0,len(aList)-1)\n",
    "    samples.append(aList[r])\n",
    "samples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now want to get 3 random samples from the list, but we want to make sure that they are not 'a' or 'd'. To implement this we keep getting new samples as long as the sample equals 'a' or 'd'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['c', 'g', 'h']"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aList = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
    "samples = []\n",
    "for _ in range (0,3):\n",
    "    r = randint(0,len(aList)-1)\n",
    "    sample = aList[r]\n",
    "    while(sample=='a' or sample=='d'):\n",
    "        r = randint(0,len(aList)-1)\n",
    "        sample = aList[r]\n",
    "    samples.append(sample)\n",
    "samples"
   ]
  }
 ],
 "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
}