Titanic Dataset¶
The challenge here is to complete the analysis of what sorts of people were likely to survive the most infamous shipwrecks in history. In particular, the goal is to apply the tools of machine learning to predict which passengers survived the tragedy, i.e to predict if a passenger survived the sinking of the Titanic or not.¶
https://www.kaggle.com/c/titanic¶
In [1]:
import numpy as np
import os
import pandas as pd
np.random.seed(42)
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
plt.rcParams['axes.labelsize'] = 14
plt.rcParams['xtick.labelsize'] = 12
plt.rcParams['ytick.labelsize'] = 12
PROJECT_ROOT_DIR = "."
CHAPTER_ID = "titanic_classification"
def save_fig(fig_id, tight_layout=True):
path = os.path.join(PROJECT_ROOT_DIR, "images", CHAPTER_ID, fig_id + ".png")
print("Saving figure", fig_id)
if tight_layout:
plt.tight_layout()
plt.savefig(path, format='png', dpi=300)
In [2]:
TITANIC_PATH = os.path.join("datasets","")
def load_titanic_data(file, titanic_path= TITANIC_PATH):
csv_path = os.path.join(titanic_path, file)
return pd.read_csv(csv_path)
In [3]:
titanic_train = load_titanic_data("titanic_train.csv")
titanic_test = load_titanic_data('titanic_test.csv')
titanic_train.head()
Out[3]:
In [4]:
import matplotlib.pyplot as plt
titanic_train.hist(bins= 50, figsize=(20,15))
save_fig("attribute_histogram_plots")
plt.show()
In [5]:
train_set = titanic_train
test_set = titanic_test
In [6]:
train_set.head(20)
Out[6]:
In [7]:
train_set.info()
In [8]:
from sklearn.base import BaseEstimator, TransformerMixin
# A class to select numerical or categorical columns
# since Scikit-Learn doesn't handle DataFrames yet
class DataFrameSelector(BaseEstimator, TransformerMixin):
def __init__(self, attribute_names):
self.attribute_names = attribute_names
def fit(self, X, y=None):
return self
def transform(self, X):
return X[self.attribute_names]
In [9]:
class MostFrequentImputer(BaseEstimator, TransformerMixin):
def fit(self, X, y=None):
self.most_frequent_ = pd.Series([X[c].value_counts().index[0] for c in X],
index=X.columns)
return self
def transform(self, X, y=None):
return X.fillna(self.most_frequent_)
In [10]:
from future_encoders import OneHotEncoder
In [11]:
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import Imputer
imputer = Imputer(strategy="median")
num_pipeline = Pipeline([
("select_numeric", DataFrameSelector(["Age", "SibSp", "Parch", "Fare"])),
("imputer", Imputer(strategy="median")),
])
In [12]:
cat_pipeline = Pipeline([
("select_cat", DataFrameSelector(["Pclass", "Sex", "Embarked"])),
("imputer", MostFrequentImputer()),
("one_hot_cat_encoder", OneHotEncoder(sparse=False)),
])
In [13]:
num_pipeline.fit_transform(train_set)
Out[13]:
In [14]:
cat_pipeline.fit_transform(train_set)
Out[14]:
In [15]:
from sklearn.pipeline import FeatureUnion
preprocess_pipeline = FeatureUnion(transformer_list=[
("num_pipeline", num_pipeline),
("cat_pipeline", cat_pipeline),
])
In [16]:
X_train = preprocess_pipeline.fit_transform(train_set)
X_train[:5]
Out[16]:
In [17]:
y_train = train_set["Survived"]
In [18]:
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score
svm_clf = SVC()
svm_clf.fit(X_train, y_train)
svm_score = cross_val_score(svm_clf, X_train, y_train, cv=10)
svm_score.mean()
Out[18]:
In [19]:
from sklearn.ensemble import RandomForestClassifier
forest_clf = RandomForestClassifier(random_state=42)
forest_clf.fit(X_train, y_train)
forest_scores = cross_val_score(forest_clf, X_train, y_train, cv=10)
forest_scores.mean()
Out[19]:
In [20]:
from sklearn.neighbors import KNeighborsClassifier
knn_clf = KNeighborsClassifier()
knn_clf.fit(X_train, y_train)
knn_scores = cross_val_score(knn_clf, X_train, y_train, cv=10)
knn_scores.mean()
Out[20]:
In [21]:
X_test = preprocess_pipeline.fit_transform(test_set)
In [22]:
y_pred = forest_clf.predict(X_test)
In [23]:
test_set[["PassengerId","Age"]][:10]
Out[23]:
In [24]:
X_test[:10]
Out[24]:
In [25]:
from sklearn.model_selection import GridSearchCV
Cs = [0.001, 0.01, 0.1, 1, 10]
gammas = [0.001, 0.01, 0.1, 1]
param_grid = [{'C': Cs, 'gamma' : gammas}]
#knn_clf = KNeighborsClassifier()
grid_search = GridSearchCV(svm_clf, param_grid, cv=10)
grid_search.fit(X_train, y_train)
Out[25]:
In [26]:
grid_search.best_params_
Out[26]:
In [27]:
grid_search.best_score_
Out[27]:
In [28]:
from sklearn.metrics import accuracy_score
y_pred_grid = grid_search.predict(X_test)
In [29]:
predictions = {'PassengerId' : test_set["PassengerId"],
'Survived': y_pred_grid}
In [30]:
final_df = pd.DataFrame(predictions, columns = ['PassengerId', 'Survived'])
In [31]:
final_df.head(10)
Out[31]:
In [32]:
final_df.to_csv('titanic_submission_svm.csv',index=False)