_2_6_gen_target_features.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:14:31.501295Z",
     "start_time": "2018-04-20T13:14:30.049053Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import pickle\n",
    "import gc\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "from utils import (\n",
    "    load_pickle, dump_pickle, get_nominal_dfal, feats_root, mem_usage, reduce_mem_usage,\n",
    "    nominal_cate_cols, ordinal_cate_cols, identity_cols, continual_cols, \n",
    ")\n",
    "\n",
    "pd.set_option('display.max_columns', 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:14:31.543423Z",
     "start_time": "2018-04-20T13:14:31.504594Z"
    }
   },
   "outputs": [],
   "source": [
    "def gen_target_agg_features(data, last_da, win_das, col):\n",
    "    data = data.copy()\n",
    "    indexing = (data.da < last_da) & (data.da >= last_da - win_das)\n",
    "    gp = data.loc[indexing, [col, 'is_trade']].groupby(col)['is_trade']\n",
    "    avgs = gp.mean()\n",
    "    sums = gp.sum()\n",
    "    cnts = gp.size()\n",
    "    skews = gp.skew()\n",
    "    var = gp.var()\n",
    "    sems = gp.sem()\n",
    "    kurts = gp.apply(pd.DataFrame.kurt)\n",
    "    \n",
    "    indexing = data.da == last_da\n",
    "    data.loc[indexing, 'agg_target_mean_{}_wd_{}'.format(col, win_das)] = data.loc[indexing, col].map(avgs)\n",
    "    data.loc[indexing, 'agg_target_sum_{}_wd_{}'.format(col, win_das)] = data.loc[indexing, col].map(sums)\n",
    "    data.loc[indexing, 'agg_target_count_{}_wd_{}'.format(col, win_das)] = data.loc[indexing, col].map(cnts)\n",
    "    data.loc[indexing, 'agg_target_var_{}_wd_{}'.format(col, win_das)] = data.loc[indexing, col].map(var)\n",
    "    data.loc[indexing, 'agg_target_sem_{}_wd_{}'.format(col, win_das)] = data.loc[indexing, col].map(sems)\n",
    "    data.loc[indexing, 'agg_target_kurt_{}_wd_{}'.format(col, win_das)] = data.loc[indexing, col].map(kurts)\n",
    "    \n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:14:31.576270Z",
     "start_time": "2018-04-20T13:14:31.547022Z"
    }
   },
   "outputs": [],
   "source": [
    "def gen_target_aggs(col, updata=False):\n",
    "    feat_path = os.path.join(feats_root,'target_aggs_{}.pkl'.format(col))\n",
    "    if os.path.exists(feat_path) and updata == False:\n",
    "        print('Found ' + feat_path)\n",
    "    else:\n",
    "        print('Generating ' + feat_path)\n",
    "        dfal = get_nominal_dfal()[[col, 'da', 'is_trade']]\n",
    "        dmax = dfal.da.max()\n",
    "        dmin = dfal.da.min()\n",
    "        for da in sorted(dfal.da.unique())[1:]:\n",
    "            for win_das in [1, 2, 3]:\n",
    "                if da - win_das < dmin:\n",
    "                    continue\n",
    "                dfal = gen_target_agg_features(dfal, da, win_das, col)\n",
    "        dfal = dfal.loc[dfal.da>17,:]\n",
    "        dfal.drop(['is_trade'], inplace=True, axis=1)\n",
    "        dfal.drop_duplicates([col, 'da'], inplace=True)\n",
    "        dfal.fillna(0, inplace=True)\n",
    "        dfal, _ = reduce_mem_usage(dfal)\n",
    "        dump_pickle(dfal, feat_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:14:31.585925Z",
     "start_time": "2018-04-20T13:14:31.579302Z"
    }
   },
   "outputs": [],
   "source": [
    "def gen_target_features():\n",
    "    for c in tqdm(nominal_cate_cols + ordinal_cate_cols + identity_cols + ['hm', 'mi', 'ho']):\n",
    "        gen_target_aggs(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:14:31.598838Z",
     "start_time": "2018-04-20T13:14:31.589238Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_target_features(data, col):\n",
    "    feat_path = os.path.join(feats_root,'target_aggs_{}.pkl'.format(col))\n",
    "    if not os.path.exists(feat_path):\n",
    "        gen_target_aggs(col)\n",
    "    agg = load_pickle(feat_path)\n",
    "    return pd.merge(data, agg, how='left',on=[col, 'da'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.421763Z",
     "start_time": "2018-04-20T13:14:31.601894Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|          | 0/20 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating ./feats/target_aggs_item_category_list.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  5%|▌         | 1/20 [00:05<01:52,  5.90s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.014392852783203125  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.004486083984375  MB\n",
      "This is  31.16883116883117 % of the initial size\n",
      "Generating ./feats/target_aggs_item_brand_id.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 10%|█         | 2/20 [00:21<03:09, 10.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 1.4493703842163086  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.4394865036010742  MB\n",
      "This is  30.322580645161292 % of the initial size\n",
      "Generating ./feats/target_aggs_item_city_id.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 15%|█▌        | 3/20 [00:27<02:33,  9.05s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.11587715148925781  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.0361175537109375  MB\n",
      "This is  31.16883116883117 % of the initial size\n",
      "Generating ./feats/target_aggs_user_gender_id.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 20%|██        | 4/20 [00:32<02:08,  8.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.00411224365234375  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.00133514404296875  MB\n",
      "This is  32.467532467532465 % of the initial size\n",
      "Generating ./feats/target_aggs_user_occupation_id.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 25%|██▌       | 5/20 [00:37<01:53,  7.54s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.0051403045654296875  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.0016689300537109375  MB\n",
      "This is  32.467532467532465 % of the initial size\n",
      "Generating ./feats/target_aggs_item_price_level.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 30%|███       | 6/20 [00:42<01:40,  7.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.012042999267578125  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.003753662109375  MB\n",
      "This is  31.16883116883117 % of the initial size\n",
      "Generating ./feats/target_aggs_item_sales_level.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 35%|███▌      | 7/20 [00:48<01:30,  6.94s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.018505096435546875  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.005527496337890625  MB\n",
      "This is  29.87012987012987 % of the initial size\n",
      "Generating ./feats/target_aggs_item_collected_level.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 40%|████      | 8/20 [00:53<01:20,  6.67s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.018505096435546875  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.005527496337890625  MB\n",
      "This is  29.87012987012987 % of the initial size\n",
      "Generating ./feats/target_aggs_item_pv_level.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 45%|████▌     | 9/20 [00:58<01:11,  6.47s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.021001815795898438  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.0062732696533203125  MB\n",
      "This is  29.87012987012987 % of the initial size\n",
      "Generating ./feats/target_aggs_user_age_level.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████     | 10/20 [01:03<01:03,  6.30s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.009252548217773438  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.0028839111328125  MB\n",
      "This is  31.16883116883117 % of the initial size\n",
      "Generating ./feats/target_aggs_user_star_level.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 55%|█████▌    | 11/20 [01:07<00:55,  6.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.01233673095703125  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.00368499755859375  MB\n",
      "This is  29.87012987012987 % of the initial size\n",
      "Generating ./feats/target_aggs_context_page_id.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 60%|██████    | 12/20 [01:12<00:48,  6.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.02056121826171875  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.00667572021484375  MB\n",
      "This is  32.467532467532465 % of the initial size\n",
      "Generating ./feats/target_aggs_shop_review_num_level.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 65%|██████▌   | 13/20 [01:17<00:41,  5.96s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.024379730224609375  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.007282257080078125  MB\n",
      "This is  29.87012987012987 % of the initial size\n",
      "Generating ./feats/target_aggs_shop_star_level.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 70%|███████   | 14/20 [01:22<00:35,  5.88s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.0223236083984375  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.0066680908203125  MB\n",
      "This is  29.87012987012987 % of the initial size\n",
      "Generating ./feats/target_aggs_item_id.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 75%|███████▌  | 15/20 [02:00<00:40,  8.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 5.758457183837891  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  1.6346588134765625  MB\n",
      "This is  28.387096774193548 % of the initial size\n",
      "Generating ./feats/target_aggs_shop_id.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 80%|████████  | 16/20 [02:21<00:35,  8.81s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 2.744565010070801  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.7791023254394531  MB\n",
      "This is  28.387096774193548 % of the initial size\n",
      "Generating ./feats/target_aggs_user_id.pkl\n",
      "Memory usage of dataframe is : 32.3357629776001  MB\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 85%|████████▌ | 17/20 [07:46<01:22, 27.43s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  8.856291770935059  MB\n",
      "This is  27.388535031847134 % of the initial size\n",
      "Generating ./feats/target_aggs_hm.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 90%|█████████ | 18/20 [07:59<00:53, 26.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 1.4798212051391602  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.41053104400634766  MB\n",
      "This is  27.741935483870968 % of the initial size\n",
      "Generating ./feats/target_aggs_mi.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 95%|█████████▌| 19/20 [08:04<00:25, 25.52s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.06168365478515625  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.017223358154296875  MB\n",
      "This is  27.92207792207792 % of the initial size\n",
      "Generating ./feats/target_aggs_ho.pkl\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "100%|██████████| 20/20 [08:09<00:00, 24.49s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory usage of dataframe is : 0.0246734619140625  MB\n",
      "___MEMORY USAGE AFTER COMPLETION:___\n",
      "Memory usage is:  0.00720977783203125  MB\n",
      "This is  29.22077922077922 % of the initial size\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "    gen_target_features()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.429705Z",
     "start_time": "2018-04-20T13:22:41.425653Z"
    }
   },
   "outputs": [],
   "source": [
    "# dfal = get_nominal_dfal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.436240Z",
     "start_time": "2018-04-20T13:22:41.432753Z"
    }
   },
   "outputs": [],
   "source": [
    "# dfal.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.443594Z",
     "start_time": "2018-04-20T13:22:41.439418Z"
    }
   },
   "outputs": [],
   "source": [
    "# dfal = dfal.loc[dfal.da>20,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.450827Z",
     "start_time": "2018-04-20T13:22:41.446344Z"
    }
   },
   "outputs": [],
   "source": [
    "# for c in tqdm_notebook(['hm']):\n",
    "#     dfal = add_target_features(dfal, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.458414Z",
     "start_time": "2018-04-20T13:22:41.453761Z"
    }
   },
   "outputs": [],
   "source": [
    "# del dfal['dt']\n",
    "# for c in dfal.columns:\n",
    "#     if c.endswith('_wd_6'):\n",
    "#         del dfal[c]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.465916Z",
     "start_time": "2018-04-20T13:22:41.462489Z"
    }
   },
   "outputs": [],
   "source": [
    "# dfal.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.472896Z",
     "start_time": "2018-04-20T13:22:41.469759Z"
    }
   },
   "outputs": [],
   "source": [
    "# dfal.groupby(['ho'])['is_trade'].mad()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.480385Z",
     "start_time": "2018-04-20T13:22:41.476584Z"
    }
   },
   "outputs": [],
   "source": [
    "# dfal, _ = reduce_mem_usage(dfal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.493062Z",
     "start_time": "2018-04-20T13:22:41.484377Z"
    }
   },
   "outputs": [],
   "source": [
    "# dfal.columns.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.516070Z",
     "start_time": "2018-04-20T13:22:41.497218Z"
    }
   },
   "outputs": [],
   "source": [
    "# X_tr = dfal.loc[dfal.da<=22,:].drop(['da', 'hm', 'instance_id', 'is_trade'] + identity_cols, axis=1)\n",
    "# y_tr = dfal.loc[dfal.da<=22,'is_trade']\n",
    "# X_va = dfal.loc[dfal.da==23,:].drop(['da', 'hm', 'instance_id', 'is_trade'] + identity_cols, axis=1)\n",
    "# y_va = dfal.loc[dfal.da==23,'is_trade']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.540886Z",
     "start_time": "2018-04-20T13:22:41.532554Z"
    }
   },
   "outputs": [],
   "source": [
    "# %matplotlib inline\n",
    "# import matplotlib.pyplot as plt\n",
    "# import catboost as cb\n",
    "# import xgboost as xg\n",
    "# import lightgbm as lg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.567372Z",
     "start_time": "2018-04-20T13:22:41.546622Z"
    }
   },
   "outputs": [],
   "source": [
    "# def print_feature_importance_lgb(gbm):\n",
    "#     print(80 * '*')\n",
    "#     print(31 * '*' + 'Feature Importance' + 31 * '*')\n",
    "#     print(80 * '.')\n",
    "#     print(\"\\n\".join((\".%50s => %9.5f\" % x) for x in sorted(\n",
    "#         zip(gbm.feature_name(), gbm.feature_importance(\"gain\")),\n",
    "#         key=lambda x: x[1],\n",
    "#         reverse=True)))\n",
    "#     print(80 * '.')\n",
    "\n",
    "# def fit_lgb(X_tr, y_tr, X_va, y_va, cates_cols):\n",
    "#     params = {\n",
    "#         'max_depth': 8,\n",
    "#         'num_leaves': 128,\n",
    "#         'objective':'binary',\n",
    "#         'min_data_in_leaf': 20,\n",
    "#         'learning_rate': 0.01,\n",
    "#         'feature_fraction': 0.9,\n",
    "#         'bagging_fraction': 0.8,\n",
    "#         'subsample':0.85,\n",
    "#         'bagging_freq': 1,\n",
    "#         'random_state':2018,\n",
    "#         'metric': ['binary_logloss'],\n",
    "#         'num_threads': 16,\n",
    "#         #'is_unbalance': True\n",
    "#     }\n",
    "\n",
    "#     MAX_ROUNDS = 10000\n",
    "#     dtr = lg.Dataset(X_tr, label=y_tr, categorical_feature=cates_cols)\n",
    "#     dva = lg.Dataset(X_va, label=y_va, categorical_feature=cates_cols, reference=dtr)\n",
    "    \n",
    "#     cls = lg.train(\n",
    "#         params,\n",
    "#         dtr,\n",
    "#         num_boost_round=MAX_ROUNDS,\n",
    "#         valid_sets=(dva, dtr),\n",
    "#         valid_names=['valid', 'train'],\n",
    "#         early_stopping_rounds=125,\n",
    "#         verbose_eval=50)\n",
    "#     print_feature_importance_lgb(cls)\n",
    "#     lg.plot_importance(cls, importance_type='gain', figsize=(11,12), max_num_features=50, grid=False)\n",
    "#     return cls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.583620Z",
     "start_time": "2018-04-20T13:22:41.574887Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# gbm = fit_lgb(X_tr, y_tr, X_va, y_va, nominal_cate_cols)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CatBoostClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.596729Z",
     "start_time": "2018-04-20T13:22:41.590427Z"
    }
   },
   "outputs": [],
   "source": [
    "# cates_idx = [X_tr.columns.values.tolist().index(c) for c in nominal_cate_cols]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.630889Z",
     "start_time": "2018-04-20T13:22:41.603747Z"
    }
   },
   "outputs": [],
   "source": [
    "# import operator\n",
    "# def verbose_feature_importance_cat(cls, X_tr):\n",
    "#     cat_feature_importance = {\n",
    "#         X_tr.columns.values.tolist()[idx]: score\n",
    "#         for idx, score in enumerate(cls.feature_importances_)\n",
    "#     }\n",
    "    \n",
    "#     cat_feature_importance = sorted(cat_feature_importance.items(), \n",
    "#                                     key=operator.itemgetter(1), \n",
    "#                                     reverse=False)\n",
    "    \n",
    "#     print(80 * '*')\n",
    "#     print(31 * '*' + 'Feature Importance' + 31 * '*')\n",
    "#     print(80 * '.')\n",
    "#     for feature, score in reversed(cat_feature_importance):\n",
    "#         print(\".%50s => %9.5f\" % (feature, score))\n",
    "#     print(80 * '.')\n",
    "    \n",
    "#     feature_score = pd.DataFrame(cat_feature_importance, columns=['Feature','Score'])\n",
    "    \n",
    "#     plt.rcParams[\"figure.figsize\"] = (11, 12)\n",
    "#     ax = feature_score.tail(50).plot('Feature', 'Score', kind='barh', color='b')\n",
    "#     ax.set_title(\"Catboost Feature Importance Ranking\", fontsize=8)\n",
    "#     ax.set_xlabel('')\n",
    "#     rects = ax.patches\n",
    "#     # get feature score as labels round to 2 decimal\n",
    "#     labels = feature_score.tail(50)['Score'].round(2)\n",
    "#     for rect, label in zip(rects, labels):\n",
    "#         width = rect.get_width()\n",
    "#         ax.text(width + 0.2,rect.get_y()+0.02, label, ha='center', va='bottom')\n",
    "#     plt.show()\n",
    "\n",
    "\n",
    "# def fit_cat(X_tr, y_tr, X_va, y_va, cates_idx):\n",
    "#     print('Fitting CatBoostClassifier ...')\n",
    "#     cls = cb.CatBoostClassifier(\n",
    "#         iterations=2000,\n",
    "#         od_type='Iter',\n",
    "#         od_wait=120,\n",
    "#         max_depth=8,\n",
    "#         learning_rate=0.02,\n",
    "#         l2_leaf_reg=9,\n",
    "#         random_seed=2018,\n",
    "#         metric_period=50,\n",
    "#         fold_len_multiplier=1.1,\n",
    "#         loss_function='Logloss',\n",
    "#         logging_level='Verbose')\n",
    "#     fine_model = cls.fit(X_tr, y_tr, eval_set=(X_va, y_va), cat_features=cates_idx)\n",
    "#     verbose_feature_importance_cat(fine_model, X_tr)\n",
    "#     return fine_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-20T13:22:41.640484Z",
     "start_time": "2018-04-20T13:22:41.634868Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# cat = fit_cat(X_tr, y_tr, X_va, y_va, cates_idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "stats36",
   "language": "python",
   "name": "stats36"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}