diff --git a/Assignment/Assignment_1/200116_Assignment_1_part-a.ipynb b/Assignment/Assignment_1/200116_Assignment_1_part-a.ipynb new file mode 100644 index 0000000..c148282 --- /dev/null +++ b/Assignment/Assignment_1/200116_Assignment_1_part-a.ipynb @@ -0,0 +1,964 @@ +{ + "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": "Assignment_1.ipynb", + "provenance": [], + "collapsed_sections": [] + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "rvFM645NE-D2" + }, + "source": [ + "# Assignment 1 - Part 1\n", + "In this assignment, we will go through basic linear algebra, NumPy, and image manipulation using Python to get everyone on the same page.\n", + "\n", + "One of the aims of this assignment is to get you to start getting comfortable searching for useful library functions online. So in many of the functions you will implement, you will have to look up helper functions.\n", + "\n", + "\\\n", + "\n", + "## Instructions\n", + "* This notebook contain blocks of code, you are required to complete those blocks(where required)\n", + "* You are required to copy this notebook (\"copy to drive\" above) and complete the code.(DO NOT CHANGE THE NAME OF THE FUNCTIONS)\n", + "\n", + "\\\n", + "\\\n", + "Also, I'd like to acknowledge the Stanford CS131. This assignment is highly based on the assignments from that course." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UhSVK4RoK9q5" + }, + "source": [ + "First Let's import some dependencies" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "cCKqyfhIE-EQ" + }, + "source": [ + "# Imports the print function from newer versions of python\n", + "from __future__ import print_function\n", + "\n", + "# Setup\n", + "\n", + "# The Random module implements pseudo-random number generators\n", + "import random \n", + "\n", + "# Numpy is the main package for scientific computing with Python. \n", + "# This will be one of our most used libraries in this project\n", + "import numpy as np\n", + "\n", + "# The Time library helps us time code runtimes\n", + "import time\n", + "\n", + "\n", + "# Some more magic so that the notebook will reload external python modules;\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "%reload_ext autoreload" + ], + "execution_count": 1, + "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": "eb40b0dd-6af2-4b34-cfa9-c54e0a520ea2" + }, + "source": [ + "### YOUR CODE HERE\n", + "M = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])\n", + "a = np.array([[1,1,0]])\n", + "b = np.array([[-1],[2],[5]])\n", + "### END CODE HERE\n", + "print(\"M = \\n\", M)\n", + "print(\"The size of M is: \", M.shape)\n", + "print()\n", + "print(\"a = \", a)\n", + "print(\"The size of a is: \", a.shape)\n", + "print()\n", + "print(\"b = \", b)\n", + "print(\"The size of b is: \", b.shape)" + ], + "execution_count": 2, + "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 = None\n", + " ### YOUR CODE HERE\n", + " out = np.dot(a,b)\n", + " \n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "pbLIS5vIE-Ea", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "a5196175-9d8d-4f4d-cf35-7e16efa9f66d" + }, + "source": [ + "# Now, let's test out this dot product. Your answer should be [[1]].\n", + "aDotB = dot_product(a, b)\n", + "print(aDotB)\n", + "\n", + "print(\"The size is: \", aDotB.shape)" + ], + "execution_count": 4, + "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 = None\n", + " ### YOUR CODE HERE\n", + " a_transpose = a.T\n", + " out = np.dot(a,b)*np.dot(M,a.T)\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "da_uQQLhE-Ec", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "4c04fb6a-6a58-41ef-bf24-346927364a64" + }, + "source": [ + "# Your answer should be $[[3], [9], [15], [21]]$ of shape(4, 1).\n", + "ans = complicated_matrix_function(M, a, b)\n", + "print(ans)\n", + "print()\n", + "print(\"The size is: \", ans.shape)" + ], + "execution_count": 6, + "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": "d56ad949-d78b-4fe6-9eeb-10f041314f65" + }, + "source": [ + "M_2 = np.array(range(4)).reshape((2,2))\n", + "a_2 = np.array([[1,1]])\n", + "b_2 = np.array([[10, 10]]).T\n", + "print(M_2.shape)\n", + "print(a_2.shape)\n", + "print(b_2.shape)\n", + "print()\n", + "\n", + "# Your answer should be $[[20], [100]]$ of shape(2, 1).\n", + "ans = complicated_matrix_function(M_2, a_2, b_2)\n", + "print(ans)\n", + "print()\n", + "print(\"The size is: \", ans.shape)" + ], + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2, 2)\n", + "(1, 2)\n", + "(2, 1)\n", + "\n", + "[[ 20]\n", + " [100]]\n", + "\n", + "The size is: (2, 1)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4fHLxLl4E-Ee" + }, + "source": [ + "## Part 1.4 (10 points) [Optional/Bonus]\n", + "Implement `eigen_decomp()` and `get_eigen_values_and_vectors()` methods. In this method, perform eigenvalue decomposition on the following matrix and return the largest k eigen values and corresponding eigen vectors (k is specified in the method calls below).\n", + "\n", + "$$M = \\begin{bmatrix}\n", + "1 & 2 & 3 \\\\\n", + "4 & 5 & 6 \\\\\n", + "7 & 8 & 9 \\end{bmatrix}\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "RfaCSoRMOIc8" + }, + "source": [ + "def eigen_decomp(M):\n", + " \"\"\"Implement eigenvalue decomposition.\n", + " (optional): You might find the `np.linalg.eig` function useful.\n", + " Args:\n", + " matrix: numpy matrix of shape (m, n)\n", + " Returns:\n", + " w: numpy array of shape (m, m) such that the column v[:,i] is the eigenvector corresponding to the eigenvalue w[i].\n", + " v: Matrix where every column is an eigenvector.\n", + " \"\"\"\n", + " w = None\n", + " v = None\n", + " ### YOUR CODE HERE\n", + " w,v = np.linalg.eig(M)\n", + " pass\n", + " ### END YOUR CODE\n", + " return w, v" + ], + "execution_count": 8, + "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", + " w,v = np.linalg.eig(M)\n", + " # w is the eigen values\n", + " #v is the eigen vector\n", + " #eigen values upto top k \n", + " #abs of w\n", + " w1=[]\n", + " for item in w:\n", + " w1.append(abs(item))\n", + " x = np.argsort(w1)\n", + " eigenvalues =[] \n", + " for item in x:\n", + " eigenvalues.append(w1[item])\n", + " eigenvalues = eigenvalues[:k]\n", + " v1 = v.T\n", + " for item in x:\n", + " eigenvectors.append(v1[item])\n", + " eigenvectors=eigenvectors[:k] \n", + " pass\n", + " ### END YOUR CODE\n", + " return eigenvalues, eigenvectors" + ], + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "t0_GkrJwE-Ee", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "e4649f70-7f02-4b88-8f18-d721880b910a" + }, + "source": [ + "# Let's define M.\n", + "M = np.array([[1,2,3],[4,5,6],[7,8,9]])\n", + "\n", + "# Now let's grab the first eigenvalue and first eigenvector.\n", + "# You should get back a single eigenvalue and a single eigenvector.\n", + "val, vec = get_eigen_values_and_vectors(M[:,:3], 1)\n", + "print(\"First eigenvalue =\", val[0])\n", + "print()\n", + "print(\"First eigenvector =\", vec[0])\n", + "print()\n", + "assert len(vec) == 1\n", + "\n", + "# Now, let's get the first two eigenvalues and eigenvectors.\n", + "# You should get back a list of two eigenvalues and a list of two eigenvector arrays.\n", + "val, vec = get_eigen_values_and_vectors(M[:,:3], 2)\n", + "print(\"Eigenvalues =\", val)\n", + "print()\n", + "print(\"Eigenvectors =\", vec)\n", + "assert len(vec) == 2" + ], + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "First eigenvalue = 1.3036777264747022e-15\n", + "\n", + "First eigenvector = [ 0.40824829 -0.81649658 0.40824829]\n", + "\n", + "Eigenvalues = [1.3036777264747022e-15, 1.1168439698070427]\n", + "\n", + "Eigenvectors = [array([ 0.40824829, -0.81649658, 0.40824829]), array([-0.78583024, -0.08675134, 0.61232756])]\n" + ] + } + ] + }, + { + "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 = None\n", + " ### YOUR CODE HERE\n", + " #find the biggest element in the first row\n", + " max=M.argmax(axis=0)\n", + " M[[0,max[0]]]=M[[max[0],0]]\n", + " out=np.copy(M)\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "S8lbAUSWWpyO" + }, + "source": [ + "def apply_rows(M):\n", + " \"\"\"For each row below the pivot, calculate the factor f which makes the kth\n", + " entry zero, and for every element in the row subtract the fth multiple of the\n", + " corresponding element in the kth row.\n", + " Args:\n", + " matrix: numpy matrix of shape (m, n)\n", + " Returns:\n", + " Ms: matrix with all other entries of the pivotal col zero\n", + " \"\"\"\n", + " out = None\n", + " ### YOUR CODE HERE\n", + " f = M[:,0]/M[0,0]\n", + " f[0] = 0\n", + " # print(f*M[0,1])\n", + " out = np.copy(M)\n", + " out = out.astype('float64')\n", + " # print(M.shape[1], out.dtype)\n", + " for i in range(M.shape[1]):\n", + " out[:,i] = - f*out[0,i] + out[:,i]\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "GnE_-JLxPYz7" + }, + "source": [ + "def forward(M):\n", + " \"\"\"Return a partial ref using the algo described above\n", + " Args:\n", + " M: numpy matrix of shape (m, n).\n", + " Returns:\n", + " Ms: ref of M\n", + " \"\"\"\n", + " out = None\n", + " ### YOUR CODE HERE\n", + " if(M.shape[0] == 2):\n", + " return M\n", + " out = np.copy(M)\n", + " out = apply_rows(swap_rows(out))\n", + " out[1:,1:] = forward(out[1:,1:])\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 20, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Wb7pPGP4XmJu" + }, + "source": [ + "def backward(M):\n", + " \"\"\"Return a rref using the algo described above\n", + " Args:\n", + " M: numpy matrix of shape (m, n).\n", + " Returns:\n", + " Ms: rref of M\n", + " \"\"\"\n", + " out = None\n", + " ### YOUR CODE HERE\n", + " out = np.copy(M)\n", + " out = out.astype('float64')\n", + " k = out.shape[0] - 1\n", + " for i in range(k):\n", + " f = out[:k-i,k-i]/out[k-i,k-i]\n", + " for j in range(k-i):\n", + " out[j,:] = out[j,:] - f[j]*out[k-i,:]\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 21, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "XLq81xzXYR85" + }, + "source": [ + "def rref(M):\n", + " \"\"\"Return a rref using the algo descrbed above\n", + " Args:\n", + " M: numpy matrix of shape (m, n).\n", + " Returns:\n", + " Ms: ref of M\n", + " \"\"\"\n", + " out = None\n", + " out =np.copy(M)\n", + " out = backward(forward(M))\n", + " ### YOUR CODE HERE\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Eiz6EbsWPYz8" + }, + "source": [ + "# Let's define M.\n", + "M = np.array([[1,2,3],[4,5,6],[7,8,9]])\n", + "\n", + "# Now let's calculate it's rref.\n", + "# Note that your code may be evaluated on other test cases as well\n", + "Mrref = rref(M)\n", + "print(Mrref)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import math" + ], + "metadata": { + "id": "Tpr9DGsURXQj" + }, + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np" + ], + "metadata": { + "id": "Gm30LHaKaT3W" + }, + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "G46pyDzAE-Ef" + }, + "source": [ + "## Part 1.6 (10 points)\n", + "\n", + "To wrap up our overview of NumPy, let's implement something fun — a helper function for computing the Euclidean distance between two $n$-dimensional points!\n", + "\n", + "In the 2-dimensional case, computing the Euclidean distance reduces to solving the Pythagorean theorem $c = \\sqrt{a^2 + b^2}$. where, given two points $(x_1, y_1)$ and $(x_2, y_2)$, $a = x_1 - x_2$ and $b = y_1 - y_2$.\n", + "\n", + "\n", + "More generally, given two $n$-dimensional vectors, the Euclidean distance can be computed by:\n", + "\n", + "1. Performing an elementwise subtraction between the two vectors, to get $n$ difference values.\n", + "2. Squaring each of the $n$ difference values, and summing the squares.\n", + "4. Taking the square root of our sum.\n", + "\n", + "Alternatively, the Euclidean distance between length-$n$ vectors $u$ and $v$ can be written as:\n", + "\n", + "$\n", + "\\quad\\textbf{distance}(u, v) = \\sqrt{\\sum_{i=1}^n (u_i - v_i)^2}\n", + "$\n", + "\n", + "\n", + "Try implementing this function: first using native Python with a `for` loop in the `euclidean_distance_native()` function, then in NumPy **without any loops** in the `euclidean_distance_numpy()` function.\n", + "We've added some `assert` statements here to help you check functionality (if it prints nothing, then your implementation is correct)!" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "5xvHopPqO29C" + }, + "source": [ + "def euclidean_distance_native(u, v):\n", + " \"\"\"Computes the Euclidean distance between two vectors, represented as Python\n", + " lists.\n", + " Args:\n", + " u (List[float]): A vector, represented as a list of floats.\n", + " v (List[float]): A vector, represented as a list of floats.\n", + " Returns:\n", + " float: Euclidean distance between `u` and `v`.\n", + " \"\"\"\n", + " # First, run some checks:\n", + " assert isinstance(u, list)\n", + " assert isinstance(v, list)\n", + " assert len(u) == len(v)\n", + "\n", + " # Compute the distance!\n", + " # Notes:\n", + " # 1) Try breaking this problem down: first, we want to get\n", + " # the difference between corresponding elements in our\n", + " # input arrays. Then, we want to square these differences.\n", + " # Finally, we want to sum the squares and square root the\n", + " # sum.\n", + " out = None\n", + " ### YOUR CODE HERE\n", + " sum = 0\n", + " for i in range(len(u)):\n", + " sum = sum + (u[i]-v[i])*(u[i]-v[i])\n", + " distance = np.sqrt(sum) \n", + " out = distance\n", + " pass\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 7, + "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", + " t= np.array([u-v])\n", + " sq = np.square(t)\n", + " sum = np.sum(sq)\n", + " sqrt = np.sqrt(sum)\n", + "\n", + " ### YOUR CODE HERE\n", + " pass\n", + "\n", + " return sqrt\n", + " ### END YOUR CODE" + ], + "execution_count": 14, + "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": 13, + "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": 15, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import time" + ], + "metadata": { + "id": "Fv26gHv1a6iX" + }, + "execution_count": 17, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "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": "fb466d7a-7041-4aff-f8c5-21e615fd88ff" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Native: 2.0234971046447754 seconds\n", + "NumPy: 0.15949606895446777 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-" + } + } + ] +} diff --git a/Assignment/Assignment_1/200116_Assignment_1_part-b.ipynb b/Assignment/Assignment_1/200116_Assignment_1_part-b.ipynb new file mode 100644 index 0000000..e99b94a --- /dev/null +++ b/Assignment/Assignment_1/200116_Assignment_1_part-b.ipynb @@ -0,0 +1,1070 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Assignment_1(b).ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "resources": { + "http://localhost:8080/nbextensions/google.colab/files.js": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "application/javascript" + ] + ], + "status": 200, + "status_text": "" + } + }, + "base_uri": "https://localhost:8080/", + "height": 74 + }, + "id": "UEWw9c3VcOaZ", + "outputId": "3108adb1-f5e3-4201-bdab-4219b8dde5cf" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving House_prediction.csv to House_prediction.csv\n" + ] + } + ], + "source": [ + "from google.colab import files\n", + "upload = files.upload()" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ], + "metadata": { + "id": "czfrayq9e5nr" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "data = pd.read_csv('House_prediction.csv')" + ], + "metadata": { + "id": "WAdmNqpVfrEi" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "data.head()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "u9n5rfFpf2Ql", + "outputId": "bc38555b-931f-4454-fd6f-b374d0915643" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " city area rooms bathroom parking spaces floor animal \\\n", + "0 São Paulo 70 2 1 1 7 acept \n", + "1 São Paulo 320 4 4 0 20 acept \n", + "2 Porto Alegre 80 1 1 1 6 acept \n", + "3 Porto Alegre 51 2 1 0 2 acept \n", + "4 São Paulo 25 1 1 0 1 not acept \n", + "\n", + " furniture hoa (R$) rent amount (R$) property tax (R$) \\\n", + "0 furnished 2065 3300 211 \n", + "1 not furnished 1200 4960 1750 \n", + "2 not furnished 1000 2800 0 \n", + "3 not furnished 270 1112 22 \n", + "4 not furnished 0 800 25 \n", + "\n", + " fire insurance (R$) total (R$) \n", + "0 42 5618 \n", + "1 63 7973 \n", + "2 41 3841 \n", + "3 17 1421 \n", + "4 11 836 " + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cityarearoomsbathroomparking spacesflooranimalfurniturehoa (R$)rent amount (R$)property tax (R$)fire insurance (R$)total (R$)
0São Paulo702117aceptfurnished20653300211425618
1São Paulo32044020aceptnot furnished120049601750637973
2Porto Alegre801116aceptnot furnished100028000413841
3Porto Alegre512102aceptnot furnished270111222171421
4São Paulo251101not aceptnot furnished08002511836
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ] + }, + "metadata": {}, + "execution_count": 5 + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount('/gdrive')\n", + "%cd /gdrive" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Xrd1SSJCgURb", + "outputId": "6b4ed8f8-abb8-4696-c751-7d22cc2e6752" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /gdrive\n", + "/gdrive\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "data.head()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "ktYDUecGgwjl", + "outputId": "4812952b-c48b-42be-81e2-1ef5f8293ed4" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " city area rooms bathroom parking spaces floor animal \\\n", + "0 São Paulo 70 2 1 1 7 acept \n", + "1 São Paulo 320 4 4 0 20 acept \n", + "2 Porto Alegre 80 1 1 1 6 acept \n", + "3 Porto Alegre 51 2 1 0 2 acept \n", + "4 São Paulo 25 1 1 0 1 not acept \n", + "\n", + " furniture hoa (R$) rent amount (R$) property tax (R$) \\\n", + "0 furnished 2065 3300 211 \n", + "1 not furnished 1200 4960 1750 \n", + "2 not furnished 1000 2800 0 \n", + "3 not furnished 270 1112 22 \n", + "4 not furnished 0 800 25 \n", + "\n", + " fire insurance (R$) total (R$) \n", + "0 42 5618 \n", + "1 63 7973 \n", + "2 41 3841 \n", + "3 17 1421 \n", + "4 11 836 " + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cityarearoomsbathroomparking spacesflooranimalfurniturehoa (R$)rent amount (R$)property tax (R$)fire insurance (R$)total (R$)
0São Paulo702117aceptfurnished20653300211425618
1São Paulo32044020aceptnot furnished120049601750637973
2Porto Alegre801116aceptnot furnished100028000413841
3Porto Alegre512102aceptnot furnished270111222171421
4São Paulo251101not aceptnot furnished08002511836
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ] + }, + "metadata": {}, + "execution_count": 7 + } + ] + }, + { + "cell_type": "code", + "source": [ + "data" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 424 + }, + "id": "VzvPkAvGjcV5", + "outputId": "79e380a3-96e8-4604-b04f-c1125ce76c2b" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " city area rooms bathroom parking spaces floor animal \\\n", + "0 São Paulo 70 2 1 1 7 acept \n", + "1 São Paulo 320 4 4 0 20 acept \n", + "2 Porto Alegre 80 1 1 1 6 acept \n", + "3 Porto Alegre 51 2 1 0 2 acept \n", + "4 São Paulo 25 1 1 0 1 not acept \n", + "... ... ... ... ... ... ... ... \n", + "10687 Porto Alegre 63 2 1 1 5 not acept \n", + "10688 São Paulo 285 4 4 4 17 acept \n", + "10689 Rio de Janeiro 70 3 3 0 8 not acept \n", + "10690 Rio de Janeiro 120 2 2 2 8 acept \n", + "10691 São Paulo 80 2 1 0 - acept \n", + "\n", + " furniture hoa (R$) rent amount (R$) property tax (R$) \\\n", + "0 furnished 2065 3300 211 \n", + "1 not furnished 1200 4960 1750 \n", + "2 not furnished 1000 2800 0 \n", + "3 not furnished 270 1112 22 \n", + "4 not furnished 0 800 25 \n", + "... ... ... ... ... \n", + "10687 furnished 402 1478 24 \n", + "10688 not furnished 3100 15000 973 \n", + "10689 furnished 980 6000 332 \n", + "10690 furnished 1585 12000 279 \n", + "10691 not furnished 0 1400 165 \n", + "\n", + " fire insurance (R$) total (R$) \n", + "0 42 5618 \n", + "1 63 7973 \n", + "2 41 3841 \n", + "3 17 1421 \n", + "4 11 836 \n", + "... ... ... \n", + "10687 22 1926 \n", + "10688 191 19260 \n", + "10689 78 7390 \n", + "10690 155 14020 \n", + "10691 22 1587 \n", + "\n", + "[10692 rows x 13 columns]" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cityarearoomsbathroomparking spacesflooranimalfurniturehoa (R$)rent amount (R$)property tax (R$)fire insurance (R$)total (R$)
0São Paulo702117aceptfurnished20653300211425618
1São Paulo32044020aceptnot furnished120049601750637973
2Porto Alegre801116aceptnot furnished100028000413841
3Porto Alegre512102aceptnot furnished270111222171421
4São Paulo251101not aceptnot furnished08002511836
..........................................
10687Porto Alegre632115not aceptfurnished402147824221926
10688São Paulo28544417aceptnot furnished31001500097319119260
10689Rio de Janeiro703308not aceptfurnished9806000332787390
10690Rio de Janeiro1202228aceptfurnished15851200027915514020
10691São Paulo80210-aceptnot furnished01400165221587
\n", + "

10692 rows × 13 columns

\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ] + }, + "metadata": {}, + "execution_count": 8 + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.bar(data.city,data.floor)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + }, + "id": "veQlNxQGp2xg", + "outputId": "fbf4dfe5-034d-4a66-bd3a-9a23edb3582f" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "y = data.groupby('city')\n", + "ra_mean = data.groupby('city').mean()\n", + "print(ra_mean)\n", + "ra_mean.plot.bar()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 741 + }, + "id": "ATTf2SBuJFFo", + "outputId": "2c089cae-6889-4a78-9085-c51b58d702e8" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " area rooms bathroom parking spaces hoa (R$) \\\n", + "city \n", + "Belo Horizonte 207.411765 3.020668 2.402226 1.955485 2324.197138 \n", + "Campinas 137.561547 2.355217 1.960141 1.558030 628.922626 \n", + "Porto Alegre 103.609388 2.140821 1.725901 1.044426 491.618609 \n", + "Rio de Janeiro 105.347768 2.243837 1.756163 0.744171 1079.432378 \n", + "São Paulo 158.899439 2.558859 2.467641 1.877527 1169.627994 \n", + "\n", + " rent amount (R$) property tax (R$) fire insurance (R$) \\\n", + "city \n", + "Belo Horizonte 3664.127981 272.782194 53.675676 \n", + "Campinas 2364.290739 147.657679 32.388042 \n", + "Porto Alegre 2337.699916 124.021794 36.425817 \n", + "Rio de Janeiro 3232.904064 256.853431 42.483011 \n", + "São Paulo 4652.793783 495.701716 62.428911 \n", + "\n", + " total (R$) \n", + "city \n", + "Belo Horizonte 6315.242448 \n", + "Campinas 3173.276671 \n", + "Porto Alegre 2989.782900 \n", + "Rio de Janeiro 4611.684877 \n", + "São Paulo 6380.831833 \n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + } + ] +} diff --git a/Assignment/Assignment_2/200116_Assignment_2 .ipynb b/Assignment/Assignment_2/200116_Assignment_2 .ipynb new file mode 100644 index 0000000..df9993c --- /dev/null +++ b/Assignment/Assignment_2/200116_Assignment_2 .ipynb @@ -0,0 +1,958 @@ +{ + "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", + "execution_count": null, + "metadata": { + "id": "iXezofBIgzId" + }, + "outputs": [], + "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 heavside step activation function here (google ;))\n", + " \n", + " '''\n", + " if x >=0:\n", + " return 1\n", + " else:\n", + " return 0 \n", + " pass\n", + "\n", + " def forward(self,x: np.ndarray):\n", + " '''\n", + " you have random initialized weights and bias\n", + " you can access then using `self.weights` and `self.bias`\n", + " you should use activation function before returning\n", + " \n", + " x : input features\n", + " return : a binary value as the output of the perceptron \n", + " '''\n", + " sum = np.dot(x,self.weights)\n", + " total = sum + self.bias\n", + " # YOUR CODE HERE\n", + " pass\n", + " # YOUR CODE HERE\n", + " return self.activation(total)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "oSKwDFAyocVo" + }, + "outputs": [], + "source": [ + "np.random.seed(0)\n", + "perc = perceptron(8)\n", + "assert perc.forward(np.arange(8))==1" + ] + }, + { + "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", + "execution_count": null, + "metadata": { + "id": "9A13CEkGr7uN" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "class LinearClassifier():\n", + " def __init__(self,num_input_features=32,num_classes=5):\n", + " self.weights = np.random.randn(num_input_features,num_classes)\n", + " self.bias = np.random.rand(num_classes)\n", + "\n", + " def forward(self,x: np.ndarray):\n", + " '''\n", + " x: input features\n", + " you have random initialized weights and bias\n", + " you can access then using `self.weights` and `self.bias`\n", + " return an output vector of num_classes size\n", + " '''\n", + " # YOUR CODE HERE\n", + " z = np.dot(x,self.weights)\n", + " sum = z + self.bias\n", + " return sum\n", + " pass\n", + " # YOUR CODE HERE" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zgzPxyTsr7uN", + "outputId": "21a4587b-a478-4e6b-8ba2-3d3d3ea3afdb" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.30208164, 5.58136003, 0.87793013, -4.7332119 , 4.81172123]])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "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]])" + ] + }, + { + "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", + "execution_count": null, + "metadata": { + "id": "YxVh6IL2tuqz" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "def L1Loss(z,y):\n", + " '''\n", + " y : True output.\n", + " z : Predicted output.\n", + " return : L\n", + " '''\n", + " x = y-z\n", + " absolute = np.absolute(x)\n", + " half = (0.5)*absolute\n", + " return half\n", + " pass" + ] + }, + { + "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", + "execution_count": null, + "metadata": { + "id": "JThp5P-KcKtS" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "def L2Loss(z,y):\n", + " '''\n", + " y : True output. \n", + " z : Predicted output. \n", + " return : L\n", + " '''\n", + " x = np.square(z-y)\n", + " half = (0.5)*x\n", + " return half\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Z2JNLnWYcLSC" + }, + "source": [ + "### **Hinge Loss**\n", + "Hinge loss is: $ L = max( 0, 1 - yz ) $" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "gQ1YM4J-cLSC" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "def hingeLoss(z,y):\n", + " '''\n", + " y : True output. \n", + " z : Predicted output. \n", + " return : L\n", + " '''\n", + " x = 1-y*z\n", + " return np.maximum(0,x)\n", + "\n", + " pass" + ] + }, + { + "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", + "execution_count": null, + "metadata": { + "id": "snJLqhszdMNY" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "def CELoss(z,y):\n", + " '''\n", + " y : True output. \n", + " z : Predicted output. \n", + " return : L\n", + " '''\n", + " return -(y*np.log(z)+(1-y)*np.log(1-z))\n", + " pass" + ] + }, + { + "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", + "execution_count": null, + "metadata": { + "id": "5sA7GxLHyEVM" + }, + "outputs": [], + "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", + " return 0\n", + " else:\n", + " return 1 \n", + " pass" + ] + }, + { + "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", + "execution_count": null, + "metadata": { + "id": "SSbmhW4og97t" + }, + "outputs": [], + "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", + " ## loss_function = lossFunction[\"l1\"] = L1Loss\n", + " # loss_function = L1Loss\n", + " # YOUR CODE HERE\n", + " #5 loss values calculated for all the types that is being discussed above\n", + "\n", + " J = None\n", + " n = len(Z)\n", + "\n", + " # YOUR CODE HERE\n", + " J1 = (np.sum(np.abs(Y-Z))/n) \n", + " J2 = (np.sum(np.square(Y-Z)))/n\n", + "\n", + " J3 = np.maximum(0,1-np.dot(Y,Z))\n", + " J4 = -np.sum((Y*np.log(Z)))\n", + " if np.array_equal(Y,Z):\n", + " J5 = 0\n", + " else:\n", + " J5 =1 \n", + " return np.array([J1,J2,J3,J4,J5])\n", + " pass" + ] + }, + { + "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": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WkinaYWmN5oP", + "outputId": "f8879112-2037-4edd-d96b-46dcced64d4a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: tensorflow in /usr/local/lib/python3.7/dist-packages (2.8.0+zzzcolab20220506162203)\n", + "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (0.2.0)\n", + "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (0.25.0)\n", + "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (3.3.0)\n", + "Requirement already satisfied: tensorboard<2.9,>=2.8 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (2.8.0)\n", + "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.6.3)\n", + "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.46.1)\n", + "Requirement already satisfied: protobuf>=3.9.2 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (3.17.3)\n", + "Requirement already satisfied: gast>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (0.5.3)\n", + "Requirement already satisfied: h5py>=2.9.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (3.1.0)\n", + "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.15.0)\n", + "Requirement already satisfied: keras<2.9,>=2.8.0rc0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (2.8.0)\n", + "Requirement already satisfied: libclang>=9.0.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (14.0.1)\n", + "Requirement already satisfied: flatbuffers>=1.12 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (2.0)\n", + "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (4.2.0)\n", + "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.1.0)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from tensorflow) (57.4.0)\n", + "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.14.1)\n", + "Requirement already satisfied: absl-py>=0.4.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.0.0)\n", + "Requirement already satisfied: numpy>=1.20 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.21.6)\n", + "Requirement already satisfied: keras-preprocessing>=1.1.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.1.2)\n", + "Requirement already satisfied: tf-estimator-nightly==2.8.0.dev2021122109 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (2.8.0.dev2021122109)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.7/dist-packages (from astunparse>=1.6.0->tensorflow) (0.37.1)\n", + "Requirement already satisfied: cached-property in /usr/local/lib/python3.7/dist-packages (from h5py>=2.9.0->tensorflow) (1.5.2)\n", + "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (0.4.6)\n", + "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (1.8.1)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (3.3.7)\n", + "Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (1.0.1)\n", + "Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (0.6.1)\n", + "Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (1.35.0)\n", + "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (2.23.0)\n", + "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.9,>=2.8->tensorflow) (4.8)\n", + "Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.9,>=2.8->tensorflow) (4.2.4)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.9,>=2.8->tensorflow) (0.2.8)\n", + "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard<2.9,>=2.8->tensorflow) (1.3.1)\n", + "Requirement already satisfied: importlib-metadata>=4.4 in /usr/local/lib/python3.7/dist-packages (from markdown>=2.6.8->tensorboard<2.9,>=2.8->tensorflow) (4.11.3)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=4.4->markdown>=2.6.8->tensorboard<2.9,>=2.8->tensorflow) (3.8.0)\n", + "Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.7/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.9,>=2.8->tensorflow) (0.4.8)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard<2.9,>=2.8->tensorflow) (1.24.3)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard<2.9,>=2.8->tensorflow) (2.10)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard<2.9,>=2.8->tensorflow) (3.0.4)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard<2.9,>=2.8->tensorflow) (2021.10.8)\n", + "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard<2.9,>=2.8->tensorflow) (3.2.0)\n" + ] + } + ], + "source": [ + "!pip install tensorflow" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tKIQ9Pt_OCNT", + "outputId": "5a297205-d466-4def-b88f-3d644c390022" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9.0\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "print(tf.__version__)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sJoG5kkYopRN" + }, + "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." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 391 + }, + "id": "_4-4RceVsor_", + "outputId": "c88b141d-e206-4eda-a478-4c2423da44f2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.9.0\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\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" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yyplk5PLEUsJ", + "outputId": "f5b69cd6-5e15-4559-92be-ed8ec42c98c4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(50000, 32, 32, 3) (50000, 1) (10000, 32, 32, 3) (10000, 1)\n" + ] + } + ], + "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()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "qQhkATYhEkkC" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "'''visualize data by plotting images'''\n", + "# YOUR CODE HERE\n", + "\n", + "fig,ax = plt.subplots(5,5)\n", + "k=0\n", + "for i in range(5):\n", + " for j in range(5):\n", + " ax[i][j].imshow(x_train[k],aspect = 'auto')\n", + " k = k+1\n", + "pass\n", + "# YOUR CODE HERE" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "yJgho2AEBFbx" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of classes: 10\n", + "Model: \"model\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " input_1 (InputLayer) [(None, 32, 32, 3)] 0 \n", + " \n", + " conv2d (Conv2D) (None, 32, 32, 32) 896 \n", + " \n", + " batch_normalization (BatchN (None, 32, 32, 32) 128 \n", + " ormalization) \n", + " \n", + " conv2d_1 (Conv2D) (None, 32, 32, 32) 9248 \n", + " \n", + " batch_normalization_1 (Batc (None, 32, 32, 32) 128 \n", + " hNormalization) \n", + " \n", + " max_pooling2d (MaxPooling2D (None, 16, 16, 32) 0 \n", + " ) \n", + " \n", + " conv2d_2 (Conv2D) (None, 16, 16, 64) 18496 \n", + " \n", + " batch_normalization_2 (Batc (None, 16, 16, 64) 256 \n", + " hNormalization) \n", + " \n", + " conv2d_3 (Conv2D) (None, 16, 16, 64) 36928 \n", + " \n", + " batch_normalization_3 (Batc (None, 16, 16, 64) 256 \n", + " hNormalization) \n", + " \n", + " max_pooling2d_1 (MaxPooling (None, 8, 8, 64) 0 \n", + " 2D) \n", + " \n", + " conv2d_4 (Conv2D) (None, 8, 8, 128) 73856 \n", + " \n", + " batch_normalization_4 (Batc (None, 8, 8, 128) 512 \n", + " hNormalization) \n", + " \n", + " conv2d_5 (Conv2D) (None, 8, 8, 128) 147584 \n", + " \n", + " batch_normalization_5 (Batc (None, 8, 8, 128) 512 \n", + " hNormalization) \n", + " \n", + " max_pooling2d_2 (MaxPooling (None, 4, 4, 128) 0 \n", + " 2D) \n", + " \n", + " flatten (Flatten) (None, 2048) 0 \n", + " \n", + " dropout (Dropout) (None, 2048) 0 \n", + " \n", + " dense (Dense) (None, 1024) 2098176 \n", + " \n", + " dropout_1 (Dropout) (None, 1024) 0 \n", + " \n", + " dense_1 (Dense) (None, 10) 10250 \n", + " \n", + "=================================================================\n", + "Total params: 2,397,226\n", + "Trainable params: 2,396,330\n", + "Non-trainable params: 896\n", + "_________________________________________________________________\n" + ] + } + ], + "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", + "i = Input(shape=x_train[0].shape)\n", + "x = Conv2D(32, (3, 3), activation='relu', padding='same')(i)\n", + "x = BatchNormalization()(x)\n", + "x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)\n", + "x = BatchNormalization()(x)\n", + "x = MaxPooling2D((2, 2))(x)\n", + " \n", + "x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)\n", + "x = BatchNormalization()(x)\n", + "x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)\n", + "x = BatchNormalization()(x)\n", + "x = MaxPooling2D((2, 2))(x)\n", + " \n", + "x = Conv2D(128, (3, 3), activation='relu', padding='same')(x)\n", + "x = BatchNormalization()(x)\n", + "x = Conv2D(128, (3, 3), activation='relu', padding='same')(x)\n", + "x = BatchNormalization()(x)\n", + "x = MaxPooling2D((2, 2))(x)\n", + " \n", + "x = Flatten()(x)\n", + "x = Dropout(0.2)(x)\n", + " \n", + "'''Hidden layer'''\n", + "# YOUR CODE HERE\n", + "x = Dense(1024, activation='relu')(x)\n", + "x = Dropout(0.2)(x)\n", + "pass\n", + "# YOUR CODE HERE\n", + " \n", + "\"\"\"last hidden layer i.e.. output layer\"\"\"\n", + "# YOUR CODE HERE\n", + "x = Dense(K, activation='softmax')(x)\n", + " \n", + "model = Model(i, x)\n", + "pass\n", + "# YOUR CODE HERE\n", + " \n", + " \n", + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "PLc4Bay65TyA" + }, + "outputs": [], + "source": [ + "# Compile\n", + "\n", + "model.compile(optimizer='adam',\n", + " loss='sparse_categorical_crossentropy',\n", + " metrics=['accuracy'])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "id": "U0fGsDCRsQrn" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/5\n", + "1563/1563 [==============================] - 324s 207ms/step - loss: 0.7545 - accuracy: 0.7378 - val_loss: 1.0737 - val_accuracy: 0.6521\n", + "Epoch 2/5\n", + "1563/1563 [==============================] - 299s 191ms/step - loss: 0.6244 - accuracy: 0.7849 - val_loss: 1.0606 - val_accuracy: 0.6862\n", + "Epoch 3/5\n", + "1563/1563 [==============================] - 319s 204ms/step - loss: 0.5358 - accuracy: 0.8168 - val_loss: 0.6267 - val_accuracy: 0.7903\n", + "Epoch 4/5\n", + "1563/1563 [==============================] - 284s 182ms/step - loss: 0.4494 - accuracy: 0.8448 - val_loss: 0.6114 - val_accuracy: 0.8054\n", + "Epoch 5/5\n", + "1563/1563 [==============================] - 283s 181ms/step - loss: 0.3793 - accuracy: 0.8703 - val_loss: 0.6583 - val_accuracy: 0.7950\n" + ] + } + ], + "source": [ + "# Fit\n", + "\n", + "r = model.fit(\n", + " x_train, y_train, validation_data=(x_test, y_test), epochs=5)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "id": "RDq_RE6osSh8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1/1 [==============================] - 1s 826ms/step\n", + "Original label is cat and predicted label is cat\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "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": { + "colab": { + "collapsed_sections": [], + "name": "Assignment_2.ipynb", + "provenance": [] + }, + "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.1" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Assignment/Assignment_3/200116_Assignment-3-.ipynb b/Assignment/Assignment_3/200116_Assignment-3-.ipynb new file mode 100644 index 0000000..57bf56d --- /dev/null +++ b/Assignment/Assignment_3/200116_Assignment-3-.ipynb @@ -0,0 +1,203 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 10, + "id": "1b1a4fd0", + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import absolute_import, division, print_function\n", + "\n", + "\n", + "import tensorflow as tf\n", + "from tensorflow.keras import Model, layers\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e557e972", + "metadata": {}, + "outputs": [], + "source": [ + "# MNIST dataset parameters.\n", + "\n", + "num_classes = 10 # total classes (0-9 digits).\n", + "num_features = 784 # data features (img shape: 28*28).\n", + "\n", + "# Training Parameters\n", + "\n", + "learning_rate = 0.001\n", + "training_steps = 1000\n", + "batch_size = 32\n", + "display_step = 100\n", + "\n", + "# Network Parameters\n", + "\n", + "num_input = 28 # number of sequences.\n", + "timesteps = 28 # timesteps.\n", + "num_units = 32 # number of neurons for the LSTM layer." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3e678d5e", + "metadata": {}, + "outputs": [], + "source": [ + "# Prepare MNIST data.\n", + "\n", + "from tensorflow.keras.datasets import mnist\n", + "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n", + "\n", + "\n", + "x_train, x_test = np.array(x_train, np.float32), np.array(x_test, np.float32)\n", + "\n", + "x_train, x_test = x_train.reshape([-1, 28, 28]), x_test.reshape([-1, num_features])\n", + "\n", + "x_train, x_test = x_train / 255., x_test / 255." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "41a77463", + "metadata": {}, + "outputs": [], + "source": [ + "class LSTM(Model):\n", + " # Set layers.\n", + " def __init__(self):\n", + " super(LSTM, self).__init__()\n", + " # RNN (LSTM) hidden layer.\n", + " self.lstm_layer = layers.LSTM(units=num_units)\n", + " self.out = layers.Dense(num_classes)\n", + "\n", + " # Set forward pass.\n", + " def call(self, x, is_training=False):\n", + " # LSTM layer.\n", + " x = self.lstm_layer(x)\n", + " \n", + " x = self.out(x) # Output layer (num_classes).\n", + " if not is_training:\n", + " x = tf.nn.softmax(x) # apply softmax when not training.\n", + " return x\n", + "\n", + "# Build LSTM model.\n", + "lstm_net = LSTM()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a75e185d", + "metadata": {}, + "outputs": [], + "source": [ + "# Cross-Entropy Loss.\n", + "#apply 'softmax' to the logits.\n", + "def cross_entropy_loss(x, y):\n", + " # Convert labels to int 64 for tf cross-entropy function.\n", + " y = tf.cast(y, tf.int64)\n", + " # Apply softmax to logits and compute cross-entropy.\n", + " loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=x)\n", + " # Average loss across the batch.\n", + " return tf.reduce_mean(loss)\n", + "\n", + "# Accuracy metric.\n", + "def accuracy(y_pred, y_true):\n", + " # Predicted class is the index of highest score in prediction vector (i.e. argmax).\n", + " correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.cast(y_true, tf.int64))\n", + " return tf.reduce_mean(tf.cast(correct_prediction, tf.float32), axis=-1)\n", + "\n", + "# Adam optimizer.\n", + "optimizer = tf.optimizers.Adam(learning_rate)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "ff44c276", + "metadata": {}, + "outputs": [], + "source": [ + "def run_optimization(x, y):\n", + " \n", + " with tf.GradientTape() as g:\n", + " # Forward pass.\n", + " pred = lstm_net(x, is_training=True)\n", + " # Compute loss.\n", + " loss = cross_entropy_loss(pred, y)\n", + " \n", + " # Variables to update\n", + " trainable_variables = lstm_net.trainable_variables\n", + "\n", + " # Compute gradients.\n", + " gradients = g.gradient(loss, trainable_variables)\n", + " \n", + " # Update weights following gradients.\n", + " optimizer.apply_gradients(zip(gradients, trainable_variables))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b0ea2b4d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step: 100, loss: 1.833434, accuracy: 0.437500\n", + "step: 200, loss: 1.234630, accuracy: 0.593750\n", + "step: 300, loss: 1.141386, accuracy: 0.593750\n", + "step: 400, loss: 0.810610, accuracy: 0.781250\n", + "step: 500, loss: 0.365388, accuracy: 0.968750\n", + "step: 600, loss: 0.417440, accuracy: 0.875000\n", + "step: 700, loss: 0.364808, accuracy: 0.875000\n", + "step: 800, loss: 0.606892, accuracy: 0.843750\n", + "step: 900, loss: 0.481163, accuracy: 0.875000\n", + "step: 1000, loss: 0.138344, accuracy: 0.968750\n" + ] + } + ], + "source": [ + "# Run training for the given number of steps.\n", + "for step, (batch_x, batch_y) in enumerate(train_data.take(training_steps), 1):\n", + " # Run the optimization to update W and b values.\n", + " run_optimization(batch_x, batch_y)\n", + " \n", + " if step % display_step == 0:\n", + " pred = lstm_net(batch_x, is_training=True)\n", + " loss = cross_entropy_loss(pred, batch_y)\n", + " acc = accuracy(pred, batch_y)\n", + " print(\"step: %i, loss: %f, accuracy: %f\" % (step, loss, acc))" + ] + } + ], + "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.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Assignment/Assignment_3/200116_Assignment_3.ipynb b/Assignment/Assignment_3/200116_Assignment_3.ipynb new file mode 100644 index 0000000..8f23433 --- /dev/null +++ b/Assignment/Assignment_3/200116_Assignment_3.ipynb @@ -0,0 +1,214 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "1b1a4fd0", + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import absolute_import, division, print_function\n", + "\n", + "\n", + "import tensorflow as tf\n", + "from tensorflow.keras import Model, layers\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e557e972", + "metadata": {}, + "outputs": [], + "source": [ + "# MNIST dataset parameters.\n", + "\n", + "num_classes = 10 # total classes (0-9 digits).\n", + "num_features = 784 # data features (img shape: 28*28).\n", + "\n", + "# Training Parameters\n", + "\n", + "learning_rate = 0.001\n", + "training_steps = 1000\n", + "batch_size = 32\n", + "display_step = 100\n", + "\n", + "# Network Parameters\n", + "\n", + "num_input = 28 # number of sequences.\n", + "timesteps = 28 # timesteps.\n", + "num_units = 32 # number of neurons for the LSTM layer." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3e678d5e", + "metadata": {}, + "outputs": [], + "source": [ + "# Prepare MNIST data.\n", + "\n", + "from tensorflow.keras.datasets import mnist\n", + "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n", + "\n", + "\n", + "x_train, x_test = np.array(x_train, np.float32), np.array(x_test, np.float32)\n", + "\n", + "x_train, x_test = x_train.reshape([-1, 28, 28]), x_test.reshape([-1, num_features])\n", + "\n", + "x_train, x_test = x_train / 255., x_test / 255." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "72244e83", + "metadata": {}, + "outputs": [], + "source": [ + "train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))\n", + "train_data = train_data.repeat().shuffle(5000).batch(batch_size).prefetch(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "41a77463", + "metadata": {}, + "outputs": [], + "source": [ + "class LSTM(Model):\n", + " # Set layers.\n", + " def __init__(self):\n", + " super(LSTM, self).__init__()\n", + " # RNN (LSTM) hidden layer.\n", + " self.lstm_layer = layers.LSTM(units=num_units)\n", + " self.out = layers.Dense(num_classes)\n", + "\n", + " # Set forward pass.\n", + " def call(self, x, is_training=False):\n", + " # LSTM layer.\n", + " x = self.lstm_layer(x)\n", + " \n", + " x = self.out(x) # Output layer (num_classes).\n", + " if not is_training:\n", + " x = tf.nn.softmax(x) # apply softmax when not training.\n", + " return x\n", + "\n", + "# Build LSTM model.\n", + "lstm_net = LSTM()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a75e185d", + "metadata": {}, + "outputs": [], + "source": [ + "# Cross-Entropy Loss.\n", + "#apply 'softmax' to the logits.\n", + "def cross_entropy_loss(x, y):\n", + " # Convert labels to int 64 for tf cross-entropy function.\n", + " y = tf.cast(y, tf.int64)\n", + " # Apply softmax to logits and compute cross-entropy.\n", + " loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=x)\n", + " # Average loss across the batch.\n", + " return tf.reduce_mean(loss)\n", + "\n", + "# Accuracy metric.\n", + "def accuracy(y_pred, y_true):\n", + " # Predicted class is the index of highest score in prediction vector (i.e. argmax).\n", + " correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.cast(y_true, tf.int64))\n", + " return tf.reduce_mean(tf.cast(correct_prediction, tf.float32), axis=-1)\n", + "\n", + "# Adam optimizer.\n", + "optimizer = tf.optimizers.Adam(learning_rate)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ff44c276", + "metadata": {}, + "outputs": [], + "source": [ + "def run_optimization(x, y):\n", + " \n", + " with tf.GradientTape() as g:\n", + " # Forward pass.\n", + " pred = lstm_net(x, is_training=True)\n", + " # Compute loss.\n", + " loss = cross_entropy_loss(pred, y)\n", + " \n", + " # Variables to update\n", + " trainable_variables = lstm_net.trainable_variables\n", + "\n", + " # Compute gradients.\n", + " gradients = g.gradient(loss, trainable_variables)\n", + " \n", + " # Update weights following gradients.\n", + " optimizer.apply_gradients(zip(gradients, trainable_variables))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b0ea2b4d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step: 100, loss: 1.600718, accuracy: 0.468750\n", + "step: 200, loss: 1.133524, accuracy: 0.625000\n", + "step: 300, loss: 0.781146, accuracy: 0.687500\n", + "step: 400, loss: 0.829619, accuracy: 0.718750\n", + "step: 500, loss: 0.469743, accuracy: 0.937500\n", + "step: 600, loss: 0.508694, accuracy: 0.843750\n", + "step: 700, loss: 0.281780, accuracy: 0.968750\n", + "step: 800, loss: 0.365150, accuracy: 0.843750\n", + "step: 900, loss: 0.371186, accuracy: 0.906250\n", + "step: 1000, loss: 0.160734, accuracy: 0.968750\n" + ] + } + ], + "source": [ + "# Run training for the given number of steps.\n", + "for step, (batch_x, batch_y) in enumerate(train_data.take(training_steps), 1):\n", + " # Run the optimization to update W and b values.\n", + " run_optimization(batch_x, batch_y)\n", + " \n", + " if step % display_step == 0:\n", + " pred = lstm_net(batch_x, is_training=True)\n", + " loss = cross_entropy_loss(pred, batch_y)\n", + " acc = accuracy(pred, batch_y)\n", + " print(\"step: %i, loss: %f, accuracy: %f\" % (step, loss, acc))" + ] + } + ], + "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.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}