From 1d27b97cefa3c73c69ec858fa6b8448dc451690a Mon Sep 17 00:00:00 2001 From: ambujpyne02 <104996993+ambujpyne02@users.noreply.github.com> Date: Mon, 16 May 2022 20:04:37 +0530 Subject: [PATCH 01/13] Add files via upload --- 210118_Ambuj Pyne_Part-1.ipynb | 965 +++++++++++++++++++++++++++++++++ 1 file changed, 965 insertions(+) create mode 100644 210118_Ambuj Pyne_Part-1.ipynb diff --git a/210118_Ambuj Pyne_Part-1.ipynb b/210118_Ambuj Pyne_Part-1.ipynb new file mode 100644 index 0000000..1bb9b33 --- /dev/null +++ b/210118_Ambuj Pyne_Part-1.ipynb @@ -0,0 +1,965 @@ +{ + "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": "Copy of DL_Stamatics_A1.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.\n", + "* For Submission, You'll be required to submit a sharable link for your copy of this notebook. (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": "2f023469-eced-40f7-d557-66b1e5a2f788" + }, + "source": [ + "### YOUR CODE HERE\n", + "import numpy as np\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": null, + "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": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "pbLIS5vIE-Ea", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "52fd3943-b0fc-4549-ffc7-264d8810639c" + }, + "source": [ + "# Now, let's test out this dot product. Your answer should be [[1]].\n", + "import numpy as np\n", + "a=np.array([[1,-1,1,-1,1]])\n", + "b=np.array([[1],[1],[1],[-1],[-1]])\n", + "\n", + "aDotB = dot_product(a, b)\n", + "print(aDotB)\n", + "\n", + "print(\"The size is: \", aDotB.shape)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[1]]\n", + "The size is: (1, 1)\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": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "da_uQQLhE-Ec", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "7925b57d-f4d4-4558-edfd-0078a3c8db89" + }, + "source": [ + "# Your answer should be $[[3], [9], [15], [21]]$ of shape(4, 1).\n", + "import numpy as np\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", + "ans = complicated_matrix_function(M, a, b)\n", + "print(ans)\n", + "print()\n", + "print(\"The size is: \", ans.shape)" + ], + "execution_count": null, + "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": "11b25fd6-df42-48f2-f5e6-a06b54e423e0" + }, + "source": [ + "\n", + "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": null, + "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 = []\n", + " v = []\n", + " ### YOUR CODE HERE\n", + " w,v=np.linalg.eig(M)\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", + " eigenvalues,eigenvectors = eigen_decomp(M)\n", + " pass\n", + " ### END YOUR CODE\n", + " return eigenvalues, eigenvectors" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "t0_GkrJwE-Ee", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 235 + }, + "outputId": "7170c92e-3e1f-46fd-da52-b93a98064a22" + }, + "source": [ + "# Let's define M.\n", + "import numpy as np\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": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# Now let's grab the first eigenvalue and first eigenvector.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# You should get back a single eigenvalue and a single eigenvector.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mval\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvec\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_eigen_values_and_vectors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"First eigenvalue =\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'get_eigen_values_and_vectors' is not defined" + ] + } + ] + }, + { + "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", + " out =[]\n", + " ### YOUR CODE HERE\n", + " max=0\n", + " l_max=0\n", + " index=0\n", + " for i in range(M.shape[0]):\n", + " if max 0:\n", + " M[[0, index]] = M[[index, 0]]\n", + " out=M\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 7, + "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 = M\n", + " ### YOUR CODE HERE\n", + " for i in range (1,(M.shape)[0]):\n", + " out[i,:]=out[i,:]-(out[0,:]*(out[i,0]/out[0,0])) \n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 6, + "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 = M\n", + " #print(out)\n", + " ### YOUR CODE HERE\n", + " out=swap_rows(out)\n", + " #print(out)\n", + " out=apply_rows(out)\n", + " out=np.round(out,decimals=2)\n", + " #print(out)\n", + " d_mat=out[1:((M.shape)[0]), 1:((M.shape)[0])]\n", + " #print(d_mat)\n", + " d_mat=swap_rows(d_mat)\n", + " #print(d_mat)\n", + " d_mat=apply_rows(d_mat)\n", + " #print(d_mat)\n", + " #print(d_mat)\n", + " out[1:((M.shape)[0]), 1:((M.shape)[0])]=d_mat\n", + " out[1,:]=out[1,:]/2\n", + " out[2,2]=out[2,2]*(-10)\n", + " #print(out)\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 5, + "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 = M\n", + " ### YOUR CODE HERE\n", + " for i in range(1,(M.shape)[0]):\n", + " out[0,:]=out[0,:]-((out[0,i]/out[i,i])*out[i,:])\n", + " out=np.round(out,decimals=2)\n", + " #print(out)\n", + " \n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 4, + "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 = forward(M)\n", + " out=backward(out)\n", + " d_mat=out[1:((M.shape)[0]), 1:((M.shape)[0])]\n", + " d_mat=backward(d_mat)\n", + " out[1:((M.shape)[0]), 1:((M.shape)[0])]=d_mat\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Eiz6EbsWPYz8", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "119190fc-d896-4fe8-c6fe-ec55cf51a5df" + }, + "source": [ + "# Let's define M.\n", + "import numpy as np\n", + "M = np.array([[1.00,2.00,3.00],[4.00,5.00,6.00],[7.00,8.00,9.00]])\n", + "np.around(M,decimals=2)\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": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[ 7. 0. 0. ]\n", + " [ 0. 0.43 0. ]\n", + " [ 0. 0. -0.05]]\n" + ] + } + ] + }, + { + "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", + "\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", + " out = 0\n", + " diff=[]\n", + " sqr=[]\n", + " for i in range(len(u)):\n", + " diff=diff +[u[i]-v[i]]\n", + " #print(diff)\n", + " for j in range(len(u)):\n", + " sqr=sqr+[diff[j]*diff[j]]\n", + " #print(sqr)\n", + " for k in range(len(u)):\n", + " out=out+sqr[k]\n", + " out=out**(0.5)\n", + " #print(out)\n", + " \n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 41, + "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", + "\n", + " ### YOUR CODE HERE\n", + " m=u-v\n", + " #print(m)\n", + " m=np.square(m)\n", + " #print(m)\n", + " out=(np.sum(m))**(0.5)\n", + " #print(out)\n", + " pass\n", + " return out\n", + " ### END YOUR CODE" + ], + "execution_count": 57, + "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": 42, + "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": 58, + "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": "e02752b8-4535-4fb8-fe69-803b3fb92b9b" + }, + "execution_count": 60, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Native: 25.01792287826538 seconds\n", + "NumPy: 0.09348750114440918 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 From 7510bd349e00a95ceaa03cc973990ec6ea06711f Mon Sep 17 00:00:00 2001 From: ambujpyne02 <104996993+ambujpyne02@users.noreply.github.com> Date: Mon, 16 May 2022 20:07:30 +0530 Subject: [PATCH 02/13] Add files via upload --- .../210118_Ambuj Pyne_Part-1.ipynb | 965 ++++++++++++++++++ 1 file changed, 965 insertions(+) create mode 100644 Assignment/Assignment_1/210118_Ambuj Pyne_Part-1.ipynb diff --git a/Assignment/Assignment_1/210118_Ambuj Pyne_Part-1.ipynb b/Assignment/Assignment_1/210118_Ambuj Pyne_Part-1.ipynb new file mode 100644 index 0000000..1bb9b33 --- /dev/null +++ b/Assignment/Assignment_1/210118_Ambuj Pyne_Part-1.ipynb @@ -0,0 +1,965 @@ +{ + "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": "Copy of DL_Stamatics_A1.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.\n", + "* For Submission, You'll be required to submit a sharable link for your copy of this notebook. (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": "2f023469-eced-40f7-d557-66b1e5a2f788" + }, + "source": [ + "### YOUR CODE HERE\n", + "import numpy as np\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": null, + "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": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "pbLIS5vIE-Ea", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "52fd3943-b0fc-4549-ffc7-264d8810639c" + }, + "source": [ + "# Now, let's test out this dot product. Your answer should be [[1]].\n", + "import numpy as np\n", + "a=np.array([[1,-1,1,-1,1]])\n", + "b=np.array([[1],[1],[1],[-1],[-1]])\n", + "\n", + "aDotB = dot_product(a, b)\n", + "print(aDotB)\n", + "\n", + "print(\"The size is: \", aDotB.shape)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[1]]\n", + "The size is: (1, 1)\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": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "da_uQQLhE-Ec", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "7925b57d-f4d4-4558-edfd-0078a3c8db89" + }, + "source": [ + "# Your answer should be $[[3], [9], [15], [21]]$ of shape(4, 1).\n", + "import numpy as np\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", + "ans = complicated_matrix_function(M, a, b)\n", + "print(ans)\n", + "print()\n", + "print(\"The size is: \", ans.shape)" + ], + "execution_count": null, + "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": "11b25fd6-df42-48f2-f5e6-a06b54e423e0" + }, + "source": [ + "\n", + "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": null, + "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 = []\n", + " v = []\n", + " ### YOUR CODE HERE\n", + " w,v=np.linalg.eig(M)\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", + " eigenvalues,eigenvectors = eigen_decomp(M)\n", + " pass\n", + " ### END YOUR CODE\n", + " return eigenvalues, eigenvectors" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "t0_GkrJwE-Ee", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 235 + }, + "outputId": "7170c92e-3e1f-46fd-da52-b93a98064a22" + }, + "source": [ + "# Let's define M.\n", + "import numpy as np\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": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# Now let's grab the first eigenvalue and first eigenvector.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# You should get back a single eigenvalue and a single eigenvector.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mval\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvec\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_eigen_values_and_vectors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"First eigenvalue =\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'get_eigen_values_and_vectors' is not defined" + ] + } + ] + }, + { + "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", + " out =[]\n", + " ### YOUR CODE HERE\n", + " max=0\n", + " l_max=0\n", + " index=0\n", + " for i in range(M.shape[0]):\n", + " if max 0:\n", + " M[[0, index]] = M[[index, 0]]\n", + " out=M\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 7, + "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 = M\n", + " ### YOUR CODE HERE\n", + " for i in range (1,(M.shape)[0]):\n", + " out[i,:]=out[i,:]-(out[0,:]*(out[i,0]/out[0,0])) \n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 6, + "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 = M\n", + " #print(out)\n", + " ### YOUR CODE HERE\n", + " out=swap_rows(out)\n", + " #print(out)\n", + " out=apply_rows(out)\n", + " out=np.round(out,decimals=2)\n", + " #print(out)\n", + " d_mat=out[1:((M.shape)[0]), 1:((M.shape)[0])]\n", + " #print(d_mat)\n", + " d_mat=swap_rows(d_mat)\n", + " #print(d_mat)\n", + " d_mat=apply_rows(d_mat)\n", + " #print(d_mat)\n", + " #print(d_mat)\n", + " out[1:((M.shape)[0]), 1:((M.shape)[0])]=d_mat\n", + " out[1,:]=out[1,:]/2\n", + " out[2,2]=out[2,2]*(-10)\n", + " #print(out)\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 5, + "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 = M\n", + " ### YOUR CODE HERE\n", + " for i in range(1,(M.shape)[0]):\n", + " out[0,:]=out[0,:]-((out[0,i]/out[i,i])*out[i,:])\n", + " out=np.round(out,decimals=2)\n", + " #print(out)\n", + " \n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 4, + "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 = forward(M)\n", + " out=backward(out)\n", + " d_mat=out[1:((M.shape)[0]), 1:((M.shape)[0])]\n", + " d_mat=backward(d_mat)\n", + " out[1:((M.shape)[0]), 1:((M.shape)[0])]=d_mat\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Eiz6EbsWPYz8", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "119190fc-d896-4fe8-c6fe-ec55cf51a5df" + }, + "source": [ + "# Let's define M.\n", + "import numpy as np\n", + "M = np.array([[1.00,2.00,3.00],[4.00,5.00,6.00],[7.00,8.00,9.00]])\n", + "np.around(M,decimals=2)\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": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[ 7. 0. 0. ]\n", + " [ 0. 0.43 0. ]\n", + " [ 0. 0. -0.05]]\n" + ] + } + ] + }, + { + "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", + "\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", + " out = 0\n", + " diff=[]\n", + " sqr=[]\n", + " for i in range(len(u)):\n", + " diff=diff +[u[i]-v[i]]\n", + " #print(diff)\n", + " for j in range(len(u)):\n", + " sqr=sqr+[diff[j]*diff[j]]\n", + " #print(sqr)\n", + " for k in range(len(u)):\n", + " out=out+sqr[k]\n", + " out=out**(0.5)\n", + " #print(out)\n", + " \n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 41, + "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", + "\n", + " ### YOUR CODE HERE\n", + " m=u-v\n", + " #print(m)\n", + " m=np.square(m)\n", + " #print(m)\n", + " out=(np.sum(m))**(0.5)\n", + " #print(out)\n", + " pass\n", + " return out\n", + " ### END YOUR CODE" + ], + "execution_count": 57, + "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": 42, + "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": 58, + "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": "e02752b8-4535-4fb8-fe69-803b3fb92b9b" + }, + "execution_count": 60, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Native: 25.01792287826538 seconds\n", + "NumPy: 0.09348750114440918 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 From 6078b329e1ff80989bbea2733bb1399625c00d0f Mon Sep 17 00:00:00 2001 From: ambujpyne02 <104996993+ambujpyne02@users.noreply.github.com> Date: Mon, 16 May 2022 23:04:57 +0530 Subject: [PATCH 03/13] Add files via upload --- .../210118_Ambuj Pyne_Part-2.ipynb | 412 ++++++++++++++++++ 1 file changed, 412 insertions(+) create mode 100644 Assignment/Assignment_1/210118_Ambuj Pyne_Part-2.ipynb diff --git a/Assignment/Assignment_1/210118_Ambuj Pyne_Part-2.ipynb b/Assignment/Assignment_1/210118_Ambuj Pyne_Part-2.ipynb new file mode 100644 index 0000000..3710032 --- /dev/null +++ b/Assignment/Assignment_1/210118_Ambuj Pyne_Part-2.ipynb @@ -0,0 +1,412 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 22, + "id": "b0d1065e", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " city area rooms bathroom parking spaces floor animal \\\n", + "21 Belo Horizonte 42 1 1 1 17 not acept \n", + "27 Belo Horizonte 64 2 2 1 11 acept \n", + "37 Belo Horizonte 80 3 2 1 - acept \n", + "42 Belo Horizonte 200 4 2 1 7 not acept \n", + "43 Belo Horizonte 45 1 1 1 5 acept \n", + "... ... ... ... ... ... ... ... \n", + "10644 Belo Horizonte 65 2 1 1 1 acept \n", + "10648 Belo Horizonte 80 2 1 1 3 not acept \n", + "10651 Belo Horizonte 95 3 2 2 7 acept \n", + "10665 Belo Horizonte 55 2 1 1 2 not acept \n", + "10667 Belo Horizonte 75 2 1 1 3 not acept \n", + "\n", + " furniture hoa (R$) rent amount (R$) property tax (R$) \\\n", + "21 furnished 470 2690 172 \n", + "27 not furnished 352 1500 80 \n", + "37 not furnished 0 11000 425 \n", + "42 not furnished 850 2550 9 \n", + "43 not furnished 500 1631 192 \n", + "... ... ... ... ... \n", + "10644 not furnished 200 1100 70 \n", + "10648 not furnished 240 1200 67 \n", + "10651 not furnished 525 3100 219 \n", + "10665 furnished 200 1600 75 \n", + "10667 not furnished 180 1250 0 \n", + "\n", + " fire insurance (R$) total (R$) \n", + "21 36 3368 \n", + "27 20 1952 \n", + "37 181 11610 \n", + "42 34 3443 \n", + "43 12 2335 \n", + "... ... ... \n", + "10644 15 1385 \n", + "10648 16 1523 \n", + "10651 42 3886 \n", + "10665 22 1897 \n", + "10667 17 1447 \n", + "\n", + "[1258 rows x 13 columns]\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "df = pd.read_csv(r'C:\\Users\\AMBUJ PYNE\\Downloads\\House_prediction.csv')\n", + "\n", + "#print(df.to_string())\n", + "df1 = df[df['city'].str.contains('Belo Horizonte')]\n", + "df2 = df[df['city'].str.contains('Campinas')]\n", + "df3 = df[df['city'].str.contains('Porto Alegre')]\n", + "df4 = df[df['city'].str.contains('Rio de Janeiro')]\n", + "df5 = df[df['city'].str.contains('São Paulo')]\n", + "\n", + "print(df1)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "9be2e98f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "area 207.411765\n", + "rooms 3.020668\n", + "bathroom 2.402226\n", + "parking spaces 1.955485\n", + "hoa (R$) 2324.197138\n", + "rent amount (R$) 3664.127981\n", + "property tax (R$) 272.782194\n", + "fire insurance (R$) 53.675676\n", + "total (R$) 6315.242448\n", + "dtype: float64 area 137.561547\n", + "rooms 2.355217\n", + "bathroom 1.960141\n", + "parking spaces 1.558030\n", + "hoa (R$) 628.922626\n", + "rent amount (R$) 2364.290739\n", + "property tax (R$) 147.657679\n", + "fire insurance (R$) 32.388042\n", + "total (R$) 3173.276671\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "print(df1[[\"area\",\"rooms\",\"bathroom\",\"parking spaces\",\"hoa (R$)\",\n", + " \"rent amount (R$)\",\"property tax (R$)\",\"fire insurance (R$)\",\"total (R$)\"]].mean(),\n", + " df2[[\"area\",\"rooms\",\"bathroom\",\"parking spaces\",\"hoa (R$)\",\n", + " \"rent amount (R$)\",\"property tax (R$)\",\"fire insurance (R$)\",\"total (R$)\"]].mean())" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "94432b56", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#AREA\n", + "import matplotlib.pyplot as plt\n", + "city = ['Belo Horizonte','Campinas','Porto Alegre','Rio de Janeiro','São Paulo']\n", + "m_area = [df1[\"area\"].mean(),df2[\"area\"].mean(),df3[\"area\"].mean(),df4[\"area\"].mean(),df5[\"area\"].mean()]\n", + " \n", + "fig = plt.figure(figsize = (10, 5))\n", + " \n", + "# creating the bar plot\n", + "plt.bar(city, m_area, color ='maroon',\n", + " width = 0.4)\n", + " \n", + "plt.xlabel(\"Cities\")\n", + "plt.ylabel(\"Area\")\n", + "plt.title(\"Mean Area Citywise plot\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "c21e1625", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No handles with labels found to put in legend.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#ROOMS + BATHROOMS\n", + "import matplotlib.pyplot as plt\n", + "city = ['Belo Horizonte','Campinas','Porto Alegre','Rio de Janeiro','São Paulo']\n", + "m_room = [df1[\"rooms\"].mean(),df2[\"rooms\"].mean(),df3[\"rooms\"].mean(),df4[\"rooms\"].mean(),df5[\"rooms\"].mean()]\n", + "m_broom = [df1[\"bathroom\"].mean(),df2[\"bathroom\"].mean(),df3[\"bathroom\"].mean(),df4[\"bathroom\"].mean(),df5[\"bathroom\"].mean()]\n", + "\n", + "fig = plt.figure(figsize = (10, 5))\n", + " \n", + "# creating the bar plot\n", + "plt.bar(city, m_room, color ='maroon',\n", + " width = 0.4)\n", + "plt.bar(city, m_broom, color ='green',\n", + " width = 0.4)\n", + " \n", + "plt.xlabel(\"Rooms and Bathrooms\")\n", + "plt.ylabel(\"Rooms\")\n", + "plt.title(\"Mean Rooms Citywise plot\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "6bb30aa7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#RENT AMOUNT\n", + "import matplotlib.pyplot as plt\n", + "city = ['Belo Horizonte','Campinas','Porto Alegre','Rio de Janeiro','São Paulo']\n", + "m_rent = [df1[\"rent amount (R$)\"].mean(),df2[\"rent amount (R$)\"].mean(),df3[\"rent amount (R$)\"].mean(),df4[\"rent amount (R$)\"].mean(),df5[\"rent amount (R$)\"].mean()]\n", + " \n", + "fig = plt.figure(figsize = (10, 5))\n", + " \n", + "# creating the bar plot\n", + "plt.bar(city, m_rent, color ='maroon',\n", + " width = 0.4)\n", + " \n", + "plt.xlabel(\"Cities\")\n", + "plt.ylabel(\"rent\")\n", + "plt.title(\"Mean rent Citywise plot\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "3d4ba3f0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#HOA\n", + "import matplotlib.pyplot as plt\n", + "city = ['Belo Horizonte','Campinas','Porto Alegre','Rio de Janeiro','São Paulo']\n", + "m_hoa = [df1[\"hoa (R$)\"].mean(),df2[\"hoa (R$)\"].mean(),df3[\"hoa (R$)\"].mean(),df4[\"hoa (R$)\"].mean(),df5[\"hoa (R$)\"].mean()]\n", + " \n", + "fig = plt.figure(figsize = (10, 5))\n", + " \n", + "# creating the bar plot\n", + "plt.bar(city, m_hoa, color ='maroon',\n", + " width = 0.4)\n", + " \n", + "plt.xlabel(\"Cities\")\n", + "plt.ylabel(\"hoa (R$)\")\n", + "plt.title(\"Mean hoa Citywise plot\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "079537b7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Prop Tax\n", + "import matplotlib.pyplot as plt\n", + "city = ['Belo Horizonte','Campinas','Porto Alegre','Rio de Janeiro','São Paulo']\n", + "m_prop = [df1[\"property tax (R$)\"].mean(),df2[\"property tax (R$)\"].mean(),df3[\"property tax (R$)\"].mean(),df4[\"property tax (R$)\"].mean(),df5[\"property tax (R$)\"].mean()]\n", + " \n", + "fig = plt.figure(figsize = (10, 5))\n", + " \n", + "# creating the bar plot\n", + "plt.bar(city, m_prop, color ='maroon',\n", + " width = 0.4)\n", + " \n", + "plt.xlabel(\"Cities\")\n", + "plt.ylabel(\"property tax (R$)\")\n", + "plt.title(\"Mean prop_tax Citywise plot\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "746c1feb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Fire Insurance\n", + "import matplotlib.pyplot as plt\n", + "city = ['Belo Horizonte','Campinas','Porto Alegre','Rio de Janeiro','São Paulo']\n", + "m_fire = [df1[\"fire insurance (R$)\"].mean(),df2[\"fire insurance (R$)\"].mean(),df3[\"fire insurance (R$)\"].mean(),df4[\"fire insurance (R$)\"].mean(),df5[\"fire insurance (R$)\"].mean()]\n", + " \n", + "fig = plt.figure(figsize = (10, 5))\n", + " \n", + "# creating the bar plot\n", + "plt.bar(city, m_fire, color ='maroon',\n", + " width = 0.4)\n", + " \n", + "plt.xlabel(\"Cities\")\n", + "plt.ylabel(\"fire insurance (R$)\")\n", + "plt.title(\"Mean fire_insurance Citywise plot\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "ce583710", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Total\n", + "import matplotlib.pyplot as plt\n", + "city = ['Belo Horizonte','Campinas','Porto Alegre','Rio de Janeiro','São Paulo']\n", + "m_total = [df1[\"total (R$)\"].mean(),df2[\"total (R$)\"].mean(),df3[\"total (R$)\"].mean(),df4[\"total (R$)\"].mean(),df5[\"total (R$)\"].mean()]\n", + " \n", + "fig = plt.figure(figsize = (10, 5))\n", + " \n", + "# creating the bar plot\n", + "plt.bar(city, m_total, color ='maroon',\n", + " width = 0.4)\n", + " \n", + "plt.xlabel(\"Cities\")\n", + "plt.ylabel(\"total (R$) \")\n", + "plt.title(\"Mean total Citywise plot\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6b9c1d75", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From fd4f1233410d07b57830ade951bdf605d63db54b Mon Sep 17 00:00:00 2001 From: ambujpyne02 <104996993+ambujpyne02@users.noreply.github.com> Date: Mon, 16 May 2022 23:05:43 +0530 Subject: [PATCH 04/13] Add files via upload --- .../210118_Ambuj Pyne_Part-3.ipynb | 398 ++++++++++++++++++ 1 file changed, 398 insertions(+) create mode 100644 Assignment/Assignment_1/210118_Ambuj Pyne_Part-3.ipynb diff --git a/Assignment/Assignment_1/210118_Ambuj Pyne_Part-3.ipynb b/Assignment/Assignment_1/210118_Ambuj Pyne_Part-3.ipynb new file mode 100644 index 0000000..ba3ac78 --- /dev/null +++ b/Assignment/Assignment_1/210118_Ambuj Pyne_Part-3.ipynb @@ -0,0 +1,398 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "id": "2867e351", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Empty DataFrame\n", + "Columns: [city, area, rooms, bathroom, parking spaces, floor, animal, furniture, hoa (R$), rent amount (R$), property tax (R$), fire insurance (R$), total (R$)]\n", + "Index: []\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "df = pd.read_csv(r'C:\\Users\\AMBUJ PYNE\\Downloads\\House_prediction.csv')\n", + "\n", + "#print(df.to_string())\n", + "df1 = df[df['city'].str.contains('Belo Horizonte')]\n", + "df2 = df[df['city'].str.contains('Campinas')]\n", + "df3 = df[df['city'].str.contains('Porto Alegre')]\n", + "df4 = df[df['city'].str.contains('Rio de Janeiro')]\n", + "df5 = df[df['city'].str.contains('São Paulo')]\n", + "print(df5)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a0544b1b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Relation in Rent amont and Area\n", + "#df1.plot()\n", + "df1.plot(kind='scatter',x='area',y='hoa (R$)',title='Belo Horizonte',xlim=(0,500),ylim=(0,0.01)) # scatter plot\n", + "df2.plot(kind='scatter',x='area',y='hoa (R$)',color='g',title='Campinas',s=1,xlim=(0,400),ylim=(-10,8000))\n", + "df3.plot(kind='scatter',x='area',y='hoa (R$)',color='y',title='Porto Alegre',s=1,xlim=(0,400),ylim=(-10,4000))\n", + "df4.plot(kind='scatter',x='area',y='hoa (R$)',color='r',title='Rio de Janeiro',s=1,xlim=(0,1000),ylim=(-10,5000))\n", + "df5.plot(kind='scatter',x='area',y='hoa (R$)',color='b',title='São Paulo')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "27be8eff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df1.plot(kind='scatter',x='rent amount (R$)',y='property tax (R$)',title='Belo Horizonte',xlim=(0,14000),ylim=(0,3000)) # scatter plot\n", + "df2.plot(kind='scatter',x='rent amount (R$)',y='property tax (R$)',color='g',title='Campinas')\n", + "df3.plot(kind='scatter',x='rent amount (R$)',y='property tax (R$)',color='y',title='Porto Alegre')\n", + "df4.plot(kind='scatter',x='rent amount (R$)',y='property tax (R$)',color='r',title='Rio de Janeiro',xlim=(0,14000),ylim=(0,5000))\n", + "df5.plot(kind='scatter',x='rent amount (R$)',y='property tax (R$)',color='b',title='São Paulo')" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "760127fd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAs0klEQVR4nO3dfZxUdd3/8ddHWGDlJvRi9SIBV00LjRJdyS4t7ymLQk0LTCPlSvPnTaW/DLPMzDK9Ui+1FOwHgalrat5F16WoaQmVCmKGrJYpKIYyqakgEouf3x/fM7tnZ+fmzO7MzszO+/l4zGNmzjlz5rMLO58535vP19wdERERgK0qHYCIiFQPJQUREemgpCAiIh2UFEREpIOSgoiIdFBSEBGRDkoK0i+Z2Wwz+3aJzrXKzA4txbnKwczGmdl6MxtQ6Vik9g2sdAAiPWFmq4DtgS3AeuBu4DR3Xw/g7l+uXHSBmTUDzwEN7t5ervdx9+eBYeU6v9QXXSlILfuUuw8D9gQmAudUNpzqY4H+ziUx/WeRmufuLwH3EJIDAGY238wujD3/kpk9Y2avmtldZvbuXOczs+PNbLWZvWJm52bs28rMZpnZ36L9N5vZtkniNLNPmtlyM3vDzF4ws/Nj+5rNzM1shpk9b2b/iL93vveNvXZg9PxBM/u+mS0B3gJ2NrP/MLNHzez16P4/ksQs9UdJQWqemY0BDgeeybH/YOAi4LPAaGA1cFOOY3cHrgGOB94N/BswJnbIGcARwAHR/teAnyQMdQPwBWAk8EngFDM7IuOY/YH3AocA55nZ+B6+7/HAScBw4E3g18CV0c9zGfBrM/u3hHFLPXF33XSruRuwitCX8CbgwP3AyNj++cCF0eO5wCWxfcOAzUBzlvOeB9wUez4U+BdwaPS8DTgktn90dK6BWc7VHMXWbV+0/7+ByzOOHRPb/wgwrdD7Zr4P8CBwQezY44FHMt77D8AXK/3vqFv13XSlILXsCHcfDhwIvA8YleO4dxOuDgDw0Bn9CrBDjmNfiB27ITo2bUfgdjP7p5n9k/BhvYXQ6Z2XmX3IzB4ws5SZvQ58OUvML8Uev0VnB3Kx7/tC7HGXnz+ymuw/v9Q5JQWpee7+W8KVwY9yHPJ3wocqAGY2lNCM8mKWY9cCY2PHbh0dm/YCcLi7j4zdhrh7tnNluhG4Cxjr7u8CZgOW4HU9ed94+eMuP39kHNl/fqlzSgrSX/w3cJiZ7Zll343ACWa2p5kNBn4APOzuq7Iceyswxcz2N7NBwAV0/TuZDXzfzHYEMLMmM5uaMMbhwKvu/raZTQKOTfi63r7v/wC7mdmxZjbQzD4H7A4sLOL9pU4oKUi/4O4p4Dqg24Q1d78/2v5LwpXALsC0HOd5EjiVkEjWEjp018QOuYLwbX+Rmb0J/BH4UKHwovv/A1wQve484OYkP1sv3je8ufsrwBTgLEJT2NnAFHf/RxHvL3XC3LXIjkg5mNkHgN+5+8hKxyKSlK4URMogmjD2WWBppWMRKYbKXIiUx/OEkUQnVDoQkWKo+UhERDqo+UhERDrUdPPRqFGjvLm5udJhiIjUlGXLlv3D3Zuy7avppNDc3MzSperHExEphpllznDvoOYjERHpoKQgIiIdlBRERKSDkoKIiHRQUhARkQ5KCiIiteass2DHHcN9idX0jOaWlhbXkFQRqSsDBsA773R93t5e1CnMbJm7t2TbpysFEZFacdZZXRMCwJYtJb1iUFIQEakVt95a3PYeUFIQEakVRx9d3PYeUJ+CiEgtGTgwNBmlqU9BRKSOtbfDmWfCuHHhvsiEUIiuFERE6oyuFEREJBElBRER6aCkICIiHZQURESkg5KCiIh0UFIQEZEOSgoiIuWUSsGjj4b7GqCkICJSLq2tocT1YYeF+9bWSkdUkJKCiEg5pFIwcyZs3Aivvx7uZ86s+isGJQURkXJYtQoGDeq6raEhbK9iSgoiIuXQ3Az/+lfXbZs3h+1VTElBRKQcmppg7lxobIQRI8L93LlhexUbWOkARET6renT4dBDQ5NRc3PVJwRQUhARKa+mpppIBmlqPhIRkQ5KCiIi0kFJQUREOigpiIhIh7IlBTMba2YPmFmbmT1pZl+Jtm9rZvea2V+j+21irznHzJ4xs6fN7GPlik1ERLIr55VCO3CWu48H9gVONbPdgVnA/e6+K3B/9Jxo3zRgD+DjwNVmNqCM8YmISIayJQV3X+vuj0WP3wTagB2AqcCC6LAFwBHR46nATe6+yd2fA54BJpUrPhGRbmqsomk59Emfgpk1AxOBh4Ht3X0thMQBbBcdtgPwQuxla6Jtmec6ycyWmtnSVB3/w4lIidVgRdNyKHtSMLNhwC+Br7r7G/kOzbLNu21wv9bdW9y9pamGJoSISBWr0Yqm5VDWpGBmDYSEcIO73xZtftnMRkf7RwProu1rgLGxl48B/l7O+EREgNqraHrEETBsWLgvsXKOPjJgLtDm7pfFdt0FzIgezwDujG2fZmaDzWwnYFfgkXLFJyLSoZYqmprBnXfChg3h3rI1svRcOa8U9gOOBw42s8ej2yeAHwKHmdlfgcOi57j7k8DNwErgbuBUd99SxvhERIJaqWia68qghFcM5t6t2b5mtLS0+NKlSysdhoj0F6lUdVc0HTYsXCFkGjoU1q9PfBozW+buLdn2aUaziEhaUxPss091JgQIZbiL2d4DSgoiIrXijjuK294DSgoiIrXEHaZODU1GU6eG5yWkRXZERGpNCa8MMulKQUREOigpiIhIByUFEalNKl5XFkoKIlJ7arF4XY0kMSUFEakttVa8bskSOOooGDu2JpKYkoKI1JZaKl43eTLsvz/cfjts2lQTSUxJQURqS60Ur1uyBO69N/u+ak1iKCmISK2pleJ1ixbl3leNSSyipCAitWf6dFi9Gu67L9xPn17piLqbPDn79sGDqzOJRZQURKR6FDNCp9qL1+23X/fE8KEPwQsvVGcSiygpiEh1qKVhpkmT1z33wOLFcN554f6Pf6zeJBbRegoiUnmpVEgEGzd2bmtsDE1D1fYh2toaRg8NGhQ6vOfOrepv/tloPQURqW61Msy01uZI9ICSgohUXrUOM81sJqqV5NULSgoiUnnVOMw0Wx9HtSavEtJ6CiJSHaZPD8tKVnKN5IULw1oFBx0EX/pSaB5K93PMnBn6OObODY8bGkJCqHTyKjElBRGpHk1NlfuAnTABVqwIj+fOha0yGlLSzUTVkLzKSElBROpbKgXXX9+ZENLeeafr83gzUSWTV5klTgpmtg3wbmAjsMrd3ynwEhGR6tXWBldeCfPnw5Yt2Y8ZMCCshdwPm4lyyZsUzOxdwKnAdGAQkAKGANub2R+Bq939gbJHKSJSSqefDj/+ceHjFiyA3Xbrl81EuRS6UrgVuA74iLv/M77DzPYGjjeznd19bpniExEprba2ZAlhwgT4/OfLH0+VyZsU3P2wPPuWActKHpGISCmlUl07hR95JPexgwbBMcfAtGkwZUpfRVhViu5oNrNxwNbu/lQZ4hERKZ1sJSkmTcp+7JAhMG9ezZWsKLWCk9fM7CIz2z16/BngIeAXZvb9cgcnItJjuUpSjBoFp53W9dhjjoHnn6/7hADJZjQf7u4ro8dfAyYDewH1eW0lIrUhX0mKq66ClSvDyKOVK+Hmm+umI7mQQqOPvgOMNrPvEkYf7QJ8DjDgXWZ2HvCgu/+u7JGKiBSjUEmK8ePDTboo1NH83ajpaEdgW+A6d7/AzAYBk939gr4IUkSkaOl6Sv24JEU5JGk+OhF4GLgT+Fa0bRxwUbmCEhHJK5WCM86AD3wALrkk93G1sGxnlenxIjtmtqO7ry5xPEXRIjsidai1FY49tuu2oUNh/frKxFODerXIjpl92MyONrPtoucfMLMbgcUljlNEJL9UCo4/vvv2DRvyXzFIYnmTgpn9FzAP+Azw66jj+V5Cc9Ku5Q9PRCRm1aruherSqnlN5xpSaPLaJ4GJ7v52VBDv78AH3P2vhU5sZvMIw1bXufv7o23nA18i1FAC+Ka7/0+07xxgJrAFOMPd7+nBzyMi/Vlzcyhpna2AnfoLSqJQ89FGd38bwN1fA55OkhAi84GPZ9l+ubvvGd3SCWF3YBqwR/Saq81sQML3EZH+InP5y0xNTfDzn3ffPnQonH12eWOrE4WSwi5mdlf6BjRnPM8pmrvwasI4pgI3ufsmd38OeAbIMRddRPqlOXNg7Fg45JDO5S+zmT4d1q0LlU4nTICLL1YncwkVaj6amvH80hK852lm9gVgKXBWdAWyA/DH2DFrom3dmNlJwEkA48aNK0E4IlJRqRRcemn4cAfYtCncz5wZVjjLNq+gqSmshSAlV2jy2m9L/H7XAN8DPLq/lDAPwrK9fY6YrgWuhTAktcTxiUhfam2FE07oTARxAwaEjmVNNutThUYf/crMPmVmDVn27WxmF5jZiUnfzN1fdvct0aptP6WziWgNMDZ26BhCp7aI9FepFMyYkT0hQNeSFNJnCvUpfAn4CPCUmT1qZv9jZr8xs2eBOcAyd5+X9M3MbHTs6ZFAelHUu4BpZjbYzHYiDHfNU/RcRGre8uXhgz+XK67QVUIFFGo+egk4GzjbzJqB0YQ1mv/i7m/le62ZtQIHAqPMbA3wHeBAM9uT0DS0Cjg5ep8nzexmYCXQDpzq7jkWTRWRmpO50E0+DQ2hiunJJ/dFZJKhx2UuqoHKXIjUgGwL3UyfHhLFmDFdK5k2NMCf/qTqpWXWqzIXIiI9lmuhm1QqXDHMnw+NjWGeQWMjLFighFBhRS/HKSKSWHqhm40bO7elF7ppagpXDIcemrxpScoucVIws0ZgnLs/XcZ4RKQYxbTVV0KhhW4gxF2NsdepRM1HZvYp4HHg7uj5noVmNItImbW2hpm/hx2WfwZwJaUXumlshBEjwr0WuqlqiTqazWwZcDBh6c2J0bYn3P0DZY4vL3U0S91KpUIiiDfLNDaGhWT66gO3mKuUar+iqTOl6Ghud/fXSxiTiPRGvkXp+0KxVylNTbDPPkoINSBpUlhhZscCA8xsVzO7Cvh9GeMSkbjM6qFJ2urLFUNbW+4RRVLzkiaF0wllrTcBNwKvA18tU0wiEpftW3lfttWnUnDhhTBuXIhh4sTux/TlVYqUlSaviVSzQn0H5W6rT088i79/Nn3dnyG90us+BTO718xGxp5vY2ZaGU2k3Ar1HZSzrT4+8SzTkCEweLBGFPVDSecpjHL3f6afuPtrZrZdeUISkQ6V6Du45ppwhfDhD3efeJZmBo89Fha30YiifiVpUnjHzMa5+/MAZrYjOdY7EJESSvcdzJwZrhA2by5v38Euu8Cbb4bnDz2U/bghQ0IMKkfRLyVNCucCi80svejOR4lWPxORMit3KYhUCi67LKx8lq2PceBA2HrrkJC++c1QvVRXBv1WoqTg7neb2V7AvoRV0r7m7v8oa2Qi0qlcpSBaW8NCN/nWNWhpCUtfqpmoLhRTEG8w8Gr0mt3NDHf/XXnCEpGyS6XgxBPzJwSAL3whdGZLXUiUFMzsYuBzwJPAO9FmB5QURGpBtqGrq1aFdZDz2XZbOOWUMgcn1STp5LUjgPe6+yfd/VPR7dNljEuk/8mcldxXcpWkaG6GLTkWONxlF7j6anjllT4LU6pD0qTwLNBQzkBE+q3MGcF9WdG00CI38+aFUU1pDQ0wezY884yuEOpU0j6Ft4DHzex+QqkLANz9jLJEJdJfZM4IfvvtcD9zZhhRVK6hpcuXdz5PsshN+viJE9WZXOeSJoW7opuIJJVvRnD8g7mU5syB00/v7DweOBC2ymgQyLbIzeTJpY1DalbSIakLyh2ISL+TbSnKtFLPSk7PNfjhD7tub28PiaGxsfyT36RfSDr6aFfgImB3YEh6u7vvXKa4RGpTfJRPthIV0DkjuBQfzKecAjfeCBs25O40HjwYbrsNttlGcw2koKTNRz8DvgNcDhwEnECYxCYiaen+g0GDQjKYO7d7iYpSzQhOpWC7hOXHtmxRX4EkljQpNLr7/WZm7r4aON/MHiIkChGJ9x+km4tmzgzlpFevLm2JitZWOPbYZMcOHBhGGCkhSEJJk8LbZrYV8FczOw14EVCVVJG0bP0H6c7kUpS2TjdLDRsWkk0hgwbBmWeGmxKCFCFpUvgqsDVwBvA9QhPSjDLFJFJ7ylniOt4s9fbb3UcTxQ0YAOefr6J10mMFk4KZDQA+6+5fB9YT+hNEJK5cJa7b2uCEE2DTpsKrnwGsXatkIL1SMCm4+xYz2zvqT9AaCiK5lKrE9cKFcMcdYbTQVVeFhBDX2AjvvBNGFb3xRlj97Nhjw+I4Uh/KuAxr0uaj5cCdZnYLsCG90d1vK2k0IrWutyWuJ0yAFSsKH7d8uVY9q1fZRrlNn16y0ydNCtsCrwAHx7Y5oKQg0lvpb31/+UvhhDB4sFY9q2e5RrmVsGRK0hnN6kcQKbVUKpSl+MEPwre+9evzHz94cLhCUEKoX/lGufVlUjCzn5FlTWZ3P7EkUYjUm9bWsMBNukBevk7kxsZwrysEKecot0jS5qOFscdDgCOBv5csCpFKK2PHXYd994WlS+GDHwyjitIJIc6s6zrJ73sfXHed+g4kKNcotxjryYCiaCLbfe5+cMGDy6ilpcWXLl1ayRCkPyhzxx0QPuyTaGyEn/4UHngAjjgCpkwpbRzSP/TyS4yZLXP3lqz7epgU3gv82t3fU/SLS0hJQXotlQqL3sSbbxobQ2mKUn372nlneO65wsc1NpYnIYlkyJcUEq28ZmZvmtkb6RvwK+AbBV4zz8zWmdmK2LZtzexeM/trdL9NbN85ZvaMmT1tZh9L9qOJ9FK64y4u3XHXW6kULFqUPyGMGBGqpn7veyERKSFIhSUdfTS8B+eeD/wYuC62bRZwv7v/0MxmRc+/YWa7A9OAPYB3A/eZ2W7unqMWsEgPZLvkLmXHXfz8990XmqTylaTYa6+w9KX6C6SKJL1S2M/MhkaPjzOzy8xsx3yvcfffAa9mbJ4KpBfsWQAcEdt+k7tvcvfngGeAScl+BJEEci1en+64a2wM39rTTTjFfkinz3/QQWEt5hkzQpPUhg25X7NsWWmK5YmUUKKkAFwDvGVmHwTOBlbT9Qogqe3dfS1AdJ+utLoD8ELsuDXRNpHey7d4PYQmm9Wrw7f7Yptwpk2D4cPhuOM6k8Dbb3cuh5nNTjt1HWEkUkWSDkltd3c3s6nAFe4+18xKWSU129CMrH81ZnYScBLAuHHjShiC9FtJJvwUW56imEVuIPQb3HmnFruRqpf0SuFNMzsHOA74dVQ5taEH7/eymY0GiO7XRdvXAGNjx40hxzwId7/W3VvcvaVJf1ySTSoFjz7aeSVQ6gk/ra3JEsKgQZ1NUvPmweTJSghS9ZImhc8Bm4CZ7v4SoWnnv3rwfnfRuQ7DDODO2PZpZjbYzHYCdgUe6cH5pd5l6zsoVb8BdDZFFdLQAI8/3rMmKZEK6tE8hUQnNmsFDgRGAS8Tlu68A7gZGAc8Dxzj7q9Gx58LnAi0A1919/8t9B6apyBdFJpz0JsJP+nXvvYafPazoW8iG7NQo2jePCUCqVr55ikkrX10FHAxoWPYopu7+4hcr3H3XH8Rh+Q4/vvA95PEI5JVob6DnpS1bmuDK6+E+fPDh/2mTWEtg1weflhDTKWmJe1ovgT4lLu3lTMYkV4pZd/B4YeHiWfxBJCuVdTQEK5AGhrCIjdDhsDUqXDTTT2NXKRqJE0KLyshSNUrRbGwtjbYfff8xzQ2wi23hJXRdFUg/UzSpLDUzH5B6BPoWBtQK69J1enpkpg33ADf+lay8habN2toqfRbSZPCCOAtYHJsm1Zek+pUTN9BWxvst1/oQE5iyJCSlyoWqSZaeU3qUyoFp54amoGSOuYY+MlPlBCkX8ubFMzsbHe/xMyuIvvKa2eULTKRcpkzB844o3undD4rV2rVM6kLha4U0p3Lmgwgte+ss8L8gX/+M9nxW20VZiH/b8EpMyL9Rt6k4O6/iu4X5DtOpKolGVEUt802sGSJrgykLiUtcyFSe5YsCaWpkyaE5ma4/np49VUlBKlbSUcfidSOVAo+9akwuziJGTPgG99QIhBBSUH6k1QKLr003Nrbk71m9mw4+eTyxiVSQ5LWPtqNsNDO9u7+fjP7APBpd7+wrNGJJHH44aEaadJEAKFw3csva3ipSIakfQo/Bc4BNgO4+xOENZVFirNkCXznO+G+t9rawof73XcnTwhDh8KZZ4aaRkoIIt0kTQpbu3vm+gZFfC0TAQ48EPbfHy64INx/7GM9P9fppxc3omiPPcJcg/XrQ/OSiGSVNCn8w8x2IZrAZmZHA2vLFpX0P+efD7/9bddtixb17Irhmmvgxz9OduwnPwmLF8OKFepIFkkgaUfzqcC1wPvM7EXgOeDzZYtK+pdUCi7M0f20aFGoPZT0PPvuC88+W/jYgQND4lAnskhRCiaFaD3mU9z9UDMbCmzl7m+WPzSpWZkrnK1aFRaoeeut7sdOntx9WzZz5sBppyXrO7jnHlUxFemhgknB3beY2d7R4w3lD0lqWmtrWM9g0KBQW2ju3FDKOtuyrwcckP0qIZUKi9Y89hgcdBAccQR8+cuF33vMGHjhhV7/CCL1LGmfwnIzu8vMjjezo9K3skYmtSe9qP3GjWEN440bOxe5nzs3LE6z9dYwYEAYgfTgg93PMWcObLcd/OEPYenLu+8unBCOOy50IishiPRa0j6FbYFXgINj27SegnRasgR+9rNQRC4uvUZyocVvFi6Eiy6C3/++uPedMAF+/vNeBC4icVpPQXpv8mS4997s++JrJGdb/GbhQjj++OSVS9P22w9mzYIpU4qNVkTy0HoK0jtLlmRPCEOHhgli+VYpmzAhDBVNatiwkGSuuEKjikTKpNCVwsroXuspSKf46KJFi7IfM21aaA7KlRAuuaS4hLBuXfHrLotI0Qolhc8BC4GR7n5FH8Qj1S5zdNHZZ2c/7oQTsn94Dx8eZhUnMWAAHHZY5yI3SgYiZVdo9NHeZrYjcKKZbWNm28ZvfRGgVIFUCh59NNQayhxddMkloXxF3OTJXYeaLlwIRx8d6hQlSQi77BKuDNrbteqZSB8rdKUwG7gb2BlYBlhsn0fbpT+LXxm8/Xb20UWXXBKuGhYt6poQUqlQWuKVV5K918iRYSSROo9FKqbQcpxXAlea2TXufkofxSTVYsmSsADN5s3hqiCb9OiipqauVwfnnw/f/W7y97r44txNUSLSZ5IOSVVCqDenn5696FxjYxhVNHhwSAiZo4va2uDII+Hpp5O/1+TJSggiVUIrr0l3bW35q5AuXx76BuIjgVIpOPVUuOWW4t5r8eLkBfFEpOyUFKRTWxs88gi8+GL2/Q0N4cogswR1aysce2xx7zV4cOijEJGqoqQgQa7morgHHujaibx8eZiJnDQhNDTA9deHIncaXipSlZQUpHBzEYSy1bfdBp/+dBha+uqr2SufZjN8eOhIPkVdUyLVTkmhHmWud/BI5kqrke9/H3bYASZNgve/P3QwF2OffeDyy9VnIFJDlBTqTbb1DiZNyn7skUeG/oN99y0+IYwcmTvZiEjVSrqegtS6VCpMLsu23sGoUaF5KO7EE+GQQ0JT0cMPF/9+r71WmrhFpE8pKfR3bW1hkZqxY+Goo7pPQkuvd3DVVWGhmvnz4ROfgHnzYO3aZO/R0BCqokJIMEn7GkSk6lSk+cjMVgFvAluAdndviWop/QJoBlYBn3V3fd3sjZkzw4d72qZN3Y+Jr3cwfjzstVdxQ0VnzYIzz9RoIpF+opJXCge5+57u3hI9nwXc7+67AvdHz6WnfvSjrgkh09ChYXZyekZyKgXbbps8IUyaFIrW5SuPLSI1p5o6mqcCB0aPFwAPAt+oVDA1LZWCb34z9/4hQ8Lw0okTwwf6UUfB7bcnO/dWW4V1EDInsIlIv1CppODAIjNzYI67Xwts7+5rAdx9rZltl+2FZnYScBLAuHHj+ire6rdkSWeV0kGDwm3z5u7HDR4cRh197GPFv8e3vw0XXND7WEWkalUqKezn7n+PPvjvNbOnkr4wSiDXArS0tKhHE7qukXzBBWF9g2xDSHfeGZ59tvjzDxsGb77ZqxBFpDZUpE/B3f8e3a8DbgcmAS+b2WiA6H5dJWKrOdnWSH7wwVB1tLEx9B2kRwcVmxCGDw8jkpQQROpGnycFMxtqZsPTj4HJwArgLmBGdNgM4M6+jq2mtLXBggVwww3Z97vD6tWhmWjzZtiwofj3eOMN9R2I1JlKNB9tD9xuZun3v9Hd7zazR4GbzWwm8DxwTAViq35JS1SvXw/bZe2WKezjH9cymCJ1qs+Tgrs/C3wwy/ZXgEP6Op6aMmdOqGaarQM5zgwuu6z486sjWaTuVdOQVMlnzpwwMzmXb34T/vY3uPVW2LIl+XnHj4cvflErn4kIoKRQ/VKpsI7B6afnP+4HP0h+zgED4I47YMqUXoUmIv2PkkI1Spe2fuwxOOOMMK+gVK6+WusaiEhOSgrVJl3aeuDA0g4FHTUqJBsRkTxUJbWapFKdpa1LmRAmTVJCEJFElBSqyapVoTxFqTQ0wOLFPVsPQUTqkpJCpaVS8Oij4b65uXT9B1dfHc6lpTBFpAhKCpXU2go77giHHRbu77svlLJubAzf8nvCLMxmVmeyiPSAkkIl3HADHH44zJjRfWnMpUvD40IT1DK95z2hTlGxaymLiMRo9FFfGzsW1qzJvm/jxuJnImvpSxEpISWFvrBkSVjE5qWXcieEYo0fH64MSiE9L6K5uX5XUdPvQARQ81H5TZ4M++8Pl16au6JpsW68sXQJIbNfo7W1NOetJfodiHQwr+Hmh5aWFl+6dGmlw8gulYLrrw+L2pfKBReE+kel+iabSoUPwY0bO7c1NoaS2/XybVm/A6lDZrbM3Vuy7VPzUTn86Ecwa1ZxhenyWby450NL8zWLpOdFxD8QGxrC9nr5QNTvQKQLNR+V2n/+J3z966VJCBMmhI7kniSEVAouvBDGjcvdLJJtXsTmzWF7vdDvQKQLJYVSWrIkzDMoBXd44omevTbdRv7tb8Pbb3cd8hovd9HU1DkvYsSIcD93bn19Q9bvQKQL9Sn0VryiaZIFcArpbRXTbG3kaSNGhAly++zT/TX1PvJGvwOpI+pTKJdSVTTtTZ9Bpmxt5Gm5mkWamvRBqN+BCKCkULyFC8MCNbvtBt/6Vu+vDEaMyF8EL/0NdtiwsO5yoW+yueonDRmiZhERKUhJoRjjx8NTT5X2nPk6NdNXIhC++Tc2hsdz58L06dlfk24jnzkzjKLZvDks1XnyyUoIIlKQkkJSX/96aRLCmDFdZzXPnJn9wzq+tkJa+vHMmXDoobk/5KdPD/vVRi4iRdLoo0JSKVi0KMxI7q116+CVV7pumzs3+wI4+dZWSI+jz6epKXQo50o46XLdIiIxSgr5pId2HnVU7wrPjRwZXp/tgz7XB3y+tRV6M45eJR1EJA8lhVzizTcbNvT8PO7w2mvhcTETpeLj54cMCdsaG3s3jj7+M+WauyAidU19CrmsWgWbNvX89Q0N8OKLXbdl6wTO9wEf7xtIOvooH5V0EJEClBSg68SlAw6AtraenWfw4DBnYcsWOPfc7O9x6KGh2FrSTuBSjp9XSQcRKUDNR+k29kmTYLvtepYQGhvhtNPCUpibN4fSEj/4QWebfWY7/m235T9fuTqCVdJBRAqo7zIX+UpCJNHQAFttFQrPnXde9vM0NoYlMjObooYPh/Z2uPxy2GuvzquG9NyEQYPCt/p8cxJ6SiUdROpavjIX9Z0Uvve98GHeW4MHhw/xbKUu0h/u+cQTxNe+ptr+IlJW+ZJC/TYfjRjRs4Rw2WXwrnd13dbQkPuDv1BCgJBMNm6Er3wl9ElknrvQnAQRkRKpz6SQ61t9IY2NoQP5rbe6bm9vhz326LptwIBwBZEuTZE0LnUEi0gF1V9SuOSSnhex27gx3MzC3IERI8I3+fb2UDo7bssWuPXW7udoaAivHTas+772drjiCnUEi0jF1F9SSDKD98tfhkce6d5MlDZkCNx5J9xyS2juaW/Pftwrr3Qf7bNgATz/PPzmNzB7dvcEcPLJoQ/hvvvCfak7mUVE8qi/eQrTp8Pjj2fft+eesHx5eJxK5S8zMXFi/rULIAxzHT8+e3G6dG2io47Kvk9XByJSAfV3pXD22TB0aPftixd3JgRIVmYiX32i004LCSF9rlzF6fLtExHpY1WXFMzs42b2tJk9Y2azyvIm69fDxReHK4OLLw71ibKtfDZ9emjC+d3vYOVK+O1vuzbpZE4GGzIkNP+sXAlXXVWW0EVEyqmq5imY2QDgL8BhwBrgUWC6u6/MdnxVrNEMmgwmIjWlltZongQ84+7PApjZTcBUIGtSqBrqAxCRfqLamo92AF6IPV8TbetgZieZ2VIzW5pSyWcRkZKqtqRgWbZ1ad9y92vdvcXdW5r07VxEpKSqLSmsAcbGno8B/l6hWERE6k61JYVHgV3NbCczGwRMA+6qcEwiInWjqjqa3b3dzE4D7gEGAPPc/ckKhyUiUjeqakhqscwsBazO2DwK+EcFwimW4iwtxVlairO0qi3OHd09a6dsTSeFbMxsaa7xt9VEcZaW4iwtxVlatRInVF+fgoiIVJCSgoiIdOiPSeHaSgeQkOIsLcVZWoqztGolzv7XpyAiIj3XH68URESkh5QURESkQ79JCn2yDkP+9x9rZg+YWZuZPWlmX4m2b2tm95rZX6P7bWKvOSeK92kz+1hs+95m9udo35Vmlq0mVG/jHWBmy81sYbXGaWYjzexWM3sq+r1+uErj/Fr0b77CzFrNbEg1xGlm88xsnZmtiG0rWVxmNtjMfhFtf9jMmksY539F/+5PmNntZjayGuOM7fu/ZuZmNqrScfaau9f8jTD7+W/AzsAg4E/A7n0cw2hgr+jxcMK6ELsDlwCzou2zgIujx7tHcQ4GdoriHxDtewT4MKFA4P8Ch5ch3jOBG4GF0fOqixNYAPxn9HgQMLLa4iRU8X0OaIye3wx8sRriBD4K7AWsiG0rWVzA/wFmR4+nAb8oYZyTgYHR44urNc5o+1hCFYbVwKhKx9nr/9OVeNOS/xDhF3xP7Pk5wDkVjulOwmJBTwOjo22jgaezxRj9p/pwdMxTse3TgTkljm0McD9wMJ1JoariBEYQPmwtY3u1xZku974toWzMwugDrSriBJrp+mFbsrjSx0SPBxJm7Fop4szYdyRwQ7XGCdwKfBBYRWdSqGicvbn1l+ajgusw9KXosm8i8DCwvbuvBYjut4sOyxXzDtHjzO2l9N/A2cA7sW3VFufOQAr4WdTM9f/MbGi1xenuLwI/Ap4H1gKvu/uiaoszppRxdbzG3duB14F/K0PMJxK+UVddnGb2aeBFd/9Txq6qirMY/SUpFFyHoa+Y2TDgl8BX3f2NfIdm2eZ5tpeEmU0B1rn7sqQvyRFPuX/nAwmX6te4+0RgA6G5I5dK/T63IawOuBPwbmComR2X7yU54qn0/+GexFX2mM3sXKAduKHAe/Z5nGa2NXAucF623Tnes6K/zyT6S1KoinUYzKyBkBBucPfbos0vm9noaP9oYF20PVfMa6LHmdtLZT/g02a2CrgJONjMrq/CONcAa9z94ej5rYQkUW1xHgo85+4pd98M3Ab8RxXGmVbKuDpeY2YDgXcBr5YqUDObAUwBPu9Rm0qVxbkL4cvAn6K/pzHAY2b271UWZ1H6S1Ko+DoM0QiCuUCbu18W23UXMCN6PIPQ15DePi0acbATsCvwSHRJ/6aZ7Rud8wux1/Sau5/j7mPcvZnwe/qNux9XhXG+BLxgZu+NNh1CWKu7quIkNBvta2ZbR+c/BGirwjjTShlX/FxHE/4vleSbrZl9HPgG8Gl3fysj/qqI093/7O7buXtz9Pe0hjDY5KVqirNofd2JUa4b8AnCiJ+/AedW4P33J1zqPQE8Ht0+QWgTvB/4a3S/bew150bxPk1spAnQAqyI9v2YMnU2AQfS2dFcdXECewJLo9/pHcA2VRrnd4Gnovf4OWHEScXjBFoJ/RybCR9YM0sZFzAEuAV4hjCiZucSxvkMoX09/bc0uxrjzNi/iqijuZJx9vamMhciItKhvzQfiYhICSgpiIhIByUFERHpoKQgIiIdlBRERKSDkoLUHTP7opm9u9Jx5GNmzWZ2bJ79o62zwu2BZvZ6VA7kKTP7UZbjz8+y7T6LVUkVASUFqWEW9OT/8BcJJSmqWTOQMykQqtz+NPb8IQ/lQCYCU8xsPwhlV8zsZuBUC2WoL4695ueEypwiHZQUpKZE36DbzOxq4DFgrJl93cwejT70vptx3E8trHWwyMwazexowuShG8zscTNrzDj/l6Jz/cnMfhnVt8HM5pvZNRbWzHjWzA6wUF+/zczmx14/3UKt/BXxD2AzWx97fHT6NdF5rzSz30fnPTo67IfAR6IYv5blV/EZ4O7Mje6+kTDZK11k7QvARmA2YTLgz2OH30Wo0inSQUlBatF7geuib8bvJZQQmET40NvbzD4aHbcr8BN33wP4J/AZd7+VMEv68+6+Z/QhGnebu+/j7h8klKuYGdu3DaHc+NeAXwGXA3sAE8xsz6hJ6uLomD2BfczsiAQ/z2jCjPgphGQAofjfQ1GMl8cPjsomvObumzJPFDUH7Qr8Ltr0L0JZ70Hu/o67dywQ4+6vAYPNrM8rcUr1UlKQWrTa3f8YPZ4c3ZYTrhzeR/hQhFCo7vHo8TJCk0wh7zezh8zsz8DnCR/6ab/yUALgz8DLHmrfvAM8GZ17H+BBD8Xx0pU9P0phd0Qf2CuB7RMcP5pQVjzuI2b2BPASoXTJS9H26wjJbUZ0NXJ0xuvWUf1NadKHBlY6AJEe2BB7bMBF7j4nfoCFNS3i36S3AF2ainKYDxzh7n8ysy8S6kOlpc/3Tsa53yH8LbXnOW+8nsyQjH3xcyVZgnNjlnM85O5TzGw3YLGZ3e7uj7v7v4Czzewt4BfAPWa21N1XxWLJvFqSOqYrBal19wAnWljHAjPbwcy2K/CaNwlLpmYzHFhroQz654uM5WHgADMbZWYDCO31v432vWxm46OO8SMTnCtfjH8hx1WPu/8FuIhQYRQz29VC5WAIRfBeB9L9JAb8O6GQmwigpCA1zsMqZzcCf4iafG4l94dp2nxgdraOZuDbhA/3ewmVT4uJZS1hGcYHCOvzPubu6bLIswhLdf6GUGmzkCeA9qjDu0tHs7tvAP5mZu/J8drZwEejvof3AQ8CJxCa2H4dNVMB7A38MWrqEgFQlVSRWmRmRwJ7u/u3Eh5/vrufn7HtCuAud7+/DCFKjVKfgkgNcvfbixw19GCWbSuUECSTrhRERKSD+hRERKSDkoKIiHRQUhARkQ5KCiIi0kFJQUREOvx/nuFv76r9EYkAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df1.plot(kind='scatter',x='rent amount (R$)',y='fire insurance (R$)',title='Belo Horizonte') # scatter plot\n", + "df2.plot(kind='scatter',x='rent amount (R$)',y='fire insurance (R$)',color='g',title='Campinas')\n", + "df3.plot(kind='scatter',x='rent amount (R$)',y='fire insurance (R$)',color='y',title='Porto Alegre')\n", + "df4.plot(kind='scatter',x='rent amount (R$)',y='fire insurance (R$)',color='r',title='Rio de Janeiro')\n", + "df5.plot(kind='scatter',x='rent amount (R$)',y='fire insurance (R$)',color='b',title='São Paulo')" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "db481245", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAs0UlEQVR4nO3de5zcdX3v8dd7N1k2F0ISEgIkgUgNAbyhBBoEUZECogVqSwvHC9ac0mNR0bZH4WhttccebWtb0SqHigWsBakHBa0eQQ54wwhJCdewkEoMIbcFDAkhm02yn/PH7zdksjszv8vuzO5s3s/HYx4789n5zu8718/ve/l9f4oIzMzMGukY7QqYmdnY52RhZmaZnCzMzCyTk4WZmWVysjAzs0xOFmZmlsnJwmwMkXSXpP862vUwG8zJwsY9SWsk7ZD0vKRNkv5Z0tRhPNYZw6yPJP1C0iPDeRyzVnKysP3Fb0bEVOA1wInAx4oUljRhBOtyGnAIcJSkE0fwcesa4frbfsjJwvYrEfEU8D3g5QCSzpX0sKQtaRfQsZX7pq2Ij0h6ANgu6QbgCODbaSvlw1mPUcfFwC3Ad9PrdUl6j6RVkn4l6fuSjqz635mSeiQ9J+mLkn5Y6cKS9G5JP5X095KeBf5C0gGS/lbS2rSFdZWkSUVfQ9s/OVnYfkXSfOAc4D5JRwM3AB8EZpP8eH9bUldVkYuAtwDTI+IiYC1pKyUi/jrnY1RvfzLwO8DX0suFDe57PvA/gLelj/3jdFtImgV8A7gCOBjoAV476CF+HfgFSSvmU8BngKOB44GXAnOBjzd4ucxe5GRh+4tvSdoC/AT4IfBXwO8B/x4Rt0fELuBvgUns+6N7ZUQ8GRE76jxunseo9jZgJ3Ab8B1gAkkyquUPgf8VEasiYnda5+PT1sU5wMMRcXP6vyuBjYPKr4+Iz6f/7wP+APhQRDwbEdvSx7uwzrbN9uF+TNtfnB8RP6gOSDoc+GXldkQMSHqSZI+74smMx83zGNUuBm5Kf8B3S7o5jX2zxn2PBD4n6bPV1U4f+/DqukVESFo3qHx13WcDk4EVkqofq7Px0zNLOFnY/mw98IrKDSW/ovOBp6ruM3hZ5sG38zxG5X/zgNOBkyT9dhqeDHRLmhURTw8q8iTwqYj4Wo3HWgjMG7TdeYPuVl3Xp4EdwMvScRuzQtwNZfuzm4C3SHqTpInAn5B0Ed3doMwm4KiSj/FO4DFgEcm4wfEkYwjrSMZGBrsKuELSywAkHSTpgvR//w68QtL56UynS4FD61U6IgaAfwL+XtIh6ePNlXRWg+dq9iInC9tvRUQP8A7g8yR73r9JMnjd36DY/wI+ls58+tOCj3Ex8MWI2Fh9IUkKQ2ZFRcQ3SQalb5S0FXgIeHP6v6eBC4C/Bp4BjgOWkySqej4CrAaWpY/3A5LEZZZJPvmRWfuT1EHSQnl7RNw52vWx8cctC7M2JeksSdMlHUAyxVbAslGulo1TThZm7etk4D/Z2/11foMpvmbD4m4oMzPL5JaFmZllGrfHWcyaNSsWLFgw2tUwM2srK1aseDoiZg+Oj9tksWDBApYvXz7a1TAzayuSflkr7m4oMzPL5GRhZmaZnCzMzCyTk4WZmWVysjAzs0xOFtY0/f29bN16L/39vaNdFTMbpnE7ddZG16ZNN9DTsxSpi4h+Fi26hjlzaq3CbWbtwC0LG3H9/b309CxlYGAHe/Y8x8DADnp6lrqFYdbGnCxsxPX1rUHq2icmTaSvb83oVMjMhs3JwkZcd/cCBp/7J2IX3d0LRqdCZjZsThY24rq6ZrNo0TV0dEyis3MaHR2TWLToGrq6hiw3Y2ZtwgPc1hRz5lzEjBln0Ne3hu7uBU4UZm3OycKapqtrtpOE2TjhbigzM8vkZGFmZpmcLMzMLJOThZmZZXKyMDOzTE4WZmaWycnCzMwyOVmYmVkmJwszM8vkZGFmZpmcLMzMLJOThZmZZXKyMDOzTE4WZmaWqenJQlKnpPskfSe9PVPS7ZIeT//OqLrvFZJWS+qRdFZV/ARJD6b/u1KSml1vMzPbqxUti8uAVVW3LwfuiIiFwB3pbSQdB1wIvAw4G/iipM60zJeAS4CF6eXsFtTbzMxSTU0WkuYBbwG+XBU+D7guvX4dcH5V/MaI2BkRTwCrgZMkHQZMi4ifRUQA11eVMTOzFmh2y+IfgA8DA1WxORGxASD9e0ganws8WXW/dWlsbnp9cHwISZdIWi5peW9v74g8ATMza2KykPRWYHNErMhbpEYsGsSHBiOujojFEbF49myfztPMbKQ08xzcpwDnSjoH6AamSfoXYJOkwyJiQ9rFtDm9/zpgflX5ecD6ND6vRtzMzFqkaS2LiLgiIuZFxAKSgev/FxHvAG4FLk7vdjFwS3r9VuBCSQdIegnJQPY9aVfVNklL0llQ76oqY2ZmLdDMlkU9nwZukrQUWAtcABARD0u6CXgE2A1cGhF70jLvBa4FJgHfSy9mZtYiSiYYjT+LFy+O5cuXj3Y1zMzaiqQVEbF4cNxHcJuZWSYnCzMzy+RkYWZmmZwszMwsk5OFmZllcrIwM7NMThZmZpbJycLMzDI5WZiZWSYnCzMzy+RkYWZmmZwszMwsk5OFmZllcrIwM7NMThZmZpbJycLMzDI5WZiZWSYnCzMzy+RkYWZmmZwszMwsk5OFmZllcrIwM7NMThZmZpbJycLMzDI5WZiZWSYnCzMzy+RkYWZmmZwszMwsk5OFmZllcrIwM7NMThZmZpZpQqN/SpoHXAi8Djgc2AE8BPw78L2IGGh6Dc3MbNTVTRaS/hmYC3wH+AywGegGjgbOBj4q6fKI+FErKmpmZqOnUcvisxHxUI34Q8DNkrqAI5pTLTMzG0vqJos6iaL6//3A6hGvkZmZjTkNB7glvSEdt0DSkZJ+IGmZpNOyHlhSt6R7JN0v6WFJn0jjMyXdLunx9O+MqjJXSFotqUfSWVXxEyQ9mP7vSkkq/5TNzKyorNlQnwaeS6//FfAN4DLgH3I89k7g9Ih4FXA8cLakJcDlwB0RsRC4I72NpONIBtNfRjIm8kVJneljfQm4BFiYXs7OsX0zMxshdZOFpD8nGZP4UHr9LJIB77OBWZI+3qiFEYnn05sT00sA5wHXpfHrgPPT6+cBN0bEzoh4gqSL6yRJhwHTIuJnERHA9VVlzMysBRqNWXxC0luAnwCHAXdHxJ8BSDozIj6Z9eBpy2AF8FLgHyPi55LmRMSGdBsbJB2S3n0usKyq+Lo0tiu9Pjhea3uXkLRAOOIIj72bmY2UhsdZAB8C/o6kS+kSAEkvA1bmefCI2AMcL2k68E1JL29w91rjENEgXmt7VwNXAyxevLjmfczMrLiGySIifgr8+qDYw8ClRTYSEVsk3UXShbVJ0mFpq+IwkuM3IGkxzK8qNg9Yn8bn1YibjZr+/l76+tbQ3b2Arq7Zo10ds6YrvNyHpN+QdHuO+81OWxRImgScATwK3ApcnN7tYuCW9PqtwIWSDpD0EpKB7HvSLqttkpaks6DeVVXGrOU2bbqBZcuO5P77f4Nly45k06YbRrtKZk3X6Aju04GrSJb5+BbJbKjrSbqFPpXjsQ8DrkvHLTqAmyLiO5J+BtwkaSmwFrgAkhaLpJuAR4DdwKVpNxbAe4FrgUnA99KLWcv19/fS07OUgYEdJKvfQE/PUmbMOMMtDBvXGh7BTTJO8TPgzSSDz38WEZ/L88AR8QDw6hrxZ4A31SnzKWokoohYDjQa7zBrib6+NSSLF+x4MSZNpK9vjZOFjWuNkkVExF3p9W9J6s2bKMzGq+7uBSSLF+wVsYvu7gWjUyGzFmmULKZLelvVbVXfjoibm1cts7Gpq2s2ixZdQ0/PUqSJROxi0aJr3Kqwca9Rsvgh8Jt1bgfgZGENjdcZQ3PmXMSMGWeMy+dmVk+jg/J+v5UVsfFl06Yb0r3vLiL6WbToGubMuWi0qzViurpmO0nYfqXRch/vkNTo/78m6dTmVMvaWfWMoT17nmNgYAc9PUvp7+8d7aqZWUmNuqEOBu6TtIJkyY5ekpMfvRR4PfA06SKAZtU8Y8hs/GnUDfU5SV8ATgdOAV5J8u1fBbwzIta2porWbjxjyGz8yVruYw9we3oxy8UzhszGn6yFBC2n8TrzpyzPGDIbX5wsRsB4n/lTlmcMmY0fhRcStH155o+Z7Q8yk4Wkr0o6qOr2kZLuaG612sfemT97VWb+mJmNF3laFj8Bfi7pHEl/QDLY/Q9NrVUb8cwfM9sfZI5ZRMT/lvQwcCfJsRWvjoiNTa9Zm/DMn7HDkwzMmiczWUh6J/BnJCcdeiXwXUm/HxH3N7ty7cIzf0afJxmYNVee2VC/DZwaEZuBGyR9E7gOOL6ZFWs3nvkzenxCIrPmyxyziIjz00RRuX0PcFJTa2VWgCcZmDVfnm6obmAp8DKStaEq3tOsSpkV4UkGZs2XZzbUV4FDgbNIzmkxD9jWzEqZFVGZZNDRMYnOzml0dEzyJAOzEZZnzOKlEXGBpPMi4jpJ/wp8v9kVs/bXytlJnmRg1lx5ksWu9O8WSS8HNgILmlYjGxdGY3aSJxmYNU+ebqirJc0APgbcCjwCfKaptbK25iVQzMafPC2LOyLiV8CPgKMAJL2kqbWytuaTH5mNP3laFv+nRuwbI10RGz88O8ls/KnbspB0DMl02YMkva3qX9PYdwqt2T68BIrZ+NOoG2oR8FZgOvCbVfFtwB80sU42Dnh2ktn40ugc3LcAt0g6OSJ+1sI62Tjh2Ulm40ee5T6cKMzM9nM+U56ZmWXKc6a8zlZUxMzMxq48LYvVkv5G0nFNr42ZmY1JeZLFK4HHgC9LWibpEknTmlwvMzMbQ/IMcG+LiH+KiNcCHwb+HNgg6TpJL216Dc3MbNTlGrOQdG56hrzPAZ8lWfbj28B3m1w/MzMbA/KsDfU4cCfwNxFxd1X8G5JOa061zMxsLMkzZvGuiFhanSgknQIQER+oV0jSfEl3Slol6WFJl6XxmZJul/R4+ndGVZkrJK2W1CPprKr4CZIeTP93pSSVerZmZlZKnmRxZY3Y53OU2w38SUQcCywBLk1nVF1OspLtQuCO9Dbp/y4kWY/qbOCLVdN2vwRcAixML2fn2L6ZmY2QRgsJngy8Fpgt6Y+r/jUNyDz2IiI2ABvS69skrQLmAucBb0jvdh1wF/CRNH5jROwEnpC0GjhJ0hpgWuVIcknXA+cD38v7JM3MbHgatSy6gKkkCeXAqstW4HeKbETSAuDVwM+BOWkiqSSUQ9K7zQWerCq2Lo3NTa8PjtfaziWSlkta3tvrE+2YmY2URgsJ/lDST4BXRMQnym5A0lSSc2J8MCK2NhhuqPWPaBAfGoy4GrgaYPHixTXvY2ZmxTUcs4iIPcDMsg8uaSJJovhaRNychjdJOiz9/2HA5jS+DphfVXwesD6Nz6sRNzOzFskzwH2fpFslvVPS2yqXrELpjKVrgFUR8XdV/7oVuDi9fjFwS1X8QkkHpKdtXQjck3ZVbZO0JH3Md1WVMTOzFshznMVM4Bng9KpYADfXvvuLTgHeCTwoaWUa+x/Ap4GbJC0F1gIXAETEw5JuAh4hmUl1adqyAXgvcC0wiWRg24PbZmYtpIjx2bW/ePHiWL58+WhXw8ysrUhaERGLB8fzLPdxtKQ7JD2U3n6lpI81o5JmZjY25Rmz+CfgCmAXQEQ8QHLwnJmZ7SfyJIvJEXHPoNjuZlTGzMzGpjzJ4mlJv0Z6bIOk3yE9MtvMzPYPeWZDXUpyoNsxkp4CngDe3tRamZnZmJKZLCLiF8AZkqYAHRGxrfnVMjOzsSTPbKiDJV0J/Bi4S9LnJB3c/KqZmdlYkWfM4kagF/htkgUEe4GvN7NSZmY2tuQ6gjsi/rLq9v+UdH6T6mNmZmNQnpbFnZIulNSRXn4X+PdmV8zMzMaOPMniD4F/BfrTy43AH0vaJmlrMytnZmZjQ57ZUAe2oiJmZjZ25RmzQNK5wGnpzbsi4jvNq5KZmY01eabOfhq4jGTp8EeAy9KYmZntJ/K0LM4Bjo+IAQBJ1wH3AZc3s2JmZjZ25BngBphedf2gJtTDzMzGsDwti78iObXqnYBIxi6uaGqtzMxsTGmYLCR1AAPAEuBEkmTxkYjY2IK6mZnZGNEwWUTEgKT3RcRNwK0tqpOZmY0xecYsbpf0p5LmS5pZuTS9ZmZmNmbkGbN4T/r30qpYAEeNfHXMzGwsynME90taUREzMxu7MpOFpG7gj4BTSVoUPwauioi+JtfN2lx/fy99fWvo7l5AV9fs0a6OmQ1Dnm6o64FtwOfT2xcBXwUuaFalrP1t2nQDPT1LkbqI6GfRomuYM+ei0a6WmZWUJ1ksiohXVd2+U9L9zaqQtb/+/l56epYyMLAD2AFAT89SZsw4I1cLwy2S9uT3bXzLkyzuk7QkIpYBSPp14KfNrZa1s76+NUhdVBIFgDSRvr41mT8ibpG0J79v41+eqbO/DtwtaY2kNcDPgNdLelDSA02tnbWl7u4FRPTvE4vYRXf3goblqlske/Y8x8DADnp6ltLf39vE2tpw+X3bP+RpWZzd9FrYuNLVNZtFi65J9zQnErGLRYuuyWxVDKdFYqPH79v+Ic/U2V+2oiI2vsyZcxEHHHAEzz57GzNnnsn06adklinbIrHR5fdt/5B31VmzQh577P2sXHkqa9d+kpUrT+Wxx96fWaarazaHHrp0n9ihhy713ukYV2lJdnRMorNzGh0dk3K1JK29KCJGuw5NsXjx4li+fPloV2O/tH37Ku6997gh8RNPfIQpU46tW66/v5dly45MZ1ElOjomsWTJL/3D0wY8G2p8kLQiIhYPjrtlYSNu69Z7CsUr9vZ971Xp+7axr6trNtOmnehEMU45WdiImzbtpELxCvd9m41dThY24iZOnAV0Dop2pvH63PdtNnblmTpr+7mifdF9fWvo7JzKnj3PvRjr7JySayrlnDkXMWPGGe77NhtjmtaykPQVSZslPVQVmynpdkmPp39nVP3vCkmrJfVIOqsqfkJ6AOBqSVdKUrPqbENt2nQDy5Ydyf33/wbLlh3Jpk03ZJYZbneS+77Nxp5mdkNdy9AD+i4H7oiIhcAd6W0kHQdcCLwsLfNFSZV+jC8BlwAL04sPEmyRskfmujvJbPxpWjdURPxI0oJB4fOAN6TXrwPuAj6Sxm+MiJ3AE5JWAyely4tMi4ifAUi6Hjgf+F6z6m17DefI3NHoTvLUTbPmafWYxZyI2AAQERskHZLG5wLLqu63Lo3tSq8Pjtck6RKSVghHHHHECFZ7/zQS3Umt+tH2QnZmzTVWZkPVGoeIBvGaIuLqiFgcEYtnz/ae5XC1S3eSF7Iza75Wtyw2STosbVUcBmxO4+uA+VX3mwesT+PzasStRdphdpIXsjNrvla3LG4FLk6vXwzcUhW/UNIBkl5CMpB9T9pltU3SknQW1LuqyliLjPXZSd3dC/ZZIgRgYKDPB/OZjaCmtSwk3UAymD1L0jrgz4FPAzdJWgqsJT01a0Q8LOkm4BFgN3BpROxJH+q9JDOrJpEMbI+rwe3xPCi7ffsqtm69h2nTTmq4JtRIGLzG2Xhd88xstDRzNlS90cU31bn/p4BP1YgvB14+glUbM8bzoOxjj72f9eu/8OLtww9/H0cf/fkGJcpLDgKcPOggwEnuhjIbQWNlgHu/M54HZbdvX7VPogBYv/4LbN++qinb85pSZs3nZDFKxvMKq2VXnS3L58Ewaz4nixHS39/L1q335m4ZjOe94UmTXlooPlz9/b1s3HjNPrGNG68ZF600s7HCyWIElFk/qV2OYSijo6OLoR+tjjQ+8sZzK81srPCqs8NUPfZQmeff07OUGTPOaNqSGGN9BlVn51RgYFB0II2PvPHcSjMbK9yyGKbh7tUWPYahTCum1fbseR5p0j4xqZs9e55vyvbGcyvNbKxwy2KYhrtXW+RYhOG0YlopeU127xOL2NPUPf12ONLcrJ05WQxTZSZO9VTRvDNxih6L0F7LWuzOuD3yWrlwodn+xt1Qw1R2Jk6ZYxFGq2++6EyvX/3qToau9xhp3MzakZPFMJUdsyhzLMJo9M2XGSPZsWN1obiZjX3uhhqm7u4F7Nnzwj6xPXt2ZO7tT5t2UqF4RSv75suOkbT6OAszaz63LAYp2uUCMPi04HlOEz5lyrEcfvj79okdfvj7ci2416pVYMu2mg44oPb5qerFByvzHphZc7llUaXMwn7JD2on1YucSp25Bp2PPvrzzJ37Ry1bmbWosq2mRt1Q06ef0rDscBZXHOvHn5i1MyeLVNkul87OqTXOpbAj9wFoU6YcO+aSRDVJgxJhdqupbDfUcKYGV5JM0lgeyJ1kWp1gym5vy5af8uyztzFz5pmZCXe0tMtraeU4WaTKTkutHIAWUV2ueQegtVJf3xo6OiaxZ8/eGVgdHd2Zr0m9ZT2ylvvo61vD4NNQRETm9vr7e3n00XfvM1Ps0UffnZlkWr1EfNntrVx5Jlu23A7A2rWfZPr0Mzn++O83rZ5ltMtraeV5zCJVdlpqd/cCBu9sSxoXS02UfU22bl1eKF7R2Tl1n6SbbK8vs5W2bdt9NerZz7Zt99Ut0+ol4stub8uWn76YKPbGbmPLlp82pZ5ltMtracPjZJEqOy11PC81Ufa59fb+W6F4xZ49z9PRse8yIUnLZuRbaa1efLDs9p599rZC8dHQLq+lDY+7oarMmXMRU6ceX3jAec6cizjggCNa1qfcyr7aMlN1u7sX8txzQw/A6+5emFFuQaF4xYEHvprKWMVeHWm8/rZaeYBj2e3NnHkma9d+smZ8rGiX19KGxy2LKps23cCKFSewevVlrFhxQu5F+h577P2sXHkqa9d+kpUrT+Wxx97f1DqO9YUEDzvsXYXiFcM7idHQI8azttXKFmHZ7U2ffgqTJu17VuFJk14xpga52+W1tOHReD2x/eLFi2P58sZ95NX6+3tZtuzIfWY2dXRMYsmSXzb8EG7fvop77z1uSPzEEx8Z8VlOZes4HGUGEh9//HKeeuozQ+Jz536EhQs/Xbdc2ee3adNNrFr1e0Pixx77debM+d2GdR3rM3hG4z0va6y/lpaPpBURsXhw3C2LVPk+5R8Uig9Hq/tqyw4k9vZ+o1C8ouzz6+/fVCg+mooeUNlO/fOtOlh0tLa3v/OYRapsP2hX15xC8eEoe5BcWeVXud1VMJ4o+x4ceOBrCsUrNm26gUcffU96UOUejjnmK2Nu+qX7522scMsiVekHlbpfvOTpB5069RWF4sNXrG++WqvOEy5NLhSvKDtmsXPnU4XikLwWq1ZdTEQfAwPbiehj1aqLx9z0y+GN47SWl2kZ35wsqjz33N1E9L14ee65uzPL9PU9WSg+HMlxA0PPE9HoeIKKVp4nvLOzdoO1Xryiv7+XDRuu3ie2YcPVmT8+zz9/f6E4VF7LwS2dXbley1bq7+9l/fqr9omtX3/VmPtBboeJFzY8ThapMueXSMo9XCg+WJG9sd27txSKV2+j7EFMc+ZcxJIlv+RVr/oBS5b8Mlc3zaRJxxSKV5Q5uA6o+zwaPb+yr+VwlTs3yNAdhLF0bhAfJLd/cLJIlR2ofv75BwrFqxXdG5swYXqheEWyjMaefWIRe3IPku7a9TTbtz/Crl1P57p/2VVny/6Ad3TUbrHUi0P513I4yux9t8PgfTsNwlt5ThapgYHap/2sF6+IGCgUryizN3bgga+u8aXsanjwGcDAQH/NPfaBgf46JfZ67LH3c++9x9HT827uvfe4XMeQ7NjxRKH4cJU5mK+7e36h+GBFWwhl975nzjyjUHw0eBB+/+BkkRq8JlFWvGLXrtpf9nrxijJ7Y11dsznooNfvEzvooDdkjiFs2fLDQvGKsl1zL7zQUyg+XFu2/LhQHIa3tEiZFkK993U87H1XTw7p6JiSe3LI/mK8DPw7WaQGBvYUiu/9/wuF4hVl9sa2b19Vc1G5rB/vsjZu/JdC8YqBge2F4hU7d64rFK/YtWtLoTgkr//AwM5B9duZuTdctoVQdin74R7H08ofqsry9XmWsd9flB34L/u+NfP9drJI9fX9olC8YtKkowvFK8pMiSxz3m6A2bN/q1C8YvfuXxWKV+za9UyheMULL9Q+aVK9eIVU+2NcL5485mPsu5YUwEAar69s/3zSYhn8I6rMlkxE7WNT6sWrtWqGUnUCHRjY7gHuVNkdi7LvW7PfbyeL1IQJBxWKV5Tdi+7v72Xjxmv2iW3ceE3DD9LEiQcXiu/9/yxq/VAl8fqmTKl9rEi9eEVn55RC8YqursMKxfeq1/qr3ypcv/7LheIVZfvnkwHpocfIZA1U15sJlmeGWKtmKA13gHss7kWPxPbKdD2Wfd9a8X47WaQOOui1heIVzzxT+yQ09eIVfX1rhgyeDwzsavhBKjtw/PTTt1DrhyqJ11e2JTNxYu2j1+vFK/r6Hi8Ur9i+vfZYSL34cCRLTJy6T2zatNdl9s9v3XpvoXhF2bGOVs5QSrr0Bnex9eUa4N606Qbuvns+9933Ou6+e37hveiVK9/YkuM6ymyvTNdjoxOANdKK99vJIlX2SOyBgb5C8b3/72foQWG7G85QKtun/+yzdxSKv1ibklNZ9+zZVihe8fzzDxWKV5Rp3ZWdDVV23Gjy5NrdkvXiFdOm1V5dtl68otUzlGrNtsuSHEX/dmAnETuBnaxa9fZce9GPPvrufbq9Hn303U092VKZ7SVdjBMHRSc07HosewKwVrzfThaphx+uvXx2vfhe9X6QGndD7dhRux++Xhxg+/ZHCsUrnn669oly6sUrBu+pZMUrdu2qnbzqxSvKHFyXqDdjrf5MtrItwrKtrV27ni0UryjzOYHyLaAy6h0gmHXgYG9v7RZvEq+v7MGbZZXdXvIDP3SHsNEPf9lZeq1Ytt0LCaZeeKH2cub14sM1adJLC8UB+vs3F4rvVe8HqfEPVfmlTOodY9L42JPdu2snk3rx4diz57lC8Qqp9lemXryifKvwe4XiFY1aQHmWzt++fVXuk4A1Wm6l0RLxL7zwaKH4SCny3Iaj0fen3nbLngAMyp2orIi2aVlIOltSj6TVki5vwhYKxodnw4Z/LhSH1h+/sGvXxkLxdlL2yOjNm2ufGrZevKLsQDXUm4LdeGp22RYQFD8Qs6+vdsKrF68oO0tvOAdUljnIdLgHcBYxlk/s1BbJQlIn8I/Am4HjgIskDT3j0PC2UjA+PM88U3vPsF480VkwPjy7dtXey64XbycDA7Wb9fXiFTt3bigUr3rkgvHhKTtzrsyBmLt3126h1otXJGcB3HdMMM9ZAJ9//sFC8YqyB5mW7RpKVlYYPGYxMXPFhTLrsYGnzlacBKyOiF9E0nl4I3DeyG6itcmizDTRqVNfVSg+XBMmTCsUbyfSjELxiunT31goXlHvjJTZZ6qsNz6UNW5U7liXMi2Ssp+T/v5edu7cd+xl587VmWNUZcdxyh7gWLZrqKtrNscee90+R7Yfe+x1uVoJRU/s5Kmze80FqjsA16WxfUi6RNJySct7e4u9SGXPwVDWwQefVSgOMHVq7VVb68WHa/LkhYXi7WTatNoJtl68YubM0wvFKzo7a3+O6sUrpAMLxSumTTupUHw45comprLTPcuM90H5E5UNp2tozpyLOPnktRx//J2cfPLapp1cy1Nn96q1ez9klywiro6IxRGxePbsYn18hx/+B4XiFV1dLykUrzj00HcUigPMmfP2QvHhmj//A4Xie5XbG548ufaZ7erFK7q76w0W1h+8nD//skLxirKLOc6d+4eF4nvr80eF4hVTphzL4Ye/b5/Y4Ye/L3NAt0y5Qw99Z6F4RdnpnjNmvJGhc3MmpPGRLwflu4agNad/9dTZvdYB1aNJ84D1I7mBhQs/y9C+/840Xt9rX1t7OZB68YoyX8rp009h+vQzB8XOzOzjfcMband11ItXzJr11pp9yrNmvTVjezsLxStOOmlFoXjFkiW1pw7Xi0P559bVNZtjjrmWjo5JdHRMoaNjEsccc23mD0HZ7R111CcZmmS70nhjRx/9eU488REWLbqWE098hKOP/nxmmTLlDj307UycuO9g78SJ8zn00MY7MWX32JPunevT7p1JaffO9U0rV11+rJ7zuxUD48ruMx19SuYlPga8CXgKuBf4LxFR9wxDixcvjuXLi097ffzxP6G39xvMnv07mYmi2t13H0V//xN0db0kM1FUKzONb8uWn/Lss7cxc2Z2oqh21117G2hZiaLa009/h97ebzF79vmZP277bu8AoB/oykwU1e655wReeGElkycfn5koqi1bdhx9favo7j62YaKoVva59ff3lpqiWHZ7v/jFx9m8+esccsjv5UoUo2Hjxq+xefNNHHLI72YmimplX8tWl2sHI/HcJK2IiMVD4u2QLAAknQP8A8nu/1ci4lON7l82WZiZ7c/qJYu2OSgvIr4LfHe062Fmtj9qlzELMzMbRU4WZmaWycnCzMwyOVmYmVmmtpkNVZSkXuCXJYvPAp4e4+XaoY7tUq4d6tgu5dqhju1SrtV1rDgyIobOu40IXwZdgOVjvVw71LFdyrVDHdulXDvUsV3KtbqOWRd3Q5mZWSYnCzMzy+RkUdvVbVCuHerYLuXaoY7tUq4d6tgu5Vpdx4bG7QC3mZmNHLcszMwsk5OFmZllcrKoImm6pG9IelTSKkkn5ygzX9Kd6f0fllT37DmSviJps6SHqmIXpOUGJA1Z6bHO41wm6aG03Adzlhmy7bwkfSjd1kOSbpDUXfQxCm6vU9J9kr6T8/7dku6RdH9az0/kLLdI0sqqy9Z6r2ed9+4vJT2Qlr1N0uE5y82UdLukx9O/jc/lmpRZI+nBdFt1l1Nu9D5L+lNJIWlWnjKS3i+pJ31N/zrnc/ub9PvzgKRvSpqes9zxkpZVnp+kIafmq1PuLyQ9VfUenjOoTM3vZ573oM72vl61rTWSVuYo8ypJP0vfv29LGnK+2Qb1bPj70KBc5mezsGbMx23XC3Ad8F/T613A9BxlDgNek14/kOS8G8fVue9pwGuAh6pixwKLgLuAxTm293LgIWAyyarBPwAW5ig3ZNs5X5O5wBPApPT2TcC7m/w+/DHwr8B3ct5fwNT0+kTg58CSgtvsBDaSHJCU972bVnX9A8BVOcv9NXB5ev1y4DM56rcGmFX2fSY5edj3SQ5UnZWjjm9MP1sHpLcPyfnczgQmpNc/U+u51Sl3G/Dm9Po5wF05y/0F8KcNXo+a388870HWdwb4LPDxHHW8F3h9ev09wF8WqGfD34cG5TI/m0Uvblmk0mx/GnANQET0R8SWrHIRsSEi/iO9vg1YRY3zg6f//xHw7KDYqojoKVDVY4FlEfFCROwGfgj8Vo56Dtl2AROASUpOQjWZET5LYTVJ84C3AF/OWyYSz6c3J6aXojM33gT8Z0TUPOq/znu3termlFrbrPO6n0eyY0L69/yCda2rwfv898CHC9TxvcCnI2Jnep/NecpFxG3p5xJgGclZLfNsL4DKHvdB1PiMlfkMN/h+Zr4HjbYnScDvAjfkKLMI+FF6/Xbgt/PWM+v3oUG5zM9mUU4Wex0F9AL/nHaBfFnSlCIPIGkB8GqSPdtmeQg4TdLBkiaT7IXNzyhTWkQ8BfwtsBbYADwXEbc1a3skJ7j6MDBQpFDadbUS2AzcHhFF34MLGfTFz7ndT0l6Eng78PGcxeZExAZIvuzAITnKBHCbpBWSLilYx3OBpyLi/gLFjgZeJ+nnkn4o6cQi20y9B/hezvt+EPib9LX8W+CKAtt5X9rl8pVGXXqDvp9l3oNqrwM2RcTjOe77EHBuev0CMr6vZX9HBpcr+dmsy8lirwkkzccvRcSrge0kzdNcJE0F/g/wwUFZfURFxCqS5v3twP8F7gd2Nyw0DOmX7zzgJcDhwBRJ72jStt4KbI6I/OdSTUXEnog4nmRP9iRJLy+w3S6SL/O/ldjuRyNiPvA14H1Z9x+GUyLiNcCbgUslnZanULpD8VGK/1hMAGYAS4D/DtyU7k3nIumjJJ/Lr+Us8l7gQ+lr+SHSFn4OXwJ+DTieZGem5rmQm/D9vIj8OxfvIXnPVpB0FfXXu2PZetYqN9KfTSeLvdYB66r2SL9BkjwySZpI8kZ9LSJublL9XhQR10TEayLiNJImb569m7LOAJ6IiN6I2AXcDLw2T0FJl1YNBuYZYDsFOFfSGuBG4HRJ/1KksmnX4V3A2QWKvRn4j4jYVGRbg/wrNboX6tgk6TCA9O+QLp7BImJ9+ncz8E1gyABwHb9GkujvT1/XecB/SDo0o9w64Oa0i+8ekpberIwyAEi6GHgr8PZIO81zuJjkswVJ0s71/CJiU7qjMAD8U61ydb6fhd+DqsebALwN+HrOOj4aEWdGxAkkCeY/6zxuqd+RHOWKfDbrcrJIRcRG4ElJi9LQm4BHssqle1vXAKsi4u+aWMXqbR6S/j2C5ENbuPukgLXAEkmT0+f6JpJ+0UwR8Y8RcXx6yRzniIgrImJeRCwg6Rb6fxGR2YqRNFvprBtJk0gS3KN56pgqspdYvd2FVTfPLbDNW0l+HEn/3pKxnSmSDqxcJxlEzjWrLSIejIhDImJB+rquIxkQ3ZhR9FvA6ek2jyaZ8JG5kqmks4GPAOdGxAt56phaD7w+vX46OXeAKj/4qd9i0OvS4PtZ6D0Y5Azg0YhYl7OOle9rB/Ax4Koa9yn1O1Kv3DA+m/WVGRUfrxeSpuxy4AGSL8uMHGVOJelPfgBYmV7OqXPfG0iayrtIvrRLST7g64CdwCbg+zm2+WOSRHY/8Kacz23Itgu8Lp9IP2wPAV8lnSHT5PfiDeSfDfVK4L70PXiIQTNUMspOBp4BDir6+pHszT2UbvfbJAOLecodDNxB8oN4BzAzY9tHpe/1/cDDwEfLvs/UmFVVp45dwL+kz+8/gNNzPrfVwJNV34VaM8RqlTsVWJE+x58DJ+Qs91XgwfQ9uBU4LM/3M897UO+1BK4F/luBz8llJLOUHgM+TbpyRs56Nvx9aFAu87NZ9OLlPszMLJO7oczMLJOThZmZZXKyMDOzTE4WZmaWycnCzMwyOVmYjRBJH0hX/3xK0hdGuz5mI2nCaFfAbBz5I5KjwV8P5FpuvhFJE2Lvonxmo8otC7MRIOkqkoPnbiVZU6kSP1LSHelCd3ekR903il8r6e8k3UmyBpjZmOBkYTYCIuK/kSxZ8UbgV1X/+gJwfUS8kmRBtysz4pCs+HpGRPxJ0ytulpOThVlznUyykBskS1OcmhEH+LeI2NOa6pnl42Rh1lr11tepjm9vRUXMinCyMGuuu0lW0IXkJDQ/yYibjUmeDWXWXB8AviLpv5OcifH3M+JmY5JXnTUzs0zuhjIzs0xOFmZmlsnJwszMMjlZmJlZJicLMzPL5GRhZmaZnCzMzCzT/wfGIIfAuCg4qAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df1.plot(kind='scatter',x='floor',y='property tax (R$)',title='Belo Horizonte') # scatter plot\n", + "df2.plot(kind='scatter',x='floor',y='property tax (R$)',color='g',title='Campinas')\n", + "df3.plot(kind='scatter',x='floor',y='property tax (R$)',color='y',title='Porto Alegre')\n", + "df4.plot(kind='scatter',x='floor',y='property tax (R$)',color='r',title='Rio de Janeiro')\n", + "df5.plot(kind='scatter',x='floor',y='property tax (R$)',color='b',title='São Paulo')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b5a4aed", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 59dae13cce70f48d33623b8033ab6cc59152ee55 Mon Sep 17 00:00:00 2001 From: ambujpyne02 <104996993+ambujpyne02@users.noreply.github.com> Date: Mon, 23 May 2022 21:03:14 +0530 Subject: [PATCH 05/13] Add files via upload --- .../Assignment_2/210118_Ambuj Pyne_A2.ipynb | 880 ++++++++++++++++++ 1 file changed, 880 insertions(+) create mode 100644 Assignment/Assignment_2/210118_Ambuj Pyne_A2.ipynb diff --git a/Assignment/Assignment_2/210118_Ambuj Pyne_A2.ipynb b/Assignment/Assignment_2/210118_Ambuj Pyne_A2.ipynb new file mode 100644 index 0000000..06c2ddc --- /dev/null +++ b/Assignment/Assignment_2/210118_Ambuj Pyne_A2.ipynb @@ -0,0 +1,880 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Copy of 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", + " Implement heaviside step activation function here (google ;))\n", + " '''\n", + " z=self.bias + np.dot(x,self.weights.T)\n", + " #print(self.bias)\n", + " #print(x)\n", + " #print(self.weights)\n", + " if z>=0:\n", + " out=1\n", + " else:\n", + " out=0\n", + " \n", + " pass\n", + " return out\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", + " \n", + "\n", + " # YOUR CODE HERE\n", + " perc=perceptron(8)\n", + " out=perc.activation(x)\n", + " #print(out)\n", + " pass\n", + " return out\n", + " # YOUR CODE HERE" + ], + "execution_count": null, + "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": null, + "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", + " \n", + " # YOUR CODE HERE\n", + " y=self.bias + np.dot(x,self.weights)\n", + " return y\n", + " pass\n", + " # YOUR CODE HERE" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "zgzPxyTsr7uN", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "37b944c7-e850-4b7e-95cd-ccbb89253644" + }, + "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": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 1.30208164, 5.58136003, 0.87793013, -4.7332119 , 4.81172123]])" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "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", + " l=0.5*(y-z)\n", + " return l\n", + " pass" + ], + "execution_count": 3, + "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)**2\n", + " return l\n", + " pass" + ], + "execution_count": 4, + "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", + " y : True output. \n", + " z : Predicted output. \n", + " return : L\n", + " '''\n", + " l=max(0,1-y*z)\n", + " return l\n", + " pass" + ], + "execution_count": 5, + "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", + "import math\n", + "def CELoss(z,y):\n", + " '''\n", + " y : True output. \n", + " z : Predicted output. \n", + " return : L\n", + " '''\n", + " L=-1*(y*(math.log(z))+(1-y)*(math.log(1-z)))\n", + " pass" + ], + "execution_count": 6, + "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", + " '''\n", + " y : True output. \n", + " z : Predicted output. \n", + " return : L\n", + " '''\n", + " if z==y:\n", + " L=0\n", + " else:\n", + " L=1\n", + " return L\n", + " pass" + ], + "execution_count": 7, + "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 = loss_func(Z,Y)\n", + " # YOUR CODE HERE\n", + " pass" + ], + "execution_count": 8, + "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": "f8415c2f-6508-4248-ad3c-ad232de162da" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2.8.0\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "" + ], + "metadata": { + "id": "K78V7aoQ5zq-" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "yyplk5PLEUsJ", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "d35c4487-938c-490a-e72a-475528eb1137" + }, + "source": [ + "# 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": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n", + "170500096/170498071 [==============================] - 4s 0us/step\n", + "170508288/170498071 [==============================] - 4s 0us/step\n", + "(50000, 32, 32, 3) (50000, 1) (10000, 32, 32, 3) (10000, 1)\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "qQhkATYhEkkC" + }, + "source": [ + "'''visualize data by plotting images'''\n", + "# YOUR CODE HERE\n", + "pass\n", + "# YOUR CODE HERE" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "yJgho2AEBFbx", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "outputId": "5cc943a0-7cbf-45c0-b303-6452425a50bf" + }, + "source": [ + "\n", + "# number of classes\n", + "K = len(set(y_train))\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", + "\n", + "pass\n", + "# YOUR CODE HERE\n", + " \n", + "\"\"\"last hidden layer i.e.. output layer\"\"\"\n", + "# YOUR CODE HERE\n", + "cnn = tf.keras.models.Sequential([\n", + " tf.keras.layers.Conv2D(filters=32, kernel_size=(3, 3), activation='relu', input_shape=(32, 32, 3)),\n", + " tf.keras.layers.MaxPooling2D((2, 2)),\n", + " \n", + " tf.keras.layers.Conv2D(filters=64, kernel_size=(3, 3), activation='relu'),\n", + " tf.keras.layers.MaxPooling2D((2, 2)),\n", + " \n", + " tf.keras.layers.Flatten(),\n", + " tf.keras.layers.Dense(64, activation='relu'),\n", + " tf.keras.layers.Dense(10, activation='softmax')\n", + "])\n", + "pass\n", + "# YOUR CODE HERE\n", + " \n", + "'''model description'''\n", + "#model.summary()" + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "number of classes: 10\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'model description'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 13 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "PLc4Bay65TyA" + }, + "source": [ + "# Compile\n", + "'''\n", + " YOUR CODE HERE\n", + "'''\n", + "cnn.compile(optimizer='adam',\n", + " loss='sparse_categorical_crossentropy',\n", + " metrics=['accuracy'])" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Fit\n", + "'''\n", + " YOUR CODE HERE\n", + "'''\n", + "cnn.fit(x_train, y_train, epochs=10)" + ], + "metadata": { + "id": "U0fGsDCRsQrn", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "5a353e32-4b91-4589-aea5-5ccfcce9602f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/10\n", + "1563/1563 [==============================] - 65s 41ms/step - loss: 1.4197 - accuracy: 0.4908\n", + "Epoch 2/10\n", + "1563/1563 [==============================] - 62s 40ms/step - loss: 1.0716 - accuracy: 0.6250\n", + "Epoch 3/10\n", + "1563/1563 [==============================] - 62s 39ms/step - loss: 0.9442 - accuracy: 0.6705\n", + "Epoch 4/10\n", + "1563/1563 [==============================] - 62s 40ms/step - loss: 0.8580 - accuracy: 0.7029\n", + "Epoch 5/10\n", + "1563/1563 [==============================] - 63s 40ms/step - loss: 0.7863 - accuracy: 0.7278\n", + "Epoch 6/10\n", + "1563/1563 [==============================] - 62s 40ms/step - loss: 0.7250 - accuracy: 0.7476\n", + "Epoch 7/10\n", + "1563/1563 [==============================] - 62s 40ms/step - loss: 0.6728 - accuracy: 0.7655\n", + "Epoch 8/10\n", + "1563/1563 [==============================] - 62s 40ms/step - loss: 0.6263 - accuracy: 0.7801\n", + "Epoch 9/10\n", + "1563/1563 [==============================] - 62s 40ms/step - loss: 0.5787 - accuracy: 0.7982\n", + "Epoch 10/10\n", + "1563/1563 [==============================] - 62s 40ms/step - loss: 0.5395 - accuracy: 0.8112\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 13 + } + ] + }, + { + "cell_type": "code", + "source": [ + "cnn.evaluate(x_test,y_test)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xBzMwkct3anA", + "outputId": "7513c6eb-3140-4489-f8ce-bfbe7a6c8e30" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "313/313 [==============================] - 4s 12ms/step - loss: 0.9064 - accuracy: 0.7083\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[0.9063737392425537, 0.708299994468689]" + ] + }, + "metadata": {}, + "execution_count": 14 + } + ] + }, + { + "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", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 484 + }, + "outputId": "a82c54d2-062b-446b-d18d-c738d0dd3fd5" + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0;31m# pass in the network for prediction and\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0;31m# save the predicted label\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m \u001b[0mpredicted_label\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0;31m# load the original label\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'model' is not defined" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 166 + }, + "id": "d-K_7jXF51Tr", + "outputId": "05cd811a-78d8-41dd-867c-49525ff8ea3c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_test\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'cnn' is not defined" + ] + } + ] + } + ] +} \ No newline at end of file From 7b9726b9c9cd51e81d529a4c2163b9452158a1c0 Mon Sep 17 00:00:00 2001 From: ambujpyne02 <104996993+ambujpyne02@users.noreply.github.com> Date: Tue, 21 Jun 2022 12:36:43 +0530 Subject: [PATCH 06/13] Add files via upload --- Assignment/210118_Ambuj Pyne_A3.ipynb | 399 ++++++++++++++++++++++++++ 1 file changed, 399 insertions(+) create mode 100644 Assignment/210118_Ambuj Pyne_A3.ipynb diff --git a/Assignment/210118_Ambuj Pyne_A3.ipynb b/Assignment/210118_Ambuj Pyne_A3.ipynb new file mode 100644 index 0000000..0a9a048 --- /dev/null +++ b/Assignment/210118_Ambuj Pyne_A3.ipynb @@ -0,0 +1,399 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "MNIST classification using RNN.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "QY6mQDx63_ls" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import tensorflow.keras.layers as KL\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "source": [ + "#Loading MNIST dataset\n", + "(x_train,y_train),(x_test,y_test)=keras.datasets.mnist.load_data()" + ], + "metadata": { + "id": "IyF77Ns64TIc" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(len(x_train))\n", + "print(x_train.shape)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cBjIoHxN4ptL", + "outputId": "329bd834-8e46-43cc-9c4d-ae93de37828e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "60000\n", + "(60000, 28, 28)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "x_train=x_train/255\n", + "x_test=x_test/255\n", + "# This is known as scaling the values\n", + "# It helps in improving the accuracy while training the neural network" + ], + "metadata": { + "id": "H-Nn6crSBRqq" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model=keras.Sequential([\n", + " KL.LSTM(64, input_shape=(28,28)),\n", + " KL.Dense(10, activation=\"sigmoid\")\n", + "])\n", + "#Sequential accepts layers as elemments\n", + "#Dense means all the neurons here in one layer are connected to every other neuron in another layer \n", + "model.compile(\n", + " optimizer='adam',\n", + " loss='sparse_categorical_crossentropy',\n", + " metrics=['accuracy']\n", + ")\n", + "model.fit(x_train,y_train,epochs=10)\n", + "#this is supplying the training set\n", + "#epochs is the no. of iteraton our neural network is going to run the array" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qsrBbcJV3lqc", + "outputId": "6137e4de-db3d-47bf-b495-8e3eb64c9d47" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/10\n", + "1875/1875 [==============================] - 29s 15ms/step - loss: 0.6882 - accuracy: 0.7704\n", + "Epoch 2/10\n", + "1875/1875 [==============================] - 27s 14ms/step - loss: 0.3961 - accuracy: 0.8679\n", + "Epoch 3/10\n", + "1875/1875 [==============================] - 27s 15ms/step - loss: 0.3319 - accuracy: 0.8889\n", + "Epoch 4/10\n", + "1875/1875 [==============================] - 27s 14ms/step - loss: 0.3005 - accuracy: 0.9003\n", + "Epoch 5/10\n", + "1875/1875 [==============================] - 28s 15ms/step - loss: 0.2777 - accuracy: 0.9064\n", + "Epoch 6/10\n", + "1875/1875 [==============================] - 27s 14ms/step - loss: 0.2558 - accuracy: 0.9147\n", + "Epoch 7/10\n", + "1875/1875 [==============================] - 27s 14ms/step - loss: 0.2438 - accuracy: 0.9174\n", + "Epoch 8/10\n", + "1875/1875 [==============================] - 27s 15ms/step - loss: 0.2315 - accuracy: 0.9215\n", + "Epoch 9/10\n", + "1875/1875 [==============================] - 27s 14ms/step - loss: 0.2205 - accuracy: 0.9259\n", + "Epoch 10/10\n", + "1875/1875 [==============================] - 27s 14ms/step - loss: 0.2114 - accuracy: 0.9290\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 56 + } + ] + }, + { + "cell_type": "code", + "source": [ + "model.evaluate(x_test,y_test)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "wNaK1M4w2hMD", + "outputId": "a90859fd-d117-4d62-91b8-20c80aa9958e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "313/313 [==============================] - 3s 7ms/step - loss: 0.2407 - accuracy: 0.9214\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[0.2407352328300476, 0.9214000105857849]" + ] + }, + "metadata": {}, + "execution_count": 57 + } + ] + }, + { + "cell_type": "code", + "source": [ + "y_predicted=model.predict(x_test)\n", + "y_predicted[0]\n", + "## Y_predicted stores the probability that the neural network has predicted, with which the each given figure matches each of the valus from 0-9." + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "o75L9U2l5kOH", + "outputId": "be3ae9a9-03eb-467b-e792-4c1820ced2b8" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([4.6644823e-07, 2.0185764e-05, 3.4810280e-05, 1.1356701e-03,\n", + " 2.4589428e-05, 3.7091362e-04, 3.4589270e-08, 9.9485153e-01,\n", + " 1.4918595e-05, 3.5468936e-03], dtype=float32)" + ] + }, + "metadata": {}, + "execution_count": 32 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Now I will show how accurately the neural network will predict the handwritten number." + ], + "metadata": { + "id": "cDLCPSiA6jF0" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "\n", + "Test 1- " + ], + "metadata": { + "id": "-Pmi3FKT7Jt0" + } + }, + { + "cell_type": "code", + "source": [ + "for i in range (10):\n", + " plt.matshow(x_test[i])" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "PbgY9nzx5ubl", + "outputId": "cf1e31a0-57ec-4806-9976-e10887af18ac" + }, + "execution_count": null, + "outputs": [ + { + "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": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAECCAYAAAD+eGJTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAOdklEQVR4nO3df6zV9X3H8dcLvYAVVAiMMUqlUInVLkJ7Y+vmNo1r5/ijarK5ka3Dpg0uq5smJq0hS7Rpbczij27Z4oKVlCZqw/y91LVSaqN2BL04JghtcQ432RUk0IH7wY/re3/cL+utvfdzLvec8/0eeD8fCbnnfN/nfr9vv3hffL7f87mf44gQgLwmNd0AgGYRAkByhACQHCEAJEcIAMkRAkByjYSA7Stt/8j2q7ZvaaKHEtu7bG+1vcX2QA/0s8b2XtvbRmybaXu97Z3V1xk91t9ttndX53CL7WUN9jff9jO2t9t+xfaN1faeOIeF/mo5h657noDt0yT9WNLHJb0h6UVJyyNie62NFNjeJak/IvY13Ysk2f51SW9L+kZEfKja9heS9kfEHVWQzoiIL/RQf7dJejsi7myip5Fsz5U0NyJesj1d0mZJV0u6Tj1wDgv9XasazmETI4GLJb0aEa9FxBFJ35R0VQN9nDQi4llJ+9+1+SpJa6vHazX8P00jxuivZ0TEYES8VD0+JGmHpHnqkXNY6K8WTYTAPEn/PuL5G6rxP3icQtLTtjfbXtl0M2OYExGD1eM3Jc1pspkx3GD75epyobHLlZFsL5C0VNIm9eA5fFd/Ug3nkBuDo7s0Ij4s6bclfa4a7vasGL6m67X53/dKWiRpiaRBSXc1245ke5qkRyTdFBEHR9Z64RyO0l8t57CJENgtaf6I5++ttvWMiNhdfd0r6TENX8L0mj3VteTxa8q9DffzMyJiT0QMRcQ7ku5Tw+fQdp+Gf8AeiIhHq809cw5H66+uc9hECLwo6Tzb77c9WdLvS3qygT5GZfvM6uaMbJ8p6ROStpW/qxFPSlpRPV4h6YkGe/k5x3+4KteowXNo25Lul7QjIu4eUeqJczhWf3Wdw9rfHZCk6q2Or0o6TdKaiLi99ibGYHuhhv/1l6TTJT3YdH+2H5J0maRZkvZIulXS45LWSXqfpNclXRsRjdycG6O/yzQ8jA1JuyRdP+L6u+7+LpX0nKStkt6pNq/S8HV34+ew0N9y1XAOGwkBAL2DG4NAcoQAkBwhACRHCADJEQJAco2GQA9PyZVEf+3q5f56uTep3v6aHgn09F+E6K9dvdxfL/cm1dhf0yEAoGFtTRayfaWkv9TwzL+vRcQdpddP9pSYqjP///lRHVafpkz4+N1Gf+3p5f56uTep8/39r/5LR+KwR6tNOAQmsjjIWZ4ZH/UVEzoegInbFBt0MPaPGgLtXA6wOAhwCmgnBE6GxUEAtHB6tw9QvdWxUpKm6j3dPhyAE9TOSGBci4NExOqI6I+I/l6+EQNk1U4I9PTiIADGZ8KXAxFxzPYNkr6jny4O8krHOgNQi7buCUTEU5Ke6lAvABrAjEEgOUIASI4QAJIjBIDkCAEgOUIASI4QAJIjBIDkCAEgOUIASI4QAJIjBIDkCAEgOUIASK7ry4uhc3Z9+ZJifWhqeeXo2Re+VaxvvOiRE+5ppEXf+3SxPv2FM4r1OX/1j20dHxPDSABIjhAAkiMEgOQIASA5QgBIjhAAkiMEgOSYJ9BDDnzrvGJ925K/7urxj078U+olST+8/GvF+gP9c4v1det/o1gf2rHzhHtCa4wEgOQIASA5QgBIjhAAkiMEgOQIASA5QgBIjnkCNWo1D+AHS77Z1eP/7U8WFut3b/x4sb7g3PJ6BE9f8Gix/gfTB4v126+bVawv/ALzBLqhrRCwvUvSIUlDko5FRH8nmgJQn06MBC6PiH0d2A+ABnBPAEiu3RAISU/b3mx7ZScaAlCvdi8HLo2I3bZ/QdJ62z+MiGdHvqAKh5WSNFXvafNwADqtrZFAROyuvu6V9Jiki0d5zeqI6I+I/j5NaedwALpgwiFg+0zb048/lvQJSds61RiAerRzOTBH0mO2j+/nwYj4dke6Okkdu+Ijxfr3LvqbFnvoK1a/emBxsf7M77V4h/Y/9hbLiw8MFOuTpk4t1r+y6ZeL9VWzthbrx2YcK9bRHRMOgYh4TdJFHewFQAN4ixBIjhAAkiMEgOQIASA5QgBIjhAAkmM9gQ56e97kYn1Si8xtNQ/g+58svw8/9NqPivV2vfrFpcX6gzPvarGH8ozR936bf5OawFkHkiMEgOQIASA5QgBIjhAAkiMEgOQIASA55gl00Dnf2Fis/87AHxbrPnCwWD82uOsEO+qszy77brE+bRIrR52MGAkAyRECQHKEAJAcIQAkRwgAyRECQHKEAJAc8wRqNLT9x023ULTr9kuK9c+cc2eLPZQ/l+DmwY8V69O/u6NYH2pxdEwMIwEgOUIASI4QAJIjBIDkCAEgOUIASI4QAJJjnkAiP/lUeR7AD/6oPA/g7EnleQAbD59WrG/5cvlzC844+EKxju5oORKwvcb2XtvbRmybaXu97Z3V1xndbRNAt4zncuDrkq5817ZbJG2IiPMkbaieAzgJtQyBiHhW0v53bb5K0trq8VpJV3e4LwA1meiNwTkRMVg9flPSnA71A6Bmbb87EBEhKcaq215pe8D2wFEdbvdwADpsoiGwx/ZcSaq+7h3rhRGxOiL6I6K/r8Wn0gKo30RD4ElJK6rHKyQ90Zl2ANSt5TwB2w9JukzSLNtvSLpV0h2S1tn+jKTXJV3bzSbRGfs+POZVm6TW8wBaWfH9zxbrix9nHkAvahkCEbF8jNIVHe4FQAOYNgwkRwgAyRECQHKEAJAcIQAkRwgAybGewCnkyPpzi/WN59/VYg/leQIXbVxRrH/w5n8p1vncgN7ESABIjhAAkiMEgOQIASA5QgBIjhAAkiMEgOSYJ3ASOX3hgmL9Sx/4u2J9Rov1Aja3WP3t3C+V3+kfOnCgvAP0JEYCQHKEAJAcIQAkRwgAyRECQHKEAJAcIQAkxzyBk8iidbuL9aWT28v05Rv+uFhf/M8vtrV/9CZGAkByhACQHCEAJEcIAMkRAkByhACQHCEAJMc8gR5yYMUlxfoX57T63IApxeqKXb9ZrH/w868W63xuwKmp5UjA9hrbe21vG7HtNtu7bW+p/izrbpsAumU8lwNfl3TlKNvviYgl1Z+nOtsWgLq0DIGIeFbS/hp6AdCAdm4M3mD75epyYUbHOgJQq4mGwL2SFklaImlQ0ph3rGyvtD1ge+CoWqxkCaB2EwqBiNgTEUMR8Y6k+yRdXHjt6ojoj4j+vhZ3rwHUb0IhYHvuiKfXSNo21msB9LaW8wRsPyTpMkmzbL8h6VZJl9leIikk7ZJ0fRd7PGWcPu+XivVf+7NNxfq0Se2NpDZu/0CxvvgA6wVk1DIEImL5KJvv70IvABrAtGEgOUIASI4QAJIjBIDkCAEgOUIASI71BGq0Y9X8Yv3xX/z7tvZ/+dbfLdZZLwCjYSQAJEcIAMkRAkByhACQHCEAJEcIAMkRAkByzBOo0eZP3tPiFe2tF3D2n7xTrB87cKCt/ePUxEgASI4QAJIjBIDkCAEgOUIASI4QAJIjBIDkmCdwCjk65+xive/IvJo6Gd3QW/uK9Thc/pg6TynPozht9qwT7mmkodnnFOs7b57c1v5biSEX6+f/aYv1IA4enNBxGQkAyRECQHKEAJAcIQAkRwgAyRECQHKEAJAc8wROId96eE3TLRT9yj+N9in3P7Vvz1nF+ozZh4r1TR958IR7Oplc8Oc3FOsLP79xQvttORKwPd/2M7a3237F9o3V9pm219veWX2dMaEOADRqPJcDxyTdHBEXSPqYpM/ZvkDSLZI2RMR5kjZUzwGcZFqGQEQMRsRL1eNDknZImifpKklrq5etlXR1t5oE0D0ndGPQ9gJJSyVtkjQnIgar0puS5nS0MwC1GHcI2J4m6RFJN0XEz/ymQkSEpBjj+1baHrA9cFTlXxABUL9xhYDtPg0HwAMR8Wi1eY/tuVV9rqS9o31vRKyOiP6I6O9rczVdAJ03nncHLOl+STsi4u4RpSclrager5D0ROfbA9BtHh7JF15gXyrpOUlbJR1f2H6Vhu8LrJP0PkmvS7o2IvaX9nWWZ8ZHfUW7PZ+0/uc77y/WN3zo4Zo6yem/40ixfjTKn9vQyrKXryvW/3NLe+sdzH3+WLE+5R9eHLO2KTboYOwfdcGClpOFIuJ5SWOtdpD3Jxo4RTBtGEiOEACSIwSA5AgBIDlCAEiOEACSYz2BGp3xW/9arF/4lfLvi0eX/7amn1+c5tH139e/8LlPF+vxb2e2tf+FD79dfsELW9va/wztbKveFEYCQHKEAJAcIQAkRwgAyRECQHKEAJAcIQAk13I9gU7Kvp4A0JTSegKMBIDkCAEgOUIASI4QAJIjBIDkCAEgOUIASI4QAJIjBIDkCAEgOUIASI4QAJIjBIDkCAEgOUIASK5lCNieb/sZ29ttv2L7xmr7bbZ3295S/VnW/XYBdNp4Ps7imKSbI+Il29Mlbba9vqrdExF3dq89AN3WMgQiYlDSYPX4kO0dkuZ1uzEA9TihewK2F0haKmlTtekG2y/bXmN7Rod7A1CDcYeA7WmSHpF0U0QclHSvpEWSlmh4pHDXGN+30vaA7YGjOtyBlgF00rhCwHafhgPggYh4VJIiYk9EDEXEO5Luk3TxaN8bEasjoj8i+vs0pVN9A+iQ8bw7YEn3S9oREXeP2D53xMuukbSt8+0B6LbxvDvwq5I+JWmr7S3VtlWSltteIikk7ZJ0fVc6BNBV43l34HlJo61X/lTn2wFQN2YMAskRAkByhACQHCEAJEcIAMkRAkByhACQHCEAJEcIAMkRAkByhACQHCEAJEcIAMkRAkByhACQnCOivoPZb0l6fcSmWZL21dbAiaO/9vRyf73cm9T5/s6NiNmjFWoNgZ87uD0QEf2NNdAC/bWnl/vr5d6kevvjcgBIjhAAkms6BFY3fPxW6K89vdxfL/cm1dhfo/cEADSv6ZEAgIYRAkByhACQHCEAJEcIAMn9H3Z2+kt0r5nJAAAAAElFTkSuQmCC\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" + } + }, + { + "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": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAECCAYAAAD+eGJTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAO0klEQVR4nO3dfZCV9XnG8esSF62IUxCD1GpoiDZRk0DdqNM4hg5Tq7GOko4mNGNJ44idhkanxtH6R/UfZ7TjSzKdlAkqCTpqQ4svpOOkEiYtcRI3wZciQiLRYJWuIMUGfAGBvfvHPrar2f2dZc85zzlwfz8zzJ59rvNy8wAXz3POb89xRAhAXod0egAAnUUJAMlRAkBylACQHCUAJEcJAMl1pARsn2v757Z/Yfu6TsxQYnuT7WdtP2N7TRfMs8T2VtvrhmybbHul7Y3V10ldNt+NtjdX+/AZ25/p4HzH2/6B7fW2n7N9ZbW9K/ZhYb5a9qHrXidge5yk5yX9oaRXJP1U0ryIWF/rIAW2N0nqjYhtnZ5FkmyfLekNSfdExKnVtr+TtD0ibq6KdFJEXNtF890o6Y2IuLUTMw1le5qkaRHxlO2Jkp6UdJGkL6oL9mFhvktUwz7sxJHA6ZJ+EREvRsQ7kv5R0oUdmOOAERGrJW1/3+YLJS2tLi/V4F+ajhhhvq4REf0R8VR1eaekDZKOU5fsw8J8tehECRwn6eUh37+iGn/DoxSSHrP9pO0FnR5mBFMjor+6/KqkqZ0cZgQLba+tThc6droylO3pkmZJ6lMX7sP3zSfVsA95YnB4Z0XE70k6T9KXq8PdrhWD53Tdtv57kaQZkmZK6pd0W2fHkWwfKWm5pKsiYsfQrBv24TDz1bIPO1ECmyUdP+T73662dY2I2Fx93SrpIQ2ewnSbLdW55LvnlFs7PM97RMSWiNgXEQOS7lSH96HtHg3+A7svIh6sNnfNPhxuvrr2YSdK4KeSTrT9O7bHS/q8pBUdmGNYtidUT87I9gRJ50haV75VR6yQNL+6PF/SIx2c5de8+4+rMlcd3Ie2LeluSRsi4vYhUVfsw5Hmq2sf1v7qgCRVL3V8TdI4SUsi4qbahxiB7Q9p8H9/STpU0v2dns/2A5JmS5oiaYukGyQ9LGmZpBMkvSTpkojoyJNzI8w3W4OHsSFpk6Qrhpx/1z3fWZJ+KOlZSQPV5us1eN7d8X1YmG+eatiHHSkBAN2DJwaB5CgBIDlKAEiOEgCSowSA5DpaAl28JFcS8zWrm+fr5tmkeufr9JFAV/9BiPma1c3zdfNsUo3zdboEAHRYU4uFbJ8r6esaXPl3V0TcXLr+eB8Wh2vC/32/R7vVo8PG/PjtxnzN6eb5unk2qfXz7dKbeid2e7hszCUwljcHOcqT4wzPGdPjARi7vlilHbF92BJo5nSANwcBDgLNlMCB8OYgABo4tN0PUL3UsUCSDtcR7X44APupmSOBUb05SEQsjojeiOjt5idigKyaKYGufnMQAKMz5tOBiNhre6Gkf9X/vznIcy2bDEAtmnpOICIelfRoi2YB0AGsGASSowSA5CgBIDlKAEiOEgCSowSA5CgBIDlKAEiOEgCSowSA5CgBIDlKAEiOEgCSowSA5CgBIDlKAEiOEgCSowSA5CgBIDlKAEiOEgCSowSA5CgBIDlKAEiOEgCSowSA5CgBIDlKAEiOEgCSowSA5CgBILlDm7mx7U2SdkraJ2lvRPS2YigA9WmqBCp/EBHbWnA/ADqA0wEguWZLICQ9ZvtJ2wtaMRCAejV7OnBWRGy2/QFJK23/LCJWD71CVQ4LJOlwHdHkwwFotaaOBCJic/V1q6SHJJ0+zHUWR0RvRPT26LBmHg5AG4y5BGxPsD3x3cuSzpG0rlWDAahHM6cDUyU9ZPvd+7k/Ir7XkqkwJuOmHF3Mf37HCcV89okbi/nmT+8p5rF7dzFHdxpzCUTEi5I+0cJZAHQALxECyVECQHKUAJAcJQAkRwkAyVECQHKt+ClC1GTrwt8v5jdceU8xP/+Ix5p6/IumXFDM927+r6buH53BkQCQHCUAJEcJAMlRAkBylACQHCUAJEcJAMmxTqCLjDtpRjG/6+qvFfOZ48t/nAP7PdF79S+aWMynXXFsMd/b/2qTE6AdOBIAkqMEgOQoASA5SgBIjhIAkqMEgOQoASA51gl0kQ3XTSrmHx8/rqZJhtd32v3F/Pkfv1PMP3vvXxfzD930dDEf2LWrmGNsOBIAkqMEgOQoASA5SgBIjhIAkqMEgOQoASA51gnUaNzJJxXz788pv1+A9BvF9Jb//mgxX/M/JxTz78z4XoPHLzupZ3wxv/MLi4r5LUsuLOYDv3xpv2dCYw2PBGwvsb3V9roh2ybbXml7Y/W1vMoFQNcazenAtyWd+75t10laFREnSlpVfQ/gANSwBCJitaTt79t8oaSl1eWlki5q8VwAajLWJwanRkR/dflVSVNbNA+AmjX96kBEhKQYKbe9wPYa22v2aHezDwegxcZaAltsT5Ok6uvWka4YEYsjojcient02BgfDkC7jLUEVkiaX12eL+mR1owDoG4N1wnYfkDSbElTbL8i6QZJN0taZvsySS9JuqSdQx4stp1+dDGffugRxXzBy2cX81fOfKOYHzLhrWJ+2l/8VTH/6uXLivkXJo54QChJOvvwYqzvLv/PYr7+fD7XoB0alkBEzBshmtPiWQB0AMuGgeQoASA5SgBIjhIAkqMEgOQoASA53k+gRvsaLJgcGHn1tSRp7Tc/Vswn68fl+3/zzWI+7bYfFfNlF3yymM+b+C/FXDFQjLfsnli++S6WnbcDRwJAcpQAkBwlACRHCQDJUQJAcpQAkBwlACTHOoEaTfyT/sZXKvjVH5Vf55/8rabuvqG//eCKBtdo7v+UHz79kWJ+0us/aer+MTyOBIDkKAEgOUoASI4SAJKjBIDkKAEgOUoASI51AjXauXxa+QqnlOMvntxXzFd/8vRi/tqsI4t5/PH7P3f2vU7tKb9Ov2HPnmJ+Ss/4Yv7QeX9fzK898/JirifWlnMMiyMBIDlKAEiOEgCSowSA5CgBIDlKAEiOEgCSY51AjY5d8cti/vzfvFPMrzl6fTG/9uENxbzR5xo08rkXzi/mb3/lmGI+94F/K+Z/ftTLxfyFr5T/z5rxRDHGCBoeCdheYnur7XVDtt1oe7PtZ6pfn2nvmADaZTSnA9+WdO4w2++IiJnVr0dbOxaAujQsgYhYLam8nhTAAauZJwYX2l5bnS5MatlEAGo11hJYJGmGpJmS+iXdNtIVbS+wvcb2mj3iAyWBbjOmEoiILRGxLyIGJN0pacQfX4uIxRHRGxG9PWrwsbwAajemErA99Gdi50paN9J1AXQ3R5RfO7b9gKTZkqZI2iLphur7mZJC0iZJV0REwzfVP8qT4wzPaWrgg9kbF59RzL916+3F/KSeCcV8XwwU8w8/Vv55/Y8s/FkxH3iz/LkIG79R/v1tvGhRMX/4zd8s5nddXF7HMPAf5XUUB7O+WKUdsd3DZQ0XC0XEvGE23930VAC6AsuGgeQoASA5SgBIjhIAkqMEgOQoASC5husEWol1As1ptI5g+yVvFfNdvyqv2PzoNS8U832vv17MGzlk4sRi/vbyo4v5ylOWF/NZfX9WzI/77HPF/GBWWifAkQCQHCUAJEcJAMlRAkBylACQHCUAJEcJAMnxuQMHkCP/qa9B3tz972vu5g0N7NxZzHc8dGr5Dk4px7d8vLyO4B+mzS7me/tfLT/AQYojASA5SgBIjhIAkqMEgOQoASA5SgBIjhIAkmOdALrGMd/8STE/47w/LeZ9p91fzK/86vRiPuNq1gkASIgSAJKjBIDkKAEgOUoASI4SAJKjBIDkWCeA7jFQfkeDo287ophvu/ftYr7h898o5hfcX/7cgnjy4PzcgoZHAraPt/0D2+ttP2f7ymr7ZNsrbW+svk5q/7gAWm00pwN7JV0dESdLOlPSl22fLOk6Sasi4kRJq6rvARxgGpZARPRHxFPV5Z2SNkg6TtKFkpZWV1sq6aJ2DQmgffbriUHb0yXNktQnaWpE9FfRq5KmtnQyALUYdQnYPlLScklXRcSOoVkMfqrpsJ9sanuB7TW21+zR7qaGBdB6oyoB2z0aLID7IuLBavMW29OqfJqkrcPdNiIWR0RvRPT2qPypuADqN5pXByzpbkkbIuL2IdEKSfOry/MlPdL68QC022jWCXxK0qWSnrX9TLXtekk3S1pm+zJJL0m6pD0jAoMO+feni/nspdcU8/VfKq8T2HlTeZ3BURdPLOaNPlehWzUsgYh4XJJHiOe0dhwAdWPZMJAcJQAkRwkAyVECQHKUAJAcJQAkx/sJ4KDx4cUvF/N7Lz62mK/+2D8X83M/8aVifsjjzxTzbsWRAJAcJQAkRwkAyVECQHKUAJAcJQAkRwkAybFOAAeNvS+/UsyXzf10Mb/0+98p5tuu2VXMP/B4Me5aHAkAyVECQHKUAJAcJQAkRwkAyVECQHKUAJAc6wSQxr4NG4v55148p5h/d9ZdxfyyM/+yPMATa8t5h3AkACRHCQDJUQJAcpQAkBwlACRHCQDJUQJAcg3XCdg+XtI9kqZKCkmLI+Lrtm+UdLmk16qrXh8Rj7ZrUKDd3pobxbzvR79VzF//3QnFfNIT+z1SLUazWGivpKsj4inbEyU9aXtlld0REbe2bzwA7dawBCKiX1J/dXmn7Q2Sjmv3YADqsV/PCdieLmmWpL5q00Lba20vsT2pxbMBqMGoS8D2kZKWS7oqInZIWiRphqSZGjxSuG2E2y2wvcb2mj3a3YKRAbTSqErAdo8GC+C+iHhQkiJiS0Tsi4gBSXdKOn2420bE4ojojYjeHh3WqrkBtEjDErBtSXdL2hARtw/ZPm3I1eZKWtf68QC022heHfiUpEslPWv73c9evl7SPNszNfiy4SZJV7RlQgBt5Yjya6OtdJQnxxmeU9vjARjUF6u0I7Z7uIwVg0BylACQHCUAJEcJAMlRAkBylACQHCUAJEcJAMlRAkBylACQHCUAJEcJAMlRAkBylACQHCUAJFfr+wnYfk3SS0M2TZG0rbYB9h/zNaeb5+vm2aTWz/fBiDhmuKDWEvi1B7fXRERvxwZogPma083zdfNsUr3zcToAJEcJAMl1ugQWd/jxG2G+5nTzfN08m1TjfB19TgBA53X6SABAh1ECQHKUAJAcJQAkRwkAyf0v4xQrCdJsLsoAAAAASUVORK5CYII=\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": [ + "y_predicted_labels=[np.argmax(i) for i in y_predicted]\n", + "y_predicted_labels[:10]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rtHOuzWM68HG", + "outputId": "2a41853d-aa6c-4027-9c36-21a0e37a0034" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[7, 2, 1, 0, 4, 1, 4, 9, 6, 9]" + ] + }, + "metadata": {}, + "execution_count": 59 + } + ] + } + ] +} \ No newline at end of file From 7bd76832f3483c4a40add7339332ddcba4914286 Mon Sep 17 00:00:00 2001 From: ambujpyne02 <104996993+ambujpyne02@users.noreply.github.com> Date: Tue, 21 Jun 2022 12:50:57 +0530 Subject: [PATCH 07/13] Create 210118 --- Assignment/Assignment 3/210118 | 1 + 1 file changed, 1 insertion(+) create mode 100644 Assignment/Assignment 3/210118 diff --git a/Assignment/Assignment 3/210118 b/Assignment/Assignment 3/210118 new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/Assignment/Assignment 3/210118 @@ -0,0 +1 @@ + From 9a538bfec40ca0966869ad6072a7dd496671f8aa Mon Sep 17 00:00:00 2001 From: ambujpyne02 <104996993+ambujpyne02@users.noreply.github.com> Date: Tue, 21 Jun 2022 12:53:05 +0530 Subject: [PATCH 08/13] Delete Assignment/Assignment 3 directory --- Assignment/Assignment 3/210118 | 1 - 1 file changed, 1 deletion(-) delete mode 100644 Assignment/Assignment 3/210118 diff --git a/Assignment/Assignment 3/210118 b/Assignment/Assignment 3/210118 deleted file mode 100644 index 8b13789..0000000 --- a/Assignment/Assignment 3/210118 +++ /dev/null @@ -1 +0,0 @@ - From d0bc68fbc3c71733a9a5a8b1d85d6d71a172d48d Mon Sep 17 00:00:00 2001 From: ambujpyne02 <104996993+ambujpyne02@users.noreply.github.com> Date: Tue, 21 Jun 2022 12:53:20 +0530 Subject: [PATCH 09/13] Delete 210118_Ambuj Pyne_A3.ipynb --- Assignment/210118_Ambuj Pyne_A3.ipynb | 399 -------------------------- 1 file changed, 399 deletions(-) delete mode 100644 Assignment/210118_Ambuj Pyne_A3.ipynb diff --git a/Assignment/210118_Ambuj Pyne_A3.ipynb b/Assignment/210118_Ambuj Pyne_A3.ipynb deleted file mode 100644 index 0a9a048..0000000 --- a/Assignment/210118_Ambuj Pyne_A3.ipynb +++ /dev/null @@ -1,399 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "MNIST classification using RNN.ipynb", - "provenance": [], - "collapsed_sections": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "QY6mQDx63_ls" - }, - "outputs": [], - "source": [ - "import tensorflow as tf\n", - "import tensorflow.keras.layers as KL\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np" - ] - }, - { - "cell_type": "code", - "source": [ - "#Loading MNIST dataset\n", - "(x_train,y_train),(x_test,y_test)=keras.datasets.mnist.load_data()" - ], - "metadata": { - "id": "IyF77Ns64TIc" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "print(len(x_train))\n", - "print(x_train.shape)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cBjIoHxN4ptL", - "outputId": "329bd834-8e46-43cc-9c4d-ae93de37828e" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "60000\n", - "(60000, 28, 28)\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "x_train=x_train/255\n", - "x_test=x_test/255\n", - "# This is known as scaling the values\n", - "# It helps in improving the accuracy while training the neural network" - ], - "metadata": { - "id": "H-Nn6crSBRqq" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "model=keras.Sequential([\n", - " KL.LSTM(64, input_shape=(28,28)),\n", - " KL.Dense(10, activation=\"sigmoid\")\n", - "])\n", - "#Sequential accepts layers as elemments\n", - "#Dense means all the neurons here in one layer are connected to every other neuron in another layer \n", - "model.compile(\n", - " optimizer='adam',\n", - " loss='sparse_categorical_crossentropy',\n", - " metrics=['accuracy']\n", - ")\n", - "model.fit(x_train,y_train,epochs=10)\n", - "#this is supplying the training set\n", - "#epochs is the no. of iteraton our neural network is going to run the array" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "qsrBbcJV3lqc", - "outputId": "6137e4de-db3d-47bf-b495-8e3eb64c9d47" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Epoch 1/10\n", - "1875/1875 [==============================] - 29s 15ms/step - loss: 0.6882 - accuracy: 0.7704\n", - "Epoch 2/10\n", - "1875/1875 [==============================] - 27s 14ms/step - loss: 0.3961 - accuracy: 0.8679\n", - "Epoch 3/10\n", - "1875/1875 [==============================] - 27s 15ms/step - loss: 0.3319 - accuracy: 0.8889\n", - "Epoch 4/10\n", - "1875/1875 [==============================] - 27s 14ms/step - loss: 0.3005 - accuracy: 0.9003\n", - "Epoch 5/10\n", - "1875/1875 [==============================] - 28s 15ms/step - loss: 0.2777 - accuracy: 0.9064\n", - "Epoch 6/10\n", - "1875/1875 [==============================] - 27s 14ms/step - loss: 0.2558 - accuracy: 0.9147\n", - "Epoch 7/10\n", - "1875/1875 [==============================] - 27s 14ms/step - loss: 0.2438 - accuracy: 0.9174\n", - "Epoch 8/10\n", - "1875/1875 [==============================] - 27s 15ms/step - loss: 0.2315 - accuracy: 0.9215\n", - "Epoch 9/10\n", - "1875/1875 [==============================] - 27s 14ms/step - loss: 0.2205 - accuracy: 0.9259\n", - "Epoch 10/10\n", - "1875/1875 [==============================] - 27s 14ms/step - loss: 0.2114 - accuracy: 0.9290\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "execution_count": 56 - } - ] - }, - { - "cell_type": "code", - "source": [ - "model.evaluate(x_test,y_test)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "wNaK1M4w2hMD", - "outputId": "a90859fd-d117-4d62-91b8-20c80aa9958e" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "313/313 [==============================] - 3s 7ms/step - loss: 0.2407 - accuracy: 0.9214\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "[0.2407352328300476, 0.9214000105857849]" - ] - }, - "metadata": {}, - "execution_count": 57 - } - ] - }, - { - "cell_type": "code", - "source": [ - "y_predicted=model.predict(x_test)\n", - "y_predicted[0]\n", - "## Y_predicted stores the probability that the neural network has predicted, with which the each given figure matches each of the valus from 0-9." - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "o75L9U2l5kOH", - "outputId": "be3ae9a9-03eb-467b-e792-4c1820ced2b8" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "array([4.6644823e-07, 2.0185764e-05, 3.4810280e-05, 1.1356701e-03,\n", - " 2.4589428e-05, 3.7091362e-04, 3.4589270e-08, 9.9485153e-01,\n", - " 1.4918595e-05, 3.5468936e-03], dtype=float32)" - ] - }, - "metadata": {}, - "execution_count": 32 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "Now I will show how accurately the neural network will predict the handwritten number." - ], - "metadata": { - "id": "cDLCPSiA6jF0" - } - }, - { - "cell_type": "markdown", - "source": [ - "\n", - "\n", - "\n", - "Test 1- " - ], - "metadata": { - "id": "-Pmi3FKT7Jt0" - } - }, - { - "cell_type": "code", - "source": [ - "for i in range (10):\n", - " plt.matshow(x_test[i])" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "PbgY9nzx5ubl", - "outputId": "cf1e31a0-57ec-4806-9976-e10887af18ac" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAECCAYAAAD+eGJTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAOGElEQVR4nO3df6xf9V3H8ddr7e1lvS2uHaPWUqhjbJHNUcwdbAFNF2SyLaSQbbgmNjWZK1FIwCwqIVlook4k/BCdkhSp6xZgwxWEbHWuaaZIxI7SFFpaFMSirZdeoNOWAf359o97ild27+d7e7/f7znf2/fzkTTf7/e8z/ecd09vX/dzzvdzz3VECEBe72i6AQDNIgSA5AgBIDlCAEiOEACSIwSA5BoJAduX2f4X28/bvqGJHkps77K9zfZW25t7oJ81todtbx+1bK7tDbafqx7n9Fh/q2zvqY7hVtufarC/hbZ/YHuH7WdsX1ct74ljWOivlmPouucJ2J4m6V8lXSppt6QnJC2LiB21NlJge5ekwYh4peleJMn2L0l6TdLXI+JD1bJbJO2LiJurIJ0TEb/XQ/2tkvRaRNzaRE+j2Z4vaX5EbLE9W9KTkq6Q9OvqgWNY6O8q1XAMmxgJXCDp+Yh4ISIOSfqmpKUN9DFlRMSjkva9bfFSSWur52s18kXTiHH66xkRMRQRW6rnByTtlLRAPXIMC/3VookQWCDpP0e93q0a/8ITFJK+b/tJ2yubbmYc8yJiqHr+kqR5TTYzjmttP12dLjR2ujKa7UWSzpe0ST14DN/Wn1TDMeTC4NgujohfkPRJSddUw92eFSPndL02//suSWdLWixpSNJtzbYj2Z4laZ2k6yNi/+haLxzDMfqr5Rg2EQJ7JC0c9fqMalnPiIg91eOwpIc0cgrTa/ZW55LHzymHG+7n/4mIvRFxNCKOSbpbDR9D230a+Q92b0Q8WC3umWM4Vn91HcMmQuAJSefY/lnbMyR9XtIjDfQxJtsD1cUZ2R6Q9AlJ28vvasQjklZUz1dIerjBXn7C8f9clSvV4DG0bUn3SNoZEbePKvXEMRyvv7qOYe2fDkhS9VHHn0iaJmlNRPxh7U2Mw/Z7NfLdX5KmS7qv6f5s3y9piaTTJO2VdJOkv5H0gKQzJb0o6aqIaOTi3Dj9LdHIMDYk7ZJ09ajz77r7u1jSP0raJulYtfhGjZx3N34MC/0tUw3HsJEQANA7uDAIJEcIAMkRAkByhACQHCEAJNdoCPTwlFxJ9NeuXu6vl3uT6u2v6ZFAT/9DiP7a1cv99XJvUo39NR0CABrW1mQh25dJulMjM//+MiJuLq0/w/1xigbeen1YB9Wn/knvv9vorz293F8v9yZ1vr839WMdioMeqzbpEJjMzUFO9dy40JdMan8AJm9TbNT+2DdmCLRzOsDNQYCTQDshMBVuDgKghend3kH1UcdKSTpFM7u9OwAnqJ2RwIRuDhIRqyNiMCIGe/lCDJBVOyHQ0zcHATAxkz4diIgjtq+V9Hf6v5uDPNOxzgDUoq1rAhGxXtL6DvUCoAHMGASSIwSA5AgBIDlCAEiOEACSIwSA5AgBIDlCAEiOEACSIwSA5AgBIDlCAEiOEACSIwSA5AgBIDlCAEiOEACSIwSA5AgBIDlCAEiOEACSIwSA5AgBIDlCAEiOEACSIwSA5AgBIDlCAEiOEACSIwSA5AgBILnp7bzZ9i5JByQdlXQkIgY70RSA+rQVApWPR8QrHdgOgAZwOgAk124IhKTv237S9spONASgXu2eDlwcEXtsny5pg+1nI+LR0StU4bBSkk7RzDZ3B6DT2hoJRMSe6nFY0kOSLhhjndURMRgRg33qb2d3ALpg0iFge8D27OPPJX1C0vZONQagHu2cDsyT9JDt49u5LyK+15GuANRm0iEQES9IOq+DvQBoAB8RAskRAkByhACQHCEAJEcIAMkRAkBynfgpwjRe/eLHivUzlz9frD87PK9YP3Swr1hfcH+5PnP3a8X6sa07inXkxEgASI4QAJIjBIDkCAEgOUIASI4QAJIjBIDkmCdwAn73d+4r1j8z8KPyBs5us4El5fKuI68X63e+/PE2G5jafjh8VrE+cNtPFevTNz7ZyXZ6BiMBIDlCAEiOEACSIwSA5AgBIDlCAEiOEACSc0TUtrNTPTcu9CW17a/TfvzZC4v1Vz5cztQ5O8vH+kc/52J9xof/u1i/5UMPFuuXvvONYv27r88q1j89s3y/gna9EYeK9U0HB4r1Jaccbmv/7/vu1cX6+1c+0db2m7QpNmp/7BvzC4yRAJAcIQAkRwgAyRECQHKEAJAcIQAkRwgAyXE/gRMw8O1NLertbf/U9t6uP/vpJcX6H1y0qLz/fyj/3oRblrzvBDs6MdPfOFasDzw9VKy/+9F1xfrPz2jxext2lesnq5YjAdtrbA/b3j5q2VzbG2w/Vz3O6W6bALplIqcDX5N02duW3SBpY0ScI2lj9RrAFNQyBCLiUUn73rZ4qaS11fO1kq7ocF8AajLZC4PzIuL4CdpLksq/ZA9Az2r704EY+QmkcX8yxvZK25ttbz6sg+3uDkCHTTYE9tqeL0nV4/B4K0bE6ogYjIjBPvVPcncAumWyIfCIpBXV8xWSHu5MOwDq1nKegO37NXLH+9Ns75Z0k6SbJT1g+wuSXpR0VTebxMQceWlvsT6wrlw/2mL7A99+9QQ76qy9v/GxYv2DM8pfzrfu+0CxvuivXijWjxSrU1fLEIiIZeOUpu7dQQC8hWnDQHKEAJAcIQAkRwgAyRECQHKEAJAc9xNAz5h+1sJi/as3frVY7/O0Yv2v7/zlYv3dQ48X6ycrRgJAcoQAkBwhACRHCADJEQJAcoQAkBwhACTHPAH0jGd/e0Gx/pF+F+vPHHqjWJ+74/UT7ikDRgJAcoQAkBwhACRHCADJEQJAcoQAkBwhACTHPAHU5uCnP1Ksb/nsHS22UP4NVr953XXF+jv/6Ycttp8TIwEgOUIASI4QAJIjBIDkCAEgOUIASI4QAJJjngBq8x+fLH/PmeXyPIBl/35psT7ze08V61Gs5tVyJGB7je1h29tHLVtle4/trdWfT3W3TQDdMpHTga9JumyM5XdExOLqz/rOtgWgLi1DICIelbSvhl4ANKCdC4PX2n66Ol2Y07GOANRqsiFwl6SzJS2WNCTptvFWtL3S9mbbmw/r4CR3B6BbJhUCEbE3Io5GxDFJd0u6oLDu6ogYjIjBvhY/BQagfpMKAdvzR728UtL28dYF0NtazhOwfb+kJZJOs71b0k2SltherJGPXndJurqLPWKKeMfs2cX68l98rFjff+zNYn34K+8t1vsPPlGsY2wtQyAilo2x+J4u9AKgAUwbBpIjBIDkCAEgOUIASI4QAJIjBIDkuJ8AOua5VR8s1r9z2l8U60uf+0yx3r+eeQDdwEgASI4QAJIjBIDkCAEgOUIASI4QAJIjBIDkmCeACfufX/tosf70r/5psf5vRw4X66/98RnFer+GinVMDiMBIDlCAEiOEACSIwSA5AgBIDlCAEiOEACSY54A3jJ9wc8U69d/+VvFer/LX06ff2p5sf6ev+V+AU1gJAAkRwgAyRECQHKEAJAcIQAkRwgAyRECQHLME0jE08v/3Od9Z3ex/rlZrxbr9x44vVif9+Xy95xjxSq6peVIwPZC2z+wvcP2M7avq5bPtb3B9nPV45zutwug0yZyOnBE0pci4lxJH5V0je1zJd0gaWNEnCNpY/UawBTTMgQiYigitlTPD0jaKWmBpKWS1larrZV0RbeaBNA9J3Rh0PYiSedL2iRpXkQcv+nbS5LmdbQzALWYcAjYniVpnaTrI2L/6FpEhKQY530rbW+2vfmwDrbVLIDOm1AI2O7TSADcGxEPVov32p5f1edLGh7rvRGxOiIGI2KwT/2d6BlAB03k0wFLukfSzoi4fVTpEUkrqucrJD3c+fYAdNtE5glcJGm5pG22t1bLbpR0s6QHbH9B0ouSrupOi+iY8z5QLP/+6d9oa/N//pXPFevveurxtraP7mgZAhHxmCSPU76ks+0AqBvThoHkCAEgOUIASI4QAJIjBIDkCAEgOe4ncBKZdu77i/WV32xvPte5a64p1hd945/b2j6awUgASI4QAJIjBIDkCAEgOUIASI4QAJIjBIDkmCdwEnn2t8p3fb985v5ivZUz/v5QeYUY8w5z6HGMBIDkCAEgOUIASI4QAJIjBIDkCAEgOUIASI55AlPIm5dfUKxvvPy2FluY2blmcNJgJAAkRwgAyRECQHKEAJAcIQAkRwgAyRECQHIt5wnYXijp65LmSQpJqyPiTturJH1R0svVqjdGxPpuNQrpvy6aVqyfOb29eQD3Hji9WO/bX76fAHcTmJomMlnoiKQvRcQW27MlPWl7Q1W7IyJu7V57ALqtZQhExJCkoer5Ads7JS3odmMA6nFC1wRsL5J0vqRN1aJrbT9te43t8r2tAPSkCYeA7VmS1km6PiL2S7pL0tmSFmtkpDDmxHXbK21vtr35sA52oGUAnTShELDdp5EAuDciHpSkiNgbEUcj4pikuyWN+dMtEbE6IgYjYrBP/Z3qG0CHtAwB25Z0j6SdEXH7qOXzR612paTtnW8PQLdN5NOBiyQtl7TN9tZq2Y2SltlerJFPhnZJurorHQLoqol8OvCYJI9RYk7AFPNHr55brD/+K4uK9Rja1sFu0CuYMQgkRwgAyRECQHKEAJAcIQAkRwgAyRECQHKOGn+n/KmeGxf6ktr2B2DEptio/bFvrPk+jASA7AgBIDlCAEiOEACSIwSA5AgBIDlCAEiu1nkCtl+W9OKoRadJeqW2Bk4c/bWnl/vr5d6kzvd3VkS8Z6xCrSHwEzu3N0fEYGMNtEB/7enl/nq5N6ne/jgdAJIjBIDkmg6B1Q3vvxX6a08v99fLvUk19tfoNQEAzWt6JACgYYQAkBwhACRHCADJEQJAcv8LId/VeNhqNOUAAAAASUVORK5CYII=\n" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAECCAYAAAD+eGJTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAOdklEQVR4nO3df6zV9X3H8dcLvYAVVAiMMUqlUInVLkJ7Y+vmNo1r5/ijarK5ka3Dpg0uq5smJq0hS7Rpbczij27Z4oKVlCZqw/y91LVSaqN2BL04JghtcQ432RUk0IH7wY/re3/cL+utvfdzLvec8/0eeD8fCbnnfN/nfr9vv3hffL7f87mf44gQgLwmNd0AgGYRAkByhACQHCEAJEcIAMkRAkByjYSA7Stt/8j2q7ZvaaKHEtu7bG+1vcX2QA/0s8b2XtvbRmybaXu97Z3V1xk91t9ttndX53CL7WUN9jff9jO2t9t+xfaN1faeOIeF/mo5h657noDt0yT9WNLHJb0h6UVJyyNie62NFNjeJak/IvY13Ysk2f51SW9L+kZEfKja9heS9kfEHVWQzoiIL/RQf7dJejsi7myip5Fsz5U0NyJesj1d0mZJV0u6Tj1wDgv9XasazmETI4GLJb0aEa9FxBFJ35R0VQN9nDQi4llJ+9+1+SpJa6vHazX8P00jxuivZ0TEYES8VD0+JGmHpHnqkXNY6K8WTYTAPEn/PuL5G6rxP3icQtLTtjfbXtl0M2OYExGD1eM3Jc1pspkx3GD75epyobHLlZFsL5C0VNIm9eA5fFd/Ug3nkBuDo7s0Ij4s6bclfa4a7vasGL6m67X53/dKWiRpiaRBSXc1245ke5qkRyTdFBEHR9Z64RyO0l8t57CJENgtaf6I5++ttvWMiNhdfd0r6TENX8L0mj3VteTxa8q9DffzMyJiT0QMRcQ7ku5Tw+fQdp+Gf8AeiIhHq809cw5H66+uc9hECLwo6Tzb77c9WdLvS3qygT5GZfvM6uaMbJ8p6ROStpW/qxFPSlpRPV4h6YkGe/k5x3+4KteowXNo25Lul7QjIu4eUeqJczhWf3Wdw9rfHZCk6q2Or0o6TdKaiLi99ibGYHuhhv/1l6TTJT3YdH+2H5J0maRZkvZIulXS45LWSXqfpNclXRsRjdycG6O/yzQ8jA1JuyRdP+L6u+7+LpX0nKStkt6pNq/S8HV34+ew0N9y1XAOGwkBAL2DG4NAcoQAkBwhACRHCADJEQJAco2GQA9PyZVEf+3q5f56uTep3v6aHgn09F+E6K9dvdxfL/cm1dhf0yEAoGFtTRayfaWkv9TwzL+vRcQdpddP9pSYqjP///lRHVafpkz4+N1Gf+3p5f56uTep8/39r/5LR+KwR6tNOAQmsjjIWZ4ZH/UVEzoegInbFBt0MPaPGgLtXA6wOAhwCmgnBE6GxUEAtHB6tw9QvdWxUpKm6j3dPhyAE9TOSGBci4NExOqI6I+I/l6+EQNk1U4I9PTiIADGZ8KXAxFxzPYNkr6jny4O8krHOgNQi7buCUTEU5Ke6lAvABrAjEEgOUIASI4QAJIjBIDkCAEgOUIASI4QAJIjBIDkCAEgOUIASI4QAJIjBIDkCAEgOUIASK7ry4uhc3Z9+ZJifWhqeeXo2Re+VaxvvOiRE+5ppEXf+3SxPv2FM4r1OX/1j20dHxPDSABIjhAAkiMEgOQIASA5QgBIjhAAkiMEgOSYJ9BDDnzrvGJ925K/7urxj078U+olST+8/GvF+gP9c4v1det/o1gf2rHzhHtCa4wEgOQIASA5QgBIjhAAkiMEgOQIASA5QgBIjnkCNWo1D+AHS77Z1eP/7U8WFut3b/x4sb7g3PJ6BE9f8Gix/gfTB4v126+bVawv/ALzBLqhrRCwvUvSIUlDko5FRH8nmgJQn06MBC6PiH0d2A+ABnBPAEiu3RAISU/b3mx7ZScaAlCvdi8HLo2I3bZ/QdJ62z+MiGdHvqAKh5WSNFXvafNwADqtrZFAROyuvu6V9Jiki0d5zeqI6I+I/j5NaedwALpgwiFg+0zb048/lvQJSds61RiAerRzOTBH0mO2j+/nwYj4dke6Okkdu+Ijxfr3LvqbFnvoK1a/emBxsf7M77V4h/Y/9hbLiw8MFOuTpk4t1r+y6ZeL9VWzthbrx2YcK9bRHRMOgYh4TdJFHewFQAN4ixBIjhAAkiMEgOQIASA5QgBIjhAAkmM9gQ56e97kYn1Si8xtNQ/g+58svw8/9NqPivV2vfrFpcX6gzPvarGH8ozR936bf5OawFkHkiMEgOQIASA5QgBIjhAAkiMEgOQIASA55gl00Dnf2Fis/87AHxbrPnCwWD82uOsEO+qszy77brE+bRIrR52MGAkAyRECQHKEAJAcIQAkRwgAyRECQHKEAJAc8wRqNLT9x023ULTr9kuK9c+cc2eLPZQ/l+DmwY8V69O/u6NYH2pxdEwMIwEgOUIASI4QAJIjBIDkCAEgOUIASI4QAJJjnkAiP/lUeR7AD/6oPA/g7EnleQAbD59WrG/5cvlzC844+EKxju5oORKwvcb2XtvbRmybaXu97Z3V1xndbRNAt4zncuDrkq5817ZbJG2IiPMkbaieAzgJtQyBiHhW0v53bb5K0trq8VpJV3e4LwA1meiNwTkRMVg9flPSnA71A6Bmbb87EBEhKcaq215pe8D2wFEdbvdwADpsoiGwx/ZcSaq+7h3rhRGxOiL6I6K/r8Wn0gKo30RD4ElJK6rHKyQ90Zl2ANSt5TwB2w9JukzSLNtvSLpV0h2S1tn+jKTXJV3bzSbRGfs+POZVm6TW8wBaWfH9zxbrix9nHkAvahkCEbF8jNIVHe4FQAOYNgwkRwgAyRECQHKEAJAcIQAkRwgAybGewCnkyPpzi/WN59/VYg/leQIXbVxRrH/w5n8p1vncgN7ESABIjhAAkiMEgOQIASA5QgBIjhAAkiMEgOSYJ3ASOX3hgmL9Sx/4u2J9Rov1Aja3WP3t3C+V3+kfOnCgvAP0JEYCQHKEAJAcIQAkRwgAyRECQHKEAJAcIQAkxzyBk8iidbuL9aWT28v05Rv+uFhf/M8vtrV/9CZGAkByhACQHCEAJEcIAMkRAkByhACQHCEAJMc8gR5yYMUlxfoX57T63IApxeqKXb9ZrH/w868W63xuwKmp5UjA9hrbe21vG7HtNtu7bW+p/izrbpsAumU8lwNfl3TlKNvviYgl1Z+nOtsWgLq0DIGIeFbS/hp6AdCAdm4M3mD75epyYUbHOgJQq4mGwL2SFklaImlQ0ph3rGyvtD1ge+CoWqxkCaB2EwqBiNgTEUMR8Y6k+yRdXHjt6ojoj4j+vhZ3rwHUb0IhYHvuiKfXSNo21msB9LaW8wRsPyTpMkmzbL8h6VZJl9leIikk7ZJ0fRd7PGWcPu+XivVf+7NNxfq0Se2NpDZu/0CxvvgA6wVk1DIEImL5KJvv70IvABrAtGEgOUIASI4QAJIjBIDkCAEgOUIASI71BGq0Y9X8Yv3xX/z7tvZ/+dbfLdZZLwCjYSQAJEcIAMkRAkByhACQHCEAJEcIAMkRAkByzBOo0eZP3tPiFe2tF3D2n7xTrB87cKCt/ePUxEgASI4QAJIjBIDkCAEgOUIASI4QAJIjBIDkmCdwCjk65+xive/IvJo6Gd3QW/uK9Thc/pg6TynPozht9qwT7mmkodnnFOs7b57c1v5biSEX6+f/aYv1IA4enNBxGQkAyRECQHKEAJAcIQAkRwgAyRECQHKEAJAc8wROId96eE3TLRT9yj+N9in3P7Vvz1nF+ozZh4r1TR958IR7Oplc8Oc3FOsLP79xQvttORKwPd/2M7a3237F9o3V9pm219veWX2dMaEOADRqPJcDxyTdHBEXSPqYpM/ZvkDSLZI2RMR5kjZUzwGcZFqGQEQMRsRL1eNDknZImifpKklrq5etlXR1t5oE0D0ndGPQ9gJJSyVtkjQnIgar0puS5nS0MwC1GHcI2J4m6RFJN0XEz/ymQkSEpBjj+1baHrA9cFTlXxABUL9xhYDtPg0HwAMR8Wi1eY/tuVV9rqS9o31vRKyOiP6I6O9rczVdAJ03nncHLOl+STsi4u4RpSclrager5D0ROfbA9BtHh7JF15gXyrpOUlbJR1f2H6Vhu8LrJP0PkmvS7o2IvaX9nWWZ8ZHfUW7PZ+0/uc77y/WN3zo4Zo6yem/40ixfjTKn9vQyrKXryvW/3NLe+sdzH3+WLE+5R9eHLO2KTboYOwfdcGClpOFIuJ5SWOtdpD3Jxo4RTBtGEiOEACSIwSA5AgBIDlCAEiOEACSYz2BGp3xW/9arF/4lfLvi0eX/7amn1+c5tH139e/8LlPF+vxb2e2tf+FD79dfsELW9va/wztbKveFEYCQHKEAJAcIQAkRwgAyRECQHKEAJAcIQAk13I9gU7Kvp4A0JTSegKMBIDkCAEgOUIASI4QAJIjBIDkCAEgOUIASI4QAJIjBIDkCAEgOUIASI4QAJIjBIDkCAEgOUIASK5lCNieb/sZ29ttv2L7xmr7bbZ3295S/VnW/XYBdNp4Ps7imKSbI+Il29Mlbba9vqrdExF3dq89AN3WMgQiYlDSYPX4kO0dkuZ1uzEA9TihewK2F0haKmlTtekG2y/bXmN7Rod7A1CDcYeA7WmSHpF0U0QclHSvpEWSlmh4pHDXGN+30vaA7YGjOtyBlgF00rhCwHafhgPggYh4VJIiYk9EDEXEO5Luk3TxaN8bEasjoj8i+vs0pVN9A+iQ8bw7YEn3S9oREXeP2D53xMuukbSt8+0B6LbxvDvwq5I+JWmr7S3VtlWSltteIikk7ZJ0fVc6BNBV43l34HlJo61X/lTn2wFQN2YMAskRAkByhACQHCEAJEcIAMkRAkByhACQHCEAJEcIAMkRAkByhACQHCEAJEcIAMkRAkByhACQnCOivoPZb0l6fcSmWZL21dbAiaO/9vRyf73cm9T5/s6NiNmjFWoNgZ87uD0QEf2NNdAC/bWnl/vr5d6kevvjcgBIjhAAkms6BFY3fPxW6K89vdxfL/cm1dhfo/cEADSv6ZEAgIYRAkByhACQHCEAJEcIAMn9H3Z2+kt0r5nJAAAAAElFTkSuQmCC\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" - } - }, - { - "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" - } - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "code", - "source": [ - "y_predicted_labels=[np.argmax(i) for i in y_predicted]\n", - "y_predicted_labels[:10]" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "rtHOuzWM68HG", - "outputId": "2a41853d-aa6c-4027-9c36-21a0e37a0034" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "[7, 2, 1, 0, 4, 1, 4, 9, 6, 9]" - ] - }, - "metadata": {}, - "execution_count": 59 - } - ] - } - ] -} \ No newline at end of file From 5232010638b16a74a689139c8cdb43fc134c0324 Mon Sep 17 00:00:00 2001 From: ambujpyne02 <104996993+ambujpyne02@users.noreply.github.com> Date: Tue, 21 Jun 2022 12:55:11 +0530 Subject: [PATCH 10/13] Create ok --- Assignment/Assignment_3/ok | 1 + 1 file changed, 1 insertion(+) create mode 100644 Assignment/Assignment_3/ok diff --git a/Assignment/Assignment_3/ok b/Assignment/Assignment_3/ok new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/Assignment/Assignment_3/ok @@ -0,0 +1 @@ + From 2766b01c4d3fdcea8618ff0a0edb9fdc27750108 Mon Sep 17 00:00:00 2001 From: ambujpyne02 <104996993+ambujpyne02@users.noreply.github.com> Date: Tue, 21 Jun 2022 12:55:35 +0530 Subject: [PATCH 11/13] Add files via upload --- .../Assignment_3/210118_Ambuj Pyne_A3.ipynb | 399 ++++++++++++++++++ 1 file changed, 399 insertions(+) create mode 100644 Assignment/Assignment_3/210118_Ambuj Pyne_A3.ipynb diff --git a/Assignment/Assignment_3/210118_Ambuj Pyne_A3.ipynb b/Assignment/Assignment_3/210118_Ambuj Pyne_A3.ipynb new file mode 100644 index 0000000..0a9a048 --- /dev/null +++ b/Assignment/Assignment_3/210118_Ambuj Pyne_A3.ipynb @@ -0,0 +1,399 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "MNIST classification using RNN.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "QY6mQDx63_ls" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import tensorflow.keras.layers as KL\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "source": [ + "#Loading MNIST dataset\n", + "(x_train,y_train),(x_test,y_test)=keras.datasets.mnist.load_data()" + ], + "metadata": { + "id": "IyF77Ns64TIc" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(len(x_train))\n", + "print(x_train.shape)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cBjIoHxN4ptL", + "outputId": "329bd834-8e46-43cc-9c4d-ae93de37828e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "60000\n", + "(60000, 28, 28)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "x_train=x_train/255\n", + "x_test=x_test/255\n", + "# This is known as scaling the values\n", + "# It helps in improving the accuracy while training the neural network" + ], + "metadata": { + "id": "H-Nn6crSBRqq" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model=keras.Sequential([\n", + " KL.LSTM(64, input_shape=(28,28)),\n", + " KL.Dense(10, activation=\"sigmoid\")\n", + "])\n", + "#Sequential accepts layers as elemments\n", + "#Dense means all the neurons here in one layer are connected to every other neuron in another layer \n", + "model.compile(\n", + " optimizer='adam',\n", + " loss='sparse_categorical_crossentropy',\n", + " metrics=['accuracy']\n", + ")\n", + "model.fit(x_train,y_train,epochs=10)\n", + "#this is supplying the training set\n", + "#epochs is the no. of iteraton our neural network is going to run the array" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qsrBbcJV3lqc", + "outputId": "6137e4de-db3d-47bf-b495-8e3eb64c9d47" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/10\n", + "1875/1875 [==============================] - 29s 15ms/step - loss: 0.6882 - accuracy: 0.7704\n", + "Epoch 2/10\n", + "1875/1875 [==============================] - 27s 14ms/step - loss: 0.3961 - accuracy: 0.8679\n", + "Epoch 3/10\n", + "1875/1875 [==============================] - 27s 15ms/step - loss: 0.3319 - accuracy: 0.8889\n", + "Epoch 4/10\n", + "1875/1875 [==============================] - 27s 14ms/step - loss: 0.3005 - accuracy: 0.9003\n", + "Epoch 5/10\n", + "1875/1875 [==============================] - 28s 15ms/step - loss: 0.2777 - accuracy: 0.9064\n", + "Epoch 6/10\n", + "1875/1875 [==============================] - 27s 14ms/step - loss: 0.2558 - accuracy: 0.9147\n", + "Epoch 7/10\n", + "1875/1875 [==============================] - 27s 14ms/step - loss: 0.2438 - accuracy: 0.9174\n", + "Epoch 8/10\n", + "1875/1875 [==============================] - 27s 15ms/step - loss: 0.2315 - accuracy: 0.9215\n", + "Epoch 9/10\n", + "1875/1875 [==============================] - 27s 14ms/step - loss: 0.2205 - accuracy: 0.9259\n", + "Epoch 10/10\n", + "1875/1875 [==============================] - 27s 14ms/step - loss: 0.2114 - accuracy: 0.9290\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 56 + } + ] + }, + { + "cell_type": "code", + "source": [ + "model.evaluate(x_test,y_test)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "wNaK1M4w2hMD", + "outputId": "a90859fd-d117-4d62-91b8-20c80aa9958e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "313/313 [==============================] - 3s 7ms/step - loss: 0.2407 - accuracy: 0.9214\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[0.2407352328300476, 0.9214000105857849]" + ] + }, + "metadata": {}, + "execution_count": 57 + } + ] + }, + { + "cell_type": "code", + "source": [ + "y_predicted=model.predict(x_test)\n", + "y_predicted[0]\n", + "## Y_predicted stores the probability that the neural network has predicted, with which the each given figure matches each of the valus from 0-9." + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "o75L9U2l5kOH", + "outputId": "be3ae9a9-03eb-467b-e792-4c1820ced2b8" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([4.6644823e-07, 2.0185764e-05, 3.4810280e-05, 1.1356701e-03,\n", + " 2.4589428e-05, 3.7091362e-04, 3.4589270e-08, 9.9485153e-01,\n", + " 1.4918595e-05, 3.5468936e-03], dtype=float32)" + ] + }, + "metadata": {}, + "execution_count": 32 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Now I will show how accurately the neural network will predict the handwritten number." + ], + "metadata": { + "id": "cDLCPSiA6jF0" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "\n", + "Test 1- " + ], + "metadata": { + "id": "-Pmi3FKT7Jt0" + } + }, + { + "cell_type": "code", + "source": [ + "for i in range (10):\n", + " plt.matshow(x_test[i])" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "PbgY9nzx5ubl", + "outputId": "cf1e31a0-57ec-4806-9976-e10887af18ac" + }, + "execution_count": null, + "outputs": [ + { + "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" + } + }, + { + "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" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAECCAYAAAD+eGJTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAPCUlEQVR4nO3df6xX9X3H8dcLuIWCoDC6K8WfdWzqmontFWs1m4vRWMemLhutSS0mTXBbrbq4ps4t0WxZYpZqf+yHHRZSliqL8UelKZt1zEYbJ+XijPJD0FmoMgQZVcC2/Li898f94r7Vez/fe+/3x/nC+/lIyP1+z/t8v+fdU3nxOed87jmOCAHIa1zVDQCoFiEAJEcIAMkRAkByhACQHCEAJFdJCNi+3PYm2y/bvrWKHkpsb7H9gu3nbPd3QT9Lbe+0va5u2Qzbj9t+qfZzepf1d4ftbbV9+JztKyrs72TbT9jeYHu97Ztqy7tiHxb668g+dKfnCdgeL2mzpEslvSZpjaRrImJDRxspsL1FUl9E7Kq6F0my/ZuS9kn654j4cG3Z30raHRF31oJ0ekR8sYv6u0PSvoj4UhU91bM9S9KsiHjW9lRJayVdJek6dcE+LPS3QB3Yh1WMBOZJejkiXomIA5L+RdKVFfRx1IiIJyXtftfiKyUtq71epsH/aCoxTH9dIyK2R8Sztdd7JW2UNFtdsg8L/XVEFSEwW9Krde9fUwf/B49QSPqe7bW2F1XdzDB6I2J77fXrknqrbGYYN9h+vna4UNnhSj3bp0k6V9JqdeE+fFd/Ugf2IScGh3ZRRHxE0ickfa423O1aMXhM123zv++RdIakuZK2S7qr2nYk28dJekjSzRGxp77WDftwiP46sg+rCIFtkk6ue39SbVnXiIhttZ87JT2iwUOYbrOjdix55JhyZ8X9/IKI2BERAxFxWNK9qngf2u7R4F+w+yLi4drirtmHQ/XXqX1YRQiskTTH9um23yfpU5JWVNDHkGxPqZ2cke0pki6TtK78qUqskLSw9nqhpEcr7OU9jvzlqrlaFe5D25a0RNLGiLi7rtQV+3C4/jq1Dzt+dUCSapc6viJpvKSlEfE3HW9iGLY/pMF//SVpgqT7q+7P9nJJF0uaKWmHpNslfVvSA5JOkbRV0oKIqOTk3DD9XazBYWxI2iLp+rrj7073d5GkpyS9IOlwbfFtGjzurnwfFvq7Rh3Yh5WEAIDuwYlBIDlCAEiOEACSIwSA5AgBILlKQ6CLp+RKor9mdXN/3dyb1Nn+qh4JdPX/EaK/ZnVzf93cm9TB/qoOAQAVa2qykO3LJX1VgzP/vhERd5bWf58nxiRNeef9Qe1XjyaOefvtRn/N6eb+urk3qfX9/Vxv60Ds91C1MYfAWG4OMs0z4nxfMqbtARi71bFKe2L3kCHQzOEANwcBjgHNhMDRcHMQAA1MaPcGapc6FknSJE1u9+YAjFIzI4ER3RwkIhZHRF9E9HXziRggq2ZCoKtvDgJgZMZ8OBARh2zfIOkx/f/NQda3rDMAHdHUOYGIWClpZYt6AVABZgwCyRECQHKEAJAcIQAkRwgAyRECQHKEAJAcIQAkRwgAyRECQHKEAJAcIQAkRwgAyRECQHKEAJAcIQAkRwgAyRECQHKEAJAcIQAkRwgAyRECQHJtfwwZMFITTuwt1g/M+WBbt9+z+T0P0PoFm/78Q8X6CRuGfOjvO2Zs/HmxPu6p/yrW24WRAJAcIQAkRwgAyRECQHKEAJAcIQAkRwgAyTFPAC3z1qc/Vqz/7xXl6+S3nvtvxfpnpq0cdU+jseStU4r135/6SLE+/Q8nNbX9+bM/2tTnx6qpELC9RdJeSQOSDkVEXyuaAtA5rRgJ/HZE7GrB9wCoAOcEgOSaDYGQ9D3ba20vakVDADqr2cOBiyJim+1flvS47Rcj4sn6FWrhsEiSJmlyk5sD0GpNjQQiYlvt505Jj0iaN8Q6iyOiLyL6ejSxmc0BaIMxh4DtKbanHnkt6TJJ61rVGIDOaOZwoFfSI7aPfM/9EVG+0ItKjTvnrGL9xc9PKdafuuwrxfoHxq8pb7/Lz0N/9vgfN1ijuXkA3WrMIRARr0g6p4W9AKhAd0czgLYjBIDkCAEgOUIASI4QAJIjBIDkuJ9AIm+fPrVY3/yJexp8w/tb10wFvv5m+bkB9209r0OdDO14vVzJdhkJAMkRAkByhACQHCEAJEcIAMkRAkByhACQHPMEOmjCSbOL9Y1fPKlY733axfq05c8U6+P2R7G++eCBYv3VQycU6ydPeLNYv27dwmL9Jxt/qVjvXVPu/4SnXy3WY9++Yv34N6u5Tl81RgJAcoQAkBwhACRHCADJEQJAcoQAkBwhACTHPIEWGn/C8cX6vO/+qFj/9swVxfqF/TeMuqd6E/+1/FyAL/zOdcX6wPpNxfr4s+YU6zM2/Xe5fnhzsd7IoaY+nRcjASA5QgBIjhAAkiMEgOQIASA5QgBIjhAAkmOewCiMm1R+Pv3+B8vzBG6b+R/F+q89/CfF+pmPrC/WB4rVxhrNA2j4+Y0vNdkBqtBwJGB7qe2dttfVLZth+3HbL9V+Tm9vmwDaZSSHA9+UdPm7lt0qaVVEzJG0qvYewFGoYQhExJOSdr9r8ZWSltVeL5N0VYv7AtAhYz0x2BsR22uvX5fU26J+AHRY01cHIiIkDXsHSNuLbPfb7j+o/c1uDkCLjTUEdtieJUm1nzuHWzEiFkdEX0T09WjiGDcHoF3GGgIrJB25f/RCSY+2ph0AndZwnoDt5ZIuljTT9muSbpd0p6QHbH9W0lZJC9rZZKeMn16+0vniX/9qsb7prH8s1tc2OBo6869eKdYH9uwpfwEwBg1DICKuGaZ0SYt7AVABpg0DyRECQHKEAJAcIQAkRwgAyRECQHLcT6DO/3z6rGJ909V/V6yveLs8z2DJ/EuL9YE3yvflB9qBkQCQHCEAJEcIAMkRAkByhACQHCEAJEcIAMkxT6DO3vN/1tTnv/qj8m9Xv38z8wDQfRgJAMkRAkByhACQHCEAJEcIAMkRAkByhACQHPME6iy/cHGDNcqZ+eDZ3yrWL7j7lmL99BUHivXx33+2WAfGgpEAkBwhACRHCADJEQJAcoQAkBwhACRHCADJMU+gzryJPcX6wRgo1qePm1Ssv/jJfyh//4Ly93941R8V68evKW9/30lRrE97pVjWzOffLq/QwK7fmFKs935/Z7E+wP0Y2qLhSMD2Uts7ba+rW3aH7W22n6v9uaK9bQJol5EcDnxT0uVDLP9yRMyt/VnZ2rYAdErDEIiIJyXt7kAvACrQzInBG2w/XztcKD+ED0DXGmsI3CPpDElzJW2XdNdwK9peZLvfdv9B7R/j5gC0y5hCICJ2RMRARByWdK+keYV1F0dEX0T09WjiWPsE0CZjCgHbs+reXi1p3XDrAuhujihfO7a9XNLFkmZK2iHp9tr7uZJC0hZJ10fE9kYbm+YZcb7L9+av0uZ/Oq9cn//1DnWS0w/3u1i/ecOnivUZ8ze3sp1jyupYpT2xe8gd3HCyUERcM8TiJU13BaArMG0YSI4QAJIjBIDkCAEgOUIASI4QAJJrOE+glbp9noAnlK+YHrj4nGL9M3//nWJ98rjytOn5k98o1ns8vlg/1h3W4WL91++/sVg/4wv/2cp2jiqleQKMBIDkCAEgOUIASI4QAJIjBIDkCAEgOUIASI7nDtSJQ4eK9Z5/X1usLz/zg01t/2t/UP59+YGe8u/bf/zPflis33nimlH31E3GNfg366RzGt7SAkNgJAAkRwgAyRECQHKEAJAcIQAkRwgAyRECQHLME+giUx5c3dTnv3POBcX6ndeW5wn8NA4U6x998o+L9VO/Ub7fwa4bf1qs95/3rWId7cFIAEiOEACSIwSA5AgBIDlCAEiOEACSIwSA5JgncAw55bHycw10bbk82e8r1jf+VvmJ9NeeemmxvvK0x8oNNPlv0o9fn1Gsz9GWpr7/WNVwr9s+2fYTtjfYXm/7ptryGbYft/1S7ef09rcLoNVGEr2HJN0SEWdL+pikz9k+W9KtklZFxBxJq2rvARxlGoZARGyPiGdrr/dK2ihptqQrJS2rrbZM0lXtahJA+4zqIMz2aZLOlbRaUm9EHLmp2+uSelvaGYCOGHEI2D5O0kOSbo6IPfW1GHyq6ZBPNrW9yHa/7f6DanDiCkDHjSgEbPdoMADui4iHa4t32J5Vq8+StHOoz0bE4ojoi4i+Hk1sRc8AWmgkVwcsaYmkjRFxd11phaSFtdcLJT3a+vYAtJsHR/KFFeyLJD0l6QXpnQfE36bB8wIPSDpF0lZJCyJid+m7pnlGnO9Lmu0Zwxg3dWqxvvP+WcX6Mx9Z3sp2Rm1/HCzW528oP5dh8oKfFOsDb7416p6OFatjlfbE7iEfXNFwslBE/EDScE+94G80cJRj2jCQHCEAJEcIAMkRAkByhACQHCEAJMf9BI4hh/fuLdZP/Hz5t71/d+nvFeu3nfbdYv2CiQPF+kP7Zhbrf7Hyk8X6r/zpM8V6eesYDiMBIDlCAEiOEACSIwSA5AgBIDlCAEiOEACSa3g/gVbifgJHtx03frxY33vez4r1M/9yV7F+aOuro+4JI1O6nwAjASA5QgBIjhAAkiMEgOQIASA5QgBIjhAAkuN+Ahix3q89Xa43+Pyh1rWCFmIkACRHCADJEQJAcoQAkBwhACRHCADJEQJAcg1DwPbJtp+wvcH2ets31ZbfYXub7edqf65of7sAWm0kk4UOSbolIp61PVXSWtuP12pfjogvta89AO3WMAQiYruk7bXXe21vlDS73Y0B6IxRnROwfZqkcyWtri26wfbztpfaLj/jCkBXGnEI2D5O0kOSbo6IPZLukXSGpLkaHCncNcznFtnut91/UPtb0DKAVhpRCNju0WAA3BcRD0tSROyIiIGIOCzpXknzhvpsRCyOiL6I6OvRxFb1DaBFRnJ1wJKWSNoYEXfXLZ9Vt9rVkta1vj0A7TaSqwMXSrpW0gu2n6stu03SNbbnSgpJWyRd35YOAbTVSK4O/EDSUPcrX9n6dgB0GjMGgeQIASA5QgBIjhAAkiMEgOQIASA5QgBIjhAAkiMEgOQIASA5QgBIjhAAkiMEgOQIASA5QgBIzhHRuY3Zb0jaWrdopqRdHWtg9OivOd3cXzf3JrW+v1Mj4gNDFToaAu/ZuN0fEX2VNdAA/TWnm/vr5t6kzvbH4QCQHCEAJFd1CCyuePuN0F9zurm/bu5N6mB/lZ4TAFC9qkcCACpGCADJEQJAcoQAkBwhACT3fyBVLCicx+kBAAAAAElFTkSuQmCC\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": [ + "y_predicted_labels=[np.argmax(i) for i in y_predicted]\n", + "y_predicted_labels[:10]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rtHOuzWM68HG", + "outputId": "2a41853d-aa6c-4027-9c36-21a0e37a0034" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[7, 2, 1, 0, 4, 1, 4, 9, 6, 9]" + ] + }, + "metadata": {}, + "execution_count": 59 + } + ] + } + ] +} \ No newline at end of file From 6b0b8c70afdc0e63c25335c4bd9a0b1adb2c184b Mon Sep 17 00:00:00 2001 From: ambujpyne02 <104996993+ambujpyne02@users.noreply.github.com> Date: Tue, 21 Jun 2022 12:55:48 +0530 Subject: [PATCH 12/13] Delete 210118_Ambuj Pyne_Part-1.ipynb --- 210118_Ambuj Pyne_Part-1.ipynb | 965 --------------------------------- 1 file changed, 965 deletions(-) delete mode 100644 210118_Ambuj Pyne_Part-1.ipynb diff --git a/210118_Ambuj Pyne_Part-1.ipynb b/210118_Ambuj Pyne_Part-1.ipynb deleted file mode 100644 index 1bb9b33..0000000 --- a/210118_Ambuj Pyne_Part-1.ipynb +++ /dev/null @@ -1,965 +0,0 @@ -{ - "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": "Copy of DL_Stamatics_A1.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.\n", - "* For Submission, You'll be required to submit a sharable link for your copy of this notebook. (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": "2f023469-eced-40f7-d557-66b1e5a2f788" - }, - "source": [ - "### YOUR CODE HERE\n", - "import numpy as np\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": null, - "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": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "pbLIS5vIE-Ea", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "52fd3943-b0fc-4549-ffc7-264d8810639c" - }, - "source": [ - "# Now, let's test out this dot product. Your answer should be [[1]].\n", - "import numpy as np\n", - "a=np.array([[1,-1,1,-1,1]])\n", - "b=np.array([[1],[1],[1],[-1],[-1]])\n", - "\n", - "aDotB = dot_product(a, b)\n", - "print(aDotB)\n", - "\n", - "print(\"The size is: \", aDotB.shape)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[[1]]\n", - "The size is: (1, 1)\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": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "da_uQQLhE-Ec", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "7925b57d-f4d4-4558-edfd-0078a3c8db89" - }, - "source": [ - "# Your answer should be $[[3], [9], [15], [21]]$ of shape(4, 1).\n", - "import numpy as np\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", - "ans = complicated_matrix_function(M, a, b)\n", - "print(ans)\n", - "print()\n", - "print(\"The size is: \", ans.shape)" - ], - "execution_count": null, - "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": "11b25fd6-df42-48f2-f5e6-a06b54e423e0" - }, - "source": [ - "\n", - "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": null, - "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 = []\n", - " v = []\n", - " ### YOUR CODE HERE\n", - " w,v=np.linalg.eig(M)\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", - " eigenvalues,eigenvectors = eigen_decomp(M)\n", - " pass\n", - " ### END YOUR CODE\n", - " return eigenvalues, eigenvectors" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "t0_GkrJwE-Ee", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 235 - }, - "outputId": "7170c92e-3e1f-46fd-da52-b93a98064a22" - }, - "source": [ - "# Let's define M.\n", - "import numpy as np\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": [ - { - "output_type": "error", - "ename": "NameError", - "evalue": "ignored", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# Now let's grab the first eigenvalue and first eigenvector.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# You should get back a single eigenvalue and a single eigenvector.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mval\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvec\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_eigen_values_and_vectors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"First eigenvalue =\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'get_eigen_values_and_vectors' is not defined" - ] - } - ] - }, - { - "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", - " out =[]\n", - " ### YOUR CODE HERE\n", - " max=0\n", - " l_max=0\n", - " index=0\n", - " for i in range(M.shape[0]):\n", - " if max 0:\n", - " M[[0, index]] = M[[index, 0]]\n", - " out=M\n", - " pass\n", - " ### END YOUR CODE\n", - " return out" - ], - "execution_count": 7, - "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 = M\n", - " ### YOUR CODE HERE\n", - " for i in range (1,(M.shape)[0]):\n", - " out[i,:]=out[i,:]-(out[0,:]*(out[i,0]/out[0,0])) \n", - " pass\n", - " ### END YOUR CODE\n", - " return out" - ], - "execution_count": 6, - "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 = M\n", - " #print(out)\n", - " ### YOUR CODE HERE\n", - " out=swap_rows(out)\n", - " #print(out)\n", - " out=apply_rows(out)\n", - " out=np.round(out,decimals=2)\n", - " #print(out)\n", - " d_mat=out[1:((M.shape)[0]), 1:((M.shape)[0])]\n", - " #print(d_mat)\n", - " d_mat=swap_rows(d_mat)\n", - " #print(d_mat)\n", - " d_mat=apply_rows(d_mat)\n", - " #print(d_mat)\n", - " #print(d_mat)\n", - " out[1:((M.shape)[0]), 1:((M.shape)[0])]=d_mat\n", - " out[1,:]=out[1,:]/2\n", - " out[2,2]=out[2,2]*(-10)\n", - " #print(out)\n", - " pass\n", - " ### END YOUR CODE\n", - " return out" - ], - "execution_count": 5, - "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 = M\n", - " ### YOUR CODE HERE\n", - " for i in range(1,(M.shape)[0]):\n", - " out[0,:]=out[0,:]-((out[0,i]/out[i,i])*out[i,:])\n", - " out=np.round(out,decimals=2)\n", - " #print(out)\n", - " \n", - " pass\n", - " ### END YOUR CODE\n", - " return out" - ], - "execution_count": 4, - "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 = forward(M)\n", - " out=backward(out)\n", - " d_mat=out[1:((M.shape)[0]), 1:((M.shape)[0])]\n", - " d_mat=backward(d_mat)\n", - " out[1:((M.shape)[0]), 1:((M.shape)[0])]=d_mat\n", - " ### YOUR CODE HERE\n", - " pass\n", - " ### END YOUR CODE\n", - " return out" - ], - "execution_count": 2, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "Eiz6EbsWPYz8", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "119190fc-d896-4fe8-c6fe-ec55cf51a5df" - }, - "source": [ - "# Let's define M.\n", - "import numpy as np\n", - "M = np.array([[1.00,2.00,3.00],[4.00,5.00,6.00],[7.00,8.00,9.00]])\n", - "np.around(M,decimals=2)\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": 8, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[[ 7. 0. 0. ]\n", - " [ 0. 0.43 0. ]\n", - " [ 0. 0. -0.05]]\n" - ] - } - ] - }, - { - "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", - "\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", - " out = 0\n", - " diff=[]\n", - " sqr=[]\n", - " for i in range(len(u)):\n", - " diff=diff +[u[i]-v[i]]\n", - " #print(diff)\n", - " for j in range(len(u)):\n", - " sqr=sqr+[diff[j]*diff[j]]\n", - " #print(sqr)\n", - " for k in range(len(u)):\n", - " out=out+sqr[k]\n", - " out=out**(0.5)\n", - " #print(out)\n", - " \n", - " ### YOUR CODE HERE\n", - " pass\n", - " ### END YOUR CODE\n", - " return out" - ], - "execution_count": 41, - "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", - "\n", - " ### YOUR CODE HERE\n", - " m=u-v\n", - " #print(m)\n", - " m=np.square(m)\n", - " #print(m)\n", - " out=(np.sum(m))**(0.5)\n", - " #print(out)\n", - " pass\n", - " return out\n", - " ### END YOUR CODE" - ], - "execution_count": 57, - "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": 42, - "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": 58, - "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": "e02752b8-4535-4fb8-fe69-803b3fb92b9b" - }, - "execution_count": 60, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Native: 25.01792287826538 seconds\n", - "NumPy: 0.09348750114440918 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 From adc66aa79aa041db6edf879e639463e1c9ba9d67 Mon Sep 17 00:00:00 2001 From: ambujpyne02 <104996993+ambujpyne02@users.noreply.github.com> Date: Tue, 21 Jun 2022 12:56:13 +0530 Subject: [PATCH 13/13] Delete ok --- Assignment/Assignment_3/ok | 1 - 1 file changed, 1 deletion(-) delete mode 100644 Assignment/Assignment_3/ok diff --git a/Assignment/Assignment_3/ok b/Assignment/Assignment_3/ok deleted file mode 100644 index 8b13789..0000000 --- a/Assignment/Assignment_3/ok +++ /dev/null @@ -1 +0,0 @@ -