Titanic_Logistic_Regression_pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputpath = './input/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(891, 12)\n",
      "(418, 11)\n",
      "(418, 2)\n",
      "train_index: 891\n"
     ]
    }
   ],
   "source": [
    "train_df = pd.read_csv(inputpath+'train.csv')\n",
    "test_df = pd.read_csv(inputpath+'test.csv')\n",
    "gender_df = pd.read_csv(inputpath+'gender_submission.csv')\n",
    "\n",
    "print(train_df.shape)\n",
    "print(test_df.shape)\n",
    "print(gender_df.shape)\n",
    "\n",
    "train_index = train_df.shape[0]\n",
    "print('train_index: ' + str(train_index))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   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  \n",
      "================\n",
      "   PassengerId  Pclass                                          Name     Sex  \\\n",
      "0          892       3                              Kelly, Mr. James    male   \n",
      "1          893       3              Wilkes, Mrs. James (Ellen Needs)  female   \n",
      "2          894       2                     Myles, Mr. Thomas Francis    male   \n",
      "3          895       3                              Wirz, Mr. Albert    male   \n",
      "4          896       3  Hirvonen, Mrs. Alexander (Helga E Lindqvist)  female   \n",
      "\n",
      "    Age  SibSp  Parch   Ticket     Fare Cabin Embarked  \n",
      "0  34.5      0      0   330911   7.8292   NaN        Q  \n",
      "1  47.0      1      0   363272   7.0000   NaN        S  \n",
      "2  62.0      0      0   240276   9.6875   NaN        Q  \n",
      "3  27.0      0      0   315154   8.6625   NaN        S  \n",
      "4  22.0      1      1  3101298  12.2875   NaN        S  \n",
      "================\n",
      "   PassengerId  Survived\n",
      "0          892         0\n",
      "1          893         1\n",
      "2          894         0\n",
      "3          895         0\n",
      "4          896         1\n"
     ]
    }
   ],
   "source": [
    "# check the data\n",
    "print(train_df.head())\n",
    "print('================')\n",
    "print(test_df.head())\n",
    "print('================')\n",
    "print(gender_df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(418, 12)\n",
      "   PassengerId  Pclass                                          Name     Sex  \\\n",
      "0          892       3                              Kelly, Mr. James    male   \n",
      "1          893       3              Wilkes, Mrs. James (Ellen Needs)  female   \n",
      "2          894       2                     Myles, Mr. Thomas Francis    male   \n",
      "3          895       3                              Wirz, Mr. Albert    male   \n",
      "4          896       3  Hirvonen, Mrs. Alexander (Helga E Lindqvist)  female   \n",
      "\n",
      "    Age  SibSp  Parch   Ticket     Fare Cabin Embarked  Survived  \n",
      "0  34.5      0      0   330911   7.8292   NaN        Q         0  \n",
      "1  47.0      1      0   363272   7.0000   NaN        S         1  \n",
      "2  62.0      0      0   240276   9.6875   NaN        Q         0  \n",
      "3  27.0      0      0   315154   8.6625   NaN        S         0  \n",
      "4  22.0      1      1  3101298  12.2875   NaN        S         1  \n"
     ]
    }
   ],
   "source": [
    "# join test_df and genger_df (test dataset) for future process\n",
    "test_df_joined = test_df.join(gender_df.set_index('PassengerId'), on='PassengerId')\n",
    "print(test_df_joined.shape)\n",
    "# expect (418,12)\n",
    "print(test_df_joined.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1309, 12)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\woare\\Anaconda3\\lib\\site-packages\\pandas\\core\\frame.py:6201: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n",
      "of pandas will change to not sort by default.\n",
      "\n",
      "To accept the future behavior, pass 'sort=True'.\n",
      "\n",
      "To retain the current behavior and silence the warning, pass sort=False\n",
      "\n",
      "  sort=sort)\n"
     ]
    }
   ],
   "source": [
    "total_df = train_df.append(test_df_joined)\n",
    "print(total_df.shape)\n",
    "#(1309, 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Age             263\n",
       "Cabin          1014\n",
       "Embarked          2\n",
       "Fare              1\n",
       "Name              0\n",
       "Parch             0\n",
       "PassengerId       0\n",
       "Pclass            0\n",
       "Sex               0\n",
       "SibSp             0\n",
       "Survived          0\n",
       "Ticket            0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check the nan data\n",
    "total_df.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAD8CAYAAABQFVIjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xd4VGXax/Hvnd4pKfSQ0ERARQVEUFGxoGsvK6zYV1zL2nVld/XadYvr7ruW3bWhYlsFFHFFRVHsBZCgKF1CCQm9JpCQfr9/nBONcSATmMmZcn+ua66ZOfOcM79Ju3Oe55zniKpijDHGHKgYrwMYY4yJDFZQjDHGBIQVFGOMMQFhBcUYY0xAWEExxhgTEFZQjDHGBIQVFGOMMQFhBcUYY0xAWEExxhgTEHFeB2gNWVlZmpeX53UMY4wJK/Pnz9+qqtn+to+KgpKXl0dBQYHXMYwxJqyISFFL2luXlzHGmICwgmKMMSYgrKAYY4wJCCsoxhhjAsIKijHGmICwgmKMMSYgrKAYY4wJCCsoxhhjAsIKijHGmICIijPlTesYP21hs23i6qtIrttFdUwSVbFprZBq7+477xBP39+YSGMFxQRdYl05g7dPZ+DO9+i0ZwUxKABlcZl8l34U89qfxdrUAR6nNMYcKCsoJqgOLv2Uc9f9g/Ta7RSlDODDnMsoi88isb6Cznu+o3/pJwzaMYMVaYN5o/PNbEnq7nVkY8x+soJigkOVkzZNZOTmZ1if1IsX8u6jOKX/T5ol1FUwZPt0Ttz0LL9ecQXTu9xKQfszPAhsjDlQNihvguK0DY8ycvMzFLQ7nUd7PemzmABUx6bwWfZoHjjoJdakHsr5JX/jvOK/EaO1rZzYGHOgrKCYgDt661SO2zqJ2Znn8WrX8dTFxDe7zu749jyT/08+zLmEwTveZEzRPcTWV7dCWmNMoFhBMQGVW76In63/N4szjuWNzjeBiN/rqsTybsdrmN75ZgaUfcIlRb8ltr4miGmNMYFkBcUETGJdORet/SOl8Tm80u13qMTu13ZmZ13AtC53ctCuOZxfch+i9QFOaowJBhuUNwFz8sYnaVuzkSd6PnbA55jMyzyLlLpSRm18grL4LN7pdF2AUhpjgsUKigmM9Qs4ets05maeE7BzSj7OHkvbmk2M2PISG5N6sqDdqQHZrjEmOKzLywTGu7+nIjaDdzuOC9w2RXij882sSh3IuSV/p+OewsBt2xgTcFZQzIFb9TGs+ZQPO1xKZWx6QDddL3FMyr2XPbHpjC36HQl1FQHdvjEmcKygmAOjCh/8GdI782X7s4PyFrvj2zOp+x9pV72BM9b/KyjvYYw5cFZQzIFZ8R6UfAkj7qA2JjFob1OUehgfZ1/M4B1v0q/0k6C9jzFm/1lBMQfm84ehTTcYODbob/V+hytZn9Sbc0v+TlrN9qC/nzGmZYJaUERklIgsF5FCEbnLx+uJIjLFfX2uiOS5y4eIyAL39o2InOvvNk0r2rgQij6DIeMgLiHob1cXE8+U3LtJrK/gnHX/CPr7GWNaJmgFRURigUeA04B+wBgR6dek2VXADlXtBTwI3O8uXwQMUtWBwCjgCRGJ83ObprXMfRziU+CIS1rtLTcn9WBWh6voX/apdX0ZE2KCuYcyBChU1VWqWg1MBpqO2p4NPOc+ngqMFBFR1QrV72cHTAL3Ahr+bdO0hvJt8O0rcNhoSG7Xqm/9WfZFbEjqyZnrH7KjvowJIcEsKF2A4kbPS9xlPtu4BaQUyAQQkaNEZDGwEPiV+7o/2zSt4avnoK4KhlzT6m9dL3H8r8sdtK3ZzMmbnm719zfG+BbMguJrVkD1t42qzlXV/sBgYLyIJPm5TWfDIuNEpEBECrZs2dKC2KZZqvD1f6H7cMjp60mEtakDmNP+HIZtfYVOe77zJIMx5seCWVBKgG6NnncF1u+tjYjEAW2AHx2+o6pLgXJggJ/bbFhvgqoOUtVB2dnZB/AxzE+UzIPtK+GwMZ7GmNnpGipiMzhz/cNOkTPGeCqYBWUe0FtE8kUkARgNTG/SZjpwmfv4AuADVVV3nTgAEekOHASs8XObJtgWvARxydDP2+Gryth03u14Nfnl3zCg9CNPsxhjglhQ3DGPG4CZwFLgZVVdLCL3ishZbrOngUwRKQRuBRoOAz4G+EZEFgCvAdep6ta9bTNYn8H4UFMJi6fBwWdCUobXaShofwYbknpy2oZHiauv8jqOMVEtqLMNq+oMYEaTZfc0elwJXOhjvReAF/zdpmlFy2dAZSkM9La7q4FKLG92vpGrV93E8K0v83FO6x3CbIz5MTtT3rTMolchvRPkj/A6yfdWpR3J4oxjOWHz86TW7vA6jjFRywqK8V/VLmfuroPPgpj9uxpjsLzT6Vri6qs5YdNzzTc2xgSFFRTjvxXvOueeeDwY78vWxFzmtz+do7a/TtvqjV7HMSYqWUEx/lvyOqTmQO5Qr5P49H7OFSjCyE0TvY5iTFSygmL8U13hdnedGXLdXQ3KEnKYk3kuR+x4h5zK1V7HMSbqWEEx/imcBTUVIdnd1dhHOZdQHZPEyRuf9DqKMVHHCorxz7I3Ibm9M91KCKuIa8un2WMYUPYJXSuWeB3HmKgS1PNQTOgZP21hi9cRreN3S95hefpQXnl9aRBSBdZnWRcxbOtURm56hufy7bopxrQW20MxzepWsYTUulKWZQzzOopfqmNT+DR7NH13zaZLxTKv4xgTNaygmGb1LfuCOmJZkT7E6yh+m5N5HhWx6Zy4+VmvoxgTNaygmGb13fUFRamHUBmb7nUUv1XFpvJ51kX0K/vMprc3ppVYQTH71KZ6E50qV7IsPTy6uxr7POsC9sSkceKmZ72OYkxUsIJi9umgXbMBwmb8pLGq2DQ+z7qQAWWf0HFPoddxjIl4VlDMPvXZNZft8Z3Yktjd6yj75fOsC6mMSeWEzTbHlzHBZgXF7FWM1tJz91cUpg8C8XX15dBXGZfBF1kXMKD0I3IqV3kdx5iIZgXF7FWXimUk1ZdTmDbI6ygH5POsn1MTk8Txm//rdRRjIpoVFLNXvXYXUI+wMu1Ir6MckIq4NsxtfzaH7nyfdtXrvY5jTMSygmL2qtfuAjYk96Yirq3XUQ7YZ9mjUYnh2C2TvI5iTMSygmJ8SqirILdiUdh3dzXYFZ/FV+1GMWj7W6TVbPc6jjERyQqK8Smv/BvitJbCtMFeRwmYT7J/QazWMnzry15HMSYiWUExPvXaXUCNJLAm9VCvowTMtsRuLGpzPEO3vUZi3W6v4xgTcaygGJ967S6gKPUQamMSvY4SUB/ljCWpvpyh217zOooxEccKivmJtJptdKpcGTHjJ41tSO7D8vSjnG6vmj1exzEmogS1oIjIKBFZLiKFInKXj9cTRWSK+/pcEclzl58sIvNFZKF7f2KjdT5yt7nAveUE8zNEox7lXwOwMgILCsDH2WNJr90BX9t5KcYEUtAKiojEAo8ApwH9gDEi0q9Js6uAHaraC3gQuN9dvhU4U1UPAS4DXmiy3sWqOtC9bQ7WZ4hW+bsXUBmTwvrk3l5HCYrVqQMpShkAX/wL6mq9jmNMxAjmHsoQoFBVV6lqNTAZaHpB8rOBhkmWpgIjRURU9WtVbTgDbTGQJCKR1ZkfwvLLF1CUegj1EqEX9BTho5yxsHMtLJ7mdRpjIkYwC0oXoLjR8xJ3mc82qloLlAKZTdqcD3ytqlWNlj3jdnfdLeJ7kikRGSciBSJSsGXLlgP5HFEltXYHHarWsDp1oNdRgmp5+jDI6QefPQj19V7HMSYiBLOg+PpDry1pIyL9cbrBrmn0+sVuV9ix7u0SX2+uqhNUdZCqDsrOzm5R8GiWV/4NAKtTD/c4SXCpxMDwm2HzElgx0+s4xkSEYBaUEqBbo+ddgaYTKX3fRkTigDbAdvd5V+A14FJVXdmwgqquc+93AS/hdK2ZAOmxewHVksS65IO8jhJ8A86Htrnw6QOgTf/XMca0VDALyjygt4jki0gCMBqY3qTNdJxBd4ALgA9UVUWkLfAWMF5VP29oLCJxIpLlPo4HzgAWBfEzRJ388q9Zm9qfuph4r6MEX2wcDLsRSr6Eoi+8TmNM2AtaQXHHRG4AZgJLgZdVdbGI3CsiZ7nNngYyRaQQuBVoOLT4BqAXcHeTw4MTgZki8i2wAFgHPBmszxBtkmvL6FC5KuK7u37k8LGQmg2f/tPrJMaEvaAexqOqM4AZTZbd0+hxJXChj/X+DPx5L5sN77nUQ1he+bfEoKyK8AH5H4lPhqHXwft/hPVfQ+coKqbGBJidKW++l1/+NTWSQEnKwV5HaV2DfwlJbWwvxZgDZAXFfC+//BuKU/pF3PxdzUrKgCHXwNI3YPNSr9MYE7asoBjAuf5Jpz0rWJN6mNdRvDH0WohPdY74MsbsFysoBoCue5YSSx1FqYd4HcUbKe1h0BWwaCpsX+V1GmPCkhUUA0Be+UIA1qb09ziJh4b9GmLi4bOHvE5iTFiygmIAyK1YyMbEfCpj072O4p30js5hxAtegtJ1XqcxJuxYQTGI1pNbvjh6u7saG34ToPDFv71OYkzYsYJiyKlaQ3L9btamWEGhXXc49CKY/yzstklFjWkJKyiG7uXfAtgeSoNjboHaSpjzqNdJjAkrVlAM3SsWsTu2LdsSml5dIEpl9Yb+58CXT8KeHV6nMSZsWEExdC9f6Oyd+L60THQ69nao3gWzbS/FGH9ZQYlyaTXbyaxeR5GNn/xYxwHQ7xyY8xhUbPc6jTFhwQpKlMutcM4/sfETH46/C6p32xFfxvjJCkqU616+iFqJZ31yH6+jhJ6cg52LcM19Asq3ep3GmJBnBSXK5VYsoiS5b/RNCOmvEb+B2j3w+cNeJzEm5FlBiWJx9VV03bOMtSkDvI4SurL7wCEXOkd87d7sdRpjQpoVlCjWec93xGmNjZ80Z8RvoK7a5vgyphlWUKJY9+8nhLQ9lH3K7AmHjYaCp6FsvddpjAlZVlCiWPeKhWxL6MLu+PZeRwl9I+6E+jr46D6vkxgTsqygRCvVH05oNM1rl+dcKvjr/8KW5V6nMSYkWUGJUpnV60ir20mRdXf577g7nKs6zvqj10mMCUlWUKJUw/hJUeqhHicJI6mZcMxNsPwtWDvH6zTGhJygFhQRGSUiy0WkUETu8vF6oohMcV+fKyJ57vKTRWS+iCx0709stM6R7vJCEfmXiE1AtT9yKxayJyaNzYl5XkcJL0Ovg7SO8N49oOp1GmNCStAKiojEAo8ApwH9gDEi0q9Js6uAHaraC3gQuN9dvhU4U1UPAS4DXmi0zmPAOKC3exsVrM8QybpXLKI4pR8qtpPaIgmpzpQsxXNh+Qyv0xgTUoL512QIUKiqq1S1GpgMnN2kzdnAc+7jqcBIERFV/VpVG47PXAwkuXsznYAMVZ2tqgo8D5wTxM8QkRLrdpNTudoG5PfX4ZdAVh+Y9Qeoq/U6jTEhw6+CIiKvisjPRFr072wXoLjR8xJ3mc82qloLlAKZTdqcD3ytqlVu+5JmttmQeZyIFIhIwZYtduW9xnIrlhCD2vkn+ys2Dk76A2z9DuY/43UaY0KGvwXiMeAXwAoR+ZuI9PVjHV9jG007nffZRkT643SDXdOCbToLVSeo6iBVHZSdne1H3OiRW7GIeoTilKY9kMZvB50O+cfBB3+26e2NcflVUFR1lqpeDBwBrAHeE5EvROQKEYnfy2olQLdGz7sCTU8z/r6NiMQBbYDt7vOuwGvApaq6slH7rs1s0zQjt3wRm5J6UBWb6nWU8CUCo+6Hql3w4V+8TmNMSPC7C0tEMoHLgV8CXwMP4xSY9/ayyjygt4jki0gCMBqY3qTNdJxBd4ALgA9UVUWkLfAWMF5VP29orKobgF0iMtQ9uutS4HV/P4MB0XpyKxZbd1cgdOgHg6+CgomwcZHXaYzxXJw/jURkGtAX52irM90/7ABTRKTA1zqqWisiNwAzgVhgoqouFpF7gQJVnQ48DbwgIoU4eyaj3dVvAHoBd4vI3e6yU1R1M3At8CyQDLzt3oyfcqrWkFRfTlGqFZTx0xYe8DaSa8/h9pjJbHjhBp7q8S8Q4b7z7GAHE538KijAU6r6o2MkRSRRVatUddDeVnLXmdFk2T2NHlcCF/pY78/An/eyzQLA/hrup1ybEDKg9sRl8F6HX3L2+gcYUPoRi9qe4HUkYzzjb5eXrz/uswMZxLSO3IrF7I5ty7aErs03Nn75MvMsNiT15PQNjxBfX+l1HGM8s8+CIiIdReRIIFlEDheRI9zb8UBKqyQ0AdW9fCFrUwc4g8omIOoljjc630y7mo2cuOlZr+MY45nmurxOxRmI7wo80Gj5LuC3QcpkgqV8G9nVxcxvf7rXSSLO6rTDKWh3OsdumQSbroMO/b2OZEyr2+ceiqo+p6onAJer6gmNbmep6rRWymgCpWQeAEUpNmgcDG93up49senwxs1QX+91HGNaXXNdXmPdh3kicmvTWyvkM4FUPJc6YlmX4s95qaalKuLaMKPz9VDyJcyf6HUcY1pdc4PyDWe+pQHpPm4mnJTMY0Nyb2pikrxOErG+bjsK8kc410wp29D8CsZEkH2OoajqE+69XVEo3NXVwLr5FGXY+ElQicAZD8KjR8M7v4GfP+91ImNajb+TQ/5dRDJEJF5E3heRrY26w0w42LQIaiqcI7xMcGX2hBF3wJLXYekbXqcxptX4ex7KKapaBpyBM59WH+COoKUygVfcMCBvBaVVDL8ZOh4Kb94C5du8TmNMq/C3oDRMAHk6MElVbXrVcFM8F9I7Uxrfwesk0SE2Hs59HPbshLdusas7mqjgb0F5Q0SWAYOA90UkG7BTgsNJyZfQbbCd0NiaOvSHE37rdH0tetXrNMYEnb/T198FHA0MUtUaoJyfXn3RhKpdG2HnWuh2lNdJos+wG6HLIJhxO+za5HUaY4KqJVdgPBi4SEQuxZlq/pTgRDIBV/ylc991iLc5olFsnNP1VbMHXr/OTng0Ec3fo7xeAP4POAYY7N72OsuwCTHFcyE2ETod6nWS6JTVG079CxTOgjmPep3GmKDxd/r6QUA/VRtZDEvFX0LnwyEu0esk0WvQVbDyQ5j1B8gb7nw/jIkw/nZ5LQI6BjOICZKaStiwwBmQN94RgbP+DWk5MPVK59LBxkQYfwtKFrBERGaKyPSGWzCDmQBZ/xXUVUPuMK+TmJT2cN4E2LEG3rrdDiU2EcffLq8/BDOECaKiz5373KHe5jCOvGPguDvh479B7lEw6EqvExkTMP4eNvwxsAaIdx/PA74KYi4TKEWzIftg579jExpG3Ak9R8KMO6GkwOs0xgSMv0d5XQ1MBZ5wF3UB/hesUCZA6mqdAfnu1t0VUmJi4fynIKMTvHwplG/1OpExAeHvGMr1wHCgDEBVVwA5wQplAmTTQqjeZQUlFKW0h5+/ABXbYOoVTvE3Jsz5W1CqVLW64YmIxAE2ohjqimY797lHe5vD+NZ5IPzsAVj9Ccwc73UaYw6YvwXlYxH5LZAsIicDrwDNzsstIqNEZLmIFIrIXT5eTxSRKe7rc0Ukz12eKSIfishuEflPk3U+cre5wL3ZntLerP0C2uZCmy5eJzF7c/jFcPQN8OUEmDvB6zTGHBB/C8pdwBZgIXANMAP4/b5WEJFY4BHgNKAfMEZE+jVpdhWwQ1V7AQ8C97vLK4G7gdv3svmLVXWge9vs52eILqrOHkr34V4nMc05+V446HTnglzfvet1GmP2m1+HDatqvYj8D/ifqm7xc9tDgEJVXQUgIpNxJpRc0qjN2fxwSPJU4D8iIqpaDnwmIr38fC/T1NYVULHVurs8MH7awhavkxB3M+MSC8mafCmP93yMjcm+f/TvO++QA41nTNDscw9FHH8Qka3AMmC5iGwRkXv82HYXoLjR8xJ3mc82qloLlAKZfmz7Gbe7624Rm4/dp7VfOPc2IB8WqmNTeD7/fipjUrli9W20q1rndSRjWqy5Lq+bcY7uGqyqmaraHjgKGC4itzSzrq8/9E0H8v1p09TFqnoIcKx7u8Tnm4uME5ECESnYssXfnaoIUjQbUrMh03bywkVZfDYTezxAnNZw1epbSK+xw4lNeGmuoFwKjFHV1Q0L3C6sse5r+1ICdGv0vCuwfm9t3CPH2gD7vBqkqq5z73cBL+F0rflqN0FVB6nqoOzs7GaiRqC1Xzhnx9sOXFjZnNSDZ/P/QVrtDq5YfRtJtWVeRzLGb80VlHhV/cm/Se44SryP9o3NA3qLSL6IJACjgabzf00HLnMfXwB8sK8ZjUUkTkSy3MfxONe4X9RMjuhTWuJcUMsG5MNScUp//tv9r2RXFXHFmjtIrCv3OpIxfmmuoFTv52sNYyI3ADOBpcDLqrpYRO4VkbPcZk8DmSJSCNyKczQZACKyBngAuFxEStwjxBKBmSLyLbAAWAc82cxniD5F7viJDciHrcL0wUzO/SNdKpZx5epbSazb7XUkY5rV3FFeh4mIr31uAZKa27iqzsA5xLjxsnsaPa4ELtzLunl72eyRzb1v1Fv1MSS1hY52RFA4W9xmBC91v5dfFN3DVatuYWKPB7yOZMw+7XMPRVVjVTXDxy1dVZvr8jJeUIXVH0P+sc6cUSasLWkzghe7/4VOlSu4atXNULHPIUZjPNWSa8qbcLB9FZQWQ/4Ir5OYAFna5hj+2/2vdKhcDU+f4oyPGROCrKBEmtUfO/c9jvcyhQmw5RnDmNjjQSjfDE+dDBvtWBQTevy9wJYJF6s/gfROdv5JBFqTehgP5f6bK1bfRuKEU3g+7z5Wpx0RkG3bGfgmEGwPJZLU1zsFJX+EnX8SoTYl9eCxno9TGp/Nlatv4/Ad73gdyZjvWUGJJJsXO9fX6GHjJ5GsNKEDT/R8lKKUAfy8+M+cuuExROu8jmWMFZSIssodP7EB+Yi3Jy6DiT0eZE77czh+y4uMXfNbEuoqvI5lopwVlEiy+mNn7MSufxIV6iWO17vezuudb+WgXXO4tvAam1TSeMoKSqSorXbOkM8/zuskppXNyTqPZ/L/SUbtVq4vHEeP3fO9jmSilBWUSFE8B6p3Q8+RXicxHliZPohHez3J7rh2XLnqVo7e+qpzkqsxrcgKSqRY8R7ExNuAfBTbltiVx3o9wfKMozlr/YOcV3I/sfX7nHLPmICyghIpCmdB96MhMd3rJMZDVbGp/Lf7X3k/53IG73iTq1fdSFrNNq9jmShhBSUSlJbA5iXQ62Svk5gQoBLDrI6/5MXce+m0p5AbCn9J14qlXscyUcAKSiRY8Z5z3/sUb3OYkLKo7Yk81usx6oll3MrrGbhjpteRTISzghIJCmdBm26QfZDXSUyI2Zjcm0d6P8nalP5cVPwnTlv/iJ0EaYLGCkq4q62CVR9Br5NsuhXjU3lcOyb2eJAvMs/nuK2TuHz1HSTV7fI6lolAVlDC3aqPncOFDzrd6yQmhNVLHG90uYVXu/yGHuVfcc3K68mo3ux1LBNhrKCEu2VvQEK6HS5s/FKQeSbP5v2DttUbuXblr8ipXOV1JBNBrKCEs/o6WDYDep8McYlepzFhYmX6YCb0fIQYreNXK68jb/cCryOZCGEFJZwVz4WKrXDwmV4nMWFmQ3JvHuv1OLviMrlq9S2w7C2vI5kIYAUlnC19E2ITnT0UY1poZ0InHu/5GOuTe8OUS2DhVK8jmTBnBSVcqTrjJz2Ot7PjzX7bE5fB0/kPQe5QePWX8PV/vY5kwlhQC4qIjBKR5SJSKCJ3+Xg9UUSmuK/PFZE8d3mmiHwoIrtF5D9N1jlSRBa66/xLJEqPlS0pgJ1rod9ZXicxYa46NgUungo9T4DXr4cvn/Q6kglTQSsoIhILPAKcBvQDxohIvybNrgJ2qGov4EHgfnd5JXA3cLuPTT8GjAN6u7dRgU8fBha+DHFJNn5iAiMhBcZMdg4/n3E7zHnM60QmDAVzD2UIUKiqq1S1GpgMnN2kzdnAc+7jqcBIERFVLVfVz3AKy/dEpBOQoaqzVVWB54FzgvgZQlNdDSyaBn1GQVIbr9OYSBGXCD9/3vkn5Z27bE/FtFgwC0oXoLjR8xJ3mc82qloLlAKZzWyzpJltRr5VHzlHdx36c6+TmEgTGw/nT/xhT6XgGa8TmTASF8Rt+xrbaHrFH3/a7Fd7ERmH0zVGRlYnxk9buI/N7r/7zjskKNvdp29fhqS2NruwCY64BLjwWZgyFt68GWLi4IhLvE5lwkAw91BKgG6NnncF1u+tjYjEAW2A7c1ss2sz2wRAVSeo6iBVHZTSpl0Lo4ewyjJY9ib0P8f5xTcmGOIS4ecvQM8TYfqvYcEkrxOZMBDMgjIP6C0i+SKSAIwGpjdpMx24zH18AfCBOzbik6puAHaJyFD36K5LgdcDHz2EfTsFairg8Eu9TmIiXXwSjH4J8o+F16+z81RMs4JWUNwxkRuAmcBS4GVVXSwi94pIw7GuTwOZIlII3Ap8f2ixiKwBHgAuF5GSRkeIXQs8BRQCK4G3g/UZQo4qFEyETodBlyO8TmOiQXyyc/RX7jCYNg4Wv+Z1IhPCgjmGgqrOAGY0WXZPo8eVwIV7WTdvL8sLgAGBSxlGiuc6V2Y882Gbqt60noRU+MUU+O/5zsmPMfFw8BlepzIhyM6UDyfznobEDBhwgddJTLRJTIOLX4FOA+GVy2H5O14nMiHICkq42LURlvwPDr3I+eU2prUlZcDYV6HjAHj5Elgxy+tEJsRYQQkXs/8D9bUw9Fqvk5holtwWxk5zLjc9+Rew8kOvE5kQYgUlHFRsh3kTYcD5kNnT6zQm2qW0h0unQ2YvmDQGVn/qdSITIoI6KG/2X+MTMUdufJqTasp5qOpMNgXpBE1jWiSlPVz6Ojx3Brx0kdMV1v1or1MZj9keSohLqi1j2LapLM44lk1JPbyOY8wP0rKdPZWMzvDiBVD8pdeJjMesoIS4EzY/T1LdbmZ1uNLrKMb8VHoHuOwNSMuB58+BVR97nch4yApKCGtXtY5h217lq3ansTG5t9dxjPEtoxNc8Ta06w4vXmiXE45iVlBClSrnrPsndRLHex2v9jqNMfuW3hEuf8s5pHhmw07PAAARB0lEQVTKJfDNFK8TGQ9YQQlRA3e+S5/dXzKz4zWUxWd7HceY5jUM1OcNh9fGwdwnvE5kWpkVlFC0Yw1nrXuQopQBzMk81+s0xvgvMR1+8Qr0PQPevhPevgvq67xOZVqJHTYcamoqYaozAD8l9x5UYj0OZKJBoK8XJPF3cHpWKsfMfQx2rIbzn3KKjYlotocSSurr4X+/gnXzebXbeHYkdPY6kTH7RSWWtzr/Gn72T1jxHkw8Dbav9jqWCTIrKKGivs65Ot7i1+CkP7K4zQivExlz4Ab/Ei5+GUrXwoQRsGxG8+uYsGVdXj5kVa0lt3wxnSpXkFpbSkJ9BdUxyVTEZrA1sRsbk3uxIaknVbEBmqSxaje8fr0z+eOxt8Hwm+C1RYHZtjFe63USXPMJvHwpTB4Dw2+GE++GWPvzE2nsO+qKq69i0PY3GbTjLbrs+Q6Aaklid3w7qmJSSKjfQ2rtTpLqKwCoJ4Z1yQfBrNOgx/HQ7SjnCnctVTQb3rgRthXCyX+C4TcG7kMZEyra5cGV78I7v4HPH4I1n8K5T0CWnV8VSaygqHLYzlmcuvFx2tVsYl1yH97ofBOFaYPYkpj740FxVTJqttCpspBuFUvpubsAPn8YPnsA4pKg62DIO9a5ZGqXI53rcvtSV+P8Qs2dAN+9DW26wSWvOYXJmEgVn+RcHC7/OHjrNnj8GDjpDzDkGoix3vdIIPu4hHvE6NSrv17+98k/WZ5Ut4vzSu7nkNKPWJfUhxmdr2dV2pEt2vZ9P8uDoi+cKSfWfAobFwLqXNUus5czO3ByO+dSqpWlULYeNnwDVWWQ3B6O+hUMu8G5Kl4jgT7qxhgv3HfeIb5f2LURpt8IK2Y6lxf+2T+hQz/fbY1nRGS+qg7yt33U7qFkV67h8tV30KZmMzM6Xsdn2aNR2Y//khLToc+pzg1gzw6nG6t4Lmz9zunKqiyFmj2Q1MaZ8+iQC6DnSOg10ik0xkSb9I7OZYUXvAjv/t7ZWxl6LRx/lx1eHMaisqB0K1/E5WvupE7ieKLnIxSnBvAS9cntoO/pzs0Ys3cicPhYOOh0mPUH5yJyi151isrAsTZoH4ai7jvWvfwbrlx1G7viM3k6/wF2JHbxOpIxEcv/rtur6dZrGD9b/2+6v3ETm9/9J+92HMfijBFO4Wlir11pxlNRNRLWcc8KLlv9G0rjs3m856NWTIwJIcUp/Xm852M83/0+lBjGFv2e6wuv5uDSTxGt9zqe8UPU7KG0rd7Alatvoyo2had7PMju+EyvIxljmhJhaZtjWZYxjMN3zGTk5me4tGg8GxPz+ThnLN+2HUm9RM2frbAT1D0UERklIstFpFBE7vLxeqKITHFfnysieY1eG+8uXy4ipzZavkZEForIAhEp8CuH1nPJmvHE1VczMf8BShM6BuLjGWOCRCWWr9qfzj8PmsSUbvcAcFHxn7ht+RiO2vaaM+edCTlBO2xYRGKB74CTgRJgHjBGVZc0anMdcKiq/kpERgPnqupFItIPmAQMAToDs4A+qlonImuAQaq61d8s/bu11YVXCc/l/53v0ocG6iMaY1qJaD19yz7nhM3P023PUnbFteezrJ8zN/OcwM1Y4bLxmR+09LDhYO6hDAEKVXWVqlYDk4Gzm7Q5G3jOfTwVGCki4i6frKpVqroaKHS3t1+S63bxTsdfWTExJkypxLC0zbE82msCT/Z4mI1JPTlt4+PctfR8Tt3wOGk127yOaAjuGEoXoLjR8xLgqL21UdVaESkFMt3lc5qs2zCCrsC7IqLAE6o6wdebi8g4YBxAnw4pfJo95sA+jTHGeyKsSjuSVWlH0rliGSO2vMhxW15k+NaXmd/+dD7JGmMH23gomAXlp8f6OcXAnzb7Wne4qq4XkRzgPRFZpqqf/KSxU2gmAHTuebD6OvTQGBO+1qf0ZVL3P5FVtZZjt0xi0Pa3GLJtOt+2PZGPsy9mY7LNE9bagtnlVQJ0a/S8K7B+b21EJA5oA2zf17qq2nC/GXgNP7rC9usMeGNMWNiamMtrXX/D3/u+wmdZF3Fw2efctOIKxhTdQ2ZVcfMbMAETzL+084DeIpIvIgnAaGB6kzbTgcvcxxcAH6hzlMB0YLR7FFg+0Bv4UkRSRSQdQERSgVMAm+fdGMOu+Cze7nw9f+v7Kh/kXEbfsi+4ZflYzi75P9Jr/D6GxxyAoHV5uWMiNwAzgVhgoqouFpF7gQJVnQ48DbwgIoU4eyaj3XUXi8jLwBKgFrjePcKrA/CaM25PHPCSqr4TrM9gjAk/lXEZvNfxamZnnseJm59jyLbXOWLHO3zQ4TI+y7qIupgEryNGrKiebdgYE/naV63jtA2PMKDsE7YkdOONLrewIn3vPeV22PAPQumwYWOM8dz2xC68mPdXnsn/PwTlytW3cvGa31k3WBBYQTHGRIXv0ofyUJ/nmdlxHAftms0t343liO0zIAp6aVqLFRRjTNSoi0ngo5xLebjPc2xM6smFJX/l8jV30KZ6k9fRIoIVFGNM1NmW2I0ne/yb6Z1vJn/3Am7+7hIGb5tueysHyAqKMSYqqcQwO+sCHurzHOuS+3Leur9z+ZrboXSd19HClhUUY0xU25HYhad7PMTrnW8hf/c38OjRsGCS7a3sBysoxpiopxLDnKzz+VefZyHnYPjfr2DyxbB7s9fRwooVFGOMcW1L7ApXzICT/wSFs+CRo2Dxa17HChtWUIwxprGYWBh+I1zzCbTrDq9cDq9cARXbvU4W8qygGGOMLzl94apZcMLvYekbzt7KshlepwppVlCMMWZvYuNgxB0w7kNIy4HJY+C1a2HPDq+ThSQrKMYY05yOh8DVH8Jxd8C3U+Dfg+Cr56G+3utkIcUKijHG+CMuAU78vbO3ktkTpv8anhoJxfO8ThYyrKAYY0xLdDoMrpwJ5z4BZevg6ZNg0i9go12ayQqKMca0lAgcNhp+PR9O+B2s+RQeH+4cEbZ+gdfpPGMFxRhj9ldiOoy4E27+Fo69HVa8BxNGwMTTYMl0qKv1OmGrsoJijDEHKrkdjLwbblkMp/wFykrg5UvgwX4w83ew4ZuomMolaJcANsaYqJPcFobdAEOvheVvwzeTYO4TMPs/kNUH+pwKvU+F3KEQG+912oCzgmKMMYEWEwsHn+HcKrbD4mlOF9icx+GLf0NiG+gxAnKPdopLx0Odc17CXPh/AmOMCWUp7WHwLxlffBQJB1fQa/c8+pbNplfhl7RbOh2AqphkilP6UZzcjw3JvdiQ3JttCV1RaX5U4r7zDgn2J/CbFRRjjGlk/LSFQdt2dWwKS9qMYEmbEQBk1Gyhe/m35JUvpHv5txy35SViqQOcIrMxqScbknuxKbEHWxJz2ZLUnbK4LOcosxBkBcUYYzxSFp/NwrYjWdh2JACx9dXkVK2h854VdNqzgk6VhQzc8R5J9eXfr1MVk+wUl8TubE3MhUXDoG13aNPNmR7Gw2IT1IIiIqOAh4FY4ClV/VuT1xOB54EjgW3ARaq6xn1tPHAVUAfcqKoz/dmmMcaEq7qYBDYk92FDcp8fFqqSUbuV7MoisquKyK4qJruqiLzybzh857sw9akf2sYlQZuuTnFpmwttu0FaR6fQpOVAag6kZjtn/QdB0AqKiMQCjwAnAyXAPBGZrqpLGjW7Ctihqr1EZDRwP3CRiPQDRgP9gc7ALBFp+Ao3t01jjIkcIpTFZ1MWn83K9EE/eim+fg/3HpMCpcWwsxhK18LOtc7j5TOgfIvvbSa3c4pLWo7zOLktJLX98X1yuxZHDeYeyhCgUFVXAYjIZOBsoPEf/7OBP7iPpwL/ERFxl09W1SpgtYgUutvDj20aY0xUqIlJZvwXCnR1b0c7f9WznFtcfRVptdtJr9lGWu0O53HtdtJqt5NWs4P0zdtIrismuW4XyXW7iNfqA8oTzILSBShu9LwEOGpvbVS1VkRKgUx3+Zwm63ZxHze3TWOMMUBtTCI7EzqxM6GTX+3j6qvc4lJGct0u4JIWvV8wC4qvkaGmp4rurc3elvs6hs7n6aciMg4Y5z6t+tv5h4bDzG1ZwFavQzQjHDKC5Qw0yxlY4ZLzoJY0DmZBKQG6NXreFVi/lzYlIhIHtAG2N7Nuc9sEQFUnABMARKRAVQf5ahdKwiFnOGQEyxloljOwwilnS9oHcy6veUBvEckXkQScQfbpTdpMBy5zH18AfKCq6i4fLSKJIpIP9Aa+9HObxhhjPBC0PRR3TOQGYCbOIb4TVXWxiNwLFKjqdOBp4AV30H07ToHAbfcyzmB7LXC9qtYB+NpmsD6DMcYY/wX1PBRVnQHMaLLsnkaPK4EL97LuX4C/+LNNP0xoYXuvhEPOcMgIljPQLGdgRWRO0SiYUtkYY0zw2fVQjDHGBEREFxQRGSUiy0WkUETu8jpPAxGZKCKbRWRRo2XtReQ9EVnh3rf8NNUAE5FuIvKhiCwVkcUiclMoZhWRJBH5UkS+cXP+0V2eLyJz3ZxT3AM5PCUisSLytYi8GcIZ14jIQhFZ0HCUT6h9z91MbUVkqogsc39Gjw61nCJykPt1bLiVicjNoZbTzXqL+/uzSEQmub9XLfr5jNiC0mjql9OAfsAYd0qXUPAsMKrJsruA91W1N/C++9xrtcBtqnowMBS43v0ahlrWKuBEVT0MGAiMEpGhOFP5POjm3IEz1Y/XbgKWNnoeihkBTlDVgY0ObQ217zk4c/q9o6p9gcNwvq4hlVNVl7tfx4E4cxZWAK8RYjlFpAtwIzBIVQfgHPTUMB2W/z+fqhqRN+BoYGaj5+OB8V7napQnD1jU6PlyoJP7uBOw3OuMPjK/jjOPWshmBVKAr3BmUNgKxPn6efAoW1ecPx4nAm/inMAbUhndHGuArCbLQup7DmQAq3HHgUM1Z5NspwCfh2JOfpi1pD3OwVpvAqe29OczYvdQ8D31S5e9tA0FHVR1A4B7n+Nxnh8RkTzgcGAuIZjV7UpaAGwG3gNWAjtVtdZtEgrf/4eAO4F693kmoZcRnNkn3hWR+e6MExB63/MewBbgGbcL8SkRSSX0cjY2GpjkPg6pnKq6Dvg/YC2wASgF5tPCn89ILij+TP1i/CAiacCrwM2qWuZ1Hl9UtU6dboWuOBOJHuyrWeum+oGInAFsVtX5jRf7aBoKP6PDVfUInO7i60XkOK8D+RAHHAE8pqqHA+WERjecT+7Yw1nAK15n8cUdwzkbyMeZ4T0V5/vf1D5/PiO5oPgz9Uso2SQinQDc+80e5wFAROJxismLqjrNXRySWQFUdSfwEc6YT1txpvQB77//w4GzRGQNMBmn2+shQisjAKq63r3fjNPfP4TQ+56XACWqOtd9PhWnwIRazganAV+p6ib3eajlPAlYrapbVLUGmAYMo4U/n5FcUMJtmpbG09BchjNe4SkREZzZDJaq6gONXgqprCKSLSJt3cfJOL8cS4EPcab0AY9zqup4Ve2qqnk4P4sfqOrFhFBGABFJFZH0hsc4/f6LCLHvuapuBIpFpGHywpE4M2uEVM5GxvBDdxeEXs61wFARSXF/7xu+ni37+fR6oCrIA02nA9/h9Kf/zus8jXJNwumnrMH5T+sqnP7094EV7n37EMh5DM4u7rfAAvd2eqhlBQ4FvnZzLgLucZf3wJkDrhCnqyHR66+pm+t44M1QzOjm+ca9LW74vQm177mbaSBQ4H7f/we0C9GcKThXpG3TaFko5vwjsMz9HXoBSGzpz6edKW+MMSYgIrnLyxhjTCuygmKMMSYgrKAYY4wJCCsoxhhjAsIKijHGmICwgmKMMSYgrKAYY4wJCCsoxhhjAuL/Acj2nMCfo6zIAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# find the replaceable data for the nan in the age.\n",
    "# check the current data\n",
    "ax = total_df[\"Age\"].hist(bins=15, density=True, stacked=True, alpha=0.6)\n",
    "total_df[\"Age\"].plot(kind='density')\n",
    "plt.xlim(0, total_df.Age.max())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28.0\n"
     ]
    }
   ],
   "source": [
    "# The data is skewed. the nan will be replace with median.\n",
    "age_replace = total_df[\"Age\"].median()\n",
    "print(age_replace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "S    914\n",
       "C    270\n",
       "Q    123\n",
       "Name: Embarked, dtype: int64"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find the replaceable data for the nan in the Embarked.\n",
    "total_df.Embarked.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S\n"
     ]
    }
   ],
   "source": [
    "embarked_replace = total_df.Embarked.value_counts().idxmax()\n",
    "print(embarked_replace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# find the replaceable data for the nan in the Fare.\n",
    "# check the current data\n",
    "ax = total_df.Fare.hist(bins=15, density=True, stacked=True, alpha=0.6)\n",
    "total_df.Fare.plot(kind='density')\n",
    "plt.xlim(0, total_df.Fare.max())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.4542\n"
     ]
    }
   ],
   "source": [
    "fare_replace = total_df.Fare.median()\n",
    "print(fare_replace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Age               0\n",
       "Cabin          1014\n",
       "Embarked          0\n",
       "Fare              0\n",
       "Name              0\n",
       "Parch             0\n",
       "PassengerId       0\n",
       "Pclass            0\n",
       "Sex               0\n",
       "SibSp             0\n",
       "Survived          0\n",
       "Ticket            0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fill nan data to replace value\n",
    "total_df.Age.fillna(age_replace, inplace=True)\n",
    "total_df.Embarked.fillna(embarked_replace, inplace=True)\n",
    "total_df.Fare.fillna(fare_replace, inplace=True)\n",
    "\n",
    "total_df.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "define filler function for data.\n",
    "\n",
    "Change Sex col. male to 1, female to 0\n",
    "change embarked col. C,Q,S to 0,1,2\n",
    "\n",
    "''' \n",
    "def SE_filter(df):\n",
    "    for row_index, value in df.iterrows():\n",
    "        # Change Sex col. male to 1, female to 0\n",
    "        if value.Sex == 'male':\n",
    "            df.at[row_index, 'Sex'] = 1\n",
    "        elif value.Sex == 'female':\n",
    "            df.at[row_index, 'Sex'] = 0\n",
    "        \n",
    "        # change embarked col. C,Q,S to 0,1,2\n",
    "        if value.Embarked == 'C':\n",
    "            df.at[row_index, 'Embarked'] = 0\n",
    "        elif value.Embarked == 'Q':\n",
    "            df.at[row_index, 'Embarked'] = 1\n",
    "        elif value.Embarked == 'S':\n",
    "            df.at[row_index, 'Embarked'] = 2\n",
    "    \n",
    "    df = df.drop(columns=['PassengerId', 'Name', 'Ticket', 'Cabin'])\n",
    "        \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# replace Sex and Embarked to number\n",
    "# drop 'PassengerId', 'Name', 'Ticket', 'Cabin'\n",
    "total_df = SE_filter(total_df)\n",
    "\n",
    "# print(total_df.Sex)\n",
    "# print(total_df.Embarked)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1309,)\n",
      "(1309, 7)\n"
     ]
    }
   ],
   "source": [
    "total_df_y = total_df.Survived.copy()\n",
    "total_df_x = total_df.drop(columns=['Survived'])\n",
    "\n",
    "print(total_df_y.shape)\n",
    "print(total_df_x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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>Age</th>\n",
       "      <th>Embarked</th>\n",
       "      <th>Fare</th>\n",
       "      <th>Parch</th>\n",
       "      <th>Pclass</th>\n",
       "      <th>Sex</th>\n",
       "      <th>SibSp</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>22.0</td>\n",
       "      <td>1</td>\n",
       "      <td>7.2500</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>38.0</td>\n",
       "      <td>2</td>\n",
       "      <td>71.2833</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>26.0</td>\n",
       "      <td>1</td>\n",
       "      <td>7.9250</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>35.0</td>\n",
       "      <td>2</td>\n",
       "      <td>53.1000</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>35.0</td>\n",
       "      <td>2</td>\n",
       "      <td>8.0500</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    Age Embarked     Fare  Parch  Pclass Sex  SibSp\n",
       "0  22.0        1   7.2500      0       3   1      1\n",
       "1  38.0        2  71.2833      0       1   0      1\n",
       "2  26.0        1   7.9250      0       3   1      0\n",
       "3  35.0        2  53.1000      0       1   1      1\n",
       "4  35.0        2   8.0500      0       3   0      0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_df_x.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Age         3.835740e-17\n",
       "Embarked    2.317135e-16\n",
       "Fare       -6.679997e-16\n",
       "Parch      -5.920059e-17\n",
       "Pclass     -4.829343e-16\n",
       "Sex         1.969395e-16\n",
       "SibSp       2.178887e-16\n",
       "dtype: float64"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# data normailzation\n",
    "total_df_x_norm = (total_df_x - total_df_x.mean())/total_df_x.std()\n",
    "\n",
    "total_df_x_norm.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Age         1.0\n",
       "Embarked    1.0\n",
       "Fare        1.0\n",
       "Parch       1.0\n",
       "Pclass      1.0\n",
       "Sex         1.0\n",
       "SibSp       1.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_df_x_norm.std()**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Age         float64\n",
       "Embarked     object\n",
       "Fare        float64\n",
       "Parch       float64\n",
       "Pclass      float64\n",
       "Sex          object\n",
       "SibSp       float64\n",
       "dtype: object"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_df_x_norm.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Age         float64\n",
       "Embarked    float64\n",
       "Fare        float64\n",
       "Parch       float64\n",
       "Pclass      float64\n",
       "Sex         float64\n",
       "SibSp       float64\n",
       "dtype: object"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# change object type to number type\n",
    "total_df_x_norm.Embarked = pd.to_numeric(total_df_x_norm.Embarked)\n",
    "total_df_x_norm.Sex = pd.to_numeric(total_df_x_norm.Sex)\n",
    "total_df_x_norm.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1309, 7)\n",
      "<class 'numpy.ndarray'>\n",
      "float64\n",
      "-----------\n",
      "(1309,)\n",
      "<class 'numpy.ndarray'>\n",
      "int64\n"
     ]
    }
   ],
   "source": [
    "# datafram to numpy array\n",
    "total_x = total_df_x_norm.values\n",
    "total_y = total_df_y.values\n",
    "\n",
    "print(total_x.shape)\n",
    "print(type(total_x))\n",
    "print(total_x.dtype)\n",
    "print('-----------')\n",
    "print(total_y.shape)\n",
    "print(type(total_y))\n",
    "print(total_y.dtype)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1309, 7)\n",
      "(1309,)\n"
     ]
    }
   ],
   "source": [
    "# save data\n",
    "np.save(inputpath+'total_x', total_x)\n",
    "np.save(inputpath+'total_y', total_y)\n",
    "\n",
    "# load data\n",
    "loaded_x = np.load(inputpath+'total_x.npy')\n",
    "loaded_y = np.load(inputpath+'total_y.npy')\n",
    "\n",
    "print(loaded_x.shape)\n",
    "print(loaded_y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.utils.data as utils\n",
    "from torch.autograd import Variable\n",
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_dataloader(data, label, train_index):\n",
    "    \n",
    "    dev_index = int(np.float(train_index * 0.85))\n",
    "    \n",
    "    # split data to train and test set\n",
    "    train_data = data[:train_index,:]\n",
    "    train_label = label[:train_index]\n",
    "    dev_data = train_data[dev_index:,:]\n",
    "    dev_label = train_label[dev_index:]\n",
    "    test_data = data[train_index:,:]\n",
    "    test_label = label[train_index:]\n",
    "    \n",
    "    '''\n",
    "    print(train_data.shape)\n",
    "    print(train_label.shape)\n",
    "    print(dev_data.shape)\n",
    "    print(dev_label.shape)\n",
    "    print(test_data.shape)\n",
    "    print(test_label.shape)\n",
    "    '''\n",
    "    \n",
    "    # np_array to tensor\n",
    "    train_data, train_label = torch.Tensor(train_data), torch.Tensor(train_label)\n",
    "    dev_data, dev_label = torch.Tensor(dev_data), torch.Tensor(dev_label)\n",
    "    test_data, test_label = torch.Tensor(test_data), torch.Tensor(test_label)\n",
    "    \n",
    "    # tensor to dataset\n",
    "    train_dataset = utils.TensorDataset(train_data, train_label)\n",
    "    dev_dataset = utils.TensorDataset(dev_data, dev_label)\n",
    "    test_dataset = utils.TensorDataset(test_data, test_label)\n",
    "    \n",
    "    # dataset to dataloader\n",
    "    train_dataloader = utils.DataLoader(train_dataset)\n",
    "    dev_dataloader = utils.DataLoader(dev_dataset)\n",
    "    test_dataloader = utils.DataLoader(test_dataset)\n",
    "    \n",
    "    return train_dataloader, dev_dataloader, test_dataloader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# take data and produce dataloaders\n",
    "train_dataloader, dev_dataloader, test_dataloader = data_dataloader(loaded_x, loaded_y, train_index=train_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set variables \n",
    "input_size = loaded_x.shape[1]\n",
    "output_size = 1\n",
    "num_epochs = 5\n",
    "learning_rate = 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create the model for Logistic Regression \n",
    "class LogisticRegression(nn.Module):\n",
    "    def __init__(self, input_size, output_size):\n",
    "        super(LogisticRegression, self).__init__()\n",
    "        self.linear = nn.Linear(input_size, output_size)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return F.sigmoid(self.linear(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set model, criterion, and optimizer.\n",
    "model = LogisticRegression(input_size, output_size)\n",
    "\n",
    "criterion = nn.BCELoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, num_epochs, train_dataloader, dev_dataloader, test_dataloader):\n",
    "    for epoch in range(num_epochs):\n",
    "        for i, (train_data, train_label) in enumerate(train_dataloader):\n",
    "\n",
    "            y_pred = model(train_data)\n",
    "\n",
    "            loss = criterion(y_pred, train_label)\n",
    "\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            '''\n",
    "            if(i+1) % 100 == 0:\n",
    "                print('Epoch: [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.data[0]))\n",
    "            '''\n",
    "\n",
    "    correct = 0\n",
    "    total = 0\n",
    "\n",
    "    for dev_data, dev_label in dev_dataloader:\n",
    "\n",
    "        output = model(dev_data)\n",
    "        output = output.round()\n",
    "        total += dev_label.size(0)\n",
    "        correct += (output == dev_label).sum()\n",
    "\n",
    "    print('In the Dev, Accuracy: {:.4f}%, correct: {}, total: {}'.format((100 * correct.item() / total), correct, total))\n",
    "\n",
    "\n",
    "    correct = 0\n",
    "    total = 0\n",
    "\n",
    "    outputs, labels = [], []\n",
    "\n",
    "\n",
    "    for test_data, test_label in test_dataloader:\n",
    "\n",
    "        output = model(test_data)\n",
    "        output = output.round()\n",
    "        total += test_label.size(0)\n",
    "        correct += (output == test_label).sum()\n",
    "\n",
    "        outputs.append(output.item())\n",
    "        labels.append(test_label.item())\n",
    "\n",
    "    print('In the test, Accuracy: {:.4f}%, correct: {}, total: {}'.format((100 * correct.item() / total), correct, total))\n",
    "    \n",
    "    return outputs, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\woare\\Anaconda3\\lib\\site-packages\\torch\\nn\\functional.py:1006: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n",
      "  warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n",
      "C:\\Users\\woare\\Anaconda3\\lib\\site-packages\\torch\\nn\\functional.py:1594: UserWarning: Using a target size (torch.Size([1])) that is different to the input size (torch.Size([1, 1])) is deprecated. Please ensure they have the same size.\n",
      "  \"Please ensure they have the same size.\".format(target.size(), input.size()))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In the Dev, Accuracy: 82.8358%, correct: 111, total: 134\n",
      "In the test, Accuracy: 82.2967%, correct: 344, total: 418\n"
     ]
    }
   ],
   "source": [
    "outputs, labels = train(model, num_epochs, train_dataloader, dev_dataloader, test_dataloader)\n",
    "\n",
    "outputs = np.asarray(outputs)\n",
    "labels = np.asarray(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_roc_and_auc_score(outputs, labels, title):\n",
    "    false_positive_rate, true_positive_rate, threshold = metrics.roc_curve(labels, outputs)\n",
    "    auc_score = metrics.roc_auc_score(labels, outputs)\n",
    "    plt.plot(false_positive_rate, true_positive_rate, label = 'ROC curve, AREA = {:.4f}'.format(auc_score))\n",
    "    plt.plot([0,1], [0,1], 'red')\n",
    "    plt.xlabel('False Positive Rate')\n",
    "    plt.ylabel('True Positive Rate')\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "    plt.title(title)\n",
    "    plt.legend(loc = 'lower right')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_roc_and_auc_score(outputs, labels, title = 'ROC curve with AUC score')"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}