From 309c9f660dffa36a62b0605a24c9ee7168c8af56 Mon Sep 17 00:00:00 2001 From: GigabyteZ Date: Tue, 17 May 2022 23:50:13 +0530 Subject: [PATCH 1/4] Assignment-1_210369 --- ...ssignment-1_210369_EmaadAhmed_Part 1.ipynb | 903 ++++++++++++++++++ ...ignment-1_210369_EmaadAhmed_Part 2&3.ipynb | 501 ++++++++++ 2 files changed, 1404 insertions(+) create mode 100644 Assignment/Assignment_1/Assignment-1_210369_EmaadAhmed_Part 1.ipynb create mode 100644 Assignment/Assignment_1/Assignment-1_210369_EmaadAhmed_Part 2&3.ipynb diff --git a/Assignment/Assignment_1/Assignment-1_210369_EmaadAhmed_Part 1.ipynb b/Assignment/Assignment_1/Assignment-1_210369_EmaadAhmed_Part 1.ipynb new file mode 100644 index 0000000..962944b --- /dev/null +++ b/Assignment/Assignment_1/Assignment-1_210369_EmaadAhmed_Part 1.ipynb @@ -0,0 +1,903 @@ +{ + "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.(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": "a70877a7-5356-4e2a-e4b3-3e9cfc59308e" + }, + "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]]).T\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", + " \n", + " ### YOUR CODE HERE\n", + " out = np.dot(a,b)\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": "b4ba02ba-3a6a-4473-d1b5-12540cefacba" + }, + "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": 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", + " \n", + " ### YOUR CODE HERE\n", + " out = dot_product(a,b)*dot_product(M,a.T)\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": "02b1ad04-2f08-485d-aab2-036795a3c682" + }, + "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": 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": "8c69e1db-9570-439c-e8cc-e682e8d9048e" + }, + "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": 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", + " \n", + " ### YOUR CODE HERE\n", + " v,w = np.linalg.eig(M)\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", + " \n", + " ### YOUR CODE HERE\n", + " u,w = eigen_decomp(M)\n", + " f_u = u.flatten()\n", + " f_w = w.flatten()\n", + " eigenvalues = np.argsort(f_u)[::-1][:k]\n", + " eigenvectors = np.argsort(f_w)[::-1][:k]\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/" + }, + "outputId": "04e91358-c44a-4e5c-ba67-79a752e85be8" + }, + "source": [ + "# Let's define M.\n", + "M = np.array([[1,2,3],[4,5,6],[7,8,9]])\n", + "\n", + "# Now let's grab the first eigenvalue and first eigenvector.\n", + "# You should get back a single eigenvalue and a single eigenvector.\n", + "val, vec = get_eigen_values_and_vectors(M[:,:3], 1)\n", + "print(\"First eigenvalue =\", val[0])\n", + "print()\n", + "print(\"First eigenvector =\", vec[0])\n", + "print()\n", + "assert len(vec) == 1\n", + "\n", + "# Now, let's get the first two eigenvalues and eigenvectors.\n", + "# You should get back a list of two eigenvalues and a list of two eigenvector arrays.\n", + "val, vec = get_eigen_values_and_vectors(M[:,:3], 2)\n", + "print(\"Eigenvalues =\", val)\n", + "print()\n", + "print(\"Eigenvectors =\", vec)\n", + "assert len(vec) == 2" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "First eigenvalue = 7\n", + "\n", + "First eigenvector = 0\n", + "\n", + "Eigenvalues = [7 2]\n", + "\n", + "Eigenvectors = [0 2]\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", + " \n", + " ### YOUR CODE HERE\n", + " n = len(M)\n", + " for i in range(0,n-1):\n", + " max_index = np.argmax(M, axis=0)\n", + " M[[max_index[0],0],:] = M[[0,max_index[0]],:] \n", + " out = M\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 25, + "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", + " \n", + " ### YOUR CODE HERE\n", + " n = len(M)\n", + " for k in range(0,n-1):\n", + " for i in range(k+1,n):\n", + " ratio = M[i,k]/M[k,k]\n", + " for j in range(k,n-1):\n", + " M[i,k] -= ratio*M[k,j]\n", + " out = M\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 26, + "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", + " \n", + " ### YOUR CODE HERE\n", + " for i in range(0,n-1):\n", + " for j in range(0,n-1):\n", + " while i > j and M[i,j] != 0:\n", + " apply_rows(M)\n", + " out = M\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 31, + "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", + " ### YOUR CODE HERE\n", + " for k in range(0,n-1):\n", + " for i in range(k+1,n):\n", + " ratio = M[k,i]/M[k,k]\n", + " for j in range(k,n-1):\n", + " M[k,i] -= ratio*M[j,k]\n", + "\n", + " out = M\n", + "\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 28, + "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", + " ### YOUR CODE HERE\n", + " swap_rows(M)\n", + " forward(M)\n", + " backward(M)\n", + " out = M\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": 33, + "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", + "\n", + "Mrref = rref(M)\n", + "print(Mrref)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "G46pyDzAE-Ef" + }, + "source": [ + "## Part 1.6 (10 points)\n", + "\n", + "To wrap up our overview of NumPy, let's implement something fun — a helper function for computing the Euclidean distance between two $n$-dimensional points!\n", + "\n", + "In the 2-dimensional case, computing the Euclidean distance reduces to solving the Pythagorean theorem $c = \\sqrt{a^2 + b^2}$. where, given two points $(x_1, y_1)$ and $(x_2, y_2)$, $a = x_1 - x_2$ and $b = y_1 - y_2$.\n", + "\n", + "\n", + "More generally, given two $n$-dimensional vectors, the Euclidean distance can be computed by:\n", + "\n", + "1. Performing an elementwise subtraction between the two vectors, to get $n$ difference values.\n", + "2. Squaring each of the $n$ difference values, and summing the squares.\n", + "4. Taking the square root of our sum.\n", + "\n", + "Alternatively, the Euclidean distance between length-$n$ vectors $u$ and $v$ can be written as:\n", + "\n", + "$\n", + "\\quad\\textbf{distance}(u, v) = \\sqrt{\\sum_{i=1}^n (u_i - v_i)^2}\n", + "$\n", + "\n", + "\n", + "Try implementing this function: first using native Python with a `for` loop in the `euclidean_distance_native()` function, then in NumPy **without any loops** in the `euclidean_distance_numpy()` function.\n", + "We've added some `assert` statements here to help you check functionality (if it prints nothing, then your implementation is correct)!" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "5xvHopPqO29C" + }, + "source": [ + "def euclidean_distance_native(u, v):\n", + " \"\"\"Computes the Euclidean distance between two vectors, represented as Python\n", + " lists.\n", + " Args:\n", + " u (List[float]): A vector, represented as a list of floats.\n", + " v (List[float]): A vector, represented as a list of floats.\n", + " Returns:\n", + " float: Euclidean distance between `u` and `v`.\n", + " \"\"\"\n", + " # First, run some checks:\n", + " assert isinstance(u, list)\n", + " assert isinstance(v, list)\n", + " assert len(u) == len(v)\n", + "\n", + " # Compute the distance!\n", + " # Notes:\n", + " # 1) Try breaking this problem down: first, we want to get\n", + " # the difference between corresponding elements in our\n", + " # input arrays. Then, we want to square these differences.\n", + " # Finally, we want to sum the squares and square root the\n", + " # sum.\n", + " out = None\n", + " ### YOUR CODE HERE\n", + " sq =[(m-n)**2 for m,n in zip(u,v)]\n", + " out = sum(sq)**.5\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": null, + "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", + " out = np.sqrt(np.sum(np.square(u-v)))\n", + " ### END YOUR CODE\n", + " return out" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "wu9MimVJE-Eg" + }, + "source": [ + "## Testing native Python function\n", + "assert euclidean_distance_native([7.0], [6.0]) == 1.0\n", + "assert euclidean_distance_native([7.0, 0.0], [3.0, 3.0]) == 5.0\n", + "assert euclidean_distance_native([7.0, 0.0, 0.0], [3.0, 0.0, 3.0]) == 5.0" + ], + "execution_count": null, + "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": null, + "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": "26fcdb30-4750-42a2-90f4-3487d4d6212a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Native: 1.3555653095245361 seconds\n", + "NumPy: 0.10069656372070312 seconds\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Mjik4mQXE-Ek" + }, + "source": [ + "Next, let's take a look at how these two implementations compare in terms of runtime:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "t4e6MfhHE-Em" + }, + "source": [ + "As you can see, doing vectorized calculations (i.e. no for loops) with NumPy results in significantly faster computations! " + ] + }, + { + "cell_type": "markdown", + "source": [ + "Congrats You've come to the end of this notebook. If you solved everything above, impressive. If not, you might need to read/think a bit more. You can always ask doubts. Also, Note that you should submit it even if you cannot solve everything. We might evaluate these using a script later." + ], + "metadata": { + "id": "XvFE0Q5bhx6-" + } + } + ] +} \ No newline at end of file diff --git a/Assignment/Assignment_1/Assignment-1_210369_EmaadAhmed_Part 2&3.ipynb b/Assignment/Assignment_1/Assignment-1_210369_EmaadAhmed_Part 2&3.ipynb new file mode 100644 index 0000000..2ff27bd --- /dev/null +++ b/Assignment/Assignment_1/Assignment-1_210369_EmaadAhmed_Part 2&3.ipynb @@ -0,0 +1,501 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "id": "a0cd5815-3993-481e-a2a7-f1f13adffdc8", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting matplotlib\n", + " Downloading matplotlib-3.5.1-cp310-cp310-win_amd64.whl (7.2 MB)\n", + "Collecting cycler>=0.10\n", + " Downloading cycler-0.11.0-py3-none-any.whl (6.4 kB)\n", + "Requirement already satisfied: numpy>=1.17 in c:\\users\\emaad\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.10_qbz5n2kfra8p0\\localcache\\local-packages\\python310\\site-packages (from matplotlib) (1.22.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in c:\\users\\emaad\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.10_qbz5n2kfra8p0\\localcache\\local-packages\\python310\\site-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: pyparsing>=2.2.1 in c:\\users\\emaad\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.10_qbz5n2kfra8p0\\localcache\\local-packages\\python310\\site-packages (from matplotlib) (3.0.7)\n", + "Requirement already satisfied: packaging>=20.0 in c:\\users\\emaad\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.10_qbz5n2kfra8p0\\localcache\\local-packages\\python310\\site-packages (from matplotlib) (21.3)\n", + "Collecting pillow>=6.2.0\n", + " Downloading Pillow-9.1.0-cp310-cp310-win_amd64.whl (3.3 MB)\n", + "Collecting kiwisolver>=1.0.1\n", + " Downloading kiwisolver-1.4.2-cp310-cp310-win_amd64.whl (55 kB)\n", + "Collecting fonttools>=4.22.0\n", + " Downloading fonttools-4.33.3-py3-none-any.whl (930 kB)\n", + "Requirement already satisfied: six>=1.5 in c:\\users\\emaad\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.10_qbz5n2kfra8p0\\localcache\\local-packages\\python310\\site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n", + "Installing collected packages: pillow, kiwisolver, fonttools, cycler, matplotlib\n", + "Successfully installed cycler-0.11.0 fonttools-4.33.3 kiwisolver-1.4.2 matplotlib-3.5.1 pillow-9.1.0\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: You are using pip version 21.3.1; however, version 22.0.4 is available.\n", + "You should consider upgrading via the 'C:\\Users\\emaad\\AppData\\Local\\Microsoft\\WindowsApps\\PythonSoftwareFoundation.Python.3.10_qbz5n2kfra8p0\\python.exe -m pip install --upgrade pip' command.\n" + ] + } + ], + "source": [ + "pip install matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "id": "e9e08219-85d8-43ba-9ed9-c50ce7a8b030", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c393969b-6198-49c8-b694-9cc56e8cff4e", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 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]\n" + ] + } + ], + "source": [ + "df = pd.read_csv('House_prediction.csv')\n", + "print(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "id": "677901c0-d9d5-4da4-af82-189f2e270248", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 142, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df2 = df.set_index('city')\n", + "df2 = df2.replace(\"-\",0)\n", + "df2['floor'] = df2['floor'].astype(int)\n", + "#df_sp = df2.loc[\"São Paulo\",[\"rooms\",\"area\",\"floor\",\"parking spaces\",\"property tax (R$)\",\"bathroom\",\"rent amount (R$)\",\"fire insurance (R$)\",\"property tax (R$)\",\"total (R$)\"]]\n", + "df2_sp = df2.loc[\"São Paulo\",~df2.columns.isin(['animal', 'furniture','rooms','floor','bathroom','parking spaces'])]\n", + "df2_sp_rem = df2.loc[\"São Paulo\",[\"rooms\",\"floor\",\"parking spaces\",\"bathroom\"]]\n", + "df2_sp.mean(numeric_only=True).plot(kind ='bar',ylim=(0,6500), title = \"São Paulo\")" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "id": "e6ae15f2-65ee-45f3-a7d5-3f614be68808", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 143, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df2_sp_rem.mean(numeric_only=True).plot(kind ='bar',ylim =(0,10),title = \"São Paulo\")" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "id": "16880aef-8a04-4c73-93ea-8fe83112dc77", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 144, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df2_pa = df2.loc[\"Porto Alegre\",~df2.columns.isin(['animal', 'furniture','rooms','floor','bathroom','parking spaces'])]\n", + "df2_pa_rem = df2.loc[\"Porto Alegre\",[\"rooms\",\"floor\",\"parking spaces\",\"bathroom\"]]\n", + "df2_pa.mean(numeric_only=True).plot(kind ='bar',ylim=(0,6500),title = \"Porto Alegre\")" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "id": "56dd9faf-a963-46ac-b1da-bbce1fced4e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 145, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df2_pa_rem.mean(numeric_only=True).plot(kind ='bar',ylim =(0,10),title = \"Porto Alegre\")" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "id": "f64fbc21-e115-49b3-b064-7b2c9c00cae9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 146, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df2_rdj = df2.loc[\"Rio de Janeiro\",~df2.columns.isin(['animal', 'furniture','rooms','floor','bathroom','parking spaces'])]\n", + "df2_rdj_rem = df2.loc[\"Rio de Janeiro\",[\"rooms\",\"floor\",\"parking spaces\",\"bathroom\"]]\n", + "df2_rdj.mean(numeric_only=True).plot(kind ='bar',ylim=(0,6500),title = \"Rio de Janeiro\")" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "id": "03e8e718-2df9-4f08-a371-0b229bea6da0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 147, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df2_rdj_rem.mean(numeric_only=True).plot(kind ='bar',ylim =(0,10),title = \"Rio de Janeiro\")" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "id": "5408b998-a617-4ef5-8292-d7a6928178e9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 148, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df2_ca = df2.loc[\"Campinas\",~df2.columns.isin(['animal', 'furniture','rooms','floor','bathroom','parking spaces'])]\n", + "df2_ca_rem = df2.loc[\"Campinas\",[\"rooms\",\"floor\",\"parking spaces\",\"bathroom\"]]\n", + "df2_ca.mean(numeric_only=True).plot(kind ='bar',ylim=(0,6500),title = \"Campinas\")" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "id": "f8dee1e6-5dc7-40e0-a249-b320c475e02f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 149, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df2_ca_rem.mean(numeric_only=True).plot(kind ='bar',ylim =(0,10),title = \"Campinas\")" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "24e9690c-9b3a-40dc-b5c7-756533e99f58", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 139, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df2_bh = df2.loc[\"Belo Horizonte\",~df2.columns.isin(['animal', 'furniture','rooms','floor','bathroom','parking spaces'])]\n", + "df2_bh_rem = df2.loc[\"Belo Horizonte\",[\"rooms\",\"floor\",\"parking spaces\",\"bathroom\"]]\n", + "df2_bh.mean(numeric_only=True).plot(kind ='bar',ylim=(0,6500),title = \"Belo Horizonte\")" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "id": "dc607259-9127-4360-a8f3-206246eb7797", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 150, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df2_bh_rem.mean(numeric_only=True).plot(kind ='bar',ylim =(0,10),title = \"Belo Horizonte\")" + ] + }, + { + "cell_type": "markdown", + "id": "23063ca9-24a0-4f8c-a93b-6eb466ddc73a", + "metadata": {}, + "source": [ + "As it is evident from the graphs and data above the hoa, fire insurance and property tax is closely related to the rent amount and area of housing offered which is pretty obvious. Another factor which is affecting these three is the number of parking spaces, rooms and bathrooms available, number of floors suprisingly have less effect on these factors." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 16f8f794626f921c1d191321c979015a5183061d Mon Sep 17 00:00:00 2001 From: GigabyteZ <95098507+GigabyteZX1@users.noreply.github.com> Date: Tue, 24 May 2022 16:27:29 +0530 Subject: [PATCH 2/4] Assignment-2_210369 --- .../Assignment_2_210369_Emaad_Ahmed.ipynb | 838 ++++++++++++++++++ 1 file changed, 838 insertions(+) create mode 100644 Assignment/Assignment_2/Assignment_2_210369_Emaad_Ahmed.ipynb diff --git a/Assignment/Assignment_2/Assignment_2_210369_Emaad_Ahmed.ipynb b/Assignment/Assignment_2/Assignment_2_210369_Emaad_Ahmed.ipynb new file mode 100644 index 0000000..6c2738c --- /dev/null +++ b/Assignment/Assignment_2/Assignment_2_210369_Emaad_Ahmed.ipynb @@ -0,0 +1,838 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Assignment-2_210369_Emaad Ahmed.ipynb", + "provenance": [], + "collapsed_sections": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "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 heavside step activation function here (google ;))\n", + " '''\n", + " if x >= 0:\n", + " return 1\n", + " else:\n", + " return 0\n", + " \n", + "\n", + " def forward(self,x: np.ndarray):\n", + "\n", + " '''\n", + " you have random initialized weights and bias\n", + " you can access then using `self.weights` and `self.bias`\n", + " you should use activation function before returning\n", + " \n", + " x : input features\n", + " return : a binary value as the output of the perceptron \n", + " '''\n", + " # YOUR CODE HERE\n", + " \n", + " a = (np.dot(self.weights , x) + self.bias)\n", + " out = self.activation(a)\n", + " return out\n", + " \n", + " # YOUR CODE HERE " + ], + "execution_count": 34, + "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": 35, + "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 (#classes, #features).\n", + "\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_classes,num_input_features)\n", + " self.bias = np.random.rand(num_classes,1)\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", + " out = np.dot(self.weights, x) + self.bias\n", + " return out\n", + " # YOUR CODE HERE" + ], + "execution_count": 15, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "zgzPxyTsr7uN", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "96e7b2d4-bc2c-4fa4-e563-2dc2d02e73e7" + }, + "source": [ + "np.random.seed(0)\n", + "lc = LinearClassifier()\n", + "lc.forward(np.random.rand(32,1))\n", + "# Should be close to:\n", + "# array([[ 7.07730669],\n", + " # [-10.24067722],\n", + " # [ 0.75398702],\n", + " # [ 9.8019519 ],\n", + " # [ 2.36684038]])" + ], + "execution_count": 16, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 7.07730669],\n", + " [-10.24067722],\n", + " [ 0.75398702],\n", + " [ 9.8019519 ],\n", + " [ 2.36684038]])" + ] + }, + "metadata": {}, + "execution_count": 16 + } + ] + }, + { + "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 = abs(y,z)/2\n", + " return L" + ], + "execution_count": 23, + "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 = (y-z)**2/2\n", + " return L" + ], + "execution_count": 24, + "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" + ], + "execution_count": 36, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m15_MjradMNY" + }, + "source": [ + "### **Cross Entropy Loss**\n", + "Another very famous loss function is Cross Entropy loss: $ L = −[ylog(z)+(1−y)log(1−z)] $." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "snJLqhszdMNY" + }, + "source": [ + "import numpy as np\n", + "def CELoss(z,y):\n", + " '''\n", + " y : True output. \n", + " z : Predicted output. \n", + " return : L\n", + " '''\n", + " L = -[y*np.log(z) + (1-y)*np.log(1-z)]\n", + " return L" + ], + "execution_count": 26, + "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", + " return 0\n", + " else:\n", + " return 1\n" + ], + "execution_count": 37, + "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)=\\frac{1}{m}\\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", + " n = len(Z)\n", + " J = 1/n*sum(loss_func(Z,Y))\n", + " # YOUR CODE HERE\n", + " return J" + ], + "execution_count": 42, + "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": "690071f1-f31f-43fd-9001-2a54bb2cf5c8" + }, + "execution_count": 43, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2.8.0\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yyplk5PLEUsJ", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "5169af71-c6c6-4f1c-843d-4c2eda1c3a15" + }, + "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": 44, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n", + "170500096/170498071 [==============================] - 11s 0us/step\n", + "170508288/170498071 [==============================] - 11s 0us/step\n", + "(50000, 32, 32, 3) (50000, 1) (10000, 32, 32, 3) (10000, 1)\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "qQhkATYhEkkC", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 269 + }, + "outputId": "5ba2a67b-7c02-4a6a-f968-baf2bb8c777a" + }, + "source": [ + "'''visualize data by plotting images'''\n", + "# YOUR CODE HERE\n", + "fig, ax = plt.subplots(5, 5)\n", + "n = 0\n", + " \n", + "for i in range(5):\n", + " for j in range(5):\n", + " ax[i][j].imshow(x_train[n], aspect='auto')\n", + " n+=1\n", + " \n", + "plt.show()\n", + "# YOUR CODE HERE" + ], + "execution_count": 57, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yJgho2AEBFbx", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "2b6ed678-5d80-4ac0-d62c-7e3af5a1b4f7" + }, + "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", + "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", + "# YOUR CODE HERE\n", + " \n", + "\"\"\"last hidden layer i.e.. output layer\"\"\"\n", + "# YOUR CODE HERE\n", + "x = Dense(K, activation='softmax')(x)\n", + "model = Model(i, x)\n", + "# YOUR CODE HERE\n", + " \n", + "'''model description'''\n", + "model.summary()" + ], + "execution_count": 58, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "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" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "PLc4Bay65TyA" + }, + "source": [ + "# Compile\n", + "model.compile(optimizer='adam',\n", + " loss='sparse_categorical_crossentropy',\n", + " metrics=['accuracy'])" + ], + "execution_count": 59, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Fit\n", + "r = model.fit(\n", + " x_train, y_train, validation_data=(x_test, y_test), epochs=50)" + ], + "metadata": { + "id": "U0fGsDCRsQrn", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "9ec7dd4e-24d1-41c2-a728-7bc0e1e0113e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/50\n", + "1563/1563 [==============================] - 417s 266ms/step - loss: 1.3180 - accuracy: 0.5438 - val_loss: 1.0036 - val_accuracy: 0.6474\n", + "Epoch 2/50\n", + "1563/1563 [==============================] - 418s 268ms/step - loss: 0.8490 - accuracy: 0.7053 - val_loss: 0.8468 - val_accuracy: 0.7115\n", + "Epoch 3/50\n", + "1563/1563 [==============================] - 417s 267ms/step - loss: 0.6913 - accuracy: 0.7611 - val_loss: 0.7307 - val_accuracy: 0.7476\n", + "Epoch 4/50\n", + " 113/1563 [=>............................] - ETA: 6:13 - loss: 0.5607 - accuracy: 0.7987" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# label mapping\n", + " \n", + "labels = '''airplane automobile bird cat deerdog frog horseship truck'''.split()\n", + " \n", + "# select the image from our test dataset\n", + "image_number = 0\n", + " \n", + "# display the image\n", + "plt.imshow(x_test[image_number])\n", + " \n", + "# load the image in an array\n", + "n = np.array(x_test[image_number])\n", + " \n", + "# reshape it\n", + "p = n.reshape(1, 32, 32, 3)\n", + " \n", + "# pass in the network for prediction and\n", + "# save the predicted label\n", + "predicted_label = labels[model.predict(p).argmax()]\n", + " \n", + "# load the original label\n", + "original_label = labels[y_test[image_number]]\n", + " \n", + "# display the result\n", + "print(\"Original label is {} and predicted label is {}\".format(\n", + " original_label, predicted_label))" + ], + "metadata": { + "id": "RDq_RE6osSh8" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From 0c8b002ebf7bd4069a6da6767a6830c16fd2e228 Mon Sep 17 00:00:00 2001 From: GigabyteZ <95098507+GigabyteZX1@users.noreply.github.com> Date: Tue, 24 May 2022 17:00:08 +0530 Subject: [PATCH 3/4] Created using Colaboratory --- .../Assignment_2_210369_Emaad_Ahmed.ipynb | 73 +++++++++++++++++-- 1 file changed, 66 insertions(+), 7 deletions(-) diff --git a/Assignment/Assignment_2/Assignment_2_210369_Emaad_Ahmed.ipynb b/Assignment/Assignment_2/Assignment_2_210369_Emaad_Ahmed.ipynb index 6c2738c..3cd28d6 100644 --- a/Assignment/Assignment_2/Assignment_2_210369_Emaad_Ahmed.ipynb +++ b/Assignment/Assignment_2/Assignment_2_210369_Emaad_Ahmed.ipynb @@ -516,6 +516,11 @@ "source": [ "import tensorflow as tf \n", " \n", + "#!!! MUST READ !!!\n", + "# I have used most of the code from geeks for geeks website for this question but \n", + "# i am not being able to understand that model building part and also no tensorflow blogs were\n", + "# provided this week hence i would request you to provide some good reading material related to this topic\n", + "\n", "# Display the version\n", "print(tf.__version__) \n", " \n", @@ -771,16 +776,17 @@ "source": [ "# Fit\n", "r = model.fit(\n", - " x_train, y_train, validation_data=(x_test, y_test), epochs=50)" + " x_train, y_train, validation_data=(x_test, y_test), epochs=10)" ], "metadata": { "id": "U0fGsDCRsQrn", "colab": { - "base_uri": "https://localhost:8080/" + "base_uri": "https://localhost:8080/", + "height": 662 }, "outputId": "9ec7dd4e-24d1-41c2-a728-7bc0e1e0113e" }, - "execution_count": null, + "execution_count": 60, "outputs": [ { "output_type": "stream", @@ -793,7 +799,35 @@ "Epoch 3/50\n", "1563/1563 [==============================] - 417s 267ms/step - loss: 0.6913 - accuracy: 0.7611 - val_loss: 0.7307 - val_accuracy: 0.7476\n", "Epoch 4/50\n", - " 113/1563 [=>............................] - ETA: 6:13 - loss: 0.5607 - accuracy: 0.7987" + "1563/1563 [==============================] - 417s 267ms/step - loss: 0.5853 - accuracy: 0.7981 - val_loss: 0.6759 - val_accuracy: 0.7762\n", + "Epoch 5/50\n", + "1563/1563 [==============================] - 445s 284ms/step - loss: 0.4941 - accuracy: 0.8319 - val_loss: 0.8403 - val_accuracy: 0.7269\n", + "Epoch 6/50\n", + "1563/1563 [==============================] - 412s 264ms/step - loss: 0.4133 - accuracy: 0.8570 - val_loss: 0.7143 - val_accuracy: 0.7771\n", + "Epoch 7/50\n", + "1563/1563 [==============================] - 413s 264ms/step - loss: 0.3476 - accuracy: 0.8806 - val_loss: 0.6943 - val_accuracy: 0.7880\n", + "Epoch 8/50\n", + " 18/1563 [..............................] - ETA: 6:30 - loss: 0.3109 - accuracy: 0.8889" + ] + }, + { + "output_type": "error", + "ename": "KeyboardInterrupt", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\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 1\u001b[0m \u001b[0;31m# Fit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m r = model.fit(\n\u001b[0;32m----> 3\u001b[0;31m x_train, y_train, validation_data=(x_test, y_test), epochs=50)\n\u001b[0m", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/keras/utils/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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 65\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# pylint: disable=broad-except\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 66\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m 1382\u001b[0m _r=1):\n\u001b[1;32m 1383\u001b[0m \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_train_batch_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1384\u001b[0;31m \u001b[0mtmp_logs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\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 1385\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdata_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshould_sync\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1386\u001b[0m \u001b[0mcontext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masync_wait\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;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/util/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 149\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 150\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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 151\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 913\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 914\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mOptionalXlaContext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_jit_compile\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;32m--> 915\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\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 916\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 917\u001b[0m \u001b[0mnew_tracing_count\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexperimental_get_tracing_count\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;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m_call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 945\u001b[0m \u001b[0;31m# In this case we have created variables on the first call, so we run the\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 946\u001b[0m \u001b[0;31m# defunned version which is guaranteed to never create variables.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 947\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stateless_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# pylint: disable=not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 948\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stateful_fn\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 949\u001b[0m \u001b[0;31m# Release the lock early so that multiple threads can perform the call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2955\u001b[0m filtered_flat_args) = self._maybe_define_function(args, kwargs)\n\u001b[1;32m 2956\u001b[0m return graph_function._call_flat(\n\u001b[0;32m-> 2957\u001b[0;31m filtered_flat_args, captured_inputs=graph_function.captured_inputs) # pylint: disable=protected-access\n\u001b[0m\u001b[1;32m 2958\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2959\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[0;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[1;32m 1852\u001b[0m \u001b[0;31m# No tape is watching; skip to running the function.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1853\u001b[0m return self._build_call_outputs(self._inference_function.call(\n\u001b[0;32m-> 1854\u001b[0;31m ctx, args, cancellation_manager=cancellation_manager))\n\u001b[0m\u001b[1;32m 1855\u001b[0m forward_backward = self._select_forward_and_backward_functions(\n\u001b[1;32m 1856\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36mcall\u001b[0;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[1;32m 502\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 503\u001b[0m \u001b[0mattrs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mattrs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 504\u001b[0;31m ctx=ctx)\n\u001b[0m\u001b[1;32m 505\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 506\u001b[0m outputs = execute.execute_with_cancellation(\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/eager/execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mensure_initialized\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 54\u001b[0m tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[0;32m---> 55\u001b[0;31m inputs, attrs, num_outputs)\n\u001b[0m\u001b[1;32m 56\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 57\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ] @@ -829,10 +863,35 @@ " original_label, predicted_label))" ], "metadata": { - "id": "RDq_RE6osSh8" + "id": "RDq_RE6osSh8", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 283 + }, + "outputId": "0967eea2-0382-49e4-bcbf-2c7dffcbb03e" }, - "execution_count": null, - "outputs": [] + "execution_count": 61, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Original label is cat and predicted label is cat\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] } ] } \ No newline at end of file From 6a2eeea9acb6224cfbc385caa2395494113b8927 Mon Sep 17 00:00:00 2001 From: GigabyteZ Date: Tue, 21 Jun 2022 22:47:09 +0530 Subject: [PATCH 4/4] Assignment 3 --- .../Assignment_3_210369_Emaad_Ahmed.ipynb | 402 ++++++++++++++++++ 1 file changed, 402 insertions(+) create mode 100644 Assignment/Assignment_3/Assignment_3_210369_Emaad_Ahmed.ipynb diff --git a/Assignment/Assignment_3/Assignment_3_210369_Emaad_Ahmed.ipynb b/Assignment/Assignment_3/Assignment_3_210369_Emaad_Ahmed.ipynb new file mode 100644 index 0000000..043a024 --- /dev/null +++ b/Assignment/Assignment_3/Assignment_3_210369_Emaad_Ahmed.ipynb @@ -0,0 +1,402 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "d2d00b72-064c-49f0-8185-385aab4c7461", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import torch\n", + "from torchvision import datasets\n", + "from torchvision.transforms import ToTensor\n", + "import matplotlib.pyplot as plt\n", + "from torch import nn\n", + "import torch.nn.functional as F\n", + "from torch import optim\n", + "from torch.utils.data import DataLoader" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "f516ccec-4903-4c7a-94b1-deaeb14be728", + "metadata": {}, + "outputs": [], + "source": [ + "if torch.cuda.is_available():\n", + " device = torch.device(\"cuda\")\n", + "else:\n", + " device = torch.device(\"cpu\") " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "01011155-c4a0-4162-8b3d-1f1ca5205465", + "metadata": {}, + "outputs": [], + "source": [ + "train_data = datasets.MNIST(root = 'data', train = True, \n", + " transform = ToTensor(), download = True, \n", + ")\n", + "test_data = datasets.MNIST(root = 'data', train = False, \n", + " transform = ToTensor()\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1dcb1add-e5d5-4115-b445-be1b5e0bb985", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(train_data.data[0], cmap='gray')\n", + "plt.title('%i' % train_data.targets[0])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1ca8848d-1a44-47ed-8f97-73d17215ed54", + "metadata": {}, + "outputs": [], + "source": [ + "trainloader = torch.utils.data.DataLoader(train_data, batch_size = 100, shuffle = True, num_workers = 1)\n", + "testloader = torch.utils.data.DataLoader(test_data, batch_size = 100, shuffle = True, num_workers = 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5613d8a9-7e61-43da-9407-72e615b897b7", + "metadata": {}, + "outputs": [], + "source": [ + "sequence_length = 28\n", + "input_size = 28\n", + "hidden_size = 128\n", + "num_layers = 2\n", + "num_classes = 10\n", + "batch_size = 100" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "ecb12493-ee96-45f2-aac8-70195c4c765e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MRNN(\n", + " (lstm): LSTM(28, 128, num_layers=2, batch_first=True)\n", + " (fc): Linear(in_features=128, out_features=10, bias=True)\n", + ")\n" + ] + } + ], + "source": [ + "class MRNN(nn.Module):\n", + " def __init__(self, input_size, hidden_size, num_layers, num_classes):\n", + " super(MRNN, self).__init__()\n", + " self.hidden_size = hidden_size\n", + " self.num_layers = num_layers\n", + " self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)\n", + " self.fc = nn.Linear(hidden_size, num_classes)\n", + " pass\n", + " \n", + " def forward(self, x):\n", + " h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device) \n", + " c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)\n", + " out, hidden = self.lstm(x, (h0, c0)) \n", + " out = self.fc(out[:, -1, :])\n", + " return out\n", + "model = MRNN(input_size, hidden_size, num_layers, num_classes).to(device)\n", + "print(model)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "92a5260f-83d4-4011-a85a-a7af66ded9e5", + "metadata": {}, + "outputs": [], + "source": [ + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.Adam(model.parameters(), lr = 0.001)" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "5c24a0ef-b2e9-4955-8b08-f7b4844a3530", + "metadata": {}, + "outputs": [], + "source": [ + "def get_accuracy(out, actual_labels, batch_size):\n", + " predictions = out.max(dim=1)[1]\n", + " correct = (predictions == actual_labels).sum().item()\n", + " accuracy = correct/batch_size\n", + " \n", + " return accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "55c4cdd4-3665-4140-96e8-a7bc164d7e67", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration: 500. Loss: 0.029. Accuracy: 98.95\n", + "Iteration: 1000. Loss: 0.035. Accuracy: 98.63\n", + "Iteration: 1500. Loss: 0.001. Accuracy: 98.73\n", + "Iteration: 2000. Loss: 0.000. Accuracy: 99.08\n", + "Iteration: 2500. Loss: 0.001. Accuracy: 99.10\n", + "Iteration: 3000. Loss: 0.003. Accuracy: 98.97\n", + "Iteration: 3500. Loss: 0.001. Accuracy: 98.91\n", + "Iteration: 4000. Loss: 0.006. Accuracy: 98.83\n", + "Iteration: 4500. Loss: 0.003. Accuracy: 98.92\n", + "Iteration: 5000. Loss: 0.010. Accuracy: 98.94\n", + "Iteration: 5500. Loss: 0.001. Accuracy: 99.16\n", + "Iteration: 6000. Loss: 0.001. Accuracy: 99.01\n", + "Iteration: 6500. Loss: 0.001. Accuracy: 98.98\n", + "Iteration: 7000. Loss: 0.025. Accuracy: 99.05\n", + "Iteration: 7500. Loss: 0.004. Accuracy: 98.99\n", + "Iteration: 8000. Loss: 0.001. Accuracy: 98.89\n", + "Iteration: 8500. Loss: 0.000. Accuracy: 99.02\n", + "Iteration: 9000. Loss: 0.003. Accuracy: 98.85\n", + "Iteration: 9500. Loss: 0.089. Accuracy: 98.75\n", + "Iteration: 10000. Loss: 0.001. Accuracy: 99.09\n", + "Iteration: 10500. Loss: 0.000. Accuracy: 99.05\n", + "Iteration: 11000. Loss: 0.000. Accuracy: 99.25\n", + "Iteration: 11500. Loss: 0.000. Accuracy: 99.04\n", + "Iteration: 12000. Loss: 0.003. Accuracy: 98.82\n", + "Iteration: 12500. Loss: 0.019. Accuracy: 99.03\n", + "Iteration: 13000. Loss: 0.000. Accuracy: 99.11\n", + "Iteration: 13500. Loss: 0.000. Accuracy: 99.04\n", + "Iteration: 14000. Loss: 0.000. Accuracy: 99.10\n", + "Iteration: 14500. Loss: 0.000. Accuracy: 99.05\n", + "Iteration: 15000. Loss: 0.001. Accuracy: 99.11\n", + "Iteration: 15500. Loss: 0.000. Accuracy: 99.09\n", + "Iteration: 16000. Loss: 0.000. Accuracy: 99.05\n", + "Iteration: 16500. Loss: 0.000. Accuracy: 98.98\n", + "Iteration: 17000. Loss: 0.000. Accuracy: 99.12\n", + "Iteration: 17500. Loss: 0.000. Accuracy: 99.15\n", + "Iteration: 18000. Loss: 0.003. Accuracy: 98.92\n" + ] + } + ], + "source": [ + "epochs = 30\n", + "iter = 0\n", + "for e in range(epochs):\n", + " for i,(images,labels) in enumerate(trainloader):\n", + " images = images.reshape(-1, sequence_length, input_size).requires_grad_().to(device)\n", + " labels = labels.to(device)\n", + " output = model(images)\n", + " optimizer.zero_grad()\n", + " loss = criterion(output,labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + " iter += 1\n", + "\n", + " if iter % 500 == 0: \n", + " correct = 0\n", + " total = 0\n", + " for images, labels in testloader:\n", + " images = images.view(-1, sequence_length, input_size).to(device)\n", + " labels = labels.to(device)\n", + " outputs = model(images)\n", + " _, predicted = torch.max(outputs.data, 1)\n", + " total += labels.size(0)\n", + " if torch.cuda.is_available():\n", + " correct += (predicted.cpu() == labels.cpu()).sum()\n", + " else:\n", + " correct += (predicted == labels).sum()\n", + "\n", + " accuracy = 100 * correct / total\n", + "\n", + " print('Iteration: {}. Loss: {:.3f}. Accuracy: {:.2f}'.format(iter, loss.item(), accuracy))\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "8cccdf17-497e-4d8a-a2ae-6a11643d5da8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Testing Started...\n", + "TEST | Average Accuracy per 0 Loaders: 0.98000\n", + "TEST | Average Accuracy per 1 Loaders: 1.97000\n", + "TEST | Average Accuracy per 2 Loaders: 2.95000\n", + "TEST | Average Accuracy per 3 Loaders: 3.93000\n", + "TEST | Average Accuracy per 4 Loaders: 4.93000\n", + "TEST | Average Accuracy per 5 Loaders: 5.90000\n", + "TEST | Average Accuracy per 6 Loaders: 6.89000\n", + "TEST | Average Accuracy per 7 Loaders: 7.89000\n", + "TEST | Average Accuracy per 8 Loaders: 8.86000\n", + "TEST | Average Accuracy per 9 Loaders: 9.86000\n", + "TEST | Average Accuracy per 10 Loaders: 10.84000\n", + "TEST | Average Accuracy per 11 Loaders: 11.81000\n", + "TEST | Average Accuracy per 12 Loaders: 12.81000\n", + "TEST | Average Accuracy per 13 Loaders: 13.80000\n", + "TEST | Average Accuracy per 14 Loaders: 14.80000\n", + "TEST | Average Accuracy per 15 Loaders: 15.80000\n", + "TEST | Average Accuracy per 16 Loaders: 16.80000\n", + "TEST | Average Accuracy per 17 Loaders: 17.79000\n", + "TEST | Average Accuracy per 18 Loaders: 18.78000\n", + "TEST | Average Accuracy per 19 Loaders: 19.78000\n", + "TEST | Average Accuracy per 20 Loaders: 20.78000\n", + "TEST | Average Accuracy per 21 Loaders: 21.77000\n", + "TEST | Average Accuracy per 22 Loaders: 22.76000\n", + "TEST | Average Accuracy per 23 Loaders: 23.75000\n", + "TEST | Average Accuracy per 24 Loaders: 24.73000\n", + "TEST | Average Accuracy per 25 Loaders: 25.72000\n", + "TEST | Average Accuracy per 26 Loaders: 26.71000\n", + "TEST | Average Accuracy per 27 Loaders: 27.71000\n", + "TEST | Average Accuracy per 28 Loaders: 28.70000\n", + "TEST | Average Accuracy per 29 Loaders: 29.68000\n", + "TEST | Average Accuracy per 30 Loaders: 30.67000\n", + "TEST | Average Accuracy per 31 Loaders: 31.66000\n", + "TEST | Average Accuracy per 32 Loaders: 32.66000\n", + "TEST | Average Accuracy per 33 Loaders: 33.63000\n", + "TEST | Average Accuracy per 34 Loaders: 34.61000\n", + "TEST | Average Accuracy per 35 Loaders: 35.59000\n", + "TEST | Average Accuracy per 36 Loaders: 36.57000\n", + "TEST | Average Accuracy per 37 Loaders: 37.57000\n", + "TEST | Average Accuracy per 38 Loaders: 38.57000\n", + "TEST | Average Accuracy per 39 Loaders: 39.55000\n", + "TEST | Average Accuracy per 40 Loaders: 40.55000\n", + "TEST | Average Accuracy per 41 Loaders: 41.55000\n", + "TEST | Average Accuracy per 42 Loaders: 42.55000\n", + "TEST | Average Accuracy per 43 Loaders: 43.54000\n", + "TEST | Average Accuracy per 44 Loaders: 44.54000\n", + "TEST | Average Accuracy per 45 Loaders: 45.51000\n", + "TEST | Average Accuracy per 46 Loaders: 46.50000\n", + "TEST | Average Accuracy per 47 Loaders: 47.50000\n", + "TEST | Average Accuracy per 48 Loaders: 48.48000\n", + "TEST | Average Accuracy per 49 Loaders: 49.48000\n", + "TEST | Average Accuracy per 50 Loaders: 50.47000\n", + "TEST | Average Accuracy per 51 Loaders: 51.46000\n", + "TEST | Average Accuracy per 52 Loaders: 52.45000\n", + "TEST | Average Accuracy per 53 Loaders: 53.44000\n", + "TEST | Average Accuracy per 54 Loaders: 54.44000\n", + "TEST | Average Accuracy per 55 Loaders: 55.43000\n", + "TEST | Average Accuracy per 56 Loaders: 56.43000\n", + "TEST | Average Accuracy per 57 Loaders: 57.43000\n", + "TEST | Average Accuracy per 58 Loaders: 58.42000\n", + "TEST | Average Accuracy per 59 Loaders: 59.41000\n", + "TEST | Average Accuracy per 60 Loaders: 60.39000\n", + "TEST | Average Accuracy per 61 Loaders: 61.38000\n", + "TEST | Average Accuracy per 62 Loaders: 62.37000\n", + "TEST | Average Accuracy per 63 Loaders: 63.37000\n", + "TEST | Average Accuracy per 64 Loaders: 64.36000\n", + "TEST | Average Accuracy per 65 Loaders: 65.34000\n", + "TEST | Average Accuracy per 66 Loaders: 66.32000\n", + "TEST | Average Accuracy per 67 Loaders: 67.29000\n", + "TEST | Average Accuracy per 68 Loaders: 68.29000\n", + "TEST | Average Accuracy per 69 Loaders: 69.25000\n", + "TEST | Average Accuracy per 70 Loaders: 70.23000\n", + "TEST | Average Accuracy per 71 Loaders: 71.21000\n", + "TEST | Average Accuracy per 72 Loaders: 72.21000\n", + "TEST | Average Accuracy per 73 Loaders: 73.20000\n", + "TEST | Average Accuracy per 74 Loaders: 74.20000\n", + "TEST | Average Accuracy per 75 Loaders: 75.19000\n", + "TEST | Average Accuracy per 76 Loaders: 76.17000\n", + "TEST | Average Accuracy per 77 Loaders: 77.16000\n", + "TEST | Average Accuracy per 78 Loaders: 78.16000\n", + "TEST | Average Accuracy per 79 Loaders: 79.15000\n", + "TEST | Average Accuracy per 80 Loaders: 80.14000\n", + "TEST | Average Accuracy per 81 Loaders: 81.13000\n", + "TEST | Average Accuracy per 82 Loaders: 82.13000\n", + "TEST | Average Accuracy per 83 Loaders: 83.12000\n", + "TEST | Average Accuracy per 84 Loaders: 84.10000\n", + "TEST | Average Accuracy per 85 Loaders: 85.09000\n", + "TEST | Average Accuracy per 86 Loaders: 86.09000\n", + "TEST | Average Accuracy per 87 Loaders: 87.06000\n", + "TEST | Average Accuracy per 88 Loaders: 88.05000\n", + "TEST | Average Accuracy per 89 Loaders: 89.04000\n", + "TEST | Average Accuracy per 90 Loaders: 90.01000\n", + "TEST | Average Accuracy per 91 Loaders: 90.99000\n", + "TEST | Average Accuracy per 92 Loaders: 91.97000\n", + "TEST | Average Accuracy per 93 Loaders: 92.96000\n", + "TEST | Average Accuracy per 94 Loaders: 93.95000\n", + "TEST | Average Accuracy per 95 Loaders: 94.93000\n", + "TEST | Average Accuracy per 96 Loaders: 95.92000\n", + "TEST | Average Accuracy per 97 Loaders: 96.92000\n", + "TEST | Average Accuracy per 98 Loaders: 97.92000\n", + "TEST | Average Accuracy per 99 Loaders: 98.92000\n" + ] + } + ], + "source": [ + "print('Testing Started...')\n", + "test_acc = 0\n", + "model.eval()\n", + " \n", + "for k, (images, labels) in enumerate(testloader):\n", + " images = images.view(-1, sequence_length, input_size).to(device)\n", + " labels = labels.to(device)\n", + " \n", + " out = model(images)\n", + "\n", + " test_acc += get_accuracy(out, labels, batch_size)\n", + " \n", + " print('TEST | Average Accuracy per {} Loaders: {:.5f}'.format(k, test_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.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}