simple_linear.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### importing the relevant packages and loading the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn import linear_model\n",
    "\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "from sklearn.metrics import median_absolute_error\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = pd.read_csv(\"/media/vajira/0FD50F0F0FD50F0F/Sem7_Academic/Data Mining/dengAI/dengue_features_train.csv\")\n",
    "y = pd.read_csv(\"/media/vajira/0FD50F0F0FD50F0F/Sem7_Academic/Data Mining/dengAI/dengue_labels_train.csv\")\n",
    "pred_X = pd.read_csv(\"/media/vajira/0FD50F0F0FD50F0F/Sem7_Academic/Data Mining/dengAI/dengue_features_test.csv\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pre Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_month(s):\n",
    "    return int(s[5:7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_process(X, train = True):\n",
    "    \"\"\"\n",
    "    Extracts the month out of date and converts it to a one hot\n",
    "    Standardizes the numerical features\n",
    "    Converts the city column to a boolean feature\n",
    "    \"\"\"\n",
    "    # Converting the city column into a boolean, since we just have two cities\n",
    "    is_sj = X.city == 'sj'\n",
    "\n",
    "    #Extracting month from the date\n",
    "    months = X.week_start_date.apply(extract_month)\n",
    "\n",
    "    # Removing the dates info for now\n",
    "    X.drop(['city', 'year', 'weekofyear', 'week_start_date'], axis=1, inplace=True)\n",
    "    \n",
    "    if train:\n",
    "        # Dropping the rows with null values for now\n",
    "        X.dropna(inplace=True)\n",
    "    else:\n",
    "        X.fillna(0,inplace=True)\n",
    "\n",
    "    # Standardizing the data\n",
    "    scaler = StandardScaler()\n",
    "    X[X.columns] = scaler.fit_transform(X)\n",
    "\n",
    "    # Adding the city boolean column\n",
    "    X['is_sj'] = is_sj.loc[X.index]\n",
    "\n",
    "    sliced_months = months.loc[X.index]\n",
    "    # Month one hot features\n",
    "    month_features = pd.get_dummies(sliced_months)\n",
    "    X = X.join(month_features)\n",
    "\n",
    "    # Alternatively use months as a discrete feature\n",
    "    #X = X.join(sliced_months)\n",
    "    \n",
    "    return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = pre_process(X)\n",
    "pred_X = pre_process(pred_X, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Selecting y values corresponding to the filtered X values\n",
    "y = y.total_cases.loc[X.index]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**splitting the data to train and test : **\n",
    "Since this is timeseries data, we set the arguement shuffle to False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, Y_train, Y_test = train_test_split(X, y, shuffle = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Model\n",
    "Let us see the performance when we predict the number of cases for any given week to be equal to the mean number of cases in the past"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_p = np.full(len(Y_test), np.mean(Y_train))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18.120148312940305"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_absolute_error(Y_test, y_p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The performance on this random model is the first benchmark that we shall improve upon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Baseline Model\n",
    "A simple linear regression implementation from scikit learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    city  year  weekofyear  total_cases\n0     sj  2008          18            0\n1     sj  2008          19            0\n2     sj  2008          20           11\n3     sj  2008          21            0\n4     sj  2008          22            0\n5     sj  2008          23            5\n6     sj  2008          24           11\n7     sj  2008          25           26\n8     sj  2008          26           29\n9     sj  2008          27           44\n10    sj  2008          28           28\n11    sj  2008          29           37\n12    sj  2008          30           53\n13    sj  2008          31           39\n14    sj  2008          32           74\n15    sj  2008          33           73\n16    sj  2008          34           71\n17    sj  2008          35           77\n18    sj  2008          36           89\n19    sj  2008          37           97\n20    sj  2008          38           80\n21    sj  2008          39           60\n22    sj  2008          40           77\n23    sj  2008          41           52\n24    sj  2008          42           55\n25    sj  2008          43           48\n26    sj  2008          44           34\n27    sj  2008          45           65\n28    sj  2008          46           47\n29    sj  2008          47           43\n..   ...   ...         ...          ...\n386   iq  2012          48           79\n387   iq  2012          49           40\n388   iq  2012          50           63\n389   iq  2012          51           63\n390   iq  2013           1           50\n391   iq  2013           2           21\n392   iq  2013           3           16\n393   iq  2013           4           57\n394   iq  2013           5           29\n395   iq  2013           6           52\n396   iq  2013           7           29\n397   iq  2013           8           45\n398   iq  2013           9           33\n399   iq  2013          10           31\n400   iq  2013          11           43\n401   iq  2013          12           55\n402   iq  2013          13           45\n403   iq  2013          14           28\n404   iq  2013          15           20\n405   iq  2013          16           31\n406   iq  2013          17           26\n407   iq  2013          18            0\n408   iq  2013          19           22\n409   iq  2013          20           17\n410   iq  2013          21            3\n411   iq  2013          22            0\n412   iq  2013          23           13\n413   iq  2013          24            0\n414   iq  2013          25            0\n415   iq  2013          26            0\n\n[416 rows x 4 columns]\n"
     ]
    }
   ],
   "source": [
    "lr = LinearRegression()\n",
    "\n",
    "lr.fit(X_train, Y_train)\n",
    "Y_pred = lr.predict(pred_X)\n",
    "Y_pred = Y_pred.clip(min=0)\n",
    "sub = pd.DataFrame()\n",
    "pred_X1 = pd.read_csv(\"/media/vajira/0FD50F0F0FD50F0F/Sem7_Academic/Data Mining/dengAI/dengue_features_test.csv\")\n",
    "sub = pred_X1[[\"city\", \"year\", \"weekofyear\"]]\n",
    "sub[\"total_cases\"] = (Y_pred.astype(int)).tolist()\n",
    "print ((sub))\n",
    "sub.to_csv(\"submission.csv\",index=False)\n",
    "#print (len(Y_pred.astype(int)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Found input variables with inconsistent numbers of samples: [300, 416]",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-94-5256f7e73901>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmean_absolute_error\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mY_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/sklearn/metrics/regression.py\u001b[0m in \u001b[0;36mmean_absolute_error\u001b[0;34m(y_true, y_pred, sample_weight, multioutput)\u001b[0m\n\u001b[1;32m    168\u001b[0m     \"\"\"\n\u001b[1;32m    169\u001b[0m     y_type, y_true, y_pred, multioutput = _check_reg_targets(\n\u001b[0;32m--> 170\u001b[0;31m         y_true, y_pred, multioutput)\n\u001b[0m\u001b[1;32m    171\u001b[0m     output_errors = np.average(np.abs(y_pred - y_true),\n\u001b[1;32m    172\u001b[0m                                weights=sample_weight, axis=0)\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/sklearn/metrics/regression.py\u001b[0m in \u001b[0;36m_check_reg_targets\u001b[0;34m(y_true, y_pred, multioutput)\u001b[0m\n\u001b[1;32m     73\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     74\u001b[0m     \"\"\"\n\u001b[0;32m---> 75\u001b[0;31m     \u001b[0mcheck_consistent_length\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_true\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     76\u001b[0m     \u001b[0my_true\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcheck_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_true\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mensure_2d\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     77\u001b[0m     \u001b[0my_pred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcheck_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_pred\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mensure_2d\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36mcheck_consistent_length\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m    202\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0muniques\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    203\u001b[0m         raise ValueError(\"Found input variables with inconsistent numbers of\"\n\u001b[0;32m--> 204\u001b[0;31m                          \" samples: %r\" % [int(l) for l in lengths])\n\u001b[0m\u001b[1;32m    205\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    206\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: Found input variables with inconsistent numbers of samples: [300, 416]"
     ],
     "output_type": "error"
    }
   ],
   "source": [
    "mean_absolute_error(Y_test, Y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEKCAYAAAD9xUlFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3XuUXXV99/H3N5MBknAJSEAYCEHMIpJGQplC2lhrqBYsAhFRpOjCLisPvSnSxoY+tAlKFcVKtU9rDVBNKyJXQ6JWoFweuvAhmhhCiEBVCJcJNahMuEWTTL7PH3ufkzOTfTt7zt5nn3M+r7WyZs6es8/5zc6c33f/bt+fuTsiIiIAE9pdABERqQ4FBRERqVNQEBGROgUFERGpU1AQEZE6BQUREambWOSLm9km4CVgBNjp7oNmdhBwIzAD2AS8x91fKLIcIiKSTRkthQXuPtfdB8PHi4G73X0mcHf4WEREKqAd3UdnAcvD75cDC9tQBhERiWBFrmg2syeBFwAHvuTuy8xs2N2nNjznBXc/MOLcC4ELAaZMmXLirFmzCiuniEg3Wrt27c/cfVoz5xQ6pgDMd/fNZnYIcJeZPZb1RHdfBiwDGBwc9DVr1hRVRhGRrmRmTzV7TqHdR+6+Ofy6BfgGcBLwUzM7DCD8uqXIMoiISHaFBQUzm2Jm+9W+B34PeARYCVwQPu0C4PaiyiAiIs0psvvoUOAbZlZ7n6+5+3fM7PvATWb2QeBp4N0FlkFERJpQWFBw9yeA4yOO/xz43aLeV0RE8tOKZhERqVNQEBGROgUFERGpU1AQEZE6BQUREalTUBARkToFBRERqVNQEBGROgUFERGpU1AQEZE6BQUREalTUBARkToFBRERqVNQEBGROgUFERGpU1AQEZE6BQUREalTUBARkToFBRERqVNQEBGROgUFERGpU1AQEZE6BQUREalTUBARkToFBRERqVNQEBGROgUFERGpU1AQEZE6BQUREalTUBARkToFBRERqVNQEBGROgUFERGpU1AQEZE6BQUREakrPCiYWZ+ZrTOzb4aPjzaz1Wb2IzO70cz2KroMIiKSTRkthY8AjzY8/jRwtbvPBF4APlhCGUREJINCg4KZHQGcDlwbPjbgFOCW8CnLgYVFlkFERLIruqXwD8DHgF3h49cAw+6+M3z8LDAQdaKZXWhma8xszfPPP19wMUVEBAoMCmb2DmCLu69tPBzxVI86392Xufuguw9OmzatkDKKiMhoEwt87fnAmWb2+8A+wP4ELYepZjYxbC0cAWwusAwiItKEwloK7n6pux/h7jOA9wL3uPv5wL3AOeHTLgBuL6oMIiLSnHasU/gr4BIz+zHBGMN1bSiDiIhEKLL7qM7d7wPuC79/AjipjPcVEZHmaEWziIjUNRUUzGyCme1fVGFERKS9UoOCmX3NzPY3synAD4HHzWxR8UUTEZGyZWkpHOfuLxKsPP42MB14f6GlEhGRtsgSFPrNrJ8gKNzu7juIWXAmIiKdLUtQ+BKwCZgC3G9mRwEvFlkoERFpj9Qpqe7+BeALDYeeMrMFxRVJRETaJctA86Fmdp2Z/Uf4+DiClcgiItJlsnQffQW4Azg8fPzfwMVFFUhERNonS1A42N1vIkx/HSayGym0VCIi0hZZgsIrZvYawhlHZjYP2FpoqUREpC2y5D66BFgJHGNmDwDT2J3lVEREukiW2Uc/MLPfAY4l2CTn8XCtQiWtWDfEVXc8zubhbRw+dRKLTj2WhSdEbu4mIiJjZJl99G5gkrtvJFjAdqOZ/XrhJcthxbohLr1tA0PD23BgaHgbl962gRXrhtpdNBGRjpBlTOFv3P0lM3sTcCqwHPhiscXK56o7HmfbjtFj4Nt2jHDVHY+3qUQiIp0lS1Co1bKnA19099uBvYorUn6bh7c1dVxEREbLEhSGzOxLwHuAb5vZ3hnPK93hUyc1dVxEREbLUrm/h2Dx2mnuPgwcBFQydfaiU49lUn/fqGOT+vtYdOqxbSqRiEhnyTL76FXgNjM7xMymh4cfK7ZY+dRmGcXNPtLMJBGRZKlBwczOBP6eIM3FFoL9FB4DZhdbtHwWnjAQWdHXZibVBqJrM5Nq54iISLbuo08A84D/dvejgbcCDxRaqgJoZpKISLosQWGHu/8cmGBmE9z9XmBuweVqOc1MEhFJlyXNxbCZ7QvcD1xvZluAncUWq/UOnzqJoYgAoJlJIiK7ZWkpnAW8CnwU+A7wE+CMIgtVBM1MEhFJl6WlcAjwnLv/ElhuZpOAQ4GfF1qyFkubmSQiItmCws3AbzU8HgmP/UYhJSpQ3MwkGT9N9xXpDlmCwkR331574O7bzaySaS6kPTTdV6R7ZBlTeD5cqwCAmZ0F/Ky4Ikmn0XRfke6RpaVwEcGso/8TPn4WeH9xRZJOo+m+It0jS5qLnwDzwmmp5u4vFV8s6SSa7ivSPTJnO3X3lxUQJIqm+4p0jyzdRyKJNN1XpHsoKEhLaLqvSHfIskfzZDP7GzO7Jnw808zeUXzRRESkbFnGFL4M/Ar4zfDxs8AVaSeZ2T5m9j0zW29mG83s8vD40Wa22sx+ZGY3as2DiEh1ZAkKx7j7Z4AdAO6+DbAM5/0KOMXdjyfIqnqamc0DPg1c7e4zgReAD+YquYiItFyWMYXtYb4jBzCzYwgq/ETu7sDL4cP+8J8DpwB/EB5fDiwFvthUqaVO6SVEpJWyBIUlBNlRjzSz64H5wAeyvLiZ9QFrgdcD/0SQYXXY3Wupt58FImswM7sQuBBg+vTpUU/pSK2sxJVeQkRaLbX7yN3vAs4mCAQ3AIPufl+WF3f3EXefCxwBnAS8IeppMecuc/dBdx+cNm1alrervFolPjS8DWd3Jb5i3VCu11N6CRFptSyzj95MsB/zS8CLwHHhsczcfRi4j2Bbz6lmVmuhHAFsbua1OlmrK3GllxCRVsvSfbSo4ft9CO741xKMDcQys2kEW3kOh2MSbyUYZL4XOAf4OnABcHuOcnekVlfiSi/RPhrLkW6VJffRqF3WzOxI4DMZXvswgk15+ghaJDe5+zfN7IfA183sCmAdcF3zxe5Mra7EF5167KgxBahmeoluq0A1liPdLM+K5meBX0t7krs/DJwQcfwJgtZG6dpdObW6Eu+E9BLdWIEmdQN26u8kUpMaFMzsH9k9GDyBYM3B+iILVYQqVE5FVOJVTy/RjRWoxnKkm2VpKaxp+H4ncIO7P1BQeTJr9q6/KpVT1SvxVuvGClRjOdLNsowpLC+jIM3Ic9dfROXU7u6oTtCNFWinjOWI5JFlSuoGM3t4zL//MrOrzew1ZRRyrDxTO+MqobyVU6vXHHS6FeuGmH/lPRy9+FvMv/Ke+nXoxr0WFp4wwKfOnsPA1EkYMDB1Ep86e45uCKQrZOk++g9gBPha+Pi94dcXga8AZ0ScU6g8d/2tvrurSndUFWRpuXVbi6rXugGld2QJCvPdfX7D4w1m9oC7zzez9xVVsCRJXRJxXTqtrpyi3j/peDdLC5CqQEU6R5agsK+ZnezuqwHM7CRg3/BnO+NPK07cXf+CWdNYdPN6duwKJksNDW9j0c3BRKlWV059Zoz4nhk6+ixLAtnu0o2DySK9Kkvq7D8CrjWzJ81sE3At8CEzmwJ8qsjCxYnr0/3m+ufqAaFmxy5n6cqNLS9DVEBIOt7NWj1eIyLtk2X20feBOWZ2AGBhHqOamworWYqou/6Lb3wo8rnD23bkfp+47qiBmC6sgR6sCDUbR6R7ZFm8tjfwLmAGMNHC7hF3/3ihJauApAFUVYS7detgskinqt3M7vXa15/Y7LlZxhRuB7YSJMFL3VynnSYY7IrovZmQs5s/aQD1gcWn1J+jilCzcUSqYuzNbLOyBIUj3P20XK9esqiAkHQ8TdoMI1WEIlI1UTezzcgy0PxdM5uT+x1KFNefn7efP66B0Xvzi0SkU4x31l+WoPAmYK2ZPR6uZt5gZg+P610L0urVs3ENjN6bXyQSL241u7THeGf9Zek+evu43qFEGvAUKVcVsg/LaFGTYJqRZUrqU2b2JmCmu3853FFt37Tz2qWV/fxT9urjle17Xtgpe/VFPFuapYSCnU/pXqqn8eb4uRznZ5mSugQYBI4Fvgz0A18F5ied1w36+yYQpH2KOi7joTvM7qDV7NVUuzm2S3+8ttlzs9Ru7wTOBF4BcPfNwH7NvlEn2hqz6C3uuGSXJ9OtVI9Ws3efLEFhu7s74fhqmN6iJ+gPvji6w+wO3ZgavddlCQo3mdmXgKlm9iHgP4Frii1WNegPvjgKuN1Be0t0nywDzZ81s7cR7J9wLPC37n5X4SWrAM1mKo7ShHQPLeLsLuYdkNVzcHDQ16xZk/5E6SiafSRSLDNb6+6DzZwT21Iws5dIWKfl7vs380ZVpwqqfLrD7A767HSX2KDg7vsBmNnHgf8B/p0gw8P5dNnsI02PFMlHn53uk2Wg+VR3/2d3f8ndX3T3LxKk0u4amh4pko8+O90nS5qLETM7H/g6QXfSeUSt6KqIPE3ZpGyoahqLxH+uNLW4+2QJCn8AfD7858AD4bHKWbFuKHGP5jhx+y2boaax9LykLqLDY3Yg1NTizpXafeTum9z9LHc/2N2nuftCd99UQtmatnTlxlx7NMftq+yOmsbS85K6iLSWp/tkaSl0jLi9mNP2aI7bbzlOlZrG6t6SoiV1EWktT/fpqqCQV9xCqr0nTogMKFVpGmvmh5QhrYtIU4u7S1el+zxwcn9Tx2viluovPXN2YtO43ZuLaOaHlEFdRL0lafHaJUknuvvnWl+c8VlyxmwW3bKeHSO7xwj6+4wlZ8xOPTfpbieqaZx3ULuVNPOjmrqtS6+oLqJuu07dIqn7qLZA7VjgN4CV4eMzgPuLLFRe4/njjfsDjQsWSYPaZf1ha+ZH9XRrl16ru4i69Tp1g6QVzZcDmNmdwK+7+0vh46XAzaWULoc8f7x5/kDzDmq3UpWSyrX6rq9T7yK1E1k2uk7VlWVMYTqwveHxdmBGIaWJsWFoa6F99p3aN1+VtMW1oDo0vA1nd1DN+//V6tcrk7r0stF1qq4ss4/+HfiemX2DYPHaO4F/SzvJzI4Mn/daYBewzN0/b2YHATcSBJZNwHvc/YW018vavMxzh5nnD/TAyf288OqerYK0Qe1Wq8LMj1bf9XXyXaS69LLRdaquLIvX/g74Q+AFYBj4Q3f/ZIbX3gn8hbu/AZgH/KmZHQcsBu5295nA3eHjTNLu3vPeYebZ8GXJGbPp77NRx7IOanebVt/1dfJdpGbqZKPrVF1Zp6ROBl50988Dz5rZ0WknuPtz7v6D8PuXgEeBAeAsYHn4tOXAwmYKnFQxpHUDxU0hXTBrWuTrxR2H4A79qnOOH9V1c9U5xxd2J9vu6a9Jpsa0juKOp+nkXdmq0qVXdbpO1ZXafWRmS4BBgllIXwb6ga8C87O+iZnNAE4AVgOHuvtzEAQOMzsk5pwLgQsB+vbfXTknVQxpie3iBpPvfez5yPPijtcUMSMjbvprlWdqxO3TlHf/pioNoOdRhS69TqDrVE1ZxhTeSVCh1+76N5tZ5v0UzGxf4FbgYnd/0czSTiF8n2XAMoC9D5vpkF4xxCW26zNLbEVUobsiqeKveh/71pgZV3HH0yh1gkj7ZAkK293dzcwBzGxK1hc3s36CgHC9u98WHv6pmR0WthIOA7Zkea2BDBVDXGK7EffEij/voFcrp01WPWglKWLQUHeRIu2RZUzhJjP7EjDVzD4E/CdwbdpJFjQJrgMeHbP6eSVwQfj9BcDtaa81Z+AAHlh8yqhKIqqPfSCmEhqYOimxnzrPoFerp02mBa24spcpblxDg4Yi3SO1peDunzWztwEvEowr/K2735XhtecD7wc2mNlD4bG/Bq4kCDQfBJ4G3t1soeO6Wt514gC3rh2K7YuO66fO012R1qXTbCsi6W47qY+9rEVeWcY11N1TjE5dyCedyTxlNNDMPu3uf5V2rEiDg4O+Zs2a+uP5V94TWYHWupjiPkCt/HAdvfhbRF05A64+d25kJZ40u2LFuiEuuekhGjNnTDD43HvmxgYZiA50WWZxNHstkq75A4tPSXwvyW9sMIbs/8ciZrbW3QebOidDUPiBu//6mGMPu/sbc5Qxl70Pm+mDH/lSveJKqpCfvPL0XO/RykoSomdCJVWgl63YwFcffHqP4++bN50rFs5pugxJFXWeiqaIay7pFIxlPPIEhdgxBTP7YzPbAMwys4cb/j0JbBhvYZvV2Gef1MeeZz5/0vhAnn70pKmxcW5Y/UxTxyH/Iq88aT2qMq7Ra6o+yUC6T9JA89cIMqLeHn6t/TvR3c8voWx7SNsCcMGsabkGf+MqyctXbWTRLetHvd6iW9azYt1Q4uKbvphpt3HHIXnmVJy8FXWeikaDye2hYCxlS8qSuhXYamafB37RkCV1PzM72d1Xl1XIRklbAOadzx9XGUblNtox4ly+amNiWu08FXzSGos4eRd55ZlCWvZgsgZXA52+kE86T5Z1Cl8EGscUXok4VpqkLQAvvvGhqFNS91+OqyTjRAWLRnF7PsdNmQU47+QjI8cUzjv5yNhz8lbUeSuastYOVH0Fd5k0s6t6uv2GJUtQMG8YjXb3XWbWlr2dx7OiOUlcJTm21ZFVnkq3Nph8w+pnGHGnz4zzTj4ydpC5Jk9FXfW7/qqv4C6bFvJVRy/csGSp3J8wsw8TtA4A/gR4orgiRRvviuYkcZXkopsfYseuPZ/fn7LkL2+le8XCOalBoFWqfNevwVWpql64YckSFC4CvgBcRrCfwt2EierKUlvRnCZPt02SnTGxJO54o7KS5VVdng9REWkzOvX6SbX0wg1LlhXNW4D3llCWccvbVx53N9vq7J95dXKTNe9Mp6T/x2Yr+LTrp61EJate2BwoNiiY2cfc/TNm9o+w57old/9woSXLIW+3TdzdbJy0MYq84iqTTm6ytnqmU54AmbYuo5UBt5MDuKTrhdlgSS2FR8OvaxKeU4oNQ1s55tJvFzbw2mzTL2lGUF4r1g2x6Jb17BgJ4m9tTURS+cbTZC3rbrbVM53yBMik66etRKUZvTAbLGmdwqrw6/K455RpxL0+ZbPVg7Fxd7MDUyexYNa0pmcE5XH5qo31gFBTWxPR6iZrmd0prf4Q5QmQSddPW4mOX691l3X7bLCk7qNVRHQb1bj7mYWUKMUNq59JrJQvW7Gh6Uo87W723seeZ/PwNl57wD4MHnVQpnI2+0GJW/vwwqs7WHLG7FGtCAj2g87bZC2zO6V2Xqs+RHkCZNL/71V3PN7SgNsLfc6N1F3WfZImV34W+HvgSWAbcE3472XgkeKLFi1pemktqVztObXWxWUrklM1xaWsAHKlzVixbohFN49Jj3Hz+nHtqzwyphUx9nEz8nanVEGedBtJKUlanb4j7+tdtmIDx1z6bWYs/hbHXPrt1L/Z8Wjlft9V/3uR5iV1H/1fADP7hLu/ueFHq8zs/sJLFmNCwhjv9av3XBFcO55nLGL+lffk6h9eunIjO3aN6Qra5SxduTH2vKmT+hmO2L5y6qR+lq7cyNjlErvC98lzN1Zmd0qr5e2OimuttLp7K8/rjc2QW2RXaavv7Kv+9yLNy7JOYZqZvc7dnwAws6OBacUWK97eE+MbN62eQpr3Dz6qck86DvCO4w+LTHMRd7z2enn6c8vsTilCXAWft2+71X3Ezb5eUobcVgeFVg+E91p3WS/IEhQ+CtxnZrVVzDOA/1VYiVL8MmqJcUHK/IO/97Hnmzpek2fAOO1uthOn3HVy33belfjQfCBs9Z19L0zR7DVZFq99x8xmArPCQ4+5+6+KLVa8pAp5cv8EXo0IGpPT8lLEWDBrWuRd+oJZrW8oJX1YD5zcHzkQPcH2XE/R2J8bN8U1KcNrp0656+SpoHlzduUJhK2+0enUvxeJlxoUzGwycAlwlLt/yMxmmtmx7v7N4os3WtodyCfPfmPklpafPDvfJnF5797jKvEDJ/fHnpO2R3PU7KOxU1hrNg9vS5zimrf/vco6uW87T4ZcyBcIi7iz78S/F4mX5Rb6y8B24DfDx88CVxRWohiNM0biLDxhgM+9Z+6oWSa1PY7zyFvRLDljNv19o+/y+vuMJWfMjj0nadbKwhMGuOqc40f9XrXHUQ6fOilxims36uTNaK5YOIf3zZtebxn0mSVuw1qT5+8zaSaWCGQbUzjG3c81s/MA3H2bWUF5HmJkTYgH7Z8TXysDNNekTjsn7veKu+uL21uiW3V633aeDLnj+ftUEJA4WYLCdjObRLiQzcyOAdo2pjAezQ7KjaeiybvPQTPnJAWSpSs3xk5x7Ua92Lfd6YFQqsk8ZYaDmb2NIG32ccCdwHzgA+5+X+GlCw0ODvqaNeNLwTR2UA6CD1Ba0zkpkFR5eX9tAV3jeon+CcZV7z4+tYxxv1enXotupusuScxsrbsPNnVOUlAIu4mOAF4F5gEGPOjuPxtPQZvViqAw/8p7YvMbZe2aapQ3yJQpT4UR93u968QBbl07FPn7QnQ3VpWuhUgvanlQaHjRE8dVsnFqRVA4evG3IhM5GfDklac3/XqtDjJVEfd7xU2brA12d+O1EOl0eYJCltlHD5rZb+QsU2W0enZKJ0+BTBJX/riFVJuHt3XttRDpRVkGmhcAF5nZJuAVgptrd/d8k//bJG6uf5Zd2aK6YNJmfuTpl6+CuN8rrqVweEJLoROmg4rIaFmCwtsLL0VZxtZpKVkEklaMJs38iDtvzVO/GNUvX8VUDHG/V9yYQi2oahaMSHdI2k9hH+Ai4PXABuA6d99ZVsFa7ao7Ho/MXJq0+jNpxWitrzzqrj8uu2ptn4eo16tKUEia2jl41EGJrZwqt4BEJJuklsJyYAfwXwStheOAj5RRqCLk6feO6hJpPB63riBPv3wRWp01NGkdhRZEiXSHpKBwnLvPATCz64DvlVOkYpSZ8TRvv3wrdXLWUBFpn6TZR/XlsJ3cbVTT6h22ksRlUZ33ugNLK0Mv7ojVyh3FRHpVUkvheDN7MfzegEnh49rso/0LL10L5UmDkDelcVwW1U0/38anzp5TyqrgXpsmqpaRSGskbcfZF/ezTtVsv3felMZJFXLSrmF5KrW8U2a7TSfvpyBSJfl2n8nAzP7VzLaY2SMNxw4ys7vM7Efh1wOLev9WyJvSOM9CuTzdPbVAMjS8DWd3IFmxbqjU7rKyRXUT9VrLSKQoqWkucr+w2ZuBl4F/c/dfC499BviFu19pZouBA939r9JeqxVpLqC85GFJeZEgugsrTxqOtFQbVV8ol0fctd2nf0LkXhFKtSG9LE+aiyyL13Jx9/vNbMaYw2cBbwm/Xw7cB6QGhVYoos/5shUb6msP+sw47+QjuWLhnNjxC4jfUzlPd0/a3XE3ThONa1HtPXECk/r7tIBOZJwKCwoxDnX35wDc/TkzOyTuiWZ2IXAhwPTp0zO/Qdzdcav7nC9bsWHUeMOIe/1xLTCMfd24RW1X3fF4rtz4vTZuAPGBcOu2HVx97tyuaxmJlK3soJCZuy8DlkHQfZTlnKTWQKv7nG9Y/Uzs8bgxh7QBaGhudlQvbrKSFAi7sWUkUrayg8JPzeywsJVwGLCllS+e1Bpo9V113OrkuOMAB0zqj9wN7YBwN7Q8O6+teeoXo7qw3nVid1eMvRgIRcpU2OyjGCuBC8LvLwBuz3LShqGtmRYjJd2Jp83GaXbhU9xKhaQVDHHLG/LueL1i3RC3rh2qB6IRd25dO9TVi7a08bxIsQprKZjZDQSDygeb2bPAEuBK4CYz+yDwNPDurK83dmA4auwgrWsBortn8gxCT96rj1e2j0QejzMcMTsm6XiatHGSbpx9BN05gF4V3fo3I9kVOfvovJgf/W7e12yctx9Viaeld46rTPIMQr8aERCSjkPrB4aTWkZa4SvN0t+MQPndR+O2eXhbbCV+72PP5+payDMInWeBWqsXlCWVQbmPlPuoWb34NyN7quzsozhxd9sQ3Nnk6VrIcwefZ8AzzwyjJEll+OiND0We060rfHWXO35aFS7QYS2FWoUXl5AuLVFdnDx38HkHPBeeMMADi0/hyStP54HFp4yrwkoqQ6v3pK463eWOX6/9zUi0jmkpDDTcVV8ccxecNB00Sd47+CoMeMaVodembuoud/x67W9GonVEUJgzcMCo/DUDMd09A+O4oymrgi9rdkevrWHoxdXdrdbq7k3pTB0RFMZadOqxLLplPTtGdrcM+vusUnc0UZU/xOc+avUHL24Nw+BRB3Xlh1x3ua1RhdavtFdHBgWAPVKKFpPsNZe4Qc+9J04oLed/r+0vUNRdrubtS6/pyKBw1R2Ps2PX6CiwY5dXpsKLq5DHHqspot+7m/vY4yrqVt/lakaT9KKODApFVHh57gjjzmm2HLV+71belXZrH3uZFXWvtbZEoEODQt4KL67STapooPnUGHHlO3ByP7/csSuy37vVld2iU49l0c3rR7Wo+idUa9wljzIr6m5ubYnE6cigkDSomKfij6tolq7cyCvbd9YHtIeGt7HolvWJ5yTtjbDkjNmxM4KS9lrIXdmNXbaRM/FeOzTbCiuioq5Ka0vjGlKmjgwKSTubNd4dDw1vY9HN6ZV4XIUSleZ6x4hz+aqNkVs/1t4zqXxxM4JaXdlddcfjo2Zn1creCV0feVphRVTUVZjRpHENKVtHBgWInjo39/I7Iwegl67cyNaICh6oV9pxqTOivPDqDozoCU+1m/Fmd14rM1le1eVphRVRUVdh3r7GNaRsHREUavsppH0go+7sa8fjFrzVPuhRFU3cbCGInwFbOx7V5E+qqK8+d25LK7uqdH3k0eod6saj3fP2Ozm4S2fqmNxHtWZz3syXSfmN4nIITQ13RBsr7nhNrck/NLwNbyj7ATHn1fZ7aOXmMa3OyFqmtBw8rcwfVXXKRyRl64iWQk1as/nAyf2Rff0HTu5PvcOMuiNc89Qv+OqDT+/xeu84/jCuf/Dp2O6juCb/Pv0T9miBZNnvIY8qdH3kVYW+/KrQtZCydVRQgORm85IzZkemv1hyxmyg+Ur33seejz1+/rzpkQG5r6zjAAAMM0lEQVTj/HnTuT7iOAQ7rF197tye6frIq5MDWqvpWkjZOi4oJDWbW/0BSurPvWLhHIBR00vPO/lIrlg4h289/Fxki2Vq2GLRBzqdrtNuuhZSpo4KClmazXk/QM3u+QxwxcI59eDQKC6Dd87M3iIipemYgeYiUz/HDQwvmDUt12Bt3PTXuOMiIlXRMUGhttBrPPvuxu3h2+o9n8ucMaJ9iUWklTqq+2g8i3aSVoamzYtv9v3K2u9hxbqhUe/TmIZDfdAikkfHtBRqxpP2IWk1cZRx3dmXsN/D5as2RqayuHzVxta/mYj0hI4LCkWkfWj1Qq+k/R6SNNsVFJd/Ke64iEiajuo+aqyok7KhRh1PmklU5lTWOEp8JiJV0DFBYSBDGuw1T/2CW9cORVasaStDWzkXPE/eoTyJz6ZO6o/M95SWhgOUjllEonVE99GcgQNG5biJq0BvWP1MYsXaytxCSfJ0R+VpXSw9czb9E0ZvktA/wVh65uzE8sVNwdXMJRHpmJZCo7iKciRmdVjt+WWtDM3THZWndZG320vpmEUkTkcGhUn9E3h1x67Mzy8qo2RSF0yzAWjBrGmRuZQWzJqWeF6eQKd0zCISpyO6j8balhAQykoX3eoumKTke62mdMwiEqcjg0LSlP+yxg2SumDyKPPuPW3MQ6ukRXpXR3YfJUnqTknq7ml2Nk7c9p3NbOvZqMyd0pLGIjQ1VqS3dWRQmBwzpjC5P77hk1TZAYk/i6o8+8wiB7b7zPY41uiyFRsi023n3Uwl79TSuOCpQWiR3taRQeGTZ7+RS256iMZFwxMsOB4nrbsn6meXr9rIL3fsigwWcTOd4o5DEBAaB5NH3OuPaym4m6ngi7ir1yB0NlrnId2qI4LChqGtzL/ynvoHL6n7I+5OPE9lF5UuohZIBmK6ewYSuntuWP1M7PErFs5peiZREXf1ZXZjdSp1sUk3a0tQMLPTgM8DfcC17n5l2jljP3hRFWjSnXhaZdfMWMDm4W2x23EmTSHN07pI0upxDdCewFmoi026WelBwcz6gH8C3gY8C3zfzFa6+w/Tzk374MXtjXz9g09z9blzEyu7qJ/tPXFCZBqJw6dOSp1CGtW9kDYO0WyXRN5xjSTaEzidutikm7WjpXAS8GN3fwLAzL4OnAWkBgVI/uDF3W872Sq7sT+D6GCx6NRj+eiND8WWL657Yd7rDuSBn/xij3POO/nIXF0SrW551GhP4GTqYpNuZl7yxsFmdg5wmrv/Ufj4/cDJ7v5nY553IXAhAH0TT9xr2gwAfGTn9h3Pb9pAhL1e+/oT4953+//8eG2e8vYdcOj0vn32m4YBDiO/fOn5ka0/fbp/2ow51jdxr7HP95Gd2wHifrZr+7atzb7emN/3YOBnAE2c063q16JMEybtf9DE/acdhdnu6W7uu3a++PxTu7a9uGfUL0dbrkVF6Vrsdqy779fMCe1oKUT1bewRmdx9GbAMwMzW/Oq5Hw0WXbBOYGZr3F3XAl2LRroWu+la7GZma5o9px0rmp8Fjmx4fASwuQ3lEBGRMdoRFL4PzDSzo81sL+C9wMo2lENERMYovfvI3Xea2Z8BdxBMSf1Xd0/bVHhZ8SXrGLoWu+la7KZrsZuuxW5NX4vSB5pFRKS6OjJLqoiIFENBQURE6iodFMzsNDN73Mx+bGaL212espnZv5rZFjN7pOHYQWZ2l5n9KPx6YDvLWAYzO9LM7jWzR81so5l9JDzei9diHzP7npmtD6/F5eHxo81sdXgtbgwncfQEM+szs3Vm9s3wcU9eCzPbZGYbzOyh2lTUPJ+RygaFhnQYbweOA84zs+PaW6rSfQU4bcyxxcDd7j4TuDt83O12An/h7m8A5gF/Gv4t9OK1+BVwirsfD8wFTjOzecCngavDa/EC8ME2lrFsHwEebXjcy9digbvPbVin0fRnpLJBgYZ0GO6+Hailw+gZ7n4/MHaF7FnA8vD75cDCUgvVBu7+nLv/IPz+JYIKYIDevBbu7i+HD/vDfw6cAtwSHu+JawFgZkcApwPXho+NHr0WMZr+jFQ5KAwAjbmmnw2P9bpD3f05CCpL4JA2l6dUZjYDOAFYTY9ei7C75CFgC3AX8BNg2N13hk/ppc/KPwAfA2q7br2G3r0WDtxpZmvDNEGQ4zNS5f0UMqXDkN5hZvsCtwIXu/uLNo5ssJ3M3UeAuWY2FfgG8Iaop5VbqvKZ2TuALe6+1szeUjsc8dSuvxah+e6+2cwOAe4ys8fyvEiVWwpKhxHtp2Z2GED4dUuby1MKM+snCAjXu/tt4eGevBY17j4M3EcwzjLVzGo3eb3yWZkPnGlmmwi6l08haDn04rXA3TeHX7cQ3CycRI7PSJWDgtJhRFsJXBB+fwFwexvLUoqwn/g64FF3/1zDj3rxWkwLWwiY2STgrQRjLPcC54RP64lr4e6XuvsR7j6DoH64x93PpwevhZlNMbP9at8Dvwc8Qo7PSKVXNJvZ7xNE/lo6jL9rc5FKZWY3AG8hSAX8U2AJsAK4CZgOPA28293bla65FGb2JuC/gA3s7jv+a4JxhV67Fm8kGDDsI7ipu8ndP25mryO4Wz4IWAe8z91/1b6SlivsPvpLd39HL16L8Hf+RvhwIvA1d/87M3sNTX5GKh0URESkXFXuPhIRkZIpKIiISJ2CgoiI1CkoiIhInYKCiIjUKShIJZjZW8zst8b5Gi+nP6t1zOw+Myt8g3gz+3CYIfb6ot9LpMppLqS3vAV4Gfhum8tRCjOb2JCfJ82fAG939yeLLJMIqKUgBTKzFWFyro0NCbpq+2T8INwT4O4wyd1FwEfDXPC/bWZfMbNzGs55Ofy6b3jOD8Lc8YmZc81sRniXfU1YjjvDlcCj7vTN7OAwXQJm9oGw7KvM7Ekz+zMzuyTM2f+gmR3U8BbvM7PvmtkjZnZSeP4UC/bC+H54zlkNr3uzma0C7owo6yXh6zxiZheHx/4FeB2w0sw+Oub5fWb22fA6PGxmfx4e/9vwvR8xs2XhivBai+OH4XO/nlLW2Rbs2/BQ+PyZif/Z0j3cXf/0r5B/wEHh10kES+5fA0wjyH579JjnLCVYkVo79yvAOQ2PXw6/TgT2D78/GPgxuxdhvhxRhhkE+zHMDR/fRLDCFYK8QYMNr7Up/P4D4evuF5Z3K3BR+LOrCRLy1c6/Jvz+zcAj4fefbHiPqcB/A1PC13229juPKeeJBCu2pwD7AhuBE8KfbQIOjjjnjwnyQU0ccy0PanjOvwNnhN9vBvaulSulrP8InB8e3wuY1O6/J/0r55+6j6RIHzazd4bfHwnMJKhk7/ewK8SbT0thwCfN7M0EKS8GgEOB/0k450l3fyj8fi1BoEhzrwd7N7xkZluBVeHxDcAbG553AwR7X5jZ/mFeot8jSNT2l+Fz9iFIMwBwV8zv/CbgG+7+CoCZ3Qb8NkGahjhvBf7Fw26ohtddYGYfAyYTpHrYGJb/YeB6M1tBkC6FhLL+P+B/W7BfwW3u/qOEckgXUVCQQoS5aN4K/Ka7v2pm9xFUOEa2VMY7Cbs3w+6P2paK5xMElhPdfUfY5bNPyms15r0ZIWi5jHqPiNdoPGdXw+NdjP7cjP1dnOB3fJe7P974AzM7GXglpox58oDvcS3NbB/gnwlaQM+Y2VJ2/26nE7RozgT+xsxmx5UVeNTMVofn3GFmf+Tu9+Qoo3QYjSlIUQ4AXggDwiyC9M4Q3IH+jpkdDcEesuHxlwi6a2o2EXSpQLB7VH/D624JA8IC4KhxlLHxPc5JeF6Sc6GetG+ru28F7gD+vKEv/4QMr3M/sNDMJluQ5fKdBEkAk9wJXGRhmujwWtYCwM8s2H/inPBnE4Aj3f1egk1pphJ0U0WW1YIEa0+4+xcIMm02to6kiykoSFG+A0w0s4eBTwAPArj788CFwG1mth64MXz+KuCdtYFm4BqC4PE9oPEO+3pg0IKNyc8Hcm0kEvos8Mdm9l2CMYU8XgjP/xd27wX8CYIg9rCZPRI+TuTBdqNfAb5HkP31WndP6jqCYAvKp8P3WQ/8gQd7LFxD0M21giAFPQRZVb9qZhsIuqSuDp8bV9ZzgUcs2OFtFvBvab+DdAdlSRURkTq1FEREpE5BQURE6hQURESkTkFBRETqFBRERKROQUFEROoUFEREpO7/A/lhLWnmI3ErAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f722408bf28>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(Y_test, Y_pred)\n",
    "plt.xlim(0, 50)\n",
    "plt.ylim(0, 50)\n",
    "plt.xlabel(\"actual number of cases\")\n",
    "plt.ylabel(\"Predicted dengue cases\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> From the graph we can see that this model isn't really good when there isn't even a slightly linear relationship between the actual and predicted values\n",
    " - let us try some feature selection to improve upon this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Recursive Feature Elimination"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.697064561092054"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.feature_selection import RFE\n",
    "\n",
    "# create a base classifier used to evaluate a subset of attributes\n",
    "model = LinearRegression()\n",
    "\n",
    "# create the RFE model and select n attributes\n",
    "rfe = RFE(model, 13)\n",
    "rfe = rfe.fit(X, y)\n",
    "X_Select = X.loc[:, rfe.support_]\n",
    "\n",
    "# Split based on the newly selected features and train and test again\n",
    "X_train, X_test, Y_train, Y_test = train_test_split(X_Select, y, shuffle = False)\n",
    "model.fit(X_train, Y_train)\n",
    "Y_pred = model.predict(X_test)\n",
    "\n",
    "mean_absolute_error(Y_test, Y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Eliminating some unnecessary features improves the accuracy, let us also try applying some regularization for further improvement!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### L1\n",
    "Linear Regression with L1 regularization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.198567106905848"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf = linear_model.Lasso(alpha=0.5)\n",
    "clf.fit(X_train, Y_train)\n",
    "Y_pred = clf.predict(X_test)\n",
    "mean_absolute_error(Y_test, Y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### L2\n",
    "Linear Regression with L2 regularization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.969390105082307"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf = linear_model.Ridge(alpha = 44)\n",
    "clf.fit(X_train, Y_train)\n",
    "Y_pred = clf.predict(X_test)\n",
    "mean_absolute_error(Y_test, Y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conclusions : \n",
    " - A simple linear model is only slightly better than a random model\n",
    " - Recursive feature elimination helps improve the accuracy\n",
    " - Regularization helps address the overfitting.\n",
    " \n",
    "#### Next Steps :\n",
    " - Trying advanced ensemble models like the XGBoost\n",
    " - Improving the train - test distributions"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}