Titanic survivor (1).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = pd.read_csv('Titanic.csv')\n",
    "test_data = pd.read_csv('Titanic test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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>pclass</th>\n",
       "      <th>survived</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",
       "      <th>boat</th>\n",
       "      <th>body</th>\n",
       "      <th>home.dest</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>O'Donoghue, Ms. Bridget</td>\n",
       "      <td>female</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>364856</td>\n",
       "      <td>7.750</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Q</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>Morley, Mr. Henry Samuel (\"Mr Henry Marshall\")</td>\n",
       "      <td>male</td>\n",
       "      <td>39.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>250655</td>\n",
       "      <td>26.000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>Smith, Miss. Marion Elsie</td>\n",
       "      <td>female</td>\n",
       "      <td>40.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>31418</td>\n",
       "      <td>13.000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "      <td>9</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>Goldsmith, Mrs. Frank John (Emily Alice Brown)</td>\n",
       "      <td>female</td>\n",
       "      <td>31.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>363291</td>\n",
       "      <td>20.525</td>\n",
       "      <td>NaN</td>\n",
       "      <td>S</td>\n",
       "      <td>C D</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Strood, Kent, England Detroit, MI</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>McCoy, Miss. Agnes</td>\n",
       "      <td>female</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>367226</td>\n",
       "      <td>23.250</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Q</td>\n",
       "      <td>16</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   pclass  survived                                            name     sex  \\\n",
       "0     3.0       0.0                         O'Donoghue, Ms. Bridget  female   \n",
       "1     2.0       0.0  Morley, Mr. Henry Samuel (\"Mr Henry Marshall\")    male   \n",
       "2     2.0       1.0                       Smith, Miss. Marion Elsie  female   \n",
       "3     3.0       1.0  Goldsmith, Mrs. Frank John (Emily Alice Brown)  female   \n",
       "4     3.0       1.0                              McCoy, Miss. Agnes  female   \n",
       "\n",
       "    age  sibsp  parch  ticket    fare cabin embarked boat  body  \\\n",
       "0   NaN    0.0    0.0  364856   7.750   NaN        Q  NaN   NaN   \n",
       "1  39.0    0.0    0.0  250655  26.000   NaN        S  NaN   NaN   \n",
       "2  40.0    0.0    0.0   31418  13.000   NaN        S    9   NaN   \n",
       "3  31.0    1.0    1.0  363291  20.525   NaN        S  C D   NaN   \n",
       "4   NaN    2.0    0.0  367226  23.250   NaN        Q   16   NaN   \n",
       "\n",
       "                           home.dest  \n",
       "0                                NaN  \n",
       "1                                NaN  \n",
       "2                                NaN  \n",
       "3  Strood, Kent, England Detroit, MI  \n",
       "4                                NaN  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "columns_to_drop=[\"name\",\"ticket\",\"cabin\",\"embarked\",\"boat\",\"body\",\"home.dest\"]\n",
    "traindata_clean = train_data.drop(columns_to_drop,axis =1)\n",
    "testdata_clean = test_data.drop(columns_to_drop,axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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>pclass</th>\n",
       "      <th>survived</th>\n",
       "      <th>sex</th>\n",
       "      <th>age</th>\n",
       "      <th>sibsp</th>\n",
       "      <th>parch</th>\n",
       "      <th>fare</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>female</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>7.750</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>male</td>\n",
       "      <td>39.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>26.000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>female</td>\n",
       "      <td>40.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>13.000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>female</td>\n",
       "      <td>31.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>20.525</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>female</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>23.250</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   pclass  survived     sex   age  sibsp  parch    fare\n",
       "0     3.0       0.0  female   NaN    0.0    0.0   7.750\n",
       "1     2.0       0.0    male  39.0    0.0    0.0  26.000\n",
       "2     2.0       1.0  female  40.0    0.0    0.0  13.000\n",
       "3     3.0       1.0  female  31.0    1.0    1.0  20.525\n",
       "4     3.0       1.0  female   NaN    2.0    0.0  23.250"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "traindata_clean.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 1009 entries, 0 to 1008\n",
      "Data columns (total 7 columns):\n",
      "pclass      1009 non-null float64\n",
      "survived    1009 non-null float64\n",
      "sex         1009 non-null object\n",
      "age         812 non-null float64\n",
      "sibsp       1009 non-null float64\n",
      "parch       1009 non-null float64\n",
      "fare        1008 non-null float64\n",
      "dtypes: float64(6), object(1)\n",
      "memory usage: 55.3+ KB\n"
     ]
    }
   ],
   "source": [
    "traindata_clean.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import LabelEncoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "le = LabelEncoder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "traindata_clean['sex'] = le.fit_transform(traindata_clean['sex'])\n",
    "testdata_clean['sex'] = le.fit_transform(testdata_clean['sex'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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>pclass</th>\n",
       "      <th>survived</th>\n",
       "      <th>sex</th>\n",
       "      <th>age</th>\n",
       "      <th>sibsp</th>\n",
       "      <th>parch</th>\n",
       "      <th>fare</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>7.750</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1</td>\n",
       "      <td>39.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>26.000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>13.000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0</td>\n",
       "      <td>31.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>20.525</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>23.250</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   pclass  survived  sex   age  sibsp  parch    fare\n",
       "0     3.0       0.0    0   NaN    0.0    0.0   7.750\n",
       "1     2.0       0.0    1  39.0    0.0    0.0  26.000\n",
       "2     2.0       1.0    0  40.0    0.0    0.0  13.000\n",
       "3     3.0       1.0    0  31.0    1.0    1.0  20.525\n",
       "4     3.0       1.0    0   NaN    2.0    0.0  23.250"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "traindata_clean.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "traindata_clean=traindata_clean.fillna(traindata_clean[\"age\"].mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "testdata_clean=testdata_clean.fillna(testdata_clean[\"age\"].mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_cols = ['pclass','sex','age','sibsp','parch','fare']\n",
    "output_cols = ['survived']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train=traindata_clean[input_cols]\n",
    "y_train=traindata_clean[output_cols]\n",
    "\n",
    "x_test=testdata_clean[input_cols]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1009, 6) (1009, 1)\n",
      "(300, 6)\n"
     ]
    }
   ],
   "source": [
    "print(x_train.shape,y_train.shape)\n",
    "print(x_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def entropy(col):\n",
    "    counts = np.unique(col,return_counts=True)\n",
    "    N = float(col.shape[0])\n",
    "    entropy = 0.0\n",
    "    for ix in counts[1]:\n",
    "        p = ix/N\n",
    "        entropy += (-1*p*np.log2(p))\n",
    "    return entropy\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def divide_data(x_data,fkey,fval):\n",
    "    # works with pandas dataframe \n",
    "    x_right = pd.DataFrame([],columns=x_data.columns)\n",
    "    x_left = pd.DataFrame([],columns=x_data.columns)\n",
    "    for ix in range(x_data.shape[0]):\n",
    "        val = x_data[fkey].loc[ix]\n",
    "        if val > fval:\n",
    "            x_right = x_right.append(x_data.loc[ix])\n",
    "        else:\n",
    "            x_left = x_left.append(x_data.loc[ix])\n",
    "    return x_left,x_right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def information_gain(x_data,fkey,fval): # here fkey is features name like sex , income , fare\n",
    "                                        # here fval is  threshold value of that feature name that we defined\n",
    "        left,right = divide_data(x_data,fkey,fval)\n",
    "        \n",
    "        # compute % of total sample on left and right\n",
    "        l = float(left.shape[0])/x_data.shape[0]\n",
    "        r = float(right.shape[0])/x_data.shape[0]\n",
    "        \n",
    "        if left.shape[0]==0 or right.shape[0]==0:\n",
    "            return -1000000 # min information gain\n",
    "        \n",
    "        i_gain = entropy(x_data.survived) - (l*entropy(left.survived) + r*entropy(right.survived))\n",
    "        return i_gain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DecisionTree:\n",
    "    \n",
    "    #Constructor\n",
    "    def __init__(self,depth=0,max_depth=5):\n",
    "        self.left = None\n",
    "        self.right = None\n",
    "        self.fkey = None\n",
    "        self.fval = None\n",
    "        self.max_depth = max_depth\n",
    "        self.depth = depth\n",
    "        self.target = None\n",
    "        \n",
    "    def train(self,X_train):\n",
    "        \n",
    "        features = ['pclass','sex','age','sibsp','parch','fare']\n",
    "\n",
    "        info_gains = []\n",
    "        \n",
    "        for ix in features:\n",
    "            i_gain = information_gain(X_train,ix,X_train[ix].mean())\n",
    "            info_gains.append(i_gain)\n",
    "            \n",
    "        self.fkey = features[np.argmax(info_gains)]\n",
    "        self.fval = X_train[self.fkey].mean()\n",
    "        print(\"Making Tree Features is\",self.fkey)\n",
    "        \n",
    "        #Split Data\n",
    "        data_left,data_right = divide_data(X_train,self.fkey,self.fval)\n",
    "        data_left = data_left.reset_index(drop=True)\n",
    "        data_right = data_right.reset_index(drop=True)\n",
    "         \n",
    "        #Truly a left node\n",
    "        if data_left.shape[0]  == 0 or data_right.shape[0] ==0:\n",
    "            if X_train.survived.mean() >= 0.5:\n",
    "                self.target = \"Survive\"\n",
    "            else:\n",
    "                self.target = \"Dead\"\n",
    "            return\n",
    "        #Stop earyly when depth >=max depth\n",
    "        if(self.depth>=self.max_depth):\n",
    "            if X_train.survived.mean() >= 0.5:\n",
    "                self.target = \"Survive\"\n",
    "            else:\n",
    "                self.target = \"Dead\"\n",
    "            return\n",
    "        \n",
    "        #Recursive Case\n",
    "        self.left = DecisionTree(depth=self.depth+1,max_depth=self.max_depth)\n",
    "        self.left.train(data_left)\n",
    "        \n",
    "        self.right = DecisionTree(depth=self.depth+1,max_depth=self.max_depth)\n",
    "        self.right.train(data_right)\n",
    "        \n",
    "        #You can set the target at every node\n",
    "        if X_train.survived.mean() >= 0.5:\n",
    "            self.target = \"Survive\"\n",
    "        else:\n",
    "            self.target = \"Dead\"\n",
    "        return\n",
    "    def predict(self,test):\n",
    "        if test[self.fkey]>self.fval:\n",
    "            # go to right\n",
    "            if self.right is None:\n",
    "                return self.target\n",
    "            return self.right.predict(test)\n",
    "        else:\n",
    "            if self.left is None:\n",
    "                return self.target\n",
    "            return self.left.predict(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt = DecisionTree()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Making Tree Features is sex\n",
      "Making Tree Features is pclass\n",
      "Making Tree Features is pclass\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is sibsp\n",
      "Making Tree Features is age\n",
      "Making Tree Features is age\n",
      "Making Tree Features is sibsp\n",
      "Making Tree Features is age\n",
      "Making Tree Features is sibsp\n",
      "Making Tree Features is parch\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is sibsp\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is age\n",
      "Making Tree Features is age\n",
      "Making Tree Features is parch\n",
      "Making Tree Features is parch\n",
      "Making Tree Features is sibsp\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is age\n",
      "Making Tree Features is sibsp\n",
      "Making Tree Features is sibsp\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is age\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is age\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is parch\n",
      "Making Tree Features is age\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is sibsp\n",
      "Making Tree Features is pclass\n",
      "Making Tree Features is pclass\n",
      "Making Tree Features is age\n",
      "Making Tree Features is pclass\n",
      "Making Tree Features is age\n",
      "Making Tree Features is sibsp\n",
      "Making Tree Features is parch\n",
      "Making Tree Features is pclass\n",
      "Making Tree Features is age\n",
      "Making Tree Features is pclass\n",
      "Making Tree Features is age\n",
      "Making Tree Features is parch\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is age\n",
      "Making Tree Features is sibsp\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is fare\n",
      "Making Tree Features is sibsp\n",
      "Making Tree Features is sibsp\n",
      "Making Tree Features is pclass\n",
      "Making Tree Features is age\n",
      "Making Tree Features is age\n",
      "Making Tree Features is pclass\n",
      "Making Tree Features is pclass\n"
     ]
    }
   ],
   "source": [
    "dt.train(traindata_clean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = []\n",
    "for ix in range(train_data.shape[0]):\n",
    "    y_pred.append(dt.predict(traindata_clean.loc[ix]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "le =LabelEncoder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = le.fit_transform(y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1009,)\n"
     ]
    }
   ],
   "source": [
    "print(y_pred.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_actual = traindata_clean[output_cols]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_actual"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1009, 1)"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_actual.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1009, 1)\n"
     ]
    }
   ],
   "source": [
    "y_pred = np.array(y_pred).reshape((-1,1))\n",
    "print(y_pred.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "acc  =np.sum(np.array(y_pred)==np.array(y_actual))/y_pred.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8057482656095144\n"
     ]
    }
   ],
   "source": [
    "print(acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred=pd.DataFrame(y_pred,columns=['survived'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred.to_csv('titanic_predictions.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decision Tree using Sklearn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "sk_tree  = DecisionTreeClassifier(criterion='entropy',max_depth=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=5,\n",
       "                       max_features=None, max_leaf_nodes=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, presort=False,\n",
       "                       random_state=None, splitter='best')"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sk_tree.fit(traindata_clean[input_cols],traindata_clean[output_cols])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0.,\n",
       "       1., 0., 0., 1., 0., 0., 0., 0., 1., 0., 1., 1., 0., 0., 1., 0., 0.,\n",
       "       0., 1., 0., 0., 0., 1., 1., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0.,\n",
       "       1., 0., 1., 0., 0., 0., 0., 1., 0., 1., 1., 0., 0., 0., 1., 0., 0.,\n",
       "       0., 1., 1., 0., 0., 0., 1., 0., 1., 1., 0., 0., 1., 0., 0., 1., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 1., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 1., 0., 1., 0., 1., 0., 0., 0., 1., 0., 0., 0., 0.,\n",
       "       1., 0., 1., 0., 0., 1., 0., 0., 0., 0., 1., 0., 1., 1., 0., 0., 0.,\n",
       "       1., 1., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 1., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 0., 1., 1.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 1., 0., 1., 0., 1.,\n",
       "       0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 1., 0., 0., 0., 1., 1., 1., 1., 0., 1., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 1., 1., 0., 0., 1., 0.,\n",
       "       0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 0., 1., 1.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sk_tree.predict(testdata_clean[input_cols])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8275520317145689"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sk_tree.score(traindata_clean[input_cols],traindata_clean[output_cols])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting pydotplus\n",
      "  Downloading pydotplus-2.0.2.tar.gz (278 kB)\n",
      "Requirement already satisfied: pyparsing>=2.0.1 in c:\\users\\ritik\\anaconda3\\lib\\site-packages (from pydotplus) (2.4.2)\n",
      "Building wheels for collected packages: pydotplus\n",
      "  Building wheel for pydotplus (setup.py): started\n",
      "  Building wheel for pydotplus (setup.py): finished with status 'done'\n",
      "  Created wheel for pydotplus: filename=pydotplus-2.0.2-py3-none-any.whl size=24571 sha256=2c2f6fd8bcaff65e86ccf20240a80e37fd532e9fa5ae52affb7c14fbb5bafa46\n",
      "  Stored in directory: c:\\users\\ritik\\appdata\\local\\pip\\cache\\wheels\\1e\\7b\\04\\7387cf6cc9e48b4a96e361b0be812f0708b394b821bf8c9c50\n",
      "Successfully built pydotplus\n",
      "Installing collected packages: pydotplus\n",
      "Successfully installed pydotplus-2.0.2\n"
     ]
    }
   ],
   "source": [
    "!pip install pydotplus\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}