Predict Restaurant Food Cost.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = pd.read_excel('Data_Train.xlsx')\n",
    "test = pd.read_excel('Data_Test.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((12690, 9), (4231, 8))"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.shape, test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data exploration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25, 1)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check for duplicate records... didn't remove the duplicate records as it was bringing score down\n",
    "train.duplicated().sum(), test.duplicated().sum()\n",
    "#train.drop_duplicates(keep='first', inplace=True)\n",
    "#train.reset_index(inplace=True)\n",
    "#test.drop_duplicates(keep='first', inplace=True)\n",
    "#test.reset_index(inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>TITLE</th>\n",
       "      <th>RESTAURANT_ID</th>\n",
       "      <th>CUISINES</th>\n",
       "      <th>TIME</th>\n",
       "      <th>CITY</th>\n",
       "      <th>LOCALITY</th>\n",
       "      <th>RATING</th>\n",
       "      <th>VOTES</th>\n",
       "      <th>COST</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CASUAL DINING</td>\n",
       "      <td>9438</td>\n",
       "      <td>Malwani, Goan, North Indian</td>\n",
       "      <td>11am – 4pm, 7:30pm – 11:30pm (Mon-Sun)</td>\n",
       "      <td>Thane</td>\n",
       "      <td>Dombivali East</td>\n",
       "      <td>3.6</td>\n",
       "      <td>49 votes</td>\n",
       "      <td>1200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CASUAL DINING,BAR</td>\n",
       "      <td>13198</td>\n",
       "      <td>Asian, Modern Indian, Japanese</td>\n",
       "      <td>6pm – 11pm (Mon-Sun)</td>\n",
       "      <td>Chennai</td>\n",
       "      <td>Ramapuram</td>\n",
       "      <td>4.2</td>\n",
       "      <td>30 votes</td>\n",
       "      <td>1500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>CASUAL DINING</td>\n",
       "      <td>10915</td>\n",
       "      <td>North Indian, Chinese, Biryani, Hyderabadi</td>\n",
       "      <td>11am – 3:30pm, 7pm – 11pm (Mon-Sun)</td>\n",
       "      <td>Chennai</td>\n",
       "      <td>Saligramam</td>\n",
       "      <td>3.8</td>\n",
       "      <td>221 votes</td>\n",
       "      <td>800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>QUICK BITES</td>\n",
       "      <td>6346</td>\n",
       "      <td>Tibetan, Chinese</td>\n",
       "      <td>11:30am – 1am (Mon-Sun)</td>\n",
       "      <td>Mumbai</td>\n",
       "      <td>Bandra West</td>\n",
       "      <td>4.1</td>\n",
       "      <td>24 votes</td>\n",
       "      <td>800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>DESSERT PARLOR</td>\n",
       "      <td>15387</td>\n",
       "      <td>Desserts</td>\n",
       "      <td>11am – 1am (Mon-Sun)</td>\n",
       "      <td>Mumbai</td>\n",
       "      <td>Lower Parel</td>\n",
       "      <td>3.8</td>\n",
       "      <td>165 votes</td>\n",
       "      <td>300</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               TITLE  RESTAURANT_ID  \\\n",
       "0      CASUAL DINING           9438   \n",
       "1  CASUAL DINING,BAR          13198   \n",
       "2      CASUAL DINING          10915   \n",
       "3        QUICK BITES           6346   \n",
       "4     DESSERT PARLOR          15387   \n",
       "\n",
       "                                     CUISINES  \\\n",
       "0                 Malwani, Goan, North Indian   \n",
       "1              Asian, Modern Indian, Japanese   \n",
       "2  North Indian, Chinese, Biryani, Hyderabadi   \n",
       "3                            Tibetan, Chinese   \n",
       "4                                    Desserts   \n",
       "\n",
       "                                     TIME     CITY        LOCALITY RATING  \\\n",
       "0  11am – 4pm, 7:30pm – 11:30pm (Mon-Sun)    Thane  Dombivali East    3.6   \n",
       "1                    6pm – 11pm (Mon-Sun)  Chennai       Ramapuram    4.2   \n",
       "2     11am – 3:30pm, 7pm – 11pm (Mon-Sun)  Chennai      Saligramam    3.8   \n",
       "3                 11:30am – 1am (Mon-Sun)   Mumbai     Bandra West    4.1   \n",
       "4                    11am – 1am (Mon-Sun)   Mumbai     Lower Parel    3.8   \n",
       "\n",
       "       VOTES  COST  \n",
       "0   49 votes  1200  \n",
       "1   30 votes  1500  \n",
       "2  221 votes   800  \n",
       "3   24 votes   800  \n",
       "4  165 votes   300  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 12690 entries, 0 to 12689\n",
      "Data columns (total 9 columns):\n",
      "TITLE            12690 non-null object\n",
      "RESTAURANT_ID    12690 non-null int64\n",
      "CUISINES         12690 non-null object\n",
      "TIME             12690 non-null object\n",
      "CITY             12578 non-null object\n",
      "LOCALITY         12592 non-null object\n",
      "RATING           12688 non-null object\n",
      "VOTES            11486 non-null object\n",
      "COST             12690 non-null int64\n",
      "dtypes: int64(2), object(7)\n",
      "memory usage: 892.3+ KB\n"
     ]
    }
   ],
   "source": [
    "train.info()\n",
    "#train.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique values in TITLE 113\n",
      "Unique values in RESTAURANT_ID 11892\n",
      "Unique values in CUISINES 4155\n",
      "Unique values in TIME 2689\n",
      "Unique values in CITY 359\n",
      "Unique values in LOCALITY 1416\n",
      "Unique values in RATING 32\n",
      "Unique values in VOTES 1847\n",
      "Unique values in COST 86\n"
     ]
    }
   ],
   "source": [
    "for i in train.columns:\n",
    "    print(\"Unique values in\", i, train[i].nunique())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data pre-processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# merge train and test\n",
    "df = train.append(test,ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df[['TITLE', 'CUISINES', 'TIME', 'CITY', 'LOCALITY', 'RATING', 'VOTES', 'COST']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_closed(time):\n",
    "    a = re.findall('Closed \\(.*?\\)', time)\n",
    "    if a != []:\n",
    "        return a[0]\n",
    "    else:\n",
    "        return 'NA'\n",
    "\n",
    "df['CLOSED'] = df['TIME'].apply(extract_closed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['TIME'] = df['TIME'].str.replace(r'Closed \\(.*?\\)','')\n",
    "#df['TIME'] = df['TIME'].str.replace(r'Closed...','')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['RATING'] = df['RATING'].str.replace('NEW', '1')\n",
    "df['RATING'] = df['RATING'].str.replace('-', '1').astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['VOTES'] = df['VOTES'].str.replace(' votes', '').astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['CITY'].fillna('Missing', inplace=True)  \n",
    "df['LOCALITY'].fillna('Missing', inplace=True)  \n",
    "df['RATING'].fillna(3.8, inplace=True)  \n",
    "df['VOTES'].fillna(0.0, inplace=True) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['COST'] = df['COST'].astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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>TITLE</th>\n",
       "      <th>CUISINES</th>\n",
       "      <th>TIME</th>\n",
       "      <th>CITY</th>\n",
       "      <th>LOCALITY</th>\n",
       "      <th>RATING</th>\n",
       "      <th>VOTES</th>\n",
       "      <th>COST</th>\n",
       "      <th>CLOSED</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CASUAL DINING</td>\n",
       "      <td>Malwani, Goan, North Indian</td>\n",
       "      <td>11am – 4pm, 7:30pm – 11:30pm (Mon-Sun)</td>\n",
       "      <td>Thane</td>\n",
       "      <td>Dombivali East</td>\n",
       "      <td>3.6</td>\n",
       "      <td>49.0</td>\n",
       "      <td>1200.0</td>\n",
       "      <td>NA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CASUAL DINING,BAR</td>\n",
       "      <td>Asian, Modern Indian, Japanese</td>\n",
       "      <td>6pm – 11pm (Mon-Sun)</td>\n",
       "      <td>Chennai</td>\n",
       "      <td>Ramapuram</td>\n",
       "      <td>4.2</td>\n",
       "      <td>30.0</td>\n",
       "      <td>1500.0</td>\n",
       "      <td>NA</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               TITLE                        CUISINES  \\\n",
       "0      CASUAL DINING     Malwani, Goan, North Indian   \n",
       "1  CASUAL DINING,BAR  Asian, Modern Indian, Japanese   \n",
       "\n",
       "                                     TIME     CITY        LOCALITY  RATING  \\\n",
       "0  11am – 4pm, 7:30pm – 11:30pm (Mon-Sun)    Thane  Dombivali East     3.6   \n",
       "1                    6pm – 11pm (Mon-Sun)  Chennai       Ramapuram     4.2   \n",
       "\n",
       "   VOTES    COST CLOSED  \n",
       "0   49.0  1200.0     NA  \n",
       "1   30.0  1500.0     NA  "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(123, 5183)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['TITLE'].nunique(), df['CUISINES'].nunique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "calc_mean = df.groupby(['CITY'], axis=0).agg({'RATING': 'mean'}).reset_index()\n",
    "calc_mean.columns = ['CITY','CITY_MEAN_RATING']\n",
    "df = df.merge(calc_mean, on=['CITY'],how='left')\n",
    "\n",
    "calc_mean = df.groupby(['LOCALITY'], axis=0).agg({'RATING': 'mean'}).reset_index()\n",
    "calc_mean.columns = ['LOCALITY','LOCALITY_MEAN_RATING']\n",
    "df = df.merge(calc_mean, on=['LOCALITY'],how='left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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>TITLE</th>\n",
       "      <th>CUISINES</th>\n",
       "      <th>TIME</th>\n",
       "      <th>CITY</th>\n",
       "      <th>LOCALITY</th>\n",
       "      <th>RATING</th>\n",
       "      <th>VOTES</th>\n",
       "      <th>COST</th>\n",
       "      <th>CLOSED</th>\n",
       "      <th>CITY_MEAN_RATING</th>\n",
       "      <th>LOCALITY_MEAN_RATING</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CASUAL DINING</td>\n",
       "      <td>Malwani, Goan, North Indian</td>\n",
       "      <td>11am – 4pm, 7:30pm – 11:30pm (Mon-Sun)</td>\n",
       "      <td>Thane</td>\n",
       "      <td>Dombivali East</td>\n",
       "      <td>3.6</td>\n",
       "      <td>49.0</td>\n",
       "      <td>1200.0</td>\n",
       "      <td>NA</td>\n",
       "      <td>3.376271</td>\n",
       "      <td>3.388889</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CASUAL DINING,BAR</td>\n",
       "      <td>Asian, Modern Indian, Japanese</td>\n",
       "      <td>6pm – 11pm (Mon-Sun)</td>\n",
       "      <td>Chennai</td>\n",
       "      <td>Ramapuram</td>\n",
       "      <td>4.2</td>\n",
       "      <td>30.0</td>\n",
       "      <td>1500.0</td>\n",
       "      <td>NA</td>\n",
       "      <td>3.584588</td>\n",
       "      <td>3.472222</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               TITLE                        CUISINES  \\\n",
       "0      CASUAL DINING     Malwani, Goan, North Indian   \n",
       "1  CASUAL DINING,BAR  Asian, Modern Indian, Japanese   \n",
       "\n",
       "                                     TIME     CITY        LOCALITY  RATING  \\\n",
       "0  11am – 4pm, 7:30pm – 11:30pm (Mon-Sun)    Thane  Dombivali East     3.6   \n",
       "1                    6pm – 11pm (Mon-Sun)  Chennai       Ramapuram     4.2   \n",
       "\n",
       "   VOTES    COST CLOSED  CITY_MEAN_RATING  LOCALITY_MEAN_RATING  \n",
       "0   49.0  1200.0     NA          3.376271              3.388889  \n",
       "1   30.0  1500.0     NA          3.584588              3.472222  "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "tf1 = TfidfVectorizer(ngram_range=(1, 1), lowercase=True)\n",
    "df_title = tf1.fit_transform(df['TITLE'])\n",
    "df_title = pd.DataFrame(data=df_title.toarray(), columns=tf1.get_feature_names())\n",
    "\n",
    "tf2 = TfidfVectorizer(ngram_range=(1, 1), lowercase=True)\n",
    "df_cuisines = tf2.fit_transform(df['CUISINES'])\n",
    "df_cuisines = pd.DataFrame(data=df_cuisines.toarray(), columns=tf2.get_feature_names())\n",
    "\n",
    "tf3 = TfidfVectorizer(ngram_range=(1, 1), lowercase=True)\n",
    "df_city = tf3.fit_transform(df['CITY'])\n",
    "df_city = pd.DataFrame(data=df_city.toarray(), columns=tf3.get_feature_names())\n",
    "\n",
    "tf4 = TfidfVectorizer(ngram_range=(1, 1), lowercase=True)\n",
    "df_locality = tf4.fit_transform(df['LOCALITY'])\n",
    "df_locality = pd.DataFrame(data=df_locality.toarray(), columns=tf4.get_feature_names())\n",
    "\n",
    "tf5 = TfidfVectorizer(ngram_range=(1, 1), lowercase=True)\n",
    "df_time = tf5.fit_transform(df['TIME'])\n",
    "df_time = pd.DataFrame(data=df_time.toarray(), columns=tf5.get_feature_names())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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>TITLE</th>\n",
       "      <th>CUISINES</th>\n",
       "      <th>TIME</th>\n",
       "      <th>CITY</th>\n",
       "      <th>LOCALITY</th>\n",
       "      <th>RATING</th>\n",
       "      <th>VOTES</th>\n",
       "      <th>COST</th>\n",
       "      <th>CLOSED</th>\n",
       "      <th>CITY_MEAN_RATING</th>\n",
       "      <th>LOCALITY_MEAN_RATING</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CASUAL DINING</td>\n",
       "      <td>Malwani, Goan, North Indian</td>\n",
       "      <td>11am – 4pm, 7:30pm – 11:30pm (Mon-Sun)</td>\n",
       "      <td>Thane</td>\n",
       "      <td>Dombivali East</td>\n",
       "      <td>3.6</td>\n",
       "      <td>49.0</td>\n",
       "      <td>1200.0</td>\n",
       "      <td>NA</td>\n",
       "      <td>3.376271</td>\n",
       "      <td>3.388889</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CASUAL DINING,BAR</td>\n",
       "      <td>Asian, Modern Indian, Japanese</td>\n",
       "      <td>6pm – 11pm (Mon-Sun)</td>\n",
       "      <td>Chennai</td>\n",
       "      <td>Ramapuram</td>\n",
       "      <td>4.2</td>\n",
       "      <td>30.0</td>\n",
       "      <td>1500.0</td>\n",
       "      <td>NA</td>\n",
       "      <td>3.584588</td>\n",
       "      <td>3.472222</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               TITLE                        CUISINES  \\\n",
       "0      CASUAL DINING     Malwani, Goan, North Indian   \n",
       "1  CASUAL DINING,BAR  Asian, Modern Indian, Japanese   \n",
       "\n",
       "                                     TIME     CITY        LOCALITY  RATING  \\\n",
       "0  11am – 4pm, 7:30pm – 11:30pm (Mon-Sun)    Thane  Dombivali East     3.6   \n",
       "1                    6pm – 11pm (Mon-Sun)  Chennai       Ramapuram     4.2   \n",
       "\n",
       "   VOTES    COST CLOSED  CITY_MEAN_RATING  LOCALITY_MEAN_RATING  \n",
       "0   49.0  1200.0     NA          3.376271              3.388889  \n",
       "1   30.0  1500.0     NA          3.584588              3.472222  "
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.concat([df, df_title, df_cuisines, df_city, df_locality, df_time], axis=1) \n",
    "df.drop(['TITLE', 'CUISINES', 'CITY', 'LOCALITY', 'TIME'], axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.get_dummies(df, columns=['CLOSED'], drop_first=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16921, 2285)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df = df[df['COST'].isnull()!=True]\n",
    "test_df = df[df['COST'].isnull()==True]\n",
    "test_df.drop('COST', axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((12690, 2285), (4231, 2284))"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.shape, test_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df['COST'] = np.log1p(train_df['COST'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = train_df.drop(labels=['COST'], axis=1)\n",
    "y = train_df['COST'].values\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_cv, y_train, y_cv = train_test_split(X, y, test_size=0.25, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((9517, 2284), (9517,), (3173, 2284), (3173,))"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape, y_train.shape, X_cv.shape, y_cv.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt \n",
    "from sklearn.metrics import mean_squared_log_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[50]\tvalid_0's rmse: 0.374992\n",
      "[100]\tvalid_0's rmse: 0.354891\n",
      "[150]\tvalid_0's rmse: 0.351117\n",
      "[200]\tvalid_0's rmse: 0.34932\n",
      "[250]\tvalid_0's rmse: 0.348682\n",
      "[300]\tvalid_0's rmse: 0.348451\n",
      "[350]\tvalid_0's rmse: 0.348393\n",
      "RMSLE: 0.34738450721214525\n"
     ]
    }
   ],
   "source": [
    "import lightgbm as lgb\n",
    "train_data = lgb.Dataset(X_train, label=y_train)\n",
    "test_data = lgb.Dataset(X_cv, label=y_cv)\n",
    "\n",
    "param = {'objective': 'regression',\n",
    "         'boosting': 'gbdt',  \n",
    "         'metric': 'l2_root',\n",
    "         'learning_rate': 0.05, \n",
    "         'num_iterations': 350,\n",
    "         'num_leaves': 31,\n",
    "         'max_depth': -1,\n",
    "         'min_data_in_leaf': 15,\n",
    "         'bagging_fraction': 0.85,\n",
    "         'bagging_freq': 1,\n",
    "         'feature_fraction': 0.55\n",
    "         }\n",
    "\n",
    "lgbm = lgb.train(params=param,\n",
    "                 verbose_eval=50,\n",
    "                 train_set=train_data,\n",
    "                 valid_sets=[test_data])\n",
    "\n",
    "y_pred_lgbm = lgbm.predict(X_cv)\n",
    "print('RMSLE:', sqrt(mean_squared_log_error(np.exp(y_cv), np.exp(y_pred_lgbm))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:   29.6s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSLE: 0.35787401792256457\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    2.1s finished\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import BaggingRegressor\n",
    "br = BaggingRegressor(base_estimator=None, n_estimators=30, max_samples=0.9, max_features=1.0, bootstrap=True, \n",
    "                      bootstrap_features=True, oob_score=True, warm_start=False, n_jobs=1, random_state=42, verbose=1)\n",
    "br.fit(X_train, y_train)\n",
    "y_pred_br = br.predict(X_cv)\n",
    "print('RMSLE:', sqrt(mean_squared_log_error(np.exp(y_cv), np.exp(y_pred_br))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSLE: 0.3615527439751424\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done  40 out of  40 | elapsed:   33.8s finished\n",
      "[Parallel(n_jobs=1)]: Done  40 out of  40 | elapsed:    0.0s finished\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestRegressor\n",
    "rf = RandomForestRegressor(n_estimators=40, criterion='mse', max_depth=None, min_samples_split=4, min_samples_leaf=1, \n",
    "                           min_weight_fraction_leaf=0.0, max_features='auto', max_leaf_nodes=None, \n",
    "                           min_impurity_decrease=0.0, min_impurity_split=None, bootstrap=True, oob_score=False, n_jobs=1, \n",
    "                           random_state=42, verbose=1, warm_start=False)\n",
    "rf.fit(X_train, y_train)\n",
    "y_pred_rf = rf.predict(X_cv)\n",
    "print('RMSLE:', sqrt(mean_squared_log_error(np.exp(y_cv), np.exp(y_pred_rf))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSLE: 0.34521123762900163\n"
     ]
    }
   ],
   "source": [
    "y_pred = y_pred_lgbm*0.70 + y_pred_br*0.15 +  y_pred_rf*0.15\n",
    "print('RMSLE:', sqrt(mean_squared_log_error(np.exp(y_cv), np.exp(y_pred))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predict on test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Xtrain = train_df.drop(labels='COST', axis=1)\n",
    "#ytrain = train_df['COST'].values\n",
    "Xtest = test_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Xtrain.shape, ytrain.shape, Xtest.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE LGBM:  0.34634770050754055\n",
      "RMSE LGBM:  0.36050434904910617\n",
      "RMSE LGBM:  0.3383243912986553\n",
      "RMSE LGBM:  0.33998775736443887\n",
      "RMSE LGBM:  0.33229233133671693\n",
      "RMSE LGBM:  0.32279425561136116\n",
      "RMSE LGBM:  0.3602566417201069\n",
      "RMSE LGBM:  0.3704199555700122\n",
      "RMSE LGBM:  0.34912114067345773\n",
      "RMSE LGBM:  0.32760152567269174\n",
      "RMSE LGBM:  0.33708072185778504\n",
      "RMSE LGBM:  0.34559951492494834\n",
      "RMSE LGBM:  0.32591077296431276\n",
      "RMSE LGBM:  0.34830474891636404\n",
      "RMSE LGBM:  0.3599866766115413\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import KFold, RepeatedKFold\n",
    "from lightgbm import LGBMRegressor\n",
    "\n",
    "errlgb = []\n",
    "y_pred_totlgb = []\n",
    "\n",
    "fold = KFold(n_splits=15, shuffle=True, random_state=42)\n",
    "\n",
    "for train_index, test_index in fold.split(X):\n",
    "    X_train, X_test = X.loc[train_index], X.loc[test_index]\n",
    "    y_train, y_test = y[train_index], y[test_index]\n",
    "\n",
    "    param = {'objective': 'regression',\n",
    "             'boosting': 'gbdt',\n",
    "             'metric': 'l2_root',\n",
    "             'learning_rate': 0.05,\n",
    "             'num_iterations': 350,\n",
    "             'num_leaves': 31,\n",
    "             'max_depth': -1,\n",
    "             'min_data_in_leaf': 15,\n",
    "             'bagging_fraction': 0.85,\n",
    "             'bagging_freq': 1,\n",
    "             'feature_fraction': 0.55\n",
    "             }\n",
    "\n",
    "    lgbm = LGBMRegressor(**param)\n",
    "    lgbm.fit(X_train, y_train,\n",
    "             eval_set=[(X_test, y_test)],\n",
    "             verbose=0,\n",
    "             early_stopping_rounds=100\n",
    "             )\n",
    "\n",
    "    y_pred_lgbm = lgbm.predict(X_test)\n",
    "    print(\"RMSE LGBM: \", sqrt(mean_squared_log_error(np.exp(y_test), np.exp(y_pred_lgbm))))\n",
    "\n",
    "    errlgb.append(sqrt(mean_squared_log_error(np.exp(y_test), np.exp(y_pred_lgbm))))\n",
    "    p = lgbm.predict(Xtest)\n",
    "    y_pred_totlgb.append(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE BR: 0.3586752213659628\n",
      "RMSE BR: 0.3613894726323447\n",
      "RMSE BR: 0.35115535979189344\n",
      "RMSE BR: 0.35330944102506\n",
      "RMSE BR: 0.33892514866656537\n",
      "RMSE BR: 0.3341160573007311\n",
      "RMSE BR: 0.3621614543958501\n",
      "RMSE BR: 0.37955509241233865\n",
      "RMSE BR: 0.35564940402710205\n",
      "RMSE BR: 0.33996481911445625\n",
      "RMSE BR: 0.344823540560161\n",
      "RMSE BR: 0.3590083435406006\n",
      "RMSE BR: 0.34023130042067395\n",
      "RMSE BR: 0.35848761007799596\n",
      "RMSE BR: 0.37049599562689933\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "from sklearn.ensemble import BaggingRegressor\n",
    "\n",
    "err_br = []\n",
    "y_pred_totbr = []\n",
    "\n",
    "fold = KFold(n_splits=15, shuffle=True, random_state=42)\n",
    "\n",
    "for train_index, test_index in fold.split(X):\n",
    "    X_train, X_test = X.loc[train_index], X.loc[test_index]\n",
    "    y_train, y_test = y[train_index], y[test_index]\n",
    "\n",
    "    br = BaggingRegressor(base_estimator=None, n_estimators=30, max_samples=1.0, max_features=1.0, bootstrap=True,\n",
    "                          bootstrap_features=True, oob_score=False, warm_start=False, n_jobs=1, random_state=42, verbose=0)\n",
    "    \n",
    "    br.fit(X_train, y_train)\n",
    "    y_pred_br = br.predict(X_test)\n",
    "\n",
    "    print(\"RMSE BR:\", sqrt(mean_squared_log_error(np.exp(y_test), np.exp(y_pred_br))))\n",
    "\n",
    "    err_br.append(sqrt(mean_squared_log_error(np.exp(y_test), np.exp(y_pred_br))))\n",
    "    p = br.predict(Xtest)\n",
    "    y_pred_totbr.append(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE RF:  0.36614000254463974\n",
      "RMSE RF:  0.3683591687547315\n",
      "RMSE RF:  0.3517377927047469\n",
      "RMSE RF:  0.35388720704961274\n",
      "RMSE RF:  0.3442536101451444\n",
      "RMSE RF:  0.33876558258256856\n",
      "RMSE RF:  0.37353126815110077\n",
      "RMSE RF:  0.38011361519234643\n",
      "RMSE RF:  0.3654908935046804\n",
      "RMSE RF:  0.35043560011157937\n",
      "RMSE RF:  0.3553517669006067\n",
      "RMSE RF:  0.3626059642439505\n",
      "RMSE RF:  0.3481312253297813\n",
      "RMSE RF:  0.36696439924366425\n",
      "RMSE RF:  0.37410589750504164\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "\n",
    "err_rf = []\n",
    "y_pred_totrf = []\n",
    "\n",
    "fold = KFold(n_splits=15, shuffle=True, random_state=42)\n",
    "\n",
    "for train_index, test_index in fold.split(X):\n",
    "    X_train, X_test = X.loc[train_index], X.loc[test_index]\n",
    "    y_train, y_test = y[train_index], y[test_index]\n",
    "\n",
    "    rf = RandomForestRegressor(n_estimators=40, criterion='mse', max_depth=None, min_samples_split=4, min_samples_leaf=1, \n",
    "                           min_weight_fraction_leaf=0.0, max_features='auto', max_leaf_nodes=None, \n",
    "                           min_impurity_decrease=0.0, min_impurity_split=None, bootstrap=True, oob_score=False, n_jobs=1, \n",
    "                           random_state=42, verbose=0, warm_start=False)\n",
    "    rf.fit(X_train, y_train)\n",
    "    y_pred_rf = rf.predict(X_test)\n",
    "\n",
    "    print(\"RMSE RF: \", sqrt(mean_squared_log_error(np.exp(y_test), np.exp(y_pred_rf))))\n",
    "\n",
    "    err_rf.append(sqrt(mean_squared_log_error(np.exp(y_test), np.exp(y_pred_rf))))\n",
    "    p = rf.predict(Xtest)\n",
    "    y_pred_totrf.append(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.3443021656052692, 0.35386321739724236, 0.35999159959761307)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(errlgb,0), np.mean(err_br,0), np.mean(err_rf,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "lgbm_final = np.exp(np.mean(y_pred_totlgb,0))\n",
    "br_final = np.exp(np.mean(y_pred_totbr,0))\n",
    "rf_final = np.exp(np.mean(y_pred_totrf,0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1089.08087315,  406.3628336 ,  717.44554087, ...,  418.31530824,\n",
       "        253.66263228,  401.25693405])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred = (lgbm_final*0.70 + br_final*0.215 + rf_final*.15) \n",
    "y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sub = pd.DataFrame(data=y_pred, columns=['COST'])\n",
    "writer = pd.ExcelWriter('Output.xlsx', engine='xlsxwriter')\n",
    "df_sub.to_excel(writer,sheet_name='Sheet1', index=False)\n",
    "writer.save()"
   ]
  }
 ],
 "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.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}