diff --git a/Assignment/Assignment3/DL_Assignment_3.ipynb b/Assignment/Assignment3/DL_Assignment_3.ipynb
new file mode 100644
index 0000000..ee35716
--- /dev/null
+++ b/Assignment/Assignment3/DL_Assignment_3.ipynb
@@ -0,0 +1,324 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "DL_Assignment_3.ipynb",
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU",
+    "gpuClass": "standard"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Importing tensorflow"
+      ],
+      "metadata": {
+        "id": "S07TSoqxDKjm"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "kAeFpk-7Bz-q",
+        "outputId": "38d11f86-c811-4dad-e90b-41373f73dc7c"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Found GPU at: /device:GPU:0\n"
+          ]
+        }
+      ],
+      "source": [
+        "%tensorflow_version 2.x\n",
+        "import tensorflow as tf\n",
+        "device_name = tf.test.gpu_device_name()\n",
+        "if device_name != '/device:GPU:0':\n",
+        "  raise SystemError('GPU device not found')\n",
+        "print('Found GPU at: {}'.format(device_name))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Importing keras, layers and dataset"
+      ],
+      "metadata": {
+        "id": "2lqBgJ62DN7v"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from tensorflow import keras\n",
+        "from tensorflow.keras import layers\n",
+        "from tensorflow.keras.datasets import mnist"
+      ],
+      "metadata": {
+        "id": "nvxO5FFVCF1k"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Splitting test and train datasets"
+      ],
+      "metadata": {
+        "id": "GHrB6KeCDbaX"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "(x_train,y_train), (x_test, y_test) = mnist.load_data()\n",
+        "print(x_train.shape)\n",
+        "#we have 60000 datasets of 28 * 28 images\n",
+        "#normalising the data\n",
+        "x_train = x_train.reshape([-1, 28, 28]).astype(\"float32\") / 255.0\n",
+        "x_test = x_test.reshape([-1, 28, 28]).astype(\"float32\") / 255.0"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "pWX29ZZICmkb",
+        "outputId": "750e20ad-9b6c-4504-df87-64ac67df3a70"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "(60000, 28, 28)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Building model LSTM (using sequential)"
+      ],
+      "metadata": {
+        "id": "DbEoIEEMDin3"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "model = keras.Sequential()\n",
+        "model.add(keras.Input(shape=(None, 28)))\n",
+        "model.add(layers.LSTM(256, return_sequences=True, activation=\"relu\"))\n",
+        "model.add(layers.LSTM(256))\n",
+        "model.add(layers.Dense(10))\n",
+        "\n",
+        "print(model.summary())\n",
+        "\n",
+        "model.compile(\n",
+        "    loss = keras.losses.SparseCategoricalCrossentropy(from_logits = True),\n",
+        "    optimizer = keras.optimizers.Adam(learning_rate = 0.003),\n",
+        "    metrics = [\"accuracy\"],\n",
+        ")\n",
+        "\n",
+        "model.fit(x_train, y_train, batch_size = 64, epochs = 10, verbose = 2)\n",
+        "model.evaluate(x_test, y_test, batch_size = 64, verbose = 2)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "HHgRpzX7DP0A",
+        "outputId": "4b14c427-059b-40d2-ee3b-f392df699ee8"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "WARNING:tensorflow:Layer lstm_6 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n",
+            "Model: \"sequential_3\"\n",
+            "_________________________________________________________________\n",
+            " Layer (type)                Output Shape              Param #   \n",
+            "=================================================================\n",
+            " lstm_6 (LSTM)               (None, None, 256)         291840    \n",
+            "                                                                 \n",
+            " lstm_7 (LSTM)               (None, 256)               525312    \n",
+            "                                                                 \n",
+            " dense_4 (Dense)             (None, 10)                2570      \n",
+            "                                                                 \n",
+            "=================================================================\n",
+            "Total params: 819,722\n",
+            "Trainable params: 819,722\n",
+            "Non-trainable params: 0\n",
+            "_________________________________________________________________\n",
+            "None\n",
+            "Epoch 1/10\n",
+            "938/938 - 90s - loss: 0.2631 - accuracy: 0.9163 - 90s/epoch - 96ms/step\n",
+            "Epoch 2/10\n",
+            "938/938 - 46s - loss: 0.0754 - accuracy: 0.9781 - 46s/epoch - 49ms/step\n",
+            "Epoch 3/10\n",
+            "938/938 - 46s - loss: 0.0540 - accuracy: 0.9834 - 46s/epoch - 49ms/step\n",
+            "Epoch 4/10\n",
+            "938/938 - 45s - loss: 0.0428 - accuracy: 0.9863 - 45s/epoch - 48ms/step\n",
+            "Epoch 5/10\n",
+            "938/938 - 47s - loss: 0.0347 - accuracy: 0.9891 - 47s/epoch - 51ms/step\n",
+            "Epoch 6/10\n",
+            "938/938 - 45s - loss: 0.0295 - accuracy: 0.9907 - 45s/epoch - 48ms/step\n",
+            "Epoch 7/10\n",
+            "938/938 - 52s - loss: 0.0260 - accuracy: 0.9921 - 52s/epoch - 55ms/step\n",
+            "Epoch 8/10\n",
+            "938/938 - 58s - loss: 0.0236 - accuracy: 0.9924 - 58s/epoch - 62ms/step\n",
+            "Epoch 9/10\n",
+            "938/938 - 46s - loss: 0.0212 - accuracy: 0.9935 - 46s/epoch - 49ms/step\n",
+            "Epoch 10/10\n",
+            "938/938 - 48s - loss: 0.0191 - accuracy: 0.9939 - 48s/epoch - 51ms/step\n",
+            "157/157 - 2s - loss: 0.0351 - accuracy: 0.9907 - 2s/epoch - 11ms/step\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "[0.03508976846933365, 0.9907000064849854]"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 9
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Testing it on some random image number (code used from previous assignments)"
+      ],
+      "metadata": {
+        "id": "vnCxP5iYDpiU"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "labels = '''0 1 2 3 4 5 6 7 8 9'''.split()\n",
+        "image_number = 0\n",
+        "plt.imshow(x_test[image_number])\n",
+        "n = np.array(x_test[image_number])\n",
+        "p = n.reshape(1, 28, 28, 1)\n",
+        "print(model.predict(p).argmax())\n",
+        "predicted_label = labels[model.predict(p).argmax()]\n",
+        "original_label = labels[y_test[image_number]]\n",
+        "print(\"Original label is {} and predicted label is {}\".format(\n",
+        "    original_label, predicted_label))"
+      ],
+      "metadata": {
+        "id": "MNBjQ41lGgd2",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 301
+        },
+        "outputId": "e8aa2fa6-6d4e-425e-b33c-ecd78e7ead9b"
+      },
+      "execution_count": 12,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "7\n",
+            "Original label is 7 and predicted label is 7\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "image_number = 3\n",
+        "plt.imshow(x_test[image_number])\n",
+        "n = np.array(x_test[image_number])\n",
+        "p = n.reshape(1, 28, 28, 1)\n",
+        "print(model.predict(p).argmax())\n",
+        "predicted_label = labels[model.predict(p).argmax()]\n",
+        "original_label = labels[y_test[image_number]]\n",
+        "print(\"Original label is {} and predicted label is {}\".format(\n",
+        "    original_label, predicted_label))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 301
+        },
+        "id": "1KwdcQXjCdn0",
+        "outputId": "de9567a2-38df-463f-ac29-ef8f83e557da"
+      },
+      "execution_count": 13,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "0\n",
+            "Original label is 0 and predicted label is 0\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "ZOgTXyarDFOY"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Assignment/Assignment3/assignment3 b/Assignment/Assignment3/assignment3
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/Assignment/Assignment3/assignment3
@@ -0,0 +1 @@
+
diff --git a/Assignment/Assignment_1/200864_Sanidhya_Part1.ipynb b/Assignment/Assignment_1/200864_Sanidhya_Part1.ipynb
new file mode 100644
index 0000000..3c620ea
--- /dev/null
+++ b/Assignment/Assignment_1/200864_Sanidhya_Part1.ipynb
@@ -0,0 +1,963 @@
+{
+  "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": "DL_Stamatics_A1_Sanidhya.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": "8cbd6e56-3e99-4bdc-d7dc-db3fa87d5a70"
+      },
+      "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 = \\n\", 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 = \n",
+            " [[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",
+        "    pass\n",
+        "    ### END YOUR CODE\n",
+        "    return out"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "pbLIS5vIE-Ea",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "244cf1c2-105b-4ca5-cfb9-6f31202aba3a"
+      },
+      "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",
+        "    out = None\n",
+        "    out= dot_product(dot_product(M,a.T),dot_product(a,b))\n",
+        "    ### YOUR CODE HERE\n",
+        "    pass\n",
+        "    ### END YOUR CODE\n",
+        "    return out"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "da_uQQLhE-Ec",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "7472d64a-fc43-4af3-f7a5-83ab8bf5ae22"
+      },
+      "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": "6d8f01a5-018b-4a1d-932a-b15624b8a45a"
+      },
+      "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",
+        "    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": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "YB120rb4ONBH"
+      },
+      "source": [
+        "def get_eigen_values_and_vectors(M, k):\n",
+        "    \"\"\"Return top k eigenvalues and eigenvectors of matrix M. By top k\n",
+        "    here we mean the eigenvalues with the top ABSOLUTE values (lookup\n",
+        "    np.argsort for a hint on how to do so.)\n",
+        "    (optional): Use the `eigen_decomp(M)` function you wrote above\n",
+        "    as a helper function\n",
+        "    Args:\n",
+        "        M: numpy matrix of shape (m, m).\n",
+        "        k: number of eigen values and respective vectors to return.\n",
+        "    Returns:\n",
+        "        eigenvalues: list of length k containing the top k eigenvalues\n",
+        "        eigenvectors: list of length k containing the top k eigenvectors\n",
+        "            of shape (m,)\n",
+        "    \"\"\"\n",
+        "    eigenvalues = []\n",
+        "    eigenvectors = []\n",
+        "    ### YOUR CODE HERE\n",
+        "    w=None\n",
+        "    v=None\n",
+        "    j=None\n",
+        "    w,v= eigen_decomp(M)\n",
+        "    for i in range(w.shape[0]):\n",
+        "      j[i]=abs(w[i])\n",
+        "    j=np.argsort(w)\n",
+        "    for i in range(k):\n",
+        "      eigenvalues.append(w[j[i]])\n",
+        "      eigenvectors.append(v[j[i]])\n",
+        "    pass\n",
+        "    ### END YOUR CODE\n",
+        "    return eigenvalues, eigenvectors"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "t0_GkrJwE-Ee",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "55b65282-a745-4039-884b-3bfb99ebef58"
+      },
+      "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 = 1.3036777264747022e-15\n",
+            "\n",
+            "First eigenvector = [-0.8186735   0.61232756  0.40824829]\n",
+            "\n",
+            "Eigenvalues = [1.3036777264747022e-15, 1.1168439698070427]\n",
+            "\n",
+            "Eigenvectors = [array([-0.8186735 ,  0.61232756,  0.40824829]), array([-0.52532209, -0.08675134, -0.81649658])]\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",
+        "    \n",
+        "    ### YOUR CODE HERE\n",
+        "    temp= M[:,0]\n",
+        "    temp=np.argsort(temp)\n",
+        "    index= temp[temp.size-1]\n",
+        "    M[[0,index]]=M[[index,0]]\n",
+        "    out=M\n",
+        "    pass\n",
+        "    ### END YOUR CODE\n",
+        "    return out"
+      ],
+      "execution_count": null,
+      "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",
+        "    row= M.shape[0]\n",
+        "    col= M.shape[1]\n",
+        "    for i in range(1,row):\n",
+        "      f=(M[i,0]/M[0,0])\n",
+        "      for j in range(col):\n",
+        "        M[i,j]=round(M[i,j]-M[0,j]*f,2)\n",
+        "    out=M\n",
+        "    ### YOUR CODE HERE\n",
+        "    pass\n",
+        "    ### END YOUR CODE\n",
+        "    return out"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "GnE_-JLxPYz7"
+      },
+      "source": [
+        "def forward(M):\n",
+        "    \"\"\"Return a partial ref using the algo described above\n",
+        "    Args:\n",
+        "        M: numpy matrix of shape (m, n).\n",
+        "    Returns:\n",
+        "        Ms: ref of M\n",
+        "    \"\"\"\n",
+        "    out = None\n",
+        "    row=M.shape[0]\n",
+        "    col=M.shape[1]\n",
+        "    l1=np.arange(row)\n",
+        "    l2=np.arange(col)\n",
+        "    for i in range(col):\n",
+        "      M[np.ix_(l1,l2)]= swap_rows(M[np.ix_(l1,l2)])\n",
+        "      M[np.ix_(l1,l2)]= apply_rows(M[np.ix_(l1,l2)])\n",
+        "      l1=np.delete(l1,0)\n",
+        "      l2=np.delete(l2,0)\n",
+        "    out=M\n",
+        "    ### YOUR CODE HERE\n",
+        "    pass\n",
+        "    ### END YOUR CODE\n",
+        "    return out"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Wb7pPGP4XmJu"
+      },
+      "source": [
+        "def backward(M):\n",
+        "    \"\"\"Return a rref using the algo described above\n",
+        "    Args:\n",
+        "        M: numpy matrix of shape (m, n).\n",
+        "    Returns:\n",
+        "        Ms: rref of M\n",
+        "    \"\"\"\n",
+        "    out = None\n",
+        "    M_=M\n",
+        "    row=M.shape[0]\n",
+        "    col=M.shape[1]\n",
+        "    M_=np.rot90(M_,2)\n",
+        "    #make it square\n",
+        "    if(row>col):\n",
+        "      i=col\n",
+        "      while(i!=row-col+1):\n",
+        "        M_=np.delete(M_,i,axis=0)\n",
+        "        i+=1\n",
+        "\n",
+        "    if(row<col):\n",
+        "      i=row\n",
+        "      while(i!=col-row+1):\n",
+        "        M_=np.delete(M_,i,axis=1)\n",
+        "        i+=1\n",
+        "    l1=np.arange(min(row,col))\n",
+        "    l2=np.arange(min(row,col))\n",
+        "    for i in range(col):\n",
+        "      M_[np.ix_(l1,l2)]= apply_rows(M_[np.ix_(l1,l2)])\n",
+        "      l1=np.delete(l1,0)\n",
+        "      l2=np.delete(l2,0)\n",
+        "    M_=np.rot90(M_,2)\n",
+        "    for i in range(min(row,col)):\n",
+        "      for j in range(min(row, col)):\n",
+        "        M[i,j]=M_[i,j]\n",
+        "    out= M\n",
+        "    ### YOUR CODE HERE\n",
+        "    pass\n",
+        "    ### END YOUR CODE\n",
+        "    return out"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "XLq81xzXYR85"
+      },
+      "source": [
+        "def rref(M):\n",
+        "    \"\"\"Return a rref using the algo descrbed above\n",
+        "    Args:\n",
+        "        M: numpy matrix of shape (m, n).\n",
+        "    Returns:\n",
+        "        Ms: ref of M\n",
+        "    \"\"\"\n",
+        "    out = None\n",
+        "    out=backward(forward(M))\n",
+        "    ### YOUR CODE HERE\n",
+        "    pass\n",
+        "    ### END YOUR CODE\n",
+        "    return out"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Eiz6EbsWPYz8",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "43126814-a8e3-4fe9-e39a-7b00eed2e8fc"
+      },
+      "source": [
+        "# Let's define M.\n",
+        "M = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
+        "M=M.astype(float)\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": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[[7.   0.   0.  ]\n",
+            " [0.   0.86 0.  ]\n",
+            " [0.   0.   0.01]]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "G46pyDzAE-Ef"
+      },
+      "source": [
+        "## Part 1.6 (10 points)\n",
+        "\n",
+        "To wrap up our overview of NumPy, let's implement something fun &mdash; 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.00\n",
+        "    for i in range(len(u)):\n",
+        "      sum+=abs(u[i]-v[i])**2\n",
+        "    sum=pow(sum,0.5)\n",
+        "    out=sum\n",
+        "    pass\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 = None\n",
+        "    out= np.sqrt(np.sum((u-v)**2))\n",
+        "    pass\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": "235bf27c-5e6d-4a7a-b54e-2c528db77188"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Native: 1.9863088130950928 seconds\n",
+            "NumPy: 0.1071619987487793 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/200864_Sanidhya_Part2.ipynb b/Assignment/Assignment_1/200864_Sanidhya_Part2.ipynb
new file mode 100644
index 0000000..096fa72
--- /dev/null
+++ b/Assignment/Assignment_1/200864_Sanidhya_Part2.ipynb
@@ -0,0 +1,1600 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "nHTHdwQGuujK"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "from google.colab import files\n",
+        "import io"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 74,
+          "resources": {
+            "http://localhost:8080/nbextensions/google.colab/files.js": {
+              "data": "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",
+              "headers": [
+                [
+                  "content-type",
+                  "application/javascript"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            }
+          }
+        },
+        "id": "GFTfUbo-vAIz",
+        "outputId": "7edb75de-865d-4ecf-85cb-174226cc58bc"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-cd78a42d-29be-4240-988d-42d4afb9cc83\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-cd78a42d-29be-4240-988d-42d4afb9cc83\">\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",
+              "      </output>\n",
+              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saving House_prediction.csv to House_prediction.csv\n"
+          ]
+        }
+      ],
+      "source": [
+        "uploaded= files.upload()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "VuLGRQ1UbtwI"
+      },
+      "outputs": [],
+      "source": [
+        "df = pd.read_csv(io.BytesIO(uploaded['House_prediction.csv']))\n",
+        "df1 = pd.read_csv(io.BytesIO(uploaded['House_prediction.csv']))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Kb7lIXU139J2"
+      },
+      "source": [
+        "# Part 1: City-wise plotting of mean of features "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 337
+        },
+        "id": "Wjxxq2zreHeI",
+        "outputId": "44c3584f-db9c-4f1e-8fba-d37da011e8f0"
+      },
+      "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",
+              "  <div id=\"df-3bab8528-dd93-4ab6-ad49-aa7365ff1294\">\n",
+              "    <div class=\"colab-df-container\">\n",
+              "      <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>city</th>\n",
+              "      <th>area</th>\n",
+              "      <th>rooms</th>\n",
+              "      <th>bathroom</th>\n",
+              "      <th>parking spaces</th>\n",
+              "      <th>floor</th>\n",
+              "      <th>animal</th>\n",
+              "      <th>furniture</th>\n",
+              "      <th>hoa (R$)</th>\n",
+              "      <th>rent amount (R$)</th>\n",
+              "      <th>property tax (R$)</th>\n",
+              "      <th>fire insurance (R$)</th>\n",
+              "      <th>total (R$)</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>São Paulo</td>\n",
+              "      <td>70</td>\n",
+              "      <td>2</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>7</td>\n",
+              "      <td>acept</td>\n",
+              "      <td>furnished</td>\n",
+              "      <td>2065</td>\n",
+              "      <td>3300</td>\n",
+              "      <td>211</td>\n",
+              "      <td>42</td>\n",
+              "      <td>5618</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>São Paulo</td>\n",
+              "      <td>320</td>\n",
+              "      <td>4</td>\n",
+              "      <td>4</td>\n",
+              "      <td>0</td>\n",
+              "      <td>20</td>\n",
+              "      <td>acept</td>\n",
+              "      <td>not furnished</td>\n",
+              "      <td>1200</td>\n",
+              "      <td>4960</td>\n",
+              "      <td>1750</td>\n",
+              "      <td>63</td>\n",
+              "      <td>7973</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>Porto Alegre</td>\n",
+              "      <td>80</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>6</td>\n",
+              "      <td>acept</td>\n",
+              "      <td>not furnished</td>\n",
+              "      <td>1000</td>\n",
+              "      <td>2800</td>\n",
+              "      <td>0</td>\n",
+              "      <td>41</td>\n",
+              "      <td>3841</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>Porto Alegre</td>\n",
+              "      <td>51</td>\n",
+              "      <td>2</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>2</td>\n",
+              "      <td>acept</td>\n",
+              "      <td>not furnished</td>\n",
+              "      <td>270</td>\n",
+              "      <td>1112</td>\n",
+              "      <td>22</td>\n",
+              "      <td>17</td>\n",
+              "      <td>1421</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>São Paulo</td>\n",
+              "      <td>25</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "      <td>not acept</td>\n",
+              "      <td>not furnished</td>\n",
+              "      <td>0</td>\n",
+              "      <td>800</td>\n",
+              "      <td>25</td>\n",
+              "      <td>11</td>\n",
+              "      <td>836</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-3bab8528-dd93-4ab6-ad49-aa7365ff1294')\"\n",
+              "              title=\"Convert this dataframe to an interactive table.\"\n",
+              "              style=\"display:none;\">\n",
+              "        \n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "       width=\"24px\">\n",
+              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
+              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
+              "  </svg>\n",
+              "      </button>\n",
+              "      \n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      flex-wrap:wrap;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "      <script>\n",
+              "        const buttonEl =\n",
+              "          document.querySelector('#df-3bab8528-dd93-4ab6-ad49-aa7365ff1294 button.colab-df-convert');\n",
+              "        buttonEl.style.display =\n",
+              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "        async function convertToInteractive(key) {\n",
+              "          const element = document.querySelector('#df-3bab8528-dd93-4ab6-ad49-aa7365ff1294');\n",
+              "          const dataTable =\n",
+              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                     [key], {});\n",
+              "          if (!dataTable) return;\n",
+              "\n",
+              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "            + ' to learn more about interactive tables.';\n",
+              "          element.innerHTML = '';\n",
+              "          dataTable['output_type'] = 'display_data';\n",
+              "          await google.colab.output.renderOutput(dataTable, element);\n",
+              "          const docLink = document.createElement('div');\n",
+              "          docLink.innerHTML = docLinkHtml;\n",
+              "          element.appendChild(docLink);\n",
+              "        }\n",
+              "      </script>\n",
+              "    </div>\n",
+              "  </div>\n",
+              "  "
+            ]
+          },
+          "metadata": {},
+          "execution_count": 4
+        }
+      ],
+      "source": [
+        "df.head(5)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "yj6qwjmNfXd7",
+        "outputId": "5fa74896-eb3d-41a7-cf23-a16183f0ce4b"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "São Paulo         5887\n",
+              "Rio de Janeiro    1501\n",
+              "Belo Horizonte    1258\n",
+              "Porto Alegre      1193\n",
+              "Campinas           853\n",
+              "Name: city, dtype: int64"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 5
+        }
+      ],
+      "source": [
+        "df.city.value_counts()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 281
+        },
+        "id": "OWK_Sr3-vj4J",
+        "outputId": "66faf95d-0cc3-4823-9e35-faa4513a1be5"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "                      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  "
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-8135755d-192d-48ce-b4b8-0902cf6bc8ad\">\n",
+              "    <div class=\"colab-df-container\">\n",
+              "      <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>area</th>\n",
+              "      <th>rooms</th>\n",
+              "      <th>bathroom</th>\n",
+              "      <th>parking spaces</th>\n",
+              "      <th>hoa (R$)</th>\n",
+              "      <th>rent amount (R$)</th>\n",
+              "      <th>property tax (R$)</th>\n",
+              "      <th>fire insurance (R$)</th>\n",
+              "      <th>total (R$)</th>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>city</th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>Belo Horizonte</th>\n",
+              "      <td>207.411765</td>\n",
+              "      <td>3.020668</td>\n",
+              "      <td>2.402226</td>\n",
+              "      <td>1.955485</td>\n",
+              "      <td>2324.197138</td>\n",
+              "      <td>3664.127981</td>\n",
+              "      <td>272.782194</td>\n",
+              "      <td>53.675676</td>\n",
+              "      <td>6315.242448</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>Campinas</th>\n",
+              "      <td>137.561547</td>\n",
+              "      <td>2.355217</td>\n",
+              "      <td>1.960141</td>\n",
+              "      <td>1.558030</td>\n",
+              "      <td>628.922626</td>\n",
+              "      <td>2364.290739</td>\n",
+              "      <td>147.657679</td>\n",
+              "      <td>32.388042</td>\n",
+              "      <td>3173.276671</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>Porto Alegre</th>\n",
+              "      <td>103.609388</td>\n",
+              "      <td>2.140821</td>\n",
+              "      <td>1.725901</td>\n",
+              "      <td>1.044426</td>\n",
+              "      <td>491.618609</td>\n",
+              "      <td>2337.699916</td>\n",
+              "      <td>124.021794</td>\n",
+              "      <td>36.425817</td>\n",
+              "      <td>2989.782900</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>Rio de Janeiro</th>\n",
+              "      <td>105.347768</td>\n",
+              "      <td>2.243837</td>\n",
+              "      <td>1.756163</td>\n",
+              "      <td>0.744171</td>\n",
+              "      <td>1079.432378</td>\n",
+              "      <td>3232.904064</td>\n",
+              "      <td>256.853431</td>\n",
+              "      <td>42.483011</td>\n",
+              "      <td>4611.684877</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>São Paulo</th>\n",
+              "      <td>158.899439</td>\n",
+              "      <td>2.558859</td>\n",
+              "      <td>2.467641</td>\n",
+              "      <td>1.877527</td>\n",
+              "      <td>1169.627994</td>\n",
+              "      <td>4652.793783</td>\n",
+              "      <td>495.701716</td>\n",
+              "      <td>62.428911</td>\n",
+              "      <td>6380.831833</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-8135755d-192d-48ce-b4b8-0902cf6bc8ad')\"\n",
+              "              title=\"Convert this dataframe to an interactive table.\"\n",
+              "              style=\"display:none;\">\n",
+              "        \n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "       width=\"24px\">\n",
+              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
+              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
+              "  </svg>\n",
+              "      </button>\n",
+              "      \n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      flex-wrap:wrap;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "      <script>\n",
+              "        const buttonEl =\n",
+              "          document.querySelector('#df-8135755d-192d-48ce-b4b8-0902cf6bc8ad button.colab-df-convert');\n",
+              "        buttonEl.style.display =\n",
+              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "        async function convertToInteractive(key) {\n",
+              "          const element = document.querySelector('#df-8135755d-192d-48ce-b4b8-0902cf6bc8ad');\n",
+              "          const dataTable =\n",
+              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                     [key], {});\n",
+              "          if (!dataTable) return;\n",
+              "\n",
+              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "            + ' to learn more about interactive tables.';\n",
+              "          element.innerHTML = '';\n",
+              "          dataTable['output_type'] = 'display_data';\n",
+              "          await google.colab.output.renderOutput(dataTable, element);\n",
+              "          const docLink = document.createElement('div');\n",
+              "          docLink.innerHTML = docLinkHtml;\n",
+              "          element.appendChild(docLink);\n",
+              "        }\n",
+              "      </script>\n",
+              "    </div>\n",
+              "  </div>\n",
+              "  "
+            ]
+          },
+          "metadata": {},
+          "execution_count": 6
+        }
+      ],
+      "source": [
+        "df.groupby('city').mean()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "K8S-mjaef5k1"
+      },
+      "outputs": [],
+      "source": [
+        "data = df.groupby('city').mean().to_numpy()\n",
+        "area=data[:,0]\n",
+        "rooms=data[:,1]\n",
+        "bathroom=data[:,2]\n",
+        "parking_space=data[:,3]\n",
+        "hoa=data[:,4]\n",
+        "rent=data[:,5]\n",
+        "property_tax=data[:,6]\n",
+        "fire_insurance=data[:,7]\n",
+        "total=data[:,8]\n",
+        "city=np.array(['Belo Horizonte','Campinas','Porto Alegre','Rio de Janeiro','Sao Paulo'])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 936
+        },
+        "id": "wFMM9fpBkRUK",
+        "outputId": "e410dd41-9307-4a6b-d918-caa5e320aef5"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 0 Axes>"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1440x1152 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ],
+      "source": [
+        "df_ = pd.DataFrame({'area': area, 'rooms': rooms, 'bathroom': bathroom, 'parking space': parking_space, 'hoa': hoa, 'rent': rent,\n",
+        "                   'property tax': property_tax, 'fire insurance': fire_insurance, 'total': total}, index=city)\n",
+        "plt.tight_layout()\n",
+        "ax = df_.plot.bar(rot=0,figsize=(20,16))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Since, \"rooms\", \"bathrooms\" and \"parking space\" aren't visible in above plot making a different plot for them:"
+      ],
+      "metadata": {
+        "id": "nFBc1rhdFKup"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_ = pd.DataFrame({'rooms': rooms, 'bathroom': bathroom, 'parking space': parking_space}, index=city)\n",
+        "plt.tight_layout()\n",
+        "ax = df_.plot.bar(rot=0,figsize=(15,10))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 610
+        },
+        "id": "0TmIiModFb2_",
+        "outputId": "9608f30b-716b-456b-81da-3b2c6d4e7895"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 0 Axes>"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1080x720 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "XDQ41S_Z4BL3"
+      },
+      "source": [
+        "# Part 2: Dependence of House Association Tax, property tax, and fire insurance on other features."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Preprocessing:\n",
+        "<ol>\n",
+        "  <li>Made furnished as 1 and else 0</li>\n",
+        "  <li>Made acept in animals column as 1 and else 0</li>\n",
+        "  <li>changed the dtype of floor column to int</li>\n",
+        "</ol>\n"
+      ],
+      "metadata": {
+        "id": "Bik2aVT1Fzsx"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 357
+        },
+        "id": "EA9bJZdl4ERf",
+        "outputId": "1f95bce3-56cc-4dc8-c826-10752f060774"
+      },
+      "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       1   \n",
+              "1     São Paulo   320      4         4               0     20       1   \n",
+              "2  Porto Alegre    80      1         1               1      6       1   \n",
+              "3  Porto Alegre    51      2         1               0      2       1   \n",
+              "4     São Paulo    25      1         1               0      1       0   \n",
+              "\n",
+              "   furniture  hoa_(R$)  rent_amount_(R$)  property_tax_(R$)  \\\n",
+              "0          1      2065              3300                211   \n",
+              "1          0      1200              4960               1750   \n",
+              "2          0      1000              2800                  0   \n",
+              "3          0       270              1112                 22   \n",
+              "4          0         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",
+              "  <div id=\"df-99c13f7e-8bb6-4da5-90a6-ee01b63ab7a6\">\n",
+              "    <div class=\"colab-df-container\">\n",
+              "      <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>city</th>\n",
+              "      <th>area</th>\n",
+              "      <th>rooms</th>\n",
+              "      <th>bathroom</th>\n",
+              "      <th>parking_spaces</th>\n",
+              "      <th>floor</th>\n",
+              "      <th>animal</th>\n",
+              "      <th>furniture</th>\n",
+              "      <th>hoa_(R$)</th>\n",
+              "      <th>rent_amount_(R$)</th>\n",
+              "      <th>property_tax_(R$)</th>\n",
+              "      <th>fire_insurance_(R$)</th>\n",
+              "      <th>total_(R$)</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>São Paulo</td>\n",
+              "      <td>70</td>\n",
+              "      <td>2</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>7</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>2065</td>\n",
+              "      <td>3300</td>\n",
+              "      <td>211</td>\n",
+              "      <td>42</td>\n",
+              "      <td>5618</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>São Paulo</td>\n",
+              "      <td>320</td>\n",
+              "      <td>4</td>\n",
+              "      <td>4</td>\n",
+              "      <td>0</td>\n",
+              "      <td>20</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1200</td>\n",
+              "      <td>4960</td>\n",
+              "      <td>1750</td>\n",
+              "      <td>63</td>\n",
+              "      <td>7973</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>Porto Alegre</td>\n",
+              "      <td>80</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>6</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1000</td>\n",
+              "      <td>2800</td>\n",
+              "      <td>0</td>\n",
+              "      <td>41</td>\n",
+              "      <td>3841</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>Porto Alegre</td>\n",
+              "      <td>51</td>\n",
+              "      <td>2</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>2</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>270</td>\n",
+              "      <td>1112</td>\n",
+              "      <td>22</td>\n",
+              "      <td>17</td>\n",
+              "      <td>1421</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>São Paulo</td>\n",
+              "      <td>25</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>800</td>\n",
+              "      <td>25</td>\n",
+              "      <td>11</td>\n",
+              "      <td>836</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-99c13f7e-8bb6-4da5-90a6-ee01b63ab7a6')\"\n",
+              "              title=\"Convert this dataframe to an interactive table.\"\n",
+              "              style=\"display:none;\">\n",
+              "        \n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "       width=\"24px\">\n",
+              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
+              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
+              "  </svg>\n",
+              "      </button>\n",
+              "      \n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      flex-wrap:wrap;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "      <script>\n",
+              "        const buttonEl =\n",
+              "          document.querySelector('#df-99c13f7e-8bb6-4da5-90a6-ee01b63ab7a6 button.colab-df-convert');\n",
+              "        buttonEl.style.display =\n",
+              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "        async function convertToInteractive(key) {\n",
+              "          const element = document.querySelector('#df-99c13f7e-8bb6-4da5-90a6-ee01b63ab7a6');\n",
+              "          const dataTable =\n",
+              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                     [key], {});\n",
+              "          if (!dataTable) return;\n",
+              "\n",
+              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "            + ' to learn more about interactive tables.';\n",
+              "          element.innerHTML = '';\n",
+              "          dataTable['output_type'] = 'display_data';\n",
+              "          await google.colab.output.renderOutput(dataTable, element);\n",
+              "          const docLink = document.createElement('div');\n",
+              "          docLink.innerHTML = docLinkHtml;\n",
+              "          element.appendChild(docLink);\n",
+              "        }\n",
+              "      </script>\n",
+              "    </div>\n",
+              "  </div>\n",
+              "  "
+            ]
+          },
+          "metadata": {},
+          "execution_count": 42
+        }
+      ],
+      "source": [
+        "df1['furniture']=df1.furniture.eq('furnished').mul(1)\n",
+        "df1['animal']=df1.animal.eq('acept').mul(1)\n",
+        "df1.columns = df1.columns. str. replace(' ','_')\n",
+        "df1['floor']=df1['floor'].replace('-',0).astype(int)\n",
+        "df1.head(5)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "dx8wN90X8z14"
+      },
+      "source": [
+        "### Intuition: \n",
+        "Getting idea for the range of some columns"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "RJKAfX0167Hn",
+        "outputId": "4358a72d-d4fe-4cba-ad89-cf5c29b7f536"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "46335"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 43
+        }
+      ],
+      "source": [
+        "df1.area.max()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "JHJEB5RZ-8Kh",
+        "outputId": "a5fae086-611b-4209-c858-3f0f15f3509a"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "11"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 44
+        }
+      ],
+      "source": [
+        "df1.area.min()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "W1I4jI9LBGBI",
+        "outputId": "3f8ed13a-e25a-4059-e95d-3e65aea69c21"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "13"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 45
+        }
+      ],
+      "source": [
+        "df1.rooms.max()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "E_sGuA_QBKOF",
+        "outputId": "0279738a-9387-44e2-f47a-ce1187cf4449"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "1"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 46
+        }
+      ],
+      "source": [
+        "df1.rooms.min()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "j-ovo9vEBKRc",
+        "outputId": "46853785-179c-48b1-aa77-d12ed1e0a1dc"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "10"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 47
+        }
+      ],
+      "source": [
+        "df1.bathroom.max()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "NC1lm-8KBKU0",
+        "outputId": "1c5b3d22-9be6-4847-efb4-059b52e46233"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "1"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 48
+        }
+      ],
+      "source": [
+        "df1.bathroom.min()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "wamrXoGlBKa2",
+        "outputId": "7b1b95e3-f294-4a67-d198-4c8330d6bb91"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "12"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 49
+        }
+      ],
+      "source": [
+        "df1.parking_spaces.max()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "kCuzFpThBKe_",
+        "outputId": "132b978b-5ff0-45d5-9ff8-012e9541998d"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "0"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 50
+        }
+      ],
+      "source": [
+        "df1.parking_spaces.min()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ac6x22FKFhJc",
+        "outputId": "c41a05c5-a32a-45ee-b1c8-82eb15161e45"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "301"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 51
+        }
+      ],
+      "source": [
+        "df1.floor.max()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "b0srWVjxBVtN",
+        "outputId": "5f8c450f-44e8-4b7f-b181-e59564d8cef3"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "0"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 52
+        }
+      ],
+      "source": [
+        "df1.floor.min()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "txlC7ZkgHWse"
+      },
+      "source": [
+        "## Floors\n",
+        "Calculating how number of floors affect the taxes"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "vj4ZmdwyHaRF"
+      },
+      "outputs": [],
+      "source": [
+        "#three columns for storing three taxes\n",
+        "bel_two=np.array([0,0,0])\n",
+        "two_five=np.array([0,0,0])\n",
+        "five_thirty=np.array([0,0,0])\n",
+        "thirty_seventy=np.array([0,0,0])\n",
+        "seventy_abv=np.array([0,0,0])\n",
+        "\n",
+        "floor_2=df1[df1[\"floor\"]<=2]\n",
+        "bel_two[0]= sum(floor_2[\"hoa_(R$)\"])/floor_2.size\n",
+        "bel_two[1]= sum(floor_2[\"property_tax_(R$)\"])/floor_2.size\n",
+        "bel_two[2]= sum(floor_2[\"fire_insurance_(R$)\"])/floor_2.size\n",
+        "\n",
+        "floor_5= df1.loc[(df1[\"floor\"]>2) & (df1[\"floor\"]<=5)]\n",
+        "two_five[0]= sum(floor_5[\"hoa_(R$)\"])/floor_5.size\n",
+        "two_five[1]= sum(floor_5[\"property_tax_(R$)\"])/floor_5.size\n",
+        "two_five[2]= sum(floor_5[\"fire_insurance_(R$)\"])/floor_5.size\n",
+        "\n",
+        "floor_30= df1.loc[(df1[\"floor\"]>5) & (df1[\"floor\"]<=30)]\n",
+        "five_thirty[0]= sum(floor_30[\"hoa_(R$)\"])/floor_30.size\n",
+        "five_thirty[1]= sum(floor_30[\"property_tax_(R$)\"])/floor_30.size\n",
+        "five_thirty[2]= sum(floor_30[\"fire_insurance_(R$)\"])/floor_30.size\n",
+        "\n",
+        "floor_70= df1.loc[(df1[\"floor\"]>30) & (df1[\"floor\"]<=70)]\n",
+        "thirty_seventy[0]= sum(floor_70[\"hoa_(R$)\"])/floor_70.size\n",
+        "thirty_seventy[1]= sum(floor_70[\"property_tax_(R$)\"])/floor_70.size\n",
+        "thirty_seventy[2]= sum(floor_70[\"fire_insurance_(R$)\"])/floor_70.size\n",
+        "\n",
+        "floor_300=df1.loc[(df1[\"floor\"]>70)]\n",
+        "seventy_abv[0]= sum(floor_300[\"hoa_(R$)\"])/floor_300.size\n",
+        "seventy_abv[1]= sum(floor_300[\"property_tax_(R$)\"])/floor_300.size\n",
+        "seventy_abv[2]= sum(floor_300[\"fire_insurance_(R$)\"])/floor_300.size\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "KS0tvOP_IKXL",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 610
+        },
+        "outputId": "37801a77-0412-44dc-e747-7c13d93b0a74"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 0 Axes>"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1080x720 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ],
+      "source": [
+        "tax=np.array([\"House association tax\",\"property tax\",\"Fire insurance\"])\n",
+        "dfo = pd.DataFrame({'<2 floors': bel_two, '3-5 floors': two_five, '5-30 floors': five_thirty, '30-70 floors': thirty_seventy, '70+ floors': seventy_abv}, index=tax)\n",
+        "plt.tight_layout()\n",
+        "ax = dfo.plot.bar(rot=0,figsize=(15,10))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Observations:\n",
+        "<ul>\n",
+        "  <li>Every tax follows almost same pattern: \n",
+        "    <ul>\n",
+        "      <li>It increases with increase of floor</li>\n",
+        "      <li>After reaching maxima at about 5-30 floors it starts decreasing</li>\n",
+        "    </ul>\n",
+        "  </li>\n",
+        "  <li>I think only appartments or company buildings have 20+ floors, so for them the taxes are less</li>\n",
+        "</ul>"
+      ],
+      "metadata": {
+        "id": "xhDxESad7oM-"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Animal and furniture\n",
+        "Calculating how inclusion of animals and furnishing affects the taxes"
+      ],
+      "metadata": {
+        "id": "Bktjtjk87rpj"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "allowed_and_furnished=np.array([0,0,0])\n",
+        "not_allowed_and_furnished= np.array([0,0,0])\n",
+        "allowed_and_not_furnished= np.array([0,0,0])\n",
+        "not_all_and_not_fur=np.array([0,0,0])\n",
+        "\n",
+        "one_1= df1.loc[(df1[\"furniture\"]==1) & (df1[\"animal\"]==1)]\n",
+        "allowed_and_furnished[0]= sum(one_1[\"hoa_(R$)\"])/one_1.size\n",
+        "allowed_and_furnished[1]= sum(one_1[\"property_tax_(R$)\"])/one_1.size\n",
+        "allowed_and_furnished[2]= sum(one_1[\"fire_insurance_(R$)\"])/one_1.size\n",
+        "\n",
+        "zero_1= df1.loc[(df1[\"furniture\"]==0) & (df1[\"animal\"]==1)]\n",
+        "allowed_and_not_furnished[0]= sum(zero_1[\"hoa_(R$)\"])/zero_1.size\n",
+        "allowed_and_not_furnished[1]= sum(zero_1[\"property_tax_(R$)\"])/zero_1.size\n",
+        "allowed_and_not_furnished[2]= sum(zero_1[\"fire_insurance_(R$)\"])/zero_1.size\n",
+        "\n",
+        "one_0= df1.loc[(df1[\"furniture\"]==1) & (df1[\"animal\"]==0)]\n",
+        "not_allowed_and_furnished[0]= sum(one_0[\"hoa_(R$)\"])/one_0.size\n",
+        "not_allowed_and_furnished[1]= sum(one_0[\"property_tax_(R$)\"])/one_0.size\n",
+        "not_allowed_and_furnished[2]= sum(one_0[\"fire_insurance_(R$)\"])/one_0.size\n",
+        "\n",
+        "zero_0= df1.loc[(df1[\"furniture\"]==0) & (df1[\"animal\"]==0)]\n",
+        "not_all_and_not_fur[0]= sum(zero_0[\"hoa_(R$)\"])/zero_0.size\n",
+        "not_all_and_not_fur[1]= sum(zero_0[\"property_tax_(R$)\"])/zero_0.size\n",
+        "not_all_and_not_fur[2]= sum(zero_0[\"fire_insurance_(R$)\"])/zero_0.size\n"
+      ],
+      "metadata": {
+        "id": "9NCJXwQo75MD"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "dfp = pd.DataFrame({'Animals allowed and furnished': allowed_and_furnished, 'animals allowed but not furnished': allowed_and_not_furnished, \n",
+        "                    'furnished but animals not allowed': not_allowed_and_furnished, 'neither animals allowed nor furnished': not_all_and_not_fur}, index=tax)\n",
+        "plt.tight_layout()\n",
+        "ax = dfp.plot.bar(rot=0,figsize=(15,10))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 610
+        },
+        "id": "By_nk92B-sVF",
+        "outputId": "19a5d8a2-61f8-4764-a38e-63a30752a93c"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 0 Axes>"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1080x720 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Observations:\n",
+        "<ul>\n",
+        "  <li>For some reason when neither animals aren't allowed nor furnitures are furnished, the HAT and PT are very high</li>\n",
+        "</ul>"
+      ],
+      "metadata": {
+        "id": "l9cEkUqLDz66"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## City\n",
+        "How location of houses affects the taxes"
+      ],
+      "metadata": {
+        "id": "TiQAgIVsEGg-"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "city=np.array(['Belo Horizonte','Campinas','Porto Alegre','Rio de Janeiro','Sao Paulo'])\n",
+        "Belo=np.array([0,0,0])\n",
+        "Campinas=np.array([0,0,0])\n",
+        "Porto=np.array([0,0,0])\n",
+        "Rio=np.array([0,0,0])\n",
+        "Sao=np.array([0,0,0])\n",
+        "\n",
+        "Bel= df1.loc[(df1[\"city\"]==\"Belo Horizonte\")]\n",
+        "Belo[0]= sum(Bel[\"hoa_(R$)\"])/Bel.size\n",
+        "Belo[1]= sum(Bel[\"property_tax_(R$)\"])/Bel.size\n",
+        "Belo[2]= sum(Bel[\"fire_insurance_(R$)\"])/Bel.size\n",
+        "\n",
+        "Campina=df1.loc[(df1[\"city\"]==\"Campinas\")]\n",
+        "Campinas[0]= sum(Campina[\"hoa_(R$)\"])/Campina.size\n",
+        "Campinas[1]= sum(Campina[\"property_tax_(R$)\"])/Campina.size\n",
+        "Campinas[2]= sum(Campina[\"fire_insurance_(R$)\"])/Campina.size\n",
+        "\n",
+        "Sa=df1.loc[(df1[\"city\"]==\"São Paulo\")]\n",
+        "Sao[0]= sum(Sa[\"hoa_(R$)\"])/Sa.size\n",
+        "Sao[1]= sum(Sa[\"property_tax_(R$)\"])/Sa.size\n",
+        "Sao[2]= sum(Sa[\"fire_insurance_(R$)\"])/Sa.size\n",
+        "\n",
+        "Port=df1.loc[(df1[\"city\"]==\"Porto Alegre\")]\n",
+        "Porto[0]= sum(Port[\"hoa_(R$)\"])/Port.size\n",
+        "Porto[1]= sum(Port[\"property_tax_(R$)\"])/Port.size\n",
+        "Porto[2]= sum(Port[\"fire_insurance_(R$)\"])/Port.size\n",
+        "\n",
+        "Ri=df1.loc[(df1[\"city\"]==\"Rio de Janeiro\")]\n",
+        "Rio[0]= sum(Ri[\"hoa_(R$)\"])/Ri.size\n",
+        "Rio[1]= sum(Ri[\"property_tax_(R$)\"])/Ri.size\n",
+        "Rio[2]= sum(Ri[\"fire_insurance_(R$)\"])/Ri.size\n"
+      ],
+      "metadata": {
+        "id": "oT75psz0H-t_"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df2 = pd.DataFrame({'Belo Horizonte': Belo, \n",
+        "                    'Campinas': Campinas, \n",
+        "                    'Porto Alegre': Porto, \n",
+        "                    'Rio de Janeiro': Rio, \n",
+        "                    'Sao Paulo': Sao}, index=tax)\n",
+        "plt.tight_layout()\n",
+        "ax = df2.plot.bar(rot=0,figsize=(20,16))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 936
+        },
+        "id": "k37nm9xbD1Uf",
+        "outputId": "992ae53b-bd90-4f99-b18f-5b2693de090d"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 0 Axes>"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1440x1152 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Observations:\n",
+        "<ul>\n",
+        "  <li>From above graph Bela Horizonte and Sao Paulo demands highest taxes, followed by Rio de Janeiro</li>\n",
+        "</ul>\n"
+      ],
+      "metadata": {
+        "id": "NE8GN6V5MuNB"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "nEwrctszMw2I"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "collapsed_sections": [],
+      "name": "House_predict_Sanidhya.ipynb",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/Assignment/Assignment_2/200864_Sanidhya_Singh.ipynb b/Assignment/Assignment_2/200864_Sanidhya_Singh.ipynb
new file mode 100644
index 0000000..0047a6d
--- /dev/null
+++ b/Assignment/Assignment_2/200864_Sanidhya_Singh.ipynb
@@ -0,0 +1,945 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "200864_Sanidhya_Singh.ipynb",
+      "provenance": [],
+      "collapsed_sections": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "rvFM645NE-D2"
+      },
+      "source": [
+        "# Assignment 2\n",
+        "In this assignment, we will go through Perceptron, Linear Classifiers, Loss Functions, Gradient Descent and Back Propagation.\n",
+        "\n",
+        "\n",
+        "PS. this one is not from Stanford's course.\n",
+        "\n",
+        "\n",
+        "\n",
+        "\\\n",
+        "\n",
+        "## Instructions\n",
+        "* This notebook contain blocks of code, you are required to complete those blocks(where required)\n",
+        "* You are required to copy this notebook (\"copy to drive\" above) and complete the code.(DO NOT CHANGE THE NAME OF THE FUNCTIONS)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": true,
+        "id": "QLtp15rqE-EU"
+      },
+      "source": [
+        "# Part 1: Perceptron\n",
+        "In this section, we will see how to implement a perceptron. Goal would be for you to delve into the mathematics.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Zao4e-DphaGA"
+      },
+      "source": [
+        "## Intro\n",
+        "What's a perceptron? It's an algorithm modelled on biological computational model to classify things into binary classes. It's a supervides learning algorithm, meaning that you need to provide labelled data containing features and the actual classifications. A perceptron would take these features as input and spit out a binary value (0 or 1). While training the model with training data, we try to minimise the error and learn the parameters involved."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "wDTUoAd6ixm-"
+      },
+      "source": [
+        "**How does it work?**\\\n",
+        "A perceptron is modelled on a biological neuron. A neuron has input dendrites and the output is carried by axons. Similarly, a perceptron takes inputs called \"features\". After processing, a perceptron gives output. For computation, it has a \"weight\" vector which is multipled with feature vector. An activation function is added to introduce some non linearities and the output is given out.\\\n",
+        "It can be represented as: $$  f=\\sum_{i=1}^{m} w_ix_i +b$$\n",
+        "\n",
+        "Let's implement this simple function to give an output.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "iXezofBIgzId"
+      },
+      "source": [
+        "import numpy as np\n",
+        "\n",
+        "class perceptron():\n",
+        "    def __init__(self,num_input_features=8):\n",
+        "        self.weights = np.random.randn(num_input_features)\n",
+        "        self.bias = np.random.random()\n",
+        "\n",
+        "    def activation(self,x):\n",
+        "        '''\n",
+        "            Implement heavside step activation function here (google ;))\n",
+        "        '''\n",
+        "        return np.heaviside(x,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",
+        "        # YOUR CODE HERE\n",
+        "        return perceptron.activation(self, np.dot(x, self.weights) + self.bias )\n",
+        "        pass\n",
+        "        # YOUR CODE HERE"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "oSKwDFAyocVo"
+      },
+      "source": [
+        "np.random.seed(0)\n",
+        "perc = perceptron(8)\n",
+        "assert perc.forward(np.arange(8))==1"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "collapsed": true,
+        "id": "NWTTg1e9r7uM"
+      },
+      "source": [
+        "# Part 2: Linear Classifier\n",
+        "In this section, we will see how to implement a linear Classifier.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "DYDO4GcHr7uM"
+      },
+      "source": [
+        "## Intro\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-HFvjH06r7uN"
+      },
+      "source": [
+        "**How does it work?**\n",
+        "\n",
+        "Linear Classifier uses the following function: $$Y = WX+b$$ Where, $W$ is a 2d array of weights with shape (#features, #classes).\n",
+        "\n",
+        "\n",
+        "Let's implement this classifier.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "9A13CEkGr7uN"
+      },
+      "source": [
+        "import numpy as np\n",
+        "\n",
+        "class LinearClassifier():\n",
+        "    def __init__(self,num_input_features=32,num_classes=5):\n",
+        "        self.weights = np.random.randn(num_input_features,num_classes)\n",
+        "        self.bias = np.random.rand(num_classes)\n",
+        "\n",
+        "    def forward(self,x: np.ndarray):\n",
+        "        '''\n",
+        "            x: input features\n",
+        "            you have random initialized weights and bias\n",
+        "            you can access then using `self.weights` and `self.bias`\n",
+        "            return an output vector of num_classes size\n",
+        "        '''\n",
+        "        # YOUR CODE HERE\n",
+        "        return np.dot(x,self.weights) + self.bias\n",
+        "        pass\n",
+        "        # YOUR CODE HERE"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "zgzPxyTsr7uN",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "28102623-20f4-4e05-b680-b959d3045b18"
+      },
+      "source": [
+        "np.random.seed(0)\n",
+        "lc = LinearClassifier()\n",
+        "lc.forward(np.random.rand(1,32))\n",
+        "# Should be close to:\n",
+        "# array([[ 1.30208164,  5.58136003,  0.87793013, -4.7332119 ,  4.81172123]])"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "array([[ 1.30208164,  5.58136003,  0.87793013, -4.7332119 ,  4.81172123]])"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 100
+        }
+      ]
+    },
+    {
+      "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",
+        "    return abs(y - z) / 2\n",
+        "    pass"
+      ],
+      "execution_count": null,
+      "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",
+        "    return abs(y - z)**2 / 2\n",
+        "    pass"
+      ],
+      "execution_count": null,
+      "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",
+        "    return max(0, 1 - y * z)\n",
+        "    pass"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "m15_MjradMNY"
+      },
+      "source": [
+        "### **Cross Entropy Loss**\n",
+        "Another very famous loss function is Cross Entropy loss: $ L = −[ylog(z)+(1−y)log(1−z)] $."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "snJLqhszdMNY"
+      },
+      "source": [
+        "import numpy as np\n",
+        "import math\n",
+        "def CELoss(z,y):\n",
+        "    '''\n",
+        "        y : True output. \n",
+        "        z : Predicted output. \n",
+        "        return : L\n",
+        "    '''\n",
+        "    return -1 * (y * math.log(z) + (1 - y) * math.log(1 - z))\n",
+        "    pass"
+      ],
+      "execution_count": null,
+      "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",
+        "    pass"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "CWhbibHcgRR8"
+      },
+      "source": [
+        "## Cost Function\n",
+        "The cost function $J$ is commonly used to assess the performance of a model, and is defined with the loss function $L$ as follows:\n",
+        "$$\\boxed{J(\\theta)=\\sum_{i=1}^mL(h_\\theta(x^{(i)}), y^{(i)})}$$\n",
+        "where $h_\\theta$ is the hypothesis function i.e. the function used to predict the output."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "SSbmhW4og97t"
+      },
+      "source": [
+        "lossFunctions = {\n",
+        "    \"l1\" : L1Loss,\n",
+        "    \"l2\" : L2Loss,\n",
+        "    \"hinge\" : hingeLoss,\n",
+        "    \"cross-entropy\" : CELoss,\n",
+        "    \"0-1\" : zeroOneLoss\n",
+        "}\n",
+        "\n",
+        "def cost(Z : np.ndarray, Y : np.ndarray, loss : str):\n",
+        "    '''\n",
+        "        Z : a numpy array of predictions.\n",
+        "        Y : a numpy array of true values.\n",
+        "        return : A numpy array of costs calculated for each example.\n",
+        "    '''\n",
+        "    loss_func = lossFunctions[loss]\n",
+        "    # YOUR CODE HERE\n",
+        "    J = None\n",
+        "    J = loss_func(Z, Y)\n",
+        "    return J\n",
+        "    # YOUR CODE HERE\n",
+        "    pass"
+      ],
+      "execution_count": null,
+      "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": "29102506-62fa-40f9-94d8-bea505989a55"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "2.8.0\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "yyplk5PLEUsJ",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "819555a3-746d-4c69-f1e1-8d97778835bf"
+      },
+      "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": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "(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": 797
+        },
+        "outputId": "08f1245e-916a-4d84-fe20-b8e564baa21f"
+      },
+      "source": [
+        "'''visualize data by plotting images'''\n",
+        "# YOUR CODE HERE\n",
+        "def visualize(x, y, index):\n",
+        "  plt.figure(figsize= (15, 2))\n",
+        "  plt.imshow(x_train[index])\n",
+        "  plt.xlabel(y_train[index]);\n",
+        "\n",
+        "for i in range(5):\n",
+        "  visualize(x_train[i], y_train[i], i);\n",
+        "pass\n",
+        "# YOUR CODE HERE"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1080x144 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1080x144 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1080x144 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1080x144 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1080x144 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "yJgho2AEBFbx",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "71d64cf7-1f11-4682-8edf-5d0a76332aef"
+      },
+      "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",
+        "#YOUR CODE HERE\n",
+        "visible= Input(shape = (32, 32, 3,))\n",
+        "conv1 = Conv2D(32, kernel_size=4, activation='relu')(visible)\n",
+        "pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\n",
+        "conv2 = Conv2D(16, kernel_size=4, activation='relu')(pool1)\n",
+        "pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)\n",
+        "flat = Flatten()(pool2)\n",
+        "#YOUR CODE HERE\n",
+        " \n",
+        "'''Hidden layer'''\n",
+        "# YOUR CODE HERE\n",
+        "hidden1 = Dense(32, activation='relu')(flat)\n",
+        "# YOUR CODE HERE\n",
+        " \n",
+        "\"\"\"last hidden layer i.e.. output layer\"\"\"\n",
+        "# YOUR CODE HERE\n",
+        "output= Dense(10, activation= 'sigmoid')(hidden1)\n",
+        "# YOUR CODE HERE\n",
+        " \n",
+        "'''model description'''\n",
+        "model =  Model(inputs= visible, outputs= output)\n",
+        "model.summary()\n",
+        "# the above line is not commented"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "number of classes: 10\n",
+            "Model: \"model_18\"\n",
+            "_________________________________________________________________\n",
+            " Layer (type)                Output Shape              Param #   \n",
+            "=================================================================\n",
+            " input_19 (InputLayer)       [(None, 32, 32, 3)]       0         \n",
+            "                                                                 \n",
+            " conv2d_13 (Conv2D)          (None, 29, 29, 32)        1568      \n",
+            "                                                                 \n",
+            " max_pooling2d_13 (MaxPoolin  (None, 14, 14, 32)       0         \n",
+            " g2D)                                                            \n",
+            "                                                                 \n",
+            " conv2d_14 (Conv2D)          (None, 11, 11, 16)        8208      \n",
+            "                                                                 \n",
+            " max_pooling2d_14 (MaxPoolin  (None, 5, 5, 16)         0         \n",
+            " g2D)                                                            \n",
+            "                                                                 \n",
+            " flatten_6 (Flatten)         (None, 400)               0         \n",
+            "                                                                 \n",
+            " dense_36 (Dense)            (None, 32)                12832     \n",
+            "                                                                 \n",
+            " dense_37 (Dense)            (None, 10)                330       \n",
+            "                                                                 \n",
+            "=================================================================\n",
+            "Total params: 22,938\n",
+            "Trainable params: 22,938\n",
+            "Non-trainable params: 0\n",
+            "_________________________________________________________________\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "PLc4Bay65TyA"
+      },
+      "source": [
+        "# Compile\n",
+        "'''\n",
+        "  YOUR CODE HERE\n",
+        "'''\n",
+        "model.compile(optimizer='adam',\n",
+        "              loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), \n",
+        "              metrics=['accuracy'])"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Fit\n",
+        "'''\n",
+        "  YOUR CODE HERE\n",
+        "'''\n",
+        "model.fit(x_train, y_train, epochs=10)"
+      ],
+      "metadata": {
+        "id": "U0fGsDCRsQrn",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "72701208-f5ec-4925-9e62-6f958c086a0b"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "metadata": {
+            "tags": null
+          },
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Epoch 1/10\n"
+          ]
+        },
+        {
+          "metadata": {
+            "tags": null
+          },
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/util/dispatch.py:1082: UserWarning: \"`sparse_categorical_crossentropy` received `from_logits=True`, but the `output` argument was produced by a sigmoid or softmax activation and thus does not represent logits. Was this intended?\"\n",
+            "  return dispatch_target(*args, **kwargs)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "1563/1563 [==============================] - 48s 31ms/step - loss: 1.7310 - accuracy: 0.3667\n",
+            "Epoch 2/10\n",
+            "1563/1563 [==============================] - 48s 30ms/step - loss: 1.4235 - accuracy: 0.4861\n",
+            "Epoch 3/10\n",
+            "1563/1563 [==============================] - 49s 31ms/step - loss: 1.3229 - accuracy: 0.5248\n",
+            "Epoch 4/10\n",
+            "1563/1563 [==============================] - 49s 31ms/step - loss: 1.2518 - accuracy: 0.5547\n",
+            "Epoch 5/10\n",
+            "1563/1563 [==============================] - 49s 32ms/step - loss: 1.2030 - accuracy: 0.5731\n",
+            "Epoch 6/10\n",
+            "1563/1563 [==============================] - 49s 31ms/step - loss: 1.1572 - accuracy: 0.5874\n",
+            "Epoch 7/10\n",
+            "1563/1563 [==============================] - 49s 32ms/step - loss: 1.1182 - accuracy: 0.6042\n",
+            "Epoch 8/10\n",
+            "1563/1563 [==============================] - 49s 31ms/step - loss: 1.0887 - accuracy: 0.6155\n",
+            "Epoch 9/10\n",
+            "1563/1563 [==============================] - 48s 31ms/step - loss: 1.0590 - accuracy: 0.6284\n",
+            "Epoch 10/10\n",
+            "1563/1563 [==============================] - 48s 30ms/step - loss: 1.0400 - accuracy: 0.6325\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<keras.callbacks.History at 0x7f766fc1c650>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 112
+        }
+      ]
+    },
+    {
+      "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 imag\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",
+        "print(model.predict(p).argmax())\n",
+        "predicted_label = labels[model.predict(p).argmax()]\n",
+        " \n",
+        "# load the original label\n",
+        "original_label = labels[y_test[image_number]]\n",
+        " \n",
+        "# display the result\n",
+        "print(\"Original label is {} and predicted label is {}\".format(\n",
+        "    original_label, predicted_label))"
+      ],
+      "metadata": {
+        "id": "RDq_RE6osSh8",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 302
+        },
+        "outputId": "c4dcaea3-42fb-4aa1-8783-f779c41eb146"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "3\n",
+            "Original label is cat and predicted label is cat\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD5CAYAAADhukOtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAe7ElEQVR4nO2daYyc13Wm31NfLb1vbLLZXEVJlBVZiSmF1tiJRpGdcaAoCWQDgccewFAAIwqCCIiBzA/BA4w9wPxwBmMb/jHwgB5rrBgeyxrbgoREyNiWgwiGHUnURi3UQnGRSDbZJJu9d+1nflTJQ2nue7vJZlfTvu8DEKy+p+/3nbr1nfqq71vnHHN3CCF+/cmttwNCiM6gYBciERTsQiSCgl2IRFCwC5EICnYhEiG/mslmdgeArwHIAPwPd/9S7Pf7u/O+YaAYPlb8PBftW0xSdHBb9FxkWvR4/Ghxo8feh2P+h20WOxmZAwAxZfbSZFvuR+xo7hd/DbSOydaD04w+6UvzI/bsmKUZcYP5OLNQx1KlEXTykoPdzDIA/w3AxwAcB/C0mT3q7q+wORsGivjCv7s+fDxv0nMVC2E3LccDolqtUFu9UePnKobfjACg0Qz76JFXxXINastl1ASv9fJjgh+zUCwHx7PIS2057n+jWae2Wp2/Zs0mCQrjftTD1ygAoMKOh+UCN+xj7E29WuXXR6MRWcfINZyLvGZVcl0t8KXHYjV8vG//5ETEh0vnFgCH3P2wu1cBPAjgrlUcTwixhqwm2LcCePuCn4+3x4QQVyBrvkFnZveY2X4z2z+/FPlcIoRYU1YT7CcAbL/g523tsXfh7vvcfa+77+3rXtV+oBBiFawm2J8GsNvMdplZEcCnADx6edwSQlxuLvlW6+51M7sXwP9BS3q7391fjs6BoUreX9yX+ESyW1kC37HOgW915/ORHfJLULyswCdVqlVqqzcjPkaktyyyi58n06zJd5hR58pFbBe5GfG/al3B8UZW4nNix2vw9bAm99GImtAVec3yxm25fES5qEXW2PifsE7W2CM6Q5aFfYwpE6v6XO3ujwF4bDXHEEJ0Bn2DTohEULALkQgKdiESQcEuRCIo2IVIhA5/y8XhLLHCufzjjfAca3CpplnjklfWHZFxwJMZmOTVjEg/xUKB2urObc1a5LlFzlevh20WyeTKRWQ+y3hikGdheQ0Alhphie3UOS5PLVS5j/PzfF7mfD36u8LrWDT+Og/0dFNbd4lLaM0cv+ZyURkt7CO/OoAaS76KaG+6swuRCAp2IRJBwS5EIijYhUgEBbsQidDR3XhzR75Bdt2zyG4xSeIoZZH8+HxsWzKS6EASDADQRJh6rFhYjvtRKPJd381XXUdts9Nnqe3sucXwufJ8Vz2HSHJKnV8iS879P3gs7KOXRuicWsYTm6p9fOd/fmaK2k5MTgfH+0r8eTVOhecAwI4xvo4b+vk6duVj5azC13Excgk3iAIRK7elO7sQiaBgFyIRFOxCJIKCXYhEULALkQgKdiESYR3KvYalAcsP8RlETqjHOnDkuCxXrfOEhWKkRlqjQWqFRRJTEJFCipE6aP/q33yM2p75+S+o7eT0ueD4QkRCqze45HXs+BlqO3KCdx8pDY0Hx7eN7aJzvNRPbdU8f10KfRuprV6eD46fmzxJ5/QMcXnw+PxpaiuTWokAMNbP01p6CuFEmEYtLKMCAGviE+nkpTu7EKmgYBciERTsQiSCgl2IRFCwC5EICnYhEmFV0puZHQUwB6ABoO7ue2O/37QcKrmwvDKz2EPnNUh7ouE+Lq8NZFwOy0fqsTUjshyTNWhdPcSz6BYXz1PbT//+EWo7Pc3r9Z2eD5/v2Al+rmMTb1Nb1tVHbY1sgNp6B0aD44Uefrx8F8+iK0VaMnXluHR4thpuKza+bQedU15aoLYjR7j0NjVTprbM+PO+amPYVmhwKc9YXcaI1Hs5dPaPuDvPuRRCXBHoY7wQibDaYHcAPzKzZ8zsnsvhkBBibVjtx/hb3f2EmW0C8GMze9Xdn7jwF9pvAvcAwHA/r/IhhFhbVnVnd/cT7f8nATwM4JbA7+xz973uvrevex2+ii+EALCKYDezXjPrf+cxgD8A8NLlckwIcXlZza12DMDD7a3+PID/5e7/GJtQbxrOLIUzfKZqPOvtiZ//c3D8N3ZzyeUj7w9LPwAwHClu2SSZbQCQI216cjme0dRw3rYooibhyLEj1Da1xDPAvGc4OJ71ceknNzxHbd1Dg9RWLXOpqUraKw0M89dsoI/bJk+dorbZ87zgZH8xfIl3dXOZ763zXFwq9G+itjOn3qK2vtN8jTcPhH3ptkimIinCioisfMnB7u6HAXzgUucLITqLpDchEkHBLkQiKNiFSAQFuxCJoGAXIhE62+stKyE/GC44uHiOv+/UiuGCglOLYSkMABarvDfYQJFntjVJ3622MTicZTxjr1zlEs8ZnryGs3NcAowVRBzeGM7mWmjO0jmj4D5mkUy0aoGvY3khLDWV57kfO8c2UNsikdAAYJJktgGAFcIy5cwUL+aISAHRpQWeEZcV+XUwOcuzDidIttzOUX5951hCXKzFITcJIX6dULALkQgKdiESQcEuRCIo2IVIhI7uxnd19+J9v/X/ZcECAI7/y2t0Xt9geDf+lg+HjwUAPdkxaquSnWIAyOV5UosVwjvTDedJPP2btlPb8wcOUVvfEN+Z3rrz/dTmufDucyGyc96shFtGAUC1GmmxFVmrjCRxvPzCATpnoBRpkdTLk2R6I3XtTp4K14yrE2UFADKygw8Aw/1cnZhp8KSn81PcduTUTHB8y9hmOifPFKVIdpXu7EIkgoJdiERQsAuRCAp2IRJBwS5EIijYhUiEjkpvuSyPnsGwpLTz6uvovCWiWuzYdS2dM1rj0sr0ES7L1SKJMI16ONHhlts+TufsuJp3xNr1m0ep7ZnnXqC24T4uyZycDNdPyzsv410qcMkLfBkxH0kKmSF14YZ7+bkip0IjIpWNbgxLswBQqYVfz7Pnw3IXAFikZVd/pE5ePuPhVC3zxJvDbx8Pjm8c4jLf7m3hNmoeuX/rzi5EIijYhUgEBbsQiaBgFyIRFOxCJIKCXYhEWFZ6M7P7AfwxgEl3v7E9NgLgewCuAnAUwCfdnRfZeudYuRyyUjhD6eTpg3Tent/+YHC8d5DX/MrmTlBbox5pkROpdXb47XC23K3D4bp6AICebdTU38vlmK48z+TqjtQ66yqSjK1IXbWtW8ap7ZU336S2YpHX+ZudC6/VVdt20znXXX8DtU1N8curb4BnHZ48NRkctxyv7zY0zGv8zURqyWURya67h/u4NBe+Dg6R6w0Auovhc9XqkSxFavl/fAvAHe8Zuw/A4+6+G8Dj7Z+FEFcwywZ7u9/6e78hcReAB9qPHwDAv1UihLgiuNS/2cfcfaL9+BRaHV2FEFcwq96gc3dH5JuOZnaPme03s/0zM7xmuBBibbnUYD9tZuMA0P4/vAsCwN33ufted987ODhwiacTQqyWSw32RwHc3X58N4BHLo87Qoi1YiXS23cB3A5g1MyOA/gCgC8BeMjMPgvgGIBPruRkZhkKXeG7e7nMCyJWKuG0t0JEgurp5Z8ieiMtjUoZz3rry4f7NX1r3zfpnD/5t/dSW2HhFLUVS5HspRz3cdfVW4Pjk1Mn6ZzyPM9e27xplNqmZrl0WKmGX8+rr+WZitdcyzMfZ557ltoW5uapbXYh7GO9wSWqpaVwOyYAGBoapLaGc6lsYIhn+9Wr4dczy/H+YMcnwh+mqyTLD1hBsLv7p4np95ebK4S4ctA36IRIBAW7EImgYBciERTsQiSCgl2IROhowUmYwbKwBLEYkX/Ki0vB8UKkJ9fcOZ7lhYxLbwXwQoTjQ+FMqTcO8p5tJ49zGxa5HHbs+FFqu2kz73G3dWe4GOWWSf6N5oVDvADnSCnSx26Iy3KHDx8Njo9vCUuDADA9y79hWYtIZafP8F51TbfguEWKQy5GpDfL8esqfKYWvZFClWiGs+yKFr7uAaB6LizbeqRsp+7sQiSCgl2IRFCwC5EICnYhEkHBLkQiKNiFSITOSm8OgPTsypxLK+Oj4f5wPV1cevvpAV4ocThSlG/3CM9O6iqFZZdinks1ZyaPUluzwosX7riGF7HMIs+7Z2A4OD46xgtfnpviWWMzkcy2RkTd3Ej6r+UjcmmZZH8B8WyupTLPDqsTJ9k4AJQrPAOzXuf3xw2jm6jNjF9XRQtfPyWL9B30cMZnIVL0Und2IRJBwS5EIijYhUgEBbsQiaBgFyIROrobbwYU8uFkksE+npwy1B+2WZPvVs46Tzw4e56nLIz28yXpLYZ3VBu5cI08ADh68ii1jQ3zemY7r+WtkMr8dHjqmXAbrRMTfOe/vy+8gw8AhQJv8fTyobe4I+Q+0ozcXyqR3fj5BZ4UMjTC2zXVSSLMxGlaEBm9/fx1yWc80aSnh9dELLK2XABQCyfyNBam6ZSxTf3B8XyBt7XSnV2IRFCwC5EICnYhEkHBLkQiKNiFSAQFuxCJsJL2T/cD+GMAk+5+Y3vsiwD+HMCZ9q993t0fW8kJMwtLIZs3hWuntZwkMk4kAWJ8G08k2R+Rw6aNS3aehevkDY7ypIrBAZ4AUegKyycAcFVEeusbDCcGAcD/vP/bwfHFyFrNLk1R2+ISrw1YiFw9m4fDz7s8xevdLZBEIwAYHOCvy6uvvUFtp0+fCY7PRlpGDQ3xJzbQ20dtmXNNtFDl65iRWoQbe/nxBrvCcZSP3L5Xcmf/FoA7AuNfdfc97X8rCnQhxPqxbLC7+xMA+Fu/EOJXgtX8zX6vmR0ws/vNjH8FSwhxRXCpwf51ANcA2ANgAsCX2S+a2T1mtt/M9k9P86//CSHWlksKdnc/7e4Nd28C+AYA2rXA3fe5+1533zs0xBsOCCHWlksKdjMbv+DHTwB46fK4I4RYK1YivX0XwO0ARs3sOIAvALjdzPagVVXuKIC/WMnJcrkczf4ZGObSW70RdrOU55lE1+3aQW37n+GS12zhWmpr2lxwfGwrl9deOfgv1PY7v/dn1PaLn/N5CwuRNknVs8HxyVNv0zmx9/z5GrflwaWh4Vw4y25rN/d95gyX0OoZ3xYa28RtjUY4k24p0uKpvMTr7i1EaujVm1zOq5VPUNumQjijb0sfz6Kr1MNzYnfvZYPd3T8dGP7mcvOEEFcW+gadEImgYBciERTsQiSCgl2IRFCwC5EIHS04mcvl0NsXzl4aHh2l8+oWdrOcK9I5XX0D1DY0xAsKvvX2KWq79YPvD/sxz9tJ9fSHs64AYOLEcWo79Prr1FZv8PZEOVJvcGF2hs7p3zBObTMzXIYa7OPFKN933Y3B8adfeJXOefbVo9R26+1/SG2FIpeoDh86FByfmePPK1YUs7zE5bWdY1zS7e7lBVVHRsLzPM8LcNar4cKXTrJKAd3ZhUgGBbsQiaBgFyIRFOxCJIKCXYhEULALkQgdld7cm2jWw5LH4Agv5LewFC5EuNjgfbeyjL+P7di+jdpef5lnXs0shiW2vl6eYbf9GmrCsdd58cUTJyeo7cMf/iC1LS6GpaH+LVvpnJEtvDjnW1NcKluqcMmx2BvuvzawcTudc1M/f13OnAn3QwOAo8deoLaFpbBMOT3DJbSNGzdS26Dz12VnH5dENw3wHmwFC2cCVmu8v10vkdhy4DGhO7sQiaBgFyIRFOxCJIKCXYhEULALkQgd3Y1v1muYOxfezeyO1PaqlMO7nNbk7pvxXcnREd4+6fXcYWqbnAq38DmX8V3pwT5eW+/6G3lCzuFjvGZcjXdJwvRsWO3YvXs3nbN7F5cMjk3wBJqXX36R2s6dDSenFEtcdRnu44kkx1/mqsCpc7yunZFkqSzSeivWOmwnzzPBjn6eGNSV40ktlXL4+mk2eW3DWp0cj1/2urMLkQoKdiESQcEuRCIo2IVIBAW7EImgYBciEVbS/mk7gL8DMIbWxv4+d/+amY0A+B6Aq9BqAfVJdw/3/GlTqVRw+FBY2tqx+zfovK5cWHprVnmiQL4rIoNEbP39XBrqGwjXtbv++vfROT/50WPUtjjD6931jGyitkPHJ6lt+7ZwUs6u991M55SK/DK4egdP8pme4i/3KwfDCUVN57rhiWmeSDJLkqEAoNzgsu3sdFiK3LSZJ928dY7XpxvZzuXScyXuB5r8uU3Xw8/N8/w6rZDjVcETblZyZ68D+Bt3vwHAhwD8lZndAOA+AI+7+24Aj7d/FkJcoSwb7O4+4e7Pth/PATgIYCuAuwA80P61BwB8fK2cFEKsnov6m93MrgJwE4AnAYy5/zK59xRaH/OFEFcoKw52M+sD8AMAn3P3d30/0d0d5It6ZnaPme03s/1zc7xggBBibVlRsJtZAa1A/467/7A9fNrMxtv2cQDBXSN33+fue919b2zzSwixtiwb7GZmaPVjP+juX7nA9CiAu9uP7wbwyOV3TwhxuVhJ1tvvAvgMgBfN7Pn22OcBfAnAQ2b2WQDHAHxyuQMtVup4/lBYNtpx4y10XhPhbDNjmT8A0OTpP7Nzc9Q2PX2W2jaM7AmO33nHR+icPR+4ntoe+uHD1GbGJZTBwWFq27olLCn1DQzROVk9vL4AMLKZXyLju2rUNtMdlo2ee4HXi5uY5yllXuDtvAY38yzG0WvCUlkWkbUazv14zcPtywDg0CkuDxYzfsylcjk4vhi5vOvN8PUx1+DZgcsGu7v/DADz9PeXmy+EuDLQN+iESAQFuxCJoGAXIhEU7EIkgoJdiEToaMHJcsPw+kx30Ha2wQsAeiEsTeSqvBiiE2kCAHI5btsyzrPN/vXvhDPHugpcctm1k7dd+qM//RS1ff/hf6C2s6f4856YCRcvLJcP0TlFcI1naonbDh3jWXuohmU5H+UZgsObwkUqAaAZqaTY+s4XmdcVPmbTwoUoAaAWaSs20+Dn6irwY3blufS2YOEsu1qBn8ub4fVtRCRb3dmFSAQFuxCJoGAXIhEU7EIkgoJdiERQsAuRCB2V3ioNw+vT4feXR37G+4bt2TkaHN9c5BlIPYVIttZm3n9tfJRnV11zNSlS6LyY4MSZc9R2/4NcXnv2+VeojfW+AwCaCOj8fd0b/HiNEl+PRo5LQ3mEJdZ6RBqq58JzAKArdqVGstTK1fDz9hyfk49kxGVN3tfPy1ymrIPPKzTDPmbGX7NqLex/pMWh7uxCpIKCXYhEULALkQgKdiESQcEuRCJ0dDe+AcN8Lpws8Pizr9N5b7wZbhl1x2/fQOdcs4W36TlyONyaCABu++CN1NZFEhPmqnyH+aF/fJrannvlJLUt1iOthCK7xblC+P27GanJlzO+ixzbtW40eQJQheww1xp8jhmvaVdBJCnE+XPL58lOd8bvcz09PKGlCO5/g2+4o2E81BpkYr3GX5dif7imoOX4eXRnFyIRFOxCJIKCXYhEULALkQgKdiESQcEuRCIsK72Z2XYAf4dWS2YHsM/dv2ZmXwTw5wDOtH/18+7+WPRk+Tw2jG4M2qbOc/lk4vx0cPznL/BWN43azognXFrZuJkkuwCwLCyHPbX/JTrnH376C2qrNHnNNeS59JbLXfx7dKPCk108Iss1I/JaTPJiLZQKeX7JWcYlTGT8NctH5mVZ+HyxJqNZZH1zzuXBRiTZqBmRDplmt3kzl4/7B8K2N0uRdeIe/JI6gL9x92fNrB/AM2b247btq+7+X1dwDCHEOrOSXm8TACbaj+fM7CAAXjJVCHFFclGfB83sKgA3AXiyPXSvmR0ws/vNjLcWFUKsOysOdjPrA/ADAJ9z91kAXwdwDYA9aN35v0zm3WNm+81sf32Jt0oWQqwtKwp2a1Xh/wGA77j7DwHA3U+7e8PdmwC+ASDYYN3d97n7Xnffm+/mjSCEEGvLssFuZgbgmwAOuvtXLhgfv+DXPgGAb0kLIdadlezG/y6AzwB40cyeb499HsCnzWwPWnLcUQB/sdyBzIzKJIUCl5rq5bCccPT0LJ1TWThIbbfdfB21dQ+NU9tMOSyR/POT++mcsvPMpVqdyzilEs9sa0bqoC0uhlsJxcgiGVnGk94Q6ciEEpG8YllZiNisxGXK7m5euy5PpL5aJKNsbmGB2hoRmbJS56/L4HC4jiIAjI2HbX2RwntLc+E/iT1ybaxkN/5nAEIveVRTF0JcWegbdEIkgoJdiERQsAuRCAp2IRJBwS5EInS04CTc0ayTLKpYxlAWlqGq4NlOk/MVanv2NV7o8c5FLq3MeVjuOHGefzOw1Mezq+qL3P9yhfvf0xORmkjbq9jxLMf9yEXaNcUy2JzIaB65vxQicuN8jWffVetcKmOyXCxjLyahLURab/UNcXltaCNvOVath4/52qs8q7NAshFrVe6f7uxCJIKCXYhEULALkQgKdiESQcEuRCIo2IVIhA5LbwBY1pBzuSPLwsX6ms5loUaOF/g7Osmlsvsf4vk9H719b3D8yMkzwXEAWGzEihBGZKguXjgwK3JbD+lhVuzmstbSHJeuYtlhHpGoCiRjK8vz1yx2rixSVDLWx25pcf6i58TONTQ8Qm0bxnjG5NlzU9Q2ffZUePwt3pPw2l27woaIpKg7uxCJoGAXIhEU7EIkgoJdiERQsAuRCAp2IRKho9Jbls8wMjQUtJXLXA5bWApn8hQznv1Vj8hCuUhxyyeeOkBtR06Gs+VmFnjhyKn5JWojyU4AgN7eSLZcpKhgqRR+bvmIXNfVzTPKskhGXL7Aj9kg95F6RPKyiM2d+9io8fWv1sKL3N3FpcjRDRuobXiUy2vVSOZmpRgpHkn6szXzXD5eKIevq2ZEwtadXYhEULALkQgKdiESQcEuRCIo2IVIhGV3482sC8ATAErt3/++u3/BzHYBeBDABgDPAPiMu0f2lwFvOipkF7EUedupNMK7rYWM7wbX+SYyPMdPluvmu+DHSMJLLpLcUa/xHeaYYlAul6ltIdKeKEeeG9ulB4DeIt/17Y4k0ORy3P9iV/h83T18fatVnghzdoonkjTB5+UL4fUYHuilc8ZGwooRAGzezBNhphd4nb+56fPUNj8zHRwfGuHnOnvmbHC8HkkmWsmdvQLgo+7+AbTaM99hZh8C8LcAvuru1wI4D+CzKziWEGKdWDbYvcU7eYKF9j8H8FEA32+PPwDg42vioRDisrDS/uxZu4PrJIAfA3gTwLT7L1uUHgewdW1cFEJcDlYU7O7ecPc9ALYBuAXA9Ss9gZndY2b7zWx/bZG3WBZCrC0XtRvv7tMA/gnAhwEMmf2ysfc2ACfInH3uvtfd9xZ6BlblrBDi0lk22M1so5kNtR93A/gYgINoBf2ftn/tbgCPrJWTQojVs5JEmHEAD5hZhtabw0Pu/vdm9gqAB83sPwN4DsA3lztQs9lEZSksKZUyo/N6iJfNGk8yiXQtQhNcMoolEjRJu6l6NZLA0eDPK9aCKGZrRhJhmPR2/jyXfqYi6zjQxyWqwUg9tgFSC68LXMprNLl0lbdIsk6Jv9iVcviYpTx/XWLnqi/ORGzc//npc9TWJMk6XSUuiZZZnTyLPC9qaePuBwDcFBg/jNbf70KIXwH0DTohEkHBLkQiKNiFSAQFuxCJoGAXIhEsJvFc9pOZnQFwrP3jKIBw6k5nkR/vRn68m181P3a6+8aQoaPB/q4Tm+1393DzNPkhP+THZfdDH+OFSAQFuxCJsJ7Bvm8dz30h8uPdyI9382vjx7r9zS6E6Cz6GC9EIqxLsJvZHWb2mpkdMrP71sOHth9HzexFM3vezPZ38Lz3m9mkmb10wdiImf3YzN5o/z+8Tn580cxOtNfkeTO7swN+bDezfzKzV8zsZTP76/Z4R9ck4kdH18TMuszsKTN7oe3Hf2qP7zKzJ9tx8z0z4xVXQ7h7R/8ByNAqa3U1gCKAFwDc0Gk/2r4cBTC6Due9DcDNAF66YOy/ALiv/fg+AH+7Tn58EcC/7/B6jAO4uf24H8DrAG7o9JpE/OjomgAwAH3txwUATwL4EICHAHyqPf7fAfzlxRx3Pe7stwA45O6HvVV6+kEAd62DH+uGuz8B4L21ke9Cq3An0KECnsSPjuPuE+7+bPvxHFrFUbaiw2sS8aOjeIvLXuR1PYJ9K4C3L/h5PYtVOoAfmdkzZnbPOvnwDmPuPtF+fArA2Dr6cq+ZHWh/zF/zPycuxMyuQqt+wpNYxzV5jx9Ah9dkLYq8pr5Bd6u73wzgDwH8lZndtt4OAa13drTeiNaDrwO4Bq0eARMAvtypE5tZH4AfAPicu7+rOmkn1yTgR8fXxFdR5JWxHsF+AsD2C36mxSrXGnc/0f5/EsDDWN/KO6fNbBwA2v9ProcT7n66faE1AXwDHVoTMyugFWDfcfcftoc7viYhP9ZrTdrnvugir4z1CPanAexu7ywWAXwKwKOddsLMes2s/53HAP4AwEvxWWvKo2gV7gTWsYDnO8HV5hPowJqYmaFVw/Cgu3/lAlNH14T50ek1WbMir53aYXzPbuOdaO10vgngP6yTD1ejpQS8AODlTvoB4LtofRysofW312fR6pn3OIA3APwEwMg6+fFtAC8COIBWsI13wI9b0fqIfgDA8+1/d3Z6TSJ+dHRNAPwWWkVcD6D1xvIfL7hmnwJwCMD/BlC6mOPqG3RCJELqG3RCJIOCXYhEULALkQgKdiESQcEuRCIo2IVIBAW7EImgYBciEf4vt7E0CnHQV6IAAAAASUVORK5CYII=\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# extra stuff\n",
+        "model.evaluate(x_test, y_test)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "qB5A4Hdn3W8k",
+        "outputId": "b4c2de50-7e02-47af-bdd0-48f604fca2b9"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 14/313 [>.............................] - ETA: 2s - loss: 1.1181 - accuracy: 0.6094"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/util/dispatch.py:1082: UserWarning: \"`sparse_categorical_crossentropy` received `from_logits=True`, but the `output` argument was produced by a sigmoid or softmax activation and thus does not represent logits. Was this intended?\"\n",
+            "  return dispatch_target(*args, **kwargs)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "313/313 [==============================] - 3s 8ms/step - loss: 1.1046 - accuracy: 0.6082\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "[1.1045507192611694, 0.6082000136375427]"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 114
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "Ksdj2uqm3kap"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file