titanic-survival-predictions-xgb-v2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['gender_submission.csv', 'test.csv', 'train.csv']\n"
     ]
    }
   ],
   "source": [
    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
    "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n",
    "# For example, here's several helpful packages to load in \n",
    "\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "\n",
    "# Input data files are available in the \"../input/\" directory.\n",
    "# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n",
    "\n",
    "import os\n",
    "print(os.listdir(\"../input\"))\n",
    "\n",
    "# Any results you write to the current directory are saved as output.\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.preprocessing import RobustScaler, MinMaxScaler\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "from sklearn.metrics import accuracy_score, make_scorer\n",
    "from sklearn.metrics import roc_curve, auc, accuracy_score\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "import lightgbm as lgb\n",
    "import xgboost as xgb\n",
    "from catboost import CatBoostClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "_uuid": "22ce767bc1537c89ab7e60182806031caa20cbaa"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PassengerId</th>\n",
       "      <th>Survived</th>\n",
       "      <th>Pclass</th>\n",
       "      <th>Sex</th>\n",
       "      <th>Age</th>\n",
       "      <th>Embarked</th>\n",
       "      <th>Title</th>\n",
       "      <th>FamilySize</th>\n",
       "      <th>Cabin1</th>\n",
       "      <th>Single</th>\n",
       "      <th>SmallF</th>\n",
       "      <th>MedF</th>\n",
       "      <th>LargeF</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>22.0</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>38.0</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>26.0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>35.0</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   PassengerId  Survived  Pclass  Sex   Age  Embarked  Title  FamilySize  \\\n",
       "0            1         0       3    1  22.0         2      4           2   \n",
       "1            2         1       1    0  38.0         0      5           2   \n",
       "2            3         1       3    0  26.0         2      1           1   \n",
       "3            4         1       1    0  35.0         2      5           2   \n",
       "4            5         0       3    1  35.0         2      4           1   \n",
       "\n",
       "   Cabin1  Single  SmallF  MedF  LargeF  \n",
       "0       8       0       1     0       0  \n",
       "1       2       0       1     0       0  \n",
       "2       8       1       0     0       0  \n",
       "3       2       0       1     0       0  \n",
       "4       8       1       0     0       0  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def read_and_clean(file_name):\n",
    "    scalers = []\n",
    "    data_full = pd.read_csv(file_name)\n",
    "    \n",
    "    # parse names to extract title information\n",
    "    dataset_title = [i.split(\",\")[1].split(\".\")[0].strip() for i in data_full[\"Name\"]]\n",
    "    data_full[\"Title\"] = pd.Series(dataset_title)\n",
    "    data_full[\"Title\"] = data_full[\"Title\"].replace(['Lady', 'the Countess','Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')\n",
    "    \n",
    "    data_full['FamilySize'] = data_full['SibSp'] + data_full['Parch'] + 1\n",
    "    data_full.drop(['Name','SibSp','Parch','Ticket','Fare'], axis=1, inplace=True)    \n",
    "\n",
    "    #cleanup\n",
    "    age_mean = data_full['Age'].mean()\n",
    "    # Replace the Cabin number by the type of cabin 'Z' if not\n",
    "    values = {'Cabin':'Z','Embarked':'S','Age':age_mean}\n",
    "    data_full.fillna(value=values,inplace=True)\n",
    "    data_full['Cabin1'] = data_full['Cabin'].str[0]    \n",
    "    data_full.drop(['Cabin'], axis=1, inplace=True)    \n",
    "    \n",
    "    #encode labels\n",
    "    data_full['Sex'] = LabelEncoder().fit_transform(data_full['Sex'].values)\n",
    "    data_full['Cabin1'] = LabelEncoder().fit_transform(data_full['Cabin1'].values)\n",
    "    data_full['Embarked'] = LabelEncoder().fit_transform(data_full['Embarked'].values)\n",
    "    data_full['Title'] = LabelEncoder().fit_transform(data_full['Title'].values)\n",
    "        \n",
    "    data_full.dropna(inplace=True)\n",
    "    \n",
    "    # Create new feature of family size\n",
    "    data_full['Single'] = data_full['FamilySize'].map(lambda s: 1 if s == 1 else 0)\n",
    "    data_full['SmallF'] = data_full['FamilySize'].map(lambda s: 1 if  s == 2  else 0)\n",
    "    data_full['MedF'] = data_full['FamilySize'].map(lambda s: 1 if 3 <= s <= 4 else 0)\n",
    "    data_full['LargeF'] = data_full['FamilySize'].map(lambda s: 1 if s >= 5 else 0)    \n",
    "    \n",
    "    return data_full\n",
    "\n",
    "dataset = read_and_clean('../input/train.csv')\n",
    "dataset.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Frequency')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "count_classes = pd.value_counts(dataset.Survived, sort = True).sort_index()\n",
    "count_classes.plot(kind = 'bar')\n",
    "plt.title(\"histogram\")\n",
    "plt.xlabel(\"traget\")\n",
    "plt.ylabel(\"Frequency\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 1.0, 1: 1.61}\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "def get_class_weights(y):\n",
    "    counter = Counter(y)\n",
    "    majority = max(counter.values())\n",
    "    return  {cls: round(float(majority)/float(count), 2) for cls, count in counter.items()}\n",
    "\n",
    "\n",
    "# Convert target to categorical\n",
    "#col = pd.Categorical(dataset.Survived)\n",
    "#dataset[\"Survived\"] = col.codes\n",
    "\n",
    "class_weights = get_class_weights(dataset.Survived.values)\n",
    "print(class_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "_uuid": "130774dc33fcbcbfbf9b1fc43123ba266ca94773"
   },
   "outputs": [],
   "source": [
    "def scale_dataset(dataset):\n",
    "    scalers = {}\n",
    "    for column in columns_to_scale:\n",
    "        scaler = RobustScaler()\n",
    "        dataset[column] = scaler.fit_transform(dataset[column].values.reshape(-1, 1))\n",
    "        scalers[column] = scaler\n",
    "    return dataset, scalers\n",
    "    \n",
    "    \n",
    "working_columns = ['Pclass','Sex','Age', 'Embarked','FamilySize','Cabin1','Title', 'Single','SmallF','MedF','LargeF']\n",
    "columns_to_scale = ['Age']\n",
    "\n",
    "# Get columns list for categorical and numerical\n",
    "#categorical_features = df.select_dtypes('int64').columns.tolist()\n",
    "#numerical_features = df.select_dtypes('float64').columns.tolist()\n",
    "    \n",
    "# Splitting into labels and data\n",
    "#dataset, scalers = scale_dataset(dataset)\n",
    "y_source = dataset['Survived']\n",
    "X_source = dataset[working_columns]\n",
    "\n",
    "# Splitting the dataset into the Training set and Test set\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_source, y_source, test_size = 0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numba import jit\n",
    "from sklearn import metrics\n",
    "import time\n",
    "import datetime\n",
    "\n",
    "SEED = 42\n",
    "\n",
    "@jit\n",
    "def fast_auc(y_true, y_prob):\n",
    "    \"\"\"\n",
    "    fast roc_auc computation: https://www.kaggle.com/c/microsoft-malware-prediction/discussion/76013\n",
    "    \"\"\"\n",
    "    y_true = np.asarray(y_true)\n",
    "    y_true = y_true[np.argsort(y_prob)]\n",
    "    nfalse = 0\n",
    "    auc = 0\n",
    "    n = len(y_true)\n",
    "    for i in range(n):\n",
    "        y_i = y_true[i]\n",
    "        nfalse += (1 - y_i)\n",
    "        auc += y_i * nfalse\n",
    "    auc /= (nfalse * (n - nfalse))\n",
    "    return auc\n",
    "\n",
    "\n",
    "def eval_auc(y_true, y_pred):\n",
    "    \"\"\"\n",
    "    Fast auc eval function for lgb.\n",
    "    \"\"\"\n",
    "    return 'auc', fast_auc(y_true, y_pred), True\n",
    "\n",
    "\n",
    "def train_model_classification(X, X_test, y, params, folds, model_type='lgb', eval_metric='auc', columns=None, \n",
    "                               plot_feature_importance=False, model=None, verbose=10000, early_stopping_rounds=200, \n",
    "                               n_estimators=50000, splits=None, n_folds=3, averaging='usual', n_jobs=-1):\n",
    "    \"\"\"\n",
    "    A function to train a variety of classification models.\n",
    "    Returns dictionary with oof predictions, test predictions, scores and, if necessary, feature importances.\n",
    "    \n",
    "    :params: X - training data, can be pd.DataFrame or np.ndarray (after normalizing)\n",
    "    :params: X_test - test data, can be pd.DataFrame or np.ndarray (after normalizing)\n",
    "    :params: y - target\n",
    "    :params: folds - folds to split data\n",
    "    :params: model_type - type of model to use\n",
    "    :params: eval_metric - metric to use\n",
    "    :params: columns - columns to use. If None - use all columns\n",
    "    :params: plot_feature_importance - whether to plot feature importance of LGB\n",
    "    :params: model - sklearn model, works only for \"sklearn\" model type\n",
    "    \n",
    "    \"\"\"\n",
    "    columns = X.columns if columns is None else columns\n",
    "    n_splits = folds.n_splits if splits is None else n_folds\n",
    "    X_test = X_test[columns]\n",
    "    \n",
    "    # to set up scoring parameters\n",
    "    metrics_dict = {'auc': {'lgb_metric_name': eval_auc,\n",
    "                        'catboost_metric_name': 'AUC',\n",
    "                        'sklearn_scoring_function': metrics.roc_auc_score},\n",
    "                    }\n",
    "    \n",
    "    result_dict = {}\n",
    "    if averaging == 'usual':\n",
    "        # out-of-fold predictions on train data\n",
    "        oof = np.zeros((len(X), 1))\n",
    "\n",
    "        # averaged predictions on train data\n",
    "        prediction = np.zeros((len(X_test), 1))\n",
    "        \n",
    "    elif averaging == 'rank':\n",
    "        # out-of-fold predictions on train data\n",
    "        oof = np.zeros((len(X), 1))\n",
    "\n",
    "        # averaged predictions on train data\n",
    "        prediction = np.zeros((len(X_test), 1))\n",
    "\n",
    "    \n",
    "    # list of scores on folds\n",
    "    scores = []\n",
    "    feature_importance = pd.DataFrame()\n",
    "    \n",
    "    # split and train on folds\n",
    "    for fold_n, (train_index, valid_index) in enumerate(folds.split(X)):\n",
    "        print(f'Fold {fold_n + 1} started at {time.ctime()}')\n",
    "        if type(X) == np.ndarray:\n",
    "            X_train, X_valid = X[columns][train_index], X[columns][valid_index]\n",
    "            y_train, y_valid = y[train_index], y[valid_index]\n",
    "        else:\n",
    "            X_train, X_valid = X[columns].iloc[train_index], X[columns].iloc[valid_index]\n",
    "            y_train, y_valid = y.iloc[train_index], y.iloc[valid_index]\n",
    "            \n",
    "        if model_type == 'lgb':\n",
    "            model = lgb.LGBMClassifier(**params, n_estimators=n_estimators, n_jobs = n_jobs, random_state=SEED)\n",
    "            model.fit(X_train, y_train, \n",
    "                    eval_set=[(X_train, y_train), (X_valid, y_valid)], eval_metric=metrics_dict[eval_metric]['lgb_metric_name'],\n",
    "                    verbose=verbose, early_stopping_rounds=early_stopping_rounds)\n",
    "            \n",
    "            y_pred_valid = model.predict_proba(X_valid)[:, 1]\n",
    "            y_pred = model.predict_proba(X_test, num_iteration=model.best_iteration_)[:, 1]\n",
    "            \n",
    "        if model_type == 'xgb':\n",
    "            train_data = xgb.DMatrix(data=X_train, label=y_train, feature_names=X.columns)\n",
    "            valid_data = xgb.DMatrix(data=X_valid, label=y_valid, feature_names=X.columns)\n",
    "\n",
    "            watchlist = [(train_data, 'train'), (valid_data, 'valid_data')]\n",
    "            model = xgb.train(dtrain=train_data, num_boost_round=n_estimators, evals=watchlist, early_stopping_rounds=early_stopping_rounds, \n",
    "                              verbose_eval=verbose, params=params)\n",
    "            y_pred_valid = model.predict(xgb.DMatrix(X_valid, feature_names=X.columns), ntree_limit=model.best_ntree_limit)\n",
    "            y_pred = model.predict(xgb.DMatrix(X_test, feature_names=X.columns), ntree_limit=model.best_ntree_limit)\n",
    "        \n",
    "        if model_type == 'sklearn':\n",
    "            model = model\n",
    "            model.fit(X_train, y_train)\n",
    "            \n",
    "            y_pred_valid = model.predict(X_valid).reshape(-1,)\n",
    "            score = metrics_dict[eval_metric]['sklearn_scoring_function'](y_valid, y_pred_valid)\n",
    "            print(f'Fold {fold_n}. {eval_metric}: {score:.4f}.')\n",
    "            print('')\n",
    "            \n",
    "            y_pred = model.predict_proba(X_test)\n",
    "        \n",
    "        if model_type == 'cat':\n",
    "            model = CatBoostClassifier(iterations=n_estimators, eval_metric=metrics_dict[eval_metric]['catboost_metric_name'], **params#,\n",
    "                                      #loss_function='LogLoss'\n",
    "                                      )\n",
    "            model.fit(X_train, y_train, eval_set=(X_valid, y_valid), cat_features=[], use_best_model=True, verbose=False)\n",
    "\n",
    "            y_pred_valid = model.predict(X_valid)\n",
    "            y_pred = model.predict(X_test)\n",
    "        \n",
    "        if averaging == 'usual':\n",
    "            \n",
    "            oof[valid_index] = y_pred_valid.reshape(-1, 1)\n",
    "            scores.append(metrics_dict[eval_metric]['sklearn_scoring_function'](y_valid, y_pred_valid))\n",
    "            \n",
    "            prediction += y_pred.reshape(-1, 1)\n",
    "\n",
    "        elif averaging == 'rank':\n",
    "                                  \n",
    "            oof[valid_index] = y_pred_valid.reshape(-1, 1)\n",
    "            scores.append(metrics_dict[eval_metric]['sklearn_scoring_function'](y_valid, y_pred_valid))\n",
    "                                  \n",
    "            prediction += pd.Series(y_pred).rank().values.reshape(-1, 1)        \n",
    "        \n",
    "        if model_type == 'lgb' and plot_feature_importance:\n",
    "            # feature importance\n",
    "            fold_importance = pd.DataFrame()\n",
    "            fold_importance[\"feature\"] = columns\n",
    "            fold_importance[\"importance\"] = model.feature_importances_\n",
    "            fold_importance[\"fold\"] = fold_n + 1\n",
    "            feature_importance = pd.concat([feature_importance, fold_importance], axis=0)\n",
    "\n",
    "    prediction /= n_splits\n",
    "    \n",
    "    print('CV mean score: {0:.4f}, std: {1:.4f}.'.format(np.mean(scores), np.std(scores)))\n",
    "    \n",
    "    result_dict['oof'] = oof\n",
    "    result_dict['prediction'] = prediction\n",
    "    result_dict['scores'] = scores\n",
    "    result_dict['model'] = model\n",
    "    \n",
    "    if model_type == 'lgb':\n",
    "        if plot_feature_importance:\n",
    "            feature_importance[\"importance\"] /= n_splits\n",
    "            cols = feature_importance[[\"feature\", \"importance\"]].groupby(\"feature\").mean().sort_values(\n",
    "                by=\"importance\", ascending=False)[:50].index\n",
    "\n",
    "            best_features = feature_importance.loc[feature_importance.feature.isin(cols)]\n",
    "\n",
    "            plt.figure(figsize=(16, 12));\n",
    "            sns.barplot(x=\"importance\", y=\"feature\", data=best_features.sort_values(by=\"importance\", ascending=False));\n",
    "            plt.title('LGB Features (avg over folds)');\n",
    "            \n",
    "            result_dict['feature_importance'] = feature_importance\n",
    "            result_dict['top_columns'] = cols\n",
    "        \n",
    "    return result_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'cat_cols' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-7e32f647df38>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m           \u001b[0;34m'reg_lambda'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m0.3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m           \u001b[0;34m'colsample_bytree'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m0.9\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m           \u001b[0;34m'categorical_feature'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mcat_cols\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m          }\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'cat_cols' is not defined"
     ]
    }
   ],
   "source": [
    "xgb_params = {\n",
    "          'objective': 'binary:logistic',\n",
    "          'min_child_samples': 79,\n",
    "          \"bagging_seed\": 11,\n",
    "          \"metric\": 'auc',\n",
    "          \"verbosity\": 1,\n",
    "          'reg_alpha': 0.3,\n",
    "          'reg_lambda': 0.3,\n",
    "          'colsample_bytree': 0.9,                            \n",
    "          'categorical_feature': cat_cols\n",
    "         }\n",
    "\n",
    "xgb_params_cv = {\n",
    "          'num_leaves': [64, 80],\n",
    "          'learning_rate': [0.072,0.071],\n",
    "          'min_child_samples': [1],\n",
    "          \"subsample_freq\": [3],\n",
    "          \"subsample\": [0.8,0.7],\n",
    "          'reg_alpha': [0.3],\n",
    "          'reg_lambda': [0.01],\n",
    "          'colsample_bytree': [0.9],\n",
    "         }\n",
    "\n",
    "\n",
    "xgb_model = xgb.XGBClassifier(**xgb_params)\n",
    "grid = GridSearchCV(estimator = xgb_model, param_grid = xgb_params_cv)\n",
    "grid_model = grid.fit(X_source, y_source)\n",
    "\n",
    "print(f'best_score: {grid_model.best_score_}')\n",
    "print(f'best_params: {grid_model.best_params_}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold 1 started at Fri Dec 27 18:57:33 2019\n",
      "[0]\ttrain-error:0.168539\tvalid_data-error:0.134529\n",
      "Multiple eval metrics have been passed: 'valid_data-error' will be used for early stopping.\n",
      "\n",
      "Will train until valid_data-error hasn't improved in 100 rounds.\n",
      "[100]\ttrain-error:0.092135\tvalid_data-error:0.134529\n",
      "Stopping. Best iteration:\n",
      "[65]\ttrain-error:0.101124\tvalid_data-error:0.116592\n",
      "\n",
      "Fold 2 started at Fri Dec 27 18:57:33 2019\n",
      "[0]\ttrain-error:0.148315\tvalid_data-error:0.206278\n",
      "Multiple eval metrics have been passed: 'valid_data-error' will be used for early stopping.\n",
      "\n",
      "Will train until valid_data-error hasn't improved in 100 rounds.\n",
      "[100]\ttrain-error:0.085393\tvalid_data-error:0.183857\n",
      "Stopping. Best iteration:\n",
      "[14]\ttrain-error:0.12809\tvalid_data-error:0.170404\n",
      "\n",
      "Fold 3 started at Fri Dec 27 18:57:33 2019\n",
      "[0]\ttrain-error:0.143498\tvalid_data-error:0.175676\n",
      "Multiple eval metrics have been passed: 'valid_data-error' will be used for early stopping.\n",
      "\n",
      "Will train until valid_data-error hasn't improved in 100 rounds.\n",
      "[100]\ttrain-error:0.089686\tvalid_data-error:0.202703\n",
      "Stopping. Best iteration:\n",
      "[0]\ttrain-error:0.143498\tvalid_data-error:0.175676\n",
      "\n",
      "CV mean score: 0.8685, std: 0.0153.\n"
     ]
    }
   ],
   "source": [
    "cat_cols = ['Pclass','Sex','Age', 'Embarked','FamilySize','Cabin1','Title', 'Single']\n",
    "\n",
    "lgb_params = {'num_leaves': 256,\n",
    "          'min_child_samples': 79,\n",
    "          'objective': 'binary',\n",
    "          'max_depth': 13,\n",
    "          'learning_rate': 0.03,\n",
    "          \"boosting_type\": \"gbdt\",\n",
    "          \"subsample_freq\": 3,\n",
    "          \"subsample\": 0.9,\n",
    "          \"bagging_seed\": 11,\n",
    "          \"metric\": 'auc',\n",
    "          \"verbosity\": -1,\n",
    "          'reg_alpha': 0.3,\n",
    "          'reg_lambda': 0.3,\n",
    "          'colsample_bytree': 0.9,\n",
    "          'categorical_feature': cat_cols\n",
    "         }\n",
    "\n",
    "cat_params = {\n",
    "          'objective': 'binary',\n",
    "          'max_depth': 13,\n",
    "          'learning_rate': 0.03,\n",
    "          \"subsample\": 0.9,\n",
    "          #'categorical_feature': cat_cols\n",
    "         }\n",
    "\n",
    "#{'colsample_bytree': 0.9, 'learning_rate': 0.07, 'min_child_samples': 1, 'num_leaves': 64, 'reg_alpha': 0.3, 'reg_lambda': 0.01, \n",
    "# 'subsample': 0.7, 'subsample_freq': 3}\n",
    "\n",
    "xgb_params = {'num_leaves': 64,\n",
    "          'objective': 'binary:logistic',\n",
    "          'learning_rate': 0.07,\n",
    "          'min_child_samples': 1,\n",
    "          \"subsample_freq\": 3,\n",
    "          \"subsample\": 0.7,\n",
    "          \"bagging_seed\": 11,\n",
    "          \"metric\": 'auc',\n",
    "          \"verbosity\": 1,\n",
    "          'reg_alpha': 0.3,\n",
    "          'reg_lambda': 0.01,\n",
    "          'colsample_bytree': 0.9,                            \n",
    "          'categorical_feature': cat_cols\n",
    "         }\n",
    "\n",
    "n_fold = 3\n",
    "folds = KFold(n_splits=3)\n",
    "\n",
    "result_dict = train_model_classification(X=X_train, X_test=X_test, y=y_train, params=xgb_params, \n",
    "        folds=folds, model_type='xgb', plot_feature_importance=True,\n",
    "        verbose=100, early_stopping_rounds=100, n_estimators=5000, averaging='usual', n_jobs=-1)\n",
    "\n",
    "model = result_dict['model']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LGB: CV mean score: 0.8634, std: 0.0285.\n",
    "XGB: CV mean score: 0.8636, std: 0.0185."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import roc_auc_score, roc_curve, accuracy_score\n",
    "\n",
    "y_pred = model.predict(xgb.DMatrix(X_test))\n",
    "\n",
    "fpr, tpr, _ = roc_curve(y_test,  y_pred)\n",
    "auc = roc_auc_score(y_test, y_pred)\n",
    "plt.plot(fpr,tpr,label=\"data 1, auc=\"+str(auc))\n",
    "plt.legend(loc=4)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "_uuid": "ef10a67c00527d1b624c4e4db75e244365b47bbd"
   },
   "outputs": [],
   "source": [
    "test_df = read_and_clean('../input/test.csv')\n",
    "\n",
    "#for column in scalers:\n",
    "#    scaler = scalers[column]\n",
    "#    test_df[column] = scaler.transform(test_df[column].values.reshape(-1, 1))\n",
    "\n",
    "predictions = model.predict(xgb.DMatrix(test_df[working_columns]))\n",
    "\n",
    "submission = pd.DataFrame({\n",
    "        \"PassengerId\": test_df[\"PassengerId\"],\n",
    "        \"Survived\": predictions\n",
    "    })\n",
    "\n",
    "submission.Survived = submission.Survived.apply(lambda x : 1 if x > 0.49 else 0)\n",
    "submission.to_csv('submission.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PassengerId</th>\n",
       "      <th>Survived</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>892</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>893</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>894</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>895</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>896</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>897</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>898</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>899</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>900</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>901</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>902</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>903</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>904</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>905</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>906</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>907</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>908</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>909</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>910</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>911</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>912</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>913</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>914</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>915</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>916</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    PassengerId  Survived\n",
       "0           892         0\n",
       "1           893         0\n",
       "2           894         0\n",
       "3           895         0\n",
       "4           896         0\n",
       "5           897         0\n",
       "6           898         1\n",
       "7           899         0\n",
       "8           900         0\n",
       "9           901         0\n",
       "10          902         0\n",
       "11          903         0\n",
       "12          904         1\n",
       "13          905         0\n",
       "14          906         1\n",
       "15          907         1\n",
       "16          908         0\n",
       "17          909         0\n",
       "18          910         1\n",
       "19          911         1\n",
       "20          912         0\n",
       "21          913         1\n",
       "22          914         1\n",
       "23          915         0\n",
       "24          916         1"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "submission.head(25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}