![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rvFM645NE-D2"
+ },
+ "source": [
+ "# Assignment 2\n",
+ "In this assignment, we will go through Perceptron, Linear Classifiers, Loss Functions, Gradient Descent and Back Propagation.\n",
+ "\n",
+ "\n",
+ "PS. this one is not from Stanford's course.\n",
+ "\n",
+ "\n",
+ "\n",
+ "\\\n",
+ "\n",
+ "## Instructions\n",
+ "* This notebook contain blocks of code, you are required to complete those blocks(where required)\n",
+ "* You are required to copy this notebook (\"copy to drive\" above) and complete the code.(DO NOT CHANGE THE NAME OF THE FUNCTIONS)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": true,
+ "id": "QLtp15rqE-EU"
+ },
+ "source": [
+ "# Part 1: Perceptron\n",
+ "In this section, we will see how to implement a perceptron. Goal would be for you to delve into the mathematics.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Zao4e-DphaGA"
+ },
+ "source": [
+ "## Intro\n",
+ "What's a perceptron? It's an algorithm modelled on biological computational model to classify things into binary classes. It's a supervides learning algorithm, meaning that you need to provide labelled data containing features and the actual classifications. A perceptron would take these features as input and spit out a binary value (0 or 1). While training the model with training data, we try to minimise the error and learn the parameters involved."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "wDTUoAd6ixm-"
+ },
+ "source": [
+ "**How does it work?**\\\n",
+ "A perceptron is modelled on a biological neuron. A neuron has input dendrites and the output is carried by axons. Similarly, a perceptron takes inputs called \"features\". After processing, a perceptron gives output. For computation, it has a \"weight\" vector which is multipled with feature vector. An activation function is added to introduce some non linearities and the output is given out.\\\n",
+ "It can be represented as: $$ f=\\sum_{i=1}^{m} w_ix_i +b$$\n",
+ "\n",
+ "Let's implement this simple function to give an output.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "iXezofBIgzId"
+ },
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "class perceptron():\n",
+ " def __init__(self,num_input_features=8):\n",
+ " self.weights = np.random.randn(num_input_features)\n",
+ " self.bias = np.random.random()\n",
+ "\n",
+ " def activation(self,x):\n",
+ " '''\n",
+ " Implement heavside step activation function here (google ;))\n",
+ " '''\n",
+ " if x >= 0:\n",
+ " return 1\n",
+ " else:\n",
+ " return 0\n",
+ "\n",
+ "\n",
+ " def forward(self,x: np.ndarray):\n",
+ " '''\n",
+ " 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",
+ " w = self.weights \n",
+ " b = self. bias \n",
+ " f = x.dot(w) + b\n",
+ " return self.activation(f)"
+ ],
+ "execution_count": 1,
+ "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": 2,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": true,
+ "id": "NWTTg1e9r7uM"
+ },
+ "source": [
+ "# Part 2: Linear Classifier\n",
+ "In this section, we will see how to implement a linear Classifier.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DYDO4GcHr7uM"
+ },
+ "source": [
+ "## Intro\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-HFvjH06r7uN"
+ },
+ "source": [
+ "**How does it work?**\n",
+ "\n",
+ "Linear Classifier uses the following function: $$Y = WX+b$$ Where, $W$ is a 2d array of weights with shape (#classes, #features).\n",
+ "\n",
+ "\n",
+ "\n",
+ "Let's implement this classifier.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "9A13CEkGr7uN"
+ },
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "class LinearClassifier():\n",
+ " def __init__(self,num_input_features=32,num_classes=5):\n",
+ " self.weights = np.random.randn(num_classes,num_input_features)\n",
+ " self.bias = np.random.rand(num_classes,1)\n",
+ "\n",
+ " def forward(self,x: np.ndarray):\n",
+ " '''\n",
+ " x: input features\n",
+ " you have random initialized weights and bias\n",
+ " you can access then using `self.weights` and `self.bias`\n",
+ " return an output vector of num_classes size\n",
+ " '''\n",
+ " return self.weights.dot(x) + self.bias\n",
+ " pass"
+ ],
+ "execution_count": 3,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "zgzPxyTsr7uN",
+ "outputId": "2263eff5-1a88-48a8-cf5b-981695266303",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ }
+ },
+ "source": [
+ "np.random.seed(0)\n",
+ "lc = LinearClassifier()\n",
+ "lc.forward(np.random.rand(32,1))\n",
+ "# Should be close to:\n",
+ "# array([[ 7.07730669],\n",
+ " # [-10.24067722],\n",
+ " # [ 0.75398702],\n",
+ " # [ 9.8019519 ],\n",
+ " # [ 2.36684038]])"
+ ],
+ "execution_count": 4,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "array([[ 7.07730669],\n",
+ " [-10.24067722],\n",
+ " [ 0.75398702],\n",
+ " [ 9.8019519 ],\n",
+ " [ 2.36684038]])"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 4
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": true,
+ "id": "ZVgOVzJetuqo"
+ },
+ "source": [
+ "# Part 3: Loss Functions, Gradient descent and Backpropagation\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4pXryjpctuqy"
+ },
+ "source": [
+ "## Intro\n",
+ "\n",
+ "Loss Functions tells how \"off\" the output od our model is. Based upon the application, you can use several different loss functions. Formally, A loss function is a function $L:(z,y)\\in\\mathbb{R}\\times Y\\longmapsto L(z,y)\\in\\mathbb{R}$ that takes as inputs the predicted value $z$ corresponding to the real data value yy and outputs how different they are We'll implement L1 loss, L2 loss, Logistic loss, hinge loss and cross entropy loss functions."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "QGRb8BHotuqy"
+ },
+ "source": [
+ "### **L1 loss**\n",
+ "L1 loss is the linear loss function $L = \\dfrac{1}{2}|y−z| $\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "YxVh6IL2tuqz"
+ },
+ "source": [
+ "import numpy as np\n",
+ "def L1loss(z,y):\n",
+ " '''\n",
+ " y : True output.\n",
+ " z : Predicted output.\n",
+ " return : L\n",
+ " '''\n",
+ " return np.sum(0.5*abs(y-z))\n",
+ " "
+ ],
+ "execution_count": 5,
+ "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 np.sum(0.5*((y-z)**2))\n",
+ " "
+ ],
+ "execution_count": 6,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Z2JNLnWYcLSC"
+ },
+ "source": [
+ "### **Hinge Loss**\n",
+ "Hinge loss is: $ L = max( 0, 1 - yz ) $"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "gQ1YM4J-cLSC"
+ },
+ "source": [
+ "import numpy as np\n",
+ "def hingeLoss(z,y):\n",
+ " '''\n",
+ " y : True output. \n",
+ " z : Predicted output. \n",
+ " return : L\n",
+ " '''\n",
+ " L = 0\n",
+ " for i in range(len(y)):\n",
+ " L += max(0,1-y[i]*z[i])\n",
+ " return L\n",
+ " "
+ ],
+ "execution_count": 7,
+ "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",
+ "from math import *\n",
+ "def CELoss(z,y):\n",
+ " '''\n",
+ " y : True output. \n",
+ " z : Predicted output. \n",
+ " return : L\n",
+ " '''\n",
+ " L = 0\n",
+ " for i in range(len(y)):\n",
+ " L -= (y[i]*log10(z[i]) + (1-y[i])*log10(1-z[i]))\n",
+ " return L\n",
+ " #pass"
+ ],
+ "execution_count": 8,
+ "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",
+ " sum = 0\n",
+ " if np.array_equal(z,y):\n",
+ " return 0\n",
+ " else:\n",
+ " return 1\n",
+ " \n",
+ "\n"
+ ],
+ "execution_count": 9,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "CWhbibHcgRR8"
+ },
+ "source": [
+ "## Cost Function\n",
+ "The cost function $J$ is commonly used to assess the performance of a model, and is defined with the loss function $L$ as follows:\n",
+ "$$\\boxed{J(\\theta)=\\frac{1}{m}\\sum_{i=1}^mL(h_\\theta(x^{(i)}), y^{(i)})}$$\n",
+ "where $h_\\theta$ is the hypothesis function i.e. the function used to predict the output."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "SSbmhW4og97t"
+ },
+ "source": [
+ "lossFunctions = {\n",
+ " \"l1\" : L1loss,\n",
+ " \"l2\" : L2loss,\n",
+ " \"hinge\" : hingeLoss,\n",
+ " \"cross-entropy\" : CELoss,\n",
+ " \"0-1\" : zeroOneLoss\n",
+ "}\n",
+ "\n",
+ "def cost(Z : np.ndarray, Y : np.ndarray, loss : str):\n",
+ " '''\n",
+ " Z : a numpy array of predictions.\n",
+ " Y : a numpy array of true values.\n",
+ " return : A numpy array of costs calculated for each example.\n",
+ " '''\n",
+ " loss_func = lossFunctions[loss]\n",
+ " A=[]\n",
+ " for i in range(len()): # should apply the loss function to each element of the arrays and return the array J\n",
+ " A.append(loss_func(Z[i],Y[i]))\n",
+ " return A"
+ ],
+ "execution_count": 11,
+ "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": "18ab1ad6-a010-4f99-fe4c-c507bf3078a3"
+ },
+ "execution_count": 12,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "2.8.0\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "yyplk5PLEUsJ",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "b65c7731-360f-4bec-822b-6dde2afebc5c"
+ },
+ "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": 13,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n",
+ "170500096/170498071 [==============================] - 11s 0us/step\n",
+ "170508288/170498071 [==============================] - 11s 0us/step\n",
+ "(50000, 32, 32, 3) (50000, 1) (10000, 32, 32, 3) (10000, 1)\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "qQhkATYhEkkC"
+ },
+ "source": [
+ "'''visualize data by plotting images'''\n",
+ "# YOUR CODE HERE\n",
+ "pass\n",
+ "# YOUR CODE HERE"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "yJgho2AEBFbx"
+ },
+ "source": [
+ "\n",
+ "# number of classes\n",
+ "K = len(set(y_train))\n",
+ "'''\n",
+ " calculate total number of classes\n",
+ " for output layer\n",
+ "'''\n",
+ "print(\"number of classes:\", K)\n",
+ "''' \n",
+ " Build the model using the functional API\n",
+ " input layer\n",
+ "'''\n",
+ "```\n",
+ " YOUR CODE HERE\n",
+ "```\n",
+ " \n",
+ "'''Hidden layer'''\n",
+ "# YOUR CODE HERE\n",
+ "pass\n",
+ "# YOUR CODE HERE\n",
+ " \n",
+ "\"\"\"last hidden layer i.e.. output layer\"\"\"\n",
+ "# YOUR CODE HERE\n",
+ "pass\n",
+ "# YOUR CODE HERE\n",
+ " \n",
+ " '''model description'''\n",
+ "model.summary()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "PLc4Bay65TyA"
+ },
+ "source": [
+ "# Compile\n",
+ "...\n",
+ " YOUR CODE HERE\n",
+ "..."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Fit\n",
+ "...\n",
+ " YOUR CODE HERE\n",
+ "..."
+ ],
+ "metadata": {
+ "id": "U0fGsDCRsQrn"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# label mapping\n",
+ " \n",
+ "labels = '''airplane automobile bird cat deerdog frog horseship truck'''.split()\n",
+ " \n",
+ "# select the image from our test dataset\n",
+ "image_number = 0\n",
+ " \n",
+ "# display the image\n",
+ "plt.imshow(x_test[image_number])\n",
+ " \n",
+ "# load the image in an array\n",
+ "n = np.array(x_test[image_number])\n",
+ " \n",
+ "# reshape it\n",
+ "p = n.reshape(1, 32, 32, 3)\n",
+ " \n",
+ "# pass in the network for prediction and\n",
+ "# save the predicted label\n",
+ "predicted_label = labels[model.predict(p).argmax()]\n",
+ " \n",
+ "# load the original label\n",
+ "original_label = labels[y_test[image_number]]\n",
+ " \n",
+ "# display the result\n",
+ "print(\"Original label is {} and predicted label is {}\".format(\n",
+ " original_label, predicted_label))"
+ ],
+ "metadata": {
+ "id": "RDq_RE6osSh8"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Assignment/200155_Anshul_Assignment_2.ipynb b/Assignment/200155_Anshul_Assignment_2.ipynb
new file mode 100644
index 0000000..d83ffaf
--- /dev/null
+++ b/Assignment/200155_Anshul_Assignment_2.ipynb
@@ -0,0 +1,694 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "200155_Anshul_Assignment_2.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",
+ " if x >= 0:\n",
+ " return 1\n",
+ " else:\n",
+ " return 0\n",
+ "\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",
+ " w = self.weights \n",
+ " b = self. bias \n",
+ " f = x.dot(w) + b\n",
+ " return self.activation(f)"
+ ],
+ "execution_count": 1,
+ "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": 2,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": true,
+ "id": "NWTTg1e9r7uM"
+ },
+ "source": [
+ "# Part 2: Linear Classifier\n",
+ "In this section, we will see how to implement a linear Classifier.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DYDO4GcHr7uM"
+ },
+ "source": [
+ "## Intro\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-HFvjH06r7uN"
+ },
+ "source": [
+ "**How does it work?**\n",
+ "\n",
+ "Linear Classifier uses the following function: $$Y = WX+b$$ Where, $W$ is a 2d array of weights with shape (#classes, #features).\n",
+ "\n",
+ "\n",
+ "\n",
+ "Let's implement this classifier.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "9A13CEkGr7uN"
+ },
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "class LinearClassifier():\n",
+ " def __init__(self,num_input_features=32,num_classes=5):\n",
+ " self.weights = np.random.randn(num_classes,num_input_features)\n",
+ " self.bias = np.random.rand(num_classes,1)\n",
+ "\n",
+ " def forward(self,x: np.ndarray):\n",
+ " '''\n",
+ " x: input features\n",
+ " you have random initialized weights and bias\n",
+ " you can access then using `self.weights` and `self.bias`\n",
+ " return an output vector of num_classes size\n",
+ " '''\n",
+ " return self.weights.dot(x) + self.bias\n",
+ " pass"
+ ],
+ "execution_count": 3,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "zgzPxyTsr7uN",
+ "outputId": "2263eff5-1a88-48a8-cf5b-981695266303",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ }
+ },
+ "source": [
+ "np.random.seed(0)\n",
+ "lc = LinearClassifier()\n",
+ "lc.forward(np.random.rand(32,1))\n",
+ "# Should be close to:\n",
+ "# array([[ 7.07730669],\n",
+ " # [-10.24067722],\n",
+ " # [ 0.75398702],\n",
+ " # [ 9.8019519 ],\n",
+ " # [ 2.36684038]])"
+ ],
+ "execution_count": 4,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "array([[ 7.07730669],\n",
+ " [-10.24067722],\n",
+ " [ 0.75398702],\n",
+ " [ 9.8019519 ],\n",
+ " [ 2.36684038]])"
+ ]
+ },
+ "metadata": {},
+ "execution_count": 4
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": true,
+ "id": "ZVgOVzJetuqo"
+ },
+ "source": [
+ "# Part 3: Loss Functions, Gradient descent and Backpropagation\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4pXryjpctuqy"
+ },
+ "source": [
+ "## Intro\n",
+ "\n",
+ "Loss Functions tells how \"off\" the output od our model is. Based upon the application, you can use several different loss functions. Formally, A loss function is a function $L:(z,y)\\in\\mathbb{R}\\times Y\\longmapsto L(z,y)\\in\\mathbb{R}$ that takes as inputs the predicted value $z$ corresponding to the real data value yy and outputs how different they are We'll implement L1 loss, L2 loss, Logistic loss, hinge loss and cross entropy loss functions."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "QGRb8BHotuqy"
+ },
+ "source": [
+ "### **L1 loss**\n",
+ "L1 loss is the linear loss function $L = \\dfrac{1}{2}|y−z| $\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "YxVh6IL2tuqz"
+ },
+ "source": [
+ "import numpy as np\n",
+ "def L1loss(z,y):\n",
+ " '''\n",
+ " y : True output.\n",
+ " z : Predicted output.\n",
+ " return : L\n",
+ " '''\n",
+ " return np.sum(0.5*abs(y-z))\n",
+ " "
+ ],
+ "execution_count": 5,
+ "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 np.sum(0.5*((y-z)**2))\n",
+ " "
+ ],
+ "execution_count": 6,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Z2JNLnWYcLSC"
+ },
+ "source": [
+ "### **Hinge Loss**\n",
+ "Hinge loss is: $ L = max( 0, 1 - yz ) $"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "gQ1YM4J-cLSC"
+ },
+ "source": [
+ "import numpy as np\n",
+ "def hingeLoss(z,y):\n",
+ " '''\n",
+ " y : True output. \n",
+ " z : Predicted output. \n",
+ " return : L\n",
+ " '''\n",
+ " L = 0\n",
+ " for i in range(len(y)):\n",
+ " L += max(0,1-y[i]*z[i])\n",
+ " return L\n",
+ " "
+ ],
+ "execution_count": 7,
+ "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",
+ "from math import *\n",
+ "def CELoss(z,y):\n",
+ " '''\n",
+ " y : True output. \n",
+ " z : Predicted output. \n",
+ " return : L\n",
+ " '''\n",
+ " L = 0\n",
+ " for i in range(len(y)):\n",
+ " L -= (y[i]*log10(z[i]) + (1-y[i])*log10(1-z[i]))\n",
+ " return L\n",
+ " #pass"
+ ],
+ "execution_count": 8,
+ "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",
+ " sum = 0\n",
+ " if np.array_equal(z,y):\n",
+ " return 0\n",
+ " else:\n",
+ " return 1\n",
+ " \n",
+ "\n"
+ ],
+ "execution_count": 9,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "CWhbibHcgRR8"
+ },
+ "source": [
+ "## Cost Function\n",
+ "The cost function $J$ is commonly used to assess the performance of a model, and is defined with the loss function $L$ as follows:\n",
+ "$$\\boxed{J(\\theta)=\\frac{1}{m}\\sum_{i=1}^mL(h_\\theta(x^{(i)}), y^{(i)})}$$\n",
+ "where $h_\\theta$ is the hypothesis function i.e. the function used to predict the output."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "SSbmhW4og97t"
+ },
+ "source": [
+ "lossFunctions = {\n",
+ " \"l1\" : L1loss,\n",
+ " \"l2\" : L2loss,\n",
+ " \"hinge\" : hingeLoss,\n",
+ " \"cross-entropy\" : CELoss,\n",
+ " \"0-1\" : zeroOneLoss\n",
+ "}\n",
+ "\n",
+ "def cost(Z : np.ndarray, Y : np.ndarray, loss : str):\n",
+ " '''\n",
+ " Z : a numpy array of predictions.\n",
+ " Y : a numpy array of true values.\n",
+ " return : A numpy array of costs calculated for each example.\n",
+ " '''\n",
+ " loss_func = lossFunctions[loss]\n",
+ " A=[]\n",
+ " for i in range(len()): # should apply the loss function to each element of the arrays and return the array J\n",
+ " A.append(loss_func(Z[i],Y[i]))\n",
+ " return A"
+ ],
+ "execution_count": 11,
+ "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": "18ab1ad6-a010-4f99-fe4c-c507bf3078a3"
+ },
+ "execution_count": 12,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "2.8.0\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "yyplk5PLEUsJ",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "b65c7731-360f-4bec-822b-6dde2afebc5c"
+ },
+ "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": 13,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n",
+ "170500096/170498071 [==============================] - 11s 0us/step\n",
+ "170508288/170498071 [==============================] - 11s 0us/step\n",
+ "(50000, 32, 32, 3) (50000, 1) (10000, 32, 32, 3) (10000, 1)\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "qQhkATYhEkkC"
+ },
+ "source": [
+ "'''visualize data by plotting images'''\n",
+ "# YOUR CODE HERE\n",
+ "pass\n",
+ "# YOUR CODE HERE"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "yJgho2AEBFbx"
+ },
+ "source": [
+ "\n",
+ "# number of classes\n",
+ "K = len(set(y_train))\n",
+ "'''\n",
+ " calculate total number of classes\n",
+ " for output layer\n",
+ "'''\n",
+ "print(\"number of classes:\", K)\n",
+ "''' \n",
+ " Build the model using the functional API\n",
+ " input layer\n",
+ "'''\n",
+ "```\n",
+ " YOUR CODE HERE\n",
+ "```\n",
+ " \n",
+ "'''Hidden layer'''\n",
+ "# YOUR CODE HERE\n",
+ "pass\n",
+ "# YOUR CODE HERE\n",
+ " \n",
+ "\"\"\"last hidden layer i.e.. output layer\"\"\"\n",
+ "# YOUR CODE HERE\n",
+ "pass\n",
+ "# YOUR CODE HERE\n",
+ " \n",
+ " '''model description'''\n",
+ "model.summary()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "PLc4Bay65TyA"
+ },
+ "source": [
+ "# Compile\n",
+ "...\n",
+ " YOUR CODE HERE\n",
+ "..."
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Fit\n",
+ "...\n",
+ " YOUR CODE HERE\n",
+ "..."
+ ],
+ "metadata": {
+ "id": "U0fGsDCRsQrn"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# label mapping\n",
+ " \n",
+ "labels = '''airplane automobile bird cat deerdog frog horseship truck'''.split()\n",
+ " \n",
+ "# select the image from our test dataset\n",
+ "image_number = 0\n",
+ " \n",
+ "# display the image\n",
+ "plt.imshow(x_test[image_number])\n",
+ " \n",
+ "# load the image in an array\n",
+ "n = np.array(x_test[image_number])\n",
+ " \n",
+ "# reshape it\n",
+ "p = n.reshape(1, 32, 32, 3)\n",
+ " \n",
+ "# pass in the network for prediction and\n",
+ "# save the predicted label\n",
+ "predicted_label = labels[model.predict(p).argmax()]\n",
+ " \n",
+ "# load the original label\n",
+ "original_label = labels[y_test[image_number]]\n",
+ " \n",
+ "# display the result\n",
+ "print(\"Original label is {} and predicted label is {}\".format(\n",
+ " original_label, predicted_label))"
+ ],
+ "metadata": {
+ "id": "RDq_RE6osSh8"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Assignment/Assignment_1/Assignment_1.ipynb b/Assignment/Assignment_1/Assignment_1.ipynb
new file mode 100644
index 0000000..5eef5f6
--- /dev/null
+++ b/Assignment/Assignment_1/Assignment_1.ipynb
@@ -0,0 +1,912 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.6.8"
+ },
+ "colab": {
+ "name": "Assignment 1.ipynb",
+ "provenance": [],
+ "collapsed_sections": []
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rvFM645NE-D2"
+ },
+ "source": [
+ "# Assignment 1 - Part 1\n",
+ "In this assignment, we will go through basic linear algebra, NumPy, and image manipulation using Python to get everyone on the same page.\n",
+ "\n",
+ "One of the aims of this assignment is to get you to start getting comfortable searching for useful library functions online. So in many of the functions you will implement, you will have to look up helper functions.\n",
+ "\n",
+ "\\\n",
+ "\n",
+ "## Instructions\n",
+ "* This notebook contain blocks of code, you are required to complete those blocks(where required)\n",
+ "* You are required to copy this notebook (\"copy to drive\" above) and complete the code.(DO NOT CHANGE THE NAME OF THE FUNCTIONS)\n",
+ "\n",
+ "\\\n",
+ "\\\n",
+ "Also, I'd like to acknowledge the Stanford CS131. This assignment is highly based on the assignments from that course."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "UhSVK4RoK9q5"
+ },
+ "source": [
+ "First Let's import some dependencies"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "cCKqyfhIE-EQ"
+ },
+ "source": [
+ "# Imports the print function from newer versions of python\n",
+ "from __future__ import print_function\n",
+ "\n",
+ "# Setup\n",
+ "\n",
+ "# The Random module implements pseudo-random number generators\n",
+ "import random \n",
+ "\n",
+ "# Numpy is the main package for scientific computing with Python. \n",
+ "# This will be one of our most used libraries in this project\n",
+ "import numpy as np\n",
+ "\n",
+ "# The Time library helps us time code runtimes\n",
+ "import time\n",
+ "\n",
+ "\n",
+ "# Some more magic so that the notebook will reload external python modules;\n",
+ "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
+ "%load_ext autoreload\n",
+ "%autoreload 2\n",
+ "%reload_ext autoreload"
+ ],
+ "execution_count": 1,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": true,
+ "id": "QLtp15rqE-EU"
+ },
+ "source": [
+ "# Part 1: Linear Algebra and NumPy Review\n",
+ "In this section, we will review linear algebra and learn how to use vectors and matrices in python using numpy."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "E8HDYpc0E-EV"
+ },
+ "source": [
+ "## Part 1.1 (5 points)\n",
+ "First, let's test whether you can define the following matrices and vectors using numpy. Look up `np.array()` for help. In the next code block, define $M$ as a $(4, 3)$ matrix, $a$ as a $(1, 3)$ row vector and $b$ as a $(3, 1)$ column vector:\n",
+ "\n",
+ "$$M = \\begin{bmatrix}\n",
+ "1 & 2 & 3 \\\\\n",
+ "4 & 5 & 6 \\\\\n",
+ "7 & 8 & 9 \\\\\n",
+ "10 & 11 & 12 \\end{bmatrix}\n",
+ "$$\n",
+ "\n",
+ "$$a = \\begin{bmatrix}\n",
+ "1 & 1 & 0\n",
+ "\\end{bmatrix}\n",
+ "$$\n",
+ "\n",
+ "$$b = \\begin{bmatrix}\n",
+ "-1 \\\\ 2 \\\\ 5\n",
+ "\\end{bmatrix} \n",
+ "$$ "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "mETk2NCME-EX",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "dbcde893-3487-4e6c-f44f-b268dc6d3170"
+ },
+ "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\")\n",
+ "print(\"The size of M is: \")\n",
+ "print(M.shape, \"\\n\")\n",
+ "print(a, \"\\n\")\n",
+ "print(\"The size of a is: \")\n",
+ "print(a.shape,\"\\n\")\n",
+ "print(b)\n",
+ "print(\"The size of b is: \")\n",
+ "print(b.shape)"
+ ],
+ "execution_count": 2,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "[[ 1 2 3]\n",
+ " [ 4 5 6]\n",
+ " [ 7 8 9]\n",
+ " [10 11 12]] \n",
+ "\n",
+ "The size of M is: \n",
+ "(4, 3) \n",
+ "\n",
+ "[1 1 0] \n",
+ "\n",
+ "The size of a is: \n",
+ "(3,) \n",
+ "\n",
+ "[[-1]\n",
+ " [ 2]\n",
+ " [ 5]]\n",
+ "The size of b is: \n",
+ "(3, 1)\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rSta4NheE-EZ"
+ },
+ "source": [
+ "## Part 1.2 (5 points)\n",
+ "Implement the `dot_product()` method below and check that it returns the correct answer for $a^Tb$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "C5ZRjCE2MVOU"
+ },
+ "source": [
+ "def dot_product(a, b):\n",
+ " \"\"\"Implement dot product between the two vectors: a and b.\n",
+ " (optional): While you can solve this using for loops, we recommend\n",
+ " that you look up `np.dot()` online and use that instead.\n",
+ " Args:\n",
+ " a: numpy array of shape (x, n)\n",
+ " b: numpy array of shape (n, x)\n",
+ " Returns:\n",
+ " out: numpy array of shape (x, x) (scalar if x = 1)\n",
+ " \"\"\"\n",
+ " out = np.dot(a,b)\n",
+ " ### YOUR CODE HERE\n",
+ " pass\n",
+ " ### END YOUR CODE\n",
+ " return out"
+ ],
+ "execution_count": 3,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "pbLIS5vIE-Ea",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "0d452429-05b5-44d5-fdd0-6155bafba6d3"
+ },
+ "source": [
+ "# Now, let's test out this dot product. Your answer should be [[1]].\n",
+ "aDotB = dot_product(a, b)\n",
+ "print(aDotB)\n",
+ "\n",
+ "print(\"The size is: \", aDotB.shape)"
+ ],
+ "execution_count": 4,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "[1]\n",
+ "The size is: (1,)\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",
+ " A = np.dot(M,a.T)\n",
+ " B = np.dot(a,b)\n",
+ " out = B*A\n",
+ " ### YOUR CODE HERE\n",
+ " pass\n",
+ " ### END YOUR CODE\n",
+ " return out"
+ ],
+ "execution_count": 5,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "da_uQQLhE-Ec",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "76575e92-1f42-4e6d-a059-929040080195"
+ },
+ "source": [
+ "# Your answer should be $[[3], [9], [15], [21]]$ of shape(4, 1).\n",
+ "ans = complicated_matrix_function(M, a, b)\n",
+ "print(ans)\n",
+ "print()\n",
+ "print(\"The size is: \", ans.shape)"
+ ],
+ "execution_count": 6,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "[ 3 9 15 21]\n",
+ "\n",
+ "The size is: (4,)\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "6CWXxSSOE-Ed",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "35c1fad8-61f8-4eb9-8f82-44945f981b44"
+ },
+ "source": [
+ "M_2 = np.array(range(4)).reshape((2,2))\n",
+ "a_2 = np.array([[1,1]])\n",
+ "b_2 = np.array([[10, 10]]).T\n",
+ "print(M_2.shape)\n",
+ "print(a_2.shape)\n",
+ "print(b_2.shape)\n",
+ "print()\n",
+ "\n",
+ "# Your answer should be $[[20], [100]]$ of shape(2, 1).\n",
+ "ans = complicated_matrix_function(M_2, a_2, b_2)\n",
+ "print(ans)\n",
+ "print()\n",
+ "print(\"The size is: \", ans.shape)"
+ ],
+ "execution_count": 7,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "(2, 2)\n",
+ "(1, 2)\n",
+ "(2, 1)\n",
+ "\n",
+ "[[ 20]\n",
+ " [100]]\n",
+ "\n",
+ "The size is: (2, 1)\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4fHLxLl4E-Ee"
+ },
+ "source": [
+ "## Part 1.4 (10 points) [Optional/Bonus]\n",
+ "Implement `eigen_decomp()` and `get_eigen_values_and_vectors()` methods. In this method, perform eigenvalue decomposition on the following matrix and return the largest k eigen values and corresponding eigen vectors (k is specified in the method calls below).\n",
+ "\n",
+ "$$M = \\begin{bmatrix}\n",
+ "1 & 2 & 3 \\\\\n",
+ "4 & 5 & 6 \\\\\n",
+ "7 & 8 & 9 \\end{bmatrix}\n",
+ "$$\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "RfaCSoRMOIc8"
+ },
+ "source": [
+ "def eigen_decomp(M):\n",
+ " \"\"\"Implement eigenvalue decomposition.\n",
+ " (optional): You might find the `np.linalg.eig` function useful.\n",
+ " Args:\n",
+ " matrix: numpy matrix of shape (m, n)\n",
+ " Returns:\n",
+ " w: numpy array of shape (m, m) such that the column v[:,i] is the eigenvector corresponding to the eigenvalue w[i].\n",
+ " v: Matrix where every column is an eigenvector.\n",
+ " \"\"\"\n",
+ " eigenvalue, eigenvector = np.linalg.eig(M)\n",
+ " w = eigenvalue\n",
+ " v = eigenvector\n",
+ " ### YOUR CODE HERE\n",
+ " pass\n",
+ " ### END YOUR CODE\n",
+ " return w, v"
+ ],
+ "execution_count": 8,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "YB120rb4ONBH"
+ },
+ "source": [
+ "def get_eigen_values_and_vectors(M, k):\n",
+ " \"\"\"Return top k eigenvalues and eigenvectors of matrix M. By top k\n",
+ " here we mean the eigenvalues with the top ABSOLUTE values (lookup\n",
+ " np.argsort for a hint on how to do so.)\n",
+ " (optional): Use the `eigen_decomp(M)` function you wrote above\n",
+ " as a helper function\n",
+ " Args:\n",
+ " M: numpy matrix of shape (m, m).\n",
+ " k: number of eigen values and respective vectors to return.\n",
+ " Returns:\n",
+ " eigenvalues: list of length k containing the top k eigenvalues\n",
+ " eigenvectors: list of length k containing the top k eigenvectors\n",
+ " of shape (m,)\n",
+ " \"\"\"\n",
+ " np.argsort(eigen_decomp(M))\n",
+ " C = np.take_along_axis(eigen_decomp(M), index_array, axis=none)\n",
+ " x = slice(-1, -k-1, -1)\n",
+ " eigenvalues = C[x]\n",
+ " np.argsort(eigen_decomp(M).v)\n",
+ " D = np.take_along_axis(eigen_decomp(M), index_array, axis=0)\n",
+ " eigenvectors = D[0:m+1, -1:-k-1]\n",
+ " ### YOUR CODE HERE\n",
+ " pass\n",
+ " ### END YOUR CODE\n",
+ " return eigenvalues, eigenvectors"
+ ],
+ "execution_count": 9,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "t0_GkrJwE-Ee",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 470
+ },
+ "outputId": "fe7620f3-a111-45d9-cae5-2be145fd070e"
+ },
+ "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": 10,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stderr",
+ "text": [
+ "/usr/local/lib/python3.7/dist-packages/numpy/core/fromnumeric.py:43: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
+ " result = getattr(asarray(obj), method)(*args, **kwds)\n"
+ ]
+ },
+ {
+ "output_type": "error",
+ "ename": "ValueError",
+ "evalue": "ignored",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m| \n", + " | city | \n", + "area | \n", + "rooms | \n", + "bathroom | \n", + "parking spaces | \n", + "floor | \n", + "animal | \n", + "furniture | \n", + "hoa (R$) | \n", + "rent amount (R$) | \n", + "property tax (R$) | \n", + "fire insurance (R$) | \n", + "total (R$) | \n", + "
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 3755 | \n", + "Belo Horizonte | \n", + "46 | \n", + "2 | \n", + "1 | \n", + "1 | \n", + "2 | \n", + "acept | \n", + "not furnished | \n", + "200 | \n", + "1050 | \n", + "27 | \n", + "14 | \n", + "1291 | \n", + "
| 10088 | \n", + "Belo Horizonte | \n", + "476 | \n", + "3 | \n", + "2 | \n", + "2 | \n", + "- | \n", + "not acept | \n", + "not furnished | \n", + "0 | \n", + "6100 | \n", + "202 | \n", + "101 | \n", + "6403 | \n", + "
| 7693 | \n", + "Belo Horizonte | \n", + "44 | \n", + "1 | \n", + "1 | \n", + "1 | \n", + "15 | \n", + "acept | \n", + "not furnished | \n", + "550 | \n", + "3400 | \n", + "222 | \n", + "46 | \n", + "4218 | \n", + "
| 5611 | \n", + "Belo Horizonte | \n", + "308 | \n", + "4 | \n", + "5 | \n", + "4 | \n", + "18 | \n", + "acept | \n", + "furnished | \n", + "1750 | \n", + "15000 | \n", + "167 | \n", + "200 | \n", + "17120 | \n", + "
| 6131 | \n", + "Belo Horizonte | \n", + "320 | \n", + "4 | \n", + "5 | \n", + "4 | \n", + "6 | \n", + "not acept | \n", + "not furnished | \n", + "3480 | \n", + "5000 | \n", + "940 | \n", + "67 | \n", + "9487 | \n", + "
| ... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "
| 4553 | \n", + "São Paulo | \n", + "16 | \n", + "1 | \n", + "1 | \n", + "0 | \n", + "1 | \n", + "not acept | \n", + "not furnished | \n", + "0 | \n", + "850 | \n", + "9 | \n", + "11 | \n", + "870 | \n", + "
| 4552 | \n", + "São Paulo | \n", + "170 | \n", + "3 | \n", + "2 | \n", + "2 | \n", + "4 | \n", + "acept | \n", + "furnished | \n", + "1970 | \n", + "9000 | \n", + "900 | \n", + "115 | \n", + "11990 | \n", + "
| 4549 | \n", + "São Paulo | \n", + "280 | \n", + "3 | \n", + "5 | \n", + "2 | \n", + "- | \n", + "acept | \n", + "not furnished | \n", + "0 | \n", + "7000 | \n", + "625 | \n", + "106 | \n", + "7731 | \n", + "
| 4565 | \n", + "São Paulo | \n", + "41 | \n", + "1 | \n", + "1 | \n", + "1 | \n", + "3 | \n", + "acept | \n", + "furnished | \n", + "534 | \n", + "2800 | \n", + "133 | \n", + "36 | \n", + "3503 | \n", + "
| 10691 | \n", + "São Paulo | \n", + "80 | \n", + "2 | \n", + "1 | \n", + "0 | \n", + "- | \n", + "acept | \n", + "not furnished | \n", + "0 | \n", + "1400 | \n", + "165 | \n", + "22 | \n", + "1587 | \n", + "
10692 rows × 13 columns
\n", + ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#impoting required libraries"
+ ],
+ "metadata": {
+ "id": "hYLvMxLD4bT5"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import pandas as pd\n",
+ "import matplotlib as mpl\n",
+ "import matplotlib.pyplot as plt"
+ ],
+ "metadata": {
+ "id": "JlHi1X8_4jYN"
+ },
+ "execution_count": 1,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# read the csv file using Pandas"
+ ],
+ "metadata": {
+ "id": "yFrhva-T47YL"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "data = pd.read_csv (r'/content/House_prediction.csv', delimiter=',')\n",
+ "print(data)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "N36hM4yuBt5s",
+ "outputId": "b93d5c70-79b8-4fa3-fa32-e842e9b70eb8"
+ },
+ "execution_count": 3,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ " city area rooms bathroom parking spaces floor animal \\\n",
+ "0 São Paulo 70 2 1 1 7 acept \n",
+ "1 São Paulo 320 4 4 0 20 acept \n",
+ "2 Porto Alegre 80 1 1 1 6 acept \n",
+ "3 Porto Alegre 51 2 1 0 2 acept \n",
+ "4 São Paulo 25 1 1 0 1 not acept \n",
+ "... ... ... ... ... ... ... ... \n",
+ "10687 Porto Alegre 63 2 1 1 5 not acept \n",
+ "10688 São Paulo 285 4 4 4 17 acept \n",
+ "10689 Rio de Janeiro 70 3 3 0 8 not acept \n",
+ "10690 Rio de Janeiro 120 2 2 2 8 acept \n",
+ "10691 São Paulo 80 2 1 0 - acept \n",
+ "\n",
+ " furniture hoa (R$) rent amount (R$) property tax (R$) \\\n",
+ "0 furnished 2065 3300 211 \n",
+ "1 not furnished 1200 4960 1750 \n",
+ "2 not furnished 1000 2800 0 \n",
+ "3 not furnished 270 1112 22 \n",
+ "4 not furnished 0 800 25 \n",
+ "... ... ... ... ... \n",
+ "10687 furnished 402 1478 24 \n",
+ "10688 not furnished 3100 15000 973 \n",
+ "10689 furnished 980 6000 332 \n",
+ "10690 furnished 1585 12000 279 \n",
+ "10691 not furnished 0 1400 165 \n",
+ "\n",
+ " fire insurance (R$) total (R$) \n",
+ "0 42 5618 \n",
+ "1 63 7973 \n",
+ "2 41 3841 \n",
+ "3 17 1421 \n",
+ "4 11 836 \n",
+ "... ... ... \n",
+ "10687 22 1926 \n",
+ "10688 191 19260 \n",
+ "10689 78 7390 \n",
+ "10690 155 14020 \n",
+ "10691 22 1587 \n",
+ "\n",
+ "[10692 rows x 13 columns]\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# Sorting on the basis of city name"
+ ],
+ "metadata": {
+ "id": "b9kj4e4gUkas"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "data.sort_values(by=['city'])"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 624
+ },
+ "id": "xg55Uw4wg18w",
+ "outputId": "da33b097-9996-4887-8e1f-c02570ab95d9"
+ },
+ "execution_count": 4,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ " city area rooms bathroom parking spaces floor animal \\\n",
+ "3755 Belo Horizonte 46 2 1 1 2 acept \n",
+ "10088 Belo Horizonte 476 3 2 2 - not acept \n",
+ "7693 Belo Horizonte 44 1 1 1 15 acept \n",
+ "5611 Belo Horizonte 308 4 5 4 18 acept \n",
+ "6131 Belo Horizonte 320 4 5 4 6 not acept \n",
+ "... ... ... ... ... ... ... ... \n",
+ "4553 São Paulo 16 1 1 0 1 not acept \n",
+ "4552 São Paulo 170 3 2 2 4 acept \n",
+ "4549 São Paulo 280 3 5 2 - acept \n",
+ "4565 São Paulo 41 1 1 1 3 acept \n",
+ "10691 São Paulo 80 2 1 0 - acept \n",
+ "\n",
+ " furniture hoa (R$) rent amount (R$) property tax (R$) \\\n",
+ "3755 not furnished 200 1050 27 \n",
+ "10088 not furnished 0 6100 202 \n",
+ "7693 not furnished 550 3400 222 \n",
+ "5611 furnished 1750 15000 167 \n",
+ "6131 not furnished 3480 5000 940 \n",
+ "... ... ... ... ... \n",
+ "4553 not furnished 0 850 9 \n",
+ "4552 furnished 1970 9000 900 \n",
+ "4549 not furnished 0 7000 625 \n",
+ "4565 furnished 534 2800 133 \n",
+ "10691 not furnished 0 1400 165 \n",
+ "\n",
+ " fire insurance (R$) total (R$) \n",
+ "3755 14 1291 \n",
+ "10088 101 6403 \n",
+ "7693 46 4218 \n",
+ "5611 200 17120 \n",
+ "6131 67 9487 \n",
+ "... ... ... \n",
+ "4553 11 870 \n",
+ "4552 115 11990 \n",
+ "4549 106 7731 \n",
+ "4565 36 3503 \n",
+ "10691 22 1587 \n",
+ "\n",
+ "[10692 rows x 13 columns]"
+ ],
+ "text/html": [
+ "\n",
+ " | \n", + " | city | \n", + "area | \n", + "rooms | \n", + "bathroom | \n", + "parking spaces | \n", + "floor | \n", + "animal | \n", + "furniture | \n", + "hoa (R$) | \n", + "rent amount (R$) | \n", + "property tax (R$) | \n", + "fire insurance (R$) | \n", + "total (R$) | \n", + "
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 3755 | \n", + "Belo Horizonte | \n", + "46 | \n", + "2 | \n", + "1 | \n", + "1 | \n", + "2 | \n", + "acept | \n", + "not furnished | \n", + "200 | \n", + "1050 | \n", + "27 | \n", + "14 | \n", + "1291 | \n", + "
| 10088 | \n", + "Belo Horizonte | \n", + "476 | \n", + "3 | \n", + "2 | \n", + "2 | \n", + "- | \n", + "not acept | \n", + "not furnished | \n", + "0 | \n", + "6100 | \n", + "202 | \n", + "101 | \n", + "6403 | \n", + "
| 7693 | \n", + "Belo Horizonte | \n", + "44 | \n", + "1 | \n", + "1 | \n", + "1 | \n", + "15 | \n", + "acept | \n", + "not furnished | \n", + "550 | \n", + "3400 | \n", + "222 | \n", + "46 | \n", + "4218 | \n", + "
| 5611 | \n", + "Belo Horizonte | \n", + "308 | \n", + "4 | \n", + "5 | \n", + "4 | \n", + "18 | \n", + "acept | \n", + "furnished | \n", + "1750 | \n", + "15000 | \n", + "167 | \n", + "200 | \n", + "17120 | \n", + "
| 6131 | \n", + "Belo Horizonte | \n", + "320 | \n", + "4 | \n", + "5 | \n", + "4 | \n", + "6 | \n", + "not acept | \n", + "not furnished | \n", + "3480 | \n", + "5000 | \n", + "940 | \n", + "67 | \n", + "9487 | \n", + "
| ... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "
| 4553 | \n", + "São Paulo | \n", + "16 | \n", + "1 | \n", + "1 | \n", + "0 | \n", + "1 | \n", + "not acept | \n", + "not furnished | \n", + "0 | \n", + "850 | \n", + "9 | \n", + "11 | \n", + "870 | \n", + "
| 4552 | \n", + "São Paulo | \n", + "170 | \n", + "3 | \n", + "2 | \n", + "2 | \n", + "4 | \n", + "acept | \n", + "furnished | \n", + "1970 | \n", + "9000 | \n", + "900 | \n", + "115 | \n", + "11990 | \n", + "
| 4549 | \n", + "São Paulo | \n", + "280 | \n", + "3 | \n", + "5 | \n", + "2 | \n", + "- | \n", + "acept | \n", + "not furnished | \n", + "0 | \n", + "7000 | \n", + "625 | \n", + "106 | \n", + "7731 | \n", + "
| 4565 | \n", + "São Paulo | \n", + "41 | \n", + "1 | \n", + "1 | \n", + "1 | \n", + "3 | \n", + "acept | \n", + "furnished | \n", + "534 | \n", + "2800 | \n", + "133 | \n", + "36 | \n", + "3503 | \n", + "
| 10691 | \n", + "São Paulo | \n", + "80 | \n", + "2 | \n", + "1 | \n", + "0 | \n", + "- | \n", + "acept | \n", + "not furnished | \n", + "0 | \n", + "1400 | \n", + "165 | \n", + "22 | \n", + "1587 | \n", + "
10692 rows × 13 columns
\n", + "