WeeklyAssignment4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Weekly Assignment 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import math\n",
    "import csv\n",
    "from random import sample\n",
    "from scipy.stats import norm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the class \"airbnb\" which will gather all the features as attributes and some methods to retrieve specific features, necessary for the process of training and prediction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class airbnb( object ):\n",
    "    \n",
    "    def __init__(self, latitude, longitude, neighbourhood_group, price, availability, room_type, minimum_nights):\n",
    "        self.latitude=latitude\n",
    "        self.longitude=longitude\n",
    "        self.neighbourhood=neighbourhood_group\n",
    "        self.price=price\n",
    "        self.availability=availability\n",
    "        self.room_type=room_type\n",
    "        self.minimum_nights=minimum_nights\n",
    "    \n",
    "    def getFeaturesDict(self): return {\"latitude\": self.latitude, \"longitud\": self.longitude}\n",
    "    def getFeaturesTuple(self): return (self.latitude,self.longitude)\n",
    "    def getFeatureskmeans(self): return (self.price, self.availability, self.minimum_nights, self.room_type, self.neighbourhood)\n",
    "    \n",
    "    def getNeighbour(self): return self.neighbourhood"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loading data from the file, converting rows into airbnb objects and gathering them into a list (myairbnbs)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "myairbnbs = []\n",
    "with open(\"listings.csv\") as data:\n",
    "    data = csv.reader(data)\n",
    "    next(data)\n",
    "    for line in data:\n",
    "        apartment = airbnb(float(line[6]),float(line[7]),line[4],float(line[9]),int(line[-1]),line[8],int(line[10]))\n",
    "        myairbnbs.append(apartment)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classification with Naive Bayes\n",
    "\n",
    "First we sample 2000 apartments randomly from the whole dataset. We divide these into a test set and a training set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "sampling = sample(myairbnbs, k = 2000)\n",
    "test_set = sampling[:1000]\n",
    "training_set = sampling[1000:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The classifier class is the same as the one we saw in lesson 7, I just changed some variable names to make it more readable and changed the properties (or features) taken into account. In this case, the classifier takes latitude and longitud as features and neighbour group as the tag."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NaiveBayesOfairnbns( object ):\n",
    " \n",
    "    def _distributionProbFunction(self,neighbourhood, Property):\n",
    "        # Return the result of evaluating a Normal distribution of:\n",
    "        #   mean equal to the mean of the property for this neighbourhood group\n",
    "        #   std  equal to the std  of the property for this neighbourhood group\n",
    "        return lambda x: norm.pdf( x, self.cmean[neighbourhood][Property], self.cstdv[neighbourhood][Property] )\n",
    "        \n",
    "    def __init__(self, training_set):\n",
    "        self.training_set = training_set\n",
    " \n",
    "        self.neighbourhoods = {}\n",
    "        for apartment in self.training_set:\n",
    "            if apartment.getNeighbour() in self.neighbourhoods.keys():\n",
    "                self.neighbourhoods[apartment.getNeighbour()] += 1\n",
    "            else: self.neighbourhoods[apartment.getNeighbour()] = 1\n",
    " \n",
    "        self.probl = {}\n",
    "        self.N = len(self.training_set[0].getFeaturesDict())\n",
    "        self.properties = list(self.training_set[0].getFeaturesDict().keys())\n",
    "        self.cmean = {}\n",
    "        self.cstdv = {}\n",
    "        self.prob = {}\n",
    "        \n",
    "        for neighbourhood in self.neighbourhoods.keys():\n",
    "            # The amount of fruits of each type that I have in my \"training\" dataset\n",
    "            self.probl[neighbourhood] = self.neighbourhoods[neighbourhood]/len(self.training_set)\n",
    "            \n",
    "            # I will store the mean, std, and normal probabiblity function,\n",
    "            # of each property for each type of fruit\n",
    "            self.cmean[neighbourhood] = {} #[0 for i in range(self.N)]\n",
    "            self.cstdv[neighbourhood] = {} #[0 for i in range(self.N)]\n",
    "            self.prob[neighbourhood] = {} #[0 for i in range(self.N)]\n",
    "            \n",
    "            # Then, for each property\n",
    "            for i, prop in enumerate(self.properties):\n",
    "                # Make a numpy array taking the list of the read properties\n",
    "                xi = np.array([float(e.getFeaturesDict()[prop]) for e in self.training_set if e.getNeighbour() == neighbourhood])\n",
    "                \n",
    "                # Fullfill the mean with the mean, the std with the std and the prob with the probability function\n",
    "                self.cmean[neighbourhood][prop] = xi.mean()\n",
    "                self.cstdv[neighbourhood][prop] = xi.std()\n",
    "                self.prob[neighbourhood][prop] = self._distributionProbFunction(neighbourhood,prop)\n",
    "\n",
    "    def predict(self, X):\n",
    "        p = {}\n",
    "        \n",
    "        # In the moment of predicting I have the probabilities of each feature of belonging to each class.\n",
    "        for neighbourhood in self.neighbourhoods.keys():\n",
    "            vectorToMultiply = [self._distributionProbFunction(neighbourhood,prop)(X[i]) \n",
    "                                    for i, prop in enumerate(self.properties)\n",
    "                                    if self._distributionProbFunction(neighbourhood,prop)(X[i]) != 0.0 ] \n",
    "            cp = np.prod( vectorToMultiply )\n",
    "            \n",
    "            p[neighbourhood] = self.probl[neighbourhood]*cp\n",
    "            \n",
    "        results = [(p[neighbourhood],neighbourhood) for neighbourhood in self.neighbourhoods.keys()]\n",
    "        results.sort()\n",
    "        return results[-1][1], results[-1][0]/sum([r[0] for r in results])\n",
    "\n",
    "    def plotDistributions(self):\n",
    "        for i, prop in enumerate(self.properties):\n",
    "            nprops=len(range(self.N))\n",
    "            rows = int(nprops/2)+int(nprops%2)\n",
    "            plt.subplot(rows,2,i+1)\n",
    "            for neighbourhood in list(self.neighbourhoods.keys()):\n",
    "                mean = self.cmean[neighbourhood][prop]\n",
    "                var = self.cstdv[neighbourhood][prop]\n",
    "                x= np.linspace(mean-4*var,mean+4*var,200)\n",
    "                xmin,xmax=plt.xlim()\n",
    "                plt.xlim(min(xmin,mean-3*var),max(xmax,mean+3*var))\n",
    "                plt.title(self.properties[i])\n",
    "                \n",
    "                self.prob[neighbourhood][prop] = self._distributionProbFunction(neighbourhood,prop)\n",
    "\n",
    "                plt.plot(x,self.prob[neighbourhood][prop](x), label = neighbourhood)\n",
    "                leg = plt.legend(loc=\"upper left\")\n",
    "                leg.get_frame().set_alpha(0.7)\n",
    "        plt.show()\n",
    "        \n",
    "    def __str__(self):\n",
    "        s = 'Gaussian Naive Bayes Model:\\n'\n",
    "        for l in self.neighbourhoods.keys():\n",
    "            s+= ' P(%s) = %.3f\\n'%(l, self.probl[l])\n",
    "            for i,prop in enumerate(self.properties):\n",
    "                s+= '  E(%s|%s) = %.3f\\n'%(self.properties[i], l, self.cmean[l][prop])\n",
    "                s+= '  VAR(%s|%s) = %.3f\\n'%(self.properties[i], l, self.cstdv[l][prop]**2)\n",
    "                s+= '\\n'\n",
    "        return s.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we train the model with the training samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "myNBC = NaiveBayesOfairnbns(training_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This last chunk of code is for the assessment of the accuracy of the classifier, that is, the percetange of correct predictions over the total number of predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy = 0.865\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "for elem in test_set:\n",
    "    pred = myNBC.predict(elem.getFeaturesTuple())\n",
    "    if pred[0] == elem.getNeighbour():\n",
    "        correct += 1\n",
    "acc = correct/len(test_set)\n",
    "print(\"Accuracy = %s\"%(acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clusterization with K-means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vector_euclidian_distance(feat_one, feat_two):\n",
    "    squared_distance = 0\n",
    "    #Assuming correct input to the function where the lengths of two features are the same\n",
    "    for i in range(len(feat_one)):\n",
    "            squared_distance += (feat_one[i] - feat_two[i])**2\n",
    "    ed = math.sqrt(squared_distance)\n",
    "    return ed\n",
    "\n",
    "class K_Means:\n",
    "\n",
    "    def __init__(self, k =3, tolerance = 0.0001, max_iterations = 500):\n",
    "        self.k = k\n",
    "        self.tolerance = tolerance\n",
    "        self.max_iterations = max_iterations\n",
    "    \n",
    "\n",
    "    def fit(self, data):\n",
    "        #initialize the centroids, the first 'k' elements in the dataset will be our initial centroids\n",
    "        self.centroids = [None for _ in range(self.k)]\n",
    "        for i in range(self.k):\n",
    "            self.centroids[i] = data[i]\n",
    "            \n",
    "        for i in range(self.max_iterations):\n",
    "            self.classes = {c:[] for c in range(self.k)}\n",
    "            for i in range(self.k):\n",
    "                self.classes[i] = []\n",
    "                #find the distance between the point and cluster; choose the nearest centroid\n",
    "                for features in data:\n",
    "                    distances = [vector_euclidian_distance(features, self.centroids[centroid]) for centroid in range(len(self.centroids))]\n",
    "                    classification = distances.index(min(distances))\n",
    "                    self.classes[classification].append(features) #add the point to the list of the nearest centroid\n",
    "\n",
    "\n",
    "            #average the cluster datapoints to re-calculate the centroids\n",
    "            for classification in self.classes:\n",
    "                self.centroids[classification] = np.average(self.classes[classification], axis = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We extract the relevant features from the dataset and modify room_type to be a discrete numerical variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [airbnb.getFeatureskmeans() for airbnb in myairbnbs]\n",
    "\n",
    "room_type_list = [apartment[3] for apartment in data]\n",
    "room_type_set = list(set(room_type_list))\n",
    "numerical_room_types = [room_type_set.index(x) for x in room_type_list]\n",
    "\n",
    "neigh_list = [apartment[4] for apartment in data]\n",
    "neigh_set = list(set(neigh_list))\n",
    "numerical_neigh = [neigh_set.index(x) for x in neigh_list]\n",
    "\n",
    "price = [apartment[0] for apartment in data]\n",
    "avaliability = [apartment[1] for apartment in data]\n",
    "minimum_nights = [apartment[2] for apartment in data]\n",
    "\n",
    "\n",
    "data = list(zip(price, numerical_room_types))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fit the clustering to the selected data to 3 groups."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Centroid: [852.73921971   0.86652977]\n",
      "Centroid: [82.55088038  1.51369759]\n",
      "Centroid: [5.81522500e+03 7.58333333e-01]\n",
      "['Hotel room', 'Entire home/apt', 'Private room', 'Shared room']\n"
     ]
    }
   ],
   "source": [
    "km = K_Means(3)\n",
    "km.fit(data)\n",
    "\n",
    "for centroid in km.centroids:\n",
    "    print (\"Centroid:\", centroid)\n",
    "    \n",
    "print(list(room_type_set))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = 10*[\"r\", \"g\", \"c\", \"b\", \"k\", \"m\", \"y\", \"lime\", \"pink\", \"gray\"]\n",
    "color_gradient = [\"lavender\",\"powderblue\",\"lightsteelblue\",\"cadetblue\",\"darkcyan\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "color_n = [colors[i] for i in numerical_neigh] #set a color for each neighbour group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "color_a = [] #set a color for each range of availability\n",
    "for aptment in avaliability:\n",
    "    if aptment <= 30:\n",
    "        color_a.append(color_gradient[0])\n",
    "    elif aptment > 30 and aptment <= 60:\n",
    "        color_a.append(color_gradient[1])\n",
    "    elif aptment > 60 and aptment <= 120:\n",
    "        color_a.append(color_gradient[2])\n",
    "    elif aptment > 120 and aptment <= 240:\n",
    "        color_a.append(color_gradient[3])\n",
    "    elif aptment > 240:\n",
    "        color_a.append(color_gradient[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "color_m = []\n",
    "for aptment in minimum_nights:\n",
    "    if aptment <= 1:\n",
    "        color_m.append(color_gradient[0])\n",
    "    elif aptment > 1 and aptment <= 5:\n",
    "        color_m.append(color_gradient[1])\n",
    "    elif aptment > 5 and aptment <= 15:\n",
    "        color_m.append(color_gradient[2])\n",
    "    elif aptment > 15 and aptment <= 30:\n",
    "        color_m.append(color_gradient[3])\n",
    "    else:\n",
    "        color_m.append(color_gradient[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Colored according to cluster group. We see that in all room types there are cheap (green), middle priced (red) and expensive (cyan) records. We only see a difference in that the hotel room type looks like it is slightly more expensive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for classification in km.classes:\n",
    "    color = colors[classification]\n",
    "    for features in km.classes[classification]:\n",
    "        plt.scatter(features[0], features[1], color = color,s = 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Colored according to minimum nights, availability and neighbourhood group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i, datapoint in enumerate(data):\n",
    "    plt.scatter(datapoint[0], datapoint[1], color = color_m[i], s = 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i, datapoint in enumerate(data):\n",
    "    plt.scatter(datapoint[0], datapoint[1], color = color_a[i], s = 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i, datapoint in enumerate(data):\n",
    "    plt.scatter(datapoint[0], datapoint[1], color = color_n[i], s = 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We do not see any special distribution of the datapoints in the groups when observing the points colored by minimum nights, availability or neighbourhood group."
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}