[TOC]

## 1. Data Analysis

First Import the Python Dependencies:

import matplotlib.pyplot as plt
%matplotlib inline
import random
import numpy as np
import pandas as pd
from sklearn import datasets, svm, cross_validation, tree, preprocessing, metrics
import sklearn.ensemble as ske
import tensorflow as tf
from tensorflow.contrib import skflow


Once we have read the spreadsheet file into a Pandas dataframe (imagine a hyperpowered Excel table), we can peek at the first five rows of data using the head() command.

titanic_df = pd.read_excel('titanic3.xls', 'titanic3', index_col=None, na_values=['NA'])


The column heading variables have the following meanings:

• survival: Survival (0 = no; 1 = yes)
• class: Passenger class (1 = first; 2 = second; 3 = third)
• name: Name
• sex: Sex
• age: Age
• sibsp: Number of siblings/spouses aboard
• parch: Number of parents/children aboard
• ticket: Ticket number
• fare: Passenger fare
• cabin: Cabin
• embarked: Port of embarkation (C = Cherbourg; Q = Queenstown; S = Southampton)
• boat: Lifeboat (if survived)
• body: Body number (if did not survive and body was recovered)

Then, examine the overall chance of survival for a Titanic passenger.

titanic_df['survived'].mean()


the output is 0.3819709702062643

Social classes were heavily stratified in the early twentieth century. This was especially true on the Titanic, where the luxurious first-class areas were completely off limits to the middle-class passengers in second class, and especially to those who carried a third class “economy price” ticket. To get a view into the composition of each class, we can group data by class, and view the averages for each column

titanic_df.groupby('pclass').mean()


the result qualifies my expectation, then extend the statistics to both sex and class:

class_sex_grouping = titanic_df.groupby(['pclass','sex']).mean()
class_sex_grouping


class_sex_grouping['survived'].plot.bar()


The effectiveness of the second part of this “Women and children first” policy can be deduced by breaking down the survival rate by age.

group_by_age = pd.cut(titanic_df["age"], np.arange(0, 90, 10))
age_grouping = titanic_df.groupby(group_by_age).mean()
age_grouping['survived'].plot.bar()


Form the above statistics, we can see that there are some relations between Age, Class, so then I try to figure out how age, class and other attributes is related to Survived or Not:

plt.subplot2grid((2,3),(0,0))             # 在一张大图里分列几个小图
data_train.Survived.value_counts().plot(kind='bar')# plots a bar graph of those who surived vs those who did not.
plt.title(u"rescue information (1 as rescured)") # puts a title on our graph
plt.ylabel(u"people num")

plt.subplot2grid((2,3),(0,1))
data_train.Pclass.value_counts().plot(kind="bar")
plt.ylabel(u"people num")
plt.title(u"class distribution")

plt.subplot2grid((2,3),(0,2))
plt.scatter(data_train.Survived, data_train.Age)
plt.ylabel(u"age")                         # sets the y axis lable
plt.grid(b=True, which='major', axis='y') # formats the grid line style of our graphs
plt.title(u"age-rescued")

plt.subplot2grid((2,3),(1,0), colspan=2)
data_train.Age[data_train.Pclass == 1].plot(kind='kde')   # plots a kernel desnsity estimate of the subset of the 1st class passanges's age
data_train.Age[data_train.Pclass == 2].plot(kind='kde')
data_train.Age[data_train.Pclass == 3].plot(kind='kde')
plt.xlabel(u"Age")# plots an axis lable
plt.ylabel(u"Dense")
plt.title(u"class-Age")
plt.legend((u'First', u'Second',u'Third'),loc='best') # sets our legend for our graph.

plt.subplot2grid((2,3),(1,2))
data_train.Embarked.value_counts().plot(kind='bar')
plt.title(u"Dock Num")
plt.ylabel(u"People Num")
plt.show()


Then we see how the class to survive:

Survived_0 = data_train.Pclass[data_train.Survived == 0].value_counts()
Survived_1 = data_train.Pclass[data_train.Survived == 1].value_counts()
df=pd.DataFrame({u'Survived':Survived_1, u'Not-Survived':Survived_0})
df.plot(kind='bar', stacked=True)
plt.title(u"Class to survive")
plt.xlabel(u"Class")
plt.ylabel(u"Num")

plt.show()


then, harbour to survived:

Survived_0 = data_train.Embarked[data_train.Survived == 0].value_counts()
Survived_1 = data_train.Embarked[data_train.Survived == 1].value_counts()
df=pd.DataFrame({u'S':Survived_1, u'NS':Survived_0})
df.plot(kind='bar', stacked=True)
plt.title(u"Harbour-Survived")
plt.xlabel(u"Harbour")
plt.ylabel(u"Num")

plt.show()


then sex to survive:

Survived_m = data_train.Survived[data_train.Sex == 'male'].value_counts()
Survived_f = data_train.Survived[data_train.Sex == 'female'].value_counts()
df=pd.DataFrame({u'Male':Survived_m, u'Female':Survived_f})
df.plot(kind='bar', stacked=True)
plt.title(u"Sex-Survive")
plt.xlabel(u"sex")
plt.ylabel(u"num")
plt.show()


Last but not the least, the cabin to survival:

Survived_cabin = data_train.Survived[pd.notnull(data_train.Cabin)].value_counts()
Survived_nocabin = data_train.Survived[pd.isnull(data_train.Cabin)].value_counts()
df=pd.DataFrame({u'Yes':Survived_cabin, u'No':Survived_nocabin}).transpose()
df.plot(kind='bar', stacked=True)
plt.title(u"Cabin-Survival")
plt.xlabel(u"Cabin or Not")
plt.ylabel(u"Num")
plt.show()


Then, I fill the missing values using Random forest to simulize the missing value:

def set_missing_ages(df):

age_df = df[['Age','Fare', 'Parch', 'SibSp', 'Pclass']]

known_age = age_df[age_df.Age.notnull()].as_matrix()
unknown_age = age_df[age_df.Age.isnull()].as_matrix()

y = known_age[:, 0]

X = known_age[:, 1:]

rfr = RandomForestRegressor(random_state=0, n_estimators=2000, n_jobs=-1)
rfr.fit(X, y)

predictedAges = rfr.predict(unknown_age[:, 1::])

df.loc[ (df.Age.isnull()), 'Age' ] = predictedAges

return df, rfr

def set_Cabin_type(df):
df.loc[ (df.Cabin.notnull()), 'Cabin' ] = "Yes"
df.loc[ (df.Cabin.isnull()), 'Cabin' ] = "No"
return df

data_train, rfr = set_missing_ages(data_train)
data_train = set_Cabin_type(data_train)
data_train


The example output is:

Now, the problem is to transfer Non-Numerical values to Numerical, and regularize to unified range.

dummies_Cabin = pd.get_dummies(data_train['Cabin'], prefix= 'Cabin')
dummies_Embarked = pd.get_dummies(data_train['Embarked'], prefix= 'Embarked')
dummies_Sex = pd.get_dummies(data_train['Sex'], prefix= 'Sex')
dummies_Pclass = pd.get_dummies(data_train['Pclass'], prefix= 'Pclass')
df = pd.concat([data_train, dummies_Cabin, dummies_Embarked, dummies_Sex, dummies_Pclass], axis=1)
df.drop(['Pclass', 'Name', 'Sex', 'Ticket', 'Cabin', 'Embarked'], axis=1, inplace=True)


import sklearn.preprocessing as preprocessing
scaler = preprocessing.StandardScaler()
age_scale_param = scaler.fit(df['Age'])
df['Age_scaled'] = scaler.fit_transform(df['Age'], age_scale_param)
fare_scale_param = scaler.fit(df['Fare'])
df['Fare_scaled'] = scaler.fit_transform(df['Fare'], fare_scale_param)


## 2. Logististic Regression:

from sklearn import linear_model
train_df = df.filter(regex='Survived|Age_.*|SibSp|Parch|Fare_.*|Cabin_.*|Embarked_.*|Sex_.*|Pclass_.*')
train_np = train_df.as_matrix()

y = train_np[:, 0]

X = train_np[:, 1:]

clf = linear_model.LogisticRegression(C=1.0, penalty='l1', tol=1e-6)
clf.fit(X, y)


Then Train and See the result:

data_test = pd.read_csv("test.csv")
data_test.loc[ (data_test.Fare.isnull()), 'Fare' ] = 0

tmp_df = data_test[['Age','Fare', 'Parch', 'SibSp', 'Pclass']]
null_age = tmp_df[data_test.Age.isnull()].as_matrix()
X = null_age[:, 1:]
predictedAges = rfr.predict(X)
data_test.loc[ (data_test.Age.isnull()), 'Age' ] = predictedAges

data_test = set_Cabin_type(data_test)
dummies_Cabin = pd.get_dummies(data_test['Cabin'], prefix= 'Cabin')
dummies_Embarked = pd.get_dummies(data_test['Embarked'], prefix= 'Embarked')
dummies_Sex = pd.get_dummies(data_test['Sex'], prefix= 'Sex')
dummies_Pclass = pd.get_dummies(data_test['Pclass'], prefix= 'Pclass')

df_test = pd.concat([data_test, dummies_Cabin, dummies_Embarked, dummies_Sex, dummies_Pclass], axis=1)
df_test.drop(['Pclass', 'Name', 'Sex', 'Ticket', 'Cabin', 'Embarked'], axis=1, inplace=True)
df_test['Age_scaled'] = scaler.fit_transform(df_test['Age'], age_scale_param)
df_test['Fare_scaled'] = scaler.fit_transform(df_test['Fare'], fare_scale_param)

test = df_test.filter(regex='Age_.*|SibSp|Parch|Fare_.*|Cabin_.*|Embarked_.*|Sex_.*|Pclass_.*')
predictions = clf.predict(test)
result = pd.DataFrame({'PassengerId':data_test['PassengerId'].as_matrix(), 'Survived':predictions.astype(np.int32)})
result.to_csv("logistic_regression_predictions.csv", index=False)


## 3. Decision Tree

A decision tree examines one variable at a time, and splits into one of two branches based on the result of that value, at which point it does the same for the next variable.

The tree first splits by sex, and then by class, since it has learned during the training phase that these are the two most important features for determining survival.

### 3.1 To create this tree

we first initialize an instance of an untrained decision tree classifier. (Here we will set the maximum depth of the tree to 10). Next we “fit” this classifier to our training set, enabling it to learn about how different factors affect the survivability of a passenger. Now that the decision tree is ready, we can “score” it using our test data to determine how accurate it is.

clf_dt = tree.DecisionTreeClassifier(max_depth=10)

clf_dt.fit (X_train, y_train)
clf_dt.score (X_test, y_test)


the output is 0.78947368421052633 means that the model correctly predicted the survival of 77% of the test set. Not bad for our first model!

### 3.2 cross validator

The accuracy of the model could vary depending on which rows were selected for the training and test sets. We will get around this problem by using a shuffle validator.

shuffle_validator = cross_validation.ShuffleSplit(len(X), n_iter=20, test_size=0.2, random_state=0)
def test_classifier(clf):
scores = cross_validation.cross_val_score(clf, X, y, cv=shuffle_validator)
print("Accuracy: %0.4f (+/- %0.2f)" % (scores.mean(), scores.std()))

test_classifier(clf_dt)


the output accuracy is: Accuracy: 0.7742 (+/- 0.02)

The result shows that our decision tree classifier has an overall accuracy of 77.34%, although it can go up to 80% and down to 75% depending on the training/test split

Using scikit-learn, we can easily test other machine learning algorithms using the exact same syntax.

## 4. Neural Network

Data analysis is the same to the above, so , In this method, I use Keras on Tensorflow to implement the NN, and the accuracy come up to 84.83%.

The model I use is shown below:

• define the NN:

def dense_highway_nn(input_len, num_units, dropout=0.5):
input_x = Input(shape=(input_len,))
dense = Dense(num_units, init='normal', activation='relu')(input_x)
dropout = Dropout(dropout)(dense)
highway = Highway()(dropout)
output_y = Dense(1, activation='sigmoid')(highway)

model = Model(input=[input_x], output=[output_y])
model.compile(loss='binary_crossentropy',
metrics=['acc'])
return model

• define the Model

# Defining and fitting the NN model
nn_model = dense_highway_nn(scaled_x_train.shape[1], 1000, dropout=0.5)
nn_model.fit(scaled_x_train, y_train, validation_split=.2, shuffle=True,
nb_epoch=30, batch_size=32)

scores = nn_model.evaluate(scaled_x_test, y_test, verbose=0)
print("\n%s: %.2f%%" % ("Test Accuracy", scores[1] * 100))

train_scaled = scaler.fit_transform(train[columns])
test_scaled = scaler.transform(test[columns])
nn_model.fit(train_scaled, train['Survived'], nb_epoch=30, batch_size=32, verbose=0)

test_proba = nn_model.predict(scaled_test)
test_classes = np_utils.probas_to_classes(test_proba)

submission = pd.DataFrame({
"PassengerId": test["PassengerId"],
"Survived": test_classes
})
submission.to_csv("titanic_predict_highwaynn.csv", index=False)


The output is like below:

## 5. Result Conclusion

From the result, I gain more accuracy on the Nueral network than on the basic Logistic regression.

The “Random Forest” classification algorithm will create a multitude of (generally very poor) trees for the data set using different random subsets of the input variables, and will return whichever prediction was returned by the most trees. This helps to avoid “overfitting”, a problem that occurs when a model is so tightly fitted to arbitrary correlations in the training data that it performs poorly on test data.

Despite the increased power and lengthier runtime of these neural network models, you will notice that the accuracy is still about the same as what we achieved using more traditional tree-based methods. The main advantage of neural networks — unsupervised learning of unstructured data — doesn’t necessarily lend itself well to our Titanic dataset, so this is not too surprising.

I still, however, think that running the passenger data of a 104-year-old shipwreck through a cutting-edge deep neural network is pretty cool.