code/kaggle-titanic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Kaggle's Titanic dataset classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialization & imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 736,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys, itertools\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV\n",
    "from sklearn.neighbors import KNeighborsClassifier, LocalOutlierFactor\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.metrics import confusion_matrix, classification_report, roc_curve, auc\n",
    "\n",
    "from time import time\n",
    "\n",
    "from customhelpers import EstimatorSelectionHelper, plot_confusion_matrix\n",
    "\n",
    "from IPython.display import display, Markdown"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas & seaborn config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 737,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.height', 1000)\n",
    "pd.set_option('display.max_columns', 500)\n",
    "pd.set_option('display.width', 1000)\n",
    "pd.set_option('chained_assignment', None)\n",
    "\n",
    "sns.set(style=\"dark\", palette=\"hls\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 738,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt_generate_plots            = False\n",
    "opt_get_pca_features          = False\n",
    "opt_estimate_best_classifier  = False\n",
    "opt_remove_outliers           = False\n",
    "opt_find_best_random_state    = False\n",
    "opt_save_submission_output    = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Features & labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 739,
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_features     = ['Age', 'SibSp', 'Parch', 'Fare', 'Embarked', 'Pclass', 'Sex', 'Cabin', 'Ticket', 'Name']\n",
    "labels           = ['Survived']\n",
    "datacolumns      = raw_features+labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CSV Reading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 740,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading CSV...\n"
     ]
    }
   ],
   "source": [
    "print \"Reading CSV...\"\n",
    "df = pd.read_csv(\"../data/input/train.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data exploration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 741,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "### Info"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 891 entries, 0 to 890\n",
      "Data columns (total 12 columns):\n",
      "PassengerId    891 non-null int64\n",
      "Survived       891 non-null int64\n",
      "Pclass         891 non-null int64\n",
      "Name           891 non-null object\n",
      "Sex            891 non-null object\n",
      "Age            714 non-null float64\n",
      "SibSp          891 non-null int64\n",
      "Parch          891 non-null int64\n",
      "Ticket         891 non-null object\n",
      "Fare           891 non-null float64\n",
      "Cabin          204 non-null object\n",
      "Embarked       889 non-null object\n",
      "dtypes: float64(2), int64(5), object(5)\n",
      "memory usage: 83.6+ KB\n",
      "None\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Null counts"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PassengerId      0\n",
      "Survived         0\n",
      "Pclass           0\n",
      "Name             0\n",
      "Sex              0\n",
      "Age            177\n",
      "SibSp            0\n",
      "Parch            0\n",
      "Ticket           0\n",
      "Fare             0\n",
      "Cabin          687\n",
      "Embarked         2\n",
      "dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Describe"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       PassengerId    Survived      Pclass         Age       SibSp       Parch        Fare\n",
      "count   891.000000  891.000000  891.000000  714.000000  891.000000  891.000000  891.000000\n",
      "mean    446.000000    0.383838    2.308642   29.699118    0.523008    0.381594   32.204208\n",
      "std     257.353842    0.486592    0.836071   14.526497    1.102743    0.806057   49.693429\n",
      "min       1.000000    0.000000    1.000000    0.420000    0.000000    0.000000    0.000000\n",
      "25%     223.500000    0.000000    2.000000   20.125000    0.000000    0.000000    7.910400\n",
      "50%     446.000000    0.000000    3.000000   28.000000    0.000000    0.000000   14.454200\n",
      "75%     668.500000    1.000000    3.000000   38.000000    1.000000    0.000000   31.000000\n",
      "max     891.000000    1.000000    3.000000   80.000000    8.000000    6.000000  512.329200\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Sex counts"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "male      577\n",
      "female    314\n",
      "Name: Sex, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Cabin counts"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "?    687\n",
      "C     59\n",
      "B     47\n",
      "D     33\n",
      "E     32\n",
      "A     15\n",
      "F     13\n",
      "G      4\n",
      "T      1\n",
      "Name: Cabin, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Survived counts"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    549\n",
      "1    342\n",
      "Name: Survived, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Embarked counts"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S    644\n",
      "C    168\n",
      "Q     77\n",
      "Name: Embarked, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Correlation"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             PassengerId  Survived    Pclass       Age     SibSp     Parch      Fare\n",
      "PassengerId     1.000000 -0.005007 -0.035144  0.036847 -0.057527 -0.001652  0.012658\n",
      "Survived       -0.005007  1.000000 -0.338481 -0.077221 -0.035322  0.081629  0.257307\n",
      "Pclass         -0.035144 -0.338481  1.000000 -0.369226  0.083081  0.018443 -0.549500\n",
      "Age             0.036847 -0.077221 -0.369226  1.000000 -0.308247 -0.189119  0.096067\n",
      "SibSp          -0.057527 -0.035322  0.083081 -0.308247  1.000000  0.414838  0.159651\n",
      "Parch          -0.001652  0.081629  0.018443 -0.189119  0.414838  1.000000  0.216225\n",
      "Fare            0.012658  0.257307 -0.549500  0.096067  0.159651  0.216225  1.000000\n"
     ]
    }
   ],
   "source": [
    "display(Markdown(\"### Info\"))\n",
    "print df.info()\n",
    "display(Markdown(\"### Null counts\"))\n",
    "print df.isnull().sum(axis=0)\n",
    "display(Markdown(\"### Describe\"))\n",
    "print df.describe()\n",
    "display(Markdown(\"### Sex counts\"))\n",
    "print df['Sex'].dropna().value_counts()\n",
    "display(Markdown(\"### Cabin counts\"))\n",
    "print df['Cabin'].fillna('?').apply(lambda x: x[0]).value_counts()\n",
    "display(Markdown(\"### Survived counts\"))\n",
    "print df['Survived'].dropna().value_counts()\n",
    "display(Markdown(\"### Embarked counts\"))\n",
    "print df['Embarked'].dropna().value_counts()\n",
    "display(Markdown(\"### Correlation\"))\n",
    "print df.corr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 742,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1285bcf8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(2,3,figsize=(15,6))\n",
    "for ax, feature in itertools.izip_longest(axes.flatten(), ['Pclass', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']):\n",
    "    if(feature):\n",
    "        ax.hist(df.dropna()[feature])\n",
    "        ax.set_title(feature)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analysis plots (optional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 743,
   "metadata": {},
   "outputs": [],
   "source": [
    "if(opt_generate_plots):\n",
    "    print \"\\n> Creating plots\"\n",
    "    fg = sns.FacetGrid(df, hue=\"Survived\", size=5, aspect=1.61)\n",
    "    fg.map(plt.scatter, \"Age\", \"Fare\")\n",
    "    fg.add_legend()\n",
    "    fg.savefig(\"../data/output/age_fare_survived.png\")\n",
    "\n",
    "    fg = sns.FacetGrid(df, hue=\"Pclass\", size=5, aspect=1.61)\n",
    "    fg.map(plt.scatter, \"Age\", \"Fare\")\n",
    "    fg.add_legend()\n",
    "    fg.savefig(\"../data/output/age_fare_pclass.png\")\n",
    "\n",
    "    # Boxplot\n",
    "    df[datacolumns].plot(kind='box', subplots=True, layout=(2, 5), figsize=(14, 12), sharex=False, sharey=False, sym=\"bo\")\n",
    "    plt.savefig(\"../data/output/univariate.png\")\n",
    "\n",
    "    # Pairplots\n",
    "    sns_plot = sns.pairplot(df[datacolumns].dropna(), size=5, hue=\"Survived\")\n",
    "    sns_plot.savefig(\"../data/output/pairplot.png\")\n",
    "    print \"Saved to file\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataframe process function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 744,
   "metadata": {},
   "outputs": [],
   "source": [
    "def processDataFrame(df):\n",
    "\n",
    "    def processTicket(ticket):\n",
    "        ticket = ticket.split(' ')[-1]\n",
    "        return int(ticket) if ticket.isdigit() else 0\n",
    "\n",
    "    scale_features  = ['Age', 'Fare', 'Ticket', 'FamilySize']\n",
    "    encode_features = ['Embarked','Pclass','Sex', 'Cabin', 'Name']\n",
    "\n",
    "    # NaN filling\n",
    "    df['Age'].fillna(df['Age'].median(), inplace=True)\n",
    "    df['Embarked'].fillna(df['Embarked'].mode(), inplace=True)\n",
    "    df['Fare'].fillna(df['Fare'].mean(), inplace=True)\n",
    "    df['Cabin'].fillna('Unknown', inplace=True)\n",
    "    \n",
    "    # Feature editing\n",
    "    df['Cabin']  = df['Cabin'].apply(lambda x: x[0])\n",
    "    df['Name']   = df['Name'].apply(lambda x: x.split(',')[1].split('.')[0].strip())\n",
    "    df['Ticket'] = df['Ticket'].apply(processTicket)\n",
    "    \n",
    "    # New features\n",
    "    df['FamilySize'] = df['SibSp'] + df['Parch']\n",
    "    #df['FamilyMemberFare'] = df['FamilySize']/df['Fare']\n",
    "    #df['Ageclass'] = df['Age']*df['Pclass']\n",
    "    df = df.drop(columns=['SibSp', 'Parch'])\n",
    "\n",
    "    # One-hot encoding\n",
    "    pre_features = df.columns.values\n",
    "    df = pd.get_dummies(df, columns=encode_features)\n",
    "    post_features = df.columns.values\n",
    "    diff_features = list(set(post_features) - set(pre_features))\n",
    "\n",
    "    # Drop other NaNs\n",
    "    df = df.dropna()\n",
    "\n",
    "    # Standarization\n",
    "    scaler = StandardScaler()\n",
    "    df[scale_features+diff_features] = scaler.fit_transform(df[scale_features+diff_features].as_matrix())\n",
    "\n",
    "    # PCA\n",
    "    if(opt_get_pca_features):\n",
    "        pca = PCA(n_components=3)\n",
    "        components = pca.fit_transform(df)\n",
    "        df = pd.DataFrame(components, columns=[\"col\" + str(n) for n in xrange(pca.n_components_)])\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocess"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 745,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing DataFrame...\n"
     ]
    }
   ],
   "source": [
    "print \"Processing DataFrame...\"\n",
    "df = processDataFrame(df[datacolumns])\n",
    "y  = df[labels]\n",
    "X  = df.drop(columns=labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Outlier removal (optional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 746,
   "metadata": {},
   "outputs": [],
   "source": [
    "if(opt_remove_outliers):\n",
    "    lof = LocalOutlierFactor(n_neighbors=5)\n",
    "    outliers = lof.fit_predict(X)\n",
    "    print \"Removing %i outliers\" % np.count_nonzero(outliers==-1)\n",
    "    X = X[outliers==1]\n",
    "    y = y[outliers==1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Splitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 747,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=34)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estimation of best classifier and best parameters (optional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 748,
   "metadata": {},
   "outputs": [],
   "source": [
    "if(opt_estimate_best_classifier):\n",
    "    t0 = time()\n",
    "    print \"\\n> Estimation of best classifier and best parameters...\"\n",
    "\n",
    "    classifiers = {\n",
    "        'KNeighborsClassifier': KNeighborsClassifier(),\n",
    "        'SVC': SVC(),\n",
    "        'DecisionTreeClassifier': DecisionTreeClassifier(),\n",
    "        'RandomForestClassifier': RandomForestClassifier(),\n",
    "        'AdaBoostClassifier': AdaBoostClassifier(),\n",
    "        'GradientBoostingClassifier': GradientBoostingClassifier(),\n",
    "        'GaussianNB': GaussianNB()\n",
    "    }\n",
    "\n",
    "    hyperparameters = {\n",
    "        'KNeighborsClassifier': { 'n_neighbors': [2,5,10,15] },\n",
    "        'SVC': [\n",
    "            { 'kernel': ['linear'], 'C': [0.1, 1, 100, 1000], 'gamma': [0.0001, 0.001, 0.01, 0.1] },\n",
    "            { 'kernel': ['rbf'], 'C': [0.1, 1, 100, 1000], 'gamma': [0.0001, 0.001, 0.01, 0.1] },\n",
    "        ],\n",
    "        'DecisionTreeClassifier': { 'min_samples_split': [2,5,10,100] },\n",
    "        'RandomForestClassifier': { 'n_estimators': [16, 32, 64, 100, 200] },\n",
    "        'AdaBoostClassifier': { 'n_estimators': [32, 64, 100, 200], 'learning_rate': [0.8, 1.0] },\n",
    "        'GradientBoostingClassifier': { 'n_estimators': [32, 64, 100, 200], 'learning_rate': [0.8, 1.0] },\n",
    "        'GaussianNB': { }\n",
    "    }\n",
    "\n",
    "    estimator = EstimatorSelectionHelper(classifiers, hyperparameters)\n",
    "    estimator.fit(X_train, y_train.values.ravel(), scoring='accuracy', verbose=1)\n",
    "    print \"(done in %0.3fs)\" % (time() - t0)\n",
    "\n",
    "    print estimator.score_summary(sort_by='min_score')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Find best random state for random forest (optional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 749,
   "metadata": {},
   "outputs": [],
   "source": [
    "if(opt_find_best_random_state):\n",
    "    print \"Finding best random state...\"\n",
    "    for i in xrange(1,512):\n",
    "        clf = RandomForestClassifier(n_estimators=32, random_state=i)\n",
    "        clf.fit(X_train, y_train.values.ravel())\n",
    "        sco = clf.score(X_test, y_test)\n",
    "        if(sco > 0.91):\n",
    "            print \"Classifier accuracy random_state=%i:\" % i, sco"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Forest classifier training + predictions & score + cross validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 750,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Selected classifier accuracy: 0.9217877094972067\n",
      "Computing cross validated scores...\n",
      "- Cross validated accuracy: 0.83 (+/- 0.06) [0.84916201 0.7877095  0.83707865 0.82022472 0.8700565 ]\n"
     ]
    }
   ],
   "source": [
    "# print \"Training classifier...\"\n",
    "clf = RandomForestClassifier(n_estimators=32, random_state=260) # Best accuracy: 0.860335195531\n",
    "clf.fit(X_train, y_train.values.ravel())\n",
    "score = clf.score(X_test, y_test)\n",
    "print \"- Selected classifier accuracy:\", score\n",
    "\n",
    "print \"Computing cross validated scores...\"\n",
    "scores = cross_val_score(clf, X, y.values.ravel(), cv=5)\n",
    "print \"- Cross validated accuracy: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2), scores\n",
    "\n",
    "y_pred = clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Confusion matrix (optional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 751,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1103cc50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cnf_matrix = confusion_matrix(y_test, y_pred)\n",
    "plot_classes = ['Survived','Not Survived']\n",
    "sns.heatmap(cnf_matrix, annot=True, fmt='d', vmax=50, cmap=\"Blues\", xticklabels=plot_classes, yticklabels=plot_classes)\n",
    "plt.title('Confusion Matrix')\n",
    "plt.ylabel('True')\n",
    "plt.xlabel('Predicted')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classification report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 752,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.94      0.94      0.94       118\n",
      "          1       0.89      0.89      0.89        61\n",
      "\n",
      "avg / total       0.92      0.92      0.92       179\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print classification_report(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature importance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 753,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xee90c18>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,10))\n",
    "plt.barh(range(len(clf.feature_importances_)), clf.feature_importances_, tick_label=X_test.columns.values)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Histogram of Residuals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 754,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xf9f1c50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(y_pred - y_test.values.ravel(), bins=50)\n",
    "plt.title(\"Histogram of Residuals.\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute ROC curve and AUC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 755,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10a5f2e8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_pred_proba = clf.predict_proba(X_test)[::,1]\n",
    "false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test, y_pred_proba)\n",
    "roc_auc = auc(false_positive_rate, true_positive_rate)\n",
    "\n",
    "plt.title('Receiver Operating Characteristic')\n",
    "plt.plot(false_positive_rate, true_positive_rate, 'b', label='AUC = %0.2f'% roc_auc)\n",
    "plt.legend(loc='lower right')\n",
    "plt.plot([0,1],[0,1],'r--')\n",
    "plt.xlim([0,1])\n",
    "plt.ylim([0,1])\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predicting new data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 756,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading test CSV...\n"
     ]
    }
   ],
   "source": [
    "print \"Reading test CSV...\"\n",
    "df_pred = pd.read_csv(\"../data/input/test.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing with feature diff & intersection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 757,
   "metadata": {},
   "outputs": [],
   "source": [
    "features = X.columns.values\n",
    "X_pred = processDataFrame(df_pred[raw_features])\n",
    "pred_features = X_pred.columns.values\n",
    "features_to_add = [f for f in features if f not in pred_features]\n",
    "colvalues = dict.fromkeys(features_to_add, 0)\n",
    "X_pred = X_pred.assign(**colvalues)\n",
    "X_pred = X_pred[features]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predictions & probability on the new data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 758,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting 418 samples...\n",
      "* Survived: 134\n",
      "* Not-Survived: 284\n",
      "* Survived with probability beyond 80%: 83\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1285bb38>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print \"Predicting %i samples...\" % X_pred.shape[0]\n",
    "test_pred = clf.predict(X_pred)\n",
    "test_proba = clf.predict_proba(X_pred)\n",
    "print \"* Survived:\", np.count_nonzero(test_pred==1)\n",
    "print \"* Not-Survived:\", np.count_nonzero(test_pred==0)\n",
    "survived = test_proba[:,1]\n",
    "plt.hist(survived)\n",
    "plt.title(\"Survived histogram\")\n",
    "print \"* Survived with probability beyond 80%:\", np.count_nonzero(survived > 0.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Submission output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 759,
   "metadata": {},
   "outputs": [],
   "source": [
    "if(opt_save_submission_output):\n",
    "    df_out = pd.DataFrame(df_pred['PassengerId']).assign(Survived=test_pred)\n",
    "    df_out.to_csv(\"../data/output/gender_submission.csv\", index=False)\n",
    "    print \"Saved.\""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}