{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introducing Data Science Workflows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "train = pd.read_csv(\"train.csv\")\n",
    "holdout = pd.read_csv(\"test.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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",
       "      <th>Pclass</th>\n",
       "      <th>Name</th>\n",
       "      <th>Sex</th>\n",
       "      <th>Age</th>\n",
       "      <th>SibSp</th>\n",
       "      <th>Parch</th>\n",
       "      <th>Ticket</th>\n",
       "      <th>Fare</th>\n",
       "      <th>Cabin</th>\n",
       "      <th>Embarked</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>Braund, Mr. Owen Harris</td>\n",
       "      <td>male</td>\n",
       "      <td>22.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>A/5 21171</td>\n",
       "      <td>7.2500</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>Cumings, Mrs. John Bradley (Florence Briggs Th...</td>\n",
       "      <td>female</td>\n",
       "      <td>38.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>PC 17599</td>\n",
       "      <td>71.2833</td>\n",
       "      <td>C85</td>\n",
       "      <td>C</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>Heikkinen, Miss. Laina</td>\n",
       "      <td>female</td>\n",
       "      <td>26.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>STON/O2. 3101282</td>\n",
       "      <td>7.9250</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>Futrelle, Mrs. Jacques Heath (Lily May Peel)</td>\n",
       "      <td>female</td>\n",
       "      <td>35.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>113803</td>\n",
       "      <td>53.1000</td>\n",
       "      <td>C123</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>Allen, Mr. William Henry</td>\n",
       "      <td>male</td>\n",
       "      <td>35.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>373450</td>\n",
       "      <td>8.0500</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   PassengerId  Survived  Pclass  \\\n",
       "0            1         0       3   \n",
       "1            2         1       1   \n",
       "2            3         1       3   \n",
       "3            4         1       1   \n",
       "4            5         0       3   \n",
       "\n",
       "                                                Name     Sex   Age  SibSp  \\\n",
       "0                            Braund, Mr. Owen Harris    male  22.0      1   \n",
       "1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  38.0      1   \n",
       "2                             Heikkinen, Miss. Laina  female  26.0      0   \n",
       "3       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  35.0      1   \n",
       "4                           Allen, Mr. William Henry    male  35.0      0   \n",
       "\n",
       "   Parch            Ticket     Fare Cabin Embarked  \n",
       "0      0         A/5 21171   7.2500   NaN        S  \n",
       "1      0          PC 17599  71.2833   C85        C  \n",
       "2      0  STON/O2. 3101282   7.9250   NaN        S  \n",
       "3      0            113803  53.1000  C123        S  \n",
       "4      0            373450   8.0500   NaN        S  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load functions.py\n",
    "def process_missing(df):\n",
    "    \"\"\"Handle various missing values from the data set\n",
    "\n",
    "    Usage\n",
    "    ------\n",
    "\n",
    "    holdout = process_missing(holdout)\n",
    "    \"\"\"\n",
    "    df[\"Fare\"] = df[\"Fare\"].fillna(train[\"Fare\"].mean())\n",
    "    df[\"Embarked\"] = df[\"Embarked\"].fillna(\"S\")\n",
    "    return df\n",
    "\n",
    "def process_age(df):\n",
    "    \"\"\"Process the Age column into pre-defined 'bins' \n",
    "\n",
    "    Usage\n",
    "    ------\n",
    "\n",
    "    train = process_age(train)\n",
    "    \"\"\"\n",
    "    df[\"Age\"] = df[\"Age\"].fillna(-0.5)\n",
    "    cut_points = [-1,0,5,12,18,35,60,100]\n",
    "    label_names = [\"Missing\",\"Infant\",\"Child\",\"Teenager\",\"Young Adult\",\"Adult\",\"Senior\"]\n",
    "    df[\"Age_categories\"] = pd.cut(df[\"Age\"],cut_points,labels=label_names)\n",
    "    return df\n",
    "\n",
    "def process_fare(df):\n",
    "    \"\"\"Process the Fare column into pre-defined 'bins' \n",
    "\n",
    "    Usage\n",
    "    ------\n",
    "\n",
    "    train = process_fare(train)\n",
    "    \"\"\"\n",
    "    cut_points = [-1,12,50,100,1000]\n",
    "    label_names = [\"0-12\",\"12-50\",\"50-100\",\"100+\"]\n",
    "    df[\"Fare_categories\"] = pd.cut(df[\"Fare\"],cut_points,labels=label_names)\n",
    "    return df\n",
    "\n",
    "def process_cabin(df):\n",
    "    \"\"\"Process the Cabin column into pre-defined 'bins' \n",
    "\n",
    "    Usage\n",
    "    ------\n",
    "\n",
    "    train process_cabin(train)\n",
    "    \"\"\"\n",
    "    df[\"Cabin_type\"] = df[\"Cabin\"].str[0]\n",
    "    df[\"Cabin_type\"] = df[\"Cabin_type\"].fillna(\"Unknown\")\n",
    "    df = df.drop('Cabin',axis=1)\n",
    "    return df\n",
    "\n",
    "def process_titles(df):\n",
    "    \"\"\"Extract and categorize the title from the name column \n",
    "\n",
    "    Usage\n",
    "    ------\n",
    "\n",
    "    train = process_titles(train)\n",
    "    \"\"\"\n",
    "    titles = {\n",
    "        \"Mr\" :         \"Mr\",\n",
    "        \"Mme\":         \"Mrs\",\n",
    "        \"Ms\":          \"Mrs\",\n",
    "        \"Mrs\" :        \"Mrs\",\n",
    "        \"Master\" :     \"Master\",\n",
    "        \"Mlle\":        \"Miss\",\n",
    "        \"Miss\" :       \"Miss\",\n",
    "        \"Capt\":        \"Officer\",\n",
    "        \"Col\":         \"Officer\",\n",
    "        \"Major\":       \"Officer\",\n",
    "        \"Dr\":          \"Officer\",\n",
    "        \"Rev\":         \"Officer\",\n",
    "        \"Jonkheer\":    \"Royalty\",\n",
    "        \"Don\":         \"Royalty\",\n",
    "        \"Sir\" :        \"Royalty\",\n",
    "        \"Countess\":    \"Royalty\",\n",
    "        \"Dona\":        \"Royalty\",\n",
    "        \"Lady\" :       \"Royalty\"\n",
    "    }\n",
    "    extracted_titles = df[\"Name\"].str.extract(' ([A-Za-z]+)\\.',expand=False)\n",
    "    df[\"Title\"] = extracted_titles.map(titles)\n",
    "    return df\n",
    "\n",
    "def create_dummies(df,column_name):\n",
    "    \"\"\"Create Dummy Columns (One Hot Encoding) from a single Column\n",
    "\n",
    "    Usage\n",
    "    ------\n",
    "\n",
    "    train = create_dummies(train,\"Age\")\n",
    "    \"\"\"\n",
    "    dummies = pd.get_dummies(df[column_name],prefix=column_name)\n",
    "    df = pd.concat([df,dummies],axis=1)\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_process(df):\n",
    "    df = process_missing(df)\n",
    "    df = process_age(df)\n",
    "    df = process_fare(df)\n",
    "    df = process_titles(df)\n",
    "    df = process_cabin(df)\n",
    "\n",
    "    for col in [\"Age_categories\",\"Fare_categories\",\n",
    "                \"Title\",\"Cabin_type\",\"Sex\"]:\n",
    "        df = create_dummies(df,col)\n",
    "    \n",
    "    return df\n",
    "\n",
    "train = pre_process(train)\n",
    "holdout = pre_process(holdout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exploring the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 891 entries, 0 to 890\n",
      "Data columns (total 3 columns):\n",
      " #   Column    Non-Null Count  Dtype\n",
      "---  ------    --------------  -----\n",
      " 0   SibSp     891 non-null    int64\n",
      " 1   Parch     891 non-null    int64\n",
      " 2   Survived  891 non-null    int64\n",
      "dtypes: int64(3)\n",
      "memory usage: 21.0 KB\n"
     ]
    }
   ],
   "source": [
    "explore_cols = [\"SibSp\",\"Parch\",\"Survived\"]\n",
    "explore = train[explore_cols].copy()\n",
    "explore.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "explore.drop(\"Survived\",axis=1).plot.hist(alpha=0.5,bins=8)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "explore[\"familysize\"] = explore[[\"SibSp\",\"Parch\"]].sum(axis=1)\n",
    "explore.drop(\"Survived\",axis=1).plot.hist(alpha=0.5,bins=10)\n",
    "plt.xticks(range(11))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "for col in explore.columns.drop(\"Survived\"):\n",
    "    pivot = explore.pivot_table(index=col,values=\"Survived\")\n",
    "    pivot.plot.bar(ylim=(0,1),yticks=np.arange(0,1,.1))\n",
    "    plt.axhspan(.3, .6, alpha=0.2, color='red')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `SibSp` column shows the number of siblings and/or spouses each passenger had on board, while the `Parch` columns shows the number of parents or children each passenger had onboard. Neither column has any missing values.\n",
    "\n",
    "The distribution of values in both columns is skewed right, with the majority of values being zero.\n",
    "\n",
    "You can sum these two columns to explore the total number of family members each passenger had onboard.  The shape of the distribution of values in this case is similar, however there are less values at zero, and the quantity tapers off less rapidly as the values increase.\n",
    "\n",
    "Looking at the survival rates of the the combined family members, you can see that few of the over 500 passengers with no family members survived, while greater numbers of passengers with family members survived."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Engineering New Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_isalone(df):\n",
    "    df[\"familysize\"] = df[[\"SibSp\",\"Parch\"]].sum(axis=1)\n",
    "    df[\"isalone\"] = 0\n",
    "    df.loc[(df[\"familysize\"] == 0),\"isalone\"] = 1\n",
    "    df = df.drop(\"familysize\",axis=1)\n",
    "    return df\n",
    "\n",
    "train = process_isalone(train)\n",
    "holdout = process_isalone(holdout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Selecting the Best-Performing Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Columns \n",
      "------------\n",
      "['Pclass', 'Age', 'SibSp', 'Parch', 'Fare', 'Age_categories_Missing', 'Age_categories_Infant', 'Age_categories_Child', 'Age_categories_Teenager', 'Age_categories_Young Adult', 'Age_categories_Adult', 'Age_categories_Senior', 'Fare_categories_0-12', 'Fare_categories_12-50', 'Fare_categories_50-100', 'Fare_categories_100+', 'Title_Master', 'Title_Miss', 'Title_Mr', 'Title_Mrs', 'Title_Officer', 'Cabin_type_A', 'Cabin_type_B', 'Cabin_type_C', 'Cabin_type_D', 'Cabin_type_E', 'Cabin_type_Unknown', 'Sex_female', 'Sex_male', 'isalone']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.feature_selection import RFECV\n",
    "\n",
    "def select_features(df):\n",
    "    # Remove non-numeric columns, columns that have null values\n",
    "    df = df.select_dtypes([np.number]).dropna(axis=1)\n",
    "    all_X = df.drop([\"Survived\",\"PassengerId\"],axis=1)\n",
    "    all_y = df[\"Survived\"]\n",
    "    \n",
    "    clf = RandomForestClassifier(random_state=1)\n",
    "    selector = RFECV(clf,cv=10)\n",
    "    selector.fit(all_X,all_y)\n",
    "    \n",
    "    best_columns = list(all_X.columns[selector.support_])\n",
    "    print(\"Best Columns \\n\"+\"-\"*12+\"\\n{}\\n\".format(best_columns))\n",
    "    \n",
    "    return best_columns\n",
    "\n",
    "cols = select_features(train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Selecting and Tuning Different Algorithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogisticRegression\n",
      "------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:762: ConvergenceWarning:\n",
      "\n",
      "lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:762: ConvergenceWarning:\n",
      "\n",
      "lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:762: ConvergenceWarning:\n",
      "\n",
      "lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:762: ConvergenceWarning:\n",
      "\n",
      "lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:762: ConvergenceWarning:\n",
      "\n",
      "lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:762: ConvergenceWarning:\n",
      "\n",
      "lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:762: ConvergenceWarning:\n",
      "\n",
      "lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:762: ConvergenceWarning:\n",
      "\n",
      "lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:762: ConvergenceWarning:\n",
      "\n",
      "lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:762: ConvergenceWarning:\n",
      "\n",
      "lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:762: ConvergenceWarning:\n",
      "\n",
      "lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Score: 0.8204744069912608\n",
      "Best Parameters: {'solver': 'lbfgs'}\n",
      "\n",
      "KNeighborsClassifier\n",
      "--------------------\n",
      "Best Score: 0.7767041198501874\n",
      "Best Parameters: {'algorithm': 'brute', 'n_neighbors': 5, 'p': 1, 'weights': 'uniform'}\n",
      "\n",
      "RandomForestClassifier\n",
      "----------------------\n",
      "Best Score: 0.8395505617977527\n",
      "Best Parameters: {'criterion': 'gini', 'max_depth': 10, 'max_features': 'sqrt', 'min_samples_leaf': 1, 'min_samples_split': 5, 'n_estimators': 6}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "def select_model(df,features):\n",
    "    \n",
    "    all_X = df[features]\n",
    "    all_y = df[\"Survived\"]\n",
    "\n",
    "    # List of dictionaries, each containing a model name,\n",
    "    # it's estimator and a dict of hyperparameters\n",
    "    models = [\n",
    "        {\n",
    "            \"name\": \"LogisticRegression\",\n",
    "            \"estimator\": LogisticRegression(),\n",
    "            \"hyperparameters\":\n",
    "                {\n",
    "                    \"solver\": [\"newton-cg\", \"lbfgs\", \"liblinear\"]\n",
    "                }\n",
    "        },\n",
    "        {\n",
    "            \"name\": \"KNeighborsClassifier\",\n",
    "            \"estimator\": KNeighborsClassifier(),\n",
    "            \"hyperparameters\":\n",
    "                {\n",
    "                    \"n_neighbors\": range(1,20,2),\n",
    "                    \"weights\": [\"distance\", \"uniform\"],\n",
    "                    \"algorithm\": [\"ball_tree\", \"kd_tree\", \"brute\"],\n",
    "                    \"p\": [1,2]\n",
    "                }\n",
    "        },\n",
    "        {\n",
    "            \"name\": \"RandomForestClassifier\",\n",
    "            \"estimator\": RandomForestClassifier(random_state=1),\n",
    "            \"hyperparameters\":\n",
    "                {\n",
    "                    \"n_estimators\": [4, 6, 9],\n",
    "                    \"criterion\": [\"entropy\", \"gini\"],\n",
    "                    \"max_depth\": [2, 5, 10],\n",
    "                    \"max_features\": [\"log2\", \"sqrt\"],\n",
    "                    \"min_samples_leaf\": [1, 5, 8],\n",
    "                    \"min_samples_split\": [2, 3, 5]\n",
    "\n",
    "                }\n",
    "        }\n",
    "    ]\n",
    "\n",
    "    for model in models:\n",
    "        print(model['name'])\n",
    "        print('-'*len(model['name']))\n",
    "\n",
    "        grid = GridSearchCV(model[\"estimator\"],\n",
    "                            param_grid=model[\"hyperparameters\"],\n",
    "                            cv=10)\n",
    "        grid.fit(all_X,all_y)\n",
    "        model[\"best_params\"] = grid.best_params_\n",
    "        model[\"best_score\"] = grid.best_score_\n",
    "        model[\"best_model\"] = grid.best_estimator_\n",
    "\n",
    "        print(\"Best Score: {}\".format(model[\"best_score\"]))\n",
    "        print(\"Best Parameters: {}\\n\".format(model[\"best_params\"]))\n",
    "\n",
    "    return models\n",
    "\n",
    "result = select_model(train,cols)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making a Submission to Kaggle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_submission_file(model,cols,filename=\"submission.csv\"):\n",
    "    holdout_data = holdout[cols]\n",
    "    predictions = model.predict(holdout_data)\n",
    "    \n",
    "    holdout_ids = holdout[\"PassengerId\"]\n",
    "    submission_df = {\"PassengerId\": holdout_ids,\n",
    "                 \"Survived\": predictions}\n",
    "    submission = pd.DataFrame(submission_df)\n",
    "\n",
    "    submission.to_csv(filename,index=False)\n",
    "\n",
    "best_rf_model = result[2][\"best_model\"]\n",
    "save_submission_file(best_rf_model,cols)"
   ]
  }
 ],
 "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}