notebooks/kfold-lightgbm-without-leak-1-062.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type='text/css'>\n",
       ".datatable table.frame { margin-bottom: 0; }\n",
       ".datatable table.frame thead { border-bottom: none; }\n",
       ".datatable table.frame tr.coltypes td {  color: #FFFFFF;  line-height: 6px;  padding: 0 0.5em;}\n",
       ".datatable .bool    { background: #DDDD99; }\n",
       ".datatable .object  { background: #565656; }\n",
       ".datatable .int     { background: #5D9E5D; }\n",
       ".datatable .float   { background: #4040CC; }\n",
       ".datatable .str     { background: #CC4040; }\n",
       ".datatable .row_index {  background: var(--jp-border-color3);  border-right: 1px solid var(--jp-border-color0);  color: var(--jp-ui-font-color3);  font-size: 9px;}\n",
       ".datatable .frame tr.coltypes .row_index {  background: var(--jp-border-color0);}\n",
       ".datatable th:nth-child(2) { padding-left: 12px; }\n",
       ".datatable .hellipsis {  color: var(--jp-cell-editor-border-color);}\n",
       ".datatable .vellipsis {  background: var(--jp-layout-color0);  color: var(--jp-cell-editor-border-color);}\n",
       ".datatable .na {  color: var(--jp-cell-editor-border-color);  font-size: 80%;}\n",
       ".datatable .footer { font-size: 9px; }\n",
       ".datatable .frame_dimensions {  background: var(--jp-border-color3);  border-top: 1px solid var(--jp-border-color0);  color: var(--jp-ui-font-color3);  display: inline-block;  opacity: 0.6;  padding: 1px 10px 1px 5px;}\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import lightgbm as lgb\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.model_selection import KFold\n",
    "import datetime\n",
    "import gc\n",
    "import pickle\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "\n",
    "from pathlib import Path\n",
    "import os\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 142 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "root = Path(r'C:\\Users\\Patrick Fu\\Google trends for buildings\\Dataset\\GEPIII_dataset')\n",
    "\n",
    "df_train = pd.read_feather(root/'train.feather')\n",
    "\n",
    "weather_train = pd.read_feather(root/'weather_train.feather')\n",
    "weather_test = pd.read_feather(root/'weather_test.feather')\n",
    "\n",
    "building = pd.read_feather(root/'building_metadata.feather')\n",
    "le = LabelEncoder()\n",
    "building.primary_use = le.fit_transform(building.primary_use)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 2min 8s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "df_train = df_train.query('not (building_id <= 104 & meter == 0 & timestamp <= \"2016-05-20 18\")')\n",
    "df_train = df_train.query('not (building_id == 681 & meter == 0 & timestamp <= \"2016-04-27\")')\n",
    "df_train = df_train.query('not (building_id == 761 & meter == 0 & timestamp <= \"2016-09-02\")')\n",
    "df_train = df_train.query('not (building_id == 799 & meter == 0 & timestamp <= \"2016-09-02\")')\n",
    "df_train = df_train.query('not (building_id == 802 & meter == 0 & timestamp <= \"2016-08-24\")')\n",
    "df_train = df_train.query('not (building_id == 1073 & meter == 0 & timestamp <= \"2016-10-26\")')\n",
    "df_train = df_train.query('not (building_id == 1094 & meter == 0 & timestamp <= \"2016-09-08\")')\n",
    "df_train = df_train.query('not (building_id == 29 & meter == 0 & timestamp <= \"2016-08-10\")')\n",
    "df_train = df_train.query('not (building_id == 40 & meter == 0 & timestamp <= \"2016-06-04\")')\n",
    "df_train = df_train.query('not (building_id == 45 & meter == 0 & timestamp <= \"2016-07\")')\n",
    "df_train = df_train.query('not (building_id == 106 & meter == 0 & timestamp <= \"2016-11\")')\n",
    "df_train = df_train.query('not (building_id == 107 & meter == 0 & timestamp >= \"2016-11-10\")')\n",
    "df_train = df_train.query('not (building_id == 112 & meter == 0 & timestamp < \"2016-10-31 15\")')\n",
    "df_train = df_train.query('not (building_id == 144 & meter == 0 & timestamp > \"2016-05-14\" & timestamp < \"2016-10-31\")')\n",
    "df_train = df_train.query('not (building_id == 147 & meter == 0 & timestamp > \"2016-06-05 19\" & timestamp < \"2016-07-18 15\")')\n",
    "df_train = df_train.query('not (building_id == 171 & meter == 0 & timestamp <= \"2016-07-05\")')\n",
    "df_train = df_train.query('not (building_id == 177 & meter == 0 & timestamp > \"2016-06-04\" & timestamp < \"2016-06-25\")')\n",
    "df_train = df_train.query('not (building_id == 258 & meter == 0 & timestamp > \"2016-09-26\" & timestamp < \"2016-12-12\")')\n",
    "df_train = df_train.query('not (building_id == 258 & meter == 0 & timestamp > \"2016-08-30\" & timestamp < \"2016-09-08\")')\n",
    "df_train = df_train.query('not (building_id == 258 & meter == 0 & timestamp > \"2016-09-18\" & timestamp < \"2016-09-25\")')\n",
    "df_train = df_train.query('not (building_id == 260 & meter == 0 & timestamp <= \"2016-05-11\")')\n",
    "df_train = df_train.query('not (building_id == 269 & meter == 0 & timestamp > \"2016-06-04\" & timestamp < \"2016-06-25\")')\n",
    "df_train = df_train.query('not (building_id == 304 & meter == 0 & timestamp >= \"2016-11-20\")')\n",
    "df_train = df_train.query('not (building_id == 545 & meter == 0 & timestamp > \"2016-01-17\" & timestamp < \"2016-02-10\")')\n",
    "df_train = df_train.query('not (building_id == 604 & meter == 0 & timestamp < \"2016-11-21\")')\n",
    "df_train = df_train.query('not (building_id == 693 & meter == 0 & timestamp > \"2016-09-07\" & timestamp < \"2016-11-23\")')\n",
    "df_train = df_train.query('not (building_id == 693 & meter == 0 & timestamp > \"2016-07-12\" & timestamp < \"2016-05-29\")')\n",
    "df_train = df_train.query('not (building_id == 723 & meter == 0 & timestamp > \"2016-10-06\" & timestamp < \"2016-11-22\")')\n",
    "df_train = df_train.query('not (building_id == 733 & meter == 0 & timestamp > \"2016-05-29\" & timestamp < \"2016-06-22\")')\n",
    "df_train = df_train.query('not (building_id == 733 & meter == 0 & timestamp > \"2016-05-19\" & timestamp < \"2016-05-20\")')\n",
    "df_train = df_train.query('not (building_id == 803 & meter == 0 & timestamp > \"2016-9-25\")')\n",
    "df_train = df_train.query('not (building_id == 815 & meter == 0 & timestamp > \"2016-05-17\" & timestamp < \"2016-11-17\")')\n",
    "df_train = df_train.query('not (building_id == 848 & meter == 0 & timestamp > \"2016-01-15\" & timestamp < \"2016-03-20\")')\n",
    "df_train = df_train.query('not (building_id == 857 & meter == 0 & timestamp > \"2016-04-13\")')\n",
    "df_train = df_train.query('not (building_id == 909 & meter == 0 & timestamp < \"2016-02-02\")')\n",
    "df_train = df_train.query('not (building_id == 909 & meter == 0 & timestamp < \"2016-06-23\")')\n",
    "df_train = df_train.query('not (building_id == 1008 & meter == 0 & timestamp > \"2016-10-30\" & timestamp < \"2016-11-21\")')\n",
    "df_train = df_train.query('not (building_id == 1113 & meter == 0 & timestamp < \"2016-07-27\")')\n",
    "df_train = df_train.query('not (building_id == 1153 & meter == 0 & timestamp < \"2016-01-20\")')\n",
    "df_train = df_train.query('not (building_id == 1169 & meter == 0 & timestamp < \"2016-08-03\")')\n",
    "df_train = df_train.query('not (building_id == 1170 & meter == 0 & timestamp > \"2016-06-30\" & timestamp < \"2016-07-05\")')\n",
    "df_train = df_train.query('not (building_id == 1221 & meter == 0 & timestamp < \"2016-11-04\")')\n",
    "df_train = df_train.query('not (building_id == 1225 & meter == 0 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1234 & meter == 0 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id >= 1233 & building_id <= 1234 & meter == 0 & timestamp > \"2016-01-13 22\" & timestamp < \"2016-03-08 12\")')\n",
    "df_train = df_train.query('not (building_id == 1241 & meter == 0 & timestamp > \"2016-07-14\" & timestamp < \"2016-11-19\")')\n",
    "df_train = df_train.query('not (building_id == 1250 & meter == 0 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1255 & meter == 0 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1264 & meter == 0 & timestamp > \"2016-08-23\")')\n",
    "df_train = df_train.query('not (building_id == 1265 & meter == 0 & timestamp > \"2016-05-06\" & timestamp < \"2016-05-26\")')\n",
    "df_train = df_train.query('not (building_id == 1272 & meter == 0 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id >= 1275 & building_id <= 1280 & meter == 0 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1283 & meter == 0 & timestamp > \"2016-07-08\" & timestamp < \"2016-08-03\")')\n",
    "df_train = df_train.query('not (building_id >= 1291 & building_id <= 1302 & meter == 0 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1303 & meter == 0 & timestamp > \"2016-07-25 22\" & timestamp < \"2016-07-27 16\")')\n",
    "df_train = df_train.query('not (building_id == 1303 & meter == 0 & timestamp > \"2016-01-26\" & timestamp < \"2016-06-02 12\")')\n",
    "df_train = df_train.query('not (building_id == 1319 & meter == 0 & timestamp > \"2016-05-17 16\" & timestamp < \"2016-06-07 12\")')\n",
    "df_train = df_train.query('not (building_id == 1319 & meter == 0 & timestamp > \"2016-08-18 14\" & timestamp < \"2016-09-02 14\")')\n",
    "df_train = df_train.query('not (building_id == 1322 & meter == 0 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "\n",
    "# 2nd cleaning\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 0 & timestamp > \"2016-10-14 22\" & timestamp < \"2016-10-17 08\")')\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 0 & timestamp > \"2016-07-01 14\" & timestamp < \"2016-07-05 06\")')\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 1 & timestamp > \"2016-10-14 22\" & timestamp < \"2016-10-17 08\")')\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 1 & timestamp > \"2016-07-01 14\" & timestamp < \"2016-07-05 06\")')\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 2 & timestamp > \"2016-10-14 22\" & timestamp < \"2016-10-17 08\")')\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 2 & timestamp > \"2016-07-01 14\" & timestamp < \"2016-07-05 06\")')\n",
    "df_train = df_train.query('not (building_id == 1272 & meter == 1 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id >= 1291 & building_id <= 1297 & meter == 1 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1300 & meter == 1 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1302 & meter == 1 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id >= 1291 & building_id <= 1299 & meter == 2 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1221 & meter == 0 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id >= 1225 & building_id <= 1226 & meter == 0 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id >= 1233 & building_id <= 1234 & meter == 0 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1241 & meter == 0 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1223 & meter == 1 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1226 & meter == 1 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id >= 1233 & building_id <= 1234 & meter == 1 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id >= 1225 & building_id <= 1226 & meter == 2 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1305 & meter == 2 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1307 & meter == 2 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1223 & meter == 3 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1231 & meter == 3 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id >= 1233 & building_id <= 1234 & meter == 3 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1272 & meter == 3 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id >= 1275 & building_id <= 1297 & meter == 3 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1300 & meter == 3 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1302 & meter == 3 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1293 & meter == 3 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-25 12\")')\n",
    "df_train = df_train.query('not (building_id == 1302 & meter == 3 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-25 12\")')\n",
    "df_train = df_train.query('not (building_id == 1223 & meter == 0 & timestamp > \"2016-9-28 07\" & timestamp < \"2016-10-11 18\")')\n",
    "df_train = df_train.query('not (building_id == 1225 & meter == 1 & timestamp > \"2016-8-22 23\" & timestamp < \"2016-10-11 14\")')\n",
    "df_train = df_train.query('not (building_id == 1230 & meter == 1 & timestamp > \"2016-8-22 08\" & timestamp < \"2016-10-05 18\")')\n",
    "df_train = df_train.query('not (building_id == 904 & meter == 0 & timestamp < \"2016-02-17 08\")')\n",
    "df_train = df_train.query('not (building_id == 986 & meter == 0 & timestamp < \"2016-02-17 08\")')\n",
    "df_train = df_train.query('not (building_id == 954 & meter == 0 & timestamp < \"2016-08-08 11\")')\n",
    "df_train = df_train.query('not (building_id == 954 & meter == 0 & timestamp < \"2016-06-23 08\")')\n",
    "df_train = df_train.query('not (building_id >= 745 & building_id <= 770 & meter == 1 & timestamp > \"2016-10-05 01\" & timestamp < \"2016-10-10 09\")')\n",
    "df_train = df_train.query('not (building_id >= 774 & building_id <= 787 & meter == 1 & timestamp > \"2016-10-05 01\" & timestamp < \"2016-10-10 09\")')\n",
    "\n",
    "# 3rd cleaning hourly spikes\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 0 & timestamp > \"2016-05-11 09\" & timestamp < \"2016-05-12 01\")')\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 1 & timestamp > \"2016-05-11 09\" & timestamp < \"2016-05-12 01\")')\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 2 & timestamp > \"2016-05-11 09\" & timestamp < \"2016-05-12 01\")')\n",
    "\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 0 & timestamp == \"2016-02-26 01\")')\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 1 & timestamp == \"2016-02-26 01\")')\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 2 & timestamp == \"2016-02-26 01\")')\n",
    "\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 0 & timestamp > \"2016-03-29 10\" & timestamp < \"2016-03-30 12\")')\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 1 & timestamp > \"2016-03-29 10\" & timestamp < \"2016-03-30 12\")')\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 2 & timestamp > \"2016-03-29 10\" & timestamp < \"2016-03-30 12\")')\n",
    "\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 0 & timestamp > \"2016-01-19 23\" & timestamp < \"2016-01-28 15\")')\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 1 & timestamp > \"2016-01-19 23\" & timestamp < \"2016-01-28 15\")')\n",
    "df_train = df_train.query('not (building_id >= 874 & building_id <= 997 & meter == 2 & timestamp > \"2016-01-19 23\" & timestamp < \"2016-01-28 15\")')\n",
    "\n",
    "df_train = df_train.query('not (building_id != 1227 & building_id != 1281 & building_id != 1314 & building_id >=1223 & building_id < 1335 & meter==0 & meter_reading==0)')\n",
    "\n",
    "# 4th cleaning (using hindsight from leaks)\n",
    "df_train = df_train.query('not (building_id >= 1223 & building_id <= 1324 & meter==1 & timestamp > \"2016-07-16 04\" & timestamp < \"2016-07-19 11\")')\n",
    "df_train = df_train.query('not (building_id == 107 & meter == 0 & timestamp <= \"2016-07-06\")')\n",
    "# df_train = df_train.query('not (building_id == 53 & meter == 0)')\n",
    "df_train = df_train.query('not (building_id == 180 & timestamp >= \"2016-02-17 12\")')\n",
    "df_train = df_train.query('not (building_id == 182 & meter == 0)')\n",
    "df_train = df_train.query('not (building_id == 191 & meter == 0 & timestamp >= \"2016-12-22 09\")')\n",
    "df_train = df_train.query('not (building_id == 192 & meter == 1 & timestamp >= \"2016-05-09 18\")')\n",
    "df_train = df_train.query('not (building_id == 192 & meter == 3 & timestamp >= \"2016-03-29 05\" & timestamp <= \"2016-04-04 08\")')\n",
    "df_train = df_train.query('not (building_id == 207 & meter == 1 & timestamp > \"2016-07-02 20\" & timestamp < \"2016-08-25 12\")')\n",
    "# df_train = df_train.query('not (building_id == 218)')\n",
    "df_train = df_train.query('not (building_id == 258 & timestamp > \"2016-09-18\" & timestamp < \"2016-12-12 13\")')\n",
    "df_train = df_train.query('not (building_id == 258 & timestamp > \"2016-08-29 08\" & timestamp < \"2016-09-08 14\")')\n",
    "df_train = df_train.query('not (building_id == 257 & meter == 1 & timestamp < \"2016-03-25 16\")')\n",
    "df_train = df_train.query('not (building_id == 260 & meter == 1 & timestamp > \"2016-05-10 17\" & timestamp < \"2016-08-17 11\")')\n",
    "df_train = df_train.query('not (building_id == 260 & meter == 1 & timestamp > \"2016-08-28 01\" & timestamp < \"2016-10-31 13\")')\n",
    "# df_train = df_train.query('not (building_id == 279 & meter == 3)')\n",
    "# df_train = df_train.query('not (building_id == 287 & meter == 1)')\n",
    "# df_train = df_train.query('not (building_id == 287 & meter == 3)')\n",
    "df_train = df_train.query('not (building_id == 220 & meter == 1 & timestamp > \"2016-09-23 01\" & timestamp < \"2016-09-23 12\")')\n",
    "df_train = df_train.query('not (building_id == 281 & meter == 1 & timestamp > \"2016-10-25 08\" & timestamp < \"2016-11-04 15\")')\n",
    "df_train = df_train.query('not (building_id == 273 & meter == 1 & timestamp > \"2016-04-03 04\" & timestamp < \"2016-04-29 15\")')\n",
    "df_train = df_train.query('not (building_id == 28 & meter == 0 & timestamp < \"2016-10-14 20\")')\n",
    "df_train = df_train.query('not (building_id == 71 & meter == 0 & timestamp < \"2016-08-18 20\")')\n",
    "df_train = df_train.query('not (building_id == 76 & meter == 0 & timestamp > \"2016-06-04 09\" & timestamp < \"2016-06-04 14\")')\n",
    "df_train = df_train.query('not (building_id == 101 & meter == 0 & timestamp > \"2016-10-12 13\" & timestamp < \"2016-10-12 18\")')\n",
    "df_train = df_train.query('not (building_id == 7 & meter == 1 & timestamp > \"2016-11-03 09\" & timestamp < \"2016-11-28 14\")')\n",
    "df_train = df_train.query('not (building_id == 9 & meter == 1 & timestamp > \"2016-12-06 08\")')\n",
    "df_train = df_train.query('not (building_id == 43 & meter == 1 & timestamp > \"2016-04-03 08\" & timestamp < \"2016-06-06 13\")')\n",
    "df_train = df_train.query('not (building_id == 60 & meter == 1 & timestamp > \"2016-05-01 17\" & timestamp < \"2016-05-01 21\")')\n",
    "df_train = df_train.query('not (building_id == 75 & meter == 1 & timestamp > \"2016-08-05 13\" & timestamp < \"2016-08-26 12\")')\n",
    "df_train = df_train.query('not (building_id == 95 & meter == 1 & timestamp > \"2016-08-08 10\" & timestamp < \"2016-08-26 13\")')\n",
    "df_train = df_train.query('not (building_id == 97 & meter == 1 & timestamp > \"2016-08-08 14\" & timestamp < \"2016-08-25 14\")')\n",
    "df_train = df_train.query('not (building_id == 1232 & meter == 1 & timestamp > \"2016-06-23 16\" & timestamp < \"2016-08-31 20\")')\n",
    "df_train = df_train.query('not (building_id == 1236 & meter == 1 & meter_reading >= 3000)')\n",
    "df_train = df_train.query('not (building_id == 1239 & meter == 1 & timestamp > \"2016-03-11 16\" & timestamp < \"2016-03-27 17\")')\n",
    "df_train = df_train.query('not (building_id == 1264 & meter == 1 & timestamp > \"2016-08-22 17\" & timestamp < \"2016-09-22 20\")')\n",
    "df_train = df_train.query('not (building_id == 1264 & meter == 1 & timestamp > \"2016-09-28 07\" & timestamp < \"2016-10-20 13\")')\n",
    "df_train = df_train.query('not (building_id == 1269 & meter == 1 & meter_reading >= 2000)')\n",
    "df_train = df_train.query('not (building_id == 1272 & meter == 1 & timestamp > \"2016-08-11 12\" & timestamp < \"2016-08-30 19\")')\n",
    "df_train = df_train.query('not (building_id == 1273 & meter == 1 & timestamp > \"2016-05-31 14\" & timestamp < \"2016-06-17\")')\n",
    "df_train = df_train.query('not (building_id == 1276 & meter == 1 & timestamp < \"2016-02-03 23\")')\n",
    "df_train = df_train.query('not (building_id == 1280 & meter == 1 & timestamp > \"2016-05-18\" & timestamp < \"2016-05-26 09\")')\n",
    "df_train = df_train.query('not (building_id == 1280 & meter == 1 & timestamp > \"2016-02-28 23\" & timestamp < \"2016-05-02 05\")')\n",
    "df_train = df_train.query('not (building_id == 1280 & meter == 1 & timestamp > \"2016-06-12 01\" & timestamp < \"2016-7-07 06\")')\n",
    "df_train = df_train.query('not (building_id == 1288 & meter == 1 & timestamp > \"2016-07-07 15\" & timestamp < \"2016-08-12 17\")')\n",
    "df_train = df_train.query('not (building_id == 1311 & meter == 1 & timestamp > \"2016-04-25 18\" & timestamp < \"2016-05-13 14\")')\n",
    "df_train = df_train.query('not (building_id == 1099 & meter == 2)')\n",
    "\n",
    "df_train = df_train.query('not (building_id == 1329 & meter == 0 & timestamp > \"2016-04-28 00\" & timestamp < \"2016-04-28 07\")')\n",
    "df_train = df_train.query('not (building_id == 1331 & meter == 0 & timestamp > \"2016-04-28 00\" & timestamp < \"2016-04-28 07\")')\n",
    "df_train = df_train.query('not (building_id == 1427 & meter == 0 & timestamp > \"2016-04-11 10\" & timestamp < \"2016-04-11 14\")')\n",
    "df_train = df_train.query('not (building_id == 1426 & meter == 2 & timestamp > \"2016-05-03 09\" & timestamp < \"2016-05-03 14\")')\n",
    "df_train = df_train.query('not (building_id == 1345 & meter == 0 & timestamp < \"2016-03-01\")')\n",
    "df_train = df_train.query('not (building_id == 1346 & timestamp < \"2016-03-01\")')\n",
    "df_train = df_train.query('not (building_id == 1359 & meter == 0 & timestamp > \"2016-04-25 17\" & timestamp < \"2016-07-22 14\")')\n",
    "df_train = df_train.query('not (building_id == 1365 & meter == 0 & timestamp > \"2016-08-19 00\" & timestamp < \"2016-08-19 07\")')\n",
    "df_train = df_train.query('not (building_id == 1365 & meter == 0 & timestamp > \"2016-06-18 22\" & timestamp < \"2016-06-19 06\")')\n",
    "\n",
    "df_train = df_train.query('not (building_id == 18 & meter == 0 & timestamp > \"2016-06-04 09\" & timestamp < \"2016-06-04 16\")')\n",
    "df_train = df_train.query('not (building_id == 18 & meter == 0 & timestamp > \"2016-11-05 05\" & timestamp < \"2016-11-05 15\")')\n",
    "df_train = df_train.query('not (building_id == 101 & meter == 0 & meter_reading > 800)')\n",
    "\n",
    "df_train = df_train.query('not (building_id == 1384 & meter == 0 & meter_reading == 0 )')\n",
    "df_train = df_train.query('not (building_id >= 1289 & building_id <= 1301 & meter == 2 & meter_reading == 0)')\n",
    "df_train = df_train.query('not (building_id == 1243 & meter == 2 & meter_reading == 0)')\n",
    "df_train = df_train.query('not (building_id == 1263 & meter == 2 & meter_reading == 0)')\n",
    "df_train = df_train.query('not (building_id == 1284 & meter == 2 & meter_reading == 0)')\n",
    "df_train = df_train.query('not (building_id == 1286 & meter == 2 & meter_reading == 0)')\n",
    "df_train = df_train.query('not (building_id == 1263 & meter == 0 & timestamp > \"2016-11-10 11\" & timestamp < \"2016-11-10 15\")')\n",
    "\n",
    "df_train = df_train.query('not (building_id == 1238 & meter == 2 & meter_reading == 0)')\n",
    "df_train = df_train.query('not (building_id == 1329 & meter == 2 & timestamp > \"2016-11-21 12\" & timestamp < \"2016-11-29 12\")')\n",
    "df_train = df_train.query('not (building_id == 1249 & meter == 2 & meter_reading == 0)')\n",
    "\n",
    "df_train = df_train.query('not (building_id == 1250 & meter == 2 & meter_reading == 0)')\n",
    "df_train = df_train.query('not (building_id == 1256 & meter == 2 & timestamp > \"2016-03-05 18\" & timestamp < \"2016-03-05 22\")')\n",
    "df_train = df_train.query('not (building_id == 1256 & meter == 2 & timestamp > \"2016-03-27 00\" & timestamp < \"2016-03-27 23\")')\n",
    "df_train = df_train.query('not (building_id == 1256 & meter == 2 & timestamp > \"2016-04-11 09\" & timestamp < \"2016-04-13 03\")')\n",
    "df_train = df_train.query('not (building_id == 1256 & meter == 2 & timestamp > \"2016-04-29 00\" & timestamp < \"2016-04-30 15\")')\n",
    "df_train = df_train.query('not (building_id == 1303 & meter == 2 & timestamp < \"2016-06-06 19\")')\n",
    "df_train = df_train.query('not (building_id >= 1223 & building_id <= 1324 & meter == 1 & timestamp > \"2016-08-11 17\" & timestamp < \"2016-08-12 17\")')\n",
    "df_train = df_train.query('not (building_id >= 1223 & building_id <= 1324 & building_id != 1296 & building_id != 129 & building_id != 1298 & building_id != 1299 & meter == 2 & timestamp > \"2016-08-11 17\" & timestamp < \"2016-08-12 17\")')\n",
    "df_train = df_train.query('not (building_id >= 1223 & building_id <= 1324 & meter == 3 & timestamp > \"2016-08-11 17\" & timestamp < \"2016-08-12 17\")')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Remove outliers\n",
    "# df_train = df_train [ df_train['building_id'] != 1099 ]\n",
    "# df_train = df_train.query('not (building_id <= 104 & meter == 0 & timestamp <= \"2016-05-20\")')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # building_meter map\n",
    "\n",
    "# bm_cols = ['bm', 'weekday', 'hour',]\n",
    "# df_train['hour'] = df_train['timestamp'].dt.hour\n",
    "# df_train['weekday'] = df_train['timestamp'].dt.weekday\n",
    "# df_train['bm'] = df_train['building_id'].apply(lambda x: str(x)) + '_' + df_train['meter'].apply(lambda x: str(x))\n",
    "# bm = df_train.groupby(bm_cols)['meter_reading'].mean().rename('bm_week_hour').to_frame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df_train = df_train.merge(bm, right_index=True, left_on=bm_cols, how='left')\n",
    "# df_train.drop(['bm'], axis=1, inplace=True)\n",
    "# df_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Utility Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Original code from https://www.kaggle.com/aitude/ashrae-missing-weather-data-handling by @aitude\n",
    "\n",
    "def fill_weather_dataset(weather_df):\n",
    "    \n",
    "    # Find Missing Dates\n",
    "    time_format = \"%Y-%m-%d %H:%M:%S\"\n",
    "    start_date = datetime.datetime.strptime(weather_df['timestamp'].min(),time_format)\n",
    "    end_date = datetime.datetime.strptime(weather_df['timestamp'].max(),time_format)\n",
    "    total_hours = int(((end_date - start_date).total_seconds() + 3600) / 3600)\n",
    "    hours_list = [(end_date - datetime.timedelta(hours=x)).strftime(time_format) for x in range(total_hours)]\n",
    "    \n",
    "    missing_hours = []\n",
    "    for site_id in range(16):\n",
    "        site_hours = np.array(weather_df[weather_df['site_id'] == site_id]['timestamp'])\n",
    "        new_rows = pd.DataFrame(np.setdiff1d(hours_list,site_hours),columns=['timestamp'])\n",
    "        new_rows['site_id'] = site_id\n",
    "        weather_df = pd.concat([weather_df,new_rows])\n",
    "\n",
    "        weather_df = weather_df.reset_index(drop=True)           \n",
    "\n",
    "    # Add new Features\n",
    "    weather_df[\"timestamp\"] = pd.to_datetime(weather_df[\"timestamp\"])\n",
    "    weather_df[\"day\"] = weather_df[\"timestamp\"].dt.day\n",
    "    weather_df[\"week\"] = weather_df[\"timestamp\"].dt.week\n",
    "    weather_df[\"month\"] = weather_df[\"timestamp\"].dt.month\n",
    "    \n",
    "    # Reset Index for Fast Update\n",
    "    weather_df = weather_df.set_index(['site_id','day','month'])\n",
    "\n",
    "    air_temperature_filler = pd.DataFrame(weather_df.groupby(['site_id','day','month'])['air_temperature'].mean(),columns=[\"air_temperature\"])\n",
    "    weather_df.update(air_temperature_filler,overwrite=False)\n",
    "\n",
    "    # Step 1\n",
    "    cloud_coverage_filler = weather_df.groupby(['site_id','day','month'])['cloud_coverage'].mean()\n",
    "    # Step 2\n",
    "    cloud_coverage_filler = pd.DataFrame(cloud_coverage_filler.fillna(method='ffill'),columns=[\"cloud_coverage\"])\n",
    "\n",
    "    weather_df.update(cloud_coverage_filler,overwrite=False)\n",
    "\n",
    "    due_temperature_filler = pd.DataFrame(weather_df.groupby(['site_id','day','month'])['dew_temperature'].mean(),columns=[\"dew_temperature\"])\n",
    "    weather_df.update(due_temperature_filler,overwrite=False)\n",
    "\n",
    "    # Step 1\n",
    "    sea_level_filler = weather_df.groupby(['site_id','day','month'])['sea_level_pressure'].mean()\n",
    "    # Step 2\n",
    "    sea_level_filler = pd.DataFrame(sea_level_filler.fillna(method='ffill'),columns=['sea_level_pressure'])\n",
    "\n",
    "    weather_df.update(sea_level_filler,overwrite=False)\n",
    "\n",
    "    wind_direction_filler =  pd.DataFrame(weather_df.groupby(['site_id','day','month'])['wind_direction'].mean(),columns=['wind_direction'])\n",
    "    weather_df.update(wind_direction_filler,overwrite=False)\n",
    "\n",
    "    wind_speed_filler =  pd.DataFrame(weather_df.groupby(['site_id','day','month'])['wind_speed'].mean(),columns=['wind_speed'])\n",
    "    weather_df.update(wind_speed_filler,overwrite=False)\n",
    "\n",
    "    # Step 1\n",
    "    precip_depth_filler = weather_df.groupby(['site_id','day','month'])['precip_depth_1_hr'].mean()\n",
    "    # Step 2\n",
    "    precip_depth_filler = pd.DataFrame(precip_depth_filler.fillna(method='ffill'),columns=['precip_depth_1_hr'])\n",
    "\n",
    "    weather_df.update(precip_depth_filler,overwrite=False)\n",
    "\n",
    "    weather_df = weather_df.reset_index()\n",
    "    weather_df = weather_df.drop(['day','week','month'],axis=1)\n",
    "        \n",
    "    return weather_df\n",
    "\n",
    "# Original code from https://www.kaggle.com/gemartin/load-data-reduce-memory-usage by @gemartin\n",
    "\n",
    "from pandas.api.types import is_datetime64_any_dtype as is_datetime\n",
    "from pandas.api.types import is_categorical_dtype\n",
    "\n",
    "def reduce_mem_usage(df, use_float16=False):\n",
    "    \"\"\"\n",
    "    Iterate through all the columns of a dataframe and modify the data type to reduce memory usage.        \n",
    "    \"\"\"\n",
    "    \n",
    "    start_mem = df.memory_usage().sum() / 1024**2\n",
    "    print(\"Memory usage of dataframe is {:.2f} MB\".format(start_mem))\n",
    "    \n",
    "    for col in df.columns:\n",
    "        if is_datetime(df[col]) or is_categorical_dtype(df[col]):\n",
    "            continue\n",
    "        col_type = df[col].dtype\n",
    "        \n",
    "        if col_type != object:\n",
    "            c_min = df[col].min()\n",
    "            c_max = df[col].max()\n",
    "            if str(col_type)[:3] == \"int\":\n",
    "                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:\n",
    "                    df[col] = df[col].astype(np.int8)\n",
    "                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:\n",
    "                    df[col] = df[col].astype(np.int16)\n",
    "                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:\n",
    "                    df[col] = df[col].astype(np.int32)\n",
    "                elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:\n",
    "                    df[col] = df[col].astype(np.int64)  \n",
    "            else:\n",
    "                if use_float16 and c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:\n",
    "                    df[col] = df[col].astype(np.float16)\n",
    "                elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:\n",
    "                    df[col] = df[col].astype(np.float32)\n",
    "                else:\n",
    "                    df[col] = df[col].astype(np.float64)\n",
    "        else:\n",
    "            df[col] = df[col].astype(\"category\")\n",
    "\n",
    "    end_mem = df.memory_usage().sum() / 1024**2\n",
    "    print(\"Memory usage after optimization is: {:.2f} MB\".format(end_mem))\n",
    "    print(\"Decreased by {:.1f}%\".format(100 * (start_mem - end_mem) / start_mem))\n",
    "    \n",
    "    return df\n",
    "\n",
    "\n",
    "def features_engineering(df):\n",
    "    \n",
    "    # Sort by timestamp\n",
    "    df.sort_values(\"timestamp\")\n",
    "    df.reset_index(drop=True)\n",
    "    \n",
    "    # Add more features\n",
    "    df[\"timestamp\"] = pd.to_datetime(df[\"timestamp\"],format=\"%Y-%m-%d %H:%M:%S\")\n",
    "    df[\"hour\"] = df[\"timestamp\"].dt.hour\n",
    "    df[\"weekday\"] = df[\"timestamp\"].dt.weekday\n",
    "    \n",
    "    df['square_feet'] =  np.log1p(df['square_feet'])\n",
    "    df['sm'] = df['site_id'].apply(lambda x: str(x)) + '_' + df['meter'].apply(lambda x: str(x))\n",
    "    \n",
    "    \n",
    "    # Remove Unused Columns\n",
    "    drop = [\"timestamp\",'site_id',\"sea_level_pressure\", \"wind_direction\", \"wind_speed\",\"year_built\",\"floor_count\"]\n",
    "    df = df.drop(drop, axis=1)\n",
    "    gc.collect()\n",
    "    \n",
    "    # Encode Categorical Data\n",
    "    le = LabelEncoder()\n",
    "    df[\"primary_use\"] = le.fit_transform(df[\"primary_use\"])\n",
    "    \n",
    "    # reduce memory\n",
    "    df = reduce_mem_usage(df, use_float16=True)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rmse(ytrue, ypred):\n",
    "    return np.sqrt(np.mean(np.square(ypred - ytrue), axis=0))\n",
    "def rmsle(ytrue, ypred):\n",
    "    return np.sqrt(np.mean(np.square(np.log1p(ypred) - np.log1p(ytrue)), axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fill Weather Information\n",
    "\n",
    "I'm using [this kernel](https://www.kaggle.com/aitude/ashrae-missing-weather-data-handling) to handle missing weather information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "weather_train['timestamp'] = weather_train['timestamp'].astype('str')\n",
    "weather_train = fill_weather_dataset(weather_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Memory Reduction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "_kg_hide-output": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is 426.99 MB\n",
      "Memory usage after optimization is: 426.99 MB\n",
      "Decreased by 0.0%\n",
      "Memory usage of dataframe is 0.03 MB\n",
      "Memory usage after optimization is: 0.02 MB\n",
      "Decreased by 36.7%\n",
      "Memory usage of dataframe is 5.90 MB\n",
      "Memory usage after optimization is: 3.08 MB\n",
      "Decreased by 47.7%\n"
     ]
    }
   ],
   "source": [
    "df_train = reduce_mem_usage(df_train,use_float16=True)\n",
    "building = reduce_mem_usage(building,use_float16=True)\n",
    "weather_train = reduce_mem_usage(weather_train,use_float16=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Merge Data\n",
    "\n",
    "We need to add building and weather information into training dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train = df_train.merge(building, left_on='building_id',right_on='building_id',how='left')\n",
    "df_train = df_train.merge(weather_train,how='left',left_on=['site_id','timestamp'],right_on=['site_id','timestamp'])\n",
    "del weather_train\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Features Engineering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is 1169.58 MB\n",
      "Memory usage after optimization is: 538.38 MB\n",
      "Decreased by 54.0%\n",
      "Wall time: 21.1 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "df_train = features_engineering(df_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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>building_id</th>\n",
       "      <th>meter</th>\n",
       "      <th>meter_reading</th>\n",
       "      <th>primary_use</th>\n",
       "      <th>square_feet</th>\n",
       "      <th>air_temperature</th>\n",
       "      <th>cloud_coverage</th>\n",
       "      <th>dew_temperature</th>\n",
       "      <th>precip_depth_1_hr</th>\n",
       "      <th>hour</th>\n",
       "      <th>weekday</th>\n",
       "      <th>sm</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>105</td>\n",
       "      <td>0</td>\n",
       "      <td>23.303600</td>\n",
       "      <td>0</td>\n",
       "      <td>10.835938</td>\n",
       "      <td>3.800781</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.400391</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>1_0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>106</td>\n",
       "      <td>3</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0</td>\n",
       "      <td>8.585938</td>\n",
       "      <td>3.800781</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.400391</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>1_3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>108</td>\n",
       "      <td>0</td>\n",
       "      <td>91.265297</td>\n",
       "      <td>0</td>\n",
       "      <td>11.312500</td>\n",
       "      <td>3.800781</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.400391</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>1_0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>109</td>\n",
       "      <td>0</td>\n",
       "      <td>80.930000</td>\n",
       "      <td>0</td>\n",
       "      <td>10.953125</td>\n",
       "      <td>3.800781</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.400391</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>1_0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>109</td>\n",
       "      <td>3</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0</td>\n",
       "      <td>10.953125</td>\n",
       "      <td>3.800781</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.400391</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>1_3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   building_id  meter  meter_reading  primary_use  square_feet  \\\n",
       "0          105      0      23.303600            0    10.835938   \n",
       "1          106      3       0.000000            0     8.585938   \n",
       "2          108      0      91.265297            0    11.312500   \n",
       "3          109      0      80.930000            0    10.953125   \n",
       "4          109      3       0.000000            0    10.953125   \n",
       "\n",
       "   air_temperature  cloud_coverage  dew_temperature  precip_depth_1_hr  hour  \\\n",
       "0         3.800781             0.0         2.400391                0.0     0   \n",
       "1         3.800781             0.0         2.400391                0.0     0   \n",
       "2         3.800781             0.0         2.400391                0.0     0   \n",
       "3         3.800781             0.0         2.400391                0.0     0   \n",
       "4         3.800781             0.0         2.400391                0.0     0   \n",
       "\n",
       "   weekday   sm  \n",
       "0        4  1_0  \n",
       "1        4  1_3  \n",
       "2        4  1_0  \n",
       "3        4  1_0  \n",
       "4        4  1_3  "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Features & Target Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = np.log1p(df_train[\"meter_reading\"])\n",
    "X_train = df_train.drop('meter_reading', axis = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  KFOLD LIGHTGBM Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training until validation scores don't improve for 50 rounds\n",
      "[25]\ttraining's rmse: 0.959242\tvalid_1's rmse: 1.13222\n",
      "[50]\ttraining's rmse: 0.753433\tvalid_1's rmse: 1.00078\n",
      "[75]\ttraining's rmse: 0.70235\tvalid_1's rmse: 0.984328\n",
      "[100]\ttraining's rmse: 0.678344\tvalid_1's rmse: 0.981712\n",
      "[125]\ttraining's rmse: 0.661012\tvalid_1's rmse: 0.982124\n",
      "[150]\ttraining's rmse: 0.647988\tvalid_1's rmse: 0.983433\n",
      "Early stopping, best iteration is:\n",
      "[111]\ttraining's rmse: 0.670203\tvalid_1's rmse: 0.981538\n",
      "Training until validation scores don't improve for 50 rounds\n",
      "[25]\ttraining's rmse: 0.998146\tvalid_1's rmse: 1.08621\n",
      "[50]\ttraining's rmse: 0.802723\tvalid_1's rmse: 0.912788\n",
      "[75]\ttraining's rmse: 0.754555\tvalid_1's rmse: 0.874042\n",
      "[100]\ttraining's rmse: 0.729886\tvalid_1's rmse: 0.861562\n",
      "[125]\ttraining's rmse: 0.710284\tvalid_1's rmse: 0.85367\n",
      "[150]\ttraining's rmse: 0.696019\tvalid_1's rmse: 0.849697\n",
      "[175]\ttraining's rmse: 0.685401\tvalid_1's rmse: 0.848105\n",
      "[200]\ttraining's rmse: 0.678617\tvalid_1's rmse: 0.847475\n",
      "[225]\ttraining's rmse: 0.67223\tvalid_1's rmse: 0.847467\n",
      "[250]\ttraining's rmse: 0.666819\tvalid_1's rmse: 0.848079\n",
      "Early stopping, best iteration is:\n",
      "[213]\ttraining's rmse: 0.675514\tvalid_1's rmse: 0.847189\n",
      "Training until validation scores don't improve for 50 rounds\n",
      "[25]\ttraining's rmse: 0.970481\tvalid_1's rmse: 1.09526\n",
      "[50]\ttraining's rmse: 0.75459\tvalid_1's rmse: 0.960302\n",
      "[75]\ttraining's rmse: 0.697987\tvalid_1's rmse: 0.945161\n",
      "[100]\ttraining's rmse: 0.670937\tvalid_1's rmse: 0.94464\n",
      "[125]\ttraining's rmse: 0.650737\tvalid_1's rmse: 0.945253\n",
      "Early stopping, best iteration is:\n",
      "[88]\ttraining's rmse: 0.681786\tvalid_1's rmse: 0.943987\n",
      "Wall time: 11min 18s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "categorical_features = ['sm', \"building_id\", \"meter\", \"primary_use\", \"weekday\"]\n",
    "params = {\n",
    "    \"objective\": \"regression\",\n",
    "    \"boosting\": \"gbdt\",\n",
    "    \"num_leaves\": 1280,\n",
    "    \"learning_rate\": 0.05,\n",
    "    \"feature_fraction\": 0.85,\n",
    "    \"reg_lambda\": 2,\n",
    "    \"metric\": \"rmse\",\n",
    "}\n",
    "\n",
    "pred_L1 = []\n",
    "valid_L1 = []\n",
    "seed = None\n",
    "kf = KFold(n_splits=3, random_state=seed)\n",
    "\n",
    "models = []\n",
    "for train_index,test_index in kf.split(X_train):\n",
    "    train_features = X_train.loc[train_index]\n",
    "    train_target = y_train.loc[train_index]\n",
    "    \n",
    "    test_features = X_train.loc[test_index]\n",
    "    test_target = y_train.loc[test_index]\n",
    "    \n",
    "    d_training = lgb.Dataset(train_features, label=train_target,categorical_feature=categorical_features, free_raw_data=False)\n",
    "    d_test = lgb.Dataset(test_features, label=test_target,categorical_feature=categorical_features, free_raw_data=False)\n",
    "    \n",
    "    model = lgb.train(params, train_set=d_training, num_boost_round=1000, valid_sets=[d_training,d_test], verbose_eval=25, early_stopping_rounds=50)\n",
    "    models.append(model)\n",
    "    pred_L1.append(model.predict(test_features))\n",
    "    valid_L1.append(test_target)\n",
    "    \n",
    "    del train_features, train_target, test_features, test_target, d_training, d_test\n",
    "    gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del X_train, y_train\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Important Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for model in models:\n",
    "    lgb.plot_importance(model)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Test Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is 437.43 MB\n",
      "Memory usage after optimization is: 437.43 MB\n",
      "Decreased by 0.0%\n"
     ]
    }
   ],
   "source": [
    "df_test = pd.read_feather(root/'test.feather')\n",
    "\n",
    "row_ids = df_test[\"row_id\"]\n",
    "df_test.drop(\"row_id\", axis=1, inplace=True)\n",
    "df_test = reduce_mem_usage(df_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df_test['hour'] = df_test['timestamp'].dt.hour\n",
    "# df_test['weekday'] = df_test['timestamp'].dt.weekday\n",
    "# df_test['bm'] = df_test['building_id'].apply(lambda x: str(x)) + '_' + df_test['meter'].apply(lambda x: str(x))\n",
    "# df_test = df_test.merge(bm, right_index=True, left_on=bm_cols, how='left')\n",
    "# df_test.drop('bm', axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Merge Building Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = df_test.merge(building,left_on='building_id',right_on='building_id',how='left')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fill Weather Information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is 11.76 MB\n",
      "Memory usage after optimization is: 9.89 MB\n",
      "Decreased by 15.9%\n"
     ]
    }
   ],
   "source": [
    "weather_test['timestamp'] = weather_test['timestamp'].astype('str')\n",
    "weather_test = fill_weather_dataset(weather_test)\n",
    "weather_test = reduce_mem_usage(weather_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Merge Weather Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test = df_test.merge(weather_test,how='left',on=['timestamp','site_id'])\n",
    "del weather_test\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Features Engineering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is 2664.32 MB\n",
      "Memory usage after optimization is: 994.15 MB\n",
      "Decreased by 62.7%\n"
     ]
    }
   ],
   "source": [
    "df_test = features_engineering(df_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 41697600 entries, 0 to 41697599\n",
      "Data columns (total 11 columns):\n",
      " #   Column             Dtype   \n",
      "---  ------             -----   \n",
      " 0   building_id        int16   \n",
      " 1   meter              int8    \n",
      " 2   primary_use        int8    \n",
      " 3   square_feet        float16 \n",
      " 4   air_temperature    float16 \n",
      " 5   cloud_coverage     float16 \n",
      " 6   dew_temperature    float16 \n",
      " 7   precip_depth_1_hr  float16 \n",
      " 8   hour               int8    \n",
      " 9   weekday            int8    \n",
      " 10  sm                 category\n",
      "dtypes: category(1), float16(5), int16(1), int8(4)\n",
      "memory usage: 994.1 MB\n"
     ]
    }
   ],
   "source": [
    "df_test.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "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>building_id</th>\n",
       "      <th>meter</th>\n",
       "      <th>primary_use</th>\n",
       "      <th>square_feet</th>\n",
       "      <th>air_temperature</th>\n",
       "      <th>cloud_coverage</th>\n",
       "      <th>dew_temperature</th>\n",
       "      <th>precip_depth_1_hr</th>\n",
       "      <th>hour</th>\n",
       "      <th>weekday</th>\n",
       "      <th>sm</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>8.914062</td>\n",
       "      <td>17.796875</td>\n",
       "      <td>4.0</td>\n",
       "      <td>11.703125</td>\n",
       "      <td>0.282715</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>0_0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>7.910156</td>\n",
       "      <td>17.796875</td>\n",
       "      <td>4.0</td>\n",
       "      <td>11.703125</td>\n",
       "      <td>0.282715</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>0_0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>8.593750</td>\n",
       "      <td>17.796875</td>\n",
       "      <td>4.0</td>\n",
       "      <td>11.703125</td>\n",
       "      <td>0.282715</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>0_0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>10.070312</td>\n",
       "      <td>17.796875</td>\n",
       "      <td>4.0</td>\n",
       "      <td>11.703125</td>\n",
       "      <td>0.282715</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>0_0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>11.664062</td>\n",
       "      <td>17.796875</td>\n",
       "      <td>4.0</td>\n",
       "      <td>11.703125</td>\n",
       "      <td>0.282715</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>0_0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   building_id  meter  primary_use  square_feet  air_temperature  \\\n",
       "0            0      0            0     8.914062        17.796875   \n",
       "1            1      0            0     7.910156        17.796875   \n",
       "2            2      0            0     8.593750        17.796875   \n",
       "3            3      0            0    10.070312        17.796875   \n",
       "4            4      0            0    11.664062        17.796875   \n",
       "\n",
       "   cloud_coverage  dew_temperature  precip_depth_1_hr  hour  weekday   sm  \n",
       "0             4.0        11.703125           0.282715     0        6  0_0  \n",
       "1             4.0        11.703125           0.282715     0        6  0_0  \n",
       "2             4.0        11.703125           0.282715     0        6  0_0  \n",
       "3             4.0        11.703125           0.282715     0        6  0_0  \n",
       "4             4.0        11.703125           0.282715     0        6  0_0  "
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d80e531e170f4d9680477213497c20a0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=3.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Wall time: 7min 49s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "pred = []\n",
    "for model in tqdm(models):\n",
    "    if  pred == []:\n",
    "        pred = np.expm1(model.predict(df_test, num_iteration=model.best_iteration)) / len(models)\n",
    "    else:\n",
    "        pred += np.expm1(model.predict(df_test, num_iteration=model.best_iteration)) / len(models)\n",
    "    del model\n",
    "    gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "submission = pd.DataFrame({\"row_id\": row_ids, \"meter_reading\": np.clip(pred, 0, a_max=None)})\n",
    "gc.collect()\n",
    "submission['meter_reading'] = submission['meter_reading'].astype('float32')\n",
    "submission['row_id'] = submission['row_id'].astype('int32')\n",
    "submission.to_csv(\"submission_baseline.csv\", index=False, chunksize=25000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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>row_id</th>\n",
       "      <th>meter_reading</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>136.128433</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>74.436104</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>9.900030</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>255.450378</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>952.865906</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   row_id  meter_reading\n",
       "0       0     136.128433\n",
       "1       1      74.436104\n",
       "2       2       9.900030\n",
       "3       3     255.450378\n",
       "4       4     952.865906"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "submission.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "submission mean: 352.7842\n",
      "submission std: 1860.7054\n",
      "submission min: 0.0000\n",
      "submission max: 634506.6875\n"
     ]
    }
   ],
   "source": [
    "print(f\"submission mean: {submission['meter_reading'].mean():.4f}\")\n",
    "print(f\"submission std: {submission['meter_reading'].std():.4f}\")\n",
    "print(f\"submission min: {submission['meter_reading'].min():.4f}\")\n",
    "print(f\"submission max: {submission['meter_reading'].max():.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEDCAYAAADQunSaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAP2ElEQVR4nO3dbYxcV33H8e+vifsAoUormyb1Q0yRgULUkNTKA5FQCkVK0gj3Ba0CFChFtUBAQwVteZDCuwqpFS1giGWRNEQNQRTS1KrMQ0QjJVQkiuPmyXFTLGjJErcxCcSkQQKr/76Ya1jWuzsz6/HemZPvRxrN3HvP3Plrtfubs2fOPZOqQpLUpp/puwBJ0sljyEtSwwx5SWqYIS9JDTPkJalhhrwkNazXkE9yXZLHkjw4YvvfT/JQkv1JPn2y65OkWZc+58kneTnwFHBDVZ09pO0W4LPAK6rqu0meW1WPrUadkjSreu3JV9XtwBPz9yV5fpIvJrknyR1JXtQd+mPg41X13e65BrwkDTGNY/K7gHdW1W8C7wE+0e1/AfCCJP+a5M4kl/ZWoSTNiFP7LmC+JKcBLwP+Icmx3T/X3Z8KbAEuATYAdyQ5u6q+t8plStLMmKqQZ/Cfxfeq6qWLHJsD7qyqHwHfTPIwg9C/exXrk6SZMlXDNVV1hEGA/x5ABs7pDt8C/Fa3fy2D4Ztv9FGnJM2KvqdQ3gR8DXhhkrkkbwFeD7wlyX3AfmBb1/xLwONJHgJuA/6sqh7vo25JmhW9TqGUJJ1cUzVcI0marN4+eF27dm1t3ry5r5eXpJl0zz33fKeq1o3avreQ37x5M3v37u3r5SVpJiX5r3HaO1wjSQ0z5CWpYYa8JDXMkJekhhnyktQwQ16SGmbIS1LDDHlJapghL0kNm7b15NWAT9/1rUX3v+6CTatciSR78pLUMENekhrmcI1WbKlhGUnTw568JDXMkJekhhnyktQwQ16SGmbIS1LDhoZ8ko1JbktyIMn+JFct0uaSJE8mube7XX1yypUkjWOUKZRHgXdX1b4kzwHuSXJrVT20oN0dVXXF5EuUJK3U0J58VR2qqn3d4+8DB4D1J7swSdKJG2tMPslm4FzgrkUOX5TkviRfSPKSJZ6/PcneJHsPHz48frWSpLGMfMVrktOAzwPvqqojCw7vA86qqqeSXA7cAmxZeI6q2gXsAti6dWuttGi1xQXNpJNnpJ58kjUMAv7Gqrp54fGqOlJVT3WP9wBrkqydaKWSpLGNMrsmwLXAgar68BJtzujakeT87ryPT7JQSdL4RhmuuRh4A/BAknu7fe8HNgFU1U7gNcDbkhwFfgBcWVUOx0hSz4aGfFV9FciQNjuAHZMqStPF1Sal2eVSw1o1vllIq89lDSSpYYa8JDXMkJekhhnyktQwQ16SGmbIS1LDDHlJapghL0kNM+QlqWGGvCQ1zGUN9GMuOyC1x568JDXMkJekhhnyktQwQ16SGmbIS1LDDHlJapghL0kNM+QlqWGGvCQ1zJCXpIYZ8pLUMENekhpmyEtSwwx5SWqYIS9JDTPkJalhfmnIM5BfDiI9c9iTl6SGDQ35JBuT3JbkQJL9Sa5apE2SfDTJwST3Jznv5JQrSRrHKMM1R4F3V9W+JM8B7klya1U9NK/NZcCW7nYBcE13L63YUsNKr7tg0ypXIs2uoT35qjpUVfu6x98HDgDrFzTbBtxQA3cCpyc5c+LVSpLGMtaYfJLNwLnAXQsOrQcembc9x/FvBCTZnmRvkr2HDx8es1RJ0rhGDvkkpwGfB95VVUcWHl7kKXXcjqpdVbW1qrauW7duvEolSWMbKeSTrGEQ8DdW1c2LNJkDNs7b3gA8euLlSZJOxCizawJcCxyoqg8v0Ww38MZuls2FwJNVdWiCdUqSVmCU2TUXA28AHkhyb7fv/cAmgKraCewBLgcOAk8Db554pZKksQ0N+ar6KouPuc9vU8DbJ1WUJGkyvOJVkhpmyEtSwwx5SWqYIS9JDXOp4Rnn+i6SlmNPXpIaZk++UX4xiCSwJy9JTTPkJalhDtdo5vhhszQ6e/KS1DBDXpIaZshLUsMMeUlqmB+8qhl+ICsdz568JDXMkJekhhnyktQwQ16SGmbIS1LDDHlJapghL0kNM+QlqWGGvCQ1zJCXpIYZ8pLUMENekhpmyEtSwwx5SWqYIS9JDRsa8kmuS/JYkgeXOH5JkieT3Nvdrp58mZKklRjlS0OuB3YANyzT5o6qumIiFUmSJmZoT76qbgeeWIVaJEkTNqkx+YuS3JfkC0leslSjJNuT7E2y9/DhwxN6aUnSUiYR8vuAs6rqHOBjwC1LNayqXVW1taq2rlu3bgIvLUlazgl/kXdVHZn3eE+STyRZW1XfOdFzS5Ow1Bd8g1/yrfadcE8+yRlJ0j0+vzvn4yd6XknSiRvak09yE3AJsDbJHPBBYA1AVe0EXgO8LclR4AfAlVVVJ61iSdLIhoZ8Vb12yPEdDKZYSpKmzAmPyWt1LDeuLElLcVkDSWqYIS9JDTPkJalhhrwkNcyQl6SGGfKS1DBDXpIaZshLUsMMeUlqmCEvSQ0z5CWpYYa8JDXMkJekhhnyktQwQ16SGmbIS1LDDHlJapghL0kNM+QlqWGGvCQ1zJCXpIYZ8pLUMENekhp2at8F6Kd9+q5v9V2CpIYY8npGW+pN9XUXbFrlSqSTw+EaSWqYIS9JDTPkJalhhrwkNWxoyCe5LsljSR5c4niSfDTJwST3Jzlv8mVKklZilNk11wM7gBuWOH4ZsKW7XQBc092fNMtNM3RWhCT9xNCefFXdDjyxTJNtwA01cCdwepIzJ1WgJGnlJjEmvx54ZN72XLfvOEm2J9mbZO/hw4cn8NKSpOVMIuSzyL5arGFV7aqqrVW1dd26dRN4aUnSciYR8nPAxnnbG4BHJ3BeSdIJmsSyBruBdyT5DIMPXJ+sqkMTOG/TXKNmurncgVoxNOST3ARcAqxNMgd8EFgDUFU7gT3A5cBB4GngzSerWEnSeIaGfFW9dsjxAt4+sYokSRPjFa+S1DBDXpIa5nryJ5kfsErqkz15SWqYIS9JDTPkJalhhrwkNcwPXifED1glTSN78pLUMENekhpmyEtSwwx5SWqYIS9JDTPkJalhhrwkNcx58tIY/MYozRp78pLUMENekhrmcM2YXL5A0iyxJy9JDTPkJalhhrwkNcyQl6SGGfKS1DBDXpIa5hRKaQK8ElbTyp68JDXMkJekhhnyktSw5sbkHRuVpJ8YqSef5NIkDyc5mOS9ixy/JMmTSe7tbldPvlRJ0riG9uSTnAJ8HHgVMAfcnWR3VT20oOkdVXXFSahRkrRCowzXnA8crKpvACT5DLANWBjyTXG1SUktGCXk1wOPzNueAy5YpN1FSe4DHgXeU1X7FzZIsh3YDrBp03SMkRvmklo2yph8FtlXC7b3AWdV1TnAx4BbFjtRVe2qqq1VtXXdunVjFSpJGt8oIT8HbJy3vYFBb/3HqupIVT3VPd4DrEmydmJVSpJWZJSQvxvYkuR5SX4WuBLYPb9BkjOSpHt8fnfexyddrCRpPEPH5KvqaJJ3AF8CTgGuq6r9Sd7aHd8JvAZ4W5KjwA+AK6tq4ZBOrxx7l/RMNNLFUN0QzJ4F+3bOe7wD2DHZ0iRJJ8plDSSpYc0tayBNE5fZUN8MeakHhr9Wi8M1ktQwQ16SGmbIS1LDDHlJapghL0kNM+QlqWGGvCQ1zHny0hRx/rwmzZ68JDXMkJekhhnyktQwQ16SGmbIS1LDDHlJaphTKKUZ4NRKrZQ9eUlqmCEvSQ0z5CWpYYa8JDXMkJekhhnyktQwp1BKM8yplRrGnrwkNcyQl6SGOVwjNchhHB1jT16SGmbIS1LDRhquSXIp8BHgFOCTVfWhBcfTHb8ceBr4w6raN+FaJZ2gpYZxluMQz2wbGvJJTgE+DrwKmAPuTrK7qh6a1+wyYEt3uwC4pruXNONW8sawGN8s+jFKT/584GBVfQMgyWeAbcD8kN8G3FBVBdyZ5PQkZ1bVoYlXLGkm+WbRj1FCfj3wyLztOY7vpS/WZj3wUyGfZDuwvdt8KsnDY1X7E2uB76zwuX2y7tUzizXDbNa9qjW/fnKnmtWf9VnjPGGUkM8i+2oFbaiqXcCuEV5z+YKSvVW19UTPs9qse/XMYs0wm3XPYs0wm3V3NW8e5zmjzK6ZAzbO294APLqCNpKkVTZKyN8NbEnyvCQ/C1wJ7F7QZjfwxgxcCDzpeLwk9W/ocE1VHU3yDuBLDKZQXldV+5O8tTu+E9jDYPrkQQZTKN988koGJjDk0xPrXj2zWDPMZt2zWDPMZt1j15zBhBhJUou84lWSGmbIS1LDZi7kk1ya5OEkB5O8t+96RpFkY5LbkhxIsj/JVX3XNKokpyT5tyT/3Hcto+ouxvtckn/vfuYX9V3TMEn+tPvdeDDJTUl+vu+aFpPkuiSPJXlw3r5fTnJrkq9397/UZ42LWaLuv+p+R+5P8o9JTu+xxOMsVvO8Y+9JUknWDjvPTIX8vCUWLgNeDLw2yYv7rWokR4F3V9WvAxcCb5+RugGuAg70XcSYPgJ8sapeBJzDlNefZD3wJ8DWqjqbwQSHK/utaknXA5cu2Pde4CtVtQX4Src9ba7n+LpvBc6uqt8A/gN432oXNcT1HF8zSTYyWGZmpEuIZyrkmbfEQlX9EDi2xMJUq6pDxxZsq6rvMwid9f1WNVySDcDvAJ/su5ZRJflF4OXAtQBV9cOq+l6vRY3mVOAXkpwKPIspvc6kqm4Hnliwexvwqe7xp4DfXc2aRrFY3VX15ao62m3eyeD6nqmxxM8a4G+AP2eRC04XM2shv9TyCTMjyWbgXOCunksZxd8y+GX6v57rGMevAYeBv+uGmT6Z5Nl9F7Wcqvo28NcMemaHGFxn8uV+qxrLrxy7Lqa7f27P9azEHwFf6LuIYZK8Gvh2Vd036nNmLeRHWj5hWiU5Dfg88K6qOtJ3PctJcgXwWFXd03ctYzoVOA+4pqrOBf6X6Rw++LFuDHsb8DzgV4FnJ/mDfqt65kjyAQZDqjf2XctykjwL+ABw9TjPm7WQn9nlE5KsYRDwN1bVzX3XM4KLgVcn+U8Gw2KvSPL3/ZY0kjlgrqqO/af0OQahP81+G/hmVR2uqh8BNwMv67mmcfxPkjMBuvvHeq5nZEneBFwBvL6m/6Kh5zPoCNzX/V1uAPYlOWO5J81ayI+yxMLU6b5U5VrgQFV9uO96RlFV76uqDd1iSFcC/1JVU9+7rKr/Bh5J8sJu1yv56WWxp9G3gAuTPKv7XXklU/5h8QK7gTd1j98E/FOPtYys+zKkvwBeXVVP913PMFX1QFU9t6o2d3+Xc8B53e/8kmYq5LsPSY4tsXAA+GxV7e+3qpFcDLyBQW/43u52ed9FNeydwI1J7gdeCvxlv+Usr/uv43PAPuABBn+XU3nJfZKbgK8BL0wyl+QtwIeAVyX5OoNZHx9a7hx9WKLuHcBzgFu7v8mdvRa5wBI1j3+e6f8PRZK0UjPVk5ckjceQl6SGGfKS1DBDXpIaZshLUsMMeUlqmCEvSQ37fxY2NMB6bxpRAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(np.log1p(submission['meter_reading'].values), kde=False);\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Submission Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is 954.38 MB\n",
      "Memory usage after optimization is: 357.89 MB\n",
      "Decreased by 62.5%\n"
     ]
    },
    {
     "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>row_id</th>\n",
       "      <th>meter_reading</th>\n",
       "      <th>Usage</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>173.369995</td>\n",
       "      <td>Public</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>53.512699</td>\n",
       "      <td>Public</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>6.143000</td>\n",
       "      <td>Public</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>101.700996</td>\n",
       "      <td>Public</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>1141.239990</td>\n",
       "      <td>Public</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41697595</th>\n",
       "      <td>41697595</td>\n",
       "      <td>-9999.000000</td>\n",
       "      <td>Ignored</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41697596</th>\n",
       "      <td>41697596</td>\n",
       "      <td>-9999.000000</td>\n",
       "      <td>Ignored</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41697597</th>\n",
       "      <td>41697597</td>\n",
       "      <td>-9999.000000</td>\n",
       "      <td>Ignored</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41697598</th>\n",
       "      <td>41697598</td>\n",
       "      <td>-9999.000000</td>\n",
       "      <td>Ignored</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41697599</th>\n",
       "      <td>41697599</td>\n",
       "      <td>-9999.000000</td>\n",
       "      <td>Ignored</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>41697600 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "            row_id  meter_reading    Usage\n",
       "0                0     173.369995   Public\n",
       "1                1      53.512699   Public\n",
       "2                2       6.143000   Public\n",
       "3                3     101.700996   Public\n",
       "4                4    1141.239990   Public\n",
       "...            ...            ...      ...\n",
       "41697595  41697595   -9999.000000  Ignored\n",
       "41697596  41697596   -9999.000000  Ignored\n",
       "41697597  41697597   -9999.000000  Ignored\n",
       "41697598  41697598   -9999.000000  Ignored\n",
       "41697599  41697599   -9999.000000  Ignored\n",
       "\n",
       "[41697600 rows x 3 columns]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_solution = pd.read_csv(os.path.join(root, 'solution.csv'))\n",
    "df_solution = reduce_mem_usage(df_solution, use_float16=True)\n",
    "df_solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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>row_id</th>\n",
       "      <th>building_id</th>\n",
       "      <th>meter</th>\n",
       "      <th>timestamp</th>\n",
       "      <th>meter_reading</th>\n",
       "      <th>Usage</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2017-01-01 00:00:00</td>\n",
       "      <td>173.369995</td>\n",
       "      <td>Public</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>2017-01-01 00:00:00</td>\n",
       "      <td>53.512699</td>\n",
       "      <td>Public</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>2017-01-01 00:00:00</td>\n",
       "      <td>6.143000</td>\n",
       "      <td>Public</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>2017-01-01 00:00:00</td>\n",
       "      <td>101.700996</td>\n",
       "      <td>Public</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>2017-01-01 00:00:00</td>\n",
       "      <td>1141.239990</td>\n",
       "      <td>Public</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41697595</th>\n",
       "      <td>41697595</td>\n",
       "      <td>1444</td>\n",
       "      <td>0</td>\n",
       "      <td>2018-05-09 07:00:00</td>\n",
       "      <td>-9999.000000</td>\n",
       "      <td>Ignored</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41697596</th>\n",
       "      <td>41697596</td>\n",
       "      <td>1445</td>\n",
       "      <td>0</td>\n",
       "      <td>2018-05-09 07:00:00</td>\n",
       "      <td>-9999.000000</td>\n",
       "      <td>Ignored</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41697597</th>\n",
       "      <td>41697597</td>\n",
       "      <td>1446</td>\n",
       "      <td>0</td>\n",
       "      <td>2018-05-09 07:00:00</td>\n",
       "      <td>-9999.000000</td>\n",
       "      <td>Ignored</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41697598</th>\n",
       "      <td>41697598</td>\n",
       "      <td>1447</td>\n",
       "      <td>0</td>\n",
       "      <td>2018-05-09 07:00:00</td>\n",
       "      <td>-9999.000000</td>\n",
       "      <td>Ignored</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41697599</th>\n",
       "      <td>41697599</td>\n",
       "      <td>1448</td>\n",
       "      <td>0</td>\n",
       "      <td>2018-05-09 07:00:00</td>\n",
       "      <td>-9999.000000</td>\n",
       "      <td>Ignored</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>41697600 rows × 6 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "            row_id  building_id  meter           timestamp  meter_reading  \\\n",
       "0                0            0      0 2017-01-01 00:00:00     173.369995   \n",
       "1                1            1      0 2017-01-01 00:00:00      53.512699   \n",
       "2                2            2      0 2017-01-01 00:00:00       6.143000   \n",
       "3                3            3      0 2017-01-01 00:00:00     101.700996   \n",
       "4                4            4      0 2017-01-01 00:00:00    1141.239990   \n",
       "...            ...          ...    ...                 ...            ...   \n",
       "41697595  41697595         1444      0 2018-05-09 07:00:00   -9999.000000   \n",
       "41697596  41697596         1445      0 2018-05-09 07:00:00   -9999.000000   \n",
       "41697597  41697597         1446      0 2018-05-09 07:00:00   -9999.000000   \n",
       "41697598  41697598         1447      0 2018-05-09 07:00:00   -9999.000000   \n",
       "41697599  41697599         1448      0 2018-05-09 07:00:00   -9999.000000   \n",
       "\n",
       "            Usage  \n",
       "0          Public  \n",
       "1          Public  \n",
       "2          Public  \n",
       "3          Public  \n",
       "4          Public  \n",
       "...           ...  \n",
       "41697595  Ignored  \n",
       "41697596  Ignored  \n",
       "41697597  Ignored  \n",
       "41697598  Ignored  \n",
       "41697599  Ignored  \n",
       "\n",
       "[41697600 rows x 6 columns]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test = pd.read_feather(root/'test.feather')\n",
    "merged = df_test.merge(df_solution,  on='row_id', how='left')\n",
    "merged"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "ytrue = df_solution.loc[merged['Usage']=='Private', 'meter_reading']\n",
    "pred = submission.loc[merged['Usage']=='Private', 'meter_reading']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSLE: 1.2888\n"
     ]
    }
   ],
   "source": [
    "print(f'RMSLE: {rmsle(ytrue, pred):.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nbuilding = pd.read_feather(root/'building_metadata.feather')\\nmerged['meter_reading_pred'] = submission['meter_reading']\\n\\nfor building_id in building['building_id'].unique():\\n    for meter in np.arange(0, 4):\\n        df_plot = merged[(merged['building_id']==building_id)&(merged['meter']==meter)].sort_values('timestamp').set_index('timestamp').copy()\\n        df_plot = df_plot[df_plot['meter_reading']>0].loc['2017']\\n        #df_plot = df_plot[df_plot['Usage']!='Ignored']\\n\\n        if len(df_plot)>0:\\n            print('R-squared: '+str(df_plot[['meter_reading','meter_reading_pred']].corr().iloc[0,1].round(3)))\\n            print('RMSLE: '+str(round(rmsle(df_plot['meter_reading'], df_plot['meter_reading_pred']), 2)))\\n            df_plot[['meter_reading','meter_reading_pred']].plot(figsize=(15,3),alpha=0.5,title='building_id: '+str(building_id)+' - meter: '+str(meter));plt.show()\\n            print('--------------------------------------------------------------------------------------------------------------------------') \\n\""
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "building = pd.read_feather(root/'building_metadata.feather')\n",
    "merged['meter_reading_pred'] = submission['meter_reading']\n",
    "\n",
    "for building_id in building['building_id'].unique():\n",
    "    for meter in np.arange(0, 4):\n",
    "        df_plot = merged[(merged['building_id']==building_id)&(merged['meter']==meter)].sort_values('timestamp').set_index('timestamp').copy()\n",
    "        df_plot = df_plot[df_plot['meter_reading']>0].loc['2017']\n",
    "        #df_plot = df_plot[df_plot['Usage']!='Ignored']\n",
    "\n",
    "        if len(df_plot)>0:\n",
    "            print('R-squared: '+str(df_plot[['meter_reading','meter_reading_pred']].corr().iloc[0,1].round(3)))\n",
    "            print('RMSLE: '+str(round(rmsle(df_plot['meter_reading'], df_plot['meter_reading_pred']), 2)))\n",
    "            df_plot[['meter_reading','meter_reading_pred']].plot(figsize=(15,3),alpha=0.5,title='building_id: '+str(building_id)+' - meter: '+str(meter));plt.show()\n",
    "            print('--------------------------------------------------------------------------------------------------------------------------') \n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "07235f1029f74615b4a3417cf0a8920d": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "IntProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "IntProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "100%",
       "description_tooltip": null,
       "layout": "IPY_MODEL_391040754519448f856db90281065917",
       "max": 3,
       "min": 0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_0e89f5ba063d4aae89468da0022b4280",
       "value": 3
      }
     },
     "0e89f5ba063d4aae89468da0022b4280": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": "initial"
      }
     },
     "391040754519448f856db90281065917": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "4215aec2bccb4ee1a2b1c011587baeee": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "7e2a2d2eff37408996e06d6fa8aaf3b3": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "c0fb7d588faf4cb0b04187c9275b2783": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_4215aec2bccb4ee1a2b1c011587baeee",
       "placeholder": "​",
       "style": "IPY_MODEL_7e2a2d2eff37408996e06d6fa8aaf3b3",
       "value": " 3/3 [53:13&lt;00:00, 1064.61s/it]"
      }
     },
     "d00998bd2608470bafaa7624b24b353f": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "e0f3c58d8a5146c7a0aaedc1c08db342": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_07235f1029f74615b4a3417cf0a8920d",
        "IPY_MODEL_c0fb7d588faf4cb0b04187c9275b2783"
       ],
       "layout": "IPY_MODEL_d00998bd2608470bafaa7624b24b353f"
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}