Week_2_Numpy_Class.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Week 2 Numpy Class.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/FrancisBilla/DSci/blob/master/Week_2_Numpy_Class.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jbPCAJ7abfJW"
      },
      "source": [
        "\n",
        "# Week 2 Numpy Class\n",
        "Proprietary material - Under Creative Commons 4.0 licence CC-BY-NC https://creativecommons.org/licenses/by-nc/4.0/legalcode"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v25riZpeVuUf"
      },
      "source": [
        "Previous content needed for this material:\n",
        "\n",
        "- Functions\n",
        "\n",
        "- Methods \n",
        "\n",
        "- Basics of Linear Algebra"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FMlQezxy57B2"
      },
      "source": [
        "## Installing Libraries\n",
        "\n",
        "To install a new library, Python comes with a default packet manager called **pip**. And its used in the console using the following command:\n",
        "\n",
        "```\n",
        "pip install newlibrary\n",
        "```\n",
        "\n",
        "A console command can also be executed from a notebook by using !. So to install the library newlibrary with pip inside a notebook we would need to do something like this:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8dd80_n2aHV2"
      },
      "source": [
        "!pip install newlibrary"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U3CUDv8w8S5W"
      },
      "source": [
        "And to be able to use this libary from our code, its necessary to import it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S5s6AdiN8NGN"
      },
      "source": [
        "import newlibrary"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lreZj262-LdL"
      },
      "source": [
        "If newlibrary contains several modules, those can also be individualy imported using **from**. \n",
        "\n",
        "Lets see an example with the module newmodule from our newlibrary"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P_N7UtSr-Zkq"
      },
      "source": [
        "from newlibrary import newmodule"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dOfNfYkyAL5S"
      },
      "source": [
        "Libraries can also be imported using an alias by using **as**. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rs0jqsULAK4V"
      },
      "source": [
        "import newlibrary as nl"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gPmg2KbMYTwV"
      },
      "source": [
        "## Preamble: Basic Libraries"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QQmuCHIt4ux8"
      },
      "source": [
        "Before jumping into Numpy, lets quickly see how to install and import Python libraries alongside with some basic and helpfull libraries."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i6jkuTwm-Ysu"
      },
      "source": [
        "### Math"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "65cmAslS_moW"
      },
      "source": [
        "The library Math includes several basic math functions and constants."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DQ_zSG9zAI0T",
        "outputId": "3eb1b78a-0ad5-45e0-98d0-b24364b5f960"
      },
      "source": [
        "import math as m\n",
        "\n",
        "print('pi: {}'.format(m.pi))\n",
        "print('e: {}'.format(m.e))\n",
        "\n",
        "print('cos(0): {}'.format(m.cos(0)))\n",
        "print('cos(pi): {}'.format(m.cos(m.pi)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "pi: 3.141592653589793\n",
            "e: 2.718281828459045\n",
            "cos(0): 1.0\n",
            "cos(pi): -1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ee_51dVeB4gY"
      },
      "source": [
        "### Pickle"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vMRM64LtDAZb"
      },
      "source": [
        "While working with data, it is often important to save and compress the data. The library Pickle allows us to save and load data structures and objects in a format similar to a .zip or .rar.  \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hrEwh-vnBUdc"
      },
      "source": [
        "import pickle \n",
        "\n",
        "file = 'Some large file'\n",
        "\n",
        "with open('pickle_test.pkl', 'bw') as handler: # b refers to binary and w to write\n",
        "    pickle.dump(file, handler) # saves the file"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 184
        },
        "id": "708ddhotExZ8",
        "outputId": "abbaa314-2292-4e99-d2ee-fe67cb1cac54"
      },
      "source": [
        "del file # deleting the object file\n",
        "print(file)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-4-78cd53b47fb3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mfile\u001b[0m \u001b[0;31m# deleting the object file\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'file' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cBiuc9zZE-sx",
        "outputId": "fd65cd7d-10b2-487d-ebe0-f313de90a52f"
      },
      "source": [
        "with open('pickle_test.pkl','br') as data: # here the r is for read\n",
        "    file = pickle.load(data) # Loading the saved data\n",
        "print(file)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Some large file\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V5dHWXW-NzBT"
      },
      "source": [
        "### Time\n",
        "\n",
        "The time library contains several methods to access and measure time."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VUzR_GSYFNAe",
        "outputId": "416a41bc-a878-4c29-9991-05bc704fec85"
      },
      "source": [
        "import time\n",
        "\n",
        "print(time.gmtime())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "time.struct_time(tm_year=2021, tm_mon=1, tm_mday=5, tm_hour=11, tm_min=7, tm_sec=50, tm_wday=1, tm_yday=5, tm_isdst=0)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vBIbCi-gO0kc",
        "outputId": "e51af154-6e89-4024-ef75-541d3cfb1204"
      },
      "source": [
        "start = time.time() # gets starting time\n",
        "\n",
        "time.sleep(5) # waits 5 seconds\n",
        "\n",
        "end = time.time() # gets end time\n",
        "\n",
        "print('Execution time: ', end - start) # total time "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Execution time:  5.005200386047363\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vl6YxOdSQvq4"
      },
      "source": [
        "Measuring execution time can be a powefull tool when optimizing a time costly operation. \n",
        "\n",
        "Even if this implementation works good enough, as a side note let's introduce some more powerfull time measuring tools.  \n",
        "\n",
        "In a notebook, we can the functions time and timeit as cell magic to measure the time of simple processes.\n",
        "\n",
        "Let's see an example:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JgszfVAQPVzb",
        "outputId": "8359a14b-9e84-4206-f481-c000dc41f89d"
      },
      "source": [
        "%%time \n",
        "\n",
        "time.sleep(3) # Or some other process"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 296 µs, sys: 23 µs, total: 319 µs\n",
            "Wall time: 3 s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J4cWvCYxb6Iy",
        "outputId": "5be14678-167c-4958-bc5d-7b66feb1b8fd"
      },
      "source": [
        "%%timeit \n",
        "\n",
        "time.sleep(3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 loop, best of 3: 3 s per loop\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uNYqijJ_cwRg"
      },
      "source": [
        "## Numpy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EKaRer2ucy7-"
      },
      "source": [
        "NumPy (Numerical Python) is an open source Python library that contains high performance operations for mathematics, linear algebra, probabilities and data manipulation.\n",
        "\n",
        "One of it's most important uses is the efficient handling of multidimentional arrays. It also has integration with C/C++ and Fortran.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wv8Dx2z76G9v"
      },
      "source": [
        "Can be installed using pip with the following line in the terminal:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "pip install numpy\n",
        "```\n",
        "\n",
        "or the following line in a jupyter cell:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2AFop7eScEZX"
      },
      "source": [
        "!pip install numpy"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oy7jUHmLxysH"
      },
      "source": [
        "In Google Colaboratory, Numpy is installed by default, but it still needs to be imported. This is usually done with the alias np."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wEPawTZc-1co"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MKxslnKox7nQ"
      },
      "source": [
        "### Arrays"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V01IIs8Tzbyn"
      },
      "source": [
        "Numpy arrays are a type of data structure that contains values inside a grid structure.\n",
        "\n",
        "An array can be initialized by the following ways:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "18PjZM5BBElH"
      },
      "source": [
        "By passing a list to np.array()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b9Nr4t6QCYxK"
      },
      "source": [
        "1. Empty list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uzoY4RxV9bo2",
        "outputId": "7509b48b-65dc-46be-b92c-4ecb4bd8300b"
      },
      "source": [
        "empty_array = np.array([])\n",
        "\n",
        "empty_array"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([], dtype=float64)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hlieSRx2CdB4"
      },
      "source": [
        "2. List of values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X_J1_g_2BOze",
        "outputId": "e04808db-a851-43ad-fa59-0bc85bd5f52f"
      },
      "source": [
        "test_list = [1, 2, 3, 4]\n",
        "\n",
        "test_array = np.array(test_list)\n",
        "\n",
        "test_array"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S2wNKpgDCqBu"
      },
      "source": [
        "3. List of lists"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4XXN2XDQCRZj",
        "outputId": "35fb37e4-a8e3-429e-c4bf-75a89005c955"
      },
      "source": [
        "matrix_list = [[1,2], [3,4]]\n",
        "\n",
        "matrix_array = np.array(matrix_list)\n",
        "\n",
        "matrix_array"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2],\n",
              "       [3, 4]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lWra-AOck14v"
      },
      "source": [
        "By using an array initializer with a default value.\n",
        "\n",
        "1. Array of ones"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i6U22IxalC1G",
        "outputId": "9e7daa0a-9eac-49f8-9767-b40bad772ca3"
      },
      "source": [
        "np.ones([2, 3]) # First dimension of size 2 and second one of size 3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 1., 1.],\n",
              "       [1., 1., 1.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FNoKAs0olQrF"
      },
      "source": [
        "2. Array of zeros"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jnH9ebbylU8M",
        "outputId": "bdd08ba2-422b-4994-ecc8-661e2da43c6d"
      },
      "source": [
        "np.zeros((2,3)) # A tuple can also be passed"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0.],\n",
              "       [0., 0., 0.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9fYWOTnUZbGL"
      },
      "source": [
        "3. Array of random numbers between [0,1] \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dpdn490ZZlEw",
        "outputId": "0fe62be2-7d5c-4876-f0a4-4435a05a4feb"
      },
      "source": [
        "np.random.random([2,3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.32340441, 0.64626558, 0.14270884],\n",
              "       [0.05117606, 0.53533044, 0.48401192]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dYv3rsozZOyp"
      },
      "source": [
        "Or by using arange() or linspace() to automaticaly create secuences"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DztsShvYajp4"
      },
      "source": [
        "# Array with the integers 0, 1, ... , 9\n",
        "np.arange(10) # Remember that the 0 is counted in Python"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hvF0F7VabIXG",
        "outputId": "8883da4a-f97c-419e-f94e-3d850eaf4434"
      },
      "source": [
        "# Arange can also accept a start and step argument\n",
        "np.arange(10, 20, 2) # Array of even numbers between 10 and 19 "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([10, 12, 14, 16, 18])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4Wz73CB3a183",
        "outputId": "f92a4df3-d26a-4e38-9d39-d6541192bf3f"
      },
      "source": [
        "# Array of 10 evenly spaced numbers between 0 and 5\n",
        "np.linspace(0, 5, 10) # start, stop, n_samples"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.        , 0.55555556, 1.11111111, 1.66666667, 2.22222222,\n",
              "       2.77777778, 3.33333333, 3.88888889, 4.44444444, 5.        ])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZDZusZv9kEha"
      },
      "source": [
        "### Dimensions of arrays"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "llm2VOHOkQ-1"
      },
      "source": [
        "All numpy arrays are n-dimensional, this means that that they can represent from points to complex multidimensional structures.\n",
        "\n",
        "As a general rule, 1-dimensional arrays are called vectors and 2-dimensional arrays or more are matrices.\n",
        "\n",
        "While working with arrays its almos always important to keep in mid their dimensinality. Luckly all numpy arrays come with some tools to know all you need about their dimensions.\n",
        "\n",
        "1. **.ndim** : Returns the number of dimentions in an array"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1ry6OFIlkDpK",
        "outputId": "ff8a593a-1c64-446c-8f2c-78c605bbeaab"
      },
      "source": [
        "m = np.ones([2, 3]) # matrix of 2x3\n",
        "m.ndim"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q1_HxjjJIDNq"
      },
      "source": [
        "2. **.shape** : Returns a tuple with the number of elements along each axis.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1H8xtg3xICQQ",
        "outputId": "ba651dad-f134-48a1-88ad-a497429357bf"
      },
      "source": [
        "m = np.ones([2, 3]) # matrix of 2x3\n",
        "m.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yE3MaISrIibG"
      },
      "source": [
        "2. .size : Returns the total number of elements in an array. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JbI5y_QEI55t",
        "outputId": "071c34db-eeb7-43af-d892-2b2ee519d454"
      },
      "source": [
        "m = np.ones([2, 3]) # matrix of 2x3\n",
        "m.size"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BCPOIiUGJAp-"
      },
      "source": [
        "### Reshaping\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LA0g3TlYYlaj"
      },
      "source": [
        "While working or operating over arrays, its often necessary to modify its dimensions.\n",
        "\n",
        "Luckly for us, Numpy also comes with a bunch of metods that makes this easy.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zwZajLXRjVGq",
        "outputId": "3d17db9d-7d97-4fd4-bdeb-c099d9fc65dd"
      },
      "source": [
        "a = np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])\n",
        "print('Original shape :', a.shape)\n",
        "\n",
        "# Reshape\n",
        "# Reshapes the array to a new shape\n",
        "# Note: The reshape must have the same number of elements\n",
        "reshaped = np.reshape(a, (5, 2))\n",
        "print('Reshape size :', reshaped.shape)\n",
        "\n",
        "# Expand dimensions\n",
        "# Adds a new dimension to the array\n",
        "ext_dim = np.expand_dims(a, axis=2)\n",
        "print('Expand dimension size :', ext_dim.shape)\n",
        "\n",
        "# Transpose \n",
        "# Returns the transpose matrix of an array\n",
        "t = a.T\n",
        "print('Transpose shape: ', t.shape)\n",
        "\n",
        "# Flatten \n",
        "# Flattens the array to a new 1-d vector\n",
        "flat = a.flatten()\n",
        "print('Flatten shape :', flat.shape)\n",
        "\n",
        "# Ravel\n",
        "# Returns a 1-d view of the array. This means that  if you modify the view, \n",
        "# it can modify the original array entries.\n",
        "rav = a.ravel()\n",
        "print('Ravel : ', rav.shape)\n",
        "rav[0] = -1 # Modifying the view\n",
        "print('Original array', a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original shape : (2, 5)\n",
            "Reshape size : (5, 2)\n",
            "Expand dimension size : (2, 5, 1)\n",
            "Transpose shape:  (5, 2)\n",
            "Flatten shape : (10,)\n",
            "Ravel :  (10,)\n",
            "Original array [[-1  1  2  3  4]\n",
            " [ 5  6  7  8  9]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iFg5vhLwoWfW"
      },
      "source": [
        "> Note: A common mistake is confusing a 2-d array with a dimension of shape 1 with a 1-d array. \n",
        "\n",
        "> In other words, an array of shape (2,1) is not the same as one of shape (2,).\n",
        "\n",
        "> Try to keep this in mind if you find yourself with some dimensionality errors."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1jG80kMcCnaH"
      },
      "source": [
        "### Aritmetic"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1qfAtVv7CrEc"
      },
      "source": [
        "Numpy arrays also can be operated with basic aritmetic"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sffTloXuGpIW",
        "outputId": "2658ee5b-4cb4-404c-904a-858795a76701"
      },
      "source": [
        "x = np.array([0, 1, 2])\n",
        "y = np.array([9, 8, 7])\n",
        "\n",
        "print('x + y = ', x + y)\n",
        "print('x - y = ', x - y)\n",
        "print('x * y = ', x * y)\n",
        "print('x / y = ', x / y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x + y [9 9 9]\n",
            "x - y [-9 -7 -5]\n",
            "x * y [ 0  8 14]\n",
            "x / y [0.         0.125      0.28571429]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pll8CKz5LMda"
      },
      "source": [
        "We can also get the max, min, their index and the sum of the values.\n",
        "\n",
        "We can also pass an axis argument to operate in a particular axis."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dzLNWGWdL07N",
        "outputId": "4712e0ea-1de3-426c-fbe4-c347e4765322"
      },
      "source": [
        "a = np.array([[1, 2, 3, 4], [9, 8, 0, 3]])\n",
        "\n",
        "print('max : \\t\\t\\t', np.max(a))\n",
        "print('max axis 0 : \\t\\t', np.max(a, axis = 0))\n",
        "print('min : \\t\\t\\t', np.max(a))\n",
        "print('min axis 1 : \\t\\t', np.min(a, axis = 1))\n",
        "print('arg max : \\t\\t', np.argmax(a))\n",
        "print('arg max axis 0: \\t', np.argmax(a, axis = 0))\n",
        "print('arg min : \\t\\t', np.argmin(a))\n",
        "print('arg min axis 1 : \\t', np.argmin(a, axis = 1))\n",
        "print('sum : \\t\\t\\t', np.sum(a))\n",
        "print('sum axis 0 : \\t\\t', np.sum(a, axis = 0))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "max : \t\t\t 9\n",
            "max axis 0 : \t\t [9 8 3 4]\n",
            "min : \t\t\t 9\n",
            "min axis 1 : \t\t [1 0]\n",
            "arg max : \t\t 4\n",
            "arg max axis 0: \t [1 1 0 0]\n",
            "arg min : \t\t 6\n",
            "arg min axis 1 : \t [0 2]\n",
            "sum : \t\t\t 30\n",
            "sum axis 0 : \t\t [10 10  3  7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZwK0hVXwq6LH"
      },
      "source": [
        "### Broadcasting"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yLp6WwNtLIt7"
      },
      "source": [
        "What happens if we want to operate arrays of different sizes or an array with a scalar? \n",
        "\n",
        "Again, luckily for us, Numpy arrays comme with another property: broadcasting.\n",
        "\n",
        "To apply broadcasting over arrays, it is necesary to follow one of two rules:\n",
        "\n",
        "1. Two dimensions of the arrays are equal\n",
        "2. One of the dimensions is 1\n",
        "\n",
        "> Note: Arrays don need to have the same number of dimensions.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FJ-yN4t1aBx7",
        "outputId": "df0e0c1f-38f9-4cd6-e130-8eae737bc9ca"
      },
      "source": [
        "x = np.ones((3,2))\n",
        "\n",
        "x * 5 # Broadcasting with a scalar"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[5., 5.],\n",
              "       [5., 5.],\n",
              "       [5., 5.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r14sydsKaRpb",
        "outputId": "864c48d3-f803-4b03-d748-df2f5dbb928f"
      },
      "source": [
        "x = np.random.random((255, 255, 3)) # Lets supose a random image\n",
        "# Colors are stored in rgb (red, green, blue)\n",
        "mask = np.array([1, 0, 0]) # Lets make a mask to only get the red colors\n",
        "x * mask # Broadcasting over the axis with dimension 3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[0.05790407, 0.        , 0.        ],\n",
              "        [0.38655452, 0.        , 0.        ],\n",
              "        [0.91856911, 0.        , 0.        ],\n",
              "        ...,\n",
              "        [0.12600722, 0.        , 0.        ],\n",
              "        [0.61158806, 0.        , 0.        ],\n",
              "        [0.52028399, 0.        , 0.        ]],\n",
              "\n",
              "       [[0.80385431, 0.        , 0.        ],\n",
              "        [0.83793821, 0.        , 0.        ],\n",
              "        [0.21284892, 0.        , 0.        ],\n",
              "        ...,\n",
              "        [0.77881444, 0.        , 0.        ],\n",
              "        [0.30579561, 0.        , 0.        ],\n",
              "        [0.67227457, 0.        , 0.        ]],\n",
              "\n",
              "       [[0.5408901 , 0.        , 0.        ],\n",
              "        [0.29061865, 0.        , 0.        ],\n",
              "        [0.03660604, 0.        , 0.        ],\n",
              "        ...,\n",
              "        [0.88862806, 0.        , 0.        ],\n",
              "        [0.56750931, 0.        , 0.        ],\n",
              "        [0.70044786, 0.        , 0.        ]],\n",
              "\n",
              "       ...,\n",
              "\n",
              "       [[0.75916139, 0.        , 0.        ],\n",
              "        [0.69504343, 0.        , 0.        ],\n",
              "        [0.84170737, 0.        , 0.        ],\n",
              "        ...,\n",
              "        [0.07149014, 0.        , 0.        ],\n",
              "        [0.87377088, 0.        , 0.        ],\n",
              "        [0.48628261, 0.        , 0.        ]],\n",
              "\n",
              "       [[0.29032842, 0.        , 0.        ],\n",
              "        [0.95047888, 0.        , 0.        ],\n",
              "        [0.41714094, 0.        , 0.        ],\n",
              "        ...,\n",
              "        [0.52345631, 0.        , 0.        ],\n",
              "        [0.56633955, 0.        , 0.        ],\n",
              "        [0.79694322, 0.        , 0.        ]],\n",
              "\n",
              "       [[0.09545898, 0.        , 0.        ],\n",
              "        [0.33117184, 0.        , 0.        ],\n",
              "        [0.8394624 , 0.        , 0.        ],\n",
              "        ...,\n",
              "        [0.51734912, 0.        , 0.        ],\n",
              "        [0.06086276, 0.        , 0.        ],\n",
              "        [0.68865703, 0.        , 0.        ]]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c-FanxEtrUEp"
      },
      "source": [
        "### Slicing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lLkE-DcsbdEC"
      },
      "source": [
        "Numpy arrays can also by sliced like Python lists"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0NdwCegigmHB",
        "outputId": "474d638f-2494-48d3-d34c-8985c06296f9"
      },
      "source": [
        "a = np.array([[1,2], [3,4]])\n",
        "\n",
        "print(a[0])\n",
        "print(a[1,0])\n",
        "print(a[-1])\n",
        "print(a[:,1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2]\n",
            "3\n",
            "[3 4]\n",
            "[2 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wMYyYcVVhwEL"
      },
      "source": [
        "### Linear Algebra"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EgSpW0JWhyx7"
      },
      "source": [
        "Most linear algebra operations on vectors and matrices can also be done with Numpy arrays"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "trb5DDmuh8F_",
        "outputId": "bc86737f-5fc3-4df2-eba0-25863419baa9"
      },
      "source": [
        "# Matrix 3x4\n",
        "a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
        "\n",
        "# Matrix 4x2\n",
        "b = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])\n",
        "\n",
        "# Matrix multiplication 3x4 @ 4x2 = 3x2\n",
        "c = np.matmul(a, b)\n",
        "c "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 50,  60],\n",
              "       [114, 140],\n",
              "       [178, 220]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ByvqBPsQrkdZ",
        "outputId": "760d624f-18de-46d7-d09d-1a3fd8fca860"
      },
      "source": [
        "# Matrix 3x4\n",
        "w = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
        "\n",
        "# Vector 4x1\n",
        "x = np.array([1, 2, 3, 4])\n",
        "\n",
        "# Vector 3x1\n",
        "b = np.array([4, 5, 6])\n",
        "\n",
        "# @ can also be used to multiply matrices\n",
        "z = w @ x + b # 3x4 @ 4x1 + 3x1 \n",
        "z"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 34,  75, 116])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oYNkgvdOrwAC"
      },
      "source": [
        "### Vectorization"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HL9WTeUaht1i"
      },
      "source": [
        "Numpy operations are extremly efficient, allowing to obtain optimal speeds even when Python is an interpreted language.\n",
        "\n",
        "With such efficient speeds, it is posible to optimize the overall code running time if you can identify when it is possible to apply vectorization and broadcasting.\n",
        "\n",
        "Put simply, vectorization consists of replacing iterations with a vector, array operation, or broadcasting.\n",
        "\n",
        "\n",
        "In general, always try to consider if a for loop can be vectorized instead.  This will become  important later when working with deep learning models ;)\n",
        "\n",
        "Let's see how much time we can save by vectorizing some operations:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c2IvtNxi20eS",
        "outputId": "d4a11c12-d59d-470d-a8a2-91f999e75e4c"
      },
      "source": [
        "# A function with a for loop\n",
        "def slow_operation(n=1000):\n",
        "    arr = np.arange(n)\n",
        "    diff = np.zeros(n-1)\n",
        "    \n",
        "    for i in range(1, n):\n",
        "        diff[i-1] = np.sqrt(arr[i]**2 - arr[i-1]**2)\n",
        "    \n",
        "    return sum(diff)/n\n",
        "    \n",
        "slow_operation()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "29.769614699783833"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gdlIYNh356TM"
      },
      "source": [
        "Let's time it"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dspt5yoy58Rd",
        "outputId": "0a4a08e7-3138-486e-c73a-bda71e4d8fab"
      },
      "source": [
        "%timeit slow_operation()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100 loops, best of 3: 2.78 ms per loop\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c6L4vWBT51us",
        "outputId": "64d4bd80-c8f5-4b59-f51b-1a050833f173"
      },
      "source": [
        "# The same operation vectorized\n",
        "def fast_operation(n=1000):\n",
        "    arr = np.arange(n)\n",
        "    diff = np.sqrt(arr[1:]**2 - arr[:-1]**2)\n",
        "    \n",
        "    return sum(diff)/n\n",
        "    \n",
        "fast_operation()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "29.769614699783833"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H7jYzqpH6YUA"
      },
      "source": [
        "Let's time it"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7D2FyEfQ6aA-",
        "outputId": "006d8ab7-35dd-45d2-f935-d11a1b5136d7"
      },
      "source": [
        "%timeit fast_operation()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10000 loops, best of 3: 192 µs per loop\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "muN9Y7Vg6f34"
      },
      "source": [
        "Its not even close! "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dJYhSFau7qX7"
      },
      "source": [
        "Even if this diference seems small, when working with large datasets this small optimizations can save you from hours to days of running time."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YVF7Sub-r21R"
      },
      "source": [
        "### Data Normalization"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jbiPFmAP6XQ2"
      },
      "source": [
        "Often while working with data, diferent kinds of features can have diferent means and deviations. If we try to visualize this data it might not be understandable or if we feed this raw data to a machine learning model the predictions might be incorrect.\n",
        "\n",
        "One solution to this problem is to normalize the features, so they have a similar mean and variance. \n",
        "\n",
        "In Python there are several libraries and tools that can help in data normalization, but in this lab lets see how to do it with Numpy."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9WAfm29iGLDU"
      },
      "source": [
        "With a custom normalizing function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WEcq7y7sGJ43",
        "outputId": "48423127-1ae6-4f69-aac0-d7f33fe78e66"
      },
      "source": [
        " A = np.array([[1,1,1],[4,5,6],[7,8,9]])\n",
        "\n",
        " def normalize(features):\n",
        "     mean = np.mean(features, axis=0)\n",
        "     print(\"Feature wise mean: \", mean)\n",
        "     deviation = np.std(features, axis=0)\n",
        "     print(\"Feature wise deviation: \", deviation)\n",
        "     # to avoid division by 0\n",
        "     std_feat = (features - mean)/(deviation + 1e-8)\n",
        "     return std_feat\n",
        "\n",
        "normalize(A)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Feature wise mean:  [4.         4.66666667 5.33333333]\n",
            "Feature wise deviation:  [2.44948974 2.86744176 3.29983165]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-1.22474487, -1.27872402, -1.3131983 ],\n",
              "       [ 0.        ,  0.11624764,  0.20203051],\n",
              "       [ 1.22474487,  1.16247638,  1.1111678 ]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vsWQ2QCjHPe4"
      },
      "source": [
        "There are more ways to normalize data, but this goes beyond the focus of the lab, if you are interested please check the references at the end."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h_zQA99Xr-Gi"
      },
      "source": [
        "### Linear Regression "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yWMg0Qy2K2sW"
      },
      "source": [
        "Linear regression is one of the first and most basic supervised learning algorithms. \n",
        "\n",
        "Still, a quick linear regresion can give a starting point before trying more complex models, and in some cases it might work just as well.\n",
        "\n",
        "Like in normalization, Python has several libraries that can do linear regression, but let's try to build an implementetion using Numpy.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "mUOnipZpXuRd",
        "outputId": "cac30931-91a7-490f-9b1a-0952feffab38"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Generate some data in an array\n",
        "#sample = np.array([[1,3],[2,4],[3,5.5],[4,8.2],[5,10],[6,11],[7,13], [8,14.2], [9,19], [10,20.3]])\n",
        "# Some random data\n",
        "sample = np.array([[x + np.random.random(), x*2 + np.random.random()] for x in range(10)]) \n",
        "\n",
        "# Get the x and y values \n",
        "x = sample[:,0]\n",
        "y = sample[:,1]\n",
        "\n",
        "# Find the number of samples in the data\n",
        "n = x.size\n",
        "\n",
        "# Calculate the mean values for x and y\n",
        "xm, ym = np.mean(x), np.mean(y)\n",
        "\n",
        "# Calculate the coefficients\n",
        "b1 = (np.sum(y*x) - n*ym*xm) / (np.sum((x - xm)**2))\n",
        "b0 = ym - b1*xm\n",
        "\n",
        "# print the results\n",
        "print(\"The coefficients are b0 %2.2f and b1 %2.2f \" % (b0,b1))\n",
        "\n",
        "# Plot the original data\n",
        "plt.plot(x, y, 'o') \n",
        "# Plot the linear regression\n",
        "plt.plot(x, x*b1 + b0)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The coefficients are b0 -0.40 and b1 1.97 \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lCUw1maCmQ0h"
      },
      "source": [
        "That looks like a start!\n",
        "\n",
        "It's easy to dismiss this simple algorithms when you are used to working with more complex and exiting models, but they still have their uses to this day,  so try to consider them when working in a real life problem.\n",
        "\n",
        "> Note: Numpy already has a method to fit lines called polyfit, but for educational purposes we have ignored it here. \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GoBa0RaRoNVx"
      },
      "source": [
        "## Exercise"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O9tTAnH5pTzI"
      },
      "source": [
        "Download the data from the google sheets 'Simple linear regression', 'Small multivariative linear set' and 'Multivariate linear regression sample dataset' as a csv. They can be found in the Labs folder.\n",
        "\n",
        "We haven't talked about how to load a csv data yet, so in case you are not familiar with it, use the provided function 'csv_loader()' to get the raw data. \n",
        "\n",
        "For each of the csvs: \n",
        "\n",
        "1. Look at the data in the sheet to understand each column.\n",
        "2. Normalize each column\n",
        "3. If there are more than two variables, choose some (at least 3) couples of variables that you think could be correlated, apply linear regression over them and obtain the parameters.\n",
        "4. Calculate the total square error of the linear regression. \n",
        "5. Make some simple comments about your results, do they confirm your initial hypothesis? \n",
        "\n",
        "> Notes: \n",
        "1. Some columns of the raw data might be full of null values, remove these columns as you see accordingly. We will learn to do this in more details in further lessons.\n",
        "2. Use vectorization and broadcasting for most, if not all, possible operations.\n",
        "3. Instead of repeating the regression several times, use a class and methods to implement steps 2, 3, and 4.\n",
        "4. It is not necessary to make a plot of the regression because we haven't explained visualization yet. Still, if you want to do so, go for it!\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4hyPyDSCt7wN"
      },
      "source": [
        "import pandas as pd # A small spoiler of the next material\n",
        "\n",
        "def csv_loader(path):\n",
        "    data = pd.read_csv(path)\n",
        "    raw_data = data.values\n",
        "    return raw_data\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bE8pk1MR9Di5"
      },
      "source": [
        "This is the end of the lab, Numpy is a huge library with several functionalities and we cant cover them all in this material. \n",
        "\n",
        "Also, some of you might already be familiar with Numpy and general data manipulation, so if you are curious to learn more we recommend that you check the following links:\n",
        "\n",
        "https://numpy.org/doc/stable/index.html\n",
        "\n",
        "https://numpy.org/doc/stable/user/basics.broadcasting.html\n",
        "\n",
        "https://www.cs.toronto.edu/~frossard/post/linear_regression/\n",
        "\n",
        "Also, in case you want some extra challenges or just want some recommendations, just contact us on your Slack channel :D"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bcgHJ9rhzFZw"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}