diff --git a/serie1/cirilli_simon_arintsoa_kiady_serie_1.zip b/serie1/cirilli_simon_arintsoa_kiady_serie_1.zip new file mode 100644 index 0000000000000000000000000000000000000000..3b7ec65812c6464b727056aaaef291113d296150 Binary files /dev/null and b/serie1/cirilli_simon_arintsoa_kiady_serie_1.zip differ diff --git a/serie1/intro-python-3.ipynb b/serie1/intro-python-3.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f1e2f2b1c44b1ca5c04c762fcf2d29feb9e84d90 --- /dev/null +++ b/serie1/intro-python-3.ipynb @@ -0,0 +1,772 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Last revision: Jean Hennebert - 12.09.2018\n", + "\n", + "# Introduction to Python\n", + "**Remark**: This document is intended for the students following the Machine Learning and Deep Learning class. We assume that students are knowledgeable in other programming languages such as Java or C and that basic data structure concepts are known. If you know already Python and iPython Notebooks (such as this document), then you can avoid reading the rest of this page. If you want a rather slow introduction to Python, read the official [tutorial](https://docs.python.org/3/tutorial/index.html).\n", + "\n", + "Python was released in 1991 and initially developed by Guido van Rossum (Holland). Python got inspiration from Modula 3, is object-oriented and can be easily extended. Good libraries are available to work with data, to visualize it and to model it with machine learning. This is why we have chosen to do most of the exercises with Python in this class.\n", + "\n", + "## How to work with Python\n", + "You have basically 3 ways to work with Python:\n", + "\n", + "1. Using a Python console in interactive mode. Just open a terminal and launch `python`.\n", + "2. Using a text editor or an IDE to develop (saving \".py\" files), as you would do it in Java or C. A good IDE is [Pycharm](https://www.jetbrains.com/pycharm/) from Jet Brains.\n", + "3. Using a iPython notebook via a web browser. The concept is similar to Mathematica notebooks where you can mix code and text inputs (using Markdown) in so-called cells. This document is actually a \".ipynb\" file.\n", + "\n", + "For this class we recommend to work with iPython Notebooks which is probably the best way to give us back your practical works.\n", + "\n", + "To install iPython notebook, you may use the [Anaconda](https://www.continuum.io/downloads) package. This is a free bundled installer of Python and other tools including the _Jupyter Notebook App_ (client-server application that allows editing and running notebooks). iPython notebooks are also supported in the IDE [Pycharm](https://www.jetbrains.com/pycharm/).\n", + "\n", + "## Which version of Python to use?\n", + "There are currently two \"concurrent\" versions of Python, versions 2 and 3. The Python world has now been strongly migrating towards using Python 3. The Python world has now been migrating strongly towards using Python 3 and we therefore recommend to use 3 instead of 2. Beware that Python 2 and Python 3 have some incompatible differences in language syntax. You may also find code examples and libraries on the web that did not move yet to version 3. Share your experience with us if you have any troubles! Now, let's start with some basics.\n", + "\n", + "## Let's start!\n", + "In a notebook, you have different types of cells: **Markdown cells** (like this one) where you can input your text and format it with simple [syntax](https://help.github.com/articles/basic-writing-and-formatting-syntax/), and Python **Code cells** (like the one just below). You can switch from one type to the other using the dropdown list in the notebook toolbar or using one of the keyboard shortcuts. For shortcuts see the very useful `Help` menu above.\n", + "\n", + "To execute a code cell, just select it with the mouse (or navigate with the arrow keys after pressing ESC), and press `SHIFT-Enter`. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "names = [\"Jean\", \"Andres\", \"Lorenz\"]\n", + "for name in names:\n", + " print(\"Hello\", name)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The output of a cell execution should appear just below the cell. You may want to try by modifying the code of the cell just above.\n", + "\n", + "## Python basics\n", + "\n", + "### Basic operators\n", + "\n", + "The operators of Python are the following, by order of priority:\n", + "\n", + "| Operator | Description |\n", + "| :-: | ----------- |\n", + "| `( )` | parenthesis |\n", + "| `-` | arithmetic negation |\n", + "| `**` | power |\n", + "| `* /` | multiplication and division|\n", + "| `+ -` | addition and subtraction|\n", + "| `== != < <= > >=` | relational operators |\n", + "| `not` | logical negation |\n", + "| `and` | conjonction (logical and) |\n", + "| `or` | disjonction (logical or) |\n", + "\n", + "\n", + "Boolean values are written with `True` and `False`.\n", + "For all operators, function equivalents are also available." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = 2 ** 3 # 2 to the power of 3\n", + "y = pow(2,3) # function pow, equivalent to 2 ** 3\n", + "print(x, y) # print can take as many arguments as you need\n", + "print(x<y) # output is here a boolean" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bitwise operators\n", + "For the happy manipulators of bits!\n", + "\n", + "| Command | Description |\n", + "| :---: | --- |\n", + "| & | Binary AND |\n", + "| | | Binary OR |\n", + "| ^ | Binary XOR |\n", + "| ~ | Binary Ones Complement |\n", + "| << | Binary Left Shift |\n", + "| >> | Binary Right Shift |" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = 60 # 60 = 0011 1100 \n", + "b = 13 # 13 = 0000 1101 \n", + "c = 0\n", + "\n", + "c = a & b # 12 = 0000 1100\n", + "print(\"Line 1 - Value of c is \", c)\n", + "c = a | b # 61 = 0011 1101\n", + "print(\"Line 2 - Value of c is \", c)\n", + "c = a ^ b # 49 = 0011 0001\n", + "print(\"Line 3 - Value of c is \", c)\n", + "c = ~a # -61 = 1100 0011\n", + "print(\"Line 4 - Value of c is \", c)\n", + "c = a << 2 # 240 = 1111 0000\n", + "print(\"Line 5 - Value of c is \", c)\n", + "c = a >> 2 # 15 = 0000 1111\n", + "print(\"Line 6 - Value of c is \", c)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Types\n", + "Python uses dynamic typing, i.e. you don't need to declare the type of a variable before using it, Python does infer it for you. \n", + "\n", + "<sub>**Remark**: Variables remain in memory from one cell to the other (`type(x)` shows the type of x which was created in the previous cell.</sub>\n", + "\n", + "<sub>**Remark bis**: Strings in Python can be created with single or double quotes. Strings are immutable objects.</sub>" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z = 3.1415\n", + "message = 'hello'\n", + "print(type(x), type(z), type(message))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic data structures\n", + "### Lists\n", + "In Python, lists are :\n", + "- defined with square brackets `[]`\n", + "- allowed to contain objects of different types\n", + "- indexed from `0` to `len(myList)-1` (negative indexes are allowed and start from the end of the list)\n", + "- supporting slicing to create sub-lists from the list\n", + " - `[i:j]` creates a list using elements from index `i` to `j-1`\n", + " - `[i:]` creates a list using elements from index `i` to the end of the list\n", + " - `[:j]` creates a list using elements from the start of the list to index `j-1`\n", + " - `[i:j:step]` creates a list from `i` to `j` by steps of `step`\n", + "- mutable, i.e. the content can be dynamically modified without re-creating a list object (...well, as usual with lists); for example using the `append()` function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_list = [\"hello\", \"this list\", \"holds\", 5, \"elements\"] #we can mix types in the list\n", + "print(\"my_list :\", my_list)\n", + "print(\"length :\", len(my_list))\n", + "print(\"1st element :\", my_list[0])\n", + "print(\"last element :\", my_list[len(my_list)-1])\n", + "print(\"last element (bis) :\", my_list[-1])\n", + "print(\"slicing from i to j :\", my_list[1:3])\n", + "print(\"slicing from start to j :\", my_list[:3])\n", + "print(\"slicing from i to j with steps :\", my_list[0:5:2])\n", + "print(\"+ operator concatenates lists : \", my_list + my_list)\n", + "my_list[2] = 'contains'\n", + "print(\"mutability, 3rd element replaced:\", my_list)\n", + "my_list.append(\"and now 6 elements\")\n", + "print(\"mutability with append() :\", my_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "You will find more information on lists and data structures in general [here](https://docs.python.org/3/tutorial/datastructures.html).\n", + "\n", + "### Stacks\n", + "You can actually use lists as stacks as explained [here](https://docs.python.org/3/tutorial/datastructures.html) and more specifically with functions `list.append()` to push and `list.pop()` to pop the stack." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_stack = []\n", + "my_stack.append('l')\n", + "my_stack.append('e')\n", + "my_stack.append('o')\n", + "my_stack.append('n')\n", + "print(my_stack.pop(), my_stack.pop(), my_stack.pop(), my_stack.pop())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### Vector and matrices with lists\n", + "A potential use of lists is to store vectors and matrices. For matrices, you may declare an element of the list as a list (i.e. a vector in a vector makes it a matrix isn't it?). Let's see this in practice:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_matrix = [[1,2,3],[4,5,6],[7,8,9]]\n", + "my_matrix[1] #gets the 1st row of the matrix (remember an index starts at 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "However we do not recommend to use lists as a way to do algebra operations on vectors and matrices. This is for two main reasons:\n", + "1. There is no type control in lists, i.e. you may mix types and therefore any vector or matrix operations you may build will be weak on lists, unless you check the types of elements (which is time consuming).\n", + "2. There are few pre-defined math functions on lists. We recommend using other libraries that have their own data structure. A very good one is `numpy` and its pre-defined data structure `array` (see below and [here](http://docs.scipy.org/doc/numpy/user/index.html) for more info on numpy).\n", + "\n", + "### Vector and matrices with numpy arrays\n", + "To import a library, use the `import` command followed by the library name. Optionnaly you may prefix the functions then imported with a `as short_name`. The short name defines actually an \"alias\" to prefix the functions available in the library. There are some widespread conventions for prefixing. Here is how most people import and prefix the `numpy` library using the `np` alias:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "x = np.array([1,2,3]) #generates a numpy array from a list, i.e. a vector\n", + "A = np.array([[1,2,3],[4,5,6],[7,8,9]]) #array of array, i.e. a matrix\n", + "z = np.zeros(10) #1x10 vector full of 0.0\n", + "O = np.ones((3,3)) #3x3 matrix full of 1.0\n", + "i = np.arange(0,100,10) #vector of values between 0 and 100 by step of 10\n", + "print('x = ', x)\n", + "print('A = ', A)\n", + "print('z = ', z)\n", + "print('O = ', O)\n", + "print('i = ', i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `array` type from numpy is similar to lists regarding the indexing and slicing mechanisms. However, the `array` type is different to the list type :\n", + "\n", + "1. Arrays do not allow type mixing (which is good as less error prone)\n", + "2. Once created, an array is not mutable and has a fixed size\n", + "3. Many practical functions are available to create arrays\n", + "4. Many functions are available to perform computation on arrays\n", + "\n", + "<sub>**Remark**: another way to import libraries it to use `from library import function_name`, in which case only the function given by its name is imported. You can use `from library import *` to import all functions from this library. In this case, there is no need for prefixes.</sub>\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tuples\n", + "Tuples are defined with `()`. They are similar to lists as they can contain heterogeneous sequences of data. The main difference with lists is that tuples are immutable." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "t = (2, True, 3.1415)\n", + "print(\"t : \", t)\n", + "print(\"t length : \", len(t))\n", + "print(\"t sliced : \", t[0:2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sets\n", + "Python offers a set data structure, defined with `{}`. Sets are used to store unordered objects. There is no notion of sequence, just a notion of being or not in the set. Duplicate objects are not allowed in sets. Sets are mutable.\n", + "\n", + "| Operator | Explanation |\n", + "| :---: | :--- |\n", + "| in\t | Check set membership |\n", + "| len | Cardinality of the set |\n", + "| or | Union of 2 sets (or) |\n", + "| &\t | Intersection of 2 sets (and) |\n", + "| -\t | Difference of 2 sets |\n", + "| <= | Check sets inclusion |\n", + "| add(e) | Adds element e in set | \n", + "| remove(e)| Removes element e from set |" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "s = {3, 6, 'cat', 4.5, False}\n", + "print(\"s : \", s)\n", + "print(\"s length : \", len(s))\n", + "print(\"is True in s : \", True in s)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dictionaries\n", + "Sets can be used to implement dictionaries storing couples of `key:values`. This datastructure is very useful in Python." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "capitals = {'Wisconsin':'Madison', 'Utah':'SaltLakeCity', 'Iowa':'DesMoines'}\n", + "print(capitals['Iowa'], \"is capital of Iowa\")\n", + "print(\"The capital of California is \", capitals.get(\"California\",\"...oops we don't know\"))\n", + "capitals['California'] = 'Sacramento' # to add a key-value pair\n", + "print(\"And now all the capitals we know about:\")\n", + "for key in capitals:\n", + " print(\" \",capitals[key] , \"is capital of\", key)\n", + "del capitals['California'] # to delete a key" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want to access to keys and their corresponding values, use the `items` method to iterate in the dictionary." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "capitals = {'Wisconsin': 'Madison', 'Utah': 'SaltLakeCity', 'Iowa': 'DesMoines'}\n", + "for key, value in capitals.items():\n", + " print(key, '->', value)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Strings\n", + "Python is also very friendly whent it comes to manipulate strings. The following examples are probably self-explanatory at this stage. You may find all the string methods in the [documentation](https://docs.python.org/3/library/stdtypes.html#string-methods). " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "words = 'The quick brown fox jumps over the lazy dog'.split()\n", + "print(words)\n", + "stuff = [[w.upper(), w.lower(), len(w)] for w in words]\n", + "for i in stuff:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "s = \"hello\"\n", + "print(s.rjust(7)) # right-justify a string, padding with spaces; prints \" hello\"\n", + "print(s.center(7)) # center a string, padding with spaces; prints \" hello \"\n", + "print(s.replace('l', '(ell)')) # replace all instances of one substring with another;\n", + " # prints \"he(ell)(ell)o\"\n", + "print(' world '.strip()) # strip leading and trailing whitespace; prints \"world\"\n", + "f = \"%s %10s %10d\" % (s, 'world', 2070) # sprintf style string formatting\n", + "print(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Control statements\n", + "You can control the execution with the classical conditional command `if`, iterative command `while` and `for`. The following examples should be self-explanatory. \n", + "\n", + "Warnings:\n", + "* don't forget the `:` after the control expressions\n", + "* use indentations (yes, we know, it's ugly, gasp!)\n", + "### If statement" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "var = np.random.randint(low=1,high=7) # var is a random int in [1,7[ (high value is exclusive)\n", + "print(var)\n", + "if var < 4:\n", + " print(\"var is 1, 2 or 3\")\n", + " if var == 3:\n", + " print(\"var is 3\")\n", + " elif var == 2:\n", + " print(\"var is 2\")\n", + " else:\n", + " print(\"var is 1\")\n", + "elif var < 7:\n", + " print(\"var is 4, 5 or 6\")\n", + "else:\n", + " print(\"There is a bug\")\n", + "\n", + "print(\"Good bye!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### While statement" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "counter = 0\n", + "while (counter <10):\n", + " print('counter value is:', counter)\n", + " counter = counter + 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### For statement" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for letter in 'python':\n", + " if letter=='o': break\n", + " if letter=='y': continue\n", + " print('current letter: ', letter)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lists generation with comprehension\n", + "Python offers a very nice way to generate sets of values (in lists, dictionaries, etc), using a syntax which is *close-to* mathematical notation. Here is an example, assume that we want to generate the following set S of values:\n", + "\n", + "$$ S = \\{ 2x \\mid x \\in \\mathbb{N}, x^2>50, x<100 \\} $$\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "S = [2*x for x in np.arange(100000) if x**2>50 and x <100]\n", + "print(S)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Functions and classes\n", + "### Function calls\n", + "Python is quite user friendly for function calls. If you don't remember the order of the arguments, you may specify the arguments in any order by using its name. Most functions are also defined with default argument values. In general, have a look at their documentation to know which parameter is compulsory or which parameter is optional with default values. In this example, have a look at the doc of [random.randint()](https://docs.scipy.org/doc/numpy-1.15.1/reference/generated/numpy.random.randint.html)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.random.randint(1,7) # function randint picks randomly an int between 1 (incl) and 7 (excl)\n", + "print(a)\n", + "b = np.random.randint(high=7, low=1) # this function call is equivalent\n", + "print(b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example below, pay attention to the arguments in the signature of the function. Some arguments have default values that allows users to call this function not specifying these arguments." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Function definitions\n", + "Here is how to define a function. Note that the function documentation is following the `def` line and also note the indentation in the body of the function. Note also that we can define optional parameters with default values, e.g. in this case `findMax`. A call to `help(function_name)` will output the documentation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def extremum_in_vector(v, find_max=True):\n", + " \"\"\"Returns the extremum value in the vector v. Argument find_max specify whether to find the max \n", + " (default) or min.\n", + " precondition: v is a sequence of comparable elements.\n", + " Usage: m = extremum_in_vector(v)\"\"\"\n", + " m = v[0]\n", + " for value in v:\n", + " if(find_max):\n", + " if(m < value):\n", + " m = value\n", + " else:\n", + " if(m > value):\n", + " m = value\n", + " return m\n", + "\n", + "help(extremum_in_vector)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "v = np.random.randint(1, 6, size=10) #generates 10 integers between 1 and 6\n", + "\n", + "print(\"v\", v)\n", + "print(\"maximum in v is\", extremum_in_vector(v))\n", + "print(\"minimum in v is\", extremum_in_vector(v, find_max=False))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Classes definitions\n", + "The syntax for defining classes is pretty straightforward:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class Hello(object):\n", + "\n", + " # Constructor\n", + " def __init__(self, name):\n", + " self.name = name # Create an instance variable\n", + " #self is the equivalent of this in java\n", + "\n", + " # Instance method\n", + " def sayhi(self, loud=False):\n", + " if loud:\n", + " print('HELLO, %s!' % self.name.upper())\n", + " else:\n", + " print('Hello, %s' % self.name)\n", + "\n", + "g = Hello('Jean') # construct an instance of the class Hello\n", + "g.sayhi() # call the instance method sayhi()\n", + "g.sayhi(loud=True) # Call the instance method sayhi() specifying the optional argument" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting graphs\n", + "Now let's import `matplotlib.pyplot` for ploting figures. You'll find more info [here](http://matplotlib.org/api/pyplot_api.html) on the API." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline \n", + "# the line above tells iPython to plot the graphs inline, below the cell\n", + "\n", + "import numpy as np # all numpy functions now available as np.*()\n", + "import matplotlib.pyplot as plt # all pyplot functions now available as plt.*()\n", + "x = np.linspace(0,10,400) # generate an array of 400 points between 0 and 10\n", + "y = np.sin(x) # compute the sin of x, element-wise \n", + "plt.plot(x,y) # generate a graph object (in memory)\n", + "plt.show() # then show the graph" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np \n", + "import matplotlib.pyplot as plt \n", + "\n", + "t = np.linspace(0,10,400) # time t (will be our x axis)\n", + "\n", + "a1 = 0.5 # damping factor 1\n", + "a2 = 0.1 # damping factor 2\n", + "\n", + "u1 = np.exp(-2*a1*t)*np.cos(2*np.pi*t) # damped cosine u (will be our y axis)\n", + "u2 = np.exp(-2*a2*t)*np.cos(2*np.pi*t)\n", + "\n", + "plt.plot(t,u1,label=\"A=0.5\") # plot1 with A = 0.5, with label for legend\n", + "plt.plot(t,u2,label=\"A=0.1\") # plot2 with A = 0.1, with label for legend\n", + "\n", + "plt.xlim(0, 10) # limit the x axis between 0 and 10\n", + "plt.xlabel(\"time\") # x axis label definition\n", + "\n", + "plt.ylim(-1, 1) # limit the y axis between -1 and 1\n", + "plt.ylabel(\"U=f(time)\") # y axis label definition\n", + "\n", + "plt.title(\"Time evolution of the tension \\n with two damping factors\", fontsize=14)\n", + "plt.legend() # plot the legend\n", + "\n", + "plt.show() # show the legend" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "gaussian_numbers = np.random.normal(size=10000) # generate 10'000 values randomly sampled from a normal dist\n", + "plt.hist(gaussian_numbers, bins=30, density=True) # histogram of the values using 30 bins and percent frequency\n", + "plt.title(\"Gaussian Histogram\")\n", + "plt.xlabel(\"Value\")\n", + "plt.ylabel(\"Frequency\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot with recursive calls - L-systems" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def lsystem(pta, angle, length, refAngle, refLengthMultiplier=0.5, level=4):\n", + "\n", + " # computing coordinates of next point\n", + " ptb = np.zeros(2)\n", + " ptb[0] = pta[0] + length * np.cos(angle)\n", + " ptb[1] = pta[1] + length * np.sin(angle)\n", + "\n", + " plt.plot([pta[0], ptb[0]], [pta[1], ptb[1]])\n", + "\n", + " if (level > 0):\n", + " # compute angles of three new branches\n", + " angle1 = angle - (refAngle*0.5) + np.random.uniform(0, 1.0) * refAngle\n", + " angle2 = angle - (refAngle*0.5) + np.random.uniform(0, 1.0) * refAngle\n", + " angle3 = angle - (refAngle*0.5) + np.random.uniform(0, 1.0) * refAngle\n", + "\n", + " # compute length of new branches\n", + " nextLength = length * refLengthMultiplier;\n", + "\n", + " # recursive call here\n", + " lsystem( ptb, angle1, nextLength, refAngle, refLengthMultiplier, level-1)\n", + " lsystem( ptb, angle2, nextLength, refAngle, refLengthMultiplier, level-1)\n", + " lsystem( ptb, angle3, nextLength, refAngle, refLengthMultiplier, level-1)\n", + "\n", + "# demo\n", + "frame = plt.gca()\n", + "frame.axes.get_xaxis().set_visible(False)\n", + "frame.axes.get_yaxis().set_visible(False)\n", + "plt.axis('equal')\n", + "\n", + "lsystem([0,0], np.pi/2, 1.0, np.pi/2, 0.75, 3); #respecting the order of the arguments\n", + "lsystem([1,0], np.pi/2, 1.0, np.pi/3); #using defaults values for refLengthMultiplier and level\n", + "lsystem([2,0], np.pi/2, 1.0, np.pi/4, 0.75, level=5); #using default for refLengthMultiplier and giving arg by name" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/serie1/iris.txt b/serie1/iris.txt new file mode 100644 index 0000000000000000000000000000000000000000..d6acb41ab05a3c80f34b7c51260fb6b1a8049cf3 --- /dev/null +++ b/serie1/iris.txt @@ -0,0 +1,151 @@ +"Sepal.Length" "Sepal.Width" "Petal.Length" "Petal.Width" "Species" "Sepal.Area" "Petal.Area" "Sepal.Ratio" "Petal.Ratio" +5.1 3.5 1.4 0.2 "setosa" 17.85 0.28 1.45714285714286 7 +4.9 3 1.4 0.2 "setosa" 14.7 0.28 1.63333333333333 7 +4.7 3.2 1.3 0.2 "setosa" 15.04 0.26 1.46875 6.5 +4.6 3.1 1.5 0.2 "setosa" 14.26 0.3 1.48387096774194 7.5 +5 3.6 1.4 0.2 "setosa" 18 0.28 1.38888888888889 7 +5.4 3.9 1.7 0.4 "setosa" 21.06 0.68 1.38461538461538 4.25 +4.6 3.4 1.4 0.3 "setosa" 15.64 0.42 1.35294117647059 4.66666666666667 +5 3.4 1.5 0.2 "setosa" 17 0.3 1.47058823529412 7.5 +4.4 2.9 1.4 0.2 "setosa" 12.76 0.28 1.51724137931034 7 +4.9 3.1 1.5 0.1 "setosa" 15.19 0.15 1.58064516129032 15 +5.4 3.7 1.5 0.2 "setosa" 19.98 0.3 1.45945945945946 7.5 +4.8 3.4 1.6 0.2 "setosa" 16.32 0.32 1.41176470588235 8 +4.8 3 1.4 0.1 "setosa" 14.4 0.14 1.6 14 +4.3 3 1.1 0.1 "setosa" 12.9 0.11 1.43333333333333 11 +5.8 4 1.2 0.2 "setosa" 23.2 0.24 1.45 6 +5.7 4.4 1.5 0.4 "setosa" 25.08 0.6 1.29545454545455 3.75 +5.4 3.9 1.3 0.4 "setosa" 21.06 0.52 1.38461538461538 3.25 +5.1 3.5 1.4 0.3 "setosa" 17.85 0.42 1.45714285714286 4.66666666666667 +5.7 3.8 1.7 0.3 "setosa" 21.66 0.51 1.5 5.66666666666667 +5.1 3.8 1.5 0.3 "setosa" 19.38 0.45 1.34210526315789 5 +5.4 3.4 1.7 0.2 "setosa" 18.36 0.34 1.58823529411765 8.5 +5.1 3.7 1.5 0.4 "setosa" 18.87 0.6 1.37837837837838 3.75 +4.6 3.6 1 0.2 "setosa" 16.56 0.2 1.27777777777778 5 +5.1 3.3 1.7 0.5 "setosa" 16.83 0.85 1.54545454545455 3.4 +4.8 3.4 1.9 0.2 "setosa" 16.32 0.38 1.41176470588235 9.5 +5 3 1.6 0.2 "setosa" 15 0.32 1.66666666666667 8 +5 3.4 1.6 0.4 "setosa" 17 0.64 1.47058823529412 4 +5.2 3.5 1.5 0.2 "setosa" 18.2 0.3 1.48571428571429 7.5 +5.2 3.4 1.4 0.2 "setosa" 17.68 0.28 1.52941176470588 7 +4.7 3.2 1.6 0.2 "setosa" 15.04 0.32 1.46875 8 +4.8 3.1 1.6 0.2 "setosa" 14.88 0.32 1.54838709677419 8 +5.4 3.4 1.5 0.4 "setosa" 18.36 0.6 1.58823529411765 3.75 +5.2 4.1 1.5 0.1 "setosa" 21.32 0.15 1.26829268292683 15 +5.5 4.2 1.4 0.2 "setosa" 23.1 0.28 1.30952380952381 7 +4.9 3.1 1.5 0.2 "setosa" 15.19 0.3 1.58064516129032 7.5 +5 3.2 1.2 0.2 "setosa" 16 0.24 1.5625 6 +5.5 3.5 1.3 0.2 "setosa" 19.25 0.26 1.57142857142857 6.5 +4.9 3.6 1.4 0.1 "setosa" 17.64 0.14 1.36111111111111 14 +4.4 3 1.3 0.2 "setosa" 13.2 0.26 1.46666666666667 6.5 +5.1 3.4 1.5 0.2 "setosa" 17.34 0.3 1.5 7.5 +5 3.5 1.3 0.3 "setosa" 17.5 0.39 1.42857142857143 4.33333333333333 +4.5 2.3 1.3 0.3 "setosa" 10.35 0.39 1.95652173913044 4.33333333333333 +4.4 3.2 1.3 0.2 "setosa" 14.08 0.26 1.375 6.5 +5 3.5 1.6 0.6 "setosa" 17.5 0.96 1.42857142857143 2.66666666666667 +5.1 3.8 1.9 0.4 "setosa" 19.38 0.76 1.34210526315789 4.75 +4.8 3 1.4 0.3 "setosa" 14.4 0.42 1.6 4.66666666666667 +5.1 3.8 1.6 0.2 "setosa" 19.38 0.32 1.34210526315789 8 +4.6 3.2 1.4 0.2 "setosa" 14.72 0.28 1.4375 7 +5.3 3.7 1.5 0.2 "setosa" 19.61 0.3 1.43243243243243 7.5 +5 3.3 1.4 0.2 "setosa" 16.5 0.28 1.51515151515152 7 +7 3.2 4.7 1.4 "versicolor" 22.4 6.58 2.1875 3.35714285714286 +6.4 3.2 4.5 1.5 "versicolor" 20.48 6.75 2 3 +6.9 3.1 4.9 1.5 "versicolor" 21.39 7.35 2.22580645161290 3.26666666666667 +5.5 2.3 4 1.3 "versicolor" 12.65 5.2 2.39130434782609 3.07692307692308 +6.5 2.8 4.6 1.5 "versicolor" 18.2 6.9 2.32142857142857 3.06666666666667 +5.7 2.8 4.5 1.3 "versicolor" 15.96 5.85 2.03571428571429 3.46153846153846 +6.3 3.3 4.7 1.6 "versicolor" 20.79 7.52 1.90909090909091 2.9375 +4.9 2.4 3.3 1 "versicolor" 11.76 3.3 2.04166666666667 3.3 +6.6 2.9 4.6 1.3 "versicolor" 19.14 5.98 2.27586206896552 3.53846153846154 +5.2 2.7 3.9 1.4 "versicolor" 14.04 5.46 1.92592592592593 2.78571428571429 +5 2 3.5 1 "versicolor" 10 3.5 2.5 3.5 +5.9 3 4.2 1.5 "versicolor" 17.7 6.3 1.96666666666667 2.8 +6 2.2 4 1 "versicolor" 13.2 4 2.72727272727273 4 +6.1 2.9 4.7 1.4 "versicolor" 17.69 6.58 2.10344827586207 3.35714285714286 +5.6 2.9 3.6 1.3 "versicolor" 16.24 4.68 1.93103448275862 2.76923076923077 +6.7 3.1 4.4 1.4 "versicolor" 20.77 6.16 2.16129032258065 3.14285714285714 +5.6 3 4.5 1.5 "versicolor" 16.8 6.75 1.86666666666667 3 +5.8 2.7 4.1 1 "versicolor" 15.66 4.1 2.14814814814815 4.1 +6.2 2.2 4.5 1.5 "versicolor" 13.64 6.75 2.81818181818182 3 +5.6 2.5 3.9 1.1 "versicolor" 14 4.29 2.24 3.54545454545454 +5.9 3.2 4.8 1.8 "versicolor" 18.88 8.64 1.84375 2.66666666666667 +6.1 2.8 4 1.3 "versicolor" 17.08 5.2 2.17857142857143 3.07692307692308 +6.3 2.5 4.9 1.5 "versicolor" 15.75 7.35 2.52 3.26666666666667 +6.1 2.8 4.7 1.2 "versicolor" 17.08 5.64 2.17857142857143 3.91666666666667 +6.4 2.9 4.3 1.3 "versicolor" 18.56 5.59 2.20689655172414 3.30769230769231 +6.6 3 4.4 1.4 "versicolor" 19.8 6.16 2.2 3.14285714285714 +6.8 2.8 4.8 1.4 "versicolor" 19.04 6.72 2.42857142857143 3.42857142857143 +6.7 3 5 1.7 "versicolor" 20.1 8.5 2.23333333333333 2.94117647058824 +6 2.9 4.5 1.5 "versicolor" 17.4 6.75 2.06896551724138 3 +5.7 2.6 3.5 1 "versicolor" 14.82 3.5 2.19230769230769 3.5 +5.5 2.4 3.8 1.1 "versicolor" 13.2 4.18 2.29166666666667 3.45454545454545 +5.5 2.4 3.7 1 "versicolor" 13.2 3.7 2.29166666666667 3.7 +5.8 2.7 3.9 1.2 "versicolor" 15.66 4.68 2.14814814814815 3.25 +6 2.7 5.1 1.6 "versicolor" 16.2 8.16 2.22222222222222 3.1875 +5.4 3 4.5 1.5 "versicolor" 16.2 6.75 1.8 3 +6 3.4 4.5 1.6 "versicolor" 20.4 7.2 1.76470588235294 2.8125 +6.7 3.1 4.7 1.5 "versicolor" 20.77 7.05 2.16129032258065 3.13333333333333 +6.3 2.3 4.4 1.3 "versicolor" 14.49 5.72 2.73913043478261 3.38461538461538 +5.6 3 4.1 1.3 "versicolor" 16.8 5.33 1.86666666666667 3.15384615384615 +5.5 2.5 4 1.3 "versicolor" 13.75 5.2 2.2 3.07692307692308 +5.5 2.6 4.4 1.2 "versicolor" 14.3 5.28 2.11538461538462 3.66666666666667 +6.1 3 4.6 1.4 "versicolor" 18.3 6.44 2.03333333333333 3.28571428571429 +5.8 2.6 4 1.2 "versicolor" 15.08 4.8 2.23076923076923 3.33333333333333 +5 2.3 3.3 1 "versicolor" 11.5 3.3 2.17391304347826 3.3 +5.6 2.7 4.2 1.3 "versicolor" 15.12 5.46 2.07407407407407 3.23076923076923 +5.7 3 4.2 1.2 "versicolor" 17.1 5.04 1.9 3.5 +5.7 2.9 4.2 1.3 "versicolor" 16.53 5.46 1.96551724137931 3.23076923076923 +6.2 2.9 4.3 1.3 "versicolor" 17.98 5.59 2.13793103448276 3.30769230769231 +5.1 2.5 3 1.1 "versicolor" 12.75 3.3 2.04 2.72727272727273 +5.7 2.8 4.1 1.3 "versicolor" 15.96 5.33 2.03571428571429 3.15384615384615 +6.3 3.3 6 2.5 "virginica" 20.79 15 1.90909090909091 2.4 +5.8 2.7 5.1 1.9 "virginica" 15.66 9.69 2.14814814814815 2.68421052631579 +7.1 3 5.9 2.1 "virginica" 21.3 12.39 2.36666666666667 2.80952380952381 +6.3 2.9 5.6 1.8 "virginica" 18.27 10.08 2.17241379310345 3.11111111111111 +6.5 3 5.8 2.2 "virginica" 19.5 12.76 2.16666666666667 2.63636363636364 +7.6 3 6.6 2.1 "virginica" 22.8 13.86 2.53333333333333 3.14285714285714 +4.9 2.5 4.5 1.7 "virginica" 12.25 7.65 1.96 2.64705882352941 +7.3 2.9 6.3 1.8 "virginica" 21.17 11.34 2.51724137931034 3.5 +6.7 2.5 5.8 1.8 "virginica" 16.75 10.44 2.68 3.22222222222222 +7.2 3.6 6.1 2.5 "virginica" 25.92 15.25 2 2.44 +6.5 3.2 5.1 2 "virginica" 20.8 10.2 2.03125 2.55 +6.4 2.7 5.3 1.9 "virginica" 17.28 10.07 2.37037037037037 2.78947368421053 +6.8 3 5.5 2.1 "virginica" 20.4 11.55 2.26666666666667 2.61904761904762 +5.7 2.5 5 2 "virginica" 14.25 10 2.28 2.5 +5.8 2.8 5.1 2.4 "virginica" 16.24 12.24 2.07142857142857 2.125 +6.4 3.2 5.3 2.3 "virginica" 20.48 12.19 2 2.30434782608696 +6.5 3 5.5 1.8 "virginica" 19.5 9.9 2.16666666666667 3.05555555555556 +7.7 3.8 6.7 2.2 "virginica" 29.26 14.74 2.02631578947368 3.04545454545455 +7.7 2.6 6.9 2.3 "virginica" 20.02 15.87 2.96153846153846 3 +6 2.2 5 1.5 "virginica" 13.2 7.5 2.72727272727273 3.33333333333333 +6.9 3.2 5.7 2.3 "virginica" 22.08 13.11 2.15625 2.47826086956522 +5.6 2.8 4.9 2 "virginica" 15.68 9.8 2 2.45 +7.7 2.8 6.7 2 "virginica" 21.56 13.4 2.75 3.35 +6.3 2.7 4.9 1.8 "virginica" 17.01 8.82 2.33333333333333 2.72222222222222 +6.7 3.3 5.7 2.1 "virginica" 22.11 11.97 2.03030303030303 2.71428571428571 +7.2 3.2 6 1.8 "virginica" 23.04 10.8 2.25 3.33333333333333 +6.2 2.8 4.8 1.8 "virginica" 17.36 8.64 2.21428571428571 2.66666666666667 +6.1 3 4.9 1.8 "virginica" 18.3 8.82 2.03333333333333 2.72222222222222 +6.4 2.8 5.6 2.1 "virginica" 17.92 11.76 2.28571428571429 2.66666666666667 +7.2 3 5.8 1.6 "virginica" 21.6 9.28 2.4 3.625 +7.4 2.8 6.1 1.9 "virginica" 20.72 11.59 2.64285714285714 3.21052631578947 +7.9 3.8 6.4 2 "virginica" 30.02 12.8 2.07894736842105 3.2 +6.4 2.8 5.6 2.2 "virginica" 17.92 12.32 2.28571428571429 2.54545454545454 +6.3 2.8 5.1 1.5 "virginica" 17.64 7.65 2.25 3.4 +6.1 2.6 5.6 1.4 "virginica" 15.86 7.84 2.34615384615385 4 +7.7 3 6.1 2.3 "virginica" 23.1 14.03 2.56666666666667 2.65217391304348 +6.3 3.4 5.6 2.4 "virginica" 21.42 13.44 1.85294117647059 2.33333333333333 +6.4 3.1 5.5 1.8 "virginica" 19.84 9.9 2.06451612903226 3.05555555555556 +6 3 4.8 1.8 "virginica" 18 8.64 2 2.66666666666667 +6.9 3.1 5.4 2.1 "virginica" 21.39 11.34 2.22580645161290 2.57142857142857 +6.7 3.1 5.6 2.4 "virginica" 20.77 13.44 2.16129032258065 2.33333333333333 +6.9 3.1 5.1 2.3 "virginica" 21.39 11.73 2.22580645161290 2.21739130434783 +5.8 2.7 5.1 1.9 "virginica" 15.66 9.69 2.14814814814815 2.68421052631579 +6.8 3.2 5.9 2.3 "virginica" 21.76 13.57 2.125 2.56521739130435 +6.7 3.3 5.7 2.5 "virginica" 22.11 14.25 2.03030303030303 2.28 +6.7 3 5.2 2.3 "virginica" 20.1 11.96 2.23333333333333 2.26086956521739 +6.3 2.5 5 1.9 "virginica" 15.75 9.5 2.52 2.63157894736842 +6.5 3 5.2 2 "virginica" 19.5 10.4 2.16666666666667 2.6 +6.2 3.4 5.4 2.3 "virginica" 21.08 12.42 1.82352941176471 2.34782608695652 +5.9 3 5.1 1.8 "virginica" 17.7 9.18 1.96666666666667 2.83333333333333 diff --git a/serie1/learning.png b/serie1/learning.png new file mode 100644 index 0000000000000000000000000000000000000000..c30bf2275dd1e28dea3f7247cb45e200def43310 Binary files /dev/null and b/serie1/learning.png differ diff --git a/serie1/line.png b/serie1/line.png new file mode 100644 index 0000000000000000000000000000000000000000..0b76558e5b9cf36e7e2f777496200ab1e5412999 Binary files /dev/null and b/serie1/line.png differ diff --git a/serie1/perceptron_learning-stud.ipynb b/serie1/perceptron_learning-stud.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..62937695557974bf8be484227065721c9f6bde8c --- /dev/null +++ b/serie1/perceptron_learning-stud.ipynb @@ -0,0 +1,596 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Perceptron Learning Rule" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Last revision: Martin Melchior - 18.09.2019\n", + "\n", + "In this exercise you implement the perceptron learning rule. Then you apply it to linearly separable data (the data can be generated on the fly) and you can convince yourself that your system is properly implemented and has found the separating line. \n", + "\n", + "Some emphasis should be given to properly handle numpy arrays. These will be much more extensively used in upcoming exercises of later weeks. So, we recommend to take a serious glance at them.\n", + "\n", + "\n", + "### Preparation of the Data\n", + "\n", + "Instead of providing a fixed input dataset, we here generate it randomly.\n", + "For easier comparison, we want to make sure that the same data is produced. Therefore, we set a random seed (set to 1 below).\n", + "\n", + "The data will be generated in form of a 2d array, the first index enumerating the dimensions (rows, in the 2d case index 0 and 1), the second enumerating the samples (columns). \n", + "\n", + "Furthermore, we provide a suitable plotting utility that allows you to inspect the generated data." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "def prepare_data(m,m1,a,s,width=0.6,eps=0.5, seed=1):\n", + " \"\"\"\n", + " Generates a random linearly separable 2D test set and associated labels (0|1).\n", + " The x-values are distributed in the interval [-0.5,0.5]. \n", + " With the parameters a,s you can control the line that separates the two classes. \n", + " This turns out to be the line with the widest corridor between the two classes (with width 'width').\n", + " If the random seed is set, the set will always look the same for given input parameters. \n", + " \n", + " Arguments:\n", + " a -- y-intercept of the seperating line\n", + " s -- slope of the separating line\n", + " m -- number of samples\n", + " m1 -- number of samples labelled with '1'\n", + " width -- width of the corridor between the two classes\n", + " eps -- measure for the variation of the samples in x2-direction\n", + " \n", + " Returns:\n", + " x -- generated 2D data of shape (2,n)\n", + " y -- labels (0 or 1) of shape (1,n)\n", + " \"\"\"\n", + " np.random.seed(seed)\n", + " idx = np.random.choice(m, m1, replace=False)\n", + " y = np.zeros(m, dtype=int).reshape(1,m)\n", + " y[0,idx] = 1\n", + " \n", + " x = np.random.rand(2,m).reshape(2,m) # random numbers uniformly distributed in [0,1]\n", + " x[0,:]-= 0.5\n", + " idx1 = y[0,:]==1\n", + " idx2 = y[0,:]==0\n", + " x[1,idx1] = (a+s*x[0,idx1]) + (width/2+eps*x[1,idx1])\n", + " x[1,idx2] = (a+s*x[0,idx2]) - (width/2+eps*x[1,idx2])\n", + " \n", + " return x,y" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "def line(a, s, n=100):\n", + " \"\"\" \n", + " Returns a line 2D array with x and y=a+s*x.\n", + " \n", + " Parameters:\n", + " a -- intercept\n", + " s -- slope\n", + " n -- number of points\n", + " \n", + " Returns:\n", + " 2d array of shape (n,2) \n", + " \"\"\"\n", + " x = np.linspace(-0.5, 0.5, n)\n", + " l = np.array([x,a+s*x]).reshape(2,n)\n", + " return l\n", + "\n", + "def plot(x, y, params_best=None, params_before=None, params_after=None, misclassified=None, selected=None):\n", + " \"\"\"\n", + " Plot the 2D data provided in form of the x-array. \n", + " Use markers depending on the label ('1 - red cross, 0 - blue cross').\n", + " Optionally, you can pass tuples with parameters for a line (a: y-intercept, s: slope) \n", + " * params_best: ideal separating line (green dashed) \n", + " * params: predicted line (magenta)\n", + " Finally, you can also mark single points:\n", + " * misclassified: array of misclassified points (blue circles)\n", + " * selected: array of selected points (green filled circles)\n", + " \n", + " Parameters:\n", + " x -- 2D input dataset of shape (2,n)\n", + " y -- ground truth labels of shape (1,n)\n", + " params_best -- parameters for the best separating line\n", + " params -- any line parameters\n", + " misclassified -- array of points to be marked as misclassified\n", + " selected -- array of points to be marked as selected\n", + " \"\"\"\n", + " idx1 = y[0,:]==1\n", + " idx2 = y[0,:]==0\n", + " plt.plot(x[0,idx1], x[1,idx1], 'r+', label=\"label 1\")\n", + " plt.plot(x[0,idx2], x[1,idx2], 'b+', label=\"label 0\") \n", + " if not params_best is None:\n", + " a = params_best[0]\n", + " s = params_best[1]\n", + " l = line(a,s)\n", + " plt.plot(l[0,:], l[1,:], 'g--')\n", + " if not params_before is None:\n", + " a = params_before[0]\n", + " s = params_before[1]\n", + " l = line(a,s)\n", + " plt.plot(l[0,:], l[1,:], 'm--')\n", + " if not params_after is None:\n", + " a = params_after[0]\n", + " s = params_after[1]\n", + " l = line(a,s)\n", + " plt.plot(l[0,:], l[1,:], 'm-')\n", + " if not misclassified is None:\n", + " plt.plot(x[0,misclassified], x[1,misclassified], 'o', label=\"misclassified\")\n", + " if not selected is None:\n", + " plt.plot(x[0,selected], x[1,selected], 'oy', label=\"selected\")\n", + " \n", + " plt.legend()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Generate and Plot a Sample" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x,y = prepare_data(200,100,0,0.5,width=0.3,eps=0.5, seed=1)\n", + "plot(x, y, params_before=(0,0.5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameters for the decision boundary\n", + "\n", + "Here, you should implement a function that translates the weights vector $(w_1,w_2)$ and the bias $b$ into parameters of a straight line ( $x_2 = a + s \\cdot x_1$ )" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "def lineparams(weight, bias):\n", + " \"\"\"\n", + " Translates the weights vector and the bias into line parameters with a x2-intercept 'a' and a slope 's'.\n", + "\n", + " Parameters:\n", + " weight -- weights vector of shape (1,2)\n", + " bias -- bias (a number)\n", + " \n", + " Returns:\n", + " a -- x2-intercept\n", + " s -- slope of the line in the (x1,x2)-plane\n", + " \"\"\"\n", + " ### START YOUR CODE ###\n", + " \n", + " a = -bias/weight[0,1]\n", + " s = -weight[0,0]/weight[0,1]\n", + " \n", + " \n", + " ### END YOUR CODE ###\n", + " return a,s" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Implement the Perceptron Learning Algorithm\n", + "\n", + "by implementing the functions\n", + "* predict\n", + "* update\n", + "* select_datapoint\n", + "* train\n", + "\n", + "Follow the descriptions of these functions." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "def predict(x,w,b):\n", + " \"\"\"\n", + " Computes the predicted value for a perceptron (single LTU).\n", + " \n", + " Parameters:\n", + " x -- input dataset of shape (2,m)\n", + " w -- weights vector of shape (1,2)\n", + " b -- bias (a number)\n", + " \n", + " Returns:\n", + " y -- prediction of a perceptron (single LTU) of shape (1,m)\n", + " \"\"\"\n", + " ### START YOUR CODE ###\n", + " \n", + " y = np.dot(w,x) + b\n", + " y = np.where(y>0,1,0)\n", + " \n", + " \n", + " ### END YOUR CODE ###\n", + " \n", + " return y\n", + "\n", + "def update(x,y,w,b,alpha=1.0):\n", + " \"\"\"\n", + " Performs an update step in accordance with the perceptron learning algorithm.\n", + " \n", + " Parameters:\n", + " x -- input data point of shape (2,1)\n", + " y -- true label ('ground truth') for the specified point\n", + " w -- weight vector of shape (1,2)\n", + " b -- bias (a number)\n", + " \n", + " Returns:\n", + " w1 -- updated weight vector\n", + " b1 -- updated bias\n", + " \"\"\"\n", + " ypred = predict(x,w,b)\n", + "\n", + " ### START YOUR CODE ###\n", + " \n", + " \n", + " # update the weights and bias\n", + " w1 = w - alpha*(ypred-y)*x.T\n", + " b1 = b - alpha*(ypred-y)\n", + " \n", + " \n", + " ### END YOUR CODE ###\n", + "\n", + " return w1, b1\n", + "\n", + "\n", + "def select_datapoint(x, y, w, b):\n", + " \"\"\"\n", + " Identifies the misclassified data points and selects one of them.\n", + " In case all datapoints are correctly classified None is returned. \n", + "\n", + " Parameters:\n", + " x -- input dataset of shape (2,m)\n", + " y -- ground truth labels of shape (1,m)\n", + " w -- weights vector of shape (1,2)\n", + " b -- bias (a number)\n", + " \n", + " Returns:\n", + " x1 -- one of the wrongly classified datapoint (of shape (2,1))\n", + " y1 -- the associated true label\n", + " misclasssified -- array with indices of wrongly classified datapoints or empty array\n", + " \"\"\"\n", + " ypred = predict(x,w,b)\n", + " wrong_mask = (ypred != y)[0]\n", + " misclassified = np.where(wrong_mask)[0]\n", + " if len(misclassified)>0:\n", + " x1 = x[:,misclassified[0]]\n", + " y1 = y[0,misclassified[0]]\n", + " return x1, y1, misclassified\n", + " return None, None, []\n", + "\n", + "def train(weight_init, bias_init, x, y, alpha=1.0, debug=False, params_best=None, max_iter=1000):\n", + " \"\"\"\n", + " Trains the perceptron (single LTU) for the given data x and ground truth labels y\n", + " by using the perceptron learning algorithm with learning rate alpha (default is 1.0).\n", + " The max number of iterations is limited to 1000.\n", + " \n", + " Optionally, debug output can be provided in form of plots with showing the effect \n", + " of the update (decision boundary before and after the update) provided at each iteration. \n", + " \n", + " Parameters:\n", + " weight_init -- weights vector of shape (1,2)\n", + " bias_init -- bias (a number)\n", + " x -- input dataset of shape (2,m)\n", + " y -- ground truth labels of shape (1,m)\n", + " alpha -- learning rate\n", + " debug -- flag for whether debug information should be provided for each iteration\n", + " params_best -- needed if debug=True for plotting the true decision boundary\n", + " \n", + " Returns:\n", + " weight -- trained weights\n", + " bias -- trained bias\n", + " misclassified_counts -- array with the number of misclassifications at each iteration\n", + " \"\"\"\n", + " weight = weight_init\n", + " bias = bias_init\n", + " iterations = 0\n", + " misclassified_counts = [] # we track them to show how the system learned in the end \n", + " \n", + " # START YOUR CODE HERE\n", + " while iterations<=max_iter:\n", + " x1, y1, misclassified = select_datapoint(x, y, weight, bias)\n", + " if x1 is None:\n", + " break\n", + " weight, bias = update(x1, y1, weight, bias, alpha)\n", + " misclassified_counts.append(len(misclassified))\n", + " iterations += 1\n", + " if debug:\n", + " params_before = lineparams(weight, bias)\n", + " params_after = lineparams(weight, bias)\n", + " plot(x,y,params_best=params_best, params_before=params_before, params_after=params_after, misclassified=misclassified, selected=np.array([misclassified[0]]))\n", + " ### END YOUR CODE ###\n", + " \n", + " return weight, bias, misclassified_counts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Auxiliary Function" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "def weights_and_bias(a,s):\n", + " \"\"\"\n", + " Computes weights vector and bias from line parameters x2-intercept and slope.\n", + " \"\"\"\n", + " w1 = - s\n", + " w2 = 1.0\n", + " weight = np.array([w1,w2]).reshape(1,2)\n", + " bias = - a\n", + " return weight, bias" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test Your Implementation\n", + "\n", + "1/ Prepare the dataset by using the prepare_data function defined above and plot it. Use the parameters specified below (a=1, s=2, n=100, n1=50).\n", + "\n", + "2/ Run the training with the default learning rate (alpha=1).\n", + "Paste the plots with the situation at the start and with the situation at the end of the training in a text document.\n", + "Paste also the start parameters (weight and bias) and trained parameters.\n", + "\n", + "3/ Create a plot with the number of mis-classifications vs iteration." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 1/ Prepare the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "weight: [[-2. 1.]] bias: -1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m = 100\n", + "m1 = 50\n", + "a = 1\n", + "s = 2\n", + "x,y = prepare_data(m,m1,a,s)\n", + "\n", + "params_best = (a,s)\n", + "weight_best, bias_best = weights_and_bias(a, s)\n", + "print(\"weight: \", weight_best, \" bias: \", bias_best)\n", + "plot(x,y,params_best=params_best)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2/ Run the training" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial Params: [[0. 1.]] 0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iterations: 28\n", + "Trained Params: [[-4.99046876 2.92867787]] [-3.]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "a1 = 0\n", + "s1 = 0\n", + "alpha = 1.0\n", + "\n", + "weight1, bias1 = weights_and_bias(a1,s1)\n", + "print(\"Initial Params: \",weight1,bias1)\n", + "params = lineparams(weight1, bias1)\n", + "plot(x,y,params_best, params)\n", + "\n", + "weight1,bias1,misclassified_counts = train(weight1, bias1, x, y)\n", + "#weight1,bias1,misclassified_counts = train(weight1, bias1, x, y, debug=True, params_best=params_best)\n", + "params = lineparams(weight1, bias1)\n", + "print(\"Iterations: \", len(misclassified_counts)-1)\n", + "print(\"Trained Params: \", weight1,bias1)\n", + "plot(x,y, params_best=params_best, params_after=params)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3/ Create the plot with the misclassifications per iteration" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[<matplotlib.lines.Line2D at 0x7f79f50a4910>]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nit = len(misclassified_counts)\n", + "it = np.linspace(0,nit,nit)\n", + "\n", + "plt.plot(it, misclassified_counts)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summarise your findings\n", + "\n", + "So we have seen that the perceptron learning rule is able to find a separating line for linearly separable data. We also saw that in 28 iterations the algorithm was able to find almost the correct separating line. We can see from the misclassifications plot that the number of misclassifications decreases with each iteration. But sometimes the number of misclassifications increases. This is because when we update the weights and bias, we are not always updating in the right direction. We are updating in the direction of the misclassified point. But sometimes the misclassified point is not the closest point to the decision boundary. " + ] + } + ], + "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.10.6" + }, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/serie1/rapport.md b/serie1/rapport.md new file mode 100644 index 0000000000000000000000000000000000000000..d2e9370d38c6a00b61b7f1b794cb04f1c605d53f --- /dev/null +++ b/serie1/rapport.md @@ -0,0 +1,18 @@ +# Perceptron learning rule +simon.cirilli@hes-so.ch - kiady.arintsoa@hes-so.ch +## lineparams +This function is usefull to translate the weights and bias into a line equation. It returns the slope and the intercept of the line. +## predict +This function is used to predict the class of a point. It returns 1 if the point is above the line and 0 if the point is below the line. +## Update weights and bias +This function is used to update the weights and bias. It returns the new weights and bias and this is from the perceptron learning rule. +## Train code +The train code is used to train the perceptron. The stop criterion is the number of iterations. The function returns the weights and bias and the number of misclassifications per iteration. +## Test +We see that we have a pretty good line separating the two classes. + +## plot with the misclassifications per iteration + + +# To summarize +So we have seen that the perceptron learning rule is able to find a separating line for linearly separable data. We also saw that in 28 iterations the algorithm was able to find almost the correct separating line. We can see from the misclassifications plot that the number of misclassifications decreases with each iteration. But sometimes the number of misclassifications increases. This is because when we update the weights and bias, we are not always updating in the perfect right direction. \ No newline at end of file diff --git a/serie1/rapport.pdf b/serie1/rapport.pdf new file mode 100644 index 0000000000000000000000000000000000000000..be3aee19b916fe5968935002e8df180a8d72a6b4 Binary files /dev/null and b/serie1/rapport.pdf differ diff --git a/serie2/MNIST_binary_classifier_stud.ipynb b/serie2/MNIST_binary_classifier_stud.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..662e2b9580e5913e6ec52b72aa9728106449c055 --- /dev/null +++ b/serie2/MNIST_binary_classifier_stud.ipynb @@ -0,0 +1,974 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "physical-johnson", + "metadata": {}, + "source": [ + "## MNIST Data\n", + "\n", + "Binary classification based on MNIST data. \n", + "\n", + "It restricts the classification problem to two digits, selects them from the MNIST dataset, splits it up into a train and test part and then trains a binary classification (logistic regression) to learn to differentiate between the two digits.\n", + "\n", + "The MNIST dataset consists of images with 28x28 = 784 pixel each. The features refer to these pixel values of the MNIST images." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "educational-syndrome", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/cirillisimon/scikit_learn_data\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from sklearn import datasets as ds \n", + "\n", + "#get local download folder where data is stored\n", + "#you may change this in the call fetch_openml() below\n", + "data_h = ds.get_data_home()\n", + "print(data_h)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "allied-flavor", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "<class 'sklearn.utils._bunch.Bunch'>\n", + "dict_keys(['data', 'target', 'frame', 'categories', 'feature_names', 'target_names', 'DESCR', 'details', 'url'])\n", + "x shape: (70000, 784)\n", + "y shape: (70000,)\n" + ] + } + ], + "source": [ + "#the first time this will download the data from the internet and put to a local folder \n", + "\n", + "mnist = ds.fetch_openml(name='mnist_784', data_home = data_h)\n", + "\n", + "#digit is a \"bunch\" i.e. similar to a dictionary\n", + "print(type(mnist))\n", + "#show the keys of digit\n", + "print(mnist.keys())\n", + "#get data i.e. the image (x) and labels (y)\n", + "x = np.array(mnist['data'], dtype='int')\n", + "#as compare to the in class activity we convert the labels here to int\n", + "y = np.array(mnist['target'], dtype='int')\n", + "#get the respective shape\n", + "print(\"x shape:\", x.shape)\n", + "print(\"y shape:\", y.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "effective-anaheim", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_img(img):\n", + " fig, ax = plt.subplots()\n", + " ax.imshow(img, cmap=plt.cm.gray)\n", + " ax.set_axis_off()\n", + " \n", + " \n", + "img = x[0,:].reshape((28,28))\n", + "plot_img(img)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "stock-simpson", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_tiles(x_array, rows, cols = -1, fig_size = [10,10]):\n", + " \"\"\"\n", + " plot list of mnist images as single image\n", + "\n", + " Arguments:\n", + " x_array -- array of mnist images (being organised as ROWS!)\n", + " rows/cols -- an image of rows x cols - mnist images is created (if x_array is smaller zeros ared padded)\n", + " fig_size -- size of full image created (default [10,10])\n", + " \"\"\"\n", + " #fix value for minist (change to 8 for mninst light)\n", + " digit_size = 28\n", + " #use rows = cols as default\n", + " if cols < 0:\n", + " cols = rows\n", + " \n", + " if x_array.shape[0] < rows*cols:\n", + " cols = int(x_array.shape[0]/rows)\n", + " remain = np.mod(x_array.shape[0], rows)\n", + " if 0 < remain:\n", + " cols += 1\n", + " x_array = np.append(x_array, np.zeros((rows-remain, x_array.shape[1])), 0) \n", + " \n", + " img = x_array[0:rows,:].reshape(rows*digit_size,digit_size)\n", + " for i0 in range(1,cols):\n", + " #the reshape operator in the append call takes num of digit_size x digit_size images and \n", + " #puts them in a single column; append then does the rest\n", + " img = np.append(img, x_array[i0*rows:(i0+1)*rows,:].reshape(rows*digit_size,digit_size),1)\n", + "\n", + " fig = plt.figure(figsize = fig_size)\n", + " ax = fig.subplots()\n", + " ax.imshow(img, cmap=plt.cm.gray)\n", + " ax.set_axis_off()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "returning-relative", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 400x400 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#append rows x cols tiles of digits\n", + "rows = 8\n", + "cols = 8\n", + "#figure size can be set\n", + "fig_size = [4,4]\n", + "\n", + "plot_tiles(x, rows, cols, fig_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "qualified-charm", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 400x400 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#choose a given digit 0..9\n", + "digit = 1\n", + "\n", + "plot_tiles(x[y == digit,:], rows, cols, fig_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "signed-kansas", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(12136, 784) (3034, 784) (12136, 1) (3034, 1)\n" + ] + } + ], + "source": [ + "#select the two digits for your training and test set\n", + "digit_1 = 1\n", + "digit_2 = 7\n", + "\n", + "x_sel_1 = x[y == digit_1,:]\n", + "x_sel_2 = x[y == digit_2,:]\n", + "\n", + "x_sel = np.append(x_sel_1, x_sel_2, 0)\n", + "y_sel = np.append(np.zeros((x_sel_1.shape[0],1)),\n", + " np.ones((x_sel_2.shape[0],1)), 0)\n", + "\n", + "from sklearn import model_selection as ms\n", + "\n", + "#define train and test split\n", + "x_train, x_test, y_train, y_test = ms.train_test_split(x_sel, y_sel, \n", + " test_size=0.20, random_state=1)\n", + "\n", + "print(x_train.shape, x_test.shape, y_train.shape, y_test.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "global-boutique", + "metadata": {}, + "source": [ + "### Class GradientDescent\n", + "\n", + "This class summarises the gradient descent steps. The training and test data is given as dictionary (c.f. cell directly below the class definition for an example). The class can be called, however only a dummy implementation is given (weigths w and bias b are always 0). Replace the dummy parts with your own implementation and test it.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "removed-commons", + "metadata": {}, + "outputs": [], + "source": [ + "class GradientDescent: \n", + " \"\"\"\n", + " obtains train and test data in the constructor and does the gradient descend\n", + " \"\"\" \n", + " cost_MSE = 0\n", + " cost_CE = 1\n", + " \n", + " def __init__(self, data, alpha = 0.5, cost_function=cost_MSE, random_std = 0):\n", + " \"\"\"\n", + " constructor\n", + " \n", + " Arguments:\n", + " data -- dictionary with data\n", + " cost_function -- can be cost_MSE (0, default) or cost_CE (1)\n", + " random_std -- std for initialisation of weight (default is 0)\n", + " \"\"\"\n", + " #keep local copy of data\n", + " self.data = data\n", + " self.alpha = alpha\n", + " self.cost_function = cost_function\n", + " \n", + " #normalize data\n", + " self.normalise_data()\n", + " \n", + " #initialize weights and bias (zero or random)\n", + " self.initialise_weights(random_std)\n", + " \n", + " #result array\n", + " self.result_data = np.array([])\n", + " \n", + " \n", + " def normalise_data(self):\n", + " \"\"\"\n", + " normalize the input data\n", + " \"\"\" \n", + " ### START YOUR CODE ###\n", + " me = np.mean(x_train)\n", + " \n", + " # standard deviation sk\n", + " std = np.std(x_train)\n", + "\n", + " #separate normalisation of train and test data\n", + " self.data['x_train'] = (self.data['x_train'] - me) / std\n", + " self.data['x_test'] = (self.data['x_test'] - me) / std\n", + " \n", + " ### END YOUR CODE ###\n", + " \n", + " \n", + " def initialise_weights(self, random_std):\n", + " \"\"\"\n", + " initialise weights\n", + " \"\"\" \n", + " #initialize weights and bias (if random_std == 0 all weights are zero)\n", + " self.w = random_std*np.random.randn(self.data['x_train'].shape[1],1)\n", + " self.b = 0\n", + " \n", + " \n", + " def calc_error(self, y_pred, y):\n", + " \"\"\"\n", + " get error information\n", + " \"\"\"\n", + " m = y.shape[0]\n", + " \n", + " res = np.round(y_pred) \n", + " train_error = np.sum(np.abs(res - y)) / m \n", + " \n", + " return train_error\n", + " \n", + " \n", + " def append_result(self, epochs):\n", + " \"\"\"\n", + " append cost and error data to output array\n", + " \"\"\" \n", + " #first call\n", + " res_data = np.array([[epochs, self.cost[0], self.calc_error(self.y_pred[0], self.data['y_train']),\n", + " self.cost[1], self.calc_error(self.y_pred[1], self.data['y_test'])]])\n", + " if self.result_data.size == 0:\n", + " self.result_data = res_data\n", + " else:\n", + " self.result_data = np.append(self.result_data, res_data, 0)\n", + " \n", + " return res_data\n", + " \n", + "\n", + " def cost_funct(self, y_pred, y):\n", + " \"\"\"\n", + " calculates the chosen cost function for given values of w and b\n", + " \"\"\"\n", + " m = y.shape[0]\n", + " \n", + " if self.cost_function == self.cost_MSE:\n", + " \n", + " ### START YOUR CODE ###\n", + " # MSE code\n", + " cost = 1 / (2 * m) * np.sum((y_pred - y)**2)\n", + " else:\n", + " cost = 0.123 \n", + " \n", + " ### END YOUR CODE ### \n", + " \n", + " return cost \n", + " \n", + " \n", + " def grad_cost(self):\n", + " \"\"\"\n", + " calculates the gradients of cost function wrt w and b\n", + " \"\"\"\n", + " #abbreviation\n", + " y_pred = self.y_pred[0]\n", + " x = self.data['x_train']\n", + " y = self.data['y_train']\n", + " m = x.shape[0]\n", + " \n", + " if self.cost_function == self.cost_MSE:\n", + " \n", + " ### START YOUR CODE ###\n", + " \n", + " # fonctionne pas\n", + " grad_w = 1 / m * np.dot(x.T, (y_pred - y))\n", + " grad_b = 1 / m * np.sum(y_pred - y)\n", + "\n", + " else: \n", + " grad_w = np.zeros((784,1))\n", + " grad_b = 0\n", + " \n", + " ### END YOUR CODE ### \n", + " \n", + " return grad_w.T, grad_b\n", + " \n", + " \n", + " def predict(self, x):\n", + " \"\"\"\n", + " implementation of sigmoid function\n", + " \"\"\" \n", + " \n", + " ### START YOUR CODE ###\n", + " \n", + " return 1 / (1 + np.exp(-np.dot(x, self.w) - self.b))\n", + " \n", + " ### END YOUR CODE ### \n", + " \n", + " \n", + " def update(self):\n", + " \"\"\"\n", + " performs one gradient descend step\n", + " \"\"\"\n", + " #predicted outcome for train [0] and test data [1]\n", + " self.y_pred = [self.predict(self.data['x_train']), self.predict(self.data['x_test'])]\n", + " \n", + " grad_w, grad_b = self.grad_cost()\n", + " \n", + " ### START YOUR CODE ###\n", + " \n", + " self.w = self.w - self.alpha * grad_w\n", + " self.b = self.b - self.alpha * grad_b\n", + " \n", + " ### END YOUR CODE ### \n", + " \n", + " #determine cost functions for train [0] and test data [1]\n", + " self.cost = [self.cost_funct(self.y_pred[0], self.data['y_train']), \n", + " self.cost_funct(self.y_pred[1], self.data['y_test'])]\n", + " \n", + " \n", + " def optimise(self, epochs, debug = False):\n", + " \"\"\"\n", + " performs epochs number of gradient descend steps and appends result to output array\n", + " \n", + " Arguments:\n", + " debug -- False (default)/True; get info on each gradient descend step\n", + " \"\"\"\n", + " for i0 in range(0,epochs):\n", + " self.update()\n", + " res_data = self.append_result(i0)\n", + " if debug and np.mod(i0,1) == 0:\n", + " print('step %r, cost %r, error %r' %(i0, res_data[0,1], res_data[0,2]))\n", + " \n", + " print('result after %d epochs, train: cost %.5f, error %.5f ; test: cost %.5f, error %.5f' \n", + " %(epochs, res_data[0,1], res_data[0,2], res_data[0,3], res_data[0,4]))\n", + " \n", + " \n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "reserved-satin", + "metadata": {}, + "source": [ + "### Sample execution of gradient descent\n", + "\n", + "The cell below shows how to use the class GradientDescent to perform the optimisation. The training and test data is given as dictionary in the constructor of the class. Then the method optimise is called with first argument being the number of epochs.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "colored-facility", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "shapes (784,) and (1,) not aligned: 784 (dim 0) != 1 (dim 0)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [98], line 6\u001b[0m\n\u001b[1;32m 2\u001b[0m data \u001b[39m=\u001b[39m {\u001b[39m'\u001b[39m\u001b[39mx_train\u001b[39m\u001b[39m'\u001b[39m : x_train, \u001b[39m'\u001b[39m\u001b[39my_train\u001b[39m\u001b[39m'\u001b[39m : y_train, \u001b[39m'\u001b[39m\u001b[39mx_test\u001b[39m\u001b[39m'\u001b[39m : x_test, \u001b[39m'\u001b[39m\u001b[39my_test\u001b[39m\u001b[39m'\u001b[39m : y_test}\n\u001b[1;32m 4\u001b[0m gradD \u001b[39m=\u001b[39m GradientDescent(data, \u001b[39m0.5\u001b[39m, \u001b[39m0\u001b[39m, \u001b[39m0.\u001b[39m)\n\u001b[0;32m----> 6\u001b[0m gradD\u001b[39m.\u001b[39moptimise(\u001b[39m5\u001b[39m, \u001b[39mFalse\u001b[39;00m)\n", + "Cell \u001b[0;32mIn [97], line 180\u001b[0m, in \u001b[0;36mGradientDescent.optimise\u001b[0;34m(self, epochs, debug)\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 174\u001b[0m \u001b[39mperforms epochs number of gradient descend steps and appends result to output array\u001b[39;00m\n\u001b[1;32m 175\u001b[0m \u001b[39m\u001b[39;00m\n\u001b[1;32m 176\u001b[0m \u001b[39mArguments:\u001b[39;00m\n\u001b[1;32m 177\u001b[0m \u001b[39mdebug -- False (default)/True; get info on each gradient descend step\u001b[39;00m\n\u001b[1;32m 178\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 179\u001b[0m \u001b[39mfor\u001b[39;00m i0 \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39m0\u001b[39m,epochs):\n\u001b[0;32m--> 180\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mupdate()\n\u001b[1;32m 181\u001b[0m res_data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mappend_result(i0)\n\u001b[1;32m 182\u001b[0m \u001b[39mif\u001b[39;00m debug \u001b[39mand\u001b[39;00m np\u001b[39m.\u001b[39mmod(i0,\u001b[39m1\u001b[39m) \u001b[39m==\u001b[39m \u001b[39m0\u001b[39m:\n", + "Cell \u001b[0;32mIn [97], line 158\u001b[0m, in \u001b[0;36mGradientDescent.update\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 155\u001b[0m \u001b[39m#predicted outcome for train [0] and test data [1]\u001b[39;00m\n\u001b[1;32m 156\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39my_pred \u001b[39m=\u001b[39m [\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mpredict(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdata[\u001b[39m'\u001b[39m\u001b[39mx_train\u001b[39m\u001b[39m'\u001b[39m]), \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mpredict(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdata[\u001b[39m'\u001b[39m\u001b[39mx_test\u001b[39m\u001b[39m'\u001b[39m])]\n\u001b[0;32m--> 158\u001b[0m grad_w, grad_b \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mgrad_cost()\n\u001b[1;32m 160\u001b[0m \u001b[39m### START YOUR CODE ###\u001b[39;00m\n\u001b[1;32m 162\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mw \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mw \u001b[39m-\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39malpha \u001b[39m*\u001b[39m grad_w\n", + "Cell \u001b[0;32mIn [97], line 124\u001b[0m, in \u001b[0;36mGradientDescent.grad_cost\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 121\u001b[0m y_pred \u001b[39m=\u001b[39m y_pred[i]\n\u001b[1;32m 123\u001b[0m grad_b \u001b[39m=\u001b[39m \u001b[39m1\u001b[39m \u001b[39m/\u001b[39m m \u001b[39m*\u001b[39m np\u001b[39m.\u001b[39msum(y_pred \u001b[39m-\u001b[39m y)\n\u001b[0;32m--> 124\u001b[0m grad_w \u001b[39m=\u001b[39m \u001b[39m1\u001b[39m \u001b[39m/\u001b[39m m \u001b[39m*\u001b[39m np\u001b[39m.\u001b[39;49mdot(x, (y_pred \u001b[39m-\u001b[39;49m y))\n\u001b[1;32m 126\u001b[0m \u001b[39m# compute gradient of cost function wrt w and b with x[i].T\u001b[39;00m\n\u001b[1;32m 127\u001b[0m \u001b[39m# grad_w = 1 / m * np.dot(x.T, (y_pred - y))\u001b[39;00m\n\u001b[1;32m 128\u001b[0m \u001b[39m# grad_b = 1 / m * np.sum(y_pred - y)\u001b[39;00m\n\u001b[1;32m 129\u001b[0m \n\u001b[1;32m 130\u001b[0m \u001b[39melse\u001b[39;00m: \n\u001b[1;32m 131\u001b[0m grad_w \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mzeros((\u001b[39m784\u001b[39m,\u001b[39m1\u001b[39m))\n", + "File \u001b[0;32m<__array_function__ internals>:180\u001b[0m, in \u001b[0;36mdot\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: shapes (784,) and (1,) not aligned: 784 (dim 0) != 1 (dim 0)" + ] + } + ], + "source": [ + "#data is arranged as dictionary with quick access through respective keys\n", + "data = {'x_train' : x_train, 'y_train' : y_train, 'x_test' : x_test, 'y_test' : y_test}\n", + "\n", + "gradD = GradientDescent(data, 0.5, 0, 0.)\n", + "\n", + "gradD.optimise(5, False)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(12136, 784)\n", + "(12136, 784)\n", + "(12136, 784)\n", + "(12136, 784)\n", + "(12136, 784)\n", + "(12136, 784)\n", + "(12136, 784)\n", + "(12136, 784)\n", + "(12136, 784)\n", + "(12136, 784)\n", + "result after 10 epochs, train: cost 187.34344, error 374.68688 ; test: cost 192.89914, error 385.79829\n" + ] + } + ], + "source": [ + "gradD.optimise(10, False)" + ] + }, + { + "cell_type": "markdown", + "id": "private-fisher", + "metadata": {}, + "source": [ + "### Result analysis\n", + "\n", + "The cells below show, how to access the different class members of GradientDescent in order to analyse the result. The sample graphs are obtained with 500 epochs, MSE cost and zero initialisation of weights." + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "lonely-quantity", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#analyse cost as function of epochs\n", + "epochs = gradD.result_data[:,0]\n", + "train_costs = gradD.result_data[:,1]\n", + "test_costs = gradD.result_data[:,3]\n", + "\n", + "plt.semilogy(epochs, train_costs, label=\"train\")\n", + "plt.semilogy(epochs, test_costs, label=\"test\")\n", + "plt.ylabel('Cost')\n", + "plt.xlabel('Epochs')\n", + "xmax = epochs[-1]\n", + "ymin = 2e-3\n", + "ymax = 1e-1\n", + "plt.axis([0,xmax,ymin,ymax])\n", + "plt.legend()\n", + "plt.show() " + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "neither-moldova", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0. 1. 2. 3. 4. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 0. 1. 2. 3. 4. 5. 6. 7. 8.\n", + " 9.]\n", + "[0.47791694 0.22577456 0.22577456 0.22577456 0.77430784 0.22577456\n", + " 0.22577456 0.22577456 0.22577456 0.22577456 0.22585695 0.22577456\n", + " 0.77430784 0.22577456 0.22577456 0.22577456 0.22577456 0.22585695\n", + " 0.22577456 0.77439024 0.22577456 0.22577456 0.22577456 0.22585695\n", + " 0.22585695]\n", + "[0.49208965 0.22808174 0.22808174 0.22808174 0.77191826 0.22808174\n", + " 0.22808174 0.22808174 0.22808174 0.22808174 0.22808174 0.22841134\n", + " 0.77191826 0.22808174 0.22808174 0.22808174 0.22808174 0.22808174\n", + " 0.22841134 0.77158866 0.22808174 0.22808174 0.22808174 0.22808174\n", + " 0.22808174]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#analyse error as function of epochs\n", + "epochs = gradD.result_data[:,0]\n", + "print(epochs)\n", + "\n", + "train_error = gradD.result_data[:,2]\n", + "print(train_error)\n", + "\n", + "test_error = gradD.result_data[:,4]\n", + "print(test_error)\n", + "\n", + "plt.semilogy(epochs, train_error, label=\"train\")\n", + "plt.semilogy(epochs, test_error, label=\"test\")\n", + "plt.ylabel('Error')\n", + "plt.xlabel('Epochs')\n", + "xmax = epochs[-1]\n", + "ymin = 3e-3\n", + "ymax = 1e-1\n", + "plt.axis([0,xmax,ymin,ymax])\n", + "plt.legend()\n", + "plt.show() " + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "delayed-desire", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(692, 784)\n" + ] + }, + { + "ename": "ValueError", + "evalue": "negative dimensions are not allowed", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [70], line 23\u001b[0m\n\u001b[1;32m 20\u001b[0m correct_labels[correct_labels_bin \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m] \u001b[39m=\u001b[39m digit_2\n\u001b[1;32m 22\u001b[0m \u001b[39mif\u001b[39;00m correct_labels\u001b[39m.\u001b[39mshape[\u001b[39m1\u001b[39m] \u001b[39m!=\u001b[39m rows\u001b[39m*\u001b[39mcols:\n\u001b[0;32m---> 23\u001b[0m correct_labels \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mappend(correct_labels, \u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39mones((\u001b[39m1\u001b[39m,rows\u001b[39m*\u001b[39mcols\u001b[39m-\u001b[39mcorrect_labels\u001b[39m.\u001b[39mshape[\u001b[39m1\u001b[39m])),\u001b[39m1\u001b[39m)\n\u001b[1;32m 25\u001b[0m correct_labels \u001b[39m=\u001b[39m correct_labels\u001b[39m.\u001b[39mreshape(cols,rows)\u001b[39m.\u001b[39mT\n\u001b[1;32m 27\u001b[0m \u001b[39mprint\u001b[39m(np\u001b[39m.\u001b[39marray(correct_labels, dtype \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m))\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/numpy/core/numeric.py:204\u001b[0m, in \u001b[0;36mones\u001b[0;34m(shape, dtype, order, like)\u001b[0m\n\u001b[1;32m 201\u001b[0m \u001b[39mif\u001b[39;00m like \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 202\u001b[0m \u001b[39mreturn\u001b[39;00m _ones_with_like(shape, dtype\u001b[39m=\u001b[39mdtype, order\u001b[39m=\u001b[39morder, like\u001b[39m=\u001b[39mlike)\n\u001b[0;32m--> 204\u001b[0m a \u001b[39m=\u001b[39m empty(shape, dtype, order)\n\u001b[1;32m 205\u001b[0m multiarray\u001b[39m.\u001b[39mcopyto(a, \u001b[39m1\u001b[39m, casting\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39munsafe\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 206\u001b[0m \u001b[39mreturn\u001b[39;00m a\n", + "\u001b[0;31mValueError\u001b[0m: negative dimensions are not allowed" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x800 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#analyse false classified training or test images\n", + "#false_classifications = x_train[(np.round(gradD.y_pred[0]) != y_train)[:,0],:]\n", + "false_classifications = x_test[(np.round(gradD.y_pred[1]) != y_test)[:,0],:]\n", + "\n", + "print(false_classifications.shape)\n", + "\n", + "#append rows x cols tiles of digits\n", + "rows = 4\n", + "cols = 7\n", + "#figure size can be set\n", + "fig_size = [8,8]\n", + "\n", + "plot_tiles(false_classifications, rows, cols, fig_size)\n", + "\n", + "\n", + "#print the correct labels \n", + "correct_labels_bin = y_test[(np.round(gradD.y_pred[1]) != y_test)[:,0]].T\n", + "correct_labels = correct_labels_bin.copy()\n", + "correct_labels[correct_labels_bin == 0] = digit_1\n", + "correct_labels[correct_labels_bin == 1] = digit_2\n", + "\n", + "if correct_labels.shape[1] != rows*cols:\n", + " correct_labels = np.append(correct_labels, -np.ones((1,rows*cols-correct_labels.shape[1])),1)\n", + " \n", + "correct_labels = correct_labels.reshape(cols,rows).T\n", + "\n", + "print(np.array(correct_labels, dtype = int))" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "endless-addition", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#analyse histogram of weights\n", + "fig = plt.hist(gradD.w, bins = 'auto')" + ] + }, + { + "cell_type": "markdown", + "id": "enormous-region", + "metadata": {}, + "source": [ + "# Unit Tests\n", + "### Unit Test for GradientDescent predict ¶" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "another-setting", + "metadata": {}, + "outputs": [], + "source": [ + "#prepare some dummy data for class GradientDescent\n", + "dummy = np.ones((3,3))\n", + "data = {'x_train' : dummy, 'y_train' : dummy, 'x_test' : dummy, 'y_test' : dummy}\n", + "\n", + "#instantiate class GradientDescent\n", + "gradDummy = GradientDescent(data, 0.5, 0, 0.)\n", + "\n", + "#prepare data for function\n", + "x = np.array([0.2,0.1,0.3,0.2,0.5,0.9,0.4,0.5,0.1,0.3,0.9,0.8]).reshape(4,3)\n", + "gradDummy.w = np.array([0.2,0.1,0.3]).reshape(3,1)\n", + "\n", + "#execute cost_funct\n", + "x_pred = gradDummy.predict(x)\n", + "\n", + "#compare with expected result\n", + "x_exp = np.array([[0.53494295],\n", + " [0.58904043],\n", + " [0.53991488],\n", + " [0.5962827 ]])\n", + "\n", + "np.testing.assert_array_almost_equal(x_pred,x_exp,decimal=8)" + ] + }, + { + "cell_type": "markdown", + "id": "solved-smith", + "metadata": {}, + "source": [ + "### Unit Test for GradientDescent grad_cost (MSE cost)¶\n", + "Assumes that Unit Test for predict is correct¶" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "decreased-candidate", + "metadata": {}, + "outputs": [], + "source": [ + "#prepare data for class GradientDescent (is used in grad_cost)\n", + "x_dummy = np.array([0.2,0.7,0.3,0.2,0.4,0.5,0.1,0.5,0.9,0.4,0.5,0.1,0.3,0.9,0.8]).reshape(5,3)\n", + "y_dummy = np.array([[1, 1, 0, 1, 0]]).reshape(5,1)\n", + "data = {'x_train' : x_dummy, 'y_train' : y_dummy, 'x_test' : x_dummy, 'y_test' : y_dummy}\n", + "\n", + "#instantiate class GradientDescent with MSE cost\n", + "gradDummy = GradientDescent(data, 0.5, 0, 0.)\n", + "\n", + "#apply predict \n", + "x_pred = gradDummy.predict(x_dummy)\n", + "gradDummy.y_pred = [x_pred,x_pred]\n", + "\n", + "grad_w_pred, grad_b_pred = gradDummy.grad_cost()\n", + "\n", + "grad_w_exp = np.array([[-0.01111111],\n", + " [-0.00555556],\n", + " [ 0.02222222]])\n", + "\n", + "grad_b_exp = np.array([-0.025])\n", + "\n", + "np.testing.assert_array_almost_equal(grad_w_pred,grad_w_exp,decimal=8)\n", + "np.testing.assert_array_almost_equal(grad_b_pred,grad_b_exp,decimal=8)" + ] + }, + { + "cell_type": "markdown", + "id": "photographic-winner", + "metadata": {}, + "source": [ + "### Unit Test for GradientDescent grad_cost (CE cost)¶\n", + "Assumes that Unit Test for predict is correct¶" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "hungry-electron", + "metadata": {}, + "outputs": [], + "source": [ + "#prepare data for class GradientDescent (is used in grad_cost)\n", + "x_dummy = np.array([0.2,0.7,0.3,0.2,0.4,0.5,0.1,0.5,0.9,0.4,0.5,0.1,0.3,0.9,0.8]).reshape(5,3)\n", + "y_dummy = np.array([[1, 1, 0, 1, 0]]).reshape(5,1)\n", + "data = {'x_train' : x_dummy, 'y_train' : y_dummy, 'x_test' : x_dummy, 'y_test' : y_dummy}\n", + "\n", + "#instantiate class GradientDescent with CE cost\n", + "gradDummy = GradientDescent(data, 0.5, 1, 0.)\n", + "\n", + "#apply predict \n", + "x_pred = gradDummy.predict(x_dummy)\n", + "gradDummy.y_pred = [x_pred,x_pred]\n", + "\n", + "grad_w_pred, grad_b_pred = gradDummy.grad_cost()\n", + "\n", + "grad_w_exp = np.array([[-0.04444444],\n", + " [-0.02222222],\n", + " [ 0.08888889]])\n", + "\n", + "grad_b_exp = np.array([-0.1])\n", + "\n", + "np.testing.assert_array_almost_equal(grad_w_pred,grad_w_exp,decimal=8)\n", + "np.testing.assert_array_almost_equal(grad_b_pred,grad_b_exp,decimal=8)" + ] + }, + { + "cell_type": "markdown", + "id": "polish-oxygen", + "metadata": {}, + "source": [ + "### Unit Test for GradientDescent cost_funct (MSE cost)¶" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "identical-worthy", + "metadata": {}, + "outputs": [], + "source": [ + "#prepare some dummy data for class GradientDescent\n", + "dummy = np.ones((3,3))\n", + "data = {'x_train' : dummy, 'y_train' : dummy, 'x_test' : dummy, 'y_test' : dummy}\n", + "\n", + "#instantiate class GradientDescent with MSE cost\n", + "gradD = GradientDescent(data, 0.5, 0, 0.)\n", + "\n", + "#prepare data for function\n", + "y_pred = np.array([0.2,0.1,0.3,0.2,0.5,0.9,0.4,0.5,0.1,0.3]).reshape(10,1)\n", + "y = np.array([[0, 0, 0, 0, 1, 0, 1, 0, 0, 1]]).reshape(10,1)\n", + "\n", + "#execute cost_funct\n", + "c_pred = gradD.cost_funct(y_pred, y)\n", + "\n", + "#compare with expected result\n", + "c_exp = 0.1175\n", + "\n", + "np.testing.assert_array_almost_equal(c_pred,c_exp,decimal=8)" + ] + }, + { + "cell_type": "markdown", + "id": "covered-pharmaceutical", + "metadata": {}, + "source": [ + "### Unit Test for GradientDescent cost_funct (CE cost)¶" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "chemical-nothing", + "metadata": {}, + "outputs": [], + "source": [ + "#prepare some dummy data for class GradientDescent\n", + "dummy = np.ones((3,3))\n", + "data = {'x_train' : dummy, 'y_train' : dummy, 'x_test' : dummy, 'y_test' : dummy}\n", + "\n", + "#instantiate class GradientDescent with CE cost\n", + "gradD = GradientDescent(data, 0.5, 1, 0.)\n", + "\n", + "#prepare data for function\n", + "y_pred = np.array([0.2,0.1,0.3,0.2,0.5,0.9,0.4,0.5,0.1,0.3]).reshape(10,1)\n", + "y = np.array([[0, 0, 0, 0, 1, 0, 1, 0, 0, 1]]).reshape(10,1)\n", + "\n", + "#execute cost_funct\n", + "c_pred = gradD.cost_funct(y_pred, y)\n", + "\n", + "#compare with expected result\n", + "c_exp = 0.6822826\n", + "\n", + "np.testing.assert_array_almost_equal(c_pred,c_exp,decimal=8)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "d715c9f2", + "metadata": {}, + "source": [ + "## PLOT FOR THE EX.2" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "90f77759", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def sigmo(z):\n", + " return 1/(1+np.exp(-z))\n", + "\n", + "def derivat_sigmo(z):\n", + " return np.exp(-z)/((1+np.exp(-z))**2)\n", + "\n", + " # plot sigmoid function\n", + "x = np.linspace(-10,10,100)\n", + "y = sigmo(x)\n", + "plt.plot(x,y)\n", + "plt.grid()\n", + "plt.show()\n", + "\n", + "\n", + "# plot derivative of sigmoid function\n", + "x = np.linspace(-10,10,100)\n", + "y = derivat_sigmo(x)\n", + "plt.plot(x,y)\n", + "plt.grid()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5e873ea8", + "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.10.6" + }, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/serie2/rapport.md b/serie2/rapport.md new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391