feature-extraction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # linear algebra\n",
    "import pandas as pd\n",
    "import gc\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.preprocessing import scale\n",
    "from sklearn import preprocessing\n",
    "from scipy import stats\n",
    "from scipy.stats import boxcox\n",
    "from scipy.stats import skew\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import gridspec\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load categorical and numerical features from train and test data sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
    "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "########### TRAIN #############\n",
    "# Load data sets\n",
    "train=pd.read_csv('inputs/train.csv')\n",
    "loss=train.loss\n",
    "train.drop(['id','loss'],axis=1,inplace=True)\n",
    "\n",
    "# Seperate numerical and categorical features\n",
    "tr_num_feat=train.select_dtypes(exclude='object')\n",
    "tr_cat_feat=train.select_dtypes(include='object')\n",
    "\n",
    "# Record numerical and categorical columns\n",
    "tr_num_cols=tr_num_feat.columns\n",
    "tr_cat_cols=tr_cat_feat.columns\n",
    "\n",
    "# Delete train data frame to save RAM\n",
    "del train\n",
    "gc.collect()\n",
    "\n",
    "########### TEST #############\n",
    "# Load data sets\n",
    "test=pd.read_csv('inputs/test.csv')\n",
    "test_id=test.id\n",
    "test.drop(['id'],axis=1,inplace=True)\n",
    "\n",
    "# Seperate numerical and categorical features\n",
    "te_num_feat=test.select_dtypes(exclude='object')\n",
    "te_cat_feat=test.select_dtypes(include='object')\n",
    "\n",
    "# Record numerical and categorical columns\n",
    "te_num_cols=te_num_feat.columns\n",
    "te_cat_cols=te_cat_feat.columns\n",
    "\n",
    "# Delete train data set\n",
    "del test\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A. Numerical features <br>\n",
    "### 1. Transformation <br>\n",
    "#### 1.1 Record feature skewness before the transformation <br>\n",
    "Note skewness for the noraml distribution should be about zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "########### TRAIN #############\n",
    "# Record absolute skewness of the numeric features before feature transformation\n",
    "tr_away_from_zero=[]\n",
    "for feat in tr_num_cols:\n",
    "    tr_away_from_zero.append(np.abs(0-skew(tr_num_feat[feat])))\n",
    "    \n",
    "########### TEST #############    \n",
    "# Record absolute skewness of the numeric features before feature transformation\n",
    "te_away_from_zero=[]\n",
    "for feat in te_num_cols:\n",
    "    te_away_from_zero.append(np.abs(0-skew(te_num_feat[feat])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2 Add all appropriate transformations for each features in a list <br>\n",
    "Selection of each transformation is done manually with the aim of pushing skewness value for each features from the train set to below 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "########### TRAIN #############\n",
    "# Record appropriate feature transformations\n",
    "tr_temp=[boxcox(tr_num_feat[tr_num_cols[0]]+1)[0],\n",
    "      np.tan(tr_num_feat[tr_num_cols[1]]),\n",
    "      tr_num_feat[tr_num_cols[2]],\n",
    "     boxcox(tr_num_feat[tr_num_cols[3]])[0],\n",
    "     np.sqrt(MinMaxScaler().fit_transform(np.array(tr_num_feat['cont5']).reshape(-1,1))),\n",
    "     (tr_num_feat[tr_num_cols[5]])**0.5,\n",
    "     boxcox(tr_num_feat[tr_num_cols[6]])[0],\n",
    "     np.sqrt(MinMaxScaler().fit_transform(np.array(tr_num_feat['cont8']).reshape(-1,1))),\n",
    "     boxcox(tr_num_feat[tr_num_cols[8]]+1)[0],\n",
    "     boxcox(tr_num_feat[tr_num_cols[9]]+1)[0],\n",
    "     np.sqrt(MinMaxScaler().fit_transform(np.array(tr_num_feat['cont11']).reshape(-1,1))),\n",
    "     np.sqrt(MinMaxScaler().fit_transform(np.array(tr_num_feat['cont12']).reshape(-1,1))),\n",
    "     np.log(MinMaxScaler().fit_transform(np.array(tr_num_feat['cont5']).reshape(-1,1))+0.1),\n",
    "     (tr_num_feat[tr_num_cols[13]])**0.5]\n",
    "\n",
    "########### TEST #############\n",
    "# Record appropriate feature transformations\n",
    "te_temp=[boxcox(te_num_feat[te_num_cols[0]]+1)[0],\n",
    "      np.tan(te_num_feat[te_num_cols[1]]),\n",
    "      te_num_feat[te_num_cols[2]],\n",
    "     boxcox(te_num_feat[te_num_cols[3]])[0],\n",
    "     np.sqrt(MinMaxScaler().fit_transform(np.array(te_num_feat['cont5']).reshape(-1,1))),\n",
    "     (te_num_feat[te_num_cols[5]])**0.5,\n",
    "     boxcox(te_num_feat[te_num_cols[6]])[0],\n",
    "     np.sqrt(MinMaxScaler().fit_transform(np.array(te_num_feat['cont8']).reshape(-1,1))),\n",
    "     boxcox(te_num_feat[te_num_cols[8]]+1)[0],\n",
    "     boxcox(te_num_feat[te_num_cols[9]]+1)[0],\n",
    "     np.sqrt(MinMaxScaler().fit_transform(np.array(te_num_feat['cont11']).reshape(-1,1))),\n",
    "     np.sqrt(MinMaxScaler().fit_transform(np.array(te_num_feat['cont12']).reshape(-1,1))),\n",
    "     np.log(MinMaxScaler().fit_transform(np.array(te_num_feat['cont5']).reshape(-1,1))+0.1),\n",
    "     (te_num_feat[te_num_cols[13]])**0.5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.3 Observe skewness after the transformation and compre it with the features before transformation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum train skew after transformation is 0.09295090402153014\n",
      "Maximum test skew after transformation is 0.09834972857117359\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "########### TRAIN #############\n",
    "# Record absolute skewness of the features after feature transformation\n",
    "tr_new_away_from_zero=[]\n",
    "for s in tr_temp:\n",
    "    tr_new_away_from_zero.append(abs(0-skew(s)))\n",
    "\n",
    "########### TEST #############\n",
    "# Record absolute skewness of the features after feature transformation\n",
    "te_new_away_from_zero=[]\n",
    "for s in te_temp:\n",
    "    te_new_away_from_zero.append(abs(0-skew(s)))\n",
    "\n",
    "# let's check improvement in feature skewness after feature transformation\n",
    "fig,ax=plt.subplots(nrows=2,ncols=1,figsize=(12,10))\n",
    "fig.tight_layout(pad=5)\n",
    "ax[0].bar(range(len(tr_away_from_zero)),tr_away_from_zero,width=0.3,label='before transformation')\n",
    "ax[0].bar(np.array(range(len(tr_new_away_from_zero)))+0.5,tr_new_away_from_zero,width=0.3,label='after transformation')\n",
    "ax[0].set_xticks(range(len(tr_away_from_zero)))\n",
    "ax[0].set_xticklabels(tr_num_cols)\n",
    "ax[0].set_ylabel('Absolute skew difference from zero',fontsize=12)\n",
    "ax[0].legend()\n",
    "ax[0].set_title('Train:Feature skewness before and after',fontsize=14)\n",
    "print('Maximum train skew after transformation is',max(tr_new_away_from_zero))\n",
    "\n",
    "ax[1].bar(range(len(te_away_from_zero)),te_away_from_zero,width=0.3,label='before transformation')\n",
    "ax[1].bar(np.array(range(len(te_new_away_from_zero)))+0.5,te_new_away_from_zero,width=0.3,label='after transformation')\n",
    "ax[1].set_xticks(range(len(te_away_from_zero)))\n",
    "ax[1].set_xticklabels(te_num_cols)\n",
    "ax[1].set_ylabel('Absolute skew difference from zero',fontsize=12)\n",
    "ax[1].legend()\n",
    "ax[1].set_title('Test:Feature skewness before and after',fontsize=14)\n",
    "print('Maximum test skew after transformation is',max(te_new_away_from_zero));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.4 Replace the transformed features (with feature standardization) back to the original data frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note: scaling does not change skewness\n",
    "for ind,col in enumerate(tr_num_feat.columns):\n",
    "    tr_num_feat[col]=scale(tr_temp[ind])\n",
    "    \n",
    "for ind,col in enumerate(te_num_feat.columns):\n",
    "    te_num_feat[col]=scale(te_temp[ind])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2 Feature interactions <br>\n",
    "From the exploratory data analysis we recognized the list of feature pairs with high (more than 0.7) linear dependence :\n",
    "<ul>\n",
    "    <li>feat 1 & feat 6</li>\n",
    "    <li>feat 1 & feat 9</li>\n",
    "    <li>feat 1 & feat 10</li>\n",
    "    <li>feat 6 & feat 9</li>\n",
    "    <li>feat 6 & feat 10</li>\n",
    "    <li>feat 6 & feat 11</li>\n",
    "    <li>feat 6 & feat 12</li>\n",
    "    <li>feat 6 & feat 13</li>\n",
    "    <li>feat 7 & feat 11</li>\n",
    "    <li>feat 7 & feat 12</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# idea from https://github.com/alno/kaggle-allstate-claims-severity/blob/master/prepare-tr_numeric-combinations.py\n",
    "tr_num_feat['diff_1_6']=tr_num_feat['cont1']-tr_num_feat['cont6']\n",
    "tr_num_feat['diff_1_9']=tr_num_feat['cont1']-tr_num_feat['cont9']\n",
    "tr_num_feat['diff_1_10']=tr_num_feat['cont1']-tr_num_feat['cont10']\n",
    "tr_num_feat['diff_6_9']=tr_num_feat['cont6']-tr_num_feat['cont9']\n",
    "tr_num_feat['diff_6_10']=tr_num_feat['cont6']-tr_num_feat['cont10']\n",
    "tr_num_feat['diff_6_11']=tr_num_feat['cont6']-tr_num_feat['cont11']\n",
    "tr_num_feat['diff_6_12']=tr_num_feat['cont6']-tr_num_feat['cont12']\n",
    "tr_num_feat['diff_6_13']=tr_num_feat['cont6']-tr_num_feat['cont13']\n",
    "tr_num_feat['diff_7_11']=tr_num_feat['cont7']-tr_num_feat['cont11']\n",
    "tr_num_feat['diff_7_12']=tr_num_feat['cont7']-tr_num_feat['cont12']\n",
    "\n",
    "te_num_feat['diff_1_6']=te_num_feat['cont1']-te_num_feat['cont6']\n",
    "te_num_feat['diff_1_9']=te_num_feat['cont1']-te_num_feat['cont9']\n",
    "te_num_feat['diff_1_10']=te_num_feat['cont1']-te_num_feat['cont10']\n",
    "te_num_feat['diff_6_9']=te_num_feat['cont6']-te_num_feat['cont9']\n",
    "te_num_feat['diff_6_10']=te_num_feat['cont6']-te_num_feat['cont10']\n",
    "te_num_feat['diff_6_11']=te_num_feat['cont6']-te_num_feat['cont11']\n",
    "te_num_feat['diff_6_12']=te_num_feat['cont6']-te_num_feat['cont12']\n",
    "te_num_feat['diff_6_13']=te_num_feat['cont6']-te_num_feat['cont13']\n",
    "te_num_feat['diff_7_11']=te_num_feat['cont7']-te_num_feat['cont11']\n",
    "te_num_feat['diff_7_12']=te_num_feat['cont7']-te_num_feat['cont12']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Save test numeric data frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "te_num_feat.to_csv('inputs/te_num.csv')\n",
    "del te_num_feat\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## B. Categorical features: Encoding <br>\n",
    "## 1. Binary categorical features\n",
    "### 1.1 Binary Encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract binary column names\n",
    "tr_bi_cols=tr_cat_cols[:72]\n",
    "te_bi_cols=te_cat_cols[:72]\n",
    "\n",
    "# Number of rows\n",
    "tr_nrows=tr_cat_feat.shape[0]\n",
    "te_nrows=te_cat_feat.shape[0]\n",
    "\n",
    "# Make copy of binary data frame. We will work on the copied data frame\n",
    "tr_bi_df=tr_cat_feat[tr_bi_cols].copy()\n",
    "te_bi_df=te_cat_feat[te_bi_cols].copy()\n",
    "\n",
    "# Convert categories into 0-1\n",
    "for feat in tr_bi_cols:\n",
    "    tr_bi_df[feat]=tr_bi_df[feat].astype('category').cat.codes\n",
    "    te_bi_df[feat]=te_bi_df[feat].astype('category').cat.codes\n",
    "    \n",
    "# Rename columns\n",
    "tr_bi_dict=dict(zip(tr_bi_cols,['bi_'+col for col in tr_bi_cols]))\n",
    "tr_bi_df.rename(columns=tr_bi_dict, inplace=True)\n",
    "te_bi_df.rename(columns=tr_bi_dict, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Probability encoding of binary values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make copy of the binary encoded data frame\n",
    "tr_ProbBi_df=tr_cat_feat[tr_bi_cols].copy()\n",
    "te_ProbBi_df=te_cat_feat[te_bi_cols].copy()\n",
    "\n",
    "# Convert binary values into probabilities\n",
    "for feat in tr_bi_cols:\n",
    "    tr_ProbBi_dict=dict(zip(tr_ProbBi_df[feat].value_counts().index,tr_ProbBi_df[feat].value_counts()/tr_nrows))\n",
    "    # Use probability values calculated only on the train data set\n",
    "    tr_ProbBi_df[feat].replace(tr_ProbBi_dict,inplace=True)\n",
    "    te_ProbBi_df[feat].replace(tr_ProbBi_dict,inplace=True)\n",
    "    \n",
    "# Rename columns\n",
    "tr_ProbBi_df.rename(columns=dict(zip(tr_bi_cols,['ProbBi_'+col for col in tr_bi_cols])), inplace=True)\n",
    "te_ProbBi_df.rename(columns=dict(zip(te_bi_cols,['ProbBi_'+col for col in te_bi_cols])), inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Multi level categorical encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extract multi level categorical features\n",
    "tr_multi_cols=tr_cat_cols[72:]\n",
    "te_multi_cols=te_cat_cols[72:]\n",
    "\n",
    "# Make copy of multi level categorical features' data frame\n",
    "tr_multi_cat_feat=tr_cat_feat[tr_multi_cols].copy()\n",
    "te_multi_cat_feat=te_cat_feat[te_multi_cols].copy()\n",
    "\n",
    "# Add log loss (shift and scaled) only into train-multi categorical feature data frame\n",
    "tr_multi_cat_feat['log_loss']=np.log(loss+1)**0.25\n",
    "\n",
    "# Remove categorical feature data frame from RAM\n",
    "del tr_cat_feat\n",
    "del te_cat_feat\n",
    "gc.collect()\n",
    "\n",
    "# Make copy of the data frames for each feature engineering method (We will work on the copied data frame)\n",
    "# train\n",
    "tr_min_df=tr_multi_cat_feat.copy()\n",
    "tr_max_df=tr_multi_cat_feat.copy()\n",
    "tr_mean_df=tr_multi_cat_feat.copy()\n",
    "tr_std_df=tr_multi_cat_feat.copy()\n",
    "tr_ohe_df=tr_multi_cat_feat.copy()\n",
    "tr_asci_df=tr_multi_cat_feat.copy()\n",
    "tr_MultiProb_df=tr_multi_cat_feat.copy()\n",
    "\n",
    "# Drop log loss column from the data frames that don't need it\n",
    "tr_ohe_df.drop('log_loss',axis=1,inplace=True)\n",
    "tr_asci_df.drop('log_loss',axis=1,inplace=True)\n",
    "\n",
    "# test\n",
    "te_min_df=te_multi_cat_feat.copy()\n",
    "te_max_df=te_multi_cat_feat.copy()\n",
    "te_mean_df=te_multi_cat_feat.copy()\n",
    "te_std_df=te_multi_cat_feat.copy()\n",
    "te_ohe_df=te_multi_cat_feat.copy()\n",
    "te_asci_df=te_multi_cat_feat.copy()\n",
    "te_MultiProb_df=te_multi_cat_feat.copy()\n",
    "\n",
    "# Remove copied (original) multi level categorical features from RAM\n",
    "del tr_multi_cat_feat\n",
    "del te_multi_cat_feat\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Min of log loss per level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "for feat in tr_multi_cols:\n",
    "    tr_min_dict=dict(tr_min_df.groupby(by=feat,as_index=False)['log_loss'].min().values)\n",
    "    unexpected=set(te_min_df[feat].unique())-set(tr_min_df[feat].unique())\n",
    "    \n",
    "    # Mean of min of log loss over all levels\n",
    "    val=np.mean(np.array([val for val in tr_min_dict.values()]))\n",
    "    \n",
    "    # Encode unexpected levels by val\n",
    "    for cat in unexpected:\n",
    "        tr_min_dict[cat]=val\n",
    "        \n",
    "    # Use values calculated only on the train data set\n",
    "    tr_min_df[feat].replace(tr_min_dict,inplace=True)\n",
    "    te_min_df[feat].replace(tr_min_dict,inplace=True)\n",
    "    \n",
    "# Rename columns\n",
    "tr_min_df.rename(columns=dict(zip(tr_multi_cols,['min_'+col for col in tr_multi_cols])), inplace=True)\n",
    "te_min_df.rename(columns=dict(zip(te_multi_cols,['min_'+col for col in te_multi_cols])), inplace=True)\n",
    "\n",
    "# Drop log loss from train\n",
    "tr_min_df.drop('log_loss',axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Max of log loss per level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "for feat in tr_multi_cols:\n",
    "    tr_max_dict=dict(tr_max_df.groupby(by=feat,as_index=False)['log_loss'].max().values)\n",
    "    unexpected=set(te_max_df[feat].unique())-set(tr_max_df[feat].unique())\n",
    "    \n",
    "    # Mean of max of log loss over all levels\n",
    "    val=np.mean(np.array([val for val in tr_max_dict.values()]))\n",
    "    \n",
    "    # Encode unexpected levels by val\n",
    "    for cat in unexpected:\n",
    "        tr_max_dict[cat]=val\n",
    "    \n",
    "    # Use values calculated only on the train data set\n",
    "    tr_max_df[feat].replace(tr_max_dict,inplace=True)\n",
    "    te_max_df[feat].replace(tr_max_dict,inplace=True)\n",
    "    \n",
    "# Rename column names\n",
    "tr_max_df.rename(columns=dict(zip(tr_multi_cols,['max_'+col for col in tr_multi_cols])), inplace=True)\n",
    "te_max_df.rename(columns=dict(zip(te_multi_cols,['max_'+col for col in te_multi_cols])), inplace=True)\n",
    "\n",
    "# drop log loss column\n",
    "tr_max_df.drop('log_loss',axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Mean of log loss per level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "for feat in tr_multi_cols:\n",
    "    tr_mean_dict=dict(tr_mean_df.groupby(by=feat,as_index=False)['log_loss'].mean().values)\n",
    "    unexpected=set(te_mean_df[feat].unique())-set(tr_mean_df[feat].unique())\n",
    "    \n",
    "    # Mean of mean of log loss over all levels\n",
    "    val=np.mean(np.array([val for val in tr_mean_dict.values()]))\n",
    "    \n",
    "    # Encode unexpected levels by val\n",
    "    for cat in unexpected:\n",
    "        tr_mean_dict[cat]=val\n",
    "        \n",
    "    # Use values calculated only on the train data set  \n",
    "    tr_mean_df[feat].replace(tr_mean_dict,inplace=True)\n",
    "    te_mean_df[feat].replace(tr_mean_dict,inplace=True)\n",
    "    \n",
    "# Rename column names\n",
    "tr_mean_df.rename(columns=dict(zip(tr_multi_cols,['mean_'+col for col in tr_multi_cols])), inplace=True)\n",
    "te_mean_df.rename(columns=dict(zip(te_multi_cols,['mean_'+col for col in te_multi_cols])), inplace=True)\n",
    "\n",
    "# Drop log loss column\n",
    "tr_mean_df.drop('log_loss',axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 Standard deviation of log loss per level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "for feat in tr_multi_cols:\n",
    "    gen=tr_std_df.groupby(by=feat)['log_loss'].std(ddof=0)\n",
    "    tr_std_dict=dict(list(zip(gen.index,gen.values)))\n",
    "    unexpected=set(te_std_df[feat].unique())-set(tr_std_df[feat].unique())\n",
    "    \n",
    "    # Mean of std of log loss over all levels\n",
    "    val=np.mean(np.array([val for val in tr_std_dict.values()]))\n",
    "    \n",
    "    # Encode unexpected levels by val\n",
    "    for cat in unexpected:\n",
    "        tr_std_dict[cat]=val \n",
    "    \n",
    "    # Use values calculated only on the train data set\n",
    "    tr_std_df[feat].replace(tr_std_dict,inplace=True)\n",
    "    te_std_df[feat].replace(tr_std_dict,inplace=True)\n",
    "    \n",
    "# rename column names\n",
    "tr_std_df.rename(columns=dict(zip(tr_multi_cols,['std_'+col for col in tr_multi_cols])), inplace=True)\n",
    "te_std_df.rename(columns=dict(zip(te_multi_cols,['std_'+col for col in te_multi_cols])), inplace=True)\n",
    "\n",
    "# drop log loss column\n",
    "tr_std_df.drop('log_loss',axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5 One hot encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Concat data frames for ohe\n",
    "df=pd.concat([tr_ohe_df,te_ohe_df],ignore_index=False)\n",
    "df=pd.get_dummies(df)\n",
    "\n",
    "# Seperate data frame\n",
    "tr_ohe_df=df.iloc[:tr_nrows]\n",
    "te_ohe_df=df.iloc[tr_nrows:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6 ASCI value encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "for feat in tr_multi_cols:\n",
    "    chars=tr_asci_df[feat].unique()\n",
    "    vals=[]\n",
    "    for char in chars:\n",
    "        if len(char)==1:\n",
    "            vals.append(ord(char))\n",
    "        else:\n",
    "            val=0\n",
    "            for ch in char:\n",
    "                val+=ord(ch)\n",
    "            vals.append(val)\n",
    "    tr_asci_dict=dict(list(zip(chars,vals)))\n",
    "\n",
    "    unexpected=set(te_asci_df[feat].unique())-set(tr_asci_df[feat].unique())\n",
    "    \n",
    "    # Median of asci of log loss over all levels\n",
    "    val=np.median(np.array([val for val in tr_asci_dict.values()]))\n",
    "    \n",
    "    # Encode unexpected levels by val\n",
    "    for cat in unexpected:\n",
    "        tr_asci_dict[cat]=val \n",
    "    \n",
    "    # Use values calculated only on the train data set    \n",
    "    tr_asci_df[feat].replace(tr_asci_dict,inplace=True)\n",
    "    te_asci_df[feat].replace(tr_asci_dict,inplace=True)\n",
    "    \n",
    "# rename column names\n",
    "tr_asci_df.rename(columns=dict(zip(tr_multi_cols,['asci_'+col for col in tr_multi_cols])), inplace=True)\n",
    "te_asci_df.rename(columns=dict(zip(te_multi_cols,['asci_'+col for col in te_multi_cols])), inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.7 Probability encoding of multi level categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "for feat in tr_multi_cols:\n",
    "    tr_MultiProb_dict=dict(zip(tr_MultiProb_df[feat].value_counts().index,tr_MultiProb_df[feat].value_counts()/tr_nrows))\n",
    "    unexpected=set(te_MultiProb_df[feat].unique())-set(tr_MultiProb_df[feat].unique())\n",
    "    \n",
    "    # Mean of probability value over all levels\n",
    "    val=np.mean(np.array([val for val in tr_MultiProb_dict.values()]))\n",
    "    \n",
    "    # Encode unexpected levels by val\n",
    "    for cat in unexpected:\n",
    "        tr_MultiProb_dict[cat]=val \n",
    "    \n",
    "    tr_MultiProb_df[feat].replace(tr_MultiProb_dict,inplace=True)\n",
    "    te_MultiProb_df[feat].replace(tr_MultiProb_dict,inplace=True)\n",
    "\n",
    "for feat in tr_multi_cols:\n",
    "    tr_MultiProb_df[feat]=(tr_MultiProb_df[feat])/tr_nrows\n",
    "    te_MultiProb_df[feat]=(te_MultiProb_df[feat])/te_nrows\n",
    "    \n",
    "# rename column names\n",
    "tr_MultiProb_df.rename(columns=dict(zip(tr_multi_cols,['MultiProb_'+col for col in tr_multi_cols])), inplace=True)\n",
    "te_MultiProb_df.rename(columns=dict(zip(te_multi_cols,['MultiProb_'+col for col in te_multi_cols])), inplace=True)\n",
    "\n",
    "# drop log loss column\n",
    "\n",
    "tr_MultiProb_df.drop('log_loss',axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Join all categorical encoded data frames to one data frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((188318, 72),\n",
       " (188318, 72),\n",
       " (188318, 44),\n",
       " (188318, 44),\n",
       " (188318, 44),\n",
       " (188318, 44),\n",
       " (188318, 1032),\n",
       " (188318, 44),\n",
       " (188318, 44))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Observe shapes\n",
    "tr_bi_df.shape,tr_ProbBi_df.shape,tr_min_df.shape,tr_max_df.shape,tr_mean_df.shape,tr_std_df.shape,tr_ohe_df.shape,tr_asci_df.shape,tr_MultiProb_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((125546, 72),\n",
       " (125546, 72),\n",
       " (125546, 44),\n",
       " (125546, 44),\n",
       " (125546, 44),\n",
       " (125546, 44),\n",
       " (125546, 1032),\n",
       " (125546, 44),\n",
       " (125546, 44))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Observe shapes\n",
    "te_bi_df.shape,te_ProbBi_df.shape,te_min_df.shape,te_max_df.shape,te_mean_df.shape,te_std_df.shape,te_ohe_df.shape,te_asci_df.shape,te_MultiProb_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tr_cat_df=tr_bi_df.copy()\n",
    "te_cat_df=te_bi_df.copy()\n",
    "del tr_bi_df\n",
    "del te_bi_df\n",
    "gc.collect()\n",
    "\n",
    "tr_cat_df=tr_cat_df.join(tr_ProbBi_df)\n",
    "te_cat_df=te_cat_df.join(te_ProbBi_df)\n",
    "del tr_ProbBi_df\n",
    "del te_ProbBi_df\n",
    "gc.collect()\n",
    "\n",
    "tr_cat_df=tr_cat_df.join(tr_min_df)\n",
    "te_cat_df=te_cat_df.join(te_min_df)\n",
    "del tr_min_df\n",
    "del te_min_df\n",
    "gc.collect()\n",
    "\n",
    "tr_cat_df=tr_cat_df.join(tr_max_df)\n",
    "te_cat_df=te_cat_df.join(te_max_df)\n",
    "del tr_max_df\n",
    "del te_max_df\n",
    "gc.collect()\n",
    "\n",
    "tr_cat_df=tr_cat_df.join(tr_mean_df)\n",
    "te_cat_df=te_cat_df.join(te_mean_df)\n",
    "del tr_mean_df\n",
    "del te_mean_df\n",
    "gc.collect()\n",
    "\n",
    "tr_cat_df=tr_cat_df.join(tr_std_df)\n",
    "te_cat_df=te_cat_df.join(te_std_df)\n",
    "del tr_std_df\n",
    "del te_std_df\n",
    "gc.collect()\n",
    "\n",
    "tr_cat_df=tr_cat_df.join(tr_ohe_df)\n",
    "te_cat_df=te_cat_df.join(te_ohe_df)\n",
    "del tr_ohe_df\n",
    "del te_ohe_df\n",
    "gc.collect()\n",
    "\n",
    "tr_cat_df=tr_cat_df.join(tr_asci_df)\n",
    "te_cat_df=te_cat_df.join(te_asci_df)\n",
    "del tr_asci_df\n",
    "del te_asci_df\n",
    "gc.collect()\n",
    "\n",
    "tr_cat_df=tr_cat_df.join(tr_MultiProb_df)\n",
    "te_cat_df=te_cat_df.join(te_MultiProb_df)\n",
    "del tr_MultiProb_df\n",
    "del te_MultiProb_df\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((188318, 1440), (125546, 1440))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tr_cat_df.shape, te_cat_df.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4 Save test data frame of encoded features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "te_cat_df.to_csv('inputs/te_cat.csv')\n",
    "del te_cat_df\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## C. Save main data frame (train with numerical and categorical features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_df=tr_cat_df.join(tr_num_feat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_df.to_csv('inputs/features.csv')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}