Flight_price_prediction.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "import datetime\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split, KFold, GridSearchCV, RandomizedSearchCV, cross_val_score\n",
    "from sklearn.feature_selection import RFE\n",
    "\n",
    "from sklearn.linear_model import Ridge, LinearRegression, Lasso\n",
    "from sklearn.metrics import mean_squared_error, mean_squared_log_error, r2_score\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from xgboost import XGBRegressor\n",
    "import xgboost as xgb\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = pd.read_csv('train.csv')\n",
    "test = pd.read_csv('test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of training data: (8012, 11)\n",
      "Shape of testing data: (2671, 10)\n",
      "Airline            object\n",
      "Date_of_Journey    object\n",
      "Source             object\n",
      "Destination        object\n",
      "Route              object\n",
      "Dep_Time           object\n",
      "Arrival_Time       object\n",
      "Duration           object\n",
      "Total_Stops        object\n",
      "Additional_Info    object\n",
      "Price               int64\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "print('Shape of training data:',train.shape)\n",
    "print('Shape of testing data:',test.shape)\n",
    "print(train.dtypes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Airline            0\n",
       "Date_of_Journey    0\n",
       "Source             0\n",
       "Destination        0\n",
       "Route              1\n",
       "Dep_Time           0\n",
       "Arrival_Time       0\n",
       "Duration           0\n",
       "Total_Stops        1\n",
       "Additional_Info    0\n",
       "Price              0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check for missing Values\n",
    "train.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Drop null values\n",
    "train.dropna(inplace = True)\n",
    "train.reset_index(drop = True, inplace = True) # Order Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Airline</th>\n",
       "      <th>Date_of_Journey</th>\n",
       "      <th>Source</th>\n",
       "      <th>Destination</th>\n",
       "      <th>Route</th>\n",
       "      <th>Dep_Time</th>\n",
       "      <th>Arrival_Time</th>\n",
       "      <th>Duration</th>\n",
       "      <th>Total_Stops</th>\n",
       "      <th>Additional_Info</th>\n",
       "      <th>Price</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Airline C</td>\n",
       "      <td>12/06/2019</td>\n",
       "      <td>Delhi</td>\n",
       "      <td>Cochin</td>\n",
       "      <td>DEL → MAA → COK</td>\n",
       "      <td>20:40</td>\n",
       "      <td>09:25 13 Jun</td>\n",
       "      <td>12h 45m</td>\n",
       "      <td>1 stop</td>\n",
       "      <td>No info</td>\n",
       "      <td>7480</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Airline A</td>\n",
       "      <td>18/06/2019</td>\n",
       "      <td>Banglore</td>\n",
       "      <td>Delhi</td>\n",
       "      <td>BLR → DEL</td>\n",
       "      <td>18:55</td>\n",
       "      <td>22:00</td>\n",
       "      <td>3h 5m</td>\n",
       "      <td>non-stop</td>\n",
       "      <td>No info</td>\n",
       "      <td>8016</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Airline C</td>\n",
       "      <td>18/05/2019</td>\n",
       "      <td>Delhi</td>\n",
       "      <td>Cochin</td>\n",
       "      <td>DEL → BOM → COK</td>\n",
       "      <td>03:50</td>\n",
       "      <td>19:15</td>\n",
       "      <td>15h 25m</td>\n",
       "      <td>1 stop</td>\n",
       "      <td>No info</td>\n",
       "      <td>8879</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Airline A</td>\n",
       "      <td>6/05/2019</td>\n",
       "      <td>Kolkata</td>\n",
       "      <td>Banglore</td>\n",
       "      <td>CCU → BOM → BLR</td>\n",
       "      <td>20:00</td>\n",
       "      <td>08:15 07 May</td>\n",
       "      <td>12h 15m</td>\n",
       "      <td>1 stop</td>\n",
       "      <td>In-flight meal not included</td>\n",
       "      <td>9663</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Airline A</td>\n",
       "      <td>9/05/2019</td>\n",
       "      <td>Kolkata</td>\n",
       "      <td>Banglore</td>\n",
       "      <td>CCU → BOM → BLR</td>\n",
       "      <td>06:30</td>\n",
       "      <td>12:00</td>\n",
       "      <td>5h 30m</td>\n",
       "      <td>1 stop</td>\n",
       "      <td>In-flight meal not included</td>\n",
       "      <td>9663</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Airline E</td>\n",
       "      <td>27/06/2019</td>\n",
       "      <td>Banglore</td>\n",
       "      <td>Delhi</td>\n",
       "      <td>BLR → DEL</td>\n",
       "      <td>05:55</td>\n",
       "      <td>08:35</td>\n",
       "      <td>2h 40m</td>\n",
       "      <td>non-stop</td>\n",
       "      <td>No info</td>\n",
       "      <td>3625</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Airline A</td>\n",
       "      <td>3/06/2019</td>\n",
       "      <td>Delhi</td>\n",
       "      <td>Cochin</td>\n",
       "      <td>DEL → NAG → BOM → COK</td>\n",
       "      <td>14:35</td>\n",
       "      <td>12:35 04 Jun</td>\n",
       "      <td>22h</td>\n",
       "      <td>2 stops</td>\n",
       "      <td>In-flight meal not included</td>\n",
       "      <td>10919</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Airline C</td>\n",
       "      <td>24/06/2019</td>\n",
       "      <td>Kolkata</td>\n",
       "      <td>Banglore</td>\n",
       "      <td>CCU → BLR</td>\n",
       "      <td>14:15</td>\n",
       "      <td>16:45</td>\n",
       "      <td>2h 30m</td>\n",
       "      <td>non-stop</td>\n",
       "      <td>No info</td>\n",
       "      <td>5510</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Airline A</td>\n",
       "      <td>12/06/2019</td>\n",
       "      <td>Delhi</td>\n",
       "      <td>Cochin</td>\n",
       "      <td>DEL → BHO → BOM → COK</td>\n",
       "      <td>05:30</td>\n",
       "      <td>12:35</td>\n",
       "      <td>7h 5m</td>\n",
       "      <td>2 stops</td>\n",
       "      <td>No info</td>\n",
       "      <td>14441</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Airline G</td>\n",
       "      <td>9/06/2019</td>\n",
       "      <td>Delhi</td>\n",
       "      <td>Cochin</td>\n",
       "      <td>DEL → BLR → COK</td>\n",
       "      <td>16:45</td>\n",
       "      <td>22:25</td>\n",
       "      <td>5h 40m</td>\n",
       "      <td>1 stop</td>\n",
       "      <td>No info</td>\n",
       "      <td>13470</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Airline Date_of_Journey    Source Destination                  Route  \\\n",
       "0  Airline C      12/06/2019     Delhi      Cochin        DEL → MAA → COK   \n",
       "1  Airline A      18/06/2019  Banglore       Delhi              BLR → DEL   \n",
       "2  Airline C      18/05/2019     Delhi      Cochin        DEL → BOM → COK   \n",
       "3  Airline A       6/05/2019   Kolkata    Banglore        CCU → BOM → BLR   \n",
       "4  Airline A       9/05/2019   Kolkata    Banglore        CCU → BOM → BLR   \n",
       "5  Airline E      27/06/2019  Banglore       Delhi              BLR → DEL   \n",
       "6  Airline A       3/06/2019     Delhi      Cochin  DEL → NAG → BOM → COK   \n",
       "7  Airline C      24/06/2019   Kolkata    Banglore              CCU → BLR   \n",
       "8  Airline A      12/06/2019     Delhi      Cochin  DEL → BHO → BOM → COK   \n",
       "9  Airline G       9/06/2019     Delhi      Cochin        DEL → BLR → COK   \n",
       "\n",
       "  Dep_Time  Arrival_Time Duration Total_Stops              Additional_Info  \\\n",
       "0    20:40  09:25 13 Jun  12h 45m      1 stop                      No info   \n",
       "1    18:55         22:00    3h 5m    non-stop                      No info   \n",
       "2    03:50         19:15  15h 25m      1 stop                      No info   \n",
       "3    20:00  08:15 07 May  12h 15m      1 stop  In-flight meal not included   \n",
       "4    06:30         12:00   5h 30m      1 stop  In-flight meal not included   \n",
       "5    05:55         08:35   2h 40m    non-stop                      No info   \n",
       "6    14:35  12:35 04 Jun      22h     2 stops  In-flight meal not included   \n",
       "7    14:15         16:45   2h 30m    non-stop                      No info   \n",
       "8    05:30         12:35    7h 5m     2 stops                      No info   \n",
       "9    16:45         22:25   5h 40m      1 stop                      No info   \n",
       "\n",
       "   Price  \n",
       "0   7480  \n",
       "1   8016  \n",
       "2   8879  \n",
       "3   9663  \n",
       "4   9663  \n",
       "5   3625  \n",
       "6  10919  \n",
       "7   5510  \n",
       "8  14441  \n",
       "9  13470  "
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract Journey month & day from 'Date_of_journey'\n",
    "def doj(df):\n",
    "    df['journey_month'] = pd.to_datetime(df['Date_of_Journey']).dt.month\n",
    "    df['journey_day'] = pd.to_datetime(df['Date_of_Journey']).dt.day\n",
    "    df.drop('Date_of_Journey',axis = 1, inplace = True)\n",
    "    return df\n",
    "\n",
    "train = doj(train)\n",
    "test = doj(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Clean number of stops\n",
    "def correct_stops(df):\n",
    "    for i in range(df.shape[0]):\n",
    "        if df.Total_Stops[i][0] == 'n': # check for 'non stop'\n",
    "            df.Total_Stops[i] = 0\n",
    "        else:\n",
    "            df.Total_Stops[i] = df.Total_Stops[i][0]\n",
    "    return df\n",
    "\n",
    "train = correct_stops(train)\n",
    "test = correct_stops(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract departure time\n",
    "def dep_time(df):\n",
    "    df['dep_hour'] = pd.to_datetime(df['Dep_Time']).dt.hour\n",
    "    df['dep_min'] = pd.to_datetime(df['Dep_Time']).dt.minute\n",
    "    df.drop('Dep_Time', axis = 1, inplace = True)\n",
    "    return df\n",
    "\n",
    "train = dep_time(train)\n",
    "test = dep_time(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract arrival time\n",
    "def arr_time(df):\n",
    "    df['arr_hour'] = pd.to_datetime(df['Arrival_Time']).dt.hour\n",
    "    df['arr_min'] = pd.to_datetime(df['Arrival_Time']).dt.minute\n",
    "    return df\n",
    "\n",
    "train = arr_time(train)\n",
    "test = arr_time(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert durration of fligth\n",
    "def duration(df):\n",
    "    df['dur_hour'] = 0\n",
    "    df['dur_min'] = 0\n",
    "    for i in range(df.shape[0]):\n",
    "        if len(df['Duration'][i].split()) == 1:\n",
    "            if 'h' in df['Duration'][i]:\n",
    "                df['dur_hour'][i] = df['Duration'][i][:-1]\n",
    "            else:\n",
    "                df['dur_min'][i] = df['Duration'][i][:-1]\n",
    "        else:\n",
    "            df['dur_hour'][i] = df['Duration'][i].split()[0][:-1]\n",
    "            df['dur_min'][i] = df['Duration'][i].split()[1][:-1]\n",
    "\n",
    "    df.drop('Duration', axis = 1, inplace = True)\n",
    "    return df\n",
    "train = duration(train)\n",
    "test = duration(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract arrival day/month\n",
    "def arr_day(df):\n",
    "    df['arr_month'] = pd.to_datetime(df['Arrival_Time']).dt.month\n",
    "    df['arr_day'] = pd.to_datetime(df['Arrival_Time']).dt.day\n",
    "    for i in range(df.shape[0]):\n",
    "        if len(df['Arrival_Time'][i].split()) < 3:\n",
    "            df['arr_month'][i] = df['journey_month'][i]\n",
    "            df['arr_day'][i] = df['journey_day'][i]\n",
    "\n",
    "    df.drop('Arrival_Time', axis = 1, inplace = True)\n",
    "    return df\n",
    "train = arr_day(train)\n",
    "test = arr_day(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find & store the intermediate airports in 3 separate column (as max no. of intermediate airports = 3)\n",
    "def intermediate_airports(df):\n",
    "    df.Route = df.Route.apply(lambda x: x.split(' → '))\n",
    "    df['int_1'] = 'na'\n",
    "    df['int_2'] = 'na'\n",
    "    df['int_3'] = 'na'\n",
    "    for i in range(df.shape[0]):\n",
    "        if len(df.Route[i]) == 3:\n",
    "            df['int_1'][i] = df.Route[i][1]\n",
    "        elif len(df.Route[i]) == 4:\n",
    "            df['int_1'][i] = df.Route[i][1]\n",
    "            df['int_2'][i] = df.Route[i][2]\n",
    "        elif len(df.Route[i]) == 5:\n",
    "            df['int_1'][i] = df.Route[i][1]\n",
    "            df['int_2'][i] = df.Route[i][2]\n",
    "            df['int_3'][i] = df.Route[i][3]\n",
    "    df.drop('Route', axis = 1, inplace = True)\n",
    "    return df\n",
    "train = intermediate_airports(train)\n",
    "test = intermediate_airports(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [],
   "source": [
    "# One-hot encoding, combining train & test as Source, Destination & Additional_Info have some non common values.\n",
    "to_encode = ['Airline','Source','Destination','Additional_Info']\n",
    "comb = train.append(test, ignore_index=True)\n",
    "for i in to_encode:\n",
    "    if i == 'Additional_Info':\n",
    "        x_t = pd.get_dummies(comb[i])\n",
    "        x_t = x_t.drop(['No info','No Info'], axis = 1)\n",
    "    else:\n",
    "        x_t = pd.get_dummies(comb[i], prefix=i, prefix_sep='_')\n",
    "    comb = comb.join(x_t)\n",
    "    comb.drop(i, axis = 1, inplace = True)\n",
    "    \n",
    "# Find all airports & save in all_airports\n",
    "all_airports = []\n",
    "for i in range(comb.shape[0]):\n",
    "    if comb.int_1[i] not in all_airports:\n",
    "        all_airports.append(comb.int_1[i])\n",
    "    if comb.int_2[i] not in all_airports:\n",
    "        all_airports.append(comb.int_2[i])\n",
    "    if comb.int_3[i] not in all_airports:\n",
    "        all_airports.append(comb.int_3[i])\n",
    "\n",
    "# convert all airports into features in a separate dataframe df2\n",
    "df2 = pd.DataFrame(columns = all_airports)\n",
    "for i in range(comb.shape[0]):\n",
    "    df2 = df2.append(pd.Series(0, index=df2.columns), ignore_index=True) #appending zeros in entire df2\n",
    "\n",
    "# set 1 if intermediate airport is their in a particular flight   \n",
    "for i in range(comb.shape[0]):\n",
    "    if comb.int_1[i] != 'na':\n",
    "        df2[comb.int_1[i]][i] = 1\n",
    "    if comb.int_2[i] != 'na':\n",
    "        df2[comb.int_2[i]][i] = 1\n",
    "    if comb.int_3[i] != 'na':\n",
    "        df2[comb.int_3[i]][i] = 1\n",
    "\n",
    "# Remove 'na' column which was assigned in case of absence of intermediate airport 1,2 or 3.\n",
    "df2.drop('na', axis = 1, inplace = True)\n",
    "\n",
    "# join intermediate airport df to comb(train + test)\n",
    "comb = comb.join(df2)\n",
    "\n",
    "# drop int_1,int_2,int_3\n",
    "comb.drop(['int_1','int_2','int_3'], axis = 1, inplace = True)\n",
    "\n",
    "# separate train & test\n",
    "train = comb.iloc[:train.shape[0],:]\n",
    "test = comb.iloc[train.shape[0]:,:]\n",
    "test.drop('Price',axis = 1, inplace = True) # remove null price column create in test due to combining with train df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Total_Stops    0.314911\n",
       "Price          1.931190\n",
       "dtype: float64"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check skewness \n",
    "train.iloc[:,:2].skew()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Skewness of Price after log transform:  -0.2454134795049426\n"
     ]
    }
   ],
   "source": [
    "# Treat Skewness of Flight price\n",
    "train.Price = train.Price.apply(lambda x : np.log1p(x))\n",
    "print('Skewness of Price after log transform: ',train.Price.skew())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9688 between  arr_day    &    journey_day  \n",
      "0.9688 between  journey_day    &    arr_day  \n",
      "1.0 between  Destination_Kolkata    &    Source_Chennai  \n",
      "1.0 between  Destination_Cochin    &    Source_Delhi  \n",
      "1.0 between  Destination_Banglore    &    Source_Kolkata  \n",
      "1.0 between  Destination_Hyderabad    &    Source_Mumbai  \n",
      "1.0 between  Source_Kolkata    &    Destination_Banglore  \n",
      "1.0 between  Source_Delhi    &    Destination_Cochin  \n",
      "1.0 between  Source_Mumbai    &    Destination_Hyderabad  \n",
      "1.0 between  Source_Chennai    &    Destination_Kolkata  \n"
     ]
    }
   ],
   "source": [
    "# Find correlated Features\n",
    "correl = train.corr()\n",
    "for i in range(correl.shape[0]):\n",
    "    for j in range(correl.shape[1]):\n",
    "        if (abs(correl.iloc[i,j]) > 0.8) & ( i != j):\n",
    "            print(round(correl.iloc[i,j], 4), 'between ',correl.columns[j], '   &   ', correl.index[i], ' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of Features =  85\n",
      "Index(['Total_Stops', 'Price', 'journey_month', 'journey_day', 'dep_hour',\n",
      "       'dep_min', 'arr_hour', 'arr_min', 'dur_hour', 'dur_min', 'arr_month',\n",
      "       'arr_day', 'Airline_Airline A', 'Airline_Airline B',\n",
      "       'Airline_Airline C', 'Airline_Airline D', 'Airline_Airline E',\n",
      "       'Airline_Airline F', 'Airline_Airline G', 'Airline_Airline H',\n",
      "       'Airline_Airline I', 'Airline_Airline J', 'Airline_Airline K',\n",
      "       'Airline_Airline L', 'Source_Banglore', 'Source_Chennai',\n",
      "       'Source_Delhi', 'Source_Kolkata', 'Source_Mumbai',\n",
      "       'Destination_Banglore', 'Destination_Cochin', 'Destination_Delhi',\n",
      "       'Destination_Hyderabad', 'Destination_Kolkata', 'Destination_New Delhi',\n",
      "       '1 Long layover', '1 Short layover', '2 Long layover', 'Business class',\n",
      "       'Change airports', 'In-flight meal not included',\n",
      "       'No check-in baggage included', 'Red-eye flight', 'MAA', 'BOM', 'NAG',\n",
      "       'BHO', 'BLR', 'HYD', 'BDQ', 'DEL', 'JAI', 'IXC', 'COK', 'ATQ', 'IXR',\n",
      "       'IDR', 'LKO', 'AMD', 'BBI', 'CCU', 'GOI', 'GAU', 'PNQ', 'JDH', 'VNS',\n",
      "       'UDR', 'IXU', 'TRV', 'VGA', 'KNU', 'IMF', 'IXB', 'ISK', 'DED', 'RPR',\n",
      "       'IXZ', 'STV', 'GWL', 'VTZ', 'JLR', 'PAT', 'NDC', 'HBX', 'IXA'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "print('Total number of Features = ', len(train.columns))\n",
    "print(train.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split data into Feature & target\n",
    "X = train.drop('Price', axis =1)\n",
    "y = train['Price'].copy()\n",
    "\n",
    "# Feature Scaling\n",
    "def scaling(df):\n",
    "    ss = StandardScaler()\n",
    "    df = ss.fit_transform(df)\n",
    "    return df\n",
    "    \n",
    "X = scaling(X)\n",
    "test = scaling(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make scorer for RMSLE\n",
    "def rmsle(ytruez,ypredz):\n",
    "    error = np.sqrt(mean_squared_log_error(ytruez, ypredz))\n",
    "    return error\n",
    "from sklearn.metrics import make_scorer\n",
    "my_func = make_scorer(rmsle, greater_is_better=False)\n",
    "\n",
    "# RMSLE scorer 2 (returns error when the price is at original scale(convert price back to original scale))\n",
    "def rmsle2(ytruez,ypredz):\n",
    "    error = np.sqrt(mean_squared_log_error(np.expm1(ytruez), np.expm1(ypredz)))\n",
    "    return error\n",
    "from sklearn.metrics import make_scorer\n",
    "my_func2 = make_scorer(rmsle2, greater_is_better=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSLE Errors for log1p(price)\n",
      "For ElasticNet : 0.023337094131008772\n",
      "For RandomForestRegressor : 0.012452454411450042\n",
      "For XGBoost : 0.012076805277496449\n"
     ]
    }
   ],
   "source": [
    "# k-fold cross validation for Ridge, RandomForestRegressor & XGBoost.\n",
    "ri_cv = Ridge(max_iter = 1500)\n",
    "rf_cv = RandomForestRegressor(n_jobs = 4)\n",
    "xgb_cv = XGBRegressor()\n",
    "\n",
    "print('RMSLE Errors for log1p(price)')\n",
    "cv_en = cross_val_score(ri_cv, X, y, cv = 8, scoring = my_func).mean()\n",
    "print('For ElasticNet :', -1 *cv_en)\n",
    "\n",
    "cv_rf = cross_val_score(rf_cv, X, y, cv = 8, scoring = my_func).mean()\n",
    "print('For RandomForestRegressor :', -1 *cv_rf)\n",
    "\n",
    "cv_xgb = cross_val_score(xgb_cv, X, y, cv = 8, scoring = my_func).mean()\n",
    "print('For XGBoost :', -1 *cv_xgb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split Data\n",
    "xtrain,xtest,ytrain,ytest = train_test_split(X,y,test_size = 0.2,random_state = 14) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting estimator with 84 features.\n",
      "Fitting estimator with 83 features.\n",
      "Fitting estimator with 82 features.\n",
      "Fitting estimator with 81 features.\n",
      "Fitting estimator with 80 features.\n",
      "Fitting estimator with 79 features.\n",
      "Fitting estimator with 78 features.\n",
      "Fitting estimator with 77 features.\n",
      "Fitting estimator with 76 features.\n",
      "Fitting estimator with 75 features.\n",
      "Fitting estimator with 74 features.\n",
      "Fitting estimator with 73 features.\n",
      "Fitting estimator with 72 features.\n",
      "Fitting estimator with 71 features.\n",
      "Fitting estimator with 70 features.\n",
      "Fitting estimator with 69 features.\n",
      "Fitting estimator with 68 features.\n",
      "Fitting estimator with 67 features.\n",
      "Fitting estimator with 66 features.\n",
      "Fitting estimator with 65 features.\n",
      "Fitting estimator with 64 features.\n",
      "Fitting estimator with 63 features.\n",
      "Fitting estimator with 62 features.\n",
      "Fitting estimator with 61 features.\n",
      "Fitting estimator with 60 features.\n",
      "Fitting estimator with 59 features.\n",
      "Fitting estimator with 58 features.\n",
      "Fitting estimator with 57 features.\n",
      "Fitting estimator with 56 features.\n",
      "Fitting estimator with 55 features.\n",
      "Fitting estimator with 54 features.\n",
      "Fitting estimator with 53 features.\n",
      "Fitting estimator with 52 features.\n",
      "Fitting estimator with 51 features.\n",
      "Fitting estimator with 50 features.\n",
      "Fitting estimator with 49 features.\n",
      "Fitting estimator with 48 features.\n",
      "Fitting estimator with 47 features.\n",
      "Fitting estimator with 46 features.\n",
      "Fitting estimator with 45 features.\n",
      "Fitting estimator with 44 features.\n",
      "Fitting estimator with 43 features.\n",
      "Number of selected Features by RFE =  42 out of 84 features.\n"
     ]
    }
   ],
   "source": [
    "# Feature Elimination using rfe with RandomForestEstimator\n",
    "rf=RandomForestRegressor()\n",
    "rfe = RFE(estimator = rf, step = 1, verbose =2)\n",
    "rfe.fit(X,y)\n",
    "\n",
    "selected_fs = pd.DataFrame({'features': train.drop('Price', axis = 1).columns,\n",
    "                           'ranks': rfe.ranking_})\n",
    "selected_fs = selected_fs.sort_values(by = 'ranks')\n",
    "\n",
    "# Convert data to use only selected features\n",
    "xtrain_rfe = rfe.transform(xtrain)\n",
    "X = rfe.transform(X)\n",
    "xtest_rfe = rfe.transform(xtest)\n",
    "test_rfe = rfe.transform(test)\n",
    "\n",
    "print('Number of selected Features by RFE = ', selected_fs[selected_fs['ranks'] == 1].shape[0], 'out of 84 features.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r2_  score:  0.705\n",
      "test RMSE:  2630.563\n",
      "test RMSLE:  0.24518177403098657\n"
     ]
    }
   ],
   "source": [
    "#Ridge\n",
    "en = Ridge()\n",
    "ypred_en = en.fit(xtrain_rfe,ytrain).predict(xtest_rfe)\n",
    "\n",
    "# Convert actual & predicted price to original scale\n",
    "y_true_scale = []\n",
    "pred_true_scale = []\n",
    "for i in range(len(ytest)):\n",
    "    y_true_scale.append((np.expm1(ytest.iloc[i])))\n",
    "    pred_true_scale.append((np.expm1(ypred_en[i])))\n",
    "    \n",
    "en_rmse = np.sqrt(mean_squared_error(y_true_scale, pred_true_scale))\n",
    "print('r2_  score: ', round(r2_score(y_true_scale, pred_true_scale),3))\n",
    "print('test RMSE: ', round(en_rmse,3))\n",
    "print('test RMSLE: ', rmsle(y_true_scale, pred_true_scale))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train r2_score:  0.947 test r2_score:  0.929 \n",
      "\n",
      "train RMSLE:  0.06 test RMSLE:  0.12\n",
      "train rmse:  1084.31 test rmse:  1291.43\n"
     ]
    }
   ],
   "source": [
    "# RandomForestRegressor\n",
    "rf=RandomForestRegressor(n_jobs = 4,random_state = 28)\n",
    "ypred_rf = rf.fit(xtrain_rfe,ytrain).predict(xtest_rfe)\n",
    "ypred_rf_train = rf.fit(xtrain_rfe,ytrain).predict(xtrain_rfe)\n",
    "\n",
    "# Convert actual & predicted price to original scale\n",
    "y_true_scale_train = []\n",
    "y_true_scale = []\n",
    "pred_true_scale = []\n",
    "pred_true_scale_train = []\n",
    "for i in range(len(ytest)):\n",
    "    y_true_scale.append((np.expm1(ytest.iloc[i])))\n",
    "    y_true_scale_train.append((np.expm1(ytrain.iloc[i])))\n",
    "    pred_true_scale.append((np.expm1(ypred_rf[i])))\n",
    "    pred_true_scale_train.append((np.expm1(ypred_rf_train[i])))\n",
    "    \n",
    "print('train r2_score: ',round(r2_score(y_true_scale_train,pred_true_scale_train),3),'test r2_score: ',round(r2_score(y_true_scale, pred_true_scale),3),'\\n')\n",
    "print('train RMSLE: ',round(rmsle(y_true_scale_train,pred_true_scale_train),2),'test RMSLE: ', round(rmsle(y_true_scale, pred_true_scale),2))\n",
    "print('train rmse: ',round(np.sqrt(mean_squared_error(y_true_scale_train, pred_true_scale_train)),2),'test rmse: ',round(np.sqrt(mean_squared_error(y_true_scale,pred_true_scale)),2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   24.8s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best params after Tuning :  {'bootstrap': True, 'max_depth': 20, 'max_features': 'auto', 'min_samples_leaf': 2, 'min_samples_split': 6, 'n_estimators': 190}\n",
      "Best Gridsearch score =   -0.12803597144160708 \n",
      "\n",
      "Gridsearchcv mean score while Training :  [-0.08054481]\n",
      "Gridsearchcv mean score while Testing :  [-0.12803597]\n"
     ]
    }
   ],
   "source": [
    "# RandomForest Hyper-Parameter Tuning\n",
    "gridrf = {\n",
    "    'max_depth' : [20],\n",
    "    'n_estimators' : [190],\n",
    "    'max_features' : ['auto'],\n",
    "    'min_samples_split':[6],\n",
    "    'min_samples_leaf' : [2],\n",
    "    'bootstrap' : [True]\n",
    "}\n",
    "gsrf = GridSearchCV(RandomForestRegressor(),gridrf,n_jobs=-1,verbose=2,scoring=my_func2, return_train_score=True)\n",
    "gsrf.fit(X,y)\n",
    "\n",
    "print('Best params after Tuning : ',gsrf.best_params_)\n",
    "print('Best Gridsearch score =  ',gsrf.best_score_, '\\n')\n",
    "print('Gridsearchcv mean score while Training : ',gsrf.cv_results_['mean_train_score'])\n",
    "print('Gridsearchcv mean score while Testing : ',gsrf.cv_results_['mean_test_score'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train r2_score:  0.954 test r2_score:  0.917 \n",
      "\n",
      "train RMSLE:  0.08 test RMSLE:  0.12\n",
      "train RMSE:  1015.06 test RMSE:  1397.82\n"
     ]
    }
   ],
   "source": [
    "# XGBoost\n",
    "xgb = XGBRegressor()\n",
    "ypred_xgb = xgb.fit(xtrain_rfe,ytrain).predict(xtest_rfe)\n",
    "ypred_xgb_train = xgb.fit(xtrain_rfe,ytrain).predict(xtrain_rfe)\n",
    "\n",
    "# Convert to Original scale\n",
    "y_true_scale_train = []\n",
    "y_true_scale = []\n",
    "pred_true_scale = []\n",
    "pred_true_scale_train = []\n",
    "for i in range(len(ytest)):\n",
    "    y_true_scale.append((np.expm1(ytest.iloc[i])))\n",
    "    y_true_scale_train.append((np.expm1(ytrain.iloc[i])))\n",
    "    pred_true_scale.append((np.expm1(ypred_xgb[i])))\n",
    "    pred_true_scale_train.append((np.expm1(ypred_xgb_train[i])))\n",
    "    \n",
    "print('train r2_score: ', round(r2_score(y_true_scale_train, pred_true_scale_train),3),'test r2_score: ', round(r2_score(y_true_scale, pred_true_scale),3), '\\n')\n",
    "print('train RMSLE: ', round(rmsle(y_true_scale_train, pred_true_scale_train),2),'test RMSLE: ', round(rmsle(y_true_scale, pred_true_scale),2))\n",
    "print('train RMSE: ', round(np.sqrt(mean_squared_error(y_true_scale_train, pred_true_scale_train)),2),'test RMSE: ', round(np.sqrt(mean_squared_error(y_true_scale, pred_true_scale)),2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:  2.9min finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train r2_score:  0.979 test r2_score:  0.92 \n",
      "\n",
      "train RMSLE:  0.06 test RMSLE:  0.11\n",
      "train RMSE:  692.74 test RMSE:  1369.5\n"
     ]
    }
   ],
   "source": [
    "# XGBoost Hyper-parameter Tuning\n",
    "grid = {\n",
    "    'max_depth' : [6],'min_child_weight' : [2],\n",
    "    'n_estimators' : [6000],\n",
    "    'gamma' : [0],\n",
    "    'subsample':[1],'colsample_bytree':[0.65],\n",
    "    'reg_alpha':[0.1],\n",
    "    'learning_rate' : [0.01]\n",
    "}\n",
    "gs1 = GridSearchCV(XGBRegressor(), grid, n_jobs=-1, verbose=2,scoring=my_func) #'neg_mean_squared_error'\n",
    "gs1.fit(xtrain_rfe,ytrain)\n",
    "ypred = gs1.predict(xtest_rfe)\n",
    "ypred_train = gs1.predict(xtrain_rfe)\n",
    "\n",
    "# Convert to Original scale\n",
    "y_true_scale = []\n",
    "y_true_scale_train = []\n",
    "pred_true_scale = []\n",
    "pred_true_scale_train = []\n",
    "for i in range(len(ytest)):\n",
    "    y_true_scale.append((np.expm1(ytest.iloc[i])))\n",
    "    y_true_scale_train.append((np.expm1(ytrain.iloc[i])))\n",
    "    pred_true_scale.append((np.expm1(ypred[i])))\n",
    "    pred_true_scale_train.append((np.expm1(ypred_train[i])))\n",
    "    \n",
    "print('train r2_score: ', round(r2_score(y_true_scale_train, pred_true_scale_train),3),'test r2_score: ', round(r2_score(y_true_scale, pred_true_scale),3), '\\n')\n",
    "print('train RMSLE: ', round(rmsle(y_true_scale_train, pred_true_scale_train),2),'test RMSLE: ', round(rmsle(y_true_scale, pred_true_scale),2))\n",
    "print('train RMSE: ', round(np.sqrt(mean_squared_error(y_true_scale_train, pred_true_scale_train)),2),'test RMSE: ', round(np.sqrt(mean_squared_error(y_true_scale, pred_true_scale)),2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'colsample_bytree': 0.65, 'gamma': 0, 'learning_rate': 0.01, 'max_depth': 6, 'min_child_weight': 2, 'n_estimators': 6000, 'reg_alpha': 0.1, 'subsample': 1}\n",
      "-0.012179149308937152\n"
     ]
    }
   ],
   "source": [
    "print(gs1.best_params_)\n",
    "print(gs1.best_score_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "g_xgb = pd.DataFrame({'actual' : np.expm1(ytest),'predicted': np.expm1(gs1.predict(xtest_rfe))})\n",
    "g_xgb = g_xgb.sort_values(by=\"actual\").reset_index()\n",
    "plt.figure(figsize = (20,5))\n",
    "plt.plot(g_xgb['predicted'])\n",
    "plt.plot(g_xgb['actual'], color = 'red')\n",
    "plt.legend(['Predicted','Actual'],fontsize = 20)\n",
    "plt.title('XGBoost Hyper-parameter Tuned Model', fontsize = 20)\n",
    "plt.ylabel('Price', fontsize = 20)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   15.1s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For metamodel, cvs : -0.0113\n"
     ]
    }
   ],
   "source": [
    "# stacking\n",
    "m1 = rf.predict(xtest_rfe)\n",
    "m2 = xgb.predict(xtest_rfe)\n",
    "m3 = gsrf.fit(xtrain_rfe, ytrain).predict(xtest_rfe)\n",
    "m4 = gs1.predict(xtest_rfe)\n",
    "\n",
    "# Create df of individual model predictoins\n",
    "meta_df1 = pd.DataFrame(data = {'m1':m1,'m2':m2,'m3':m3,'m4':m4})\n",
    "\n",
    "# using Ridge as meta model\n",
    "meta_model = Ridge()   \n",
    "meta_model.fit(meta_df1,ytest)  # Fit ridge with the predictions of individual models\n",
    "\n",
    "# Use Cross validation to check model performance\n",
    "metacv1 = cross_val_score(meta_model, meta_df1, ytest, cv = 8, scoring = my_func).mean()\n",
    "print('For metamodel, cvs :', round(metacv1,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# meta model pred on test data\n",
    "m11 = rf.predict(test_rfe)\n",
    "m22 = xgb.predict(test_rfe)\n",
    "m33 = gsrf.predict(test_rfe)\n",
    "m44 = gs1.predict(test_rfe)\n",
    "\n",
    "meta_df2 = pd.DataFrame(data = {'m11':m11,'m2':m22,'m3':m33,'m4':m44})\n",
    "meta_model_prediction = meta_model.predict(meta_df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converting Predicted price to true scale\n",
    "sub1 = []\n",
    "for i in range(len(meta_model_prediction)):\n",
    "    sub1.append((np.expm1(meta_model_prediction[i])))\n",
    "    \n",
    "# Create df & export\n",
    "subm = pd.DataFrame({'Price':sub1})\n",
    "#subm.to_csv('sub.csv', index = False)"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}