diff --git a/Aadvik_210002_DL_Stamatics_A1(1).ipynb b/Aadvik_210002_DL_Stamatics_A1(1).ipynb new file mode 100644 index 0000000..94aa5d5 --- /dev/null +++ b/Aadvik_210002_DL_Stamatics_A1(1).ipynb @@ -0,0 +1,893 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + }, + "colab": { + "name": "Aadvik_210002_DL_Stamatics_A1(1).ipynb", + "provenance": [], + "collapsed_sections": [], + "include_colab_link": true + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rvFM645NE-D2" + }, + "source": [ + "# Assignment 1 - Part 1\n", + "In this assignment, we will go through basic linear algebra, NumPy, and image manipulation using Python to get everyone on the same page.\n", + "\n", + "One of the aims of this assignment is to get you to start getting comfortable searching for useful library functions online. So in many of the functions you will implement, you will have to look up helper functions.\n", + "\n", + "\\\n", + "\n", + "## Instructions\n", + "* This notebook contain blocks of code, you are required to complete those blocks(where required)\n", + "* You are required to copy this notebook (\"copy to drive\" above) and complete the code.(DO NOT CHANGE THE NAME OF THE FUNCTIONS)\n", + "\n", + "\\\n", + "\\\n", + "Also, I'd like to acknowledge the Stanford CS131. This assignment is highly based on the assignments from that course." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UhSVK4RoK9q5" + }, + "source": [ + "First Let's import some dependencies" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "cCKqyfhIE-EQ" + }, + "source": [ + "# Imports the print function from newer versions of python\n", + "from __future__ import print_function\n", + "\n", + "# Setup\n", + "\n", + "# The Random module implements pseudo-random number generators\n", + "import random \n", + "\n", + "# Numpy is the main package for scientific computing with Python. \n", + "# This will be one of our most used libraries in this project\n", + "import numpy as np\n", + "\n", + "# The Time library helps us time code runtimes\n", + "import time\n", + "\n", + "\n", + "# Some more magic so that the notebook will reload external python modules;\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "%reload_ext autoreload" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true, + "id": "QLtp15rqE-EU" + }, + "source": [ + "# Part 1: Linear Algebra and NumPy Review\n", + "In this section, we will review linear algebra and learn how to use vectors and matrices in python using numpy." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E8HDYpc0E-EV" + }, + "source": [ + "## Part 1.1 (5 points)\n", + "First, let's test whether you can define the following matrices and vectors using numpy. Look up `np.array()` for help. In the next code block, define $M$ as a $(4, 3)$ matrix, $a$ as a $(1, 3)$ row vector and $b$ as a $(3, 1)$ column vector:\n", + "\n", + "$$M = \\begin{bmatrix}\n", + "1 & 2 & 3 \\\\\n", + "4 & 5 & 6 \\\\\n", + "7 & 8 & 9 \\\\\n", + "10 & 11 & 12 \\end{bmatrix}\n", + "$$\n", + "\n", + "$$a = \\begin{bmatrix}\n", + "1 & 1 & 0\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "$$b = \\begin{bmatrix}\n", + "-1 \\\\ 2 \\\\ 5\n", + "\\end{bmatrix} \n", + "$$ " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "mETk2NCME-EX", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "aeb8a105-dbec-4c27-ebfc-3720611e9c82" + }, + "source": [ + "### YOUR CODE HERE\n", + "M = np.array([[1,2,3] , [4,5,6] , [7,8,9] , [10,11,12]])\n", + "a = np.array( [[1,1,0]] )\n", + "b = np.array([[-1] , [2] , [5]])\n", + "### END CODE HERE\n", + "print(\"M = \\n\", M)\n", + "print(\"The size of M is: \", M.shape)\n", + "print()\n", + "print(\"a = \", a)\n", + "print(\"The size of a is: \", a.shape)\n", + "print()\n", + "print(\"b = \", b)\n", + "print(\"The size of b is: \", b.shape)" + ], + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "M = \n", + " [[ 1 2 3]\n", + " [ 4 5 6]\n", + " [ 7 8 9]\n", + " [10 11 12]]\n", + "The size of M is: (4, 3)\n", + "\n", + "a = [[1 1 0]]\n", + "The size of a is: (1, 3)\n", + "\n", + "b = [[-1]\n", + " [ 2]\n", + " [ 5]]\n", + "The size of b is: (3, 1)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rSta4NheE-EZ" + }, + "source": [ + "## Part 1.2 (5 points)\n", + "Implement the `dot_product()` method below and check that it returns the correct answer for $a^Tb$." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C5ZRjCE2MVOU" + }, + "source": [ + "def dot_product(a, b):\n", + " \"\"\"Implement dot product between the two vectors: a and b.\n", + " (optional): While you can solve this using for loops, we recommend\n", + " that you look up `np.dot()` online and use that instead.\n", + " Args:\n", + " a: numpy array of shape (x, n)\n", + " b: numpy array of shape (n, x)\n", + " Returns:\n", + " out: numpy array of shape (x, x) (scalar if x = 1)\n", + " \"\"\"\n", + " out = np.dot(a,b)\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 46, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "pbLIS5vIE-Ea", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "934eaff1-9d1d-4194-d2d1-acc03fb3f9ae" + }, + "source": [ + "# Now, let's test out this dot product. Your answer should be [[1]].\n", + "aDotB = dot_product(a, b)\n", + "print(aDotB)\n", + "\n", + "print(\"The size is: \", aDotB.shape)" + ], + "execution_count": 47, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0.0\n", + "The size is: ()\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0rGfcRU1E-Eb" + }, + "source": [ + "## Part 1.3 (5 points)\n", + "Implement the `complicated_matrix_function()` method and use it to compute $(ab)Ma^T$\n", + "\n", + "IMPORTANT NOTE: The `complicated_matrix_function()` method expects all inputs to be two dimensional numpy arrays, as opposed to 1-D arrays. This is an important distinction, because 2-D arrays can be transposed, while 1-D arrays cannot.\n", + "\n", + "To transpose a 2-D array, you can use the syntax `array.T` " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "dglQmbuLNOk6" + }, + "source": [ + "def complicated_matrix_function(M, a, b):\n", + " \"\"\"Implement (a * b) * (M * a.T).\n", + " (optional): Use the `dot_product(a, b)` function you wrote above\n", + " as a helper function.\n", + " Args:\n", + " M: numpy matrix of shape (x, n).\n", + " a: numpy array of shape (1, n).\n", + " b: numpy array of shape (n, 1).\n", + " Returns:\n", + " out: numpy matrix of shape (x, 1).\n", + " \"\"\"\n", + " out = np.dot(a,b)*np.dot(M,a.T)\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 18, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "da_uQQLhE-Ec", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ca4d664b-5ee5-49a3-b508-a10fbb5573e5" + }, + "source": [ + "# Your answer should be $[[3], [9], [15], [21]]$ of shape(4, 1).\n", + "ans = complicated_matrix_function(M, a, b)\n", + "print(ans)\n", + "print()\n", + "print(\"The size is: \", ans.shape)" + ], + "execution_count": 19, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[ 3]\n", + " [ 9]\n", + " [15]\n", + " [21]]\n", + "\n", + "The size is: (4, 1)\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "6CWXxSSOE-Ed", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "6d9547ca-01ad-4cd9-afe2-66c0ffc688d8" + }, + "source": [ + "M_2 = np.array(range(4)).reshape((2,2))\n", + "a_2 = np.array([[1,1]])\n", + "b_2 = np.array([[10, 10]]).T\n", + "print(M_2.shape)\n", + "print(a_2.shape)\n", + "print(b_2.shape)\n", + "print()\n", + "\n", + "# Your answer should be $[[20], [100]]$ of shape(2, 1).\n", + "ans = complicated_matrix_function(M_2, a_2, b_2)\n", + "print(ans)\n", + "print()\n", + "print(\"The size is: \", ans.shape)" + ], + "execution_count": 20, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2, 2)\n", + "(1, 2)\n", + "(2, 1)\n", + "\n", + "[[ 20]\n", + " [100]]\n", + "\n", + "The size is: (2, 1)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4fHLxLl4E-Ee" + }, + "source": [ + "## Part 1.4 (10 points) [Optional/Bonus]\n", + "Implement `eigen_decomp()` and `get_eigen_values_and_vectors()` methods. In this method, perform eigenvalue decomposition on the following matrix and return the largest k eigen values and corresponding eigen vectors (k is specified in the method calls below).\n", + "\n", + "$$M = \\begin{bmatrix}\n", + "1 & 2 & 3 \\\\\n", + "4 & 5 & 6 \\\\\n", + "7 & 8 & 9 \\end{bmatrix}\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "RfaCSoRMOIc8" + }, + "source": [ + "def eigen_decomp(M):\n", + " \"\"\"Implement eigenvalue decomposition.\n", + " (optional): You might find the `np.linalg.eig` function useful.\n", + " Args:\n", + " matrix: numpy matrix of shape (m, n)\n", + " Returns:\n", + " w: numpy array of shape (m, m) such that the column v[:,i] is the eigenvector corresponding to the eigenvalue w[i].\n", + " v: Matrix where every column is an eigenvector.\n", + " \"\"\"\n", + " w = None\n", + " v = None\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return w, v" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "YB120rb4ONBH" + }, + "source": [ + "def get_eigen_values_and_vectors(M, k):\n", + " \"\"\"Return top k eigenvalues and eigenvectors of matrix M. By top k\n", + " here we mean the eigenvalues with the top ABSOLUTE values (lookup\n", + " np.argsort for a hint on how to do so.)\n", + " (optional): Use the `eigen_decomp(M)` function you wrote above\n", + " as a helper function\n", + " Args:\n", + " M: numpy matrix of shape (m, m).\n", + " k: number of eigen values and respective vectors to return.\n", + " Returns:\n", + " eigenvalues: list of length k containing the top k eigenvalues\n", + " eigenvectors: list of length k containing the top k eigenvectors\n", + " of shape (m,)\n", + " \"\"\"\n", + " eigenvalues = []\n", + " eigenvectors = []\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return eigenvalues, eigenvectors" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "t0_GkrJwE-Ee" + }, + "source": [ + "# Let's define M.\n", + "M = np.array([[1,2,3],[4,5,6],[7,8,9]])\n", + "\n", + "# Now let's grab the first eigenvalue and first eigenvector.\n", + "# You should get back a single eigenvalue and a single eigenvector.\n", + "val, vec = get_eigen_values_and_vectors(M[:,:3], 1)\n", + "print(\"First eigenvalue =\", val[0])\n", + "print()\n", + "print(\"First eigenvector =\", vec[0])\n", + "print()\n", + "assert len(vec) == 1\n", + "\n", + "# Now, let's get the first two eigenvalues and eigenvectors.\n", + "# You should get back a list of two eigenvalues and a list of two eigenvector arrays.\n", + "val, vec = get_eigen_values_and_vectors(M[:,:3], 2)\n", + "print(\"Eigenvalues =\", val)\n", + "print()\n", + "print(\"Eigenvectors =\", vec)\n", + "assert len(vec) == 2" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Yeh-V5x1PYz5" + }, + "source": [ + "## Part 1.5 (10 points)\n", + "In this section, you'll implement a gaussian elimination.\n", + "\n", + "The algorithm to to reduce a matrix to rref using gaussian elimination contains 2 parts, First reducing the matrix to partial reduced form, then back substituting to calculate the rref. First algorithm can be summed up as:\n", + "1. Partial pivoting: Find the kth pivot by swapping rows, to move the entry with the largest absolute value to the pivot position. This imparts computational stability to the algorithm.\n", + "2. For each row below the pivot, calculate the factor f which makes the kth entry zero, and for every element in the row subtract the fth multiple of the corresponding element in the kth row.\n", + "3. Repeat above steps for each unknown. We will be left with a partial r.e.f. matrix.\n", + "\n", + "$$\\begin{bmatrix}\n", + "1 & 2 & 3 \\\\\n", + "4 & 5 & 6 \\\\\n", + "7 & 8 & 9 \\end{bmatrix}\n", + "=>\n", + "\\begin{bmatrix}\n", + "7 & 8 & 9 \\\\\n", + "4 & 5 & 6 \\\\\n", + "1 & 2 & 3 \\end{bmatrix}\n", + "=>\n", + "\\begin{bmatrix}\n", + "7 & 8 & 9 \\\\\n", + "0 & 0.42 & 0.85 \\\\\n", + "0 & 0.85 & 1.71 \\end{bmatrix}\n", + "=>\n", + "\\begin{bmatrix}\n", + "7 & 8 & 9 \\\\\n", + "0 & 0.85 & 1.71 \\\\\n", + "0 & 0.45 & 0.85 \\end{bmatrix}\n", + "=>\n", + "\\begin{bmatrix}\n", + "7 & 8 & 9 \\\\\n", + "0 & 0.42 & 0.85 \\\\\n", + "0 & 0 & -0.05 \\end{bmatrix}\n", + "$$\n", + "Second algorithm:\n", + "1. Take a pivot from the last row.\n", + "2. For each row above the pivot, calculate the factor f which makes the kth entry zero, and for every element in the row subtract the fth multiple of the corresponding element in the kth row\n", + "3. Repeat the above step untill the matrix is in rref\n", + "$$\\begin{bmatrix}\n", + "7 & 8 & 0 \\\\\n", + "0 & 0.42 & 0 \\\\\n", + "0 & 0 & -0.05 \\end{bmatrix}\n", + "=>\n", + "\\begin{bmatrix}\n", + "7 & 0 & 0 \\\\\n", + "0 & 0.42 & 0 \\\\\n", + "0 & 0 & -0.05 \\end{bmatrix}\n", + "$$\n", + "\n", + "Steps for implementation:\n", + "1. Complete the function `swap_rows()`\n", + "2. Complete the function `apply_row()`\n", + "3. Complete `forward()` and `backward()`\n", + "4. Finally implement `rref()` using the `forward()` and `backward()`\n", + "\n", + "Note: You can skip this part if you want." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "qUFujiFAPYz6" + }, + "source": [ + "def swap_rows(M):\n", + " \"\"\"Implement row swapping to make the largest element in the pivotial column to be the first row.\n", + " Args:\n", + " matrix: numpy matrix of shape (m, n)\n", + " Returns:\n", + " Ms: matrix with swapped row\n", + " \"\"\"\n", + " \n", + " for i in range(M):\n", + " j=max(M[i,0])\n", + " M[j,:]=M[0,:]\n", + " out = M\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 41, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "S8lbAUSWWpyO" + }, + "source": [ + "def apply_rows(M):\n", + " \"\"\"For each row below the pivot, calculate the factor f which makes the kth\n", + " entry zero, and for every element in the row subtract the fth multiple of the\n", + " corresponding element in the kth row.\n", + " Args:\n", + " matrix: numpy matrix of shape (m, n)\n", + " Returns:\n", + " Ms: matrix with all other entries of the pivotal col zero\n", + " \"\"\"\n", + " out = None\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "GnE_-JLxPYz7" + }, + "source": [ + "def forward(M):\n", + " \"\"\"Return a partial ref using the algo described above\n", + " Args:\n", + " M: numpy matrix of shape (m, n).\n", + " Returns:\n", + " Ms: ref of M\n", + " \"\"\"\n", + " out = None\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Wb7pPGP4XmJu" + }, + "source": [ + "def backward(M):\n", + " \"\"\"Return a rref using the algo described above\n", + " Args:\n", + " M: numpy matrix of shape (m, n).\n", + " Returns:\n", + " Ms: rref of M\n", + " \"\"\"\n", + " out = None\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "XLq81xzXYR85" + }, + "source": [ + "def rref(M):\n", + " \"\"\"Return a rref using the algo descrbed above\n", + " Args:\n", + " M: numpy matrix of shape (m, n).\n", + " Returns:\n", + " Ms: ref of M\n", + " \"\"\"\n", + " out = None\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Eiz6EbsWPYz8" + }, + "source": [ + "# Let's define M.\n", + "M = np.array([[1,2,3],[4,5,6],[7,8,9]])\n", + "\n", + "# Now let's calculate it's rref.\n", + "# Note that your code may be evaluated on other test cases as well\n", + "Mrref = rref(M)\n", + "print(Mrref)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "G46pyDzAE-Ef" + }, + "source": [ + "## Part 1.6 (10 points)\n", + "\n", + "To wrap up our overview of NumPy, let's implement something fun — a helper function for computing the Euclidean distance between two $n$-dimensional points!\n", + "\n", + "In the 2-dimensional case, computing the Euclidean distance reduces to solving the Pythagorean theorem $c = \\sqrt{a^2 + b^2}$. where, given two points $(x_1, y_1)$ and $(x_2, y_2)$, $a = x_1 - x_2$ and $b = y_1 - y_2$.\n", + "\n", + "\n", + "More generally, given two $n$-dimensional vectors, the Euclidean distance can be computed by:\n", + "\n", + "1. Performing an elementwise subtraction between the two vectors, to get $n$ difference values.\n", + "2. Squaring each of the $n$ difference values, and summing the squares.\n", + "4. Taking the square root of our sum.\n", + "\n", + "Alternatively, the Euclidean distance between length-$n$ vectors $u$ and $v$ can be written as:\n", + "\n", + "$\n", + "\\quad\\textbf{distance}(u, v) = \\sqrt{\\sum_{i=1}^n (u_i - v_i)^2}\n", + "$\n", + "\n", + "\n", + "Try implementing this function: first using native Python with a `for` loop in the `euclidean_distance_native()` function, then in NumPy **without any loops** in the `euclidean_distance_numpy()` function.\n", + "We've added some `assert` statements here to help you check functionality (if it prints nothing, then your implementation is correct)!" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "5xvHopPqO29C" + }, + "source": [ + "def euclidean_distance_native(u, v):\n", + " \"\"\"Computes the Euclidean distance between two vectors, represented as Python\n", + " lists.\n", + " Args:\n", + " u (List[float]): A vector, represented as a list of floats.\n", + " v (List[float]): A vector, represented as a list of floats.\n", + " Returns:\n", + " float: Euclidean distance between `u` and `v`.\n", + " \"\"\"\n", + " # First, run some checks:\n", + " assert isinstance(u, list)\n", + " assert isinstance(v, list)\n", + " assert len(u) == len(v)\n", + "\n", + " # Compute the distance!\n", + " # Notes:\n", + " # 1) Try breaking this problem down: first, we want to get\n", + " # the difference between corresponding elements in our\n", + " # input arrays. Then, we want to square these differences.\n", + " # Finally, we want to sum the squares and square root the\n", + " # sum.\n", + " sum = 0;\n", + " d = 0;\n", + " for i in range(len(u)):\n", + " d = (u[i]-v[i])**(2) \n", + " sum = sum + d\n", + " out = sum**(0.5)\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 22, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "wvLuK8MuO3LH" + }, + "source": [ + "def euclidean_distance_numpy(u, v):\n", + " \"\"\"Computes the Euclidean distance between two vectors, represented as NumPy\n", + " arrays.\n", + " Args:\n", + " u (np.ndarray): A vector, represented as a NumPy array.\n", + " v (np.ndarray): A vector, represented as a NumPy array.\n", + " Returns:\n", + " float: Euclidean distance between `u` and `v`.\n", + " \"\"\"\n", + " # First, run some checks:\n", + " assert isinstance(u, np.ndarray)\n", + " assert isinstance(v, np.ndarray)\n", + " assert u.shape == v.shape\n", + "\n", + " # Compute the distance!\n", + " # Note:\n", + " # 1) You shouldn't need any loops\n", + " # 2) Some functions you can Google that might be useful:\n", + " # np.sqrt(), np.sum()\n", + " # 3) Try breaking this problem down: first, we want to get\n", + " # the difference between corresponding elements in our\n", + " # input arrays. Then, we want to square these differences.\n", + " # Finally, we want to sum the squares and square root the\n", + " # sum.\n", + " a = np.square(v-u)\n", + " b = np.sum(a)\n", + " c = np.sqrt(b)\n", + " return c\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE" + ], + "execution_count": 37, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "" + ], + "metadata": { + "id": "LLm3s3EHiq6s" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "wu9MimVJE-Eg" + }, + "source": [ + "## Testing native Python function\n", + "assert euclidean_distance_native([7.0], [6.0]) == 1.0\n", + "assert euclidean_distance_native([7.0, 0.0], [3.0, 3.0]) == 5.0\n", + "assert euclidean_distance_native([7.0, 0.0, 0.0], [3.0, 0.0, 3.0]) == 5.0" + ], + "execution_count": 23, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "kJDk88g1E-Ej" + }, + "source": [ + "## Testing NumPy function\n", + "assert euclidean_distance_numpy(\n", + " np.array([7.0]),\n", + " np.array([6.0])\n", + ") == 1.0\n", + "assert euclidean_distance_numpy(\n", + " np.array([7.0, 0.0]),\n", + " np.array([3.0, 3.0])\n", + ") == 5.0\n", + "assert euclidean_distance_numpy(\n", + " np.array([7.0, 0.0, 0.0]),\n", + " np.array([3.0, 0.0, 3.0])\n", + ") == 5.0" + ], + "execution_count": 38, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import time\n", + "n = 1000\n", + "\n", + "# Create some length-n lists and/or n-dimensional arrays\n", + "a = [0.0] * n\n", + "b = [10.0] * n\n", + "a_array = np.array(a)\n", + "b_array = np.array(b)\n", + "\n", + "# Compute runtime for native implementation\n", + "start_time = time.time()\n", + "for i in range(10000):\n", + " euclidean_distance_native(a, b)\n", + "print(\"Native:\", (time.time() - start_time), \"seconds\")\n", + "\n", + "# Compute runtime for numpy implementation\n", + "# Start by grabbing the current time in seconds\n", + "start_time = time.time()\n", + "for i in range(10000):\n", + " euclidean_distance_numpy(a_array, b_array)\n", + "print(\"NumPy:\", (time.time() - start_time), \"seconds\")" + ], + "metadata": { + "id": "E7Z38WwHhoNl", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3653b6ad-a871-4d27-ba05-1dceef09e077" + }, + "execution_count": 40, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Native: 1.7147166728973389 seconds\n", + "NumPy: 0.11908769607543945 seconds\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Mjik4mQXE-Ek" + }, + "source": [ + "Next, let's take a look at how these two implementations compare in terms of runtime:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "t4e6MfhHE-Em" + }, + "source": [ + "As you can see, doing vectorized calculations (i.e. no for loops) with NumPy results in significantly faster computations! " + ] + }, + { + "cell_type": "markdown", + "source": [ + "Congrats You've come to the end of this notebook. If you solved everything above, impressive. If not, you might need to read/think a bit more. You can always ask doubts. Also, Note that you should submit it even if you cannot solve everything. We might evaluate these using a script later." + ], + "metadata": { + "id": "XvFE0Q5bhx6-" + } + } + ] +} \ No newline at end of file diff --git a/Aadvik_210002_DL_Stamatics_A1(2,3).ipynb b/Aadvik_210002_DL_Stamatics_A1(2,3).ipynb new file mode 100644 index 0000000..8898613 --- /dev/null +++ b/Aadvik_210002_DL_Stamatics_A1(2,3).ipynb @@ -0,0 +1,635 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Aadvik_210002_DL_Stamatics_A1(2,3).ipynb", + "provenance": [], + "authorship_tag": "ABX9TyOWu3+WWyKY0soM5B2owoBv", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "resources": { + "http://localhost:8080/nbextensions/google.colab/files.js": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "application/javascript" + ] + ], + "status": 200, + "status_text": "" + } + }, + "base_uri": "https://localhost:8080/", + "height": 73 + }, + "id": "OUKGDeCGsT0z", + "outputId": "691035bb-b1f8-4777-8cc1-3cbfc0f23d81" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving House_prediction.csv to House_prediction.csv\n" + ] + } + ], + "source": [ + "from google.colab import files \n", + "\n", + "uploaded= files.upload()\n" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "A = pd.read_csv('House_prediction.csv')\n", + "\n", + "\n", + "ax1 = A.groupby(\"city\").agg(np.mean)\n", + "ax1.plot.barh(y='rent amount (R$)' , color='pink')\n", + "\n", + "ax2 = A.groupby(\"city\").agg(np.mean)\n", + "ax2.plot.barh(y='rooms' , color='darkred')\n", + "\n", + "ax3 = A.groupby(\"city\").agg(np.mean)\n", + "ax3.plot.barh(y='area' , color='purple')\n", + "\n", + "ax4 = A.groupby(\"city\").agg(np.mean)\n", + "ax4.plot.barh(y='parking spaces' , color='darkblue')\n", + "\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "zEGlkasG0FUe", + "outputId": "167be6a5-86e8-461c-ba7c-8919db0db6da" + }, + "execution_count": 35, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 35 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "A = pd.read_csv('House_prediction.csv')\n", + "\n", + "\n", + "ax1 = A.groupby(\"rooms\").agg(np.mean)\n", + "ax1.plot.barh( y = 'hoa (R$)' , color='pink')\n", + "\n", + "ax1.plot.barh(y= 'property tax (R$)' , color='darkred')\n", + "\n", + "ax1.plot.barh(y= 'fire insurance (R$)' , color='purple')\n", + "\n", + "ax1.plot.barh(y= 'total (R$)' , color='darkblue')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "lveF8irnGFV-", + "outputId": "53f3302d-2440-4031-8897-a782f8dd6419" + }, + "execution_count": 53, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 53 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "A = pd.read_csv('House_prediction.csv')\n", + "\n", + "\n", + "ax1 = A.groupby(\"bathroom\").agg(np.mean)\n", + "ax1.plot.barh( y = 'hoa (R$)' , color='pink')\n", + "\n", + "ax1.plot.barh(y= 'property tax (R$)' , color='darkred')\n", + "\n", + "ax1.plot.barh(y= 'fire insurance (R$)' , color='purple')\n", + "\n", + "ax1.plot.barh(y= 'total (R$)' , color='darkblue')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "nvqVpRlpIRkq", + "outputId": "657b8037-7e32-44c5-9546-3ff7436cee9e" + }, + "execution_count": 54, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 54 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "A = pd.read_csv('House_prediction.csv')\n", + "\n", + "\n", + "ax1 = A.groupby(\"animal\").agg(np.mean)\n", + "ax1.plot.barh( y = 'hoa (R$)' , color='pink')\n", + "\n", + "ax1.plot.barh(y= 'property tax (R$)' , color='darkred')\n", + "\n", + "ax1.plot.barh(y= 'fire insurance (R$)' , color='purple')\n", + "\n", + "ax1.plot.barh(y= 'total (R$)' , color='darkblue')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "lgHB8RTPIYKh", + "outputId": "17c0a9fe-e0e5-4048-9624-93a36865707b" + }, + "execution_count": 55, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 55 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "A = pd.read_csv('House_prediction.csv')\n", + "\n", + "\n", + "ax1 = A.groupby(\"furniture\").agg(np.mean)\n", + "ax1.plot.barh( y = 'hoa (R$)' , color='pink')\n", + "\n", + "ax1.plot.barh(y= 'property tax (R$)' , color='darkred')\n", + "\n", + "ax1.plot.barh(y= 'fire insurance (R$)' , color='purple')\n", + "\n", + "ax1.plot.barh(y= 'total (R$)' , color='darkblue')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "akyXuLk1IbS7", + "outputId": "3370eef2-d5c0-4dfd-f4fb-b0a6d6059dfc" + }, + "execution_count": 56, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 56 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAAD4CAYAAACE2RPlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAWtklEQVR4nO3dfZBV9Z3n8fdXUEElqPgQkdmADkHBpbsFFR1hfNqAicOoQc2WEyRujKjxYV2X0WQdNBVrNJXVRCfGMuPjFHEdIYwWzhiNDwPqjgaEGA0oUSDTipoQ1KiBRf3uH31gLk13c7ub5vY9vl9Vt/qec37n3O+v+xQffr9z7r2RmUiSVO92qHUBkiRtCwaaJKkUDDRJUikYaJKkUjDQJEml0LfWBXyS7bXXXjl06NBalyFJdWXRokW/y8y9W6830Gpo6NChLFy4sNZlSFJdiYhVba13ylGSVAoGmiSpFAw0SVIpeA1NUq+1YcMGmpubWbduXa1LUQ3069ePIUOGsOOOO1bV3kCT1Gs1NzczYMAAhg4dSkTUuhxtR5nJmjVraG5uZtiwYVXt45SjpF5r3bp1DBo0yDD7BIoIBg0a1KnRuYEmqVczzD65Ovu3N9AkSaXgNTRJdePquHqbHm9mztymx1NtOUKTpA7ceOONHHzwwZx55pk88MADXHvttV0+Vnf3741Wr17NSSedBMATTzzBwIEDaWxs5KCDDuKyyy7bov1VV121xboTTjiBtWvXdrsWA02SOnDzzTfzyCOPMGvWLCZPnszll1++RZsPP/ywqmO1t/+2Um0d29L111/POeecs2l5/PjxLFmyhMWLFzNv3jyeeuopAN577z1OP/10fvjDHzJ69GhmzJixaZ8vf/nL3Hzzzd2uxUCTpHZMnz6dV199lRNPPJEbbriBO++8k69//esATJs2jenTp3PEEUcwY8YMXnnlFSZNmsSYMWMYP348y5Yt2+J4rfe/6KKLOOqoozjggAOYPXs20DLimTBhAo2NjRxyyCEsWLAAgN12223TcWbPns20adParOPZZ5/lyCOPpKmpiaOOOoqXXnpp02ufeuqpTJo0ieHDh28WKA899BCHHnooDQ0NHH/88QC8//77nH322Rx++OE0NTVx//33t/k7mjNnDpMmTdpiff/+/WlsbOS1114D4O6772a33XbjvPPOY8mSJUydOnVT28mTJ3PPPfdU8RfpmNfQJKkdt9xyCw899BCPP/44e+21F3feeedm25ubm3n66afp06cPxx9/PLfccgvDhw/nmWee4fzzz+exxx7r8PirV6/mySefZNmyZUyePJkpU6bw4x//mIkTJ/LNb36Tjz76iA8++GCrdVbW8e6777JgwQL69u3Lz372M77xjW8wZ84cgE0jp5133pkRI0Zw4YUX0q9fP8455xzmz5/PsGHD+P3vfw/ANddcw3HHHcftt9/O22+/zeGHH84JJ5zArrvuuul1V6xYwR577MHOO++8RU1r165l+fLlTJgwAYCddtqJd999lz/+8Y/ssMMOHHLIIZva7rHHHqxfv541a9YwaNCgrfa3PQaaJHXRaaedRp8+fXjvvfd4+umnOe200zZtW79+/Vb3P/nkk9lhhx0YOXIkb775JgCHHXYYZ599Nhs2bODkk0+msbGx6joA3nnnHc466yyWL19ORLBhw4ZN7Y4//ngGDhwIwMiRI1m1ahVr165lwoQJm968vOeeewLw8MMP88ADD/Dd734XaHlP4G9+8xsOPvjgTcdbvXo1e++9+be4LFiwgIaGBpYvX84ll1zCpz/9aQCmTp3Kyy+/zF133cWCBQu49NJLmTJlyqb99tlnH15//XUDTZJqYeNo5eOPP2b33XdnyZIlndq/cmSTmQBMmDCB+fPn8+CDDzJt2jQuvfRSpk6dutl7slq/2bhy1HTllVdy7LHHMnfuXFauXMkxxxzT5uv16dOnw2tumcmcOXMYMWJEu2369++/RS3jx49n3rx5rFixgnHjxnH66afT2NjITjvtxHe+8x122WUXzjjjDCZOnMjYsWPZ+J2Q69ato3///u2+VjUMNEl1o7feZv+pT32KYcOGcd9993HaaaeRmTz//PM0NDR0+lirVq1iyJAhnHPOOaxfv57nnnuOqVOnsu+++7J06VJGjBjB3LlzGTBgQJv7v/POO+y///4AW0yRtmXcuHGcf/75rFixYtOU45577snEiRO56aabuOmmm4gIFi9eTFNT02b7fvazn2XlypVtHnfYsGFcfvnlXHfdddxzzz0sX76cz3zmMwAMHz6cgQMHbppOzUzeeOMNuvuFx94UIknbwKxZs7jttttoaGhg1KhR7d5EsTVPPPEEDQ0NNDU1ce+993LxxRcDcO2113LSSSdx1FFHsd9++7W7/4wZM7jiiitoamqq6q7Hvffem1tvvZVTTz2VhoYGzjjjDKBlpLdhwwZGjx7NqFGjuPLKK7fYd9ddd+XAAw/k17/+dZvHnj59OvPnz2flypUsW7aMY445hjvuuIOmpia+8IUvMHLkSAAWLVrEuHHj6Nu3e2Os2DjM1fY3duzY9BurpfYtXbp0s2s26n3mzp3LokWL+Pa3v11V+6uuumqL96JdfPHFTJ48edMdlpXaOgciYlFmjm3d1ilHSVKXnXLKKaxZs6bq9pXX9DY65JBD2gyzznLKUVKv5ixS7/fVr3616rZtBVrlG7MrdfZvb6BJ6rX69evHmjVrDLVPoI3fh9avX7+q93HKUVKvNWTIEJqbm/ntb39b61JUAxu/sbpaBpqkXmvHHXes+tuKJaccJUmlYKBJkkrBQJMklYLX0Gro9UWvb/Nv4JW0ffXWj+P6JHKEJkkqBQNNklQKBpokqRQMNElSKRhokqRSMNAkSaVgoEmSSsFAkySVgoEmSSoFA02SVAoGmiSpFAw0SVIpGGiSpFIw0CRJpWCgSZJKwUCTJJWCgSZJKgUDTZJUCgaaJKkUDDRJUikYaJKkUjDQJEmlYKBJkkqh1wRaREyLiMHtbDsoIpZExOKIOHAbvNbYiLixg+3HRMS8bhx/aES80NX9JUmd12sCDZgGtBlowMnA7MxsysxXqjlYRPRtb1tmLszMizpfoiSpt+qRQCtGKEsj4kcR8WJEPBwR/YttjRHxbxHxfETMjYg9ImIKMBaYVYzE+lcc6/PAJcB5EfF469FPRFwWEVcVz5+IiO9FxELg4mL5uoh4NiJejojxRbtNI7CI+PPiNTeOAAcUh94tImZHxLKImBURUbQfExH/GhGLIuKnEbFfxfpfRMQvgAt64vcqSWpfT47QhgM/yMxRwNvAF4v1dwN/nZmjgV8CMzNzNrAQODMzGzPzjxsPkpn/DNwC3JCZx1bxujtl5tjM/N/Fct/MPJyWUJzZRvvLgAsysxEYD2x87aZin5HAAcCfRcSOwE3AlMwcA9wOXFO0vwO4MDMbOiouIr4WEQsjYuEHfFBFdyRJ1Wh3Wm4bWJGZS4rni4ChETEQ2D0z/7VYfxdw3zZ+3XtbLf+ksoY22j8FXB8Rs4CfZGZzMRh7NjObASJiSbHv28AhwCNFmz7A6ojYnZZ+zS+O+Q/AiW0Vl5m3ArcCDI7B2YX+SZLa0JOBtr7i+UdA//YadtKHbD6y7Ndq+/vt1PERbfQ3M6+NiAeBzwNPRcTEVvtV7hvAi5l5ZOUxikCTJNXQdr0pJDPfAdZuvJYFfBnYOFr7AzCgzR039yawT0QMioidgZO6U1NEHJiZv8zM64CfAwd10PwlYO+IOLLYd8eIGJWZbwNvR8TRRbszu1OTJKnzenKE1p6zgFsiYhfgVeArxfo7i/V/BI6svI5WKTM3RMS3gGeB14Bl3aznkog4FvgYeBH4F+DIthpm5v8rbmC5sZg+7Qt8r9jvK8DtEZHAw92sSZLUSZHpZZxaGRyD81zOrXUZkrphZrZ1r5l6UkQsysyxrdf3pvehSZLUZQaaJKkUDDRJUikYaJKkUjDQJEmlYKBJkkrBQJMklYKBJkkqBQNNklQKBpokqRQMNElSKRhokqRSMNAkSaVgoEmSSsFAkySVgoEmSSoFA02SVAoGmiSpFAw0SVIpGGiSpFIw0CRJpdC31gV8kg0eM5iZC2fWugxJKgVHaJKkUjDQJEmlYKBJkkrBQJMklYKBJkkqBQNNklQKBpokqRQMNElSKWw10CLisxHxaES8UCyPjoj/1fOlSZJUvWpGaD8CrgA2AGTm88CXerIoSZI6q5pA2yUzn2217sOeKEaSpK6qJtB+FxEHAgkQEVOA1T1alSRJnVTNhxNfANwKHBQRrwErgDN7tCpJkjqpw0CLiD7A+Zl5QkTsCuyQmX/YPqVJklS9DgMtMz+KiKOL5+9vn5IkSeq8aqYcF0fEA8B9wKZQy8yf9FhVkiR1UjWB1g9YAxxXsS4BA02S1GtsNdAy8yvboxBJkrpjq4EWEXdQ3LJfKTPP7pGKJEnqgmqmHOdVPO8HnAK83jPlSJLUNdVMOc6pXI6Ie4Ane6wiSZK6oCuftj8c2GdbFyJJUndUcw3tD2x+De0N4K97rCJJkrqgminHAdujEEmSuqOa70N7tJp1kiTVUrsjtIjoB+wC7BURewBRbPoUsP92qE2SpKp1NOV4LnAJMBh4rmL9u8Df9WRRkiR1VruBlpnfB74fERdm5k3bsSZJkjqtoynH4zLzMeC1iDi19XY/nFiS1Jt0NOX458BjwF+0sc0PJ5Yk9SodTTnOLH764cSSpF6vmjdW7wx8ERha2T4zv9VzZUmS1DnVfDjx/cA7wCJgfc+WI0lS11QTaEMyc1KPVyJJUjdU8+HET0fEf+7xSiRJ6oZqRmhHA9MiYgUtU44BZGaO7tHKJEnqhA4DLSICmA6s2j7lSJLUNR0GWmZmRPwgM51ylCT1atVcQ3suIg7r8UokSeqGaq6hHQGcGRGrgPfxGpokqReqJtAm9ngVkiR1UzWBlj1ehSRJ3VRNoD1IS6gF0A8YBrwEjOrBuiRJ6pStBlrrOxwj4lDg/B6rSJKkLqjmLsfNZOZztNwoIklSr1HNp+1fWrG4AzAGeL3HKpIkqQvaHaFFxD8UT/8GGFA8dgbmAX/Z86VJklS9jkZoYyJiMPAb4KZW23YB1vVYVZIkdVJHgXYL8CgtdzUurFgftNz1eEAP1iVJUqe0O+WYmTdm5sHAHZl5QMVjWGYaZpKkXmWrdzlm5nnboxBJkrqj07ftS5LUGxlokqRSqOajr9RDXl/0OlfH1bUuQ5K2q5k5s0eO6whNklQKBpokqRQMNElSKRhokqRSMNAkSaVgoEmSSsFAkySVgoEmSSoFA02SVAoGmiSpFAw0SVIpGGiSpFIw0CRJpWCgSZJKwUCTJJWCgSZJKgUDTZJUCgaaJKkUDDRJUikYaJKkUjDQJEmlYKBJkkrBQJMklULdBFpEXBQRSyNi1jY41rci4oQOtt8ZEVO6cfyrIuKyru4vSeq8vrUuoBPOB07IzOatNYyIACIzP25re2b+zbYuTpJUW3UxQouIW4ADgH+JiHcqRz8R8UJEDC0eL0XE3cALwPhiRPejiHgxIh6OiP7FPptGYBFxbUT8KiKej4jvVrzshIh4OiJerRytRcT/jIifF+2vrlj/zYh4OSKeBEb07G9EktRaXQRaZk4HXgeOBW7ooOlw4ObMHAWsKpZ/UCy/DXyxsnFEDAJOAUZl5mjg2xWb9wOOBk4Cri3af6445uFAIzAmIiZExBjgS8W6zwOHtVdgRHwtIhZGxMIP+KDK34AkaWvqacqxGqsy898qlldk5pLi+SJgaKv27wDrgNsiYh4wr2LbPxVTlr+KiH2LdZ8rHouL5d1oCbgBwNzM/AAgIh5or8DMvBW4FWBwDM7OdU+S1J66GKG18iGb192v4vn7rdqur3j+Ea0CPDM/pGW0NZuWkdhD7ewbFT//NjMbi8efZuZtne+CJGlbq8dAWwkcChARhwLDunqgiNgNGJiZ/wz8d6BhK7v8FDi72I+I2D8i9gHmAydHRP+IGAD8RVdrkiR1TT1OOc4BpkbEi8AzwMvdONYA4P6I6EfL6OvSjhpn5sMRcTDwf1tupOQ94K8y87mIuBf4BfAW8PNu1CRJ6oLI9DJOrQyOwXku59a6DEnarmbmzG7tHxGLMnNs6/X1OOUoSdIWDDRJUikYaJKkUjDQJEmlYKBJkkrBQJMklYKBJkkqBQNNklQKBpokqRQMNElSKRhokqRSMNAkSaVgoEmSSsFAkySVgoEmSSoFA02SVAoGmiSpFAw0SVIpGGiSpFIw0CRJpWCgSZJKwUCTJJVC31oX8Ek2eMxgZi6cWesyJKkUHKFJkkrBQJMklYKBJkkqBQNNklQKBpokqRQMNElSKRhokqRSMNAkSaVgoEmSSsFAkySVgoEmSSoFA02SVAoGmiSpFAw0SVIpGGiSpFIw0CRJpWCgSZJKwUCTJJWCgSZJKgUDTZJUCgaaJKkUDDRJUikYaJKkUjDQJEmlYKBJkkrBQJMklUJkZq1r+MSKiD8AL9W6jm7aC/hdrYvoJvtQe/VeP9iH7ekzmbl365V9a1GJNnkpM8fWuojuiIiF9qH26r0P9V4/2IfewClHSVIpGGiSpFIw0Grr1loXsA3Yh96h3vtQ7/WDfag5bwqRJJWCIzRJUikYaJKkUjDQaiAiJkXESxHx64i4vNb1VCsibo+ItyLihYp1e0bEIxGxvPi5Ry1r7EhE/ElEPB4Rv4qIFyPi4mJ9PfWhX0Q8GxG/KPpwdbF+WEQ8U5xT90bETrWudWsiok9ELI6IecVyXfUhIlZGxC8jYklELCzW1c25BBARu0fE7IhYFhFLI+LIeutDJQNtO4uIPsAPgBOBkcB/jYiRta2qancCk1qtuxx4NDOHA48Wy73Vh8D/yMyRwDjgguJ3X099WA8cl5kNQCMwKSLGAdcBN2TmnwJrgf9WwxqrdTGwtGK5HvtwbGY2Vrx3q57OJYDvAw9l5kFAAy1/j3rrw3/ITB/b8QEcCfy0YvkK4Ipa19WJ+ocCL1QsvwTsVzzfj5Y3i9e8zir7cj/wX+q1D8AuwHPAEbR8ukPfYv1m51hvfABDaPnH8jhgHhB12IeVwF6t1tXNuQQMBFZQ3BxYj31o/XCEtv3tD/x7xXJzsa5e7ZuZq4vnbwD71rKYakXEUKAJeIY660MxVbcEeAt4BHgFeDszPyya1MM59T1gBvBxsTyI+utDAg9HxKKI+Fqxrp7OpWHAb4E7iqnfv4+IXamvPmzGQNM2ky3/pev17wOJiN2AOcAlmflu5bZ66ENmfpSZjbSMcg4HDqpxSZ0SEScBb2XmolrX0k1HZ+ahtFw+uCAiJlRurINzqS9wKPDDzGwC3qfV9GId9GEzBtr29xrwJxXLQ4p19erNiNgPoPj5Vo3r6VBE7EhLmM3KzJ8Uq+uqDxtl5tvA47RMz+0eERs/m7W3n1N/BkyOiJXA/6Fl2vH71FcfyMzXip9vAXNp+c9FPZ1LzUBzZj5TLM+mJeDqqQ+bMdC2v58Dw4s7unYCvgQ8UOOauuMB4Kzi+Vm0XJfqlSIigNuApZl5fcWmeurD3hGxe/G8Py3XAJfSEmxTima9ug+ZeUVmDsnMobSc/49l5pnUUR8iYteIGLDxOfA54AXq6FzKzDeAf4+IEcWq44FfUUd9aM1PCqmBiPg8LdcQ+gC3Z+Y1NS6pKhFxD3AMLV8x8SYwE/gn4B+B/wSsAk7PzN/XqsaORMTRwALgl/zHtZtv0HIdrV76MBq4i5ZzZwfgHzPzWxFxAC2jnT2BxcBfZeb62lVanYg4BrgsM0+qpz4Utc4tFvsCP87MayJiEHVyLgFERCPw98BOwKvAVyjOK+qkD5UMNElSKTjlKEkqBQNNklQKBpokqRQMNElSKRhokqRSMNAkSaVgoEmSSuH/A4bG1zf3NpQCAAAAAElFTkSuQmCC\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "A = pd.read_csv('House_prediction.csv')\n", + "\n", + "\n", + "ax1 = A.groupby(\"bathroom\").agg(np.mean)\n", + "ax1.plot.barh( y = 'hoa (R$)' , color='pink')\n", + "\n", + "ax1.plot.barh(y= 'property tax (R$)' , color='darkred')\n", + "\n", + "ax1.plot.barh(y= 'fire insurance (R$)' , color='purple')\n", + "\n", + "ax1.plot.barh(y= 'total (R$)' , color='darkblue')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "dnQSoBC-ImEz", + "outputId": "3ca09082-f26f-4d97-ed5c-cac7988767ec" + }, + "execution_count": 57, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 57 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file diff --git a/Assignment/Assignment_1/Aadvik_210002_DL_Stamatics_A1(1).ipynb b/Assignment/Assignment_1/Aadvik_210002_DL_Stamatics_A1(1).ipynb new file mode 100644 index 0000000..6b3b29d --- /dev/null +++ b/Assignment/Assignment_1/Aadvik_210002_DL_Stamatics_A1(1).ipynb @@ -0,0 +1,882 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + }, + "colab": { + "name": "Aadvik_210002_DL_Stamatics_A1(1).ipynb", + "provenance": [], + "collapsed_sections": [] + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "rvFM645NE-D2" + }, + "source": [ + "# Assignment 1 - Part 1\n", + "In this assignment, we will go through basic linear algebra, NumPy, and image manipulation using Python to get everyone on the same page.\n", + "\n", + "One of the aims of this assignment is to get you to start getting comfortable searching for useful library functions online. So in many of the functions you will implement, you will have to look up helper functions.\n", + "\n", + "\\\n", + "\n", + "## Instructions\n", + "* This notebook contain blocks of code, you are required to complete those blocks(where required)\n", + "* You are required to copy this notebook (\"copy to drive\" above) and complete the code.(DO NOT CHANGE THE NAME OF THE FUNCTIONS)\n", + "\n", + "\\\n", + "\\\n", + "Also, I'd like to acknowledge the Stanford CS131. This assignment is highly based on the assignments from that course." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UhSVK4RoK9q5" + }, + "source": [ + "First Let's import some dependencies" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "cCKqyfhIE-EQ" + }, + "source": [ + "# Imports the print function from newer versions of python\n", + "from __future__ import print_function\n", + "\n", + "# Setup\n", + "\n", + "# The Random module implements pseudo-random number generators\n", + "import random \n", + "\n", + "# Numpy is the main package for scientific computing with Python. \n", + "# This will be one of our most used libraries in this project\n", + "import numpy as np\n", + "\n", + "# The Time library helps us time code runtimes\n", + "import time\n", + "\n", + "\n", + "# Some more magic so that the notebook will reload external python modules;\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "%reload_ext autoreload" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true, + "id": "QLtp15rqE-EU" + }, + "source": [ + "# Part 1: Linear Algebra and NumPy Review\n", + "In this section, we will review linear algebra and learn how to use vectors and matrices in python using numpy." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E8HDYpc0E-EV" + }, + "source": [ + "## Part 1.1 (5 points)\n", + "First, let's test whether you can define the following matrices and vectors using numpy. Look up `np.array()` for help. In the next code block, define $M$ as a $(4, 3)$ matrix, $a$ as a $(1, 3)$ row vector and $b$ as a $(3, 1)$ column vector:\n", + "\n", + "$$M = \\begin{bmatrix}\n", + "1 & 2 & 3 \\\\\n", + "4 & 5 & 6 \\\\\n", + "7 & 8 & 9 \\\\\n", + "10 & 11 & 12 \\end{bmatrix}\n", + "$$\n", + "\n", + "$$a = \\begin{bmatrix}\n", + "1 & 1 & 0\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "$$b = \\begin{bmatrix}\n", + "-1 \\\\ 2 \\\\ 5\n", + "\\end{bmatrix} \n", + "$$ " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "mETk2NCME-EX", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "aeb8a105-dbec-4c27-ebfc-3720611e9c82" + }, + "source": [ + "### YOUR CODE HERE\n", + "M = np.array([[1,2,3] , [4,5,6] , [7,8,9] , [10,11,12]])\n", + "a = np.array( [[1,1,0]] )\n", + "b = np.array([[-1] , [2] , [5]])\n", + "### END CODE HERE\n", + "print(\"M = \\n\", M)\n", + "print(\"The size of M is: \", M.shape)\n", + "print()\n", + "print(\"a = \", a)\n", + "print(\"The size of a is: \", a.shape)\n", + "print()\n", + "print(\"b = \", b)\n", + "print(\"The size of b is: \", b.shape)" + ], + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "M = \n", + " [[ 1 2 3]\n", + " [ 4 5 6]\n", + " [ 7 8 9]\n", + " [10 11 12]]\n", + "The size of M is: (4, 3)\n", + "\n", + "a = [[1 1 0]]\n", + "The size of a is: (1, 3)\n", + "\n", + "b = [[-1]\n", + " [ 2]\n", + " [ 5]]\n", + "The size of b is: (3, 1)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rSta4NheE-EZ" + }, + "source": [ + "## Part 1.2 (5 points)\n", + "Implement the `dot_product()` method below and check that it returns the correct answer for $a^Tb$." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C5ZRjCE2MVOU" + }, + "source": [ + "def dot_product(a, b):\n", + " \"\"\"Implement dot product between the two vectors: a and b.\n", + " (optional): While you can solve this using for loops, we recommend\n", + " that you look up `np.dot()` online and use that instead.\n", + " Args:\n", + " a: numpy array of shape (x, n)\n", + " b: numpy array of shape (n, x)\n", + " Returns:\n", + " out: numpy array of shape (x, x) (scalar if x = 1)\n", + " \"\"\"\n", + " out = np.dot(a,b)\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 46, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "pbLIS5vIE-Ea", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "934eaff1-9d1d-4194-d2d1-acc03fb3f9ae" + }, + "source": [ + "# Now, let's test out this dot product. Your answer should be [[1]].\n", + "aDotB = dot_product(a, b)\n", + "print(aDotB)\n", + "\n", + "print(\"The size is: \", aDotB.shape)" + ], + "execution_count": 47, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0.0\n", + "The size is: ()\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0rGfcRU1E-Eb" + }, + "source": [ + "## Part 1.3 (5 points)\n", + "Implement the `complicated_matrix_function()` method and use it to compute $(ab)Ma^T$\n", + "\n", + "IMPORTANT NOTE: The `complicated_matrix_function()` method expects all inputs to be two dimensional numpy arrays, as opposed to 1-D arrays. This is an important distinction, because 2-D arrays can be transposed, while 1-D arrays cannot.\n", + "\n", + "To transpose a 2-D array, you can use the syntax `array.T` " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "dglQmbuLNOk6" + }, + "source": [ + "def complicated_matrix_function(M, a, b):\n", + " \"\"\"Implement (a * b) * (M * a.T).\n", + " (optional): Use the `dot_product(a, b)` function you wrote above\n", + " as a helper function.\n", + " Args:\n", + " M: numpy matrix of shape (x, n).\n", + " a: numpy array of shape (1, n).\n", + " b: numpy array of shape (n, 1).\n", + " Returns:\n", + " out: numpy matrix of shape (x, 1).\n", + " \"\"\"\n", + " out = np.dot(a,b)*np.dot(M,a.T)\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 18, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "da_uQQLhE-Ec", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ca4d664b-5ee5-49a3-b508-a10fbb5573e5" + }, + "source": [ + "# Your answer should be $[[3], [9], [15], [21]]$ of shape(4, 1).\n", + "ans = complicated_matrix_function(M, a, b)\n", + "print(ans)\n", + "print()\n", + "print(\"The size is: \", ans.shape)" + ], + "execution_count": 19, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[ 3]\n", + " [ 9]\n", + " [15]\n", + " [21]]\n", + "\n", + "The size is: (4, 1)\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "6CWXxSSOE-Ed", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "6d9547ca-01ad-4cd9-afe2-66c0ffc688d8" + }, + "source": [ + "M_2 = np.array(range(4)).reshape((2,2))\n", + "a_2 = np.array([[1,1]])\n", + "b_2 = np.array([[10, 10]]).T\n", + "print(M_2.shape)\n", + "print(a_2.shape)\n", + "print(b_2.shape)\n", + "print()\n", + "\n", + "# Your answer should be $[[20], [100]]$ of shape(2, 1).\n", + "ans = complicated_matrix_function(M_2, a_2, b_2)\n", + "print(ans)\n", + "print()\n", + "print(\"The size is: \", ans.shape)" + ], + "execution_count": 20, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2, 2)\n", + "(1, 2)\n", + "(2, 1)\n", + "\n", + "[[ 20]\n", + " [100]]\n", + "\n", + "The size is: (2, 1)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4fHLxLl4E-Ee" + }, + "source": [ + "## Part 1.4 (10 points) [Optional/Bonus]\n", + "Implement `eigen_decomp()` and `get_eigen_values_and_vectors()` methods. In this method, perform eigenvalue decomposition on the following matrix and return the largest k eigen values and corresponding eigen vectors (k is specified in the method calls below).\n", + "\n", + "$$M = \\begin{bmatrix}\n", + "1 & 2 & 3 \\\\\n", + "4 & 5 & 6 \\\\\n", + "7 & 8 & 9 \\end{bmatrix}\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "RfaCSoRMOIc8" + }, + "source": [ + "def eigen_decomp(M):\n", + " \"\"\"Implement eigenvalue decomposition.\n", + " (optional): You might find the `np.linalg.eig` function useful.\n", + " Args:\n", + " matrix: numpy matrix of shape (m, n)\n", + " Returns:\n", + " w: numpy array of shape (m, m) such that the column v[:,i] is the eigenvector corresponding to the eigenvalue w[i].\n", + " v: Matrix where every column is an eigenvector.\n", + " \"\"\"\n", + " w = None\n", + " v = None\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return w, v" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "YB120rb4ONBH" + }, + "source": [ + "def get_eigen_values_and_vectors(M, k):\n", + " \"\"\"Return top k eigenvalues and eigenvectors of matrix M. By top k\n", + " here we mean the eigenvalues with the top ABSOLUTE values (lookup\n", + " np.argsort for a hint on how to do so.)\n", + " (optional): Use the `eigen_decomp(M)` function you wrote above\n", + " as a helper function\n", + " Args:\n", + " M: numpy matrix of shape (m, m).\n", + " k: number of eigen values and respective vectors to return.\n", + " Returns:\n", + " eigenvalues: list of length k containing the top k eigenvalues\n", + " eigenvectors: list of length k containing the top k eigenvectors\n", + " of shape (m,)\n", + " \"\"\"\n", + " eigenvalues = []\n", + " eigenvectors = []\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return eigenvalues, eigenvectors" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "t0_GkrJwE-Ee" + }, + "source": [ + "# Let's define M.\n", + "M = np.array([[1,2,3],[4,5,6],[7,8,9]])\n", + "\n", + "# Now let's grab the first eigenvalue and first eigenvector.\n", + "# You should get back a single eigenvalue and a single eigenvector.\n", + "val, vec = get_eigen_values_and_vectors(M[:,:3], 1)\n", + "print(\"First eigenvalue =\", val[0])\n", + "print()\n", + "print(\"First eigenvector =\", vec[0])\n", + "print()\n", + "assert len(vec) == 1\n", + "\n", + "# Now, let's get the first two eigenvalues and eigenvectors.\n", + "# You should get back a list of two eigenvalues and a list of two eigenvector arrays.\n", + "val, vec = get_eigen_values_and_vectors(M[:,:3], 2)\n", + "print(\"Eigenvalues =\", val)\n", + "print()\n", + "print(\"Eigenvectors =\", vec)\n", + "assert len(vec) == 2" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Yeh-V5x1PYz5" + }, + "source": [ + "## Part 1.5 (10 points)\n", + "In this section, you'll implement a gaussian elimination.\n", + "\n", + "The algorithm to to reduce a matrix to rref using gaussian elimination contains 2 parts, First reducing the matrix to partial reduced form, then back substituting to calculate the rref. First algorithm can be summed up as:\n", + "1. Partial pivoting: Find the kth pivot by swapping rows, to move the entry with the largest absolute value to the pivot position. This imparts computational stability to the algorithm.\n", + "2. For each row below the pivot, calculate the factor f which makes the kth entry zero, and for every element in the row subtract the fth multiple of the corresponding element in the kth row.\n", + "3. Repeat above steps for each unknown. We will be left with a partial r.e.f. matrix.\n", + "\n", + "$$\\begin{bmatrix}\n", + "1 & 2 & 3 \\\\\n", + "4 & 5 & 6 \\\\\n", + "7 & 8 & 9 \\end{bmatrix}\n", + "=>\n", + "\\begin{bmatrix}\n", + "7 & 8 & 9 \\\\\n", + "4 & 5 & 6 \\\\\n", + "1 & 2 & 3 \\end{bmatrix}\n", + "=>\n", + "\\begin{bmatrix}\n", + "7 & 8 & 9 \\\\\n", + "0 & 0.42 & 0.85 \\\\\n", + "0 & 0.85 & 1.71 \\end{bmatrix}\n", + "=>\n", + "\\begin{bmatrix}\n", + "7 & 8 & 9 \\\\\n", + "0 & 0.85 & 1.71 \\\\\n", + "0 & 0.45 & 0.85 \\end{bmatrix}\n", + "=>\n", + "\\begin{bmatrix}\n", + "7 & 8 & 9 \\\\\n", + "0 & 0.42 & 0.85 \\\\\n", + "0 & 0 & -0.05 \\end{bmatrix}\n", + "$$\n", + "Second algorithm:\n", + "1. Take a pivot from the last row.\n", + "2. For each row above the pivot, calculate the factor f which makes the kth entry zero, and for every element in the row subtract the fth multiple of the corresponding element in the kth row\n", + "3. Repeat the above step untill the matrix is in rref\n", + "$$\\begin{bmatrix}\n", + "7 & 8 & 0 \\\\\n", + "0 & 0.42 & 0 \\\\\n", + "0 & 0 & -0.05 \\end{bmatrix}\n", + "=>\n", + "\\begin{bmatrix}\n", + "7 & 0 & 0 \\\\\n", + "0 & 0.42 & 0 \\\\\n", + "0 & 0 & -0.05 \\end{bmatrix}\n", + "$$\n", + "\n", + "Steps for implementation:\n", + "1. Complete the function `swap_rows()`\n", + "2. Complete the function `apply_row()`\n", + "3. Complete `forward()` and `backward()`\n", + "4. Finally implement `rref()` using the `forward()` and `backward()`\n", + "\n", + "Note: You can skip this part if you want." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "qUFujiFAPYz6" + }, + "source": [ + "def swap_rows(M):\n", + " \"\"\"Implement row swapping to make the largest element in the pivotial column to be the first row.\n", + " Args:\n", + " matrix: numpy matrix of shape (m, n)\n", + " Returns:\n", + " Ms: matrix with swapped row\n", + " \"\"\"\n", + " \n", + " for i in range(M):\n", + " j=max(M[i,0])\n", + " M[j,:]=M[0,:]\n", + " out = M\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 41, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "S8lbAUSWWpyO" + }, + "source": [ + "def apply_rows(M):\n", + " \"\"\"For each row below the pivot, calculate the factor f which makes the kth\n", + " entry zero, and for every element in the row subtract the fth multiple of the\n", + " corresponding element in the kth row.\n", + " Args:\n", + " matrix: numpy matrix of shape (m, n)\n", + " Returns:\n", + " Ms: matrix with all other entries of the pivotal col zero\n", + " \"\"\"\n", + " out = None\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "GnE_-JLxPYz7" + }, + "source": [ + "def forward(M):\n", + " \"\"\"Return a partial ref using the algo described above\n", + " Args:\n", + " M: numpy matrix of shape (m, n).\n", + " Returns:\n", + " Ms: ref of M\n", + " \"\"\"\n", + " out = None\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Wb7pPGP4XmJu" + }, + "source": [ + "def backward(M):\n", + " \"\"\"Return a rref using the algo described above\n", + " Args:\n", + " M: numpy matrix of shape (m, n).\n", + " Returns:\n", + " Ms: rref of M\n", + " \"\"\"\n", + " out = None\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "XLq81xzXYR85" + }, + "source": [ + "def rref(M):\n", + " \"\"\"Return a rref using the algo descrbed above\n", + " Args:\n", + " M: numpy matrix of shape (m, n).\n", + " Returns:\n", + " Ms: ref of M\n", + " \"\"\"\n", + " out = None\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Eiz6EbsWPYz8" + }, + "source": [ + "# Let's define M.\n", + "M = np.array([[1,2,3],[4,5,6],[7,8,9]])\n", + "\n", + "# Now let's calculate it's rref.\n", + "# Note that your code may be evaluated on other test cases as well\n", + "Mrref = rref(M)\n", + "print(Mrref)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "G46pyDzAE-Ef" + }, + "source": [ + "## Part 1.6 (10 points)\n", + "\n", + "To wrap up our overview of NumPy, let's implement something fun — a helper function for computing the Euclidean distance between two $n$-dimensional points!\n", + "\n", + "In the 2-dimensional case, computing the Euclidean distance reduces to solving the Pythagorean theorem $c = \\sqrt{a^2 + b^2}$. where, given two points $(x_1, y_1)$ and $(x_2, y_2)$, $a = x_1 - x_2$ and $b = y_1 - y_2$.\n", + "\n", + "\n", + "More generally, given two $n$-dimensional vectors, the Euclidean distance can be computed by:\n", + "\n", + "1. Performing an elementwise subtraction between the two vectors, to get $n$ difference values.\n", + "2. Squaring each of the $n$ difference values, and summing the squares.\n", + "4. Taking the square root of our sum.\n", + "\n", + "Alternatively, the Euclidean distance between length-$n$ vectors $u$ and $v$ can be written as:\n", + "\n", + "$\n", + "\\quad\\textbf{distance}(u, v) = \\sqrt{\\sum_{i=1}^n (u_i - v_i)^2}\n", + "$\n", + "\n", + "\n", + "Try implementing this function: first using native Python with a `for` loop in the `euclidean_distance_native()` function, then in NumPy **without any loops** in the `euclidean_distance_numpy()` function.\n", + "We've added some `assert` statements here to help you check functionality (if it prints nothing, then your implementation is correct)!" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "5xvHopPqO29C" + }, + "source": [ + "def euclidean_distance_native(u, v):\n", + " \"\"\"Computes the Euclidean distance between two vectors, represented as Python\n", + " lists.\n", + " Args:\n", + " u (List[float]): A vector, represented as a list of floats.\n", + " v (List[float]): A vector, represented as a list of floats.\n", + " Returns:\n", + " float: Euclidean distance between `u` and `v`.\n", + " \"\"\"\n", + " # First, run some checks:\n", + " assert isinstance(u, list)\n", + " assert isinstance(v, list)\n", + " assert len(u) == len(v)\n", + "\n", + " # Compute the distance!\n", + " # Notes:\n", + " # 1) Try breaking this problem down: first, we want to get\n", + " # the difference between corresponding elements in our\n", + " # input arrays. Then, we want to square these differences.\n", + " # Finally, we want to sum the squares and square root the\n", + " # sum.\n", + " sum = 0;\n", + " d = 0;\n", + " for i in range(len(u)):\n", + " d = (u[i]-v[i])**(2) \n", + " sum = sum + d\n", + " out = sum**(0.5)\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 22, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "wvLuK8MuO3LH" + }, + "source": [ + "def euclidean_distance_numpy(u, v):\n", + " \"\"\"Computes the Euclidean distance between two vectors, represented as NumPy\n", + " arrays.\n", + " Args:\n", + " u (np.ndarray): A vector, represented as a NumPy array.\n", + " v (np.ndarray): A vector, represented as a NumPy array.\n", + " Returns:\n", + " float: Euclidean distance between `u` and `v`.\n", + " \"\"\"\n", + " # First, run some checks:\n", + " assert isinstance(u, np.ndarray)\n", + " assert isinstance(v, np.ndarray)\n", + " assert u.shape == v.shape\n", + "\n", + " # Compute the distance!\n", + " # Note:\n", + " # 1) You shouldn't need any loops\n", + " # 2) Some functions you can Google that might be useful:\n", + " # np.sqrt(), np.sum()\n", + " # 3) Try breaking this problem down: first, we want to get\n", + " # the difference between corresponding elements in our\n", + " # input arrays. Then, we want to square these differences.\n", + " # Finally, we want to sum the squares and square root the\n", + " # sum.\n", + " a = np.square(v-u)\n", + " b = np.sum(a)\n", + " c = np.sqrt(b)\n", + " return c\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE" + ], + "execution_count": 37, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "" + ], + "metadata": { + "id": "LLm3s3EHiq6s" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "wu9MimVJE-Eg" + }, + "source": [ + "## Testing native Python function\n", + "assert euclidean_distance_native([7.0], [6.0]) == 1.0\n", + "assert euclidean_distance_native([7.0, 0.0], [3.0, 3.0]) == 5.0\n", + "assert euclidean_distance_native([7.0, 0.0, 0.0], [3.0, 0.0, 3.0]) == 5.0" + ], + "execution_count": 23, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "kJDk88g1E-Ej" + }, + "source": [ + "## Testing NumPy function\n", + "assert euclidean_distance_numpy(\n", + " np.array([7.0]),\n", + " np.array([6.0])\n", + ") == 1.0\n", + "assert euclidean_distance_numpy(\n", + " np.array([7.0, 0.0]),\n", + " np.array([3.0, 3.0])\n", + ") == 5.0\n", + "assert euclidean_distance_numpy(\n", + " np.array([7.0, 0.0, 0.0]),\n", + " np.array([3.0, 0.0, 3.0])\n", + ") == 5.0" + ], + "execution_count": 38, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import time\n", + "n = 1000\n", + "\n", + "# Create some length-n lists and/or n-dimensional arrays\n", + "a = [0.0] * n\n", + "b = [10.0] * n\n", + "a_array = np.array(a)\n", + "b_array = np.array(b)\n", + "\n", + "# Compute runtime for native implementation\n", + "start_time = time.time()\n", + "for i in range(10000):\n", + " euclidean_distance_native(a, b)\n", + "print(\"Native:\", (time.time() - start_time), \"seconds\")\n", + "\n", + "# Compute runtime for numpy implementation\n", + "# Start by grabbing the current time in seconds\n", + "start_time = time.time()\n", + "for i in range(10000):\n", + " euclidean_distance_numpy(a_array, b_array)\n", + "print(\"NumPy:\", (time.time() - start_time), \"seconds\")" + ], + "metadata": { + "id": "E7Z38WwHhoNl", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3653b6ad-a871-4d27-ba05-1dceef09e077" + }, + "execution_count": 40, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Native: 1.7147166728973389 seconds\n", + "NumPy: 0.11908769607543945 seconds\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Mjik4mQXE-Ek" + }, + "source": [ + "Next, let's take a look at how these two implementations compare in terms of runtime:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "t4e6MfhHE-Em" + }, + "source": [ + "As you can see, doing vectorized calculations (i.e. no for loops) with NumPy results in significantly faster computations! " + ] + }, + { + "cell_type": "markdown", + "source": [ + "Congrats You've come to the end of this notebook. If you solved everything above, impressive. If not, you might need to read/think a bit more. You can always ask doubts. Also, Note that you should submit it even if you cannot solve everything. We might evaluate these using a script later." + ], + "metadata": { + "id": "XvFE0Q5bhx6-" + } + } + ] +} \ No newline at end of file diff --git a/Assignment/Assignment_1/Aadvik_210002_DL_Stamatics_A1(2,3).ipynb b/Assignment/Assignment_1/Aadvik_210002_DL_Stamatics_A1(2,3).ipynb new file mode 100644 index 0000000..94f2be9 --- /dev/null +++ b/Assignment/Assignment_1/Aadvik_210002_DL_Stamatics_A1(2,3).ipynb @@ -0,0 +1,623 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Aadvik_210002_DL_Stamatics_A1(2,3).ipynb", + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "resources": { + "http://localhost:8080/nbextensions/google.colab/files.js": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "application/javascript" + ] + ], + "status": 200, + "status_text": "" + } + }, + "base_uri": "https://localhost:8080/", + "height": 73 + }, + "id": "OUKGDeCGsT0z", + "outputId": "691035bb-b1f8-4777-8cc1-3cbfc0f23d81" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving House_prediction.csv to House_prediction.csv\n" + ] + } + ], + "source": [ + "from google.colab import files \n", + "\n", + "uploaded= files.upload()\n" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "A = pd.read_csv('House_prediction.csv')\n", + "\n", + "\n", + "ax1 = A.groupby(\"city\").agg(np.mean)\n", + "ax1.plot.barh(y='rent amount (R$)' , color='pink')\n", + "\n", + "ax2 = A.groupby(\"city\").agg(np.mean)\n", + "ax2.plot.barh(y='rooms' , color='darkred')\n", + "\n", + "ax3 = A.groupby(\"city\").agg(np.mean)\n", + "ax3.plot.barh(y='area' , color='purple')\n", + "\n", + "ax4 = A.groupby(\"city\").agg(np.mean)\n", + "ax4.plot.barh(y='parking spaces' , color='darkblue')\n", + "\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "zEGlkasG0FUe", + "outputId": "167be6a5-86e8-461c-ba7c-8919db0db6da" + }, + "execution_count": 35, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 35 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "A = pd.read_csv('House_prediction.csv')\n", + "\n", + "\n", + "ax1 = A.groupby(\"rooms\").agg(np.mean)\n", + "ax1.plot.barh( y = 'hoa (R$)' , color='pink')\n", + "\n", + "ax1.plot.barh(y= 'property tax (R$)' , color='darkred')\n", + "\n", + "ax1.plot.barh(y= 'fire insurance (R$)' , color='purple')\n", + "\n", + "ax1.plot.barh(y= 'total (R$)' , color='darkblue')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "lveF8irnGFV-", + "outputId": "53f3302d-2440-4031-8897-a782f8dd6419" + }, + "execution_count": 53, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 53 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "A = pd.read_csv('House_prediction.csv')\n", + "\n", + "\n", + "ax1 = A.groupby(\"bathroom\").agg(np.mean)\n", + "ax1.plot.barh( y = 'hoa (R$)' , color='pink')\n", + "\n", + "ax1.plot.barh(y= 'property tax (R$)' , color='darkred')\n", + "\n", + "ax1.plot.barh(y= 'fire insurance (R$)' , color='purple')\n", + "\n", + "ax1.plot.barh(y= 'total (R$)' , color='darkblue')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "nvqVpRlpIRkq", + "outputId": "657b8037-7e32-44c5-9546-3ff7436cee9e" + }, + "execution_count": 54, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 54 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "A = pd.read_csv('House_prediction.csv')\n", + "\n", + "\n", + "ax1 = A.groupby(\"animal\").agg(np.mean)\n", + "ax1.plot.barh( y = 'hoa (R$)' , color='pink')\n", + "\n", + "ax1.plot.barh(y= 'property tax (R$)' , color='darkred')\n", + "\n", + "ax1.plot.barh(y= 'fire insurance (R$)' , color='purple')\n", + "\n", + "ax1.plot.barh(y= 'total (R$)' , color='darkblue')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "lgHB8RTPIYKh", + "outputId": "17c0a9fe-e0e5-4048-9624-93a36865707b" + }, + "execution_count": 55, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 55 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "A = pd.read_csv('House_prediction.csv')\n", + "\n", + "\n", + "ax1 = A.groupby(\"furniture\").agg(np.mean)\n", + "ax1.plot.barh( y = 'hoa (R$)' , color='pink')\n", + "\n", + "ax1.plot.barh(y= 'property tax (R$)' , color='darkred')\n", + "\n", + "ax1.plot.barh(y= 'fire insurance (R$)' , color='purple')\n", + "\n", + "ax1.plot.barh(y= 'total (R$)' , color='darkblue')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "akyXuLk1IbS7", + "outputId": "3370eef2-d5c0-4dfd-f4fb-b0a6d6059dfc" + }, + "execution_count": 56, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 56 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAAD4CAYAAACE2RPlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAVCUlEQVR4nO3df7RV5Z3f8fdXQX4kVAiCi8CsgglVICKB6yhLAZNaYk10/PWHs2zVmEaNZmJ0JZ0YZymadjWkU02MaRktZowhNh2J4nImNVNjo8N0VFBArkZ0os6gZoIuZahKCvLtH2dze7jcezn3x7nn3of3a62z2PvZz973+9wN58Oz977nRmYiSdJwd0irC5AkaSAYaJKkIhhokqQiGGiSpCIYaJKkIoxodQEHsyOOOCKnT5/e6jIkaVhZv379G5k5qXO7gdZC06dPZ926da0uQ5KGlYh4pat2LzlKkopgoEmSimCgSZKK4D00SWqyXbt2sXXrVnbu3NnqUoaV0aNHM23aNEaOHNlQfwNNkpps69atjBs3junTpxMRrS5nWMhM3nzzTbZu3cqMGTMa2sdLjpLUZDt37mTixImGWS9EBBMnTuzVrNZAk6RBYJj1Xm+/ZwaaJKkI3kOTpMH2iwH+QIUlbQN7vGHKGZokFe7ll1/mYx/7WFOOff/993PTTTcBsGzZMqZOncq8efOYPXs299xzz379ly1bts/6tm3bOO200wakFgNNktRn3/rWt7jiiis61q+++mo2bNjAmjVruOyyy9i1axcAzz77LEuWLGHFihXMnz+/I+wmTZrElClTWLt2bb9rMdAk6SDw/vvv8/nPf545c+awdOlS3nvvPQA2bNjAiSeeyNy5czn77LN56623ALjjjjs4/vjjOe644zj33HN599139zvmli1bGDVqFEccccR+22bOnMnYsWM7jrds2TIuueQSLr/8ctauXcvxxx/f0fess85i1apV/R6jgSZJB4EXXniBK6+8kvb2dsaPH8/q1asBuPDCC1m+fDmbNm3i2GOP5cYbbwTgnHPO4cknn2Tjxo3MmjWLlStX7nfMtWvXMn/+/C6/3lNPPcXMmTOZPHkyAIcddhhvvPEGe/bsYcyYMXz0ox/t6NvW1sZjjz3W7zEaaJJ0EJgxYwbz5s0DYMGCBbz88sts376dt99+myVLlgBw0UUX8eijjwKwefNmFi1axLHHHsuqVatob2/f75ivv/46kybt+1tcbrnlFubMmcMJJ5zAdddd19G+fPly1q9fz2233cYZZ5zBxo0bO7ZNnjyZ1157rd9jNNAk6SAwatSojuVDDz2U3bt399j/4osv5rbbbuOZZ57hhhtu6PIHnMeMGbNf+9VXX017ezurV6/mc5/7XMf2qVOn8qMf/YgvfvGLXHrppZxzzjkd++zcuZMxY8b0Z3iAj+1L0uAbIo/ZH3744UyYMIHHHnuMRYsWcffdd3fM1nbs2MGUKVPYtWsXq1atYurUqfvtP2vWLH74wx92eewzzzyTlStXctddd3HZZZfR3t7OnDlzOOSQQ1iwYAHvvPNOR98tW7YMyFOYztAk6SB211138dWvfpW5c+eyYcMGrr/+egC+8Y1vcMIJJ3DSSSdxzDHHdLnv4sWLefrpp8nMLrdff/313HzzzezZs4f77ruPhQsXcuedd7J06VJuvfXWjn6PPPIIn/70p/s9luiuEDVfW1tb+hurpfI999xzzJo1q9VlNMVVV13FGWecwamnntpQ/2XLlu33s2iLFy9mzZo1TJgwYb/+XX3vImJ9Zu43zXWGJknqs69//etdPtLfnVNOOWWf9W3btnHNNdd0GWa9ZaBJ0iAo9WrYkUceyZlnntlw/86BNmnSJM4666wu+/b2e2agSVKTjR49mjfffLPYUGuGvb8PbfTo0Q3v41OOktRk06ZNY+vWrWzbtq3VpQwre39jdaMMNElqspEjRzb8W5fVd15ylCQVwUCTJBXBQJMkFcF7aK20492B/821ktSIIfLxWwPJGZokqQgGmiSpCAaaJKkIBpokqQgGmiSpCAaaJKkIBpokqQgGmiSpCAaaJKkIBpokqQgGmiSpCAaaJKkIBpokqQgGmiSpCAaaJKkIBpokqQgGmiSpCAaaJKkIBpokqQgGmiSpCAaaJKkIBpokqQgGmiSpCEMm0CLi4oj4cDfbjomIDRHxdER8ZAC+VltE3NrD9lMi4sF+HH96RGzu6/6SpN4bMoEGXAx0GWjAWcC9mfnxzPzbRg4WESO625aZ6zLzS70vUZI0VDUl0KoZynMRcUdEtEfEzyJiTLVtXkT8TURsioj7ImJCRJwHtAGrqpnYmLpjnQ58GfhCRDzSefYTEV+JiGXV8v+KiG9HxDrgqmp9eUQ8ERFbImJR1a9jBhYRS6qvuXcGOK469Acj4t6I+GVErIqIqPoviIhfRMT6iHgoIqbUtW+MiI3Alc34vkqSutfMGdpM4HuZOQd4Gzi3av8B8IeZORd4BrghM+8F1gEXZOa8zHxv70Ey8y+AFcAtmfmJBr7uYZnZlpn/qVofkZm/Sy0Ub+ii/1eAKzNzHrAI2Pu1P17tMxs4CjgpIkYC3wXOy8wFwJ3Av6/6fx/4g8w8rqfiIuLSiFgXEeu2bX+rgeFIkhrRzEB7KTM3VMvrgekRcTgwPjN/UbXfBSwe4K/7407rP6mvoYv+a4GbI+JLVW27q/YnMnNrZu4BNlT7Hg18DPjLiNgA/BEwLSLGV/s+Wu17d3fFZebtVeC2TTp8Qu9HJ0nqUrf3mQbAb+uW3wfGdNexl3azbxCP7rT9nW7qeJ8uxpuZ34yIPwdOB9ZGxKc67Ve/bwDtmbmw/hhVoEmSWmhQHwrJzO3AW3vvZQH/Gtg7W9sBjOtyx339AzA5IiZGxCjgM/2pKSI+kpnPZOZy4EngmB66Pw9MioiF1b4jI2JOZr4NvB0RJ1f9LuhPTZKk3mvmDK07FwErImIs8Cvgs1X7n1bt7wEL6++j1cvMXRFxE/AE8Crwy37W8+WI+ASwB2gHfgos7KpjZv7f6gGWW6vLpyOAb1f7fRa4MyIS+Fk/a5Ik9VJkZqtrOGi1HT07193+g1aXIelgtKSt1RX0WUSsz8z9BjCUfg5NkqQ+M9AkSUUw0CRJRTDQJElFMNAkSUUw0CRJRTDQJElFMNAkSUUw0CRJRTDQJElFMNAkSUUw0CRJRTDQJElFMNAkSUUw0CRJRTDQJElFMNAkSUUw0CRJRTDQJElFMNAkSUUw0CRJRRjR6gIOauPGwpK2VlchSUVwhiZJKoKBJkkqgoEmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKoKBJkkqwgEDLSL+WUQ8HBGbq/W5EfFHzS9NkqTGNTJDuwO4FtgFkJmbgPObWZQkSb3VSKCNzcwnOrXtbkYxkiT1VSOB9kZEfARIgIg4D3i9qVVJktRLjXw48ZXA7cAxEfEq8BJwQVOrkiSpl3oMtIg4FLgiM0+NiA8Ah2TmjsEpTZKkxvUYaJn5fkScXC2/MzglSZLUe41ccnw6Ih4A/gzoCLXM/EnTqpIkqZcaCbTRwJvAJ+vaEjDQJElDxgEDLTM/OxiFSJLUHwcMtIj4PtUj+/Uy85KmVCRJUh80csnxwbrl0cDZwGvNKUeSpL5p5JLj6vr1iLgH+KumVSRJUh/05dP2ZwKTB7oQSZL6o5F7aDvY9x7ar4E/bFpFkiT1QSOXHMcNRiGSJPVHI78P7eFG2iRJaqVuZ2gRMRoYCxwREROAqDb9E2DqINQmSVLDerrkeBnwZeDDwFN17f8I3NbMoiRJ6q1uAy0zvwN8JyL+IDO/O4g1SZLUaz1dcvxkZv4ceDUizum83Q8nliQNJT1dclwC/Bw4o4ttfjixJGlI6emS4w3Vn344sSRpyGvkB6tHAecC0+v7Z+ZNzStLkqTeaeTDidcA24H1wG+bW44kSX3TSKBNy8zTml6JJEn90MiHE/91RBzb9EokSeqHRmZoJwMXR8RL1C45BpCZObeplUmS1As9BlpEBHA58MrglCNJUt/0GGiZmRHxvcz0kqMkaUhr5B7aUxFxfNMrkSSpHxq5h3YCcEFEvAK8g/fQJElDUCOB9qmmVyFJUj81EmjZ9CokSeqnRgLtz6mFWgCjgRnA88CcJtYlSVKvHDDQOj/hGBHzgSuaVpEkSX3QyFOO+8jMp6g9KCJJ0pDRyKftX1O3egiwAHitaRVJktQH3c7QIuLuavF6YFz1GgU8CPxe80uTJKlxPc3QFkTEh4G/A77badtYYGfTqpIkqZd6CrQVwMPUnmpcV9ce1J56PKqJdUmS1CvdXnLMzFszcxbw/cw8qu41IzMNM0nSkHLApxwz8wuDUYgkSf3R68f2JUkaigw0SVIRGvnoKzXLjnfhF+sO3E+SSrKkrSmHdYYmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKsKwCbSI+FJEPBcRqwbgWDdFxKk9bP/TiDivH8dfFhFf6ev+kqTeG9HqAnrhCuDUzNx6oI4REUBk5p6utmfm9QNdnCSptYbFDC0iVgBHAT+NiO31s5+I2BwR06vX8xHxA2AzsKia0d0REe0R8bOIGFPt0zEDi4hvRsSzEbEpIv647ssujoi/johf1c/WIuKrEfFk1f/GuvbrImJLRPwVcHRzvyOSpM6GRaBl5uXAa8AngFt66DoT+M+ZOQd4pVr/XrX+NnBufeeImAicDczJzLnAv6vbPAU4GfgM8M2q/9LqmL8LzAMWRMTiiFgAnF+1nQ4c312BEXFpRKyLiHXbtr/V4HdAknQgw+mSYyNeycy/qVt/KTM3VMvrgemd+m8HdgIrI+JB4MG6bfdXlyyfjYgjq7al1evpav2D1AJuHHBfZr4LEBEPdFdgZt4O3A7QdvTs7N3wJEndGRYztE52s2/do+uW3+nU97d1y+/TKcAzcze12da91GZi/6ObfaPuz/+QmfOq10czc2XvhyBJGmjDMdBeBuYDRMR8YEZfDxQRHwQOz8y/AK4GjjvALg8Bl1T7ERFTI2Iy8ChwVkSMiYhxwBl9rUmS1DfD8ZLjauDCiGgHHge29ONY44A1ETGa2uzrmp46Z+bPImIW8L9rD1Lyf4B/lZlPRcSPgY3Ab4An+1GTJKkPItPbOK3SdvTsXHf7D1pdhiQNriVt/do9ItZn5n4HGY6XHCVJ2o+BJkkqgoEmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKoKBJkkqgoEmSSqCgSZJKsKIVhdwUBs3Fpa0tboKSSqCMzRJUhEMNElSEQw0SVIRDDRJUhEMNElSEQw0SVIRDDRJUhEMNElSEQw0SVIRDDRJUhEMNElSEQw0SVIRDDRJUhEMNElSEQw0SVIRDDRJUhEMNElSEQw0SVIRDDRJUhEMNElSEQw0SVIRDDRJUhEMNElSEQw0SVIRDDRJUhEMNElSESIzW13DQSsidgDPt7qOAXAE8EarixggpYzFcQwtpYwDhsZY/mlmTurcOKIVlajD85nZ1uoi+isi1pUwDihnLI5jaCllHDC0x+IlR0lSEQw0SVIRDLTWur3VBQyQUsYB5YzFcQwtpYwDhvBYfChEklQEZ2iSpCIYaJKkIhhoLRARp0XE8xHxYkR8rdX1HEhE/E5EPBIRz0ZEe0RcVbV/KCL+MiJeqP6cULVHRNxajW9TRMxv7Qj2FRGHRsTTEfFgtT4jIh6v6v1xRBxWtY+q1l+stk9vZd31ImJ8RNwbEb+MiOciYuFwPB8RcXX1d2pzRNwTEaOHy/mIiDsj4jcRsbmurdfnICIuqvq/EBEXDZFx/Mfq79amiLgvIsbXbbu2GsfzEfGpuvbWv69lpq9BfAGHAn8LHAUcBmwEZre6rgPUPAWYXy2PA7YAs4FvAV+r2r8GLK+WTwd+CgRwIvB4q8fQaTzXAD8CHqzW/ztwfrW8AvhCtXwFsKJaPh/4catrrxvDXcC/qZYPA8YPt/MBTAVeAsbUnYeLh8v5ABYD84HNdW29OgfAh4BfVX9OqJYnDIFxLAVGVMvL68Yxu3rPGgXMqN7LDh0q72st/0t9sL2AhcBDdevXAte2uq5ejmEN8C+ofcrJlKptCrUfFAf4E+D36/p39Gv1C5gGPAx8EniweoN5o+4fb8f5AR4CFlbLI6p+MQTGcHgVBNGpfVidjyrQ/r56Mx9RnY9PDafzAUzvFAS9OgfA7wN/Ute+T79WjaPTtrOBVdXyPu9Xe8/JUHlf85Lj4Nv7j3ivrVXbsFBd5vk48DhwZGa+Xm36NXBktTyUx/ht4N8Ce6r1icDbmbm7Wq+vtWMc1fbtVf9WmwFsA75fXTr9rxHxAYbZ+cjMV4E/Bv4OeJ3a93c9w+981OvtORiS56aTS6jNLmGIj8NAU8Mi4oPAauDLmfmP9duy9t+yIf0zIBHxGeA3mbm+1bX00whql4j+S2Z+HHiH2uWtDsPkfEwAfo9aQH8Y+ABwWkuLGkDD4RwcSERcB+wGVrW6lkYYaIPvVeB36tanVW1DWkSMpBZmqzLzJ1XzP0TElGr7FOA3VftQHeNJwJkR8TLw36hddvwOMD4i9n6uaX2tHeOoth8OvDmYBXdjK7A1Mx+v1u+lFnDD7XycCryUmdsycxfwE2rnaLidj3q9PQdD9dwQERcDnwEuqMIZhvg4DLTB9yQws3qS6zBqN7cfaHFNPYqIAFYCz2XmzXWbHgD2PpV1EbV7a3vbL6ye7DoR2F53GaZlMvPazJyWmdOpfd9/npkXAI8A51XdOo9j7/jOq/q3/H/cmflr4O8j4uiq6Z8DzzLMzge1S40nRsTY6u/Y3nEMq/PRSW/PwUPA0oiYUM1Yl1ZtLRURp1G7NH9mZr5bt+kB4PzqidMZwEzgCYbK+9pg37Tz1fHE0xZqTwVd1+p6Gqj3ZGqXTjYBG6rX6dTuXzwMvAD8T+BDVf8AvleN7xmgrdVj6GJMp/D/n3I8ito/yheBPwNGVe2jq/UXq+1HtbruuvrnAeuqc3I/tSfkht35AG4EfglsBu6m9vTcsDgfwD3U7v3tojZr/lxfzgG1e1QvVq/PDpFxvEjtntjef+8r6vpfV43jeeBf1rW3/H3Nj76SJBXBS46SpCIYaJKkIhhokqQiGGiSpCIYaJKkIhhokqQiGGiSpCL8P70gri7ukDv+AAAAAElFTkSuQmCC\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAAD4CAYAAACE2RPlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAX2ElEQVR4nO3deZCV9Z3v8fdXQSGIGnEpE0xAr0ZkDYsOKoqaG401icYli3gVk5TBJZOY0pBUbsWl7tTVKNHRxEuwXDOoGYhRs5jNnZBEaAUBEQaFeFuZuNxo0AwZhO/94zx0Dm13c7qh+5x+fL+qTvHs53Oepvnwe87TpyMzkSSpt9uh3gEkSdoeLDRJUilYaJKkUrDQJEmlYKFJkkqhT70DvJvtueeeOWTIkHrHkKRepamp6dXM3Kv1cgutjoYMGcLChQvrHUOSepWI+GNby73kKEkqBQtNklQKFpokqRR8D01Sr7Rhwwaam5tZv359vaOom/Tr14/BgwfTt2/fmra30CT1Ss3NzQwcOJAhQ4YQEfWOo+0sM3nttddobm5m6NChNe3jJUdJvdL69esZNGiQZVZSEcGgQYM6NQK30CT1WpZZuXX262uhSZJKwffQJJXCNdt5tHZxL/hdkY888gg77bQThx9+eM373HvvvRx00EEccsgh2yXDddddxx577MFZZ53F1KlTefTRR9ltt93ITL7zne9w3HHHbbH9ZZddxmWXXdYyv2TJEmbMmMFtt922zVkcoUlSN9q4cWO3HPftt9/mkUceYf78+Z3a79577+WZZ57ZbhluueUWzjjjjJZlV199NYsWLeK6665j2rRpLcvnzZvHYYcdxsyZM5kwYQIPPvggACNHjqS5uZkXXnhhm/NYaJLUBWvWrOHggw9mypQpDBs2jNNOO42//vWvQOVj7aZPn87YsWOZM2cOd911FyNHjmTEiBFMnz695Ri77LILF110EcOHD+e4447jlVdeAeC5557jhBNOYNy4cUyaNIlnn30WgKlTpzJt2jQOO+wwPvWpTzFz5kyuvfZaxowZw+OPP87QoUPZsGEDAH/5y1+2mAeYP38+999/P5dccgljxozhueee46abbmLChAmMHj2aU089teU1nHTSSdxxxx0AfP/732fKlCnvOAcPPfQQY8eOpU+fd17smzhxIi+++GLL/Fe/+lW+/e1vM23aNH7zm99w4IEHtqz7+Mc/zt133921L0QVC02SumjFihWcf/75LF++nF133ZUbb7yxZd2gQYN48sknOeqoo5g+fToPPfQQixYtYsGCBdx7770AvPXWW4wfP55ly5Zx9NFHc/nllwNw7rnncsMNN9DU1MQ111zD+eef33Lc5uZm5s+fzz333MO0adO46KKLWLRoEZMmTWLy5Mn87Gc/A+Duu+/mlFNO2eJnuA4//HA+8YlPtIyiDjjgAE455RQWLFjA4sWLGTZsGDfffDMAs2bN4oorruDxxx9nxowZ3HDDDe94/b/97W8ZN25cm+fmF7/4BSeffHLL/E477dRS2Lvtthsf+MAHWtaNHz+exx9/vHMnvw0WmiR10X777ccRRxwBwJlnnsm8efNa1n36058GYMGCBUyePJm99tqLPn36MGXKFB577DEAdthhh5btNu//5ptvMn/+fE4//XTGjBnDF7/4RdauXdty3NNPP50dd9yxzTxf+MIXuPXWWwG49dZbOeecc7b6GpYuXcqkSZMYOXIks2fPZtmyZQDss88+XHHFFRxzzDHMmDGDPfbY4x37rl27lr322vJD7y+55BIOOuggzjjjjC1Go7NmzeL222/n+uuv57Of/Sxr1qxpWbf33nvz0ksvbTXr1lhoktRFrW8rr54fMGBAl463adMmdt99dxYtWtTyWL58eU3HPeKII1izZg2PPPIIGzduZMSIEVt9zqlTp/Ld736XJUuWcOmll27xc19Llixh0KBB7ZZN//793/FzYldffTUrV67kqquu4nOf+1zL8kMOOYSf/OQnnHfeeUyaNInPf/7zLevWr19P//79t5p1ayw0SeqiF154gd/97ncA3HnnnRx55JHv2ObQQw/l0Ucf5dVXX2Xjxo3cddddHH300QBs2rSJuXPnbrH/rrvuytChQ5kzZw5Q+cSMxYsXt/n8AwcOZN26dVssO+usszjjjDPaHZ213mfdunXsu+++bNiwgdmzZ7csf+KJJ3jggQd46qmnuOaaa1i9evU7jjVs2DBWrVrV5vNceOGFbNq0iV/+8pdAZSQI0LdvX8aOHbtFhpUrV9ZUvluVmT7q9Bg3blxK6ppnnnmmrs+/evXq/NCHPpRTpkzJgw8+OE855ZR86623MjPzgx/8YL7yyist29555505YsSIHD58eH7ta19rWT5gwIC86KKLcvjw4XnMMcfkyy+/nJmZzz//fB5//PE5atSoHDZsWF5++eWZmXn22WfnnDlzWvZfsWJFjhw5MkePHp2PPfZYZmauXbs2+/Xrl3/+85/bzD1v3rwcNmxYjhkzJletWpU33nhjDhkyJCdMmJAXXnhhnn322bl+/focNWpUNjU1ZWbmfffdl5MnT85NmzZtcaw1a9bkpEmTWuZb55s7d24ee+yxmZl53nnn5cSJE3Pw4ME5evTofPjhh1u2u+CCC/L+++9vM29bX2dgYbbxb2rd/1F/Nz8sNKnrGqHQhg8fvk3HGDBgwHZK83dz5szJM888c7sftz0nn3xyrly5subtL7300i3m169fn4cddlhu2LChze07U2j+YLUklcSXvvQlHnjgAX7+85/32HNeeeWVrF27dovb8DsyefLkLeZfeOEFrrzyyjZv/e+sqJSd6mH8+PG5cOHCeseQeqXly5czbNiwesdQN2vr6xwRTZk5vvW23hQiqdfyP+Tl1tmvr4UmqVfq168fr732mqVWUpmV34fWr1+/mvfxPTRJvdLgwYNpbm5u+fQJlc/m31hdKwtNUq/Ut2/fmn+Tsd4dvOQoSSoFC02SVAoWmiSpFHwPrY7+1NS03X/LriQ1ip7+rd+O0CRJpWChSZJKwUKTJJWChSZJKgULTZJUChaaJKkULDRJUilYaJKkUrDQJEmlYKFJkkrBQpMklYKFJkkqBQtNklQKFpokqRQsNElSKVhokqRSsNAkSaVgoUmSSsFCkySVgoUmSSoFC02SVAoWmiSpFCw0SVIpNEyhRcTUiHhfO+sOjohFEfFURBywHZ5rfERc38H6yRHx0204/pCIWNrV/SVJndcwhQZMBdosNOBkYG5mfjgzn6vlYBHRp711mbkwM/+p8xElSY2qWwqtGKEsj4ibImJZRPwqIvoX68ZExO8j4umI+HFEvDciTgPGA7OLkVj/qmOdCHwFOC8iHm49+omIiyPismL6kYi4LiIWAl8u5q+KiCciYmVETCq2axmBRcTRxXNuHgEOLA69S0TMjYhnI2J2RESx/biIeDQimiLilxGxb9XyxRGxGLigO86rJKl93TlCOxD4XmYOB14HTi2W3wFMz8xRwBLg0sycCywEpmTmmMz8z80HycyfAzOBazPzmBqed6fMHJ+ZM4r5Ppl5KJVSvLSN7S8GLsjMMcAkYPNzf7jY5xBgf+CIiOgL3ACclpnjgFuAfy62vxX4UmaO7ihcRJwbEQsjYuGbNbwYSVJt2r0stx2szsxFxXQTMCQidgN2z8xHi+W3A3O28/P+sNX8PdUZ2tj+t8B3ImI2cE9mNheDsScysxkgIhYV+74OjAB+XWyzI7A2Inan8roeK475A+BjbYXLzFnALID9IrILr0+S1IbuLLS/VU1vBPq3t2Envc2WI8t+rda/1U6OjbTxejPzyoj4GXAi8NuIOL7VftX7BrAsMydWH6MoNElSHfXoTSGZ+Qbw583vZQH/A9g8WlsHDGxzxy39Cdg7IgZFxM7AP25Lpog4IDOXZOZVwALg4A42XwHsFRETi337RsTwzHwdeD0ijiy2m7ItmSRJndedI7T2nA3MjIj3AM8D5xTLbyuW/ycwsfp9tGqZuSEirgCeAF4Ent3GPF+JiGOATcAy4AFgYlsbZuZ/FTewXF9cPu0DXFfsdw5wS1QuI/5qGzNJkjopMn0bp172i8gv1zuEJHWTi7upXyKiKTPHt17eSD+HJklSl1lokqRSsNAkSaVgoUmSSsFCkySVgoUmSSoFC02SVAoWmiSpFCw0SVIpWGiSpFKw0CRJpWChSZJKwUKTJJWChSZJKgULTZJUChaaJKkULDRJUilYaJKkUrDQJEmlYKFJkkrBQpMklUKfegd4N9tn3DguXriw3jEkqRQcoUmSSsFCkySVgoUmSSoFC02SVAoWmiSpFCw0SVIpWGiSpFKw0CRJpbDVQouIgyLiwYhYWsyPioj/2f3RJEmqXS0jtJuAbwAbADLzaeAz3RlKkqTOqqXQ3pOZT7Ra9nZ3hJEkqatqKbRXI+IAIAEi4jRgbbemkiSpk2r5cOILgFnAwRHxIrAamNKtqSRJ6qQOCy0idgTOz8yPRMQAYIfMXNcz0SRJql2HhZaZGyPiyGL6rZ6JJElS59VyyfGpiLgfmAO0lFpm3tNtqSRJ6qRaCq0f8BpwbNWyBCw0SVLD2GqhZeY5PRFEkqRtsdVCi4hbKW7Zr5aZn+uWRJIkdUEtlxx/WjXdD/gk8FL3xJEkqWtqueT4o+r5iLgLmNdtiSRJ6oKufNr+gcDe2zuIJEnbopb30Nax5Xto/wFM77ZEkiR1QS2XHAf2RBBJkrZFLb8P7cFalkmSVE/tjtAioh/wHmDPiHgvEMWqXYH390A2SZJq1tElxy8CXwHeBzxZtfwvwHe7M5QkSZ3VbqFl5r8A/xIRX8rMG3owkyRJndbRJcdjM/Mh4MWIOKX1ej+cWJLUSDq65Hg08BDw8TbW+eHEkqSG0tElx0uLP/1wYklSw6vlB6t3Bk4FhlRvn5lXdF8sSZI6p5YPJ74PeANoAv7WvXEkSeqaWgptcGae0O1JJEnaBrV8OPH8iBjZ7UkkSdoGtYzQjgSmRsRqKpccA8jMHNWtySRJ6oQOCy0iApgG/LFn4kiS1DUdFlpmZkR8LzO95ChJami1vIf2ZERM6PYkkiRtg1reQzsMmBIRfwTewvfQJEkNqJZCO77bU0iStI1qKbTs9hSSJG2jWgrtZ1RKLYB+wFBgBTC8G3NJktQpWy201nc4RsRY4PxuSyRJUhfUcpfjFjLzSSo3ikiS1DBq+bT9r1bN7gCMA17qtkSSJHVBuyO0iPhBMfktYGDx2Bn4KXBS90eTJKl2HY3QxkXE+4AXgBtarXsPsL7bUkmS1EkdFdpM4EEqdzUurFoeVO563L8bc0mS1CntXnLMzOszcxhwa2buX/UYmpmWmSSpoWz1LsfMPK8ngkiStC06fdu+JEmNyEKTJJVCLR99pW7yp6YmromodwxJ6lEXZ/d8RLAjNElSKVhokqRSsNAkSaVgoUmSSsFCkySVgoUmSSoFC02SVAoWmiSpFCw0SVIpWGiSpFKw0CRJpWChSZJKwUKTJJWChSZJKgULTZJUChaaJKkULDRJUilYaJKkUrDQJEmlYKFJkkrBQpMklYKFJkkqBQtNklQKvabQIuKfImJ5RMzeDse6IiI+0sH62yLitG04/mURcXFX95ckdV6fegfohPOBj2Rm89Y2jIgAIjM3tbU+M7+1vcNJkuqrV4zQImImsD/wQES8UT36iYilETGkeKyIiDuApcCkYkR3U0Qsi4hfRUT/Yp+WEVhEXBkRz0TE0xFxTdXTHhUR8yPi+erRWkRcEhELiu0vr1r+zYhYGRHzgA917xmRJLXWKwotM6cBLwHHANd2sOmBwI2ZORz4YzH/vWL+deDU6o0jYhDwSWB4Zo4C/lfV6n2BI4F/BK4stv9occxDgTHAuIg4KiLGAZ8plp0ITGgvYEScGxELI2LhmzW+fknS1vWmS461+GNm/r5qfnVmLiqmm4AhrbZ/A1gP3BwRPwV+WrXu3uKS5TMRsU+x7KPF46lifhcqBTcQ+HFm/hUgIu5vL2BmzgJmAewXkZ17eZKk9vSKEVorb7Nl7n5V02+12vZvVdMbaVXgmfk2ldHWXCojsV+0s29U/fm/M3NM8fhvmXlz51+CJGl7642FtgYYCxARY4GhXT1QROwC7JaZPwcuAkZvZZdfAp8r9iMi3h8RewOPASdHRP+IGAh8vKuZJEld0xsvOf4IOCsilgF/AFZuw7EGAvdFRD8qo6+vdrRxZv4qIoYBv6vcSMmbwJmZ+WRE/BBYDLwMLNiGTJKkLohM38apl/0i8sv1DiFJPezibeydiGjKzPGtl/fGS46SJL2DhSZJKgULTZJUChaaJKkULDRJUilYaJKkUrDQJEmlYKFJkkrBQpMklYKFJkkqBQtNklQKFpokqRQsNElSKVhokqRSsNAkSaVgoUmSSsFCkySVgoUmSSoFC02SVAoWmiSpFCw0SVIpWGiSpFLoU+8A72b7jBvHxQsX1juGJJWCIzRJUilYaJKkUrDQJEmlYKFJkkrBQpMklYKFJkkqBQtNklQKFpokqRQsNElSKVhokqRSsNAkSaVgoUmSSsFCkySVgoUmSSoFC02SVAoWmiSpFCw0SVIpWGiSpFKw0CRJpWChSZJKwUKTJJWChSZJKgULTZJUChaaJKkULDRJUilYaJKkUojMrHeGd62IWAesqHeOGu0JvFrvEDXqLVl7S04wa3cxa9d8MDP3ar2wTz2SqMWKzBxf7xC1iIiFZt2+ektOMGt3Mev25SVHSVIpWGiSpFKw0OprVr0DdIJZt7/ekhPM2l3Muh15U4gkqRQcoUmSSsFCkySVgoVWBxFxQkSsiIhVEfH1eudpLSLWRMSSiFgUEQuLZXtExK8j4t+LP99bp2y3RMTLEbG0almb2aLi+uI8Px0RYxsg62UR8WJxbhdFxIlV675RZF0REcf3cNb9IuLhiHgmIpZFxJeL5Q11bjvI2XDnNSL6RcQTEbG4yHp5sXxoRPyhyPTDiNipWL5zMb+qWD+kAbLeFhGrq87rmGJ5Xb+32pWZPnrwAewIPAfsD+wELAYOqXeuVhnXAHu2WvZt4OvF9NeBq+qU7ShgLLB0a9mAE4EHgAD+AfhDA2S9DLi4jW0PKf4u7AwMLf6O7NiDWfcFxhbTA4GVRaaGOrcd5Gy481qcm12K6b7AH4pz9W/AZ4rlM4HziunzgZnF9GeAH/bg17+9rLcBp7WxfV2/t9p7OELreYcCqzLz+cz8L+Bu4KQ6Z6rFScDtxfTtwMn1CJGZjwH/r9Xi9rKdBNyRFb8Hdo+IfXsmabtZ23MScHdm/i0zVwOrqPxd6RGZuTYznyym1wHLgffTYOe2g5ztqdt5Lc7Nm8Vs3+KRwLHA3GJ563O6+VzPBY6LiKhz1vbU9XurPRZaz3s/8H+r5pvp+BuyHhL4VUQ0RcS5xbJ9MnNtMf0fwD71idam9rI16rm+sLhMc0vVpduGyVpc6vowlf+lN+y5bZUTGvC8RsSOEbEIeBn4NZUR4uuZ+XYbeVqyFuvfAAbVK2tmbj6v/1yc12sjYufWWQsN8b1loaktR2bmWOBjwAURcVT1yqxcc2jIn/do5GyF/wMcAIwB1gIz6htnSxGxC/Aj4CuZ+ZfqdY10btvI2ZDnNTM3ZuYYYDCVkeHBdY7UrtZZI2IE8A0qmScAewDT6xhxqyy0nvcisF/V/OBiWcPIzBeLP18GfkzlG/FPmy8pFH++XL+E79BetoY715n5p+Ifjk3ATfz98lfds0ZEXyolMTsz7ykWN9y5bStnI5/XIt/rwMPARCqX5zZ/jm51npasxfrdgNd6OGp11hOKS7yZmX8DbqXBzmtrFlrPWwAcWNzptBOVN3/vr3OmFhExICIGbp4GPgospZLx7GKzs4H76pOwTe1lux84q7gj6x+AN6oun9VFq/cZPknl3EIl62eKO92GAgcCT/RgrgBuBpZn5neqVjXUuW0vZyOe14jYKyJ2L6b7A/+dynt+DwOnFZu1Pqebz/VpwEPFqLheWZ+t+s9MUHmvr/q8NtT3FuBdjvV4ULlDaCWV6+nfrHeeVtn2p3JX2GJg2eZ8VK7lPwj8O/AbYI865buLyiWlDVSu23++vWxU7sD6XnGelwDjGyDrD4osT1P5R2Hfqu2/WWRdAXysh7MeSeVy4tPAouJxYqOd2w5yNtx5BUYBTxWZlgLfKpbvT6VUVwFzgJ2L5f2K+VXF+v0bIOtDxXldCvwrf78Tsq7fW+09/OgrSVIpeMlRklQKFpokqRQsNElSKVhokqRSsNAkSaVgoUmSSsFCkySVwv8H+vsCJ+LVljUAAAAASUVORK5CYII=\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAAD4CAYAAACE2RPlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAWtklEQVR4nO3dfZBV9Z3n8fdXUEElqPgQkdmADkHBpbsFFR1hfNqAicOoQc2WEyRujKjxYV2X0WQdNBVrNJXVRCfGMuPjFHEdIYwWzhiNDwPqjgaEGA0oUSDTipoQ1KiBRf3uH31gLk13c7ub5vY9vl9Vt/qec37n3O+v+xQffr9z7r2RmUiSVO92qHUBkiRtCwaaJKkUDDRJUikYaJKkUjDQJEml0LfWBXyS7bXXXjl06NBalyFJdWXRokW/y8y9W6830Gpo6NChLFy4sNZlSFJdiYhVba13ylGSVAoGmiSpFAw0SVIpeA1NUq+1YcMGmpubWbduXa1LUQ3069ePIUOGsOOOO1bV3kCT1Gs1NzczYMAAhg4dSkTUuhxtR5nJmjVraG5uZtiwYVXt45SjpF5r3bp1DBo0yDD7BIoIBg0a1KnRuYEmqVczzD65Ovu3N9AkSaXgNTRJdePquHqbHm9mztymx1NtOUKTpA7ceOONHHzwwZx55pk88MADXHvttV0+Vnf3741Wr17NSSedBMATTzzBwIEDaWxs5KCDDuKyyy7bov1VV121xboTTjiBtWvXdrsWA02SOnDzzTfzyCOPMGvWLCZPnszll1++RZsPP/ywqmO1t/+2Um0d29L111/POeecs2l5/PjxLFmyhMWLFzNv3jyeeuopAN577z1OP/10fvjDHzJ69GhmzJixaZ8vf/nL3Hzzzd2uxUCTpHZMnz6dV199lRNPPJEbbriBO++8k69//esATJs2jenTp3PEEUcwY8YMXnnlFSZNmsSYMWMYP348y5Yt2+J4rfe/6KKLOOqoozjggAOYPXs20DLimTBhAo2NjRxyyCEsWLAAgN12223TcWbPns20adParOPZZ5/lyCOPpKmpiaOOOoqXXnpp02ufeuqpTJo0ieHDh28WKA899BCHHnooDQ0NHH/88QC8//77nH322Rx++OE0NTVx//33t/k7mjNnDpMmTdpiff/+/WlsbOS1114D4O6772a33XbjvPPOY8mSJUydOnVT28mTJ3PPPfdU8RfpmNfQJKkdt9xyCw899BCPP/44e+21F3feeedm25ubm3n66afp06cPxx9/PLfccgvDhw/nmWee4fzzz+exxx7r8PirV6/mySefZNmyZUyePJkpU6bw4x//mIkTJ/LNb36Tjz76iA8++GCrdVbW8e6777JgwQL69u3Lz372M77xjW8wZ84cgE0jp5133pkRI0Zw4YUX0q9fP8455xzmz5/PsGHD+P3vfw/ANddcw3HHHcftt9/O22+/zeGHH84JJ5zArrvuuul1V6xYwR577MHOO++8RU1r165l+fLlTJgwAYCddtqJd999lz/+8Y/ssMMOHHLIIZva7rHHHqxfv541a9YwaNCgrfa3PQaaJHXRaaedRp8+fXjvvfd4+umnOe200zZtW79+/Vb3P/nkk9lhhx0YOXIkb775JgCHHXYYZ599Nhs2bODkk0+msbGx6joA3nnnHc466yyWL19ORLBhw4ZN7Y4//ngGDhwIwMiRI1m1ahVr165lwoQJm968vOeeewLw8MMP88ADD/Dd734XaHlP4G9+8xsOPvjgTcdbvXo1e++9+be4LFiwgIaGBpYvX84ll1zCpz/9aQCmTp3Kyy+/zF133cWCBQu49NJLmTJlyqb99tlnH15//XUDTZJqYeNo5eOPP2b33XdnyZIlndq/cmSTmQBMmDCB+fPn8+CDDzJt2jQuvfRSpk6dutl7slq/2bhy1HTllVdy7LHHMnfuXFauXMkxxxzT5uv16dOnw2tumcmcOXMYMWJEu2369++/RS3jx49n3rx5rFixgnHjxnH66afT2NjITjvtxHe+8x122WUXzjjjDCZOnMjYsWPZ+J2Q69ato3///u2+VjUMNEl1o7feZv+pT32KYcOGcd9993HaaaeRmTz//PM0NDR0+lirVq1iyJAhnHPOOaxfv57nnnuOqVOnsu+++7J06VJGjBjB3LlzGTBgQJv7v/POO+y///4AW0yRtmXcuHGcf/75rFixYtOU45577snEiRO56aabuOmmm4gIFi9eTFNT02b7fvazn2XlypVtHnfYsGFcfvnlXHfdddxzzz0sX76cz3zmMwAMHz6cgQMHbppOzUzeeOMNuvuFx94UIknbwKxZs7jttttoaGhg1KhR7d5EsTVPPPEEDQ0NNDU1ce+993LxxRcDcO2113LSSSdx1FFHsd9++7W7/4wZM7jiiitoamqq6q7Hvffem1tvvZVTTz2VhoYGzjjjDKBlpLdhwwZGjx7NqFGjuPLKK7fYd9ddd+XAAw/k17/+dZvHnj59OvPnz2flypUsW7aMY445hjvuuIOmpia+8IUvMHLkSAAWLVrEuHHj6Nu3e2Os2DjM1fY3duzY9BurpfYtXbp0s2s26n3mzp3LokWL+Pa3v11V+6uuumqL96JdfPHFTJ48edMdlpXaOgciYlFmjm3d1ilHSVKXnXLKKaxZs6bq9pXX9DY65JBD2gyzznLKUVKv5ixS7/fVr3616rZtBVrlG7MrdfZvb6BJ6rX69evHmjVrDLVPoI3fh9avX7+q93HKUVKvNWTIEJqbm/ntb39b61JUAxu/sbpaBpqkXmvHHXes+tuKJaccJUmlYKBJkkrBQJMklYLX0Gro9UWvb/Nv4JW0ffXWj+P6JHKEJkkqBQNNklQKBpokqRQMNElSKRhokqRSMNAkSaVgoEmSSsFAkySVgoEmSSoFA02SVAoGmiSpFAw0SVIpGGiSpFIw0CRJpWCgSZJKwUCTJJWCgSZJKgUDTZJUCgaaJKkUDDRJUikYaJKkUjDQJEmlYKBJkkqh1wRaREyLiMHtbDsoIpZExOKIOHAbvNbYiLixg+3HRMS8bhx/aES80NX9JUmd12sCDZgGtBlowMnA7MxsysxXqjlYRPRtb1tmLszMizpfoiSpt+qRQCtGKEsj4kcR8WJEPBwR/YttjRHxbxHxfETMjYg9ImIKMBaYVYzE+lcc6/PAJcB5EfF469FPRFwWEVcVz5+IiO9FxELg4mL5uoh4NiJejojxRbtNI7CI+PPiNTeOAAcUh94tImZHxLKImBURUbQfExH/GhGLIuKnEbFfxfpfRMQvgAt64vcqSWpfT47QhgM/yMxRwNvAF4v1dwN/nZmjgV8CMzNzNrAQODMzGzPzjxsPkpn/DNwC3JCZx1bxujtl5tjM/N/Fct/MPJyWUJzZRvvLgAsysxEYD2x87aZin5HAAcCfRcSOwE3AlMwcA9wOXFO0vwO4MDMbOiouIr4WEQsjYuEHfFBFdyRJ1Wh3Wm4bWJGZS4rni4ChETEQ2D0z/7VYfxdw3zZ+3XtbLf+ksoY22j8FXB8Rs4CfZGZzMRh7NjObASJiSbHv28AhwCNFmz7A6ojYnZZ+zS+O+Q/AiW0Vl5m3ArcCDI7B2YX+SZLa0JOBtr7i+UdA//YadtKHbD6y7Ndq+/vt1PERbfQ3M6+NiAeBzwNPRcTEVvtV7hvAi5l5ZOUxikCTJNXQdr0pJDPfAdZuvJYFfBnYOFr7AzCgzR039yawT0QMioidgZO6U1NEHJiZv8zM64CfAwd10PwlYO+IOLLYd8eIGJWZbwNvR8TRRbszu1OTJKnzenKE1p6zgFsiYhfgVeArxfo7i/V/BI6svI5WKTM3RMS3gGeB14Bl3aznkog4FvgYeBH4F+DIthpm5v8rbmC5sZg+7Qt8r9jvK8DtEZHAw92sSZLUSZHpZZxaGRyD81zOrXUZkrphZrZ1r5l6UkQsysyxrdf3pvehSZLUZQaaJKkUDDRJUikYaJKkUjDQJEmlYKBJkkrBQJMklYKBJkkqBQNNklQKBpokqRQMNElSKRhokqRSMNAkSaVgoEmSSsFAkySVgoEmSSoFA02SVAoGmiSpFAw0SVIpGGiSpFIw0CRJpdC31gV8kg0eM5iZC2fWugxJKgVHaJKkUjDQJEmlYKBJkkrBQJMklYKBJkkqBQNNklQKBpokqRQMNElSKWw10CLisxHxaES8UCyPjoj/1fOlSZJUvWpGaD8CrgA2AGTm88CXerIoSZI6q5pA2yUzn2217sOeKEaSpK6qJtB+FxEHAgkQEVOA1T1alSRJnVTNhxNfANwKHBQRrwErgDN7tCpJkjqpw0CLiD7A+Zl5QkTsCuyQmX/YPqVJklS9DgMtMz+KiKOL5+9vn5IkSeq8aqYcF0fEA8B9wKZQy8yf9FhVkiR1UjWB1g9YAxxXsS4BA02S1GtsNdAy8yvboxBJkrpjq4EWEXdQ3LJfKTPP7pGKJEnqgmqmHOdVPO8HnAK83jPlSJLUNdVMOc6pXI6Ie4Ane6wiSZK6oCuftj8c2GdbFyJJUndUcw3tD2x+De0N4K97rCJJkrqgminHAdujEEmSuqOa70N7tJp1kiTVUrsjtIjoB+wC7BURewBRbPoUsP92qE2SpKp1NOV4LnAJMBh4rmL9u8Df9WRRkiR1VruBlpnfB74fERdm5k3bsSZJkjqtoynH4zLzMeC1iDi19XY/nFiS1Jt0NOX458BjwF+0sc0PJ5Yk9SodTTnOLH764cSSpF6vmjdW7wx8ERha2T4zv9VzZUmS1DnVfDjx/cA7wCJgfc+WI0lS11QTaEMyc1KPVyJJUjdU8+HET0fEf+7xSiRJ6oZqRmhHA9MiYgUtU44BZGaO7tHKJEnqhA4DLSICmA6s2j7lSJLUNR0GWmZmRPwgM51ylCT1atVcQ3suIg7r8UokSeqGaq6hHQGcGRGrgPfxGpokqReqJtAm9ngVkiR1UzWBlj1ehSRJ3VRNoD1IS6gF0A8YBrwEjOrBuiRJ6pStBlrrOxwj4lDg/B6rSJKkLqjmLsfNZOZztNwoIklSr1HNp+1fWrG4AzAGeL3HKpIkqQvaHaFFxD8UT/8GGFA8dgbmAX/Z86VJklS9jkZoYyJiMPAb4KZW23YB1vVYVZIkdVJHgXYL8CgtdzUurFgftNz1eEAP1iVJUqe0O+WYmTdm5sHAHZl5QMVjWGYaZpKkXmWrdzlm5nnboxBJkrqj07ftS5LUGxlokqRSqOajr9RDXl/0OlfH1bUuQ5K2q5k5s0eO6whNklQKBpokqRQMNElSKRhokqRSMNAkSaVgoEmSSsFAkySVgoEmSSoFA02SVAoGmiSpFAw0SVIpGGiSpFIw0CRJpWCgSZJKwUCTJJWCgSZJKgUDTZJUCgaaJKkUDDRJUikYaJKkUjDQJEmlYKBJkkrBQJMklULdBFpEXBQRSyNi1jY41rci4oQOtt8ZEVO6cfyrIuKyru4vSeq8vrUuoBPOB07IzOatNYyIACIzP25re2b+zbYuTpJUW3UxQouIW4ADgH+JiHcqRz8R8UJEDC0eL0XE3cALwPhiRPejiHgxIh6OiP7FPptGYBFxbUT8KiKej4jvVrzshIh4OiJerRytRcT/jIifF+2vrlj/zYh4OSKeBEb07G9EktRaXQRaZk4HXgeOBW7ooOlw4ObMHAWsKpZ/UCy/DXyxsnFEDAJOAUZl5mjg2xWb9wOOBk4Cri3af6445uFAIzAmIiZExBjgS8W6zwOHtVdgRHwtIhZGxMIP+KDK34AkaWvqacqxGqsy898qlldk5pLi+SJgaKv27wDrgNsiYh4wr2LbPxVTlr+KiH2LdZ8rHouL5d1oCbgBwNzM/AAgIh5or8DMvBW4FWBwDM7OdU+S1J66GKG18iGb192v4vn7rdqur3j+Ea0CPDM/pGW0NZuWkdhD7ewbFT//NjMbi8efZuZtne+CJGlbq8dAWwkcChARhwLDunqgiNgNGJiZ/wz8d6BhK7v8FDi72I+I2D8i9gHmAydHRP+IGAD8RVdrkiR1TT1OOc4BpkbEi8AzwMvdONYA4P6I6EfL6OvSjhpn5sMRcTDwf1tupOQ94K8y87mIuBf4BfAW8PNu1CRJ6oLI9DJOrQyOwXku59a6DEnarmbmzG7tHxGLMnNs6/X1OOUoSdIWDDRJUikYaJKkUjDQJEmlYKBJkkrBQJMklYKBJkkqBQNNklQKBpokqRQMNElSKRhokqRSMNAkSaVgoEmSSsFAkySVgoEmSSoFA02SVAoGmiSpFAw0SVIpGGiSpFIw0CRJpWCgSZJKwUCTJJVC31oX8Ek2eMxgZi6cWesyJKkUHKFJkkrBQJMklYKBJkkqBQNNklQKBpokqRQMNElSKRhokqRSMNAkSaVgoEmSSsFAkySVgoEmSSoFA02SVAoGmiSpFAw0SVIpGGiSpFIw0CRJpWCgSZJKwUCTJJWCgSZJKgUDTZJUCgaaJKkUDDRJUikYaJKkUjDQJEmlYKBJkkrBQJMklUJkZq1r+MSKiD8AL9W6jm7aC/hdrYvoJvtQe/VeP9iH7ekzmbl365V9a1GJNnkpM8fWuojuiIiF9qH26r0P9V4/2IfewClHSVIpGGiSpFIw0Grr1loXsA3Yh96h3vtQ7/WDfag5bwqRJJWCIzRJUikYaJKkUjDQaiAiJkXESxHx64i4vNb1VCsibo+ItyLihYp1e0bEIxGxvPi5Ry1r7EhE/ElEPB4Rv4qIFyPi4mJ9PfWhX0Q8GxG/KPpwdbF+WEQ8U5xT90bETrWudWsiok9ELI6IecVyXfUhIlZGxC8jYklELCzW1c25BBARu0fE7IhYFhFLI+LIeutDJQNtO4uIPsAPgBOBkcB/jYiRta2qancCk1qtuxx4NDOHA48Wy73Vh8D/yMyRwDjgguJ3X099WA8cl5kNQCMwKSLGAdcBN2TmnwJrgf9WwxqrdTGwtGK5HvtwbGY2Vrx3q57OJYDvAw9l5kFAAy1/j3rrw3/ITB/b8QEcCfy0YvkK4Ipa19WJ+ocCL1QsvwTsVzzfj5Y3i9e8zir7cj/wX+q1D8AuwHPAEbR8ukPfYv1m51hvfABDaPnH8jhgHhB12IeVwF6t1tXNuQQMBFZQ3BxYj31o/XCEtv3tD/x7xXJzsa5e7ZuZq4vnbwD71rKYakXEUKAJeIY660MxVbcEeAt4BHgFeDszPyya1MM59T1gBvBxsTyI+utDAg9HxKKI+Fqxrp7OpWHAb4E7iqnfv4+IXamvPmzGQNM2ky3/pev17wOJiN2AOcAlmflu5bZ66ENmfpSZjbSMcg4HDqpxSZ0SEScBb2XmolrX0k1HZ+ahtFw+uCAiJlRurINzqS9wKPDDzGwC3qfV9GId9GEzBtr29xrwJxXLQ4p19erNiNgPoPj5Vo3r6VBE7EhLmM3KzJ8Uq+uqDxtl5tvA47RMz+0eERs/m7W3n1N/BkyOiJXA/6Fl2vH71FcfyMzXip9vAXNp+c9FPZ1LzUBzZj5TLM+mJeDqqQ+bMdC2v58Dw4s7unYCvgQ8UOOauuMB4Kzi+Vm0XJfqlSIigNuApZl5fcWmeurD3hGxe/G8Py3XAJfSEmxTima9ug+ZeUVmDsnMobSc/49l5pnUUR8iYteIGLDxOfA54AXq6FzKzDeAf4+IEcWq44FfUUd9aM1PCqmBiPg8LdcQ+gC3Z+Y1NS6pKhFxD3AMLV8x8SYwE/gn4B+B/wSsAk7PzN/XqsaORMTRwALgl/zHtZtv0HIdrV76MBq4i5ZzZwfgHzPzWxFxAC2jnT2BxcBfZeb62lVanYg4BrgsM0+qpz4Utc4tFvsCP87MayJiEHVyLgFERCPw98BOwKvAVyjOK+qkD5UMNElSKTjlKEkqBQNNklQKBpokqRQMNElSKRhokqRSMNAkSaVgoEmSSuH/A4bG1zf3NpQCAAAAAElFTkSuQmCC\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "A = pd.read_csv('House_prediction.csv')\n", + "\n", + "\n", + "ax1 = A.groupby(\"bathroom\").agg(np.mean)\n", + "ax1.plot.barh( y = 'hoa (R$)' , color='pink')\n", + "\n", + "ax1.plot.barh(y= 'property tax (R$)' , color='darkred')\n", + "\n", + "ax1.plot.barh(y= 'fire insurance (R$)' , color='purple')\n", + "\n", + "ax1.plot.barh(y= 'total (R$)' , color='darkblue')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "dnQSoBC-ImEz", + "outputId": "3ca09082-f26f-4d97-ed5c-cac7988767ec" + }, + "execution_count": 57, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 57 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file diff --git a/Assignment/Assignment_2/Aadvik_210002_DL_Stamatics_A2.ipynb b/Assignment/Assignment_2/Aadvik_210002_DL_Stamatics_A2.ipynb new file mode 100644 index 0000000..265ac89 --- /dev/null +++ b/Assignment/Assignment_2/Aadvik_210002_DL_Stamatics_A2.ipynb @@ -0,0 +1,720 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Aadvik_210002_DL_Stamatics_A2.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "rvFM645NE-D2" + }, + "source": [ + "# Assignment 2\n", + "In this assignment, we will go through Perceptron, Linear Classifiers, Loss Functions, Gradient Descent and Back Propagation.\n", + "\n", + "\n", + "PS. this one is not from Stanford's course.\n", + "\n", + "\n", + "\n", + "\\\n", + "\n", + "## Instructions\n", + "* This notebook contain blocks of code, you are required to complete those blocks(where required)\n", + "* You are required to copy this notebook (\"copy to drive\" above) and complete the code.(DO NOT CHANGE THE NAME OF THE FUNCTIONS)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true, + "id": "QLtp15rqE-EU" + }, + "source": [ + "# Part 1: Perceptron\n", + "In this section, we will see how to implement a perceptron. Goal would be for you to delve into the mathematics.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Zao4e-DphaGA" + }, + "source": [ + "## Intro\n", + "What's a perceptron? It's an algorithm modelled on biological computational model to classify things into binary classes. It's a supervides learning algorithm, meaning that you need to provide labelled data containing features and the actual classifications. A perceptron would take these features as input and spit out a binary value (0 or 1). While training the model with training data, we try to minimise the error and learn the parameters involved." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wDTUoAd6ixm-" + }, + "source": [ + "**How does it work?**\\\n", + "A perceptron is modelled on a biological neuron. A neuron has input dendrites and the output is carried by axons. Similarly, a perceptron takes inputs called \"features\". After processing, a perceptron gives output. For computation, it has a \"weight\" vector which is multipled with feature vector. An activation function is added to introduce some non linearities and the output is given out.\\\n", + "It can be represented as: $$ f=\\sum_{i=1}^{m} w_ix_i +b$$\n", + "\n", + "Let's implement this simple function to give an output.\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "iXezofBIgzId" + }, + "source": [ + "import numpy as np\n", + "\n", + "class perceptron():\n", + " def __init__(self,num_input_features=8):\n", + " self.weights = np.random.randn(num_input_features)\n", + " self.bias = np.random.random()\n", + "\n", + " def activation(self,x):\n", + " \n", + " if x>=0:\n", + " return 1\n", + " else:\n", + " return 0\n", + " \n", + " pass\n", + "\n", + " def forward(self,x: np.ndarray):\n", + " '''\n", + " you have random initialized weights and bias\n", + " you can access then using `self.weights` and `self.bias`\n", + " you should use activation function before returning\n", + " \n", + " x : input features\n", + " return : a binary value as the output of the perceptron \n", + " '''\n", + " # YOUR CODE HERE\n", + " a = np.dot(self.weights,x)\n", + " a += self.bias\n", + " fwd = self.activation(a)\n", + " return fwd\n", + " pass\n", + " # YOUR CODE HERE" + ], + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "oSKwDFAyocVo" + }, + "source": [ + "np.random.seed(0)\n", + "perc = perceptron(8)\n", + "assert perc.forward(np.arange(8))==1" + ], + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true, + "id": "NWTTg1e9r7uM" + }, + "source": [ + "# Part 2: Linear Classifier\n", + "In this section, we will see how to implement a linear Classifier.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DYDO4GcHr7uM" + }, + "source": [ + "## Intro\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-HFvjH06r7uN" + }, + "source": [ + "**How does it work?**\n", + "\n", + "Linear Classifier uses the following function: $$Y = WX+b$$ Where, $W$ is a 2d array of weights with shape (#features, #classes).\n", + "\n", + "\n", + "Let's implement this classifier.\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "9A13CEkGr7uN" + }, + "source": [ + "import numpy as np\n", + "\n", + "class LinearClassifier():\n", + " def __init__(self,num_input_features=32,num_classes=5):\n", + " self.weights = np.random.randn(num_input_features,num_classes)\n", + " self.bias = np.random.rand(num_classes)\n", + "\n", + " def forward(self,x: np.ndarray):\n", + " '''\n", + " x: input features\n", + " you have random initialized weights and bias\n", + " you can access then using `self.weights` and `self.bias`\n", + " return an output vector of num_classes size\n", + " '''\n", + " # YOUR CODE HERE\n", + " \n", + " A = np.dot(x , self.weights)\n", + " A += self.bias\n", + " return A\n", + " \n", + " # YOUR CODE HERE" + ], + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "zgzPxyTsr7uN", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "79f5724b-9d1c-4c32-c380-509345a7bf9d" + }, + "source": [ + "np.random.seed(0)\n", + "lc = LinearClassifier()\n", + "lc.forward(np.random.rand(1,32))\n", + "# Should be close to:\n", + "# array([[ 1.30208164, 5.58136003, 0.87793013, -4.7332119 , 4.81172123]])" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 1.30208164, 5.58136003, 0.87793013, -4.7332119 , 4.81172123]])" + ] + }, + "metadata": {}, + "execution_count": 12 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true, + "id": "ZVgOVzJetuqo" + }, + "source": [ + "# Part 3: Loss Functions, Gradient descent and Backpropagation\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4pXryjpctuqy" + }, + "source": [ + "## Intro\n", + "\n", + "Loss Functions tells how \"off\" the output od our model is. Based upon the application, you can use several different loss functions. Formally, A loss function is a function $L:(z,y)\\in\\mathbb{R}\\times Y\\longmapsto L(z,y)\\in\\mathbb{R}$ that takes as inputs the predicted value $z$ corresponding to the real data value yy and outputs how different they are We'll implement L1 loss, L2 loss, Logistic loss, hinge loss and cross entropy loss functions." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QGRb8BHotuqy" + }, + "source": [ + "### **L1 loss**\n", + "L1 loss is the linear loss function $L = \\dfrac{1}{2}|y−z| $\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "YxVh6IL2tuqz" + }, + "source": [ + "import numpy as np\n", + "def L1Loss(z,y):\n", + " '''\n", + " y : True output.\n", + " z : Predicted output.\n", + " return : L\n", + " '''\n", + " if y>z:\n", + " L = 0.5*(y-z)\n", + " else:\n", + " L = 0.5*(z-y)\n", + " return L\n", + " pass" + ], + "execution_count": 13, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2xy8ZS84cKtQ" + }, + "source": [ + "### **L2 loss**\n", + "L2 loss is the quadratic loss function or the least square error function $L = \\dfrac{1}{2}(y−z)^2 $\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "JThp5P-KcKtS" + }, + "source": [ + "import numpy as np\n", + "def L2Loss(z,y):\n", + " '''\n", + " y : True output. \n", + " z : Predicted output. \n", + " return : L\n", + " '''\n", + " L = 0.5*(y-z)*(y-z)\n", + " return L\n", + " pass" + ], + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Z2JNLnWYcLSC" + }, + "source": [ + "### **Hinge Loss**\n", + "Hinge loss is: $ L = max( 0, 1 - yz ) $" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "gQ1YM4J-cLSC" + }, + "source": [ + "import numpy as np\n", + "def hingeLoss(z,y):\n", + " \n", + " H = 1-y*z\n", + " if H>0:\n", + " L = H \n", + " else: \n", + " L = 0\n", + " return L\n", + " pass" + ], + "execution_count": 16, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m15_MjradMNY" + }, + "source": [ + "### **Cross Entropy Loss**\n", + "Another very famous loss function is Cross Entropy loss: $ L = −[ylog(z)+(1−y)log(1−z)] $." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "snJLqhszdMNY" + }, + "source": [ + "import numpy as np\n", + "def CELoss(z,y):\n", + " '''\n", + " y : True output. \n", + " z : Predicted output. \n", + " return : L\n", + " '''\n", + " Lp = y*math.log(z)\n", + " Lu = (1-y)*math.log(1-z)\n", + " L = -1*(Lu + Lp)\n", + " return L\n", + " pass" + ], + "execution_count": 17, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OsRPsfzxyEVL" + }, + "source": [ + "### **0-1 Loss**\n", + "Loss Function used by perceptron is: $ \\begin{cases} \n", + " 0=z-y & z=y \\\\\n", + " 1=\\dfrac{z-y}{z-y} & z\\neq y\n", + " \\end{cases} $." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "5sA7GxLHyEVM" + }, + "source": [ + "import numpy as np\n", + "def zeroOneLoss(z,y):\n", + " if z==y:\n", + " L = 0 \n", + " else: \n", + " L = 1\n", + " return L \n", + " pass" + ], + "execution_count": 18, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CWhbibHcgRR8" + }, + "source": [ + "## Cost Function\n", + "The cost function $J$ is commonly used to assess the performance of a model, and is defined with the loss function $L$ as follows:\n", + "$$\\boxed{J(\\theta)=\\sum_{i=1}^mL(h_\\theta(x^{(i)}), y^{(i)})}$$\n", + "where $h_\\theta$ is the hypothesis function i.e. the function used to predict the output." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "SSbmhW4og97t" + }, + "source": [ + "lossFunctions = {\n", + " \"l1\" : L1Loss,\n", + " \"l2\" : L2Loss,\n", + " \"hinge\" : hingeLoss,\n", + " \"cross-entropy\" : CELoss,\n", + " \"0-1\" : zeroOneLoss\n", + "}\n", + "\n", + "def cost(Z : np.ndarray, Y : np.ndarray, loss : str):\n", + " '''\n", + " Z : a numpy array of predictions.\n", + " Y : a numpy array of true values.\n", + " return : A numpy array of costs calculated for each example.\n", + " '''\n", + " loss_func = lossFunctions[loss]\n", + " # YOUR CODE HERE\n", + " J = 0\n", + " for i in range(np.size(Y)):\n", + " J += loss_func(Y[i] , Z[i])\n", + " J = J/np.size(Y)\n", + " return J \n", + " # YOUR CODE HERE\n", + " pass" + ], + "execution_count": 20, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "upsN7A0zjGqx" + }, + "source": [ + "## Gradient Descent and Back Propagation\n", + "Gradient Descent is an algorithm that minimizes the loss function by calculating it's gradient. By noting $\\alpha\\in\\mathbb{R}$ the learning rate, the update rule for gradient descent is expressed with the learning rate $\\alpha$ and the cost function $J$ as follows:\n", + "\n", + "$$\\boxed{ W \\longleftarrow W -\\alpha\\nabla J( W )}$$\n", + "​\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AFCN-fYCqidi" + }, + "source": [ + "But we need to find the partial derivative of Loss function wrt every parameter to know what is the slight change that we need to apply to our parameters. This becomes particularly hard if we have more than 1 layer in our algorithm. Here's where **Back Propagation** comes in. It's a way to find gradients wrt every parameter using the chain rule. Backpropagation is a method to update the weights in the neural network by taking into account the actual output and the desired output. The derivative with respect to weight ww is computed using chain rule and is of the following form:\n", + "\n", + "$$\\boxed{\\frac{\\partial L(z,y)}{\\partial w}=\\frac{\\partial L(z,y)}{\\partial a}\\times\\frac{\\partial a}{\\partial z}\\times\\frac{\\partial z}{\\partial w}}$$\n", + "​\n", + " \n", + "As a result, the weight is updated as follows:\n", + "\n", + "$$\\boxed{w\\longleftarrow w-\\alpha\\frac{\\partial L(z,y)}{\\partial w}}$$\n", + "\n", + "So, In a neural network, weights are updated as follows:\n", + "\n", + "* Step 1: Take a batch of training data.\n", + "* Step 2: Perform forward propagation to obtain the corresponding loss.\n", + "* Step 3: Backpropagate the loss to get the gradients.\n", + "* Step 4: Use the gradients to update the weights of the network.\n", + "​\n", + "\n", + "Bonus Problem\n", + " \n", + "Now, Assuming that you know Back Propagation (read a bit about it, if you don't), we'll now implement an image classification model on CIFAR-10." + ] + }, + { + "cell_type": "markdown", + "source": [ + "# **Bonus Problem**\n", + "\n", + "Now, Assuming that you know Back Propagation (read a bit about it, if you don't), we'll now implement an image classification model on CIFAR-10." + ], + "metadata": { + "id": "sJoG5kkYopRN" + } + }, + { + "cell_type": "code", + "source": [ + "import tensorflow as tf \n", + " \n", + "# Display the version\n", + "print(tf.__version__) \n", + " \n", + "# other imports\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from tensorflow.keras.layers import Input, Conv2D, Dense, Flatten, Dropout\n", + "from tensorflow.keras.layers import GlobalMaxPooling2D, MaxPooling2D\n", + "from tensorflow.keras.layers import BatchNormalization\n", + "from tensorflow.keras.models import Model" + ], + "metadata": { + "id": "_4-4RceVsor_", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "959d9c90-87fc-402e-abfe-e6603b30ae10" + }, + "execution_count": 23, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2.8.0\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yyplk5PLEUsJ", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "8b4da816-4519-4174-cf45-8b7e3ee62ebe" + }, + "source": [ + "import tensorflow as tf \n", + "# Load in the data\n", + "cifar10 = tf.keras.datasets.cifar10\n", + " \n", + "# Distribute it to train and test set\n", + "(x_train, y_train), (x_test, y_test) = cifar10.load_data()\n", + "print(x_train.shape, y_train.shape, x_test.shape, y_test.shape)\n", + "\n", + "# Reduce pixel values\n", + "x_train, x_test = x_train / 255.0, x_test / 255.0\n", + " \n", + "# flatten the label values\n", + "y_train, y_test = y_train.flatten(), y_test.flatten()" + ], + "execution_count": 24, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n", + "170500096/170498071 [==============================] - 2s 0us/step\n", + "170508288/170498071 [==============================] - 2s 0us/step\n", + "(50000, 32, 32, 3) (50000, 1) (10000, 32, 32, 3) (10000, 1)\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "qQhkATYhEkkC", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 269 + }, + "outputId": "0c71b81d-b4b1-49f9-8e5d-c5fd1e59b3d2" + }, + "source": [ + "'''visualize data by plotting images'''\n", + "# YOUR CODE HERE\n", + "fig, ax = plt.subplots(5, 5)\n", + "k = 0\n", + " \n", + "for i in range(5):\n", + " for j in range(5):\n", + " ax[i][j].imshow(x_train[k], aspect='auto')\n", + " k += 1\n", + " \n", + "plt.show()\n", + "# YOUR CODE HERE" + ], + "execution_count": 25, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yJgho2AEBFbx" + }, + "source": [ + "\n", + "# number of classes\n", + "K = len(set(y_train))\n", + "\n", + "'''\n", + " calculate total number of classes\n", + " for output layer\n", + "'''\n", + "print(\"number of classes:\", K)\n", + "''' \n", + " Build the model using the functional API\n", + " input layer\n", + "'''\n", + "```\n", + " YOUR CODE HERE\n", + "```\n", + " \n", + "'''Hidden layer'''\n", + "# YOUR CODE HERE\n", + "pass\n", + "# YOUR CODE HERE\n", + " \n", + "\"\"\"last hidden layer i.e.. output layer\"\"\"\n", + "# YOUR CODE HERE\n", + "pass\n", + "# YOUR CODE HERE\n", + " \n", + " '''model description'''\n", + "model.summary()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "PLc4Bay65TyA" + }, + "source": [ + "# Compile\n", + "...\n", + " YOUR CODE HERE\n", + "..." + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Fit\n", + "...\n", + " YOUR CODE HERE\n", + "..." + ], + "metadata": { + "id": "U0fGsDCRsQrn" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# label mapping\n", + " \n", + "labels = '''airplane automobile bird cat deerdog frog horseship truck'''.split()\n", + " \n", + "# select the image from our test dataset\n", + "image_number = 0\n", + " \n", + "# display the image\n", + "plt.imshow(x_test[image_number])\n", + " \n", + "# load the image in an array\n", + "n = np.array(x_test[image_number])\n", + " \n", + "# reshape it\n", + "p = n.reshape(1, 32, 32, 3)\n", + " \n", + "# pass in the network for prediction and\n", + "# save the predicted label\n", + "predicted_label = labels[model.predict(p).argmax()]\n", + " \n", + "# load the original label\n", + "original_label = labels[y_test[image_number]]\n", + " \n", + "# display the result\n", + "print(\"Original label is {} and predicted label is {}\".format(\n", + " original_label, predicted_label))" + ], + "metadata": { + "id": "RDq_RE6osSh8" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/Assignment/Assignment_3/Aadvik210002_DeepLearning_Ass3.ipynb b/Assignment/Assignment_3/Aadvik210002_DeepLearning_Ass3.ipynb new file mode 100644 index 0000000..7d4b35c --- /dev/null +++ b/Assignment/Assignment_3/Aadvik210002_DeepLearning_Ass3.ipynb @@ -0,0 +1,311 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "0d96ba61-638d-4b71-be84-de966f7ddf9f", + "metadata": {}, + "outputs": [], + "source": [ + "import torch \n", + "from torchvision import datasets \n", + "from torchvision.transforms import ToTensor\n", + "from torch import nn\n", + "from torch.utils.data import DataLoader\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "22d878ab-4830-4f90-8729-ec3c27a14f89", + "metadata": {}, + "outputs": [], + "source": [ + "traindata = datasets.MNIST(\n", + " root = 'data' ,\n", + " train = True ,\n", + " download = True ,\n", + " transform = ToTensor()\n", + " ) \n", + "testdata = datasets.MNIST(\n", + " root = 'data' ,\n", + " train = False , \n", + " transform = ToTensor()\n", + " )\n", + "trainloader = torch.utils.data.DataLoader(\n", + " traindata ,\n", + " shuffle = True ,\n", + " batch_size = 50 ,\n", + " num_workers = 1\n", + " )\n", + "testloader = torch.utils.data.DataLoader(\n", + " testdata , \n", + " shuffle = True ,\n", + " batch_size = 50 , \n", + " num_workers = 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8eb4eebe-dcc6-40b2-81a8-d488b4a2771d", + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "449d4fed-96a3-4469-acfe-67c5da0482f1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figure = plt.figure(figsize=(10, 8))\n", + "cols, rows = 5, 5\n", + "for i in range(1, cols * rows + 1):\n", + " sample_idx = torch.randint(len(traindata), size=(1,)).item()\n", + " img, label = traindata[sample_idx]\n", + " figure.add_subplot(rows, cols, i)\n", + " plt.title(label)\n", + " plt.axis(\"off\")\n", + " plt.imshow(img.squeeze(), cmap=\"gray\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e117220c-2391-43cd-9e56-fab2222c0bea", + "metadata": {}, + "outputs": [], + "source": [ + "seq_length = 28\n", + "input_size = 28\n", + "hidden_size = 128\n", + "num_layers = 2\n", + "num_classes = 10\n", + "batch_size = 100\n", + "\n", + "class RNN(nn.Module):\n", + " def __init__(self , input_size, hidden_size , num_layers , num_classes):\n", + " super(RNN , self).__init__()\n", + " self.hidden_size = hidden_size\n", + " self.num_layers = num_layers\n", + " self.lstm = nn.LSTM(input_size , hidden_size , num_layers , batch_first=True)\n", + " self.fc = nn.Linear(hidden_size , num_classes)\n", + " pass\n", + "\n", + " def forward(self,x):\n", + " h = torch.zeros(self.num_layers, x.size(0) , self.hidden_size).to(device)\n", + " c= torch.zeros(self.num_layers, x.size(0) , self.hidden_size).to(device)\n", + " out , hidden = self.lstm(x, (c,h))\n", + " out = self.fc(out[: , -1 , :])\n", + " return out\n", + "model = RNN(input_size , hidden_size , num_layers , num_classes).to(device)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6a726f63-b5cf-4632-8160-70f1b9ec26b8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch:3, Iteration:100, Loss:0.8645853996276855, Accuracy: 78.90999603271484\n", + "Epoch:3, Iteration:200, Loss:0.380636990070343, Accuracy: 83.23999786376953\n", + "Epoch:3, Iteration:300, Loss:0.3888150751590729, Accuracy: 91.62999725341797\n", + "Epoch:3, Iteration:400, Loss:0.3459419310092926, Accuracy: 90.43000030517578\n", + "Epoch:3, Iteration:500, Loss:0.24078091979026794, Accuracy: 94.55999755859375\n", + "Epoch:3, Iteration:600, Loss:0.4134293794631958, Accuracy: 94.8499984741211\n", + "Epoch:3, Iteration:700, Loss:0.4566323757171631, Accuracy: 94.81999969482422\n", + "Epoch:3, Iteration:800, Loss:0.09807086735963821, Accuracy: 96.01000213623047\n", + "Epoch:3, Iteration:900, Loss:0.1623331606388092, Accuracy: 96.59000396728516\n", + "Epoch:3, Iteration:1000, Loss:0.1732684075832367, Accuracy: 95.79000091552734\n", + "Epoch:3, Iteration:1100, Loss:0.044007301330566406, Accuracy: 97.1500015258789\n", + "Epoch:3, Iteration:1200, Loss:0.016187576577067375, Accuracy: 96.47000122070312\n", + "Epoch:3, Iteration:1300, Loss:0.21294070780277252, Accuracy: 96.45999908447266\n", + "Epoch:3, Iteration:1400, Loss:0.09665826708078384, Accuracy: 96.66999816894531\n", + "Epoch:3, Iteration:1500, Loss:0.1696651130914688, Accuracy: 96.5\n", + "Epoch:3, Iteration:1600, Loss:0.06570668518543243, Accuracy: 97.11000061035156\n", + "Epoch:3, Iteration:1700, Loss:0.10131289809942245, Accuracy: 97.25\n", + "Epoch:3, Iteration:1800, Loss:0.08747141808271408, Accuracy: 96.61000061035156\n", + "Epoch:3, Iteration:1900, Loss:0.06416402012109756, Accuracy: 97.16999816894531\n", + "Epoch:3, Iteration:2000, Loss:0.0507415309548378, Accuracy: 97.02999877929688\n", + "Epoch:3, Iteration:2100, Loss:0.07503575086593628, Accuracy: 97.33000183105469\n", + "Epoch:3, Iteration:2200, Loss:0.04707108810544014, Accuracy: 96.55000305175781\n", + "Epoch:3, Iteration:2300, Loss:0.06459096819162369, Accuracy: 96.38999938964844\n", + "Epoch:3, Iteration:2400, Loss:0.17823626101016998, Accuracy: 96.15999603271484\n", + "Epoch:3, Iteration:2500, Loss:0.1273122876882553, Accuracy: 97.01000213623047\n", + "Epoch:3, Iteration:2600, Loss:0.019332462921738625, Accuracy: 96.91999816894531\n", + "Epoch:3, Iteration:2700, Loss:0.010376335121691227, Accuracy: 97.36000061035156\n", + "Epoch:3, Iteration:2800, Loss:0.041446611285209656, Accuracy: 97.05000305175781\n", + "Epoch:3, Iteration:2900, Loss:0.12149006873369217, Accuracy: 96.5\n", + "Epoch:3, Iteration:3000, Loss:0.11476122587919235, Accuracy: 97.2699966430664\n", + "Epoch:3, Iteration:3100, Loss:0.07229476422071457, Accuracy: 96.87000274658203\n", + "Epoch:3, Iteration:3200, Loss:0.0027696022298187017, Accuracy: 97.94999694824219\n", + "Epoch:3, Iteration:3300, Loss:0.04697310924530029, Accuracy: 97.30999755859375\n", + "Epoch:3, Iteration:3400, Loss:0.059735871851444244, Accuracy: 95.76000213623047\n", + "Epoch:3, Iteration:3500, Loss:0.07519158720970154, Accuracy: 96.45999908447266\n", + "Epoch:3, Iteration:3600, Loss:0.17212095856666565, Accuracy: 97.0199966430664\n" + ] + } + ], + "source": [ + "lossf = torch.nn.CrossEntropyLoss() \n", + "optim = torch.optim.Adam(model.parameters() , lr=0.01)\n", + "\n", + "epoch = 3 \n", + "iterations = 0 \n", + "\n", + "for i in range(epoch):\n", + " for j,(images,labels) in enumerate(trainloader):\n", + " images = images.reshape(-1 , seq_length , input_size).requires_grad_().to(device)\n", + " optim.zero_grad()\n", + " output = model(images)\n", + " labels = labels.to(device)\n", + " loss = lossf(output,labels) \n", + " loss.backward()\n", + " optim.step()\n", + " iterations +=1\n", + "\n", + " if iterations%100 == 0:\n", + " correct = 0\n", + " total = 0 \n", + " for images , labels in testloader:\n", + " images = images.view(-1 , seq_length , input_size).to(device)\n", + " labels = labels.to(device)\n", + " outputs = model(images)\n", + " _ , predicted = torch.max(outputs.data , 1)\n", + " total += labels.size(0)\n", + " correct+= (predicted == labels).sum().to(device)\n", + "\n", + " accuracy = (correct/total)*100\n", + " print('Epoch:{}, Iteration:{}, Loss:{}, Accuracy: {}'.format(epoch, iterations, loss.item(), accuracy))\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b9edbd00-07cf-4aef-bccf-907cf10ea3a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch:3, Iteration:100, Loss:0.02960243448615074, Accuracy: 97.75999450683594\n", + "Epoch:3, Iteration:200, Loss:0.037816938012838364, Accuracy: 98.15999603271484\n", + "Epoch:3, Iteration:300, Loss:0.03077937848865986, Accuracy: 98.2199935913086\n", + "Epoch:3, Iteration:400, Loss:0.10566378384828568, Accuracy: 98.37999725341797\n", + "Epoch:3, Iteration:500, Loss:0.045936502516269684, Accuracy: 98.45999145507812\n", + "Epoch:3, Iteration:600, Loss:0.08540216088294983, Accuracy: 98.45999145507812\n", + "Epoch:3, Iteration:700, Loss:0.03976510837674141, Accuracy: 98.5999984741211\n", + "Epoch:3, Iteration:800, Loss:0.008425017818808556, Accuracy: 98.6199951171875\n", + "Epoch:3, Iteration:900, Loss:0.19239357113838196, Accuracy: 98.69999694824219\n", + "Epoch:3, Iteration:1000, Loss:0.008022384718060493, Accuracy: 98.62999725341797\n", + "Epoch:3, Iteration:1100, Loss:0.003174879588186741, Accuracy: 98.69999694824219\n", + "Epoch:3, Iteration:1200, Loss:0.016863830387592316, Accuracy: 98.65999603271484\n", + "Epoch:3, Iteration:1300, Loss:0.016630567610263824, Accuracy: 98.64999389648438\n", + "Epoch:3, Iteration:1400, Loss:0.1486801654100418, Accuracy: 98.65999603271484\n", + "Epoch:3, Iteration:1500, Loss:0.00858297199010849, Accuracy: 98.7199935913086\n", + "Epoch:3, Iteration:1600, Loss:0.01869731955230236, Accuracy: 98.67999267578125\n", + "Epoch:3, Iteration:1700, Loss:0.0617079921066761, Accuracy: 98.69999694824219\n", + "Epoch:3, Iteration:1800, Loss:0.012810898013412952, Accuracy: 98.67999267578125\n", + "Epoch:3, Iteration:1900, Loss:0.014734245836734772, Accuracy: 98.7699966430664\n", + "Epoch:3, Iteration:2000, Loss:0.002489517442882061, Accuracy: 98.75999450683594\n", + "Epoch:3, Iteration:2100, Loss:0.10422997176647186, Accuracy: 98.77999877929688\n", + "Epoch:3, Iteration:2200, Loss:0.004481997340917587, Accuracy: 98.79999542236328\n", + "Epoch:3, Iteration:2300, Loss:0.0421517938375473, Accuracy: 98.78999328613281\n", + "Epoch:3, Iteration:2400, Loss:0.022293932735919952, Accuracy: 98.77999877929688\n", + "Epoch:3, Iteration:2500, Loss:0.03584142401814461, Accuracy: 98.7199935913086\n", + "Epoch:3, Iteration:2600, Loss:0.005098472349345684, Accuracy: 98.77999877929688\n", + "Epoch:3, Iteration:2700, Loss:0.002425034064799547, Accuracy: 98.69999694824219\n", + "Epoch:3, Iteration:2800, Loss:0.0012882195878773928, Accuracy: 98.74999237060547\n", + "Epoch:3, Iteration:2900, Loss:0.004711168818175793, Accuracy: 98.65999603271484\n", + "Epoch:3, Iteration:3000, Loss:0.010352177545428276, Accuracy: 98.78999328613281\n", + "Epoch:3, Iteration:3100, Loss:0.003941243514418602, Accuracy: 98.8499984741211\n", + "Epoch:3, Iteration:3200, Loss:0.0012398991966620088, Accuracy: 98.81999206542969\n", + "Epoch:3, Iteration:3300, Loss:0.06550697237253189, Accuracy: 98.87999725341797\n", + "Epoch:3, Iteration:3400, Loss:0.04815981909632683, Accuracy: 98.8699951171875\n", + "Epoch:3, Iteration:3500, Loss:0.006304584909230471, Accuracy: 98.89999389648438\n", + "Epoch:3, Iteration:3600, Loss:0.032886989414691925, Accuracy: 98.89999389648438\n" + ] + } + ], + "source": [ + "lossf = torch.nn.CrossEntropyLoss() \n", + "optim = torch.optim.Adam(model.parameters() , lr=0.001)\n", + "\n", + "epoch = 3 \n", + "iterations = 0 \n", + "\n", + "for i in range(epoch):\n", + " for j,(images,labels) in enumerate(trainloader):\n", + " images = images.reshape(-1 , seq_length , input_size).requires_grad_().to(device)\n", + " optim.zero_grad()\n", + " output = model(images)\n", + " labels = labels.to(device)\n", + " loss = lossf(output,labels) \n", + " loss.backward()\n", + " optim.step()\n", + " iterations +=1\n", + " \n", + " if iterations%100 == 0:\n", + " correct = 0\n", + " total = 0 \n", + " for images , labels in testloader:\n", + " images = images.view(-1 , seq_length , input_size).to(device)\n", + " labels = labels.to(device)\n", + " outputs = model(images)\n", + " _ , predicted = torch.max(outputs.data , 1)\n", + " total += labels.size(0)\n", + " correct+= (predicted == labels).sum().to(device)\n", + "\n", + " accuracy = (correct/total)*100\n", + " print('Epoch:{}, Iteration:{}, Loss:{}, Accuracy: {}'.format(epoch, iterations, loss.item(), accuracy))\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}