-
-You will notice there will be a directory structure on the left-hand side of your window. On the right-hand side, we have a "launcher" interface where we can create a Jupyter Notebook (boxed in red), or several other types of files. To start a new notebook, click on the "Python 3" logo beneath "Notebook". You can also open an existing notebook from the directory.
-
-Once you open a notebook, you will be brought to the following screen.
-
-
-
-
-Some of the most important components of the notebook are highlighted in colored boxes.
-- To rename your notebook (shown here as Untitled), you can right-click your document and select Rename.
-- In purple is the cell formatting assignment. By default, it is set to "Code", but it can also be set to "Markdown".
-- In red is a code cell, in which you can write Python code.
-- In blue is a markdown cell, which is used to display nicely formatted text, images and mathematical equations.
-
-
-
-#### Markdown cells
-Here are some useful resources for Markdown cells:
-- https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet
-- https://www.datacamp.com/community/tutorials/markdown-in-jupyter-notebook
-
-#### Code cells
-
-Code cells support Python code (and other languages with different kernels, although we will only use Python in this course). They can be executed in any order.
-
-- To run a single cell, use **Shift + Enter** or press on the ▶ button.
-- To run all the cells starting from the beginning, go to `Run` -> `Run All Cells...`.
-
-
-
-
-**Warning:** Code cells can be executed in any order. This means that you can overwrite your current variables by running cells out of order. This also means that variables declared in cells that were executed then deleted will still be present (known as a hidden state) unless the kernel is restarted. Therefore, **when coding in notebooks, be cautious of the order in which you run cells.** One solution to avoid hidden states is to frequently restart your kernel (and run up to your currently selected cell).
-
-#### Autocompletion and documentation
-Autocompletion is possible with JupyterLab too! Use **Tab**.
-
-
-
-To view the documentation for a function or class, use **Shift + Tab**.
-
-#### Keyboard shortcuts
-
-You can gain a lot of time using [keyboard shortcuts](https://cheatography.com/weidadeyue/cheat-sheets/jupyter-notebook/pdf/) to navigate through notebooks.
-
-## The kernel
-
-The kernel maintains the state of a notebook's computations (such as current variables, declared functions and loaded data). For notebooks that do not take too long to run, it is desirable to frequently restart the kernel to ensure that there are no hidden states.
-
-Here is a list of what the different kernel related actions do:
-
-
-
-- **Interrupt ( or ■ button):** Causes the kernel to stop performing the current task without actually shutting the kernel down. You can use this option when you want to stop a very long task (eg. stop processing a large dataset).
-
-- **Restart (or ↻ button):** Stops the kernel and starts it again. This action causes you to lose all the state data. In some cases, this is precisely what you need to do when the environment has become "dirty" with hidden state data.
-
-- **Restart & Clear Output:** Stops the kernel, starts it again, and clears all the existing cell outputs.
-
-- **Restart Kernel & Run Up to Selected Cell:** Stops the kernel, starts it again, and then runs every cell starting from the top cell and ending with the currently selected cell. Use this when you are working on a Notebook and want to make sure there are no hidden states.
-
-- **Restart Kernel & Run All Cells:** Stops the kernel, starts it again, and then runs every cell starting from the top cell and ending with the last cell. Use this when you're done working on a Notebook and want to make sure everything runs properly and doesn't depend on hidden states.
-
-- **Shutdown:** Shuts the kernel down. You may perform this step in preparation for using a different kernel.
-
-- **Change Kernel:** Selects a different kernel from the list of kernels you have installed. For example, you may want to test an application using various Python versions to ensure that it runs on all of them.
-
-## Additional resources
-
-**Jupyter Notebook tutorial: https://www.dataquest.io/blog/jupyter-notebook-tutorial/**
-
-**Jupyter Notebook documentation: https://jupyterlab.readthedocs.io/en/stable/user/notebook.html**
-
-**Jupyter Lab interface documentation: https://jupyterlab.readthedocs.io/en/stable/user/interface.html**
diff --git a/Exercises/00-setup/.ipynb_checkpoints/noto-checkpoint.md b/Exercises/00-setup/.ipynb_checkpoints/noto-checkpoint.md
deleted file mode 100644
index 262adad..0000000
--- a/Exercises/00-setup/.ipynb_checkpoints/noto-checkpoint.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# EPFL Noto
-
-EPFL provides a centralized JupyterLab platform for students called [Noto](https://www.epfl.ch/education/educational-initiatives/cede/digitaltools/noto/), allowing you to run all these notebooks without having to install anything on your computer. This is because those notebooks are running in the cloud (i.e. on a remote server, with which you directly interact through the JupyterLab interface).
-
-To clone this repository on EPFL Noto, click on this link: https://go.epfl.ch/ME-390-2022.
-
-As in a local Python installation, you will need to frequently `git pull` the most recent changes in order to ensure that your files are up-to-date.
-
-**Warning**: You'll need a stable internet connection to run these labs through Noto, as it runs in the cloud. This is not the case when running the notebooks locally, even though we're still using a web browser to access Jupyter Lab.
-
-## Other cloud-based notebook platforms
-There exist other online platforms offering cloud-based Jupyter Notebooks. These platforms could enable faster computation time. Notably:
-
-- [Google Colab](https://colab.research.google.com/), which offers free GPU runtimes, which is very useful for some machine learning tasks (such as training neural networks).
-- [Deepnote](https://deepnote.com/), which offers real-time collaboration (useful for group projects).
-
-**Note**: We do not provide any support for using these platforms.
diff --git a/Exercises/01-python/.ipynb_checkpoints/intro_to_python-checkpoint.ipynb b/Exercises/01-python/.ipynb_checkpoints/intro_to_python-checkpoint.ipynb
deleted file mode 100644
index 15bb71a..0000000
--- a/Exercises/01-python/.ipynb_checkpoints/intro_to_python-checkpoint.ipynb
+++ /dev/null
@@ -1,1528 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Introduction to Python"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "![](\"images/list_indices.png\")
"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "* You can extract multiple elements by slicing. This will give you elements from the start up to **(but not including)** the end index.\n",
- "\n",
- " `list1[start_index:end_index]`\n",
- "\n",
- "\n",
- "* If you do not specify the `start_index`, you will retrieve the elements from index $0$ up to the `end_index`.\n",
- "\n",
- " `list1[:end_index]` is the same as `list1[0:end_index]`\n",
- "\n",
- "\n",
- "* If you do not specify the `end_index`, you will retrieve the elements from the `start_index` up to (and **including**) the end of the list.\n",
- "\n",
- " `list1[start_index:]`\n",
- "\n",
- "\n",
- "* You can provide a step size.\n",
- " `list1[start_index:end_index:step_size]`\n",
- " "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Exercise\n",
- "\n",
- "Try to write the output of the following code **BEFORE** running the cell."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Don't run BEFORE you solve it!\n",
- "list_1 = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
- "\n",
- "print(f\"list_1[-3] = {list_1[-3]}\")\n",
- "print(f\"list_1[0:2] = {list_1[0:2]}\")\n",
- "print(f\"list_1[:4:2] = {list_1[:4:2]}\")\n",
- "print(f\"list_1[::-1] = {list_1[::-1]}\")\n",
- "print(f\"list_1[-4:-1] = {list_1[-4:-1]}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "You can also assign new values to indices using slicing. Here is an example:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "list_1 = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
- "\n",
- "list_1[-1]= \"<3\"\n",
- "print(list_1)\n",
- "\n",
- "list_1[0:2] = [\"x\", \"y\"]\n",
- "print(list_1)\n",
- "\n",
- "list_1[::2] = [\":)\",\":(\", \":O\"]\n",
- "print(list_1)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 4.2. Copying\n",
- "\n",
- "We have one last thing to say about lists. Observe the behaviour of the following code:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Case 1:\n",
- "\n",
- "list_1 = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
- "print(f\"list_1 before {list_1}\")\n",
- "\n",
- "list_2 = list_1\n",
- "list_2.append(\"Z\")\n",
- "\n",
- "print(f\"list_1 after {list_1}\")"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Case 2:\n",
- "\n",
- "list_1 = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
- "print(f\"list_1 before function {list_1}\")\n",
- "\n",
- "def function_that_changes_list(input_list):\n",
- " input_list.append(\"Z\")\n",
- "\n",
- "function_that_changes_list(list_1)\n",
- "\n",
- "print(f\"list_1 after function {list_1}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We never changed list_1 explicitly, but the values changed anyway. What's going on?\n",
- "\n",
- "Well, in Python, when you say `list_2 = list_1`, you are not actually creating a new list, you are only copying the **reference** to the same list. This means that they are actually two variables pointing to the same list! So when you change the values of `list_2`, the values of `list_1` also change (since they are referring to the same list). Something similar is at play when you pass this list to a function. So be careful!\n",
- "\n",
- "If you do not want this to happen, you can use the function `.copy()` to create a new object with the same values. \n",
- "\n",
- "#### Exercise\n",
- "\n",
- "Change the code below and fix the two cases given above using the `.copy()` function. Make sure the contents of `list_1` do not change."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Case 1\n",
- "list_1 = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
- "print(f\"list_1 before {list_1}\")\n",
- "\n",
- "list_2 = list_1\n",
- "list_2.append(\"Z\")\n",
- "\n",
- "print(f\"list_1 after {list_1}\")\n",
- "print(\"**\")\n",
- "\n",
- "# Case 2\n",
- "list_1 = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
- "print(f\"list_1 before function {list_1}\")\n",
- "\n",
- "def function_that_changes_list(input_list):\n",
- " input_list.append(\"Z\")\n",
- "\n",
- "list_2 = list_1\n",
- "function_that_changes_list(list_2)\n",
- "\n",
- "print(f\"list_1 after function {list_1}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Exercise\n",
- "\n",
- "Now that we know how lists work, here is a quick exercise for you. Fill in the function below that takes a list and returns True if it is a palindrome, False if it is not. Palindromes are defined as sequences that read the same forwards and backwards.\n",
- "Examples of palindrome lists:\n",
- "* [\"cat\", \"dog\", \"fish\", \"dog\", \"cat\"]\n",
- "* [0, 1, 2, 3, 3, 2, 1, 0]\n",
- "* [1]\n",
- "* []\n",
- "\n",
- "You may use a for-loop in this exercise. However, if you're feeling ambitious try to do it in 1 line, without using a for-loop (hint: use slicing)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def function_is_palindrome(input_list):\n",
- " is_palindrome = True\n",
- " # Your code here\n",
- " return is_palindrome"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "test_list_1 = [\"cat\", \"dog\", \"fish\", \"dog\", \"cat\"]\n",
- "res_1 = function_is_palindrome(test_list_1)\n",
- "\n",
- "test_list_2 = [\"cat\", \"dog\", \"fish\", \"bird\", \"dog\", \"cat\"]\n",
- "res_2 = function_is_palindrome(test_list_2)\n",
- "\n",
- "test_list_3 = [\"cat\"]\n",
- "res_3 = function_is_palindrome(test_list_3)\n",
- "\n",
- "test_list_4 = [\"cat\", \"cat\"]\n",
- "res_4 = function_is_palindrome(test_list_4)\n",
- "\n",
- "if not (res_1 and not res_2 and res_3 and res_4):\n",
- " print(\"Test failed\")\n",
- "else:\n",
- " print(\"Correct! :)\")\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 5. Tuples\n",
- "\n",
- "Tuples are similar to lists but they are fixed in size and **immutable**, which means that change is not allowed.\n",
- "We declare tuples in the following way using parentheses`()`:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "tuple_1 = (\"wash\", \"your\", \"hands\", \"with\", \"soap\")\n",
- "\n",
- "print(f\"tuple_1 = {tuple_1}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Since change is not allowed, observe the result of the following piece of code."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "tuple_1[2] = (\"face\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "You can typecast from list to tuple and vice versa! "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "sequence_1 = [\"here\", \"comes\", \"the\", \"sun\"]\n",
- "print(f\"{sequence_1} is {type(sequence_1)}\")\n",
- "\n",
- "\n",
- "# from list to tuple\n",
- "sequence_1 = tuple(sequence_1)\n",
- "print(f\"{sequence_1} is {type(sequence_1)}\")\n",
- "\n",
- "#from tuple to list\n",
- "sequence_1 = list(sequence_1)\n",
- "print(f\"{sequence_1} is {type(sequence_1)}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 6. Dictionaries\n",
- "\n",
- "An incredibly useful data type to know, you might also know dictionaries as \"hash maps\". Dictionaries are collections of \"key: value\" pairs. You can access the values using the keys in $O(1)$ time.\n",
- "\n",
- "The keys of a dictionary must be **immutable** and **unique**. Below we show how to define a dictionary.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "shopping_list = {\"apples\": 3, \"pears\":2, \"eggs\":6, \"bread\":1, \"yogurt\":1}\n",
- "print(f\"shopping_list = {shopping_list}\")\n",
- "print(\"**\")\n",
- "\n",
- "\n",
- "book_dict = {}\n",
- "print(f\"book_dict = {book_dict}\")\n",
- "#add key value pairs\n",
- "book_dict[\"vonnegut\"] = \"cat\\'s cradle\"\n",
- "book_dict[\"ishiguro\"] = \"never let me go\"\n",
- "print(f\"book_dict = {book_dict}\")\n",
- "print(\"**\")\n",
- "\n",
- "# we can retrieve the dict keys:\n",
- "print(book_dict.keys())\n",
- "# and the dict values:\n",
- "print(book_dict.values())\n",
- "print(\"**\")\n",
- "\n",
- "#we can also iterate through the dict keys and values with a for-loop\n",
- "for key, value in book_dict.items():\n",
- " print(f\"{key} : {value}\")\n",
- "\n",
- "print(\"**\")\n",
- "#we can modify the value of a key\n",
- "book_dict[\"ishiguro\"] = \"a pale view of hills\"\n",
- "print(f\"modified book_dict = {book_dict}\")\n",
- "print(\"**\")\n",
- "\n",
- "#and we can remove a key completely\n",
- "removed_value = book_dict.pop(\"ishiguro\")\n",
- "print(f\"book_dict with removed value = {book_dict}\")\n",
- "print(f\"removed_value = {removed_value}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 7. Functions\n",
- "\n",
- "You can define a function in Python in the following way:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def multiply(a, b):\n",
- " return a * b\n",
- "\n",
- "print(f\"multiply(100, 2) = {multiply(100, 2)}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "You can have default arguments by specifying their default value in the parameters."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def add(a, b, c=0, d=1):\n",
- " return a + b + c + d\n",
- "\n",
- "# use no default arguments\n",
- "print(f\"add(1, 2, 100, 1000) = {add(1, 2, 100, 1000)}\")\n",
- "\n",
- "# use the default value of d\n",
- "print(f\"add(1, 2, 100) = {add(1, 2, 100)}\")\n",
- "\n",
- "# use the default value of c and d\n",
- "print(f\"add(1, 2) = {add(1, 2)}\")\n",
- "\n",
- "# use the default value of c\n",
- "print(f\"add(1, 2, d=1000) = {add(1, 2, d=1000)}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "A function can return multiple values in a tuple. You can assign the values of the tuple to separate variables. This is called **tuple unpacking**."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def min_max(input_list):\n",
- " return min(input_list), max(input_list)\n",
- "\n",
- "\n",
- "test_list = [1,2,3,4]\n",
- "min_val, max_val = min_max(test_list)\n",
- "print(f\"min_val: {min_val}, max_val: {max_val}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Note: You have seen tuple unpacking when using function `enumerate` in for-loop."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 7.1. Common Built-in Functions\n",
- "\n",
- "Here we introduce some nifty commonly used built-in functions. \n",
- "\n",
- "* You already learned `range()`, `enumerate()`!\n",
- "* We have also seen `type()` to return the type of the object. We use `str()`, `int()`, `float()`, `list()`, `tuple()` for typecasting.\n",
- "* The functions `len()`, `sum()`, `min()`, `max()`, `any()`, `all()`, `sorted()`, `zip()` are useful for lists and tuples.\n",
- "\n",
- "Let's see them in action below"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "list_1 = list(range(5))\n",
- "print(f\"list_1 = {list_1}\")\n",
- "\n",
- "print(f\"len(list_1) = {len(list_1)}\")\n",
- "print(f\"sum(list_1) = {sum(list_1)}\")\n",
- "print(f\"min(list_1) = {min(list_1)}\")\n",
- "print(f\"max(list_1) = {max(list_1)}\")\n",
- "print(\"**\")\n",
- "\n",
- "\n",
- "list_2 = [5,3,1,2,0,6]\n",
- "print(f\"list_2 = {list_2}\")\n",
- "print(f\"sorted(list_2) = {sorted(list_2)}\")\n",
- "print(\"**\")\n",
- "\n",
- "\n",
- "# any checks whether there are any 1s in the list (OR)\n",
- "# all checks whether all elements are 1s. (AND)\n",
- "# in Python: 1 = True, 0 = False\n",
- "list_3 = [1, 1, 1]\n",
- "print(f\"list_3 = {list_3}\")\n",
- "print(f\"any(list_3) = {any(list_3)}\")\n",
- "print(f\"all(list_3) = {all(list_3)}\")\n",
- "\n",
- "list_4 = [0, 1, 1]\n",
- "print(f\"list_4 = {list_4}\")\n",
- "print(f\"any(list_4) = {any(list_4)}\")\n",
- "print(f\"all(list_4) = {all(list_4)}\")\n",
- "\n",
- "list_5 = [0, 0, 0]\n",
- "print(f\"list_5 = {list_5}\")\n",
- "print(f\"any(list_5) = {any(list_5)}\")\n",
- "print(f\"all(list_5) = {all(list_5)}\")\n",
- "print(\"**\")\n",
- "\n",
- "# zip function:\n",
- "x = [1,2,3]\n",
- "y = [4,5,6]\n",
- "zipped = zip(x,y)\n",
- "print(f\"x {x}\")\n",
- "print(f\"y {y}\")\n",
- "print(f\"zipped {list(zipped)}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 7.2. List Comprehensions\n",
- "\n",
- "One of the most practical things about Python is that you can do many things on just a single line. One popular example is so called *list comprehensions*, a specific syntax to create and initalize lists of objects. Here are some examples.\n",
- "\n",
- "A syntax for list comprehension is shown below:\n",
- "`[thing for thing in list]`\n",
- "\n",
- "Let's make it more concrete with an example."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "list_of_numbers = [1, 2, 3, 101, 102, 103]\n",
- "print(f\"list_of_numbers = {list_of_numbers}\")\n",
- "\n",
- "#I want to create a new list with all these items doubled.\n",
- "doubled_list = [2 * elem for elem in list_of_numbers]\n",
- "print(f\"doubled_list = {doubled_list}\")\n",
- "\n",
- "#A new list with all these items as floats\n",
- "float_list = [float(elem) for elem in list_of_numbers]\n",
- "print(f\"float_list = {float_list}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Let's make it more interesting by adding an if in there:\n",
- "\n",
- "`[thing for thing in list if condition]`\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#I want to create a new list with all these items doubled\n",
- "#IF the element is above 100\n",
- "conditional_doubled_list = [2 * elem for elem in list_of_numbers if elem > 100]\n",
- "print(f\"conditional_doubled_list = {conditional_doubled_list}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Exercise\n",
- "\n",
- "You will be given a list of vocabulary words. Your task is to use list comprehensions to iterate through a document and create a new list including the words that are included in the vocabulary. You don't need to worry about duplicates.\n",
- "\n",
- "Example: \n",
- "```python\n",
- "vocabulary = [\"a\" \"c\", \"e\"]\n",
- "document = [\"a\", \"b\", \"c\", \"d\"]\n",
- "new_list = [\"a\", \"c\"]\n",
- "```"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "vocabulary = ['epfl', 'europe', 'swiss', 'switzerland', 'best', 'education', 'high', 'higher', 'research', 'school', 'science', 'students', 'technology', 'top-tier', 'university']\n",
- "\n",
- "document = \"\"\"The École polytechnique fédérale de Lausanne (EPFL) is a research institute\n",
- "and university in Lausanne, Switzerland, that specializes in natural sciences and engineering.\n",
- "It is one of the two Swiss Federal Institutes of Technology, and it has three main missions: \n",
- "education, research and technology transfer at the highest international level. EPFL is widely regarded \n",
- "as a world leading university. The QS World University Rankings ranks EPFL 12th in the world \n",
- "across all fields in their 2017/2018 ranking, whilst Times Higher Education World \n",
- "University Rankings ranks EPFL as the world's 11th best school for Engineering and Technology.\"\"\"\n",
- "document_parsed = document.split()\n",
- "document_parsed = [word.lower() for word in document_parsed]\n",
- "new_list = []\n",
- "\n",
- "#your code here\n",
- "new_list = ...\n",
- "\n",
- "#We convert the list to a set and then back to a list. We do this because converting it to a set automatically\n",
- "#removes duplicates (since sets are sequences that do not contain duplicates). afterwards we sort it.\n",
- "new_list = sorted(list(set(new_list)))\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "correct_result = ['best', 'education', 'epfl', 'higher', 'research', 'school', 'swiss', 'technology', 'university']\n",
- "\n",
- "if new_list == correct_result:\n",
- " print (\"Correct! :)\")\n",
- "else:\n",
- " print (\"Incorrect :(\")\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "tags": []
- },
- "source": [
- "## 8. (optional now - useful later on) Object-Oriented Programming\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Object-oriented programming is a programming paradigm that provides a means of structuring programs so that properties and behaviors are bundled into individual objects.\n",
- "\n",
- "For this end, we use classes. Classes are used to create user-defined data structures. Classes define functions called methods, which identify the behaviors and actions that an object created from the class can perform with its data."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "All class definitions start with the class keyword, which is followed by the name of the class and a colon. Any code that is indented below the class definition is considered part of the class’s body. To start, let's declare an `EPFL_faculty` class."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "class EPFL_faculty:\n",
- "\n",
- " def __init__(self, name, number_of_students):\n",
- " self.name = name\n",
- " self.number_of_students = number_of_students\n",
- "\n",
- " # Instance method\n",
- " def description(self):\n",
- " return f\"The faculty {self.name} has {self.number_of_students} students\""
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "While the class is the blueprint, an instance is an object that is built from a class and contains real data. `.__init__()` sets the initial state of the object by assigning the values of the object’s properties. That is, `.__init__()` initializes each new instance of the class."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "sti = EPFL_faculty(\"STI\", 500)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Now that the instance `sti` has been created, we can call the method description."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "sti.description()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Inheritance is the process by which one class takes on the attributes and methods of another. Newly formed classes are called child classes, and the classes that child classes are derived from are called parent classes. Child classes inherit from the parent's attributs and methods but it can overwrite methods. Let's define a class `EPFL_section` that inherits from `EPFL_faculty` and that overwrites the method `description(self)`."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "class EPFL_section(EPFL_faculty):\n",
- " \n",
- " def description(self):\n",
- " return f\"The section {self.name} has {self.number_of_students} students\""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "genie_mechanique = EPFL_section(\"GM\", 200)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "genie_mechanique.description()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "__Disclaimer__: This part of the tutorial and its text was inspired by and taken from \"Object-Oriented Programming (OOP) in Python 3\" by David Amos. "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Additional OOP resources"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "For further information on object-oriented programming and classes in Python, here are two useful resources:\n",
- "* Object-Oriented Programming (OOP) in Python 3: https://realpython.com/python3-object-oriented-programming/\n",
- "* Classes from the official Python Tutorial: https://docs.python.org/3/tutorial/classes.html"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 9. (optional now - useful later on) Matplotlib"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Perhaps the most widely used plotting library in Python is Matplotlib. If you've ever used MATLAB, you'll find that the functions look pretty similar. \n",
- "\n",
- "In the following exercise sessions, we won't ask you to do any plotting. So this part is optional for those who are interested in having a short introduction.\n",
- "\n",
- "First, we will import Matplotlib."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Importing in Python\n",
- "\n",
- "* A short note on importing: to be able to use modules in our code, we import them. \n",
- " \n",
- " example: `import numpy`\n",
- " \n",
- "\n",
- "* We can also select a name for the imported module.\n",
- " \n",
- " example: `import numpy as np`. Now when we call numpy functions, we will always use `np.` as a prefix, i.e. `np.zeros()`\n",
- " \n",
- "\n",
- "* You can also choose to only import selected functions/variables/classes from the module. \n",
- " \n",
- " example: `from numpy import arange`. Now you can use this function as `arange(5)`. You cannot use any other functions from the numpy module as you did not import them."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# To import Matplotlib we do:\n",
- "\n",
- "import matplotlib.pyplot as plt"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Let's do some plotting! \n",
- "\n",
- "Let's start with the simplest of plots, the good old line-plot. The function we will use is `plot()`"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#Let's create some data first to plot\n",
- "x = list(range(10))\n",
- "y = [2,3,5,1,0,2,3,0,0,1]\n",
- "\n",
- "#first create a figure\n",
- "fig = plt.figure()\n",
- "\n",
- "#now do the plotting\n",
- "#specifying a color and marker are optional.\n",
- "#check out the documentation to see what else you can do with the plot function\n",
- "plt.plot(x, y, marker=\"*\", color=\"r\")\n",
- "\n",
- "#axis labels and title\n",
- "plt.xlabel(\"x\")\n",
- "plt.ylabel(\"y\")\n",
- "plt.title(\"just a random plot\")\n",
- "\n",
- "#so that we see the plot\n",
- "plt.show()\n",
- "\n",
- "#close the plot\n",
- "plt.close(fig)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Exercise\n",
- "\n",
- "You can plot two lines on top of one another by calling the `plt.plot()` function consecutively. Try to implement this! Also, specify the parameter `label` of the `plt.plot()` function and call the function `plt.legend()` to create a legend for your graph. It should look like the figure shown below."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- ""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#Let's create some data first to plot\n",
- "x = list(range(10))\n",
- "y1 = [2,3,5,1,0,2,3,0,0,1]\n",
- "y2 = [1,2,3,5,1,0,2,3,0,0]\n",
- "\n",
- "#first create a figure\n",
- "fig = plt.figure()\n",
- "#your code here\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "You can create scatter plots (line plots without lines) with `scatter()`"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#Let's create some data first to plot\n",
- "x = list(range(10))\n",
- "y1 = [2,3,5,1,0,2,3,0,0,1]\n",
- "\n",
- "#first create a figure\n",
- "fig = plt.figure()\n",
- "\n",
- "#now do the plotting\n",
- "p1 = plt.scatter(x, y1, marker=\"*\", color=\"r\")\n",
- "\n",
- "#axis labels and title\n",
- "plt.xlabel(\"x\")\n",
- "plt.ylabel(\"y\")\n",
- "plt.title(\"just a random scatter plot\")\n",
- "\n",
- "#so that we see the plot\n",
- "plt.show()\n",
- "\n",
- "#close the plot\n",
- "plt.close(fig)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "And you can read and display images with `imread()` and `imshow()`"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#first create a figure\n",
- "fig = plt.figure()\n",
- "\n",
- "#now do the plotting\n",
- "im = plt.imread(\"images/krabby_patty.jpg\")\n",
- "plt.imshow(im)\n",
- "\n",
- "#axis labels and title\n",
- "plt.xlabel(\"x\")\n",
- "plt.ylabel(\"y\")\n",
- "plt.title(\"krabby patty\")\n",
- "\n",
- "#so that we see the plot\n",
- "plt.show()\n",
- "\n",
- "#close the plot\n",
- "plt.close(fig)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "And that's all for this exercise! If you have any problems, just ask (or even Google) them. You can check out the official Python tutorials for further learning.\n",
- "\n",
- "https://docs.python.org/3/tutorial/"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.8.10"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/Exercises/01-python/.ipynb_checkpoints/intro_to_python_Sol-checkpoint.ipynb b/Exercises/01-python/.ipynb_checkpoints/intro_to_python_Sol-checkpoint.ipynb
deleted file mode 100644
index eba5588..0000000
--- a/Exercises/01-python/.ipynb_checkpoints/intro_to_python_Sol-checkpoint.ipynb
+++ /dev/null
@@ -1,1565 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Introduction to Python - Solutions"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- ""
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "* You can extract multiple elements by slicing. This will give you elements from the start up to **(but not including)** the end index.\n",
- "\n",
- " `list1[start_index:end_index]`\n",
- "\n",
- "\n",
- "* If you do not specify the `start_index`, you will retrieve the elements from index $0$ up to the `end_index`.\n",
- "\n",
- " `list1[:end_index]` is the same as `list1[0:end_index]`\n",
- "\n",
- "\n",
- "* If you do not specify the `end_index`, you will retrieve the elements from the `start_index` up to (and **including**) the end of the list.\n",
- "\n",
- " `list1[start_index:]`\n",
- "\n",
- "\n",
- "* You can provide a step size.\n",
- " `list1[start_index:end_index:step_size]`\n",
- " "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Exercise\n",
- "\n",
- "Try to write the output of the following code **BEFORE** running the cell."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Don't run BEFORE you solve it!\n",
- "list_1 = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
- "\n",
- "print(f\"list_1[-3] = {list_1[-3]}\")\n",
- "print(f\"list_1[0:2] = {list_1[0:2]}\")\n",
- "print(f\"list_1[:4:2] = {list_1[:4:2]}\")\n",
- "print(f\"list_1[::-1] = {list_1[::-1]}\")\n",
- "print(f\"list_1[-4:-1] = {list_1[-4:-1]}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "You can also assign new values to indices using slicing. Here is an example:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "list_1 = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
- "\n",
- "list_1[-1]= \"<3\"\n",
- "print(list_1)\n",
- "\n",
- "list_1[0:2] = [\"x\", \"y\"]\n",
- "print(list_1)\n",
- "\n",
- "list_1[::2] = [\":)\",\":(\", \":O\"]\n",
- "print(list_1)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 4.2. Copying\n",
- "\n",
- "We have one last thing to say about lists. Observe the behaviour of the following code:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Case 1:\n",
- "\n",
- "list_1 = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
- "print(f\"list_1 before {list_1}\")\n",
- "\n",
- "list_2 = list_1\n",
- "list_2.append(\"Z\")\n",
- "\n",
- "print(f\"list_1 after {list_1}\")"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Case 2:\n",
- "\n",
- "list_1 = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
- "print(f\"list_1 before function {list_1}\")\n",
- "\n",
- "def function_that_changes_list(input_list):\n",
- " input_list.append(\"Z\")\n",
- "\n",
- "function_that_changes_list(list_1)\n",
- "\n",
- "print(f\"list_1 after function {list_1}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We never changed list_1 explicitly, but the values changed anyway. What's going on?\n",
- "\n",
- "Well, in Python, when you say `list_2 = list_1`, you are not actually creating a new list, you are only copying the **reference** to the same list. This means that they are actually two variables pointing to the same list! So when you change the values of `list_2`, the values of `list_1` also change (since they are referring to the same list). Something similar is at play when you pass this list to a function. So be careful!\n",
- "\n",
- "If you do not want this to happen, you can use the function `.copy()` to create a new object with the same values. \n",
- "\n",
- "#### Exercise\n",
- "\n",
- "Change the code below and fix the two cases given above using the `.copy()` function. Make sure the contents of `list_1` do not change."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Case 1\n",
- "list_1 = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
- "print(f\"list_1 before {list_1}\")\n",
- "\n",
- "list_2 = list_1.copy()\n",
- "list_2.append(\"Z\")\n",
- "\n",
- "print(f\"list_1 after {list_1}\")\n",
- "print(\"**\")\n",
- "\n",
- "# Case 2\n",
- "list_1 = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
- "print(f\"list_1 before function {list_1}\")\n",
- "\n",
- "def function_that_changes_list(input_list):\n",
- " input_list.append(\"Z\")\n",
- "\n",
- "list_2 = list_1.copy()\n",
- "function_that_changes_list(list_2)\n",
- "\n",
- "print(f\"list_1 after function {list_1}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Exercise\n",
- "\n",
- "Now that we know how lists work, here is a quick exercise for you. Fill in the function below that takes a list and returns True if it is a palindrome, False if it is not. Palindromes are defined as sequences that read the same forwards and backwards.\n",
- "Examples of palindrome lists:\n",
- "* [\"cat\", \"dog\", \"fish\", \"dog\", \"cat\"]\n",
- "* [0, 1, 2, 3, 3, 2, 1, 0]\n",
- "* [1]\n",
- "* []\n",
- "\n",
- "You may use a for-loop in this exercise. However, if you're feeling ambitious try to do it in 1 line, without using a for-loop (hint: use slicing)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# with for-loop\n",
- "def function_is_palindrome(input_list):\n",
- " is_palindrome = True\n",
- " \n",
- " # Your code here\n",
- " len_of_list = len(input_list) // 2\n",
- " for element in range(len_of_list):\n",
- " if input_list[element] != input_list[-element-1]:\n",
- " is_palindrome = False\n",
- " return is_palindrome"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# without for-loop\n",
- "def function_is_palindrome(input_list):\n",
- " return input_list == input_list[::-1]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "test_list_1 = [\"cat\", \"dog\", \"fish\", \"dog\", \"cat\"]\n",
- "res_1 = function_is_palindrome(test_list_1)\n",
- "\n",
- "test_list_2 = [\"cat\", \"dog\", \"fish\", \"bird\", \"dog\", \"cat\"]\n",
- "res_2 = function_is_palindrome(test_list_2)\n",
- "\n",
- "test_list_3 = [\"cat\"]\n",
- "res_3 = function_is_palindrome(test_list_3)\n",
- "\n",
- "test_list_4 = [\"cat\", \"cat\"]\n",
- "res_4 = function_is_palindrome(test_list_4)\n",
- "\n",
- "if not (res_1 and not res_2 and res_3 and res_4):\n",
- " print(\"Test failed\")\n",
- "else:\n",
- " print(\"Correct! :)\")\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 5. Tuples\n",
- "\n",
- "Tuples are similar to lists but they are fixed in size and **immutable**, which means that change is not allowed.\n",
- "We declare tuples in the following way using parentheses`()`:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "tuple_1 = (\"wash\", \"your\", \"hands\", \"with\", \"soap\")\n",
- "\n",
- "print(f\"tuple_1 = {tuple_1}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Since change is not allowed, observe the result of the following piece of code."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "tuple_1[2] = (\"face\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "You can typecast from list to tuple and vice versa! "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "sequence_1 = [\"here\", \"comes\", \"the\", \"sun\"]\n",
- "print(f\"{sequence_1} is {type(sequence_1)}\")\n",
- "\n",
- "\n",
- "# from list to tuple\n",
- "sequence_1 = tuple(sequence_1)\n",
- "print(f\"{sequence_1} is {type(sequence_1)}\")\n",
- "\n",
- "#from tuple to list\n",
- "sequence_1 = list(sequence_1)\n",
- "print(f\"{sequence_1} is {type(sequence_1)}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 6. Dictionaries\n",
- "\n",
- "An incredibly useful data type to know, you might also know dictionaries as \"hash maps\". Dictionaries are collections of \"key: value\" pairs. You can access the values using the keys in $O(1)$ time.\n",
- "\n",
- "The keys of a dictionary must be **immutable** and **unique**. Below we show how to define a dictionary.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "shopping_list = {\"apples\": 3, \"pears\":2, \"eggs\":6, \"bread\":1, \"yogurt\":1}\n",
- "print(f\"shopping_list = {shopping_list}\")\n",
- "print(\"**\")\n",
- "\n",
- "\n",
- "book_dict = {}\n",
- "print(f\"book_dict = {book_dict}\")\n",
- "#add key value pairs\n",
- "book_dict[\"vonnegut\"] = \"cat\\'s cradle\"\n",
- "book_dict[\"ishiguro\"] = \"never let me go\"\n",
- "print(f\"book_dict = {book_dict}\")\n",
- "print(\"**\")\n",
- "\n",
- "# we can retrieve the dict keys:\n",
- "print(book_dict.keys())\n",
- "# and the dict values:\n",
- "print(book_dict.values())\n",
- "print(\"**\")\n",
- "\n",
- "#we can also iterate through the dict keys and values with a for-loop\n",
- "for key, value in book_dict.items():\n",
- " print(f\"{key} : {value}\")\n",
- "\n",
- "print(\"**\")\n",
- "#we can modify the value of a key\n",
- "book_dict[\"ishiguro\"] = \"a pale view of hills\"\n",
- "print(f\"modified book_dict = {book_dict}\")\n",
- "print(\"**\")\n",
- "\n",
- "#and we can remove a key completely\n",
- "removed_value = book_dict.pop(\"ishiguro\")\n",
- "print(f\"book_dict with removed value = {book_dict}\")\n",
- "print(f\"removed_value = {removed_value}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 7. Functions\n",
- "\n",
- "You can define a function in Python in the following way:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def multiply(a, b):\n",
- " return a * b\n",
- "\n",
- "print(f\"multiply(100, 2) = {multiply(100, 2)}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "You can have default arguments by specifying their default value in the parameters."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def add(a, b, c=0, d=1):\n",
- " return a + b + c + d\n",
- "\n",
- "# use no default arguments\n",
- "print(f\"add(1, 2, 100, 1000) = {add(1, 2, 100, 1000)}\")\n",
- "\n",
- "# use the default value of d\n",
- "print(f\"add(1, 2, 100) = {add(1, 2, 100)}\")\n",
- "\n",
- "# use the default value of c and d\n",
- "print(f\"add(1, 2) = {add(1, 2)}\")\n",
- "\n",
- "# use the default value of c\n",
- "print(f\"add(1, 2, d=1000) = {add(1, 2, d=1000)}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "A function can return multiple values in a tuple. You can assign the values of the tuple to separate variables. This is called **tuple unpacking**."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def min_max(input_list):\n",
- " return min(input_list), max(input_list)\n",
- "\n",
- "\n",
- "test_list = [1,2,3,4]\n",
- "min_val, max_val = min_max(test_list)\n",
- "print(f\"min_val: {min_val}, max_val: {max_val}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Note: You have seen tuple unpacking when using function `enumerate` in for-loop."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 7.1. Common Built-in Functions\n",
- "\n",
- "Here we introduce some nifty commonly used built-in functions. \n",
- "\n",
- "* You already learned `range()`, `enumerate()`!\n",
- "* We have also seen `type()` to return the type of the object. We use `str()`, `int()`, `float()`, `list()`, `tuple()` for typecasting.\n",
- "* The functions `len()`, `sum()`, `min()`, `max()`, `any()`, `all()`, `sorted()`, `zip()` are useful for lists and tuples.\n",
- "\n",
- "Let's see them in action below"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "list_1 = list(range(5))\n",
- "print(f\"list_1 = {list_1}\")\n",
- "\n",
- "print(f\"len(list_1) = {len(list_1)}\")\n",
- "print(f\"sum(list_1) = {sum(list_1)}\")\n",
- "print(f\"min(list_1) = {min(list_1)}\")\n",
- "print(f\"max(list_1) = {max(list_1)}\")\n",
- "print(\"**\")\n",
- "\n",
- "\n",
- "list_2 = [5,3,1,2,0,6]\n",
- "print(f\"list_2 = {list_2}\")\n",
- "print(f\"sorted(list_2) = {sorted(list_2)}\")\n",
- "print(\"**\")\n",
- "\n",
- "\n",
- "# any checks whether there are any 1s in the list (OR)\n",
- "# all checks whether all elements are 1s. (AND)\n",
- "# in Python: 1 = True, 0 = False\n",
- "list_3 = [1, 1, 1]\n",
- "print(f\"list_3 = {list_3}\")\n",
- "print(f\"any(list_3) = {any(list_3)}\")\n",
- "print(f\"all(list_3) = {all(list_3)}\")\n",
- "\n",
- "list_4 = [0, 1, 1]\n",
- "print(f\"list_4 = {list_4}\")\n",
- "print(f\"any(list_4) = {any(list_4)}\")\n",
- "print(f\"all(list_4) = {all(list_4)}\")\n",
- "\n",
- "list_5 = [0, 0, 0]\n",
- "print(f\"list_5 = {list_5}\")\n",
- "print(f\"any(list_5) = {any(list_5)}\")\n",
- "print(f\"all(list_5) = {all(list_5)}\")\n",
- "print(\"**\")\n",
- "\n",
- "# zip function:\n",
- "x = [1,2,3]\n",
- "y = [4,5,6]\n",
- "zipped = zip(x,y)\n",
- "print(f\"x {x}\")\n",
- "print(f\"y {y}\")\n",
- "print(f\"zipped {list(zipped)}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 7.2. List Comprehensions\n",
- "\n",
- "One of the most practical things about Python is that you can do many things on just a single line. One popular example is so called *list comprehensions*, a specific syntax to create and initalize lists of objects. Here are some examples.\n",
- "\n",
- "A syntax for list comprehension is shown below:\n",
- "`[thing for thing in list]`\n",
- "\n",
- "Let's make it more concrete with an example."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "list_of_numbers = [1, 2, 3, 101, 102, 103]\n",
- "print(f\"list_of_numbers = {list_of_numbers}\")\n",
- "\n",
- "#I want to create a new list with all these items doubled.\n",
- "doubled_list = [2 * elem for elem in list_of_numbers]\n",
- "print(f\"doubled_list = {doubled_list}\")\n",
- "\n",
- "#A new list with all these items as floats\n",
- "float_list = [float(elem) for elem in list_of_numbers]\n",
- "print(f\"float_list = {float_list}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Let's make it more interesting by adding an if in there:\n",
- "\n",
- "`[thing for thing in list if condition]`\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#I want to create a new list with all these items doubled\n",
- "#IF the element is above 100\n",
- "conditional_doubled_list = [2 * elem for elem in list_of_numbers if elem > 100]\n",
- "print(f\"conditional_doubled_list = {conditional_doubled_list}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Exercise\n",
- "\n",
- "You will be given a list of vocabulary words. Your task is to use list comprehensions to iterate through a document and create a new list including the words that are included in the vocabulary. You don't need to worry about duplicates.\n",
- "\n",
- "Example: \n",
- "```python\n",
- "vocabulary = [\"a\" \"c\", \"e\"]\n",
- "document = [\"a\", \"b\", \"c\", \"d\"]\n",
- "new_list = [\"a\", \"c\"]\n",
- "```"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "vocabulary = ['epfl', 'europe', 'swiss', 'switzerland', 'best', 'education', 'high', 'higher', 'research', 'school', 'science', 'students', 'technology', 'top-tier', 'university']\n",
- "\n",
- "document = \"\"\"The École polytechnique fédérale de Lausanne (EPFL) is a research institute\n",
- "and university in Lausanne, Switzerland, that specializes in natural sciences and engineering.\n",
- "It is one of the two Swiss Federal Institutes of Technology, and it has three main missions: \n",
- "education, research and technology transfer at the highest international level. EPFL is widely regarded \n",
- "as a world leading university. The QS World University Rankings ranks EPFL 12th in the world \n",
- "across all fields in their 2017/2018 ranking, whilst Times Higher Education World \n",
- "University Rankings ranks EPFL as the world's 11th best school for Engineering and Technology.\"\"\"\n",
- "document_parsed = document.split()\n",
- "document_parsed = [word.lower() for word in document_parsed]\n",
- "new_list = []\n",
- "\n",
- "# Your code here\n",
- "new_list = [word for word in document_parsed if (word in vocabulary)]\n",
- "\n",
- "# We convert the list to a set and then back to a list. We do this because converting it to a set automatically\n",
- "# removes duplicates (since sets are sequences that do not contain duplicates). afterwards we sort it.\n",
- "new_list = sorted(list(set(new_list)))\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "correct_result = ['best', 'education', 'epfl', 'higher', 'research', 'school', 'swiss', 'technology', 'university']\n",
- "\n",
- "if new_list == correct_result:\n",
- " print (\"Correct! :)\")\n",
- "else:\n",
- " print (\"Incorrect :(\")\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 8. (optional now - useful later on) Object-Oriented Programming"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Object-oriented programming is a programming paradigm that provides a means of structuring programs so that properties and behaviors are bundled into individual objects.\n",
- "\n",
- "For this end, we use classes. Classes are used to create user-defined data structures. Classes define functions called methods, which identify the behaviors and actions that an object created from the class can perform with its data."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "All class definitions start with the class keyword, which is followed by the name of the class and a colon. Any code that is indented below the class definition is considered part of the class’s body. To start, let's declare an `EPFL_faculty` class."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "class EPFL_faculty:\n",
- "\n",
- " def __init__(self, name, number_of_students):\n",
- " self.name = name\n",
- " self.number_of_students = number_of_students\n",
- "\n",
- " # Instance method\n",
- " def description(self):\n",
- " return f\"The faculty {self.name} has {self.number_of_students} students\""
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "While the class is the blueprint, an instance is an object that is built from a class and contains real data. `.__init__()` sets the initial state of the object by assigning the values of the object’s properties. That is, `.__init__()` initializes each new instance of the class."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "sti = EPFL_faculty(\"STI\", 1000)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Now that the instance `sti` has been created, we can call the method description."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# sti.description()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Inheritance is the process by which one class takes on the attributes and methods of another. Newly formed classes are called child classes, and the classes that child classes are derived from are called parent classes. Child classes inherit from the parent's attributs and methods but it can overwrite methods. Let's define a class `EPFL_section` that inherits from `EPFL_faculty` and that overwrites the method `description(self)`."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "class EPFL_section(EPFL_faculty):\n",
- " \n",
- " def description(self):\n",
- " return f\"The section {self.name} has {self.number_of_students} students\""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "genie_mecanique = EPFL_section(\"GM\", 200)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "genie_mecanique.description()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "__Disclaimer__: This part of the tutorial and its text was inspired by and taken from \"Object-Oriented Programming (OOP) in Python 3\" by David Amos. "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Additional OOP resources"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "For further information on object-oriented programming and classes in Python, here are two useful resources:\n",
- "* Object-Oriented Programming (OOP) in Python 3: https://realpython.com/python3-object-oriented-programming/\n",
- "* Classes from the official Python Tutorial: https://docs.python.org/3/tutorial/classes.html"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 9. (optional now, useful later on) Matplotlib"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Perhaps the most widely used plotting library in Python is Matplotlib. If you've ever used MATLAB, you'll find that the functions look pretty similar. \n",
- "\n",
- "In the following exercise sessions, we won't ask you to do any plotting. So this part is optional for those who are interested in having a short introduction.\n",
- "\n",
- "First, we will import Matplotlib."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Importing in Python\n",
- "\n",
- "* A short note on importing: to be able to use modules in our code, we import them. \n",
- " \n",
- " example: `import numpy`\n",
- " \n",
- "\n",
- "* We can also select a name for the imported module.\n",
- " \n",
- " example: `import numpy as np`. Now when we call numpy functions, we will always use `np.` as a prefix, i.e. `np.zeros()`\n",
- " \n",
- "\n",
- "* You can also choose to only import selected functions/variables/classes from the module. \n",
- " \n",
- " example: `from numpy import arange`. Now you can use this function as `arange(5)`. You cannot use any other functions from the numpy module as you did not import them."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# To import Matplotlib we do:\n",
- "\n",
- "import matplotlib.pyplot as plt"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Let's do some plotting! \n",
- "\n",
- "Let's start with the simplest of plots, the good old line-plot. The function we will use is `plot()`"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#Let's create some data first to plot\n",
- "x = list(range(10))\n",
- "y = [2,3,5,1,0,2,3,0,0,1]\n",
- "\n",
- "#first create a figure\n",
- "fig = plt.figure()\n",
- "\n",
- "#now do the plotting\n",
- "#specifying a color and marker are optional.\n",
- "#check out the documentation to see what else you can do with the plot function\n",
- "plt.plot(x, y, marker=\"*\", color=\"r\")\n",
- "\n",
- "#axis labels and title\n",
- "plt.xlabel(\"x\")\n",
- "plt.ylabel(\"y\")\n",
- "plt.title(\"just a random plot\")\n",
- "\n",
- "#so that we see the plot\n",
- "plt.show()\n",
- "\n",
- "#close the plot\n",
- "plt.close(fig)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### Exercise\n",
- "\n",
- "You can plot two lines on top of one another by calling the `plt.plot()` function consecutively. Try to implement this! Also, specify the parameter `label` of the `plt.plot()` function and call the function `plt.legend()` to create a legend for your graph. It should look like the figure shown below."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- ""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#Let's create some data first to plot\n",
- "x = list(range(10))\n",
- "y1 = [2,3,5,1,0,2,3,0,0,1]\n",
- "y2 = [1,2,3,5,1,0,2,3,0,0]\n",
- "\n",
- "#your code here\n",
- "#first create a figure\n",
- "fig = plt.figure()\n",
- "\n",
- "#now do the plotting\n",
- "#let's add labels for the legend\n",
- "p1 = plt.plot(x, y1, marker=\"*\", color=\"r\", label=\"red line\")\n",
- "p2 = plt.plot(x, y2, marker=\"^\", color=\"b\", label=\"green line\")\n",
- "plt.legend()\n",
- "\n",
- "#axis labels and title\n",
- "plt.xlabel(\"x\")\n",
- "plt.ylabel(\"y\")\n",
- "plt.title(\"just a random plot\")\n",
- "\n",
- "#so that we see the plot\n",
- "plt.show()\n",
- "#close the plot\n",
- "plt.close(fig)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "You can create scatter plots (line plots without lines) with `scatter()`"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#Let's create some data first to plot\n",
- "x = list(range(10))\n",
- "y1 = [2,3,5,1,0,2,3,0,0,1]\n",
- "\n",
- "#first create a figure\n",
- "fig = plt.figure()\n",
- "\n",
- "#now do the plotting\n",
- "p1 = plt.scatter(x, y1, marker=\"*\", color=\"r\")\n",
- "\n",
- "#axis labels and title\n",
- "plt.xlabel(\"x\")\n",
- "plt.ylabel(\"y\")\n",
- "plt.title(\"just a random scatter plot\")\n",
- "\n",
- "#so that we see the plot\n",
- "plt.show()\n",
- "\n",
- "#close the plot\n",
- "plt.close(fig)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "And you can read and display images with `imread()` and `imshow()`"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#first create a figure\n",
- "fig = plt.figure()\n",
- "\n",
- "#now do the plotting\n",
- "im = plt.imread(\"images/krabby_patty.jpg\")\n",
- "plt.imshow(im)\n",
- "\n",
- "#axis labels and title\n",
- "plt.xlabel(\"x\")\n",
- "plt.ylabel(\"y\")\n",
- "plt.title(\"krabby patty\")\n",
- "\n",
- "#so that we see the plot\n",
- "plt.show()\n",
- "\n",
- "#close the plot\n",
- "plt.close(fig)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "And that's all for this tutorial! If you have any problems, just ask (or even Google) them. You can check out the official Python tutorials for further learning.\n",
- "\n",
- "https://docs.python.org/3/tutorial/"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.8.10"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/Exercises/02-numpy/.ipynb_checkpoints/numpy_basics-checkpoint.ipynb b/Exercises/02-numpy/.ipynb_checkpoints/numpy_basics-checkpoint.ipynb
deleted file mode 100644
index 45544f5..0000000
--- a/Exercises/02-numpy/.ipynb_checkpoints/numpy_basics-checkpoint.ipynb
+++ /dev/null
@@ -1,1316 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# NumPy Basics"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "![\"slicing\"](\"images/slicing.png\")
"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Create a 2D array, which will be used in the following cells, an print it out.\n",
- "x = np.arange(1, 31).reshape((5, 6))\n",
- "print(f'Array x:\\n{x}\\n')\n",
- "\n",
- "# Access 3 elements in the 1st row.\n",
- "orange = x[0, 2:5]\n",
- "print(f'orange:\\n{orange}\\n')\n",
- "\n",
- "# Access the third column.\n",
- "red = x[:, 2]\n",
- "print(f'red:\\n{red}\\n')\n",
- "\n",
- "# Access a 2x2 submatrix form the bottom right corner.\n",
- "green = x[-2:, -2:]\n",
- "print(f'green:\\n{green}\\n')\n",
- "\n",
- "# Access elements from even indices starting from the 3rd row.\n",
- "magenta = x[2::2, ::2]\n",
- "print(f'magenta:\\n{magenta}\\n')\n",
- "\n",
- "# Replace last two rows with zeros.\n",
- "x[-2:, :] = 0\n",
- "print(x)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 3.2 Indexing by an Array of Indices.\n",
- "On top of standard indexing, NumPy also allows for providing a list of integer indices for every axis.\n",
- "\n",
- "![\"slicing\"](\"images/indexing_by_array.png\")
"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Create a 2D array, which will be used in the following cells, an print it out.\n",
- "x = np.arange(1, 31).reshape((5, 6))\n",
- "print(f'Array x:\\n{x}\\n')\n",
- "\n",
- "# Access the 2nd, the 4th and the 5th columns.\n",
- "red = x[:, [1, 3, 4]]\n",
- "print(f'red:\\n{red}\\n')\n",
- "\n",
- "# Access the elements from the 2nd and the 3rd rows in a zig-zag fashion.\n",
- "magenta = x[[1, 2, 1, 2], range(4)]\n",
- "print(f'magenta:\\n{magenta}\\n')\n",
- "\n",
- "# Replace the violet elemenets with a value -1.\n",
- "x[[1, 2, 1, 2], range(4)] = -1\n",
- "print(x)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 3.3 Masking\n",
- "We have seen indexing using arrays of integers, where the integer numbers pointed to given elements. Another approach is indexing using boolean arrays representing a binary mask. Such a mask must have the same shape as indexed array, or it must match along the first dimensions (where the last dimensions are taken as is). A mask array can only contain boolean values ``True`` and ``False``, otherwise it would be interpreted as indexing by an integer array.\n",
- "\n",
- "Masking can be combined with traditional indexing/slicing and indexing using integer arrays. However, the mask must have the same shape as that dimension(s) for which we are using the mask.\n",
- "\n",
- "Masking is especially useful when you want to access those elements in an array which satisfy certain condition. E.g. You might want to access all the elements bigger then a given threshold. Comparison operators (`<`, `>`, `==`, `>=`, `<=`) and other NumPy functions can be used to compare an array to a given value and get a binary mask.\n",
- "\n",
- "![\"slicing\"](\"images/masking.png\")
"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Create a 2D array, which will be used in the following cells, an print it out.\n",
- "x = np.arange(1, 31).reshape((5, 6))\n",
- "print(f'Array x:\\n{x}\\n')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Creating the mask manually.\n",
- "# Create a mask corresponding to the red squares.\n",
- "mask = np.zeros((5, 6), dtype=bool)\n",
- "mask[0, 1:4] = True\n",
- "mask[2, 2] = True\n",
- "mask[3, :2] = True\n",
- "mask[-1, -2:] = True\n",
- "print(f'mask:\\n{mask}\\n')\n",
- "\n",
- "# Select the values using a mask\n",
- "red = x[mask]\n",
- "print(f'red:\\n{red}\\n')\n",
- "\n",
- "# Combining traditional indexing/slicing and masking - select the green\n",
- "# columns. Not that the mask is a 1D array whose size is the\n",
- "# same as the size of the corresponding dimension of the original \n",
- "# array `x`.\n",
- "mask = np.array([True, False, False, False, False, True])\n",
- "green = x[:, mask]\n",
- "print(f'green:\\n{green}\\n')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Creating the mask using comparison operators.\n",
- "\n",
- "# Extract the values larger than 26.\n",
- "mask = x > 26\n",
- "sel = x[mask]\n",
- "print(f'mask:\\n{mask}\\n')\n",
- "print(f'bigger than 26:\\n{sel}\\n')\n",
- "\n",
- "# Extract the odd values.\n",
- "mask = (x % 2) == 1\n",
- "sel = x[mask]\n",
- "print(f'mask:\\n{mask}\\n')\n",
- "print(f'odd:\\n{sel}\\n')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 3.4 Structural Indexing\n",
- "Finally, NumPy introduces an object ``np.newaxis`` and an *ellipsis* syntax to facilitate indexing/reshaping.\n",
- "\n",
- "``np.newaxis`` can be used within square brackets to create a new empty axis. E.g. if we have a 1D array of E elements and we want to make it a column vector explicitly, i.e. a matrix with E rows and 1 column, ``np.newaxis`` object comes in handy. (Note that ``np.newaxis`` is in fact defined as ``None``, therefore you can use ``None`` instead.)\n",
- "\n",
- "```python\n",
- ">>> col_vec = np.array([1, 2, 3])\n",
- ">>> col_vec.shape\n",
- " (3, )\n",
- ">>> col_vec = col_vec[:, np.newaxis] # or col_vec[:, None]\n",
- ">>> col_vec.shape\n",
- " (3, 1)\n",
- "```\n",
- "\n",
- "``ellipsis`` operator ``...`` stands for \"as many as needed\" consecutive symbols ``:`` used when slicing a multidimensional array.\n",
- "\n",
- "```python\n",
- ">>> x = np.ones((3, 4, 5, 6))\n",
- ">>> x.shape\n",
- " (3, 4, 5, 6)\n",
- ">>> a = x[0, :, :, 3]\n",
- ">>> b = x[0, ..., 3]\n",
- ">>> np.allclose(a, b)\n",
- "```"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 3.5 Exercises\n",
- "\n",
- "Using only standard indexing/slicing, extract the subarrays as depicted in the Figure below.\n",
- "\n",
- "![\"slicing\"](\"images/slicing_ex.png\")
"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Using _only_ standard indexing and slicing, select the red, blue and green \n",
- "# subarrays from the 3D array depicted above.\n",
- "\n",
- "# Create a 2D array and print it out.\n",
- "x = np.arange(1, 31).reshape((5, 6))\n",
- "print(f'Array x:\\n{x}\\n')\n",
- "\n",
- "# Select the subarrays\n",
- "\n",
- "red = None # <<< YOUR CODE HERE\n",
- "print(f'red:\\n{red}\\n')\n",
- "\n",
- "green = None # <<< YOUR CODE HERE\n",
- "print(f'green:\\n{green}\\n')\n",
- "\n",
- "blue = None # <<< YOUR CODE HERE\n",
- "print(f'blue:\\n{blue}\\n')\n",
- "\n",
- "# Bonus: Come up with indexing which selects from x the following submatrix:\n",
- "# [[29, 28], \n",
- "# [11, 10]].\n",
- "\n",
- "bonus = None # <<< YOUR CODE HERE\n",
- "print(f'bonus:\\n{bonus}\\n')\n",
- "\n",
- "# Check the results:\n",
- "assert(np.allclose(red, np.array([[1, 6], [7, 12], [13, 18], [19, 24], [25, 30]])))\n",
- "assert(np.allclose(green, np.array([15, 16, 17])))\n",
- "assert(np.allclose(blue, np.array([[2, 3], [14, 15], [26, 27]])))\n",
- "assert(np.allclose(bonus, np.array([[29, 28], [11, 10]])))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We will move forward with the exercise session for now, but there are more exercises about indexing using list of indices and masking at the end of the exercise. We encourage you to do them all when you get to the end, as these concepts will keep reocurring in the upcoming exercises."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 4 Iterating\n",
- "\n",
- "An N dimensional array can be expressed as a list of N-1 dimensional arrays. \n",
- "\n",
- "For instance, a (2D) matrix ``x = np.ones((2, 3))`` can be thought of as a list of (1D) vectors of lenght 3. As you have seen in Section 3.1, we can access, say, the 2nd row as ``x[1, :]`` which is, however, equivalent to ``x[1]`` (i.e. omitting the ``:`` symbol referring to \"all the values in this dimension\").\n",
- "\n",
- "Similarly, a 3D array ``x = np.ones((4, 2, 3))`` can be thought of as a list of (2D) matrices of shape (2, 3). Again, we can access, say, the 1st matrix as ``x[0, :, :]``, which is equivalent to ``x[0]``.\n",
- "\n",
- "You have seen how to iterate through an array (Python list) using ``for``-loop or ``while``-loop in the exercise 1. You can use the same strategy with NumPy arrays as well. I.e. treat an N dimensional array as a list of N-1 dimensional arrays.\n",
- "\n",
- "Note that for many operations it is preferable _not_ to use an explicit ``for`` or ``while`` loop as the same computation can be usually achieved orders of magnitude faster using so called **vectorization** which will be introduced later. However, explicit iteration still comes in handy at times so it is useful to know how to use it."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Let us create a 3D array, iterate through it's slices, i.e. matrices, and \n",
- "# find the trace of every matrix.\n",
- "x = np.random.uniform(0, 10, (5, 10, 10))\n",
- "\n",
- "for i, matrix in enumerate(x):\n",
- " print(f'Trace of matrix {i}: {np.trace(matrix)}')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 5 Concatenating, Stacking, Splitting\n",
- "\n",
- "Arrays can be **concatenated** (i.e. glueing the arrays while keeping the number of dimensions) and **stacked** (gluing the arrays along a newly created dimension). **Splitting** is the counterpart operation to concatenating.\n",
- "\n",
- "All of the **concatenated** arrays must have the same shape along all the dimensions except the one along which we concatenate. E.g. we can stack two matrices of shapes (4, 2) and (4, 5) along *axis 1* to get a new matrix of shape (4, 7).\n",
- "\n",
- "All of the **stacked** arrays must have exactly the same shape, the size of the newly created dimensions correspond to the number of stacked arrays. E.g. we can stack 2 matrices of shapes (4, 3) and (4, 3) along the newly created dimension *axis 0* to get a 3D array of shape (2, 4, 3).\n",
- "\n",
- "The axis for concatenation or stacing is specified using an argument ``axis``.\n",
- "\n",
- "See the examples below."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Concatenating.\n",
- "\n",
- "# Concatenate a couple of matrices vertically.\n",
- "m1 = np.array([[1, 2, 3], [4, 5, 6]])\n",
- "m2 = np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]])\n",
- "m3 = np.array([[100, 200, 300]])\n",
- "m_cat = np.concatenate([m1, m2, m3], axis=0)\n",
- "print(m_cat)\n",
- "\n",
- "m_cat_error = np.concatenate([m1, m2, m3], axis=1) # This will fail, study the error message."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Stacking\n",
- "\n",
- "# Stack a couple of matrices to create a 3D array.\n",
- "m1 = np.array([[1, 2], [4, 5]])\n",
- "m2 = np.array([[10, 20], [40, 50]])\n",
- "m3 = np.array([[100, 200], [400, 500]])\n",
- "\n",
- "# We can stack along any of axes 0, 1, 2. Stacking along different\n",
- "# axis results in \"rotating\" our newly created 3D cube.\n",
- "m_stack_0 = np.stack([m1, m2, m3], axis=0)\n",
- "m_stack_1 = np.stack([m1, m2, m3], axis=1)\n",
- "m_stack_2 = np.stack([m1, m2, m3], axis=2)\n",
- "\n",
- "print(m_stack_0.shape)\n",
- "print(m_stack_1.shape)\n",
- "print(m_stack_2.shape)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 5.1 Exercises\n",
- "\n",
- "Study the documentation for function [``np.split`` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.split.html) and use it to solve the following exercise."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "## Create a 3D array of increasing sequence of even numbers (starting from 0) of shape (10, 5, 7).\n",
- "\n",
- "x = None # <<< YOUR CODE HERE\n",
- "print(f'x:\\n{x}\\n')\n",
- "\n",
- "## Split the array into 5 arrays each of the shape (2, 5, 7)\n",
- "\n",
- "splits_5 = None # <<< YOUR CODE HERE\n",
- "\n",
- "## Split the array into 2 arrays of shapes (10, 2, 7) and (10, 3, 7)\n",
- "\n",
- "splits_2 = None # <<< YOUR CODE HERE\n",
- "\n",
- "# Check the answers.\n",
- "assert((np.unique(x).size == 10 * 5 * 7) and np.all(x % 2 == 0) and np.min(x) == 0 and np.max(x) == 698)\n",
- "assert(len(splits_5) == 5 and np.allclose(np.concatenate(splits_5, axis=0), x))\n",
- "assert(len(splits_2) == 2 and np.allclose(np.concatenate(splits_2, axis=1), x))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 6 Basic Arithmetic Operators, Linear Algebra\n",
- "\n",
- "Basic arithmetic operators `+`, `-`, `*`, `/`, `//`, `**`, `%` are applied element-wise as long as one of the operands is a scalar or both operands are arrays of the same shape. If the two arrays are not the same shape, **broadcasting** will be applied (see Section 7 Broadcasting).\n",
- "\n",
- "Here are the most common linear algebra operators which you will mostly use for vectors (1D arrays) and matrices (2D arrays):\n",
- "- `np.matmul` - Scalar product, vector-matrix or matrix-matrix multiplication (very similar to `np.dot`, read more about it [here](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html)).\n",
- "- `@` - The same as `np.matmul`, syntactic sugar.\n",
- "- [`np.linalg.inv`( documentation)](https://numpy.org/doc/stable/reference/generated/numpy.linalg.inv.html) - Matrix inversion.\n",
- "- [`np.linalg.norm` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.linalg.norm.html) - Norm computation (L2 norm by default).\n",
- "- [`np.linalg.solve` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.linalg.solve.html) - Numerically stable solution to a system of linear equations given as Ax = b.\n",
- "- `x.T` - Transposition.\n",
- "\n",
- "See the examples below."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Arithmetic operations.\n",
- "\n",
- "# When used for scalar and array operands, the scalar is applied to every element of an array regardless of its shape.\n",
- "x = np.zeros((2, 2))\n",
- "print(f'x:\\n{x}\\n')\n",
- "x += 1\n",
- "print(f'x + 1:\\n{x}\\n')\n",
- "\n",
- "# When used for two array operands, the operator is applies to their corresponding values pair-wise.\n",
- "x1 = np.arange(10).reshape((2, 5))\n",
- "x2 = np.zeros((2, 5))\n",
- "print(f'x1:\\n{x1}\\n')\n",
- "print(f'x1:\\n{x2}\\n')\n",
- "x2min1 = x2 - x1\n",
- "print(f'x2 - x1:\\n{x2min1}\\n')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Linear algebra.\n",
- "\n",
- "## Dot product of two orthogonal vectors.\n",
- "v1 = np.array([0.0893, 0.9332, 0.3481])\n",
- "v2 = np.array([-0.6949, -0.1920, 0.6930])\n",
- "v_dot = np.dot(v1, v2)\n",
- "\n",
- "# If they are orthogonal, their dot product should be close to 0.\n",
- "print('v1 and v2 are orthogonal: {}'.format(\n",
- " ('FALSE', 'TRUE')[int(np.isclose(v_dot, 0., atol=1e-5))]))\n",
- "\n",
- "## Matrix multiplication.\n",
- "m1 = np.eye(3)\n",
- "m2 = np.random.uniform(-10., 10., (3, 8))\n",
- "m_mult = m1 @ m2\n",
- "\n",
- "# m1 is an identity matrix, therefore the matrix multiplication with \n",
- "# any matrix M will produce the same matrix M.\n",
- "print('m_mult is the same as m2: {}'.format(\n",
- " ('FALSE', 'TRUE')[np.allclose(m2, m_mult)]))\n",
- "\n",
- "## Solve a linear system Ax = b.\n",
- "# All the coefficients are random so it is extremely unlikely that we would\n",
- "# generate a rank deficient matrix A and therefore the system of linear\n",
- "# equations will have a solution.\n",
- "A = np.random.uniform(-1., 1., (10, 10))\n",
- "b = np.random.uniform(-1., 1., (10, ))\n",
- "x = np.linalg.solve(A, b)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 6.1 Exercises"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "## Generate a matrix of shape (100, 100) filled with Euler's number. You cannot use np.full.\n",
- "\n",
- "eul = None # <<< YOUR CODE HERE\n",
- "print(f'eul:\\n{eul}\\n')\n",
- "\n",
- "## Generate a 1D array of length 10 of powers of 2, i.e. [2^0, 2^1, ..., 2^9]\n",
- "\n",
- "pows = None # <<< YOUR CODE HERE\n",
- "print(f'pows:\\n{pows}\\n')\n",
- "\n",
- "## Check the answers:\n",
- "assert(np.allclose(eul, np.stack([[2.71828182] * 100] * 100, axis=0)))\n",
- "assert(np.allclose(pows, [2**0, 2**1, 2**2, 2**3, 2**4, 2**5, 2**6, 2**7, 2**8, 2**9]))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Helper function to print an arrow.\n",
- "def plot_arrow(pts, clr):\n",
- " plt.plot(*pts[:2].T, color=clr, marker='*')\n",
- " plt.plot(*pts[1:3].T, color=clr, marker='*')\n",
- " plt.plot(*pts[[1, 3], :].T, color=clr, marker='*')\n",
- "\n",
- "## The array 'arrow' contains 4 2D points defining a blue arrow. The objective\n",
- "## is to make the arrow 2 times shorter and thinner and rotate it by 45 degrees \n",
- "## counter-clockwise. \n",
- "## First you will rotate the arrow by multiplying the points with the rotation \n",
- "## matrix, where the rotation matrix stands on the left.\n",
- "## Then, you will scale the arrow by multiplying the previous result with the scale matrix\n",
- "## where the scale matrix stands on the left.\n",
- "\n",
- "## Hint: You will need to do some transpose operations.\n",
- "\n",
- "arrow = np.array([[ 0., 0.,], \n",
- " [ 0., 2.], \n",
- " [-0.5, 1.5], \n",
- " [ 0.5, 1.5]])\n",
- "angle = np.pi / 4.\n",
- "\n",
- "rot = np.array([[np.cos(angle), -np.sin(angle)], \n",
- " [np.sin(angle), np.cos(angle)]])\n",
- "\n",
- "scale = np.array([[0.5, 0.], \n",
- " [0., 0.5]])\n",
- "\n",
- "arrow_sr = None # <<< YOUR CODE HERE\n",
- "\n",
- "# Plot the arrows.\n",
- "plt.figure(figsize=(5, 5))\n",
- "plt.xlim(-3, 3)\n",
- "plt.ylim(-3, 3)\n",
- "plot_arrow(arrow, 'b')\n",
- "plot_arrow(arrow_sr, 'r')\n",
- "\n",
- "## Check the answers.\n",
- "assert(np.allclose(arrow_sr, np.array([[ 0. , 0. ],\n",
- " [-0.70710678, 0.70710678],\n",
- " [-0.70710678, 0.35355339],\n",
- " [-0.35355339, 0.70710678]])))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 7 Broadcasting\n",
- "\n",
- "Broadcasting allows for performing arithmetic and other operations on arrays of different shape, where the smaller is \"broadcast\" over the larger array. For instance, adding a column vector *v* to a matrix *M*, M + v, will effectively take every column of the matrix and add the vector *v* element-wise.\n",
- "\n",
- "Broadcasting further allows for so called **vectorization**, i.e. performing a given operation in parallel where the actual looping occurs in highly-optimized C code rather than in Python, where looping is slow.\n",
- "\n",
- "Example:\n",
- "\n",
- "```python\n",
- ">>> a = np.arange(6).reshape((2, 3)) # shape (2, 3)\n",
- "array([[0, 1, 2],\n",
- " [3, 4, 5]])\n",
- "\n",
- ">>> b = np.array([10, 20, 30]) # shape (3, )\n",
- "array([10, 20, 30])\n",
- "\n",
- ">>> a + b\n",
- "array([[10, 21, 32],\n",
- " [13, 24, 35]]) # shape (2, 3)\n",
- "```\n",
- "\n",
- "### 7.1 Broadcasting Rules\n",
- "\n",
- "The corresponding dimensions of the 2 arrays must satisfy one of the following:\n",
- "- Have the same dimensions.\n",
- "- One of the dimensions is 1.\n",
- "\n",
- "Furthermore, non-existent dimensions are treated as 1.\n",
- "\n",
- "Here are a couple of examples of the input and output shapes to a binary operation (such as `+`) being applied on 2 arrays *A* and *B*:\n",
- "\n",
- "
\n",
- "\n",
- "**Note:** Do not confuse the concept of _vectorization_ with NumPy's function `np.vectorize`, which is provided for programming convenience, not for performance and thus does not guranatee the actual vectorization of an operation.\n",
- "\n",
- "If the concept is not clear, you can read more about broadcasting [here](https://numpy.org/devdocs/user/basics.broadcasting.html).\n",
- "\n",
- "Go through the examples below and try to understand how the arrays are constructed and computed."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "## Manual Python looping vs. vectorization - Multiplying a \n",
- "# matrix by a vector row-wise.\n",
- "m = np.arange(15).reshape(5, 3)\n",
- "v = np.array([0, 4, 2])\n",
- "m_loop = np.copy(m)\n",
- "m_vect = np.copy(m)\n",
- "\n",
- "# Python loop.\n",
- "for i in range(m.shape[0]):\n",
- " m_loop[i] *= v\n",
- "\n",
- "# Vectorization.\n",
- "m_vect *= v\n",
- "\n",
- "# Check that both results are the same.\n",
- "assert(np.allclose(m_loop, m_vect))\n",
- "\n",
- "## Generate a matrix where each row holds a constant value \n",
- "## which increases throughout the rows.\n",
- "seq_mat = np.ones((5, 3)) * np.arange(5).reshape((-1, 1))\n",
- "print(f'seq_mat:\\n{seq_mat}\\n')\n",
- "\n",
- "m = np.random.randint(0, 10, (4, 5))\n",
- "print(f'm:\\n{m}\\n')\n",
- "\n",
- "## Add a vector to a matrix row-wise (horizontally).\n",
- "add_rw = np.array([10, 20, 30, 40, 50])\n",
- "m_add_rw = m + add_rw\n",
- "print(f'm_add_rw:\\n{m_add_rw}\\n')\n",
- "\n",
- "## Add a vector to a matrix column-wise (vertically).\n",
- "add_cw = np.array([10, 20, 30, 40]).reshape((-1, 1))\n",
- "m_add_cw = m + add_cw\n",
- "print(f'm_add_cw:\\n{m_add_cw}\\n')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 7.2 Exercises"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "## Given a matrix 'data' defined below, Compute a matrix data_pow, \n",
- "## where a value in each column is taken to the power of its column\n",
- "## index.\n",
- "\n",
- "data = np.random.uniform(0, 5, (4, 5))\n",
- "data_pow = None # <<< YOUR CODE HERE\n",
- "print(f'data_pow:\\n{data_pow}\\n')\n",
- "\n",
- "## Generate a matrix of shape (5, 4), where each row is an integer \n",
- "## sequence starting from 0 with an increment of a row index i. E.g.\n",
- "## the first 3 rows would be:\n",
- "##\n",
- "## [0*0, 0*0, 0*0, 0*0] [0, 0, 0, 0]\n",
- "## [0*1, 1*1, 2*1, 3*1] = [0, 1, 2, 3]\n",
- "## [0*2, 1*2, 2*2, 3*2] [0, 2, 4, 6]\n",
- "##\n",
- "## You can use 1D arrays only and the rules of broadcasting.\n",
- "# Hint: Use np.arange\n",
- "\n",
- "seqs = None # <<< YOUR CODE HERE\n",
- "print(f'seqs:\\n{seqs}\\n')\n",
- "\n",
- "## Check the results:\n",
- "data_pow_gt = np.copy(data)\n",
- "for i in range(data.shape[1]):\n",
- " data_pow_gt[:, i] = data_pow_gt[:, i] ** i\n",
- "assert(np.allclose(data_pow, data_pow_gt))\n",
- "assert(np.allclose(seqs, np.array([[ 0, 0, 0, 0],\n",
- " [ 0, 1, 2, 3],\n",
- " [ 0, 2, 4, 6],\n",
- " [ 0, 3, 6, 9],\n",
- " [ 0, 4, 8, 12]])))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 8 Common NumPy Functions\n",
- "\n",
- "NumPy offers plethora of functions to perform computations with N dimensional arrays. One of the common concepts is that these functions would accept an argument `axis` using which you can specify along which axis the operation should be performed. \n",
- "\n",
- "For example, given a matrix `A = np.array([[1, 2, 3], [4, 5, 6]])`, we might want to find a sum of values over rows and columns:\n",
- "\n",
- "
\n",
- "\n",
- "```python\n",
- ">>> sum_per_row = np.sum(A, axis=1)\n",
- "array([6, 15])\n",
- "\n",
- ">>> sum_per_col = np.sum(A, axis=0)\n",
- "array([5, 7, 9])\n",
- "```\n",
- "\n",
- "Among the most common functions you might need the following: \n",
- "- [`np.sum` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.sum.html)\n",
- "- [`np.prod` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.prod.html) \n",
- "- [`np.mean` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.mean.html)\n",
- "- [`np.std` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.std.html)\n",
- "- `np.min`\n",
- "- `np.max`\n",
- "- [`np.argmin` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.argmin.html)\n",
- "- [`np.argmax` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.argmax.html)\n",
- "- [`np.sort` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.sort.html)\n",
- "- `np.abs` \n",
- "- [`np.sqrt` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.sqrt.html)\n",
- "- [`np.unravel_index` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.unravel_index.html).\n",
- "\n",
- "Please study their corresponding reference pages and fill in the following exercises."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 8.1 (OPTIONAL) Exercises"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "## Given a matrix M, find the product of the values in each row.\n",
- "M = np.arange(12).reshape((4, 3))\n",
- "\n",
- "sm = None # <<< YOUR CODE HERE\n",
- "\n",
- "# Check the results.\n",
- "assert(np.allclose(sm, np.array([0, 60, 336, 990])))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Write a function `rescale` which takes as input an array $x \\in \\mathbb R ^ {N \\times M}$ and scalars $a np.ndarray:\n",
- " \"\"\" Rescales the input from range [min(x), max(x)] to range [a, b].\n",
- " \n",
- " Args:\n",
- " x (np.ndarray): Input array, shape (N, M).\n",
- " a (float): Lower bound of the output range.\n",
- " b (float): Upper bound of the output range.\n",
- " \n",
- " Returns:\n",
- " np.ndarray: Rescaled array, shape (N, M).\n",
- " \"\"\"\n",
- " y = None # <<< YOUR CODE HERE\n",
- "\n",
- " return y\n",
- "\n",
- "# Test.\n",
- "x = 2 * np.random.rand(3, 2) - 1\n",
- "a, b = 1, 3\n",
- "y = rescale(x, a, b)\n",
- "\n",
- "assert(np.isclose(np.min(y), a) and np.isclose(np.max(y), b))\n",
- "\n",
- "print(f'Input array:\\n{x}\\n')\n",
- "print(f'Required range: {a, b}\\n')\n",
- "print(f'Output array:\\n{y}\\n')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Write function `find_closest`, which given scalar $u \\in \\mathbb R$ and input array $x \\in \\mathbb R ^ {N \\times M}$, returns the closest element to the scalar in the array $x_{i^*,j^*} : (i^*,j^*)=\\text{argmin}_{i,j} | x_{i,j} - u |$. $\\text{argmin}$ is the operation that finds the index of the minimum element.\n",
- "\n",
- "Hint: Use `np.abs`, [`np.argmin` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.argmin.html), [`np.unravel_index` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.unravel_index.html)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def find_closest(x: np.ndarray, u: float) -> float:\n",
- " \"\"\" Finds the closest element to `u` in `x`.\n",
- " \n",
- " Args:\n",
- " x (np.ndarray): Input array, shape (N, M).\n",
- " u (float): A value to which the closest element in x is searched for.\n",
- " \n",
- " Returns:\n",
- " float: Closest element in `x` to `u`.\n",
- " \"\"\"\n",
- " closest = None # <<< YOUR CODE HERE\n",
- "\n",
- " return closest\n",
- "\n",
- "# Test.\n",
- "x = np.arange(11)\n",
- "u = np.random.uniform(0, 10)\n",
- "x_ij = find_closest(x, u)\n",
- "\n",
- "assert(x_ij == x[int(round(u))] )\n",
- "\n",
- "print(f'The closest element to {u:.3f} within {x} is {x_ij}')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Write a function `z_score_normalize` which takes as input an array $x \\in \\mathbb R ^ {N \\times M}$ and returns an output array $y \\in \\mathbb R ^ {N \\times M}$ such that $\\mathbb E [y]= 0$ and $\\sigma [y] = 1$, where $\\sigma[y]$ is a standard deviation of $y$.\n",
- "\n",
- "Hint: Use [`np.mean` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.mean.html) [`np.std` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.std.html)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def z_score_normalize(x: np.ndarray) -> np.ndarray:\n",
- " \"\"\" Normalizes the input x so that its mean is 0 and std is 1.\n",
- " \n",
- " Args:\n",
- " x (np.ndarray): Input array, shape (N, M).\n",
- " \n",
- " Returns:\n",
- " np.ndarray: Normalized array, shape (N, M).\n",
- " \"\"\"\n",
- " normalized = None # <<< YOUR CODE HERE\n",
- " \n",
- " return normalized\n",
- "\n",
- "# Test.\n",
- "x = 2 * np.random.rand(3, 2) - 1\n",
- "y = z_score_normalize(x)\n",
- "\n",
- "assert(np.isclose(np.mean(y), 0))\n",
- "assert(np.isclose(np.std(y), 1.))\n",
- "\n",
- "print(f'Mean/std for input array\\n{x}\\nis: {np.mean(x):.3f}/{np.std(x):.3f}\\n')\n",
- "print(f'Mean/std for normalized array\\n{y} is:\\n{np.mean(y):.3f}/{np.std(y):.3f}')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 9 Shallow and Deep Copy\n",
- "\n",
- "A simple assignment makes no copy of the underlying data, have a look at the following example:\n",
- "\n",
- "```python\n",
- ">>> a = np.array([1., 2., 3.])\n",
- ">>> b = a\n",
- ">>> b[1] = 1.602e-19\n",
- ">>> print(a, b)\n",
- "array([1, 1.602e-19, 3])\n",
- "array([1, 1.602e-19, 3])\n",
- "```\n",
- "\n",
- "Assigning a slice of an array to a new array works with the very same data as well, i.e. no copy is made:\n",
- "\n",
- "```python\n",
- ">>> a = np.array([1., 2., 3.])\n",
- ">>> b = a[:2]\n",
- ">>> b[0] = 6.626e-34\n",
- ">>> print(a, b)\n",
- "array([6.626e-34, 2, 3])\n",
- "array([6.626e-34, 2])\n",
- "```\n",
- "\n",
- "In order to truly copy the data, we need to make a deep copy using the NumPy function [`np.copy` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.copy.html):\n",
- "\n",
- "```python\n",
- ">>> a = np.array([1., 2., 3.])\n",
- ">>> b = a.copy()\n",
- ">>> b[2] = 9.807\n",
- ">>> print(a, b)\n",
- "array([1, 2, 3])\n",
- "array([2, 2, 9.807])\n",
- "```\n",
- "\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 10 Random\n",
- "\n",
- "The module [`np.random` (documentation)](https://numpy.org/doc/stable/reference/random/index.html) implements pseudo-random number generators (RNG) for various distributions. We will frequently use it to randomly sample our data or to randomly initialize the parameters of our models.\n",
- "\n",
- "In order to fix the RNG and thus to be able to reproduce the computation, we can set the so called *seed*. Setting the seed guarantees that the same sequence of numbers will be generated by the RNG in each run.\n",
- "\n",
- "```python\n",
- ">>> constant = 3 # Any we want\n",
- ">>> np.random.seed(constant)\n",
- "```\n",
- "\n",
- "Here are some of the functions we will be using most frequently:\n",
- "- np.random.randint\n",
- "- np.random.shuffle\n",
- "- np.random.uniform\n",
- "- np.random.randn\n",
- "- np.random.permutation\n",
- "\n",
- "Please study their respective [reference pages](https://docs.scipy.org/doc/numpy-1.16.0/reference/routines.random.html) and complete the exercises below."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 10.1 (OPTIONAL) Exercises"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "## Create a 1D array of randomly permuted sequence from 0 to 10.\n",
- "x_perm = None # <<< YOUR CODE HERE\n",
- "print(f'Permuted array:\\n{x_perm}\\n')\n",
- "\n",
- "## Check the answers.\n",
- "assert(np.unique(x_perm).shape == (11, ) and np.min(x_perm) == 0 and np.max(x_perm) == 10)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 11 (OPTIONAL) Extra Indexing Exercises"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Using indexing by integer arrays, extract the subarrays as depicted in the Figure below.\n",
- "\n",
- "![\"slicing\"](\"images/indexing_by_array_ex.png\")
"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Using a combination of standard indexing/slicing and an indexing by an array \n",
- "# of indices, select the following subarrays.\n",
- "\n",
- "# Create a 2D array an print it out.\n",
- "x = np.arange(1, 31).reshape((5, 6))\n",
- "print(f'Array x:\\n{x}\\n')\n",
- "\n",
- "# Select the subarrays.\n",
- "\n",
- "red = None # <<< YOUR CODE HERE\n",
- "print(f'red:\\n{red}\\n')\n",
- "\n",
- "green = None # <<< YOUR CODE HERE\n",
- "print(f'green:\\n{green}\\n')\n",
- "\n",
- "blue = None # <<< YOUR CODE HERE\n",
- "print(f'blue:\\n{blue}\\n')\n",
- "\n",
- "# Bonus: Come up with indexing which results in matrix `x` being stacked 3 times \n",
- "# horizontally, i.e. the resulting shape is (15, 6).\n",
- "# Hint: Use functions range and list, use operator * with a list.\n",
- "\n",
- "bonus = None # <<< YOUR CODE HERE\n",
- "print(f'bonus:\\n{bonus}\\n')\n",
- "\n",
- "# Check the results:\n",
- "assert(np.allclose(red, np.arange(1, 30, 7)))\n",
- "assert(np.allclose(green, np.array([[5, 6], [11, 12], [23, 24]])))\n",
- "assert(np.allclose(blue, np.array([19, 25, 26])))\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Using masking, extract the subarray as depicted in the Figure below.\n",
- "\n",
- "![\"slicing\"](\"images/masking_ex.png\")
"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Construct a mask and then extract the red values above the main diagonal.\n",
- "\n",
- "## Extract the red values.\n",
- "mask = None # <<< YOUR CODE HERE\n",
- "print(f'mask:\\n{mask}\\n')\n",
- "\n",
- "red = None # <<< YOUR CODE HERE\n",
- "print(f'red:\\n{red}\\n')\n",
- "\n",
- "## Bonus: Extract all the values, which are not red.\n",
- "## Hint: Use your already constructed `mask`, study NumPy's binary operations\n",
- "## https://docs.scipy.org/doc/numpy/reference/routines.bitwise.html\n",
- "\n",
- "the_rest = None # <<< YOUR CODE HERE\n",
- "print(f'the_rest:\\n{the_rest}\\n')\n",
- "\n",
- "## Bonus2: Extract the values which can be divided by both 2 and 3.\n",
- "## Hint: Construct two masks and combine them using NumPy's binary operators.\n",
- "\n",
- "div23 = None # <<< YOUR CODE HERE\n",
- "print(f'div23:\\n{div23}\\n')\n",
- "\n",
- "# Check the results:\n",
- "assert(np.allclose(red, np.concatenate(\n",
- " [range(2, 7), range(9, 13), range(16, 19), range(23, 25), [30]])))\n",
- "assert(np.allclose(np.sort(np.concatenate([red, the_rest])), np.arange(1, 31)))\n",
- "assert(not np.any(np.fmod(div23, 2.)) and not np.any(np.fmod(div23, 3.)))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 12 Next Steps\n",
- "\n",
- "Feel free to consult more thorough NumPy tutorials.\n",
- "\n",
- "- NumPy basics: [https://docs.scipy.org/doc/numpy/user/basics.html](https://docs.scipy.org/doc/numpy/user/basics.html)\n",
- "- Official NumPy tutorial: [https://docs.scipy.org/doc/numpy/user/quickstart.html](https://docs.scipy.org/doc/numpy/user/quickstart.html)"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.8.10"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/Exercises/02-numpy/.ipynb_checkpoints/numpy_basics_Sol-checkpoint.ipynb b/Exercises/02-numpy/.ipynb_checkpoints/numpy_basics_Sol-checkpoint.ipynb
deleted file mode 100644
index 1f40a1a..0000000
--- a/Exercises/02-numpy/.ipynb_checkpoints/numpy_basics_Sol-checkpoint.ipynb
+++ /dev/null
@@ -1,1308 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# NumPy Basics - Solutions"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- ""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Create a 2D array, which will be used in the following cells, an print it out.\n",
- "x = np.arange(1, 31).reshape((5, 6))\n",
- "print(f'Array x:\\n{x}\\n')\n",
- "\n",
- "# Access 3 elements in the 1st row.\n",
- "orange = x[0, 2:5]\n",
- "print(f'orange:\\n{orange}\\n')\n",
- "\n",
- "# Access the third column.\n",
- "red = x[:, 2]\n",
- "print(f'red:\\n{red}\\n')\n",
- "\n",
- "# Access a 2x2 submatrix form the bottom right corner.\n",
- "green = x[-2:, -2:]\n",
- "print(f'green:\\n{green}\\n')\n",
- "\n",
- "# Access elements from even indices starting from the 3rd row.\n",
- "magenta = x[2::2, ::2]\n",
- "print(f'magenta:\\n{magenta}\\n')\n",
- "\n",
- "# Replace last two rows with zeros.\n",
- "x[-2:, :] = 0\n",
- "print(x)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 3.2 Indexing by an Array of Indices.\n",
- "On top of standard indexing, NumPy also allows for providing a list of integer indices for every axis.\n",
- "\n",
- ""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Create a 2D array, which will be used in the following cells, an print it out.\n",
- "x = np.arange(1, 31).reshape((5, 6))\n",
- "print(f'Array x:\\n{x}\\n')\n",
- "\n",
- "# Access the 2nd, the 4th and the 5th columns.\n",
- "red = x[:, [1, 3, 4]]\n",
- "print(f'red:\\n{red}\\n')\n",
- "\n",
- "# Access the elements from the 2nd and the 3rd rows in a zig-zag fashion.\n",
- "magenta = x[[1, 2, 1, 2], range(4)]\n",
- "print(f'magenta:\\n{magenta}\\n')\n",
- "\n",
- "# Replace the violet elemenets with a value -1.\n",
- "x[[1, 2, 1, 2], range(4)] = -1\n",
- "print(x)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 3.3 Masking\n",
- "We have seen indexing using arrays of integers, where the integer numbers pointed to given elements. Another approach is indexing using boolean arrays representing a binary mask. Such a mask must have the same shape as indexed array, or it must match along the first dimensions (where the last dimensions are taken as is). A mask array can only contain boolean values ``True`` and ``False``, otherwise it would be interpreted as indexing by an integer array.\n",
- "\n",
- "Masking can be combined with traditional indexing/slicing and indexing using integer arrays. However, the mask must have the same shape as that dimension(s) for which we are using the mask.\n",
- "\n",
- "Masking is especially useful when you want to access those elements in an array which satisfy certain condition. E.g. You might want to access all the elements bigger then a given threshold. Comparison operators (`<`, `>`, `==`, `>=`, `<=`) and other NumPy functions can be used to compare an array to a given value and get a binary mask.\n",
- "\n",
- ""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Create a 2D array, which will be used in the following cells, an print it out.\n",
- "x = np.arange(1, 31).reshape((5, 6))\n",
- "print(f'Array x:\\n{x}\\n')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Creating the mask manually.\n",
- "# Create a mask corresponding to the red squares.\n",
- "mask = np.zeros((5, 6), dtype=bool)\n",
- "mask[0, 1:4] = True\n",
- "mask[2, 2] = True\n",
- "mask[3, :2] = True\n",
- "mask[-1, -2:] = True\n",
- "print(f'mask:\\n{mask}\\n')\n",
- "\n",
- "# Select the values using a mask\n",
- "red = x[mask]\n",
- "print(f'red:\\n{red}\\n')\n",
- "\n",
- "# Combining traditional indexing/slicing and masking - select the green\n",
- "# columns. Not that the mask is a 1D array whose size is the\n",
- "# same as the size of the corresponding dimension of the original \n",
- "# array `x`.\n",
- "mask = np.array([True, False, False, False, False, True])\n",
- "green = x[:, mask]\n",
- "print(f'green:\\n{green}\\n')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Creating the mask using comparison operators.\n",
- "\n",
- "# Extract the values larger than 26.\n",
- "mask = x > 26\n",
- "sel = x[mask]\n",
- "print(f'mask:\\n{mask}\\n')\n",
- "print(f'bigger than 26:\\n{sel}\\n')\n",
- "\n",
- "# Extract the odd values.\n",
- "mask = (x % 2) == 1\n",
- "sel = x[mask]\n",
- "print(f'mask:\\n{mask}\\n')\n",
- "print(f'odd:\\n{sel}\\n')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 3.4 Structural Indexing\n",
- "Finally, NumPy introduces an object ``np.newaxis`` and an *ellipsis* syntax to facilitate indexing/reshaping.\n",
- "\n",
- "``np.newaxis`` can be used within square brackets to create a new empty axis. E.g. if we have a 1D array of E elements and we want to make it a column vector explicitly, i.e. a matrix with E rows and 1 column, ``np.newaxis`` object comes in handy. (Note that ``np.newaxis`` is in fact defined as ``None``, therefore you can use ``None`` instead.)\n",
- "\n",
- "```python\n",
- ">>> col_vec = np.array([1, 2, 3])\n",
- ">>> col_vec.shape\n",
- " (3, )\n",
- ">>> col_vec = col_vec[:, np.newaxis] # or col_vec[:, None]\n",
- ">>> col_vec.shape\n",
- " (3, 1)\n",
- "```\n",
- "\n",
- "``ellipsis`` operator ``...`` stands for \"as many as needed\" consecutive symbols ``:`` used when slicing a multidimensional array.\n",
- "\n",
- "```python\n",
- ">>> x = np.ones((3, 4, 5, 6))\n",
- ">>> x.shape\n",
- " (3, 4, 5, 6)\n",
- ">>> a = x[0, :, :, 3]\n",
- ">>> b = x[0, ..., 3]\n",
- ">>> np.allclose(a, b)\n",
- "```"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 3.5 Exercises\n",
- "\n",
- "Using only standard indexing/slicing, extract the subarrays as depicted in the Figure below.\n",
- "\n",
- ""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Using _only_ standard indexing and slicing, select the red, blue and green \n",
- "# subarrays from the 3D array depicted above.\n",
- "\n",
- "# Create a 2D array and print it out.\n",
- "x = np.arange(1, 31).reshape((5, 6))\n",
- "print(f'Array x:\\n{x}\\n')\n",
- "\n",
- "# Select the subarrays\n",
- "red = x[:, ::5]\n",
- "print(f'red:\\n{red}\\n')\n",
- "\n",
- "green = x[2, 2:5]\n",
- "print(f'green:\\n{green}\\n')\n",
- "\n",
- "blue = x[::2, 1:3] \n",
- "print(f'blue:\\n{blue}\\n')\n",
- "\n",
- "# Bonus: Come up with indexing which selects from x the following submatrix:\n",
- "# [[29, 28], \n",
- "# [11, 10]].\n",
- "bonus = x[-1::-3, -2:-4:-1]\n",
- "print(f'bonus:\\n{bonus}\\n')\n",
- "\n",
- "# Check the results:\n",
- "assert(np.allclose(red, np.array([[1, 6], [7, 12], [13, 18], [19, 24], [25, 30]])))\n",
- "assert(np.allclose(green, np.array([15, 16, 17])))\n",
- "assert(np.allclose(blue, np.array([[2, 3], [14, 15], [26, 27]])))\n",
- "assert(np.allclose(bonus, np.array([[29, 28], [11, 10]])))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We will move forward with the exercise session for now, but there are more exercises about indexing using list of indices and masking at the end of the exercise. We encourage you to do them all when you get to the end, as these concepts will keep reocurring in the upcoming exercises."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 4 Iterating\n",
- "\n",
- "An N dimensional array can be expressed as a list of N-1 dimensional arrays. \n",
- "\n",
- "For instance, a (2D) matrix ``x = np.ones((2, 3))`` can be thought of as a list of (1D) vectors of lenght 3. As you have seen in Section 3.1, we can access, say, the 2nd row as ``x[1, :]`` which is, however, equivalent to ``x[1]`` (i.e. omitting the ``:`` symbol referring to \"all the values in this dimension\").\n",
- "\n",
- "Similarly, a 3D array ``x = np.ones((4, 2, 3))`` can be thought of as a list of (2D) matrices of shape (2, 3). Again, we can access, say, the 1st matrix as ``x[0, :, :]``, which is equivalent to ``x[0]``.\n",
- "\n",
- "You have seen how to iterate through an array (Python list) using ``for``-loop or ``while``-loop in the exercise 1. You can use the same strategy with NumPy arrays as well. I.e. treat an N dimensional array as a list of N-1 dimensional arrays.\n",
- "\n",
- "Note that for many operations it is preferable _not_ to use an explicit ``for`` or ``while`` loop as the same computation can be usually achieved orders of magnitude faster using so called **vectorization** which will be introduced later. However, explicit iteration still comes in handy at times so it is useful to know how to use it."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Let us create a 3D array, iterate through it's slices, i.e. matrices, and \n",
- "# find the trace of every matrix.\n",
- "x = np.random.uniform(0, 10, (5, 10, 10))\n",
- "\n",
- "for i, matrix in enumerate(x):\n",
- " print(f'Trace of matrix {i}: {np.trace(matrix)}')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 5 Concatenating, Stacking, Splitting\n",
- "\n",
- "Arrays can be **concatenated** (i.e. glueing the arrays while keeping the number of dimensions) and **stacked** (gluing the arrays along a newly created dimension). **Splitting** is the counterpart operation to concatenating.\n",
- "\n",
- "All of the **concatenated** arrays must have the same shape along all the dimensions except the one along which we concatenate. E.g. we can stack two matrices of shapes (4, 2) and (4, 5) along *axis 1* to get a new matrix of shape (4, 7).\n",
- "\n",
- "All of the **stacked** arrays must have exactly the same shape, the size of the newly created dimensions correspond to the number of stacked arrays. E.g. we can stack 2 matrices of shapes (4, 3) and (4, 3) along the newly created dimension *axis 0* to get a 3D array of shape (2, 4, 3).\n",
- "\n",
- "The axis for concatenation or stacing is specified using an argument ``axis``.\n",
- "\n",
- "See the examples below."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Concatenating.\n",
- "\n",
- "# Concatenate a couple of matrices vertically.\n",
- "m1 = np.array([[1, 2, 3], [4, 5, 6]])\n",
- "m2 = np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]])\n",
- "m3 = np.array([[100, 200, 300]])\n",
- "m_cat = np.concatenate([m1, m2, m3], axis=0)\n",
- "print(m_cat)\n",
- "\n",
- "m_cat_error = np.concatenate([m1, m2, m3], axis=1) # This will fail, study the error message."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Stacking\n",
- "\n",
- "# Stack a couple of matrices to create a 3D array.\n",
- "m1 = np.array([[1, 2], [4, 5]])\n",
- "m2 = np.array([[10, 20], [40, 50]])\n",
- "m3 = np.array([[100, 200], [400, 500]])\n",
- "\n",
- "# We can stack along any of axes 0, 1, 2. Stacking along different\n",
- "# axis results in \"rotating\" our newly created 3D cube.\n",
- "m_stack_0 = np.stack([m1, m2, m3], axis=0)\n",
- "m_stack_1 = np.stack([m1, m2, m3], axis=1)\n",
- "m_stack_2 = np.stack([m1, m2, m3], axis=2)\n",
- "\n",
- "print(m_stack_0.shape)\n",
- "print(m_stack_1.shape)\n",
- "print(m_stack_2.shape)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 5.1 Exercises\n",
- "\n",
- "Study the documentation for function [``np.split`` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.split.html) and use it to solve the following exercise."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Create a 3D array of increasing sequence of even numbers (starting from 0) of shape (10, 5, 7).\n",
- "x = np.arange(0, 10 * 5 * 7 * 2, 2).reshape((10, 5, 7))\n",
- "print(f'x:\\n{x}\\n')\n",
- "\n",
- "# Split the array into 5 arrays each of the shape (2, 5, 7)\n",
- "splits_5 = np.split(x, 5, axis=0)\n",
- "\n",
- "# Split the array into 2 arrays of shapes (10, 2, 7) and (10, 3, 7)\n",
- "splits_2 = np.split(x, [2], axis=1)\n",
- "\n",
- "# Check the answers.\n",
- "assert((np.unique(x).size == 10 * 5 * 7) and np.all(x % 2 == 0) and np.min(x) == 0 and np.max(x) == 698)\n",
- "assert(len(splits_5) == 5 and np.allclose(np.concatenate(splits_5, axis=0), x))\n",
- "assert(len(splits_2) == 2 and np.allclose(np.concatenate(splits_2, axis=1), x))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 6 Basic Arithmetic Operators, Linear Algebra\n",
- "\n",
- "Basic arithmetic operators `+`, `-`, `*`, `/`, `//`, `**`, `%` are applied element-wise as long as one of the operands is a scalar or both operands are arrays of the same shape. If the two arrays are not the same shape, **broadcasting** will be applied (see Section 7 Broadcasting).\n",
- "\n",
- "Here are the most common linear algebra operators which you will mostly use for vectors (1D arrays) and matrices (2D arrays):\n",
- "- `np.matmul` - Scalar product, vector-matrix or matrix-matrix multiplication (very similar to `np.dot`, read more about it [here](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html)).\n",
- "- `@` - The same as `np.matmul`, syntactic sugar.\n",
- "- [`np.linalg.inv`( documentation)](https://numpy.org/doc/stable/reference/generated/numpy.linalg.inv.html) - Matrix inversion.\n",
- "- [`np.linalg.norm` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.linalg.norm.html) - Norm computation (L2 norm by default).\n",
- "- [`np.linalg.solve` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.linalg.solve.html) - Numerically stable solution to a system of linear equations given as Ax = b.\n",
- "- `x.T` - Transposition.\n",
- "\n",
- "See the examples below."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Arithmetic operations.\n",
- "\n",
- "# When used for scalar and array operands, the scalar is applied to every element of an array regardless of its shape.\n",
- "x = np.zeros((2, 2))\n",
- "print(f'x:\\n{x}\\n')\n",
- "x += 1\n",
- "print(f'x + 1:\\n{x}\\n')\n",
- "\n",
- "# When used for two array operands, the operator is applies to their corresponding values pair-wise.\n",
- "x1 = np.arange(10).reshape((2, 5))\n",
- "x2 = np.zeros((2, 5))\n",
- "print(f'x1:\\n{x1}\\n')\n",
- "print(f'x1:\\n{x2}\\n')\n",
- "x2min1 = x2 - x1\n",
- "print(f'x2 - x1:\\n{x2min1}\\n')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Linear algebra.\n",
- "\n",
- "## Dot product of two orthogonal vectors.\n",
- "v1 = np.array([0.0893, 0.9332, 0.3481])\n",
- "v2 = np.array([-0.6949, -0.1920, 0.6930])\n",
- "v_dot = np.dot(v1, v2)\n",
- "\n",
- "# If they are orthogonal, their dot product should be close to 0.\n",
- "print('v1 and v2 are orthogonal: {}'.format(\n",
- " ('FALSE', 'TRUE')[int(np.isclose(v_dot, 0., atol=1e-5))]))\n",
- "\n",
- "## Matrix multiplication.\n",
- "m1 = np.eye(3)\n",
- "m2 = np.random.uniform(-10., 10., (3, 8))\n",
- "m_mult = m1 @ m2\n",
- "\n",
- "# m1 is an identity matrix, therefore the matrix multiplication with \n",
- "# any matrix M will produce the same matrix M.\n",
- "print('m_mult is the same as m2: {}'.format(\n",
- " ('FALSE', 'TRUE')[np.allclose(m2, m_mult)]))\n",
- "\n",
- "## Solve a linear system Ax = b.\n",
- "# All the coefficients are random so it is extremely unlikely that we would\n",
- "# generate a rank deficient matrix A and therefore the system of linear\n",
- "# equations will have a solution.\n",
- "A = np.random.uniform(-1., 1., (10, 10))\n",
- "b = np.random.uniform(-1., 1., (10, ))\n",
- "x = np.linalg.solve(A, b)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 6.1 Exercises"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "## Generate a matrix of shape (100, 100) filled with Euler's number. You cannot use np.full.\n",
- "eul = np.ones((100, 100)) * np.exp(1)\n",
- "print(f'eul:\\n{eul}\\n')\n",
- "\n",
- "## Generate a 1D array of length 10 of powers of 2, i.e. [2^0, 2^1, ..., 2^9]\n",
- "pows = 2. ** np.arange(10)\n",
- "print(f'pows:\\n{pows}\\n')\n",
- "\n",
- "## Check the answers:\n",
- "assert(np.allclose(eul, np.stack([[2.71828182] * 100] * 100, axis=0)))\n",
- "assert(np.allclose(pows, [2**0, 2**1, 2**2, 2**3, 2**4, 2**5, 2**6, 2**7, 2**8, 2**9]))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Helper function to print an arrow.\n",
- "def plot_arrow(pts, clr):\n",
- " plt.plot(*pts[:2].T, color=clr, marker='*')\n",
- " plt.plot(*pts[1:3].T, color=clr, marker='*')\n",
- " plt.plot(*pts[[1, 3], :].T, color=clr, marker='*')\n",
- "\n",
- "## The array 'arrow' contains 4 2D points defining a blue arrow. The objective\n",
- "## is to make the arrow 2 times shorter and thinner and rotate it by 45 degrees \n",
- "## counter-clockwise. \n",
- "## First you will rotate the arrow by multiplying the points with the rotation \n",
- "## matrix, where the rotation matrix stands on the left.\n",
- "## Then, you will scale the arrow by multiplying the previous result with the scale matrix\n",
- "## where the scale matrix stands on the left.\n",
- "\n",
- "## Hint: You will need to do some transpose operations.\n",
- "\n",
- "arrow = np.array([[ 0., 0.,], \n",
- " [ 0., 2.], \n",
- " [-0.5, 1.5], \n",
- " [ 0.5, 1.5]])\n",
- "angle = np.pi / 4.\n",
- "rot = np.array([[np.cos(angle), -np.sin(angle)], \n",
- " [np.sin(angle), np.cos(angle)]])\n",
- "scale = np.array([[0.5, 0.], \n",
- " [0., 0.5]])\n",
- "\n",
- "# When doing matrix multiplication, always know your shapes.\n",
- "# Rotation matrix in D dimension is always (DxD), here D=2\n",
- "# The arrow is made of 4 points (4x2).\n",
- "# To rotate it with matrix operation on the left, you need to transpose it:\n",
- "rotated_arrow_T = rot @ arrow.T # (shapes: (2x2)@(2x4) = (2x4))\n",
- "# Now scale and return the arrow to how you defined your space (NxD)\n",
- "arrow_sr = (scale @ rotated_arrow_T).T\n",
- "\n",
- "plt.figure(figsize=(5, 5))\n",
- "plt.xlim(-3, 3)\n",
- "plt.ylim(-3, 3)\n",
- "plot_arrow(arrow, 'b')\n",
- "plot_arrow(arrow_sr, 'r')\n",
- "\n",
- "## Check the answers.\n",
- "assert(np.allclose(arrow_sr, np.array([[ 0. , 0. ],\n",
- " [-0.70710678, 0.70710678],\n",
- " [-0.70710678, 0.35355339],\n",
- " [-0.35355339, 0.70710678]])))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 7 Broadcasting\n",
- "\n",
- "Broadcasting allows for performing arithmetic and other operations on arrays of different shape, where the smaller is \"broadcast\" over the larger array. For instance, adding a column vector *v* to a matrix *M*, M + v, will effectively take every column of the matrix and add the vector *v* element-wise.\n",
- "\n",
- "Broadcasting further allows for so called **vectorization**, i.e. performing a given operation in parallel where the actual looping occurs in highly-optimized C code rather than in Python, where looping is slow.\n",
- "\n",
- "Example:\n",
- "\n",
- "```python\n",
- ">>> a = np.arange(6).reshape((2, 3)) # shape (2, 3)\n",
- "array([[0, 1, 2],\n",
- " [3, 4, 5]])\n",
- "\n",
- ">>> b = np.array([10, 20, 30]) # shape (3, )\n",
- "array([10, 20, 30])\n",
- "\n",
- ">>> a + b\n",
- "array([[10, 21, 32],\n",
- " [13, 24, 35]]) # shape (2, 3)\n",
- "```\n",
- "\n",
- "### 7.1 Broadcasting Rules\n",
- "\n",
- "The corresponding dimensions of the 2 arrays must satisfy one of the following:\n",
- "- Have the same dimensions.\n",
- "- One of the dimensions is 1.\n",
- "\n",
- "Furthermore, non-existent dimensions are treated as 1.\n",
- "\n",
- "Here are a couple of examples of the input and output shapes to a binary operation (such as `+`) being applied on 2 arrays *A* and *B*:\n",
- "\n",
- "\n",
- "\n",
- "**Note:** Do not confuse the concept of _vectorization_ with NumPy's function `np.vectorize`, which is provided for programming convenience, not for performance and thus does not guranatee the actual vectorization of an operation.\n",
- "\n",
- "If the concept is not clear, you can read more about broadcasting [here](https://numpy.org/devdocs/user/basics.broadcasting.html).\n",
- "\n",
- "Go through the examples below and try to understand how the arrays are constructed and computed."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "## Manual Python looping vs. vectorization - Multiplying a \n",
- "# matrix by a vector row-wise.\n",
- "m = np.arange(15).reshape(5, 3)\n",
- "v = np.array([0, 4, 2])\n",
- "m_loop = np.copy(m)\n",
- "m_vect = np.copy(m)\n",
- "\n",
- "# Python loop.\n",
- "for i in range(m.shape[0]):\n",
- " m_loop[i] *= v\n",
- "\n",
- "# Vectorization.\n",
- "m_vect *= v\n",
- "\n",
- "# Check that both results are the same.\n",
- "assert(np.allclose(m_loop, m_vect))\n",
- "\n",
- "## Generate a matrix where each row holds a constant value \n",
- "## which increases throughout the rows.\n",
- "seq_mat = np.ones((5, 3)) * np.arange(5).reshape((-1, 1))\n",
- "print(f'seq_mat:\\n{seq_mat}\\n')\n",
- "\n",
- "m = np.random.randint(0, 10, (4, 5))\n",
- "print(f'm:\\n{m}\\n')\n",
- "\n",
- "## Add a vector to a matrix row-wise (horizontally).\n",
- "add_rw = np.array([10, 20, 30, 40, 50])\n",
- "m_add_rw = m + add_rw\n",
- "print(f'm_add_rw:\\n{m_add_rw}\\n')\n",
- "\n",
- "## Add a vector to a matrix column-wise (vertically).\n",
- "add_cw = np.array([10, 20, 30, 40]).reshape((-1, 1))\n",
- "m_add_cw = m + add_cw\n",
- "print(f'm_add_cw:\\n{m_add_cw}\\n')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 7.2 Exercises"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "## Given a matrix 'data' defined below, Compute a matrix data_pow, \n",
- "## where a value in each column is taken to the power of its column\n",
- "## index.\n",
- "data = np.random.uniform(0, 5, (4, 5))\n",
- "data_pow = data ** np.arange(5)\n",
- "print(f'data_pow:\\n{data_pow}\\n')\n",
- "\n",
- "## Generate a matrix of shape (5, 4), where each row is an integer \n",
- "## sequence starting from 0 with an increment of a row index i. E.g.\n",
- "## the first 3 rows would be:\n",
- "##\n",
- "## [0*0, 0*0, 0*0, 0*0] [0, 0, 0, 0]\n",
- "## [0*1, 1*1, 2*1, 3*1] = [0, 1, 2, 3]\n",
- "## [0*2, 1*2, 2*2, 3*2] [0, 2, 4, 6]\n",
- "##\n",
- "## You can use 1D arrays only and the rules of broadcasting.\n",
- "# Hint: Use np.arange\n",
- "seqs = np.arange(5)[:, None] * np.arange(4)\n",
- "print(f'seqs:\\n{seqs}\\n')\n",
- "\n",
- "## Check the results:\n",
- "data_pow_gt = np.copy(data)\n",
- "for i in range(data.shape[1]):\n",
- " data_pow_gt[:, i] = data_pow_gt[:, i] ** i\n",
- "assert(np.allclose(data_pow, data_pow_gt))\n",
- "assert(np.allclose(seqs, np.array([[ 0, 0, 0, 0],\n",
- " [ 0, 1, 2, 3],\n",
- " [ 0, 2, 4, 6],\n",
- " [ 0, 3, 6, 9],\n",
- " [ 0, 4, 8, 12]])))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 8 Common NumPy Functions\n",
- "\n",
- "NumPy offers plethora of functions to perform computations with N dimensional arrays. One of the common concepts is that these functions would accept an argument `axis` using which you can specify along which axis the operation should be performed. \n",
- "\n",
- "For example, given a matrix `A = np.array([[1, 2, 3], [4, 5, 6]])`, we might want to find a sum of values over rows and columns:\n",
- "\n",
- "\n",
- "\n",
- "```python\n",
- ">>> sum_per_row = np.sum(A, axis=1)\n",
- "array([6, 15])\n",
- "\n",
- ">>> sum_per_col = np.sum(A, axis=0)\n",
- "array([5, 7, 9])\n",
- "```\n",
- "\n",
- "Among the most common functions you might need the following: \n",
- "- [`np.sum` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.sum.html)\n",
- "- [`np.prod` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.prod.html) \n",
- "- [`np.mean` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.mean.html)\n",
- "- [`np.std` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.std.html)\n",
- "- `np.min`\n",
- "- `np.max`\n",
- "- [`np.argmin` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.argmin.html)\n",
- "- [`np.argmax` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.argmax.html)\n",
- "- [`np.sort` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.sort.html)\n",
- "- `np.abs` \n",
- "- [`np.sqrt` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.sqrt.html)\n",
- "- [`np.unravel_index` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.unravel_index.html).\n",
- "\n",
- "Please study their corresponding reference pages and fill in the following exercises."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 8.1 (OPTIONAL) Exercises"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "## Given a matrix M, find the product of the values in each row.\n",
- "M = np.arange(12).reshape((4, 3))\n",
- "sm = np.prod(M, axis=1)\n",
- "\n",
- "# Check the results.\n",
- "assert(np.allclose(sm, np.array([0, 60, 336, 990])))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Write a function `rescale` which takes as input an array $x \\in \\mathbb R ^ {N \\times M}$ and scalars $a np.ndarray:\n",
- " \"\"\" Rescales the input from range [min(x), max(x)] to range [a, b].\n",
- " \n",
- " Args:\n",
- " x (np.ndarray): Input array, shape (N, M).\n",
- " a (float): Lower bound of the output range.\n",
- " b (float): Upper bound of the output range.\n",
- " \n",
- " Returns:\n",
- " np.ndarray: Rescaled array, shape (N, M).\n",
- " \"\"\"\n",
- " return (b - a) * (x - np.min(x)) / (np.max(x) - np.min(x)) + a\n",
- "\n",
- "# Test.\n",
- "x = 2 * np.random.rand(3, 2) - 1\n",
- "a, b = 1, 3\n",
- "y = rescale(x, a, b)\n",
- "\n",
- "assert(np.isclose(np.min(y), a) and np.isclose(np.max(y), b))\n",
- "\n",
- "print(f'Input array:\\n{x}\\n')\n",
- "print(f'Required range: {a, b}\\n')\n",
- "print(f'Output array:\\n{y}\\n')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Write function `find_closest`, which given scalar $u \\in \\mathbb R$ and input array $x \\in \\mathbb R ^ {N \\times M}$, returns the closest element to the scalar in the array $x_{i^*,j^*} : (i^*,j^*)=\\text{argmin}_{i,j} | x_{i,j} - u |$. $\\text{argmin}$ is the operation that finds the index of the minimum element.\n",
- "\n",
- "Hint: Use `np.abs`, [`np.argmin` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.argmin.html), [`np.unravel_index` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.unravel_index.html)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def find_closest(x: np.ndarray, u: float) -> float:\n",
- " \"\"\" Finds the closest element to `u` in `x`.\n",
- " \n",
- " Args:\n",
- " x (np.ndarray): Input array, shape (N, M).\n",
- " u (float): A value to which the closest element in x is searched for.\n",
- " \n",
- " Returns:\n",
- " float: Closest element in `x` to `u`.\n",
- " \"\"\"\n",
- " index_min = (np.abs(x - u)).argmin()\n",
- " index_min_unravelled = np.unravel_index(index_min, x.shape)\n",
- " return x[index_min_unravelled]\n",
- "\n",
- "# Test.\n",
- "x = np.arange(12).reshape(3,4)\n",
- "u = np.random.uniform(0, 11)\n",
- "x_ij = find_closest(x, u)\n",
- "\n",
- "assert(x_ij == round(u))\n",
- "\n",
- "print(f'The closest element to {u:.3f} within\\n{x} is {x_ij}')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Write a function `z_score_normalize` which takes as input an array $x \\in \\mathbb R ^ {N \\times M}$ and returns an output array $y \\in \\mathbb R ^ {N \\times M}$ such that $\\mathbb E [y]= 0$ and $\\sigma [y] = 1$, where $\\sigma[y]$ is a standard deviation of $y$.\n",
- "\n",
- "Hint: Use [`np.mean` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.mean.html) [`np.std` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.std.html)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def z_score_normalize(x: np.ndarray) -> np.ndarray:\n",
- " \"\"\" Normalizes the input x so that its mean is 0 and std is 1.\n",
- " \n",
- " Args:\n",
- " x (np.ndarray): Input array, shape (N, M).\n",
- " \n",
- " Returns:\n",
- " np.ndarray: Normalized array, shape (N, M).\n",
- " \"\"\"\n",
- " return (x - np.mean(x)) / np.std(x)\n",
- "\n",
- "# Test.\n",
- "x = 2 * np.random.rand(3,2) - 1\n",
- "y = z_score_normalize(x)\n",
- "\n",
- "assert(np.isclose(np.mean(y), 0))\n",
- "assert(np.isclose(np.std(y), 1.))\n",
- "\n",
- "print(f'Mean/std for input array\\n{x}\\nis: {np.mean(x):.3f}/{np.std(x):.3f}\\n')\n",
- "print(f'Mean/std for normalized array\\n{y} is:\\n{np.mean(y):.3f}/{np.std(y):.3f}')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 9 Shallow and Deep Copy\n",
- "\n",
- "A simple assignment makes no copy of the underlying data, have a look at the following example:\n",
- "\n",
- "```python\n",
- ">>> a = np.array([1., 2., 3.])\n",
- ">>> b = a\n",
- ">>> b[1] = 1.602e-19\n",
- ">>> print(a, b)\n",
- "array([1, 1.602e-19, 3])\n",
- "array([1, 1.602e-19, 3])\n",
- "```\n",
- "\n",
- "Assigning a slice of an array to a new array works with the very same data as well, i.e. no copy is made:\n",
- "\n",
- "```python\n",
- ">>> a = np.array([1., 2., 3.])\n",
- ">>> b = a[:2]\n",
- ">>> b[0] = 6.626e-34\n",
- ">>> print(a, b)\n",
- "array([6.626e-34, 2, 3])\n",
- "array([6.626e-34, 2])\n",
- "```\n",
- "\n",
- "In order to truly copy the data, we need to make a deep copy using the NumPy function [`np.copy` (documentation)](https://numpy.org/doc/stable/reference/generated/numpy.copy.html):\n",
- "\n",
- "```python\n",
- ">>> a = np.array([1., 2., 3.])\n",
- ">>> b = a.copy()\n",
- ">>> b[2] = 9.807\n",
- ">>> print(a, b)\n",
- "array([1, 2, 3])\n",
- "array([2, 2, 9.807])\n",
- "```\n",
- "\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 10 Random\n",
- "\n",
- "The module [`np.random` (documentation)](https://numpy.org/doc/stable/reference/random/index.html) implements pseudo-random number generators (RNG) for various distributions. We will frequently use it to randomly sample our data or to randomly initialize the parameters of our models.\n",
- "\n",
- "In order to fix the RNG and thus to be able to reproduce the computation, we can set the so called *seed*. Setting the seed guarantees that the same sequence of numbers will be generated by the RNG in each run.\n",
- "\n",
- "```python\n",
- ">>> constant = 3 # Any we want\n",
- ">>> np.random.seed(constant)\n",
- "```\n",
- "\n",
- "Here are some of the functions we will be using most frequently:\n",
- "- np.random.randint\n",
- "- np.random.shuffle\n",
- "- np.random.uniform\n",
- "- np.random.randn\n",
- "- np.random.permutation\n",
- "\n",
- "Please study their respective [reference pages](https://docs.scipy.org/doc/numpy-1.16.0/reference/routines.random.html) and complete the exercises below."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### 10.1 (OPTIONAL) Exercises"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "## Create a 1D array of randomly permuted sequence from 0 to 10.\n",
- "x_perm = np.random.permutation(11) \n",
- "x_perm = np.arange(11)\n",
- "np.random.shuffle(x_perm)\n",
- "print(f'Permuted array:\\n{x_perm}\\n')\n",
- "\n",
- "## Check the answers.\n",
- "assert(np.unique(x_perm).shape == (11, ) and np.min(x_perm) == 0 and np.max(x_perm) == 10)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 11 (OPTIONAL) Extra Indexing Exercises"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Using indexing by integer arrays, extract the subarrays as depicted in the Figure below.\n",
- "\n",
- ""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Using a combination of standard indexing/slicing and an indexing by an array \n",
- "# of indices, select the following subarrays.\n",
- "\n",
- "# Create a 2D array an print it out.\n",
- "x = np.arange(1, 31).reshape((5, 6))\n",
- "print(f'Array x:\\n{x}\\n')\n",
- "\n",
- "# Select the subarrays.\n",
- "red = x[range(5), range(5)]\n",
- "print(f'red:\\n{red}\\n')\n",
- "\n",
- "green = x[[0, 1, 3], 4:]\n",
- "print(f'green:\\n{green}\\n')\n",
- "\n",
- "blue = x[[3, 4, 4], [0, 0, 1]]\n",
- "print(f'blue:\\n{blue}\\n')\n",
- "\n",
- "# Bonus: Come up with indexing which results in matrix `x` being stacked 3 times \n",
- "# horizontally, i.e. the resulting shape is (15, 6).\n",
- "# Hint: Use functions range and list, use operator * with a list.\n",
- "bonus = x[list(range(5)) * 3, :]\n",
- "print(f'bonus:\\n{bonus}\\n')\n",
- "\n",
- "# Check the results:\n",
- "assert(np.allclose(red, np.arange(1, 30, 7)))\n",
- "assert(np.allclose(green, np.array([[5, 6], [11, 12], [23, 24]])))\n",
- "assert(np.allclose(blue, np.array([19, 25, 26])))\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Using masking, extract the subarray as depicted in the Figure below.\n",
- "\n",
- ""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "### Construct a mask and then extract the red values above the main diagonal.\n",
- "\n",
- "# Extract the red values.\n",
- "mask = np.zeros_like(x, dtype=bool)\n",
- "for i in range(5):\n",
- " mask[i, i + 1:] = True\n",
- "print(f'mask:\\n{mask}\\n')\n",
- "\n",
- "red = x[mask]\n",
- "print(f'red:\\n{red}\\n')\n",
- "\n",
- "# Bonus: Extract all the values, which are not red.\n",
- "# Hint: Use your already constructed `mask`, study NumPy's binary operations\n",
- "# https://docs.scipy.org/doc/numpy/reference/routines.bitwise.html\n",
- "the_rest = x[~mask]\n",
- "print(f'the_rest:\\n{the_rest}\\n')\n",
- "\n",
- "# Bonus2: Extract the values which can be divided by both 2 and 3.\n",
- "# Hint: Construct two masks and combine them using NumPy's binary operators.\n",
- "mask = (x % 2 == 0) & (x % 3 == 0)\n",
- "div23 = x[mask]\n",
- "print(f'div23:\\n{div23}\\n')\n",
- "\n",
- "# Check the results:\n",
- "assert(np.allclose(red, np.concatenate(\n",
- " [range(2, 7), range(9, 13), range(16, 19), range(23, 25), [30]])))\n",
- "assert(np.allclose(np.sort(np.concatenate([red, the_rest])), np.arange(1, 31)))\n",
- "assert(not np.any(np.fmod(div23, 2.)) and not np.any(np.fmod(div23, 3.)))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 12 Next Steps\n",
- "\n",
- "Feel free to consult more thorough NumPy tutorials.\n",
- "\n",
- "- NumPy basics: [https://docs.scipy.org/doc/numpy/user/basics.html](https://docs.scipy.org/doc/numpy/user/basics.html)\n",
- "- Official NumPy tutorial: [https://docs.scipy.org/doc/numpy/user/quickstart.html](https://docs.scipy.org/doc/numpy/user/quickstart.html)"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.8.10"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/Exercises/03-linear-regression/.ipynb_checkpoints/linear_regression-checkpoint.ipynb b/Exercises/03-linear-regression/.ipynb_checkpoints/linear_regression-checkpoint.ipynb
deleted file mode 100644
index 5980034..0000000
--- a/Exercises/03-linear-regression/.ipynb_checkpoints/linear_regression-checkpoint.ipynb
+++ /dev/null
@@ -1,1319 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Linear Regression"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "| \n", - " | population | \n", - "profit | \n", - "
|---|---|---|
| 0 | \n", - "6.1101 | \n", - "17.5920 | \n", - "
| 1 | \n", - "5.5277 | \n", - "9.1302 | \n", - "
| 2 | \n", - "8.5186 | \n", - "13.6620 | \n", - "
| 3 | \n", - "7.0032 | \n", - "11.8540 | \n", - "
| 4 | \n", - "5.8598 | \n", - "6.8233 | \n", - "