Kaggle/Titanic/AdaBoost Classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import Normalizer, QuantileTransformer\n",
    "from sklearn.model_selection import train_test_split, RandomizedSearchCV\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.metrics import classification_report\n",
    "from time import time\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper function to get and process the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dataget(train_path, test_path):\n",
    "\n",
    "    train_data = pd.read_csv(train_path)\n",
    "    test_data = pd.read_csv(test_path)\n",
    "    #Join the train and test data to cleanse and enhance the data\n",
    "    df = train_data.append(test_data, ignore_index=True)\n",
    "    Titles_Dictionary = {\n",
    "                        \"Capt\":         \"Officer\",\n",
    "                        \"Col\":          \"Officer\",\n",
    "                        \"Major\":        \"Officer\",\n",
    "                        \"Jonkheer\":     \"Royalty\",\n",
    "                        \"Don\":          \"Royalty\",\n",
    "                        \"Sir\":          \"Royalty\",\n",
    "                        \"Dr\":           \"Officer\",\n",
    "                        \"Rev\":          \"Officer\",\n",
    "                        \"the Countess\": \"Royalty\",\n",
    "                        \"Dona\":         \"Royalty\",\n",
    "                        \"Mme\":          \"Mrs\",\n",
    "                        \"Mlle\":         \"Miss\",\n",
    "                        \"Ms\":           \"Mrs\",\n",
    "                        \"Mr\":           \"Mr\",\n",
    "                        \"Mrs\":          \"Mrs\",\n",
    "                        \"Miss\":         \"Miss\",\n",
    "                        \"Master\":       \"Master\",\n",
    "                        \"Lady\":         \"Royalty\"\n",
    "                        }\n",
    "    ## Extract Title and map to the Titles from each Name\n",
    "    df['Title'] = df['Name'].apply(lambda x: Titles_Dictionary[x.split(',')[1].split('.')[0].strip()])\n",
    "    ## Fill missing Embarked with 'C'\n",
    "    df['Embarked'].fillna('C', inplace=True)\n",
    "    ## Note down the Imputed Ages\n",
    "    df['Imputed'] = df['Age'].isnull().astype('uint8')\n",
    "    columns = ['Age','Fare']\n",
    "    groups = ['Title', 'Embarked']\n",
    "    ## Fill null Ages with the mean Age based on Title, Embarked\n",
    "    df[columns] = df.groupby(groups)[columns].transform(lambda x: x.fillna(x.mean()))\n",
    "    ## Convert to categorical data\n",
    "    categories = ['Title', 'Sex', 'Pclass', 'SibSp', 'Parch', 'Embarked']\n",
    "    df[categories] = df[categories].apply(lambda x: x.astype('category'))\n",
    "    df = df.drop(columns=['Cabin', 'Name', 'Ticket'])\n",
    "    #df = df.drop(columns=['Title', 'SibSp', 'Imputed', 'Pclass', 'Parch', 'Embarked', 'Fare'])\n",
    "    df = df.round(2)\n",
    "    original = df.copy()\n",
    "    df = pd.get_dummies(df, drop_first=True)\n",
    "    test_data = df[df.Survived.isnull()].copy()\n",
    "    test_data = test_data.drop(columns=['Survived'])\n",
    "    train_data = df.dropna().copy()\n",
    "    train_data['Survived'] = train_data['Survived'].astype('uint8')\n",
    "    train_data = train_data.drop(columns=['PassengerId'])\n",
    "\n",
    "    return original, train_data, test_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     Age Embarked   Fare Parch Pclass     Sex SibSp  Survived   Title  Imputed\n",
      "0  22.00        S   7.25     0      3    male     1       0.0      Mr        0\n",
      "1  38.00        C  71.28     0      1  female     1       1.0     Mrs        0\n",
      "2  26.00        S   7.92     0      3  female     0       1.0    Miss        0\n",
      "3  35.00        S  53.10     0      1  female     1       1.0     Mrs        0\n",
      "4  35.00        S   8.05     0      3    male     0       0.0      Mr        0\n",
      "5  36.24        Q   8.46     0      3    male     0       0.0      Mr        1\n",
      "6  54.00        S  51.86     0      1    male     0       0.0      Mr        0\n",
      "7   2.00        S  21.08     1      3    male     3       0.0  Master        0\n",
      "8  27.00        S  11.13     2      3  female     0       1.0     Mrs        0\n",
      "9  14.00        C  30.07     0      2  female     1       1.0     Mrs        0\n"
     ]
    }
   ],
   "source": [
    "train_path = 'train.csv'\n",
    "test_path = 'test.csv'\n",
    "original, train_data, test_data = dataget(train_path, test_path)\n",
    "df = original.copy()\n",
    "df.drop(columns=['PassengerId'], inplace=True)\n",
    "#df.dropna(inplace=True)\n",
    "print(df.head(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               Age         Fare    Survived      Imputed\n",
      "count  1309.000000  1309.000000  891.000000  1309.000000\n",
      "mean     30.085829    33.285921    0.383838     0.200917\n",
      "std      13.214767    51.740153    0.486592     0.400839\n",
      "min       0.170000     0.000000    0.000000     0.000000\n",
      "25%      22.000000     7.900000    0.000000     0.000000\n",
      "50%      30.000000    14.450000    0.000000     0.000000\n",
      "75%      36.240000    31.280000    1.000000     0.000000\n",
      "max      80.000000   512.330000    1.000000     1.000000\n"
     ]
    }
   ],
   "source": [
    "print(df.describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 1309 entries, 0 to 1308\n",
      "Data columns (total 10 columns):\n",
      "Age         1309 non-null float64\n",
      "Embarked    1309 non-null category\n",
      "Fare        1309 non-null float64\n",
      "Parch       1309 non-null category\n",
      "Pclass      1309 non-null category\n",
      "Sex         1309 non-null category\n",
      "SibSp       1309 non-null category\n",
      "Survived    891 non-null float64\n",
      "Title       1309 non-null category\n",
      "Imputed     1309 non-null uint8\n",
      "dtypes: category(6), float64(3), uint8(1)\n",
      "memory usage: 40.9 KB\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(df.info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "search = True\n",
    "test_size = 0.2\n",
    "normalizer = Normalizer(norm='l1')\n",
    "df = train_data\n",
    "train = df.dropna()\n",
    "y_train = train['Survived'].values\n",
    "x_train = train.drop(columns=['Survived']).values\n",
    "quantile_transformer = QuantileTransformer(output_distribution='normal')\n",
    "X_train = normalizer.fit_transform(x_train)\n",
    "#X_train = quantile_transformer.fit_transform(x_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RandomizedSearchCV took 242.51 seconds for 500 candidates parameter settings.\n",
      "0.8215488215488216\n",
      "{'n_estimators': 14, 'learning_rate': 0.9}\n"
     ]
    }
   ],
   "source": [
    "clf = AdaBoostClassifier()\n",
    "lr = [element/100 for element in range(1,101,1)]\n",
    "param_dist = {\"n_estimators\": list(range(1,100)),\n",
    "              \"learning_rate\": lr\n",
    "             }\n",
    "n_iter_search = 500\n",
    "\n",
    "if search:\n",
    "    random_search = RandomizedSearchCV(clf, param_distributions=param_dist, n_jobs =-1,\n",
    "                                       n_iter=n_iter_search, cv=10, scoring='accuracy', random_state=42)\n",
    "\n",
    "    start = time()\n",
    "    random_search.fit(X_train, y_train)\n",
    "\n",
    "    print(\"RandomizedSearchCV took %.2f seconds for %d candidates\"\n",
    "          \" parameter settings.\" % ((time() - start), n_iter_search))\n",
    "\n",
    "    print(random_search.best_score_)\n",
    "    print(random_search.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#http://scikit-learn.org/stable/auto_examples/preprocessing/plot_all_scaling.html#sphx-glr-auto-examples-preprocessing-plot-all-scaling-py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.85      0.88      0.86       549\n",
      "          1       0.79      0.75      0.77       342\n",
      "\n",
      "avg / total       0.83      0.83      0.83       891\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#params = {'n_estimators': 13, 'max_depth': 12, 'criterion': 'entropy', 'bootstrap': True} quantile\n",
    "params = {'n_estimators': 14, 'learning_rate': 0.9, 'random_state':42}\n",
    "clf = AdaBoostClassifier(**params)\n",
    "clf.fit(X_train, y_train)\n",
    "y_true, y_pred = y_train, clf.predict(X_train)\n",
    "print(classification_report(y_true, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = test_data\n",
    "resultdf = pd.DataFrame(data=df['PassengerId'])\n",
    "df = df.drop(columns=['PassengerId'])\n",
    "#test_x = quantile_transformer.transform(df)\n",
    "test_x = normalizer.transform(df)\n",
    "predictions = clf.predict(test_x)\n",
    "resultdf['Survived'] = predictions.astype(int)\n",
    "\n",
    "resultdf.to_csv('submission.csv', index=False)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}