Observer.3.0.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove outliers\n",
    "# with code big_data = big_data[big_data.price_x < 6000]\n",
    "\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import sklearn.cluster as cluster\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.preprocessing import StandardScaler as SC\n",
    "from sklearn.neighbors import KNeighborsRegressor as KNN\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "big_data = pd.read_csv('airbnb_coded.2.0.csv')\n",
    "sc = SC()\n",
    "sc_y = SC()\n",
    "le = LabelEncoder()\n",
    "knn = KNN(n_neighbors=65, weights='distance')\n",
    "\n",
    "pd.options.mode.chained_assignment = None  # default='warn'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99.0\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [-1])], remainder='passthrough')\n",
    "var = 'bathrooms'\n",
    "var2 = 'accommodates'\n",
    "var3 = 'cleaning_fee'\n",
    "var4 = 'bedrooms'\n",
    "var5 = 'beds'\n",
    "var6 = 'minimum_nights_x'\n",
    "var7 = 'maximum_nights'\n",
    "var8 = 'number_of_reviews_y'\n",
    "var9 = 'listing_class'\n",
    "var10 = 'price_x'\n",
    "var11 = 'bed_code'\n",
    "var12 = 'cancellation_policy_mapped'\n",
    "var13 = 'room_code'\n",
    "var14 = 'superhost'\n",
    "var15 = 'instant_book'\n",
    "var16 = 'review_scores_location'\n",
    "var17 = 'review_scores_rating'\n",
    "var18 = 'host_total_listings_count'\n",
    "var19 = 'availability_90'\n",
    "var20 = 'room_code'\n",
    "var21 = 'extra_people'\n",
    "var22 = 'property_type'\n",
    "\n",
    "big_data = big_data[big_data.price_x < 100]\n",
    "\n",
    "data = big_data[[var2, var3, var22, var10]]\n",
    "\n",
    "# data[var] = data[var].fillna(data[var].median())\n",
    "data[var2] = data[var2].fillna(data[var2].median())\n",
    "data[var3] = data[var3].fillna(data[var3].median())\n",
    "# data[var4] = data[var4].fillna(data[var4].median())\n",
    "# data[var5] = data[var5].fillna(data[var5].median())\n",
    "\n",
    "# data[var6][17990] = data[var6].median()\n",
    "# data[var6][6215] = data[var6].median()\n",
    "# data[var6][11299] = data[var6].median()\n",
    "# data[var6][12737] = data[var6].median()\n",
    "# data[var6][14598] = data[var6].median()\n",
    "# data[var7][872] = 8000\n",
    "# data[var7][2372] = 8000\n",
    "# data[var7][4391] = 8000\n",
    "# data[var7][17952] = 8000\n",
    "# data[var7][17990] = data[var7].median()\n",
    "# data[var7][6351] = data[var7].median()\n",
    "# data[var7][8341] = data[var7].median()\n",
    "\n",
    "\n",
    "# data[var6] = data[var6].fillna(data[var6].median())\n",
    "# data[var7] = data[var7].fillna(data[var7].median())\n",
    "# data[var8] = data[var8].fillna(data[var8].median())\n",
    "data[var10] = data[var10].fillna(data[var10].median())\n",
    "# data[var11] = data[var11].fillna(data[var11].median())\n",
    "# data[var12] = data[var12].fillna(data[var12].median())\n",
    "# data[var13] = data[var13].fillna(data[var13].median())\n",
    "# data[var14] = data[var14].fillna(data[var14].median())\n",
    "# data[var15] = data[var15].fillna(data[var15].median())\n",
    "# data[var16] = data[var16].fillna(data[var16].median())\n",
    "# data[var17] = data[var17].fillna(data[var17].median())\n",
    "# data[var18] = data[var18].fillna(data[var18].median())\n",
    "# data[var19] = data[var19].fillna(data[var19].median())\n",
    "# data[var20] = data[var20].fillna(data[var20].median())\n",
    "# data[var21] = data[var21].fillna(data[var21].median())\n",
    "data['property_type'] = data['property_type'].fillna('Apartment')\n",
    "\n",
    "\n",
    "# data[var6][17990] = data[var6].median()\n",
    "\n",
    "X = data.iloc[:, :-1].values\n",
    "y = data.iloc[:, -1].values\n",
    "X = ct.fit_transform(X)\n",
    "X = X.todense()\n",
    "X = np.array(X)\n",
    "# X = ct.fit_transform(X)\n",
    "# # X = X.todense()\n",
    "# X = np.array(X)\n",
    "# X = ct.fit_transform(X)\n",
    "# # X = X.todense()\n",
    "# X = np.array(X)\n",
    "# X = ct.fit_transform(X)\n",
    "# # X = X.todense()\n",
    "# X = np.array(X)\n",
    "# # ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [-4])], remainder='passthrough')\n",
    "# X = ct.fit_transform(X)\n",
    "# # X = X.todense()\n",
    "# X = np.array(X)\n",
    "# ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [-5])], remainder='passthrough')\n",
    "# X = ct.fit_transform(X)\n",
    "# X = X.todense()\n",
    "# X = np.array(X)\n",
    "# ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [-6])], remainder='passthrough')\n",
    "# X = ct.fit_transform(X)\n",
    "# # X = X.todense()\n",
    "# X = np.array(X)\n",
    "\n",
    "# plt.scatter(data[var6].values, data[var7].values, s=100, c='red', alpha=0.5)\n",
    "# plt.show()\n",
    "\n",
    "# X[:,-8:] = sc.fit_transform(X[:,-8:])\n",
    "# X = sc.fit_transform(X)\n",
    "for i in range(len(y)):\n",
    "    if y[i]>=6000:\n",
    "        print(i)\n",
    "print(max(y.T))\n",
    "# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.1)\n",
    "\n",
    "# data.head()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f11ca92bdf0>"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(data[var3].values, data[var10].values, alpha=0.2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from hdbscan import HDBSCAN as HDB\n",
    "# hdb = HDB(min_cluster_size=10, min_samples=16)\n",
    "# price_cluster = hdb.fit_predict(X)\n",
    "# price_cluster\n",
    "# data['price_class'] = price_cluster\n",
    "# big_data['price_class'] = price_cluster\n",
    "# data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "# counter = 0\n",
    "# for index in price_cluster:\n",
    "#     if index == -1:\n",
    "#         counter +=1\n",
    "# counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "# clusterer = cluster.KMeans(n_clusters=5)\n",
    "# price_cluster = clusterer.fit_predict(X)\n",
    "# price_cluster\n",
    "# data['price_class'] = price_cluster\n",
    "# big_data['price_class'] = price_cluster\n",
    "# data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.scatter(data[var2].values*100, data['price_class'].values, alpha=0.1, c='red')\n",
    "# plt.scatter(data[var10].values, data['price_class'].values, alpha=0.1, c='blue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "big_data.to_csv('airbnb_coded.4.0.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import sklearn.cluster as cluster\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.preprocessing import StandardScaler as SC\n",
    "from sklearn.neighbors import KNeighborsRegressor as KNN\n",
    "\n",
    "big_data = pd.read_csv('airbnb_coded.4.0.csv')\n",
    "sc = SC()\n",
    "sc_y = SC()\n",
    "knn = KNN(n_neighbors=65, weights='distance')\n",
    "\n",
    "pd.options.mode.chained_assignment = None  # default='warn'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1.   0.   0. ...  97.   0.   0.]\n",
      " [  1.   0.   0. ...  75.   0.   0.]\n",
      " [  0.   0.   0. ...  80.  10.  83.]\n",
      " ...\n",
      " [  0.   0.   0. ...  99.  19.   6.]\n",
      " [  0.   0.   0. ...  90.  10.   0.]\n",
      " [  1.   0.   0. ... 100.   0.   0.]]\n",
      "22\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [-1])], remainder='passthrough')\n",
    "var = 'bathrooms'\n",
    "var2 = 'accommodates'\n",
    "var3 = 'cleaning_fee'\n",
    "var4 = 'bedrooms'\n",
    "var5 = 'beds'\n",
    "var6 = 'minimum_nights_x'\n",
    "var7 = 'maximum_nights'\n",
    "var8 = 'number_of_reviews_y'\n",
    "var9 = 'listing_class'\n",
    "var10 = 'price_x'\n",
    "var11 = 'bed_code'\n",
    "var12 = 'cancellation_policy_mapped'\n",
    "var13 = 'room_code'\n",
    "var14 = 'superhost'\n",
    "var15 = 'instant_book'\n",
    "var16 = 'review_scores_location'\n",
    "var17 = 'review_scores_rating'\n",
    "var18 = 'host_total_listings_count'\n",
    "var19 = 'availability_90'\n",
    "var20 = 'room_code'\n",
    "var21 = 'extra_people'\n",
    "var22 = 'price_class'\n",
    "\n",
    "\n",
    "data = big_data[[var, var2, var3, var6, var8, var17, var21, var19, var9, var12, var20, var14, var10]]\n",
    "\n",
    "data[var] = data[var].fillna(data[var].median())\n",
    "data[var2] = data[var2].fillna(data[var2].median())\n",
    "data[var3] = data[var3].fillna(data[var3].median())\n",
    "# data[var4] = data[var4].fillna(data[var4].median())\n",
    "# data[var5] = data[var5].fillna(data[var5].median())\n",
    "\n",
    "data[var6][17990] = data[var6].median()\n",
    "data[var6][6215] = data[var6].median()\n",
    "data[var6][11299] = data[var6].median()\n",
    "data[var6][12737] = data[var6].median()\n",
    "data[var6][14598] = data[var6].median()\n",
    "# data[var7][872] = 8000\n",
    "# data[var7][2372] = 8000\n",
    "# data[var7][4391] = 8000\n",
    "# data[var7][17952] = 8000\n",
    "# data[var7][17990] = data[var7].median()\n",
    "# data[var7][6351] = data[var7].median()\n",
    "# data[var7][8341] = data[var7].median()\n",
    "\n",
    "\n",
    "data[var6] = data[var6].fillna(data[var6].median())\n",
    "# data[var7] = data[var7].fillna(data[var7].median())\n",
    "data[var8] = data[var8].fillna(data[var8].median())\n",
    "data[var10] = data[var10].fillna(data[var10].median())\n",
    "# data[var11] = data[var11].fillna(data[var11].median())\n",
    "data[var12] = data[var12].fillna(data[var12].median())\n",
    "# data[var13] = data[var13].fillna(data[var13].median())\n",
    "data[var14] = data[var14].fillna(data[var14].median())\n",
    "# data[var15] = data[var15].fillna(data[var15].median())\n",
    "# data[var16] = data[var16].fillna(data[var16].median())\n",
    "data[var17] = data[var17].fillna(data[var17].median())\n",
    "# data[var18] = data[var18].fillna(data[var18].median())\n",
    "data[var19] = data[var19].fillna(data[var19].median())\n",
    "data[var20] = data[var20].fillna(data[var20].median())\n",
    "data[var21] = data[var21].fillna(data[var21].median())\n",
    "\n",
    "\n",
    "# data[var6][17990] = data[var6].median()\n",
    "\n",
    "# data = data.drop(data.index[17990])\n",
    "data = data.drop(data.index[14598])\n",
    "\n",
    "X = data.iloc[:, :-1].values\n",
    "y = data.iloc[:, -1].values\n",
    "X = ct.fit_transform(X)\n",
    "# X = X.todense()\n",
    "X = np.array(X)\n",
    "X = ct.fit_transform(X)\n",
    "# X = X.todense()\n",
    "X = np.array(X)\n",
    "X = ct.fit_transform(X)\n",
    "# X = X.todense()\n",
    "X = np.array(X)\n",
    "X = ct.fit_transform(X)\n",
    "# X = X.todense()\n",
    "X = np.array(X)\n",
    "# ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [-4])], remainder='passthrough')\n",
    "# X = ct.fit_transform(X)\n",
    "# # X = X.todense()\n",
    "# X = np.array(X)\n",
    "# ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [-5])], remainder='passthrough')\n",
    "# X = ct.fit_transform(X)\n",
    "# X = X.todense()\n",
    "# X = np.array(X)\n",
    "# ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [-6])], remainder='passthrough')\n",
    "# X = ct.fit_transform(X)\n",
    "# # X = X.todense()\n",
    "# X = np.array(X)\n",
    "\n",
    "# plt.scatter(data[var6].values, data[var7].values, s=100, c='red', alpha=0.5)\n",
    "# plt.show()\n",
    "\n",
    "print(X)\n",
    "# X[:,-8:] = sc.fit_transform(X[:,-8:])\n",
    "# X = sc.fit_transform(X)\n",
    "print(len(X[0]))\n",
    "# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.1)\n",
    "\n",
    "# data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X = sc.fit_transform(X)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3)\n",
    "# X_train = sc.fit_transform(X_train)\n",
    "# X_test = sc.fit_transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8812614962454702"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestRegressor as RFR\n",
    "rf = RFR(n_estimators=500, min_samples_leaf=1)\n",
    "rf = rf.fit(X_train, y_train)\n",
    "rf.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.434140357104296"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rf = RFR(n_estimators=500, min_samples_leaf=10)\n",
    "# rf = rf.fit(X_train, y_train)\n",
    "# rf.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rf.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.43074722 0.45235778 0.490122   0.51238123 0.25680587 0.4445461\n",
      " 0.52091901 0.42874119 0.44317643 0.383395   0.332495   0.60257194\n",
      " 0.45576464 0.40108724 0.53311488]\n",
      "0.4458817022743881\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.08138810550250893"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "scores = cross_val_score(rf, X, \n",
    "                          y, scoring='r2', cv=15)\n",
    "print(scores)\n",
    "print(np.mean(scores))\n",
    "np.std(scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "# array = data[var10].isna()\n",
    "# array = array.values\n",
    "# for i in range(len(array)):\n",
    "#     if array[i]:\n",
    "#         print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9580952110742209"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "knn.fit(X_train, y_train)\n",
    "knn.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.25002303725856456"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "knn.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.24952782 -0.22604822 -0.25643589 -0.19669794 -0.25365488]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-0.23647295012242892"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "scores = -cross_val_score(knn, X, \n",
    "                          y, scoring='r2', cv=5)\n",
    "print(scores)\n",
    "np.mean(scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5157455656453052"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeRegressor as DTR\n",
    "dt = DTR(min_samples_leaf=10)\n",
    "dt = dt.fit(X_train, y_train)\n",
    "dt.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1990989758492535"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.34470636 -0.30002252 -0.29912436 -0.28319368 -0.2894111 ]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-0.30329160387403836"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores = -cross_val_score(dt, X, \n",
    "                          y, scoring='r2', cv=5)\n",
    "print(scores)\n",
    "np.mean(scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}