display_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:04.475509Z",
     "start_time": "2019-08-11T16:55:58.765145Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.model_selection import train_test_split, StratifiedKFold, KFold\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from xgboost import XGBClassifier\n",
    "import random\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras.layers import Dropout\n",
    "from pathlib import Path\n",
    "import warnings\n",
    "from pandas.core.common import SettingWithCopyWarning\n",
    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
    "warnings.simplefilter(action=\"ignore\", category=SettingWithCopyWarning)\n",
    "import logging\n",
    "logging.getLogger('tensorflow').disabled = True\n",
    "\n",
    "# set seed and path\n",
    "SEED = 1\n",
    "ROOT = Path('.')\n",
    "TRAIN_FILE = ROOT / 'data/train.csv'\n",
    "\n",
    "# check your current working directory\n",
    "# !pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:04.619923Z",
     "start_time": "2019-08-11T16:56:04.478555Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RESOURCE            int64\n",
       "MGR_ID              int64\n",
       "ROLE_FAMILY_DESC    int64\n",
       "ROLE_FAMILY         int64\n",
       "ROLE_CODE           int64\n",
       "dtype: object"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(32769, 5)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>RESOURCE</th>\n",
       "      <th>MGR_ID</th>\n",
       "      <th>ROLE_FAMILY_DESC</th>\n",
       "      <th>ROLE_FAMILY</th>\n",
       "      <th>ROLE_CODE</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>39353</td>\n",
       "      <td>85475</td>\n",
       "      <td>117906</td>\n",
       "      <td>290919</td>\n",
       "      <td>117908</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>17183</td>\n",
       "      <td>1540</td>\n",
       "      <td>118536</td>\n",
       "      <td>308574</td>\n",
       "      <td>118539</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>36724</td>\n",
       "      <td>14457</td>\n",
       "      <td>267952</td>\n",
       "      <td>19721</td>\n",
       "      <td>117880</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>36135</td>\n",
       "      <td>5396</td>\n",
       "      <td>240983</td>\n",
       "      <td>290919</td>\n",
       "      <td>118322</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>42680</td>\n",
       "      <td>5905</td>\n",
       "      <td>123932</td>\n",
       "      <td>19793</td>\n",
       "      <td>119325</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   RESOURCE  MGR_ID  ROLE_FAMILY_DESC  ROLE_FAMILY  ROLE_CODE\n",
       "0     39353   85475            117906       290919     117908\n",
       "1     17183    1540            118536       308574     118539\n",
       "2     36724   14457            267952        19721     117880\n",
       "3     36135    5396            240983       290919     118322\n",
       "4     42680    5905            123932        19793     119325"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'TARGET'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "1    30872\n",
       "0     1897\n",
       "Name: ACTION, dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train = pd.read_csv(TRAIN_FILE)\n",
    "y = train['ACTION']\n",
    "train = train[['RESOURCE', 'MGR_ID',\n",
    "               'ROLE_FAMILY_DESC', 'ROLE_FAMILY',\n",
    "               'ROLE_CODE']]\n",
    "display(train.dtypes,\n",
    "       train.shape,\n",
    "       train.head(),\n",
    "       'TARGET',\n",
    "       y.value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Data 簡介\n",
    "這次的示範資料集是從Kaggle上2013年的[Amazon員工訪問權限預測挑戰賽](https://www.kaggle.com/c/amazon-employee-access-challenge)中取得\n",
    "這個資料集，該資料集收集了Amazon公司中各個員工針對每個資源(例如網頁的logging)的訪問紀錄，當員工屬於能夠取得訪問權限時，系統卻不給訪問，又要向上申請才能取得權限，一來一往浪費的非常多時間，因此這場比賽希望能夠建構模型，減少員工訪問權限所需的人工流程，我們取出5個特徵如下 :\n",
    "\n",
    "\n",
    "* Feature (X)\n",
    "\n",
    "> RESOURCE : 資源ID\n",
    "\n",
    "> MGR_ID : 員工主管的ID \n",
    "\n",
    "> ROLE_FAMILY_DESC : 員工類別擴展描述 (例如 軟體工程的零售經理)\n",
    "\n",
    "> ROLE_FAMILY : 員工類別 (例如 零售經理)\n",
    "\n",
    "> ROLE_CODE : 員工角色編碼 (例如 經理)\n",
    "\n",
    "* Target (Y)\n",
    "\n",
    "> ACTION : \n",
    "\n",
    " >> 1 : RESOURCE 訪問權限取得\n",
    " \n",
    " >> 0 : RESOURCE 禁止訪問"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:04.643819Z",
     "start_time": "2019-08-11T16:56:04.624034Z"
    }
   },
   "outputs": [],
   "source": [
    "# helper function\n",
    "def get_score(model, X, y, X_val, y_val):\n",
    "    model.fit(X, y)\n",
    "    y_pred = model.predict_proba(X_val)[:,1]\n",
    "    score = roc_auc_score(y_val, y_pred)\n",
    "    return score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:04.723929Z",
     "start_time": "2019-08-11T16:56:04.670398Z"
    }
   },
   "outputs": [],
   "source": [
    "LogReg_model = LogisticRegression(random_state=SEED)\n",
    "xgb_model = XGBClassifier(random_state=SEED)\n",
    "X_train, X_val, y_train, y_val = train_test_split(train, y, \n",
    "                                                  test_size=0.2,\n",
    "                                                  random_state=SEED, \n",
    "                                                  stratify = y)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:04.745556Z",
     "start_time": "2019-08-11T16:56:04.728732Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RESOURCE uniques :  6670\n",
      "MGR_ID uniques :  4049\n",
      "ROLE_FAMILY_DESC uniques :  2206\n",
      "ROLE_FAMILY uniques :  67\n",
      "ROLE_CODE uniques :  338\n"
     ]
    }
   ],
   "source": [
    "for col in X_train.columns:\n",
    "    print(col , 'uniques : ',X_train[f'{col}'].nunique())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# label encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:06.599442Z",
     "start_time": "2019-08-11T16:56:04.749217Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Label encoding: 0.5274805849614904\n",
      "Xgboost Label encoding: 0.7297548417420656\n"
     ]
    }
   ],
   "source": [
    "baseline_logit_score = get_score(LogReg_model, X_train, y_train, X_val, y_val)\n",
    "baseline_xgb_score = get_score(xgb_model, X_train, y_train, X_val, y_val)\n",
    "print('Logistic Regression Label encoding:', baseline_logit_score)\n",
    "print('Xgboost Label encoding:', baseline_xgb_score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# One hot encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:06.719803Z",
     "start_time": "2019-08-11T16:56:06.606570Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original number of features: 5\n",
      "Features after OHE 13330\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "one_hot_enc = OneHotEncoder(sparse=True)\n",
    "\n",
    "print('Original number of features:', X_train.shape[1])\n",
    "data_ohe_train = (one_hot_enc.fit_transform(X_train))\n",
    "data_ohe_val = (one_hot_enc.transform(X_val))\n",
    "print('Features after OHE', data_ohe_train.shape[1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:15.424890Z",
     "start_time": "2019-08-11T16:56:06.724557Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression OneHot encoding: 0.8686105562261652\n",
      "Xgboost OneHot encoding: 0.7327572025252903\n"
     ]
    }
   ],
   "source": [
    "ohe_logit_score = get_score(LogReg_model, data_ohe_train, y_train, data_ohe_val, y_val)\n",
    "ohe_xgb_score = get_score(xgb_model, data_ohe_train, y_train, data_ohe_val, y_val)\n",
    "print('Logistic Regression OneHot encoding:', ohe_logit_score)\n",
    "print('Xgboost OneHot encoding:', ohe_xgb_score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Target encoding\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:15.470725Z",
     "start_time": "2019-08-11T16:56:15.438530Z"
    }
   },
   "outputs": [],
   "source": [
    "def TargetEncoder(train, test, ft, target, \n",
    "                   min_samples_leaf=1,\n",
    "                   smoothing_slope=1,\n",
    "                   noise_level=0,\n",
    "                   handle_missing='informed', handle_unseen='overall_mean',\n",
    "                   verbose=True):\n",
    "    '''\n",
    "        Tree model 處理 high cardinality特徵的方法, (例如, 地區, 地址, IP...)\n",
    "        由於特徵非線性且基數高，導致Tree model非常容易overfitting，\n",
    "        Target encoding的中心思想為 :\n",
    "        將類別特徵轉換為數值特徵，使用該特徵中每個種類的sooth_mean，\n",
    "        smooth_mean可以理解為，當該種類出現的次數越多次，我們就越相信該平均值，否則資訊量太少，\n",
    "        我們傾向相信總平均值。\n",
    "        公式為 : smooth_mean = smoothing_factor * estimated_mean + (1 - smoothing_factor) * overall mean\n",
    "        其中 smoothing_factor =  1 / (1 + np.exp(-(counts - min_samples_leaf) / smoothing_slope))\n",
    "        when min_samples_leaf, smoothing_slope fixed, counts -> infinity, smoothing_factor -> 1\n",
    "        min_sample_leaf 為曲線的反曲點, 當counts = min_sample_leaf 時， smoothing_factor = 0.5\n",
    "        smoothing_slope 為曲線從反曲點趨近於0和1的增加量 :\n",
    "        當smoothing_slope -> infinity, smoothing_factor = 0.5\n",
    "        當smoothing_slope -> 0 smoothing_factor -> step function\n",
    "        \n",
    "    :param train: pd.DataFrame\n",
    "    :param test: pd.DataFrame \n",
    "    :param ft: string \n",
    "    :param target : pd.Series with target name\n",
    "    :param noise_level: float  noise level\n",
    "    :param handle_missing: string 'overall_mean','informed'\n",
    "    :param handle_unseen: string 'overall_mean','return_nan'\n",
    "    :param verbose: bool, check the unseen in testing set\n",
    "    :return: train - pd.Series, test, - pd.Series target encoding result\n",
    "    \n",
    "    '''\n",
    "\n",
    "    def add_noise(s: 'pd.Series', noise_level: int) -> 'pd.Series':\n",
    "        return s * (1 + noise_level * np.random.randn(len(s)))\n",
    "    \n",
    "    train = pd.concat([train, target], axis=1)\n",
    "    target_name = target.name\n",
    "    overall_mean = target.mean()\n",
    "\n",
    "    # handling missing value - filling\n",
    "    train[ft].fillna('is_missing')\n",
    "    test[ft].fillna('is_missing')\n",
    "\n",
    "    # Compute the number of values and the estimated_mean of each group\n",
    "    agg = train.groupby(ft)[target_name].agg(['count', 'mean'])\n",
    "    counts = agg['count']\n",
    "    estimated_mean = agg['mean']\n",
    "\n",
    "    if handle_missing == 'overall_mean':\n",
    "        # assign zero to group \"is_missing\", then smooth will be overall_mean\n",
    "        counts.is_missing = 0\n",
    "\n",
    "    # Compute the \"smoothed\" overall_means\n",
    "    # DEFAULT take missing value is informed\n",
    "\n",
    "    smoothing_factor = 1 / (1 + np.exp(- (counts - min_samples_leaf) / smoothing_slope))\n",
    "    smooth_mean = (smoothing_factor * estimated_mean + (1 - smoothing_factor) * overall_mean)\n",
    "\n",
    "    # create seen variable for test\n",
    "    test_seen = test[ft].map(smooth_mean)\n",
    "    unseen_ratio = test_seen.isnull().sum() / len(test)\n",
    "\n",
    "    # return nan for unseen variable\n",
    "    if handle_unseen == 'return_nan':\n",
    "        return add_noise(train[ft].map(smooth_mean), noise_level), add_noise(test_seen, noise_level)\n",
    "\n",
    "    if verbose:\n",
    "        print(f'feature \"{ft}\" overall_mean is : ', round(overall_mean, 3))\n",
    "        print(f'feature \"{ft}\" unssen ratio in test set is : ', round(unseen_ratio, 3))\n",
    "\n",
    "    # DEFAULT return overall_mean for unseen variable\n",
    "    return add_noise(train[ft].map(smooth_mean), noise_level), add_noise(test_seen.fillna(overall_mean), noise_level)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:15.766385Z",
     "start_time": "2019-08-11T16:56:15.480286Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "feature \"RESOURCE\" overall_mean is :  0.942\n",
      "feature \"RESOURCE\" unssen ratio in test set is :  0.143\n",
      "feature \"MGR_ID\" overall_mean is :  0.942\n",
      "feature \"MGR_ID\" unssen ratio in test set is :  0.034\n",
      "feature \"ROLE_FAMILY_DESC\" overall_mean is :  0.942\n",
      "feature \"ROLE_FAMILY_DESC\" unssen ratio in test set is :  0.027\n",
      "feature \"ROLE_FAMILY\" overall_mean is :  0.942\n",
      "feature \"ROLE_FAMILY\" unssen ratio in test set is :  0.0\n",
      "feature \"ROLE_CODE\" overall_mean is :  0.942\n",
      "feature \"ROLE_CODE\" unssen ratio in test set is :  0.001\n"
     ]
    }
   ],
   "source": [
    "data_te_train = X_train.copy()\n",
    "data_te_val = X_val.copy()\n",
    "for feature in data_te_train.columns:\n",
    "    data_te_train[f'{feature}_te'], data_te_val[f'{feature}_te'] = TargetEncoder(data_te_train,\n",
    "                                                                           X_val, ft=feature,\n",
    "                                                                           target=y_train,\n",
    "                                                                      min_samples_leaf=3, smoothing_slope=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:17.945159Z",
     "start_time": "2019-08-11T16:56:15.771481Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Target encoding: 0.8360454210419492\n",
      "Xgboost Target encoding: 0.8444055846944335\n"
     ]
    }
   ],
   "source": [
    "te_col = [feature for feature in data_te_train.columns\n",
    "                              if feature.endswith('_te')]\n",
    "# Training\n",
    "target_logit_score = get_score(LogReg_model, data_te_train[te_col], y_train, data_te_val[te_col], y_val)\n",
    "target_xgb_score = get_score(xgb_model, data_te_train[te_col], y_train, data_te_val[te_col], y_val)\n",
    "print('Logistic Regression Target encoding:', target_logit_score)\n",
    "print('Xgboost Target encoding:', target_xgb_score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regularized Target encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:26.195550Z",
     "start_time": "2019-08-11T16:56:17.950967Z"
    }
   },
   "outputs": [],
   "source": [
    "FOLDS = StratifiedKFold(n_splits=5, random_state=SEED)\n",
    "VAL_FOLDS = KFold(n_splits=5, random_state=SEED)\n",
    "\n",
    "data_te_cv_train = X_train.copy()\n",
    "data_te_cv_val = X_val.copy()\n",
    "oof_trn_list = []\n",
    "oof_test_list = []\n",
    "\n",
    "for (trn_idx, val_idx), (_, test_idx) in zip(FOLDS.split(data_te_cv_train, y_train),\n",
    "                                             VAL_FOLDS.split(data_te_cv_val)):\n",
    "    X_train_te, y_train_te = data_te_cv_train.iloc[trn_idx], y_train.iloc[trn_idx]\n",
    "    X_val_te, y_val_te = data_te_cv_train.iloc[val_idx], y_train.iloc[val_idx]\n",
    "    X_test_te = data_te_cv_val.iloc[test_idx]\n",
    "    \n",
    "    for feature in X_train_te.columns:\n",
    "        X_train_te[f'{feature}_te'], X_val_te[f'{feature}_te'] = TargetEncoder(X_train_te,\n",
    "                                                                               X_val_te,\n",
    "                                                                               ft=feature,\n",
    "                                                                               target=y_train_te,\n",
    "                                                                               min_samples_leaf=3,\n",
    "                                                                               smoothing_slope=2,\n",
    "                                                                               verbose=False)\n",
    "        _, X_test_te[f'{feature}_te'] =TargetEncoder(X_train_te,\n",
    "                                                    X_test_te,\n",
    "                                                    ft=feature,\n",
    "                                                    target=y_train_te,\n",
    "                                                    min_samples_leaf=3,\n",
    "                                                    smoothing_slope=2,\n",
    "                                                    verbose=False)\n",
    "    \n",
    "    oof_trn_list.append(X_val_te.reset_index(drop=True))\n",
    "    oof_test_list.append(X_test_te.reset_index(drop=True))\n",
    "\n",
    "te_col = [feature for feature in data_te_train.columns\n",
    "                              if feature.endswith('_te')]\n",
    "\n",
    "data_te_cv_train = pd.concat(oof_trn_list,ignore_index=True)\n",
    "data_te_cv_val = pd.concat(oof_test_list, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:28.472920Z",
     "start_time": "2019-08-11T16:56:26.204255Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Regularized Target encoding: 0.8483556770961298\n",
      "Xgboost Regularized Target encoding: 0.8569692243598646\n"
     ]
    }
   ],
   "source": [
    "te_cv_logit_score = get_score(LogReg_model, data_te_cv_train[te_col], y_train, data_te_cv_val[te_col], y_val)\n",
    "te_cv_xgb_score = get_score(xgb_model, data_te_cv_train[te_col], y_train, data_te_cv_val[te_col], y_val)\n",
    "print('Logistic Regression Regularized Target encoding:', te_cv_logit_score)\n",
    "print('Xgboost Regularized Target encoding:', te_cv_xgb_score)\n",
    "# # Embedding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:28.488460Z",
     "start_time": "2019-08-11T16:56:28.478729Z"
    }
   },
   "outputs": [],
   "source": [
    "data_embedding_train = X_train.copy()\n",
    "data_embedding_val = X_val.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:28.525703Z",
     "start_time": "2019-08-11T16:56:28.493754Z"
    }
   },
   "outputs": [],
   "source": [
    "class EmbeddingMapping():\n",
    "    \"\"\"\n",
    "    Helper class for handling categorical variables\n",
    "    An instance of this class should be defined for each categorical variable we want to use.\n",
    "    \"\"\"\n",
    "    def __init__(self, s : 'pd.Series') -> None:\n",
    "        values = s.unique().tolist()\n",
    "        self.feature_name = s.name\n",
    "        # dictionary mapper\n",
    "        self.embedding_dict = {value: int_value + 1 for int_value, value in enumerate(values)}\n",
    "        \n",
    "        # The num_values will be used as the input_dim when defining the embedding layer.\n",
    "        # we set unseen values as maximum value + 1 \n",
    "        self.num_values = len(values) + 1\n",
    "\n",
    "    def mapping(self,s : 'pd.Series', verbose = True) -> None:\n",
    "        tmp_series = s.map(self.embedding_dict)\n",
    "        unseen_ratio = round(tmp_series.isnull().sum() / len(s), 3)\n",
    "        if verbose:\n",
    "            print(f'Feature \"{self.feature_name}\"')\n",
    "            print(f'    encode {self.num_values -1} values to label, {self.num_values} will be the unseen value ')\n",
    "            print(f'    unssen ratio is : ', unseen_ratio)\n",
    "        return tmp_series.fillna(self.num_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:56:28.647584Z",
     "start_time": "2019-08-11T16:56:28.535789Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature \"RESOURCE\"\n",
      "    encode 6670 values to label, 6671 will be the unseen value \n",
      "    unssen ratio is :  0.0\n",
      "Feature \"RESOURCE\"\n",
      "    encode 6670 values to label, 6671 will be the unseen value \n",
      "    unssen ratio is :  0.143\n",
      "Feature \"MGR_ID\"\n",
      "    encode 4049 values to label, 4050 will be the unseen value \n",
      "    unssen ratio is :  0.0\n",
      "Feature \"MGR_ID\"\n",
      "    encode 4049 values to label, 4050 will be the unseen value \n",
      "    unssen ratio is :  0.034\n",
      "Feature \"ROLE_FAMILY_DESC\"\n",
      "    encode 2206 values to label, 2207 will be the unseen value \n",
      "    unssen ratio is :  0.0\n",
      "Feature \"ROLE_FAMILY_DESC\"\n",
      "    encode 2206 values to label, 2207 will be the unseen value \n",
      "    unssen ratio is :  0.027\n",
      "Feature \"ROLE_FAMILY\"\n",
      "    encode 67 values to label, 68 will be the unseen value \n",
      "    unssen ratio is :  0.0\n",
      "Feature \"ROLE_FAMILY\"\n",
      "    encode 67 values to label, 68 will be the unseen value \n",
      "    unssen ratio is :  0.0\n",
      "Feature \"ROLE_CODE\"\n",
      "    encode 338 values to label, 339 will be the unseen value \n",
      "    unssen ratio is :  0.0\n",
      "Feature \"ROLE_CODE\"\n",
      "    encode 338 values to label, 339 will be the unseen value \n",
      "    unssen ratio is :  0.001\n"
     ]
    }
   ],
   "source": [
    "for feature in data_embedding_train.columns:\n",
    "    Mapper = EmbeddingMapping(data_embedding_train[feature])\n",
    "    data_embedding_train[f'{feature}'] = Mapper.mapping(data_embedding_train[f'{feature}'])\n",
    "    data_embedding_val[f'{feature}'] = Mapper.mapping(data_embedding_val[f'{feature}'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:57:35.842113Z",
     "start_time": "2019-08-11T16:56:28.653441Z"
    },
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 23593 samples, validate on 2622 samples\n",
      "Epoch 1/80\n",
      "23593/23593 - 4s - loss: 0.6398 - auc: 0.5025 - val_loss: 0.5815 - val_auc: 0.5017\n",
      "Epoch 2/80\n",
      "23593/23593 - 3s - loss: 0.5210 - auc: 0.5047 - val_loss: 0.4445 - val_auc: 0.5037\n",
      "Epoch 3/80\n",
      "23593/23593 - 3s - loss: 0.4037 - auc: 0.5036 - val_loss: 0.3282 - val_auc: 0.5062\n",
      "Epoch 4/80\n",
      "23593/23593 - 3s - loss: 0.3226 - auc: 0.5085 - val_loss: 0.2605 - val_auc: 0.5096\n",
      "Epoch 5/80\n",
      "23593/23593 - 3s - loss: 0.2790 - auc: 0.5128 - val_loss: 0.2290 - val_auc: 0.5157\n",
      "Epoch 6/80\n",
      "23593/23593 - 3s - loss: 0.2627 - auc: 0.5182 - val_loss: 0.2156 - val_auc: 0.5210\n",
      "Epoch 7/80\n",
      "23593/23593 - 3s - loss: 0.2460 - auc: 0.5243 - val_loss: 0.2090 - val_auc: 0.5283\n",
      "Epoch 8/80\n",
      "23593/23593 - 3s - loss: 0.2363 - auc: 0.5319 - val_loss: 0.2046 - val_auc: 0.5361\n",
      "Epoch 9/80\n",
      "23593/23593 - 3s - loss: 0.2307 - auc: 0.5401 - val_loss: 0.2009 - val_auc: 0.5441\n",
      "Epoch 10/80\n",
      "23593/23593 - 3s - loss: 0.2211 - auc: 0.5488 - val_loss: 0.1972 - val_auc: 0.5537\n",
      "Epoch 11/80\n",
      "23593/23593 - 3s - loss: 0.2112 - auc: 0.5594 - val_loss: 0.1934 - val_auc: 0.5653\n",
      "Epoch 12/80\n",
      "23593/23593 - 3s - loss: 0.2033 - auc: 0.5713 - val_loss: 0.1897 - val_auc: 0.5775\n",
      "Epoch 13/80\n",
      "23593/23593 - 3s - loss: 0.1948 - auc: 0.5841 - val_loss: 0.1860 - val_auc: 0.5906\n",
      "Epoch 14/80\n",
      "23593/23593 - 3s - loss: 0.1840 - auc: 0.5977 - val_loss: 0.1830 - val_auc: 0.6050\n",
      "Epoch 15/80\n",
      "23593/23593 - 3s - loss: 0.1739 - auc: 0.6124 - val_loss: 0.1801 - val_auc: 0.6200\n",
      "Epoch 16/80\n",
      "23593/23593 - 2s - loss: 0.1668 - auc: 0.6276 - val_loss: 0.1781 - val_auc: 0.6350\n",
      "Epoch 17/80\n",
      "23593/23593 - 2s - loss: 0.1574 - auc: 0.6425 - val_loss: 0.1767 - val_auc: 0.6502\n",
      "Epoch 18/80\n",
      "23593/23593 - 2s - loss: 0.1483 - auc: 0.6578 - val_loss: 0.1761 - val_auc: 0.6654\n",
      "Epoch 19/80\n",
      "23593/23593 - 2s - loss: 0.1393 - auc: 0.6730 - val_loss: 0.1767 - val_auc: 0.6804\n",
      "Epoch 20/80\n",
      "23593/23593 - 2s - loss: 0.1309 - auc: 0.6878 - val_loss: 0.1778 - val_auc: 0.6950\n",
      "Epoch 21/80\n",
      "23593/23593 - 2s - loss: 0.1265 - auc: 0.7021 - val_loss: 0.1798 - val_auc: 0.7090\n",
      "Epoch 22/80\n",
      "23593/23593 - 2s - loss: 0.1182 - auc: 0.7158 - val_loss: 0.1821 - val_auc: 0.7225\n",
      "Epoch 23/80\n",
      "23593/23593 - 2s - loss: 0.1136 - auc: 0.7291 - val_loss: 0.1853 - val_auc: 0.7353\n"
     ]
    }
   ],
   "source": [
    "LR = .00005\n",
    "EPOCHS = 80\n",
    "hidden_units = (8,8)\n",
    " \n",
    "def auc(y_true, y_pred):\n",
    "    auc = tf.metrics.auc(y_true, y_pred)[1]\n",
    "    keras.backend.get_session().run(tf.local_variables_initializer())\n",
    "    return auc\n",
    "\n",
    "# Google's paper tell us a good herustic size = number of category ** 0.25\n",
    "embedding_size_dict = {'RESOURCE': 9,\n",
    "                       'MGR_ID': 8 ,\n",
    "                      'ROLE_FAMILY_DESC': 7,\n",
    "                      'ROLE_FAMILY': 3,\n",
    "                      'ROLE_CODE':  4,\n",
    "                      }\n",
    "\n",
    "def build_and_train_model(df, target,  \n",
    "                          verbose, hidden_units, epochs, LR,\n",
    "                         embedding_size_dict, SEED):\n",
    "    tf.set_random_seed(SEED); np.random.seed(SEED); random.seed(SEED)\n",
    "    def build_input_and_embedding_layer(s, embedding_size_dict = embedding_size_dict):\n",
    "        assert s.name in embedding_size_dict.keys()\n",
    "        input_layer = keras.Input(shape=(1,), name = s.name)\n",
    "        embedded_layer = keras.layers.Embedding(s.max() + 1, \n",
    "                                               embedding_size_dict[s.name],\n",
    "                                               input_length=1, name = f'{s.name}_embedding')(input_layer)\n",
    "        return input_layer, embedded_layer\n",
    "    # Create embedding layer\n",
    "    emb_layer_list = []\n",
    "    input_layer_list = []\n",
    "    for feature in df.columns:\n",
    "        input_layer, embedded_layer = build_input_and_embedding_layer(df[feature], embedding_size_dict=embedding_size_dict)\n",
    "        input_layer_list.append(input_layer)\n",
    "        emb_layer_list.append(embedded_layer)\n",
    "    # concat\n",
    "    concatenated = keras.layers.Concatenate()(emb_layer_list)\n",
    "    out = keras.layers.Flatten()(concatenated)\n",
    "    \n",
    "    # hidden layers\n",
    "    for n_hidden in hidden_units:\n",
    "        out = keras.layers.Dense(n_hidden, activation='relu')(out)\n",
    "        out = Dropout(0.3)(out)\n",
    "    # output layer\n",
    "    out = keras.layers.Dense(1, activation='sigmoid', name='prediction')(out)\n",
    "    \n",
    "    # model\n",
    "    model = keras.Model(\n",
    "    inputs = input_layer_list,\n",
    "    outputs = out)\n",
    "#     model.summary()\n",
    "\n",
    "    model.compile(\n",
    "    tf.train.AdamOptimizer(LR),\n",
    "    loss='binary_crossentropy',\n",
    "    metrics=[auc],\n",
    "    )\n",
    "    tf.initialize_all_variables()\n",
    "    callback = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=5)\n",
    "    X_train, X_val, y_train, y_val = train_test_split(df, target, \n",
    "                                                  test_size=0.1,\n",
    "                                                  random_state=SEED, \n",
    "                                                  stratify = target)\n",
    "    history = model.fit(\n",
    "    [X_train[feature] for feature in X_train.columns],\n",
    "    y_train,\n",
    "    batch_size= 32,\n",
    "    callbacks=[callback],\n",
    "    epochs=epochs,\n",
    "    verbose=verbose,\n",
    "    validation_data=([X_val[feature] for feature in X_val.columns],\n",
    "                    y_val)\n",
    "    )\n",
    "    return history\n",
    "\n",
    "history = build_and_train_model(df = data_embedding_train,\n",
    "                      target = y_train,\n",
    "                      verbose=2, \n",
    "                      hidden_units=hidden_units,\n",
    "                      epochs=EPOCHS,\n",
    "                      LR=LR,\n",
    "                      embedding_size_dict = embedding_size_dict,\n",
    "                      SEED=SEED)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:57:36.753976Z",
     "start_time": "2019-08-11T16:57:35.845831Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('embedding', <tensorflow.python.keras.callbacks.History object at 0x134781748>)] <class 'list'>\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "history_FS = (15, 5)\n",
    "def plot_history(histories, keys=('loss','auc',), train=True, figsize=history_FS):\n",
    "    if isinstance(histories, tf.keras.callbacks.History):\n",
    "        histories = [ ('', histories) ]\n",
    "        print(histories, type(histories))\n",
    "    print(histories, type(histories))\n",
    "    for key in keys:\n",
    "        plt.figure(figsize=history_FS)\n",
    "        for name, history in histories:\n",
    "            val = plt.plot(history.epoch, history.history['val_'+key],\n",
    "                           '--', label=str(name).title()+' Val')\n",
    "            if train:\n",
    "                plt.plot(history.epoch, history.history[key], color=val[0].get_color(), alpha=.5,\n",
    "                         label=str(name).title()+' Train')\n",
    "                \n",
    "        plt.xlabel('Epochs')\n",
    "        plt.ylabel(key.replace('_',' ').title())\n",
    "        plt.legend()\n",
    "        plt.title(key)\n",
    "\n",
    "        plt.xlim([0,max(max(history.epoch) for (_, history) in histories)])\n",
    "\n",
    "plot_history([ \n",
    "    ('embedding', history)\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:57:36.905113Z",
     "start_time": "2019-08-11T16:57:36.757235Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " processing ... RESOURCE_embedding\n",
      " processing ... MGR_ID_embedding\n",
      " processing ... ROLE_FAMILY_DESC_embedding\n",
      " processing ... ROLE_FAMILY_embedding\n",
      " processing ... ROLE_CODE_embedding\n",
      "Setup compelete\n"
     ]
    }
   ],
   "source": [
    "model = history.model\n",
    "embedding_vector_dict = {}\n",
    "embedding_vector_column = {}\n",
    "for feature in data_embedding_train.columns:\n",
    "    print(f' processing ... {feature}_embedding')\n",
    "    embedding_vector_dict[feature] = model.get_layer(f'{feature}_embedding').get_weights()[0]\n",
    "    embedding_vector_column[feature] = [f'{feature}_emb_{i}' for i in range(embedding_vector_dict[feature].shape[1])]\n",
    "print('Setup compelete')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:57:36.915496Z",
     "start_time": "2019-08-11T16:57:36.908963Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_embedding_vector(feature, feature_label, embedding_vector_dict):\n",
    "    return embedding_vector_dict[feature][feature_label - 1,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:57:37.009358Z",
     "start_time": "2019-08-11T16:57:36.919941Z"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "data_embedding_train = data_embedding_train.astype(int).reset_index(drop=True)\n",
    "data_embedding_val = data_embedding_val.astype(int).reset_index(drop=True)\n",
    "\n",
    "data_embedding_train_prepared = data_embedding_train.copy()\n",
    "data_embedding_val_prepared = data_embedding_val.copy()\n",
    "\n",
    "for feature in data_embedding_train.columns:\n",
    "    # train converting\n",
    "    tmp_train_features_df = pd.DataFrame(get_embedding_vector(feature, data_embedding_train[feature],\n",
    "                                                             embedding_vector_dict),\n",
    "                                             columns=embedding_vector_column[f'{feature}'])\n",
    "\n",
    "    # test converting\n",
    "    tmp_test_features_df = pd.DataFrame(get_embedding_vector(feature,data_embedding_val[feature],\n",
    "                                                            embedding_vector_dict),\n",
    "                                    columns=embedding_vector_column[f'{feature}'])\n",
    "    # train concat\n",
    "    data_embedding_train_prepared = pd.concat([data_embedding_train_prepared, tmp_train_features_df],\n",
    "                                               axis = 1)\n",
    "    # test concat\n",
    "    data_embedding_val_prepared = pd.concat([data_embedding_val_prepared, tmp_test_features_df],\n",
    "                                             axis = 1)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:57:37.024992Z",
     "start_time": "2019-08-11T16:57:37.015458Z"
    }
   },
   "outputs": [],
   "source": [
    "from pandas.core.common import flatten\n",
    "EMBEDDING_COLS = list(flatten(embedding_vector_column.values()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-11T16:57:44.227620Z",
     "start_time": "2019-08-11T16:57:37.031708Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Embedding encoding: 0.6114176449852051\n",
      "Xgboost Embedding encoding: 0.7658081676690203\n"
     ]
    }
   ],
   "source": [
    "embedding_logit_score = get_score(LogReg_model, \n",
    "                                  data_embedding_train_prepared[EMBEDDING_COLS],\n",
    "                                  y_train,\n",
    "                                  data_embedding_val_prepared[EMBEDDING_COLS],\n",
    "                                  y_val)\n",
    "embedding_xgb_score = get_score(xgb_model,\n",
    "                                data_embedding_train_prepared[EMBEDDING_COLS],\n",
    "                                y_train,\n",
    "                                data_embedding_val_prepared[EMBEDDING_COLS],\n",
    "                                y_val)\n",
    "print('Logistic Regression Embedding encoding:', embedding_logit_score)\n",
    "print('Xgboost Embedding encoding:', embedding_xgb_score)\n",
    "# # Embedding"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "encoding": "# -*- coding: utf-8 -*-",
   "notebook_metadata_filter": "-all",
   "text_representation": {
    "extension": ".py",
    "format_name": "light"
   }
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}