kaggle竞赛——Titanic：Machine Learning from Disaster

题目地址：https://www.kaggle.com/c/titanic
根据所提供的乘客信息，判断该乘客Survived or not？
Introduction
机器学习这块停了整整三个月，主要原因是一方面课题需要推进尤其是修改论文，进度特别慢，终于知道为啥修改论文要至少三个月了！另一方面，学习了数据结构与算法方面的内容，目的是提高自己编程能力，之前从未想过手编梯度下降、逻辑回归、BP等算法，现在基本上都可以尝试编写(虽然有点麻烦)。说一嘴，笔试和面试都比较看重编程能力，所以还是建议有事没事刷刷题，编编程，防止手生！闲话少说，这次主要总结第一次做kaggle题的思路，尤其是如何写Baseline，如何优化！(使用Jupyter
Notebook讲解更好)其中主要参考了七月在线中寒老师的讲解内容，受益匪浅！再次强调，这次内容非常简单，是最基本的数据挖掘过程，kaggle——>kernels里有各种大牛，可以参考他们进一步学习，当然，前提是知道要学他们什么地方？如何数据清洗？如何做特征工程？如何画图？用什么模型？如何做模型选择等等，有目的的看才有效果！好了，废话不多少，开始Baseline的累码！
method
1、载入基本包
import numpy as np
import pandas as pd
import math
importmatplotlib.pyplot as plt
2、导入并查看数据
df_origin =pd.read_csv('train.csv')
defread_data(df):  

    print(df.head(10))
    print(df.describe())
    print(df.info())
    cols = df.columns
    print(cols)
    for c in cols:
        print (c, df[c].unique())
read_data(df_origin)
3、画图，看看每个/多个 属性和最后的Survived之间有着什么样的关系
 
fig = plt.figure()
fig.set(alpha = 0.8)
plt.rcParams['font.sans-serif']= ['SimHei'] #指定默认字体 

plt.rcParams['axes.unicode_minus']= False

#解决保存图像是负号'-'显示为方块的问题 

'''
**************查看Survived分布****************
'''
plt.subplot(331)
plt.subplots_adjust(wspace=0.4,hspace=0.4)
df_origin.Survived.value_counts().plot(kind= 'bar')
plt.title(u'获救情况 (1为获救)') #puts a title on our graph
plt.ylabel(u'人数')

'''
**************查看乘客等级分布****************
'''
plt.subplot(332)
df_origin.Pclass.value_counts().plot(kind= 'bar')
plt.title(u'乘客登机分布') # puts a title on our graph
plt.ylabel(u'人数')

'''
**************按年龄看获救分布****************
'''
plt.subplot(333)
plt.scatter(df_origin.Survived,df_origin.Age)
plt.title(u'乘客登机分布') # puts a title on our graph
plt.ylabel(u'人数')
'''
**************各等级的乘客年龄分布****************
'''
plt.subplot2grid((3,3),(1,0),colspan=2)
df_origin.Age[df_origin.Pclass== 1].plot(kind = 'kde')
df_origin.Age[df_origin.Pclass== 2].plot(kind = 'kde')
df_origin.Age[df_origin.Pclass== 3].plot(kind = 'kde')
plt.xlabel(u"年龄")# plots an axis lable
plt.ylabel(u"密度")

plt.title(u"各等级的乘客年龄分布")
plt.legend((u'头等舱', u'2等舱',u'3等舱'),loc='best') # sets our legend for our graph.
'''
**************各登船口岸人数分布****************
'''
plt.subplot(336)
df_origin.Embarked.value_counts().plot(kind='bar')
plt.title(u"各登船口岸上船人数")
plt.ylabel(u"人数")  

'''
**************性别分布****************
'''
plt.subplot(337)
df_origin.Sex.value_counts().plot(kind='bar')
plt.title(u"不同性别人数")
plt.ylabel(u"人数")  

'''
**************SibSp个数****************
'''
plt.subplot(338)
df_origin.SibSp.value_counts().plot(kind='bar')
plt.title(u"各登船口岸上船人数")
plt.ylabel(u"人数")  

'''
**************Parch个数****************
'''
plt.subplot(339)
df_origin.Parch.value_counts().plot(kind='bar')
plt.title(u"Parch人数")
plt.ylabel(u"人数")  

plt.show()
'''
**************看看各属性与最后的获救情况的关系****************
'''
#看看各乘客等级的获救情况
fig = plt.figure()
fig.set(alpha=0.2)  # 设定图表颜色alpha参数
plt.rcParams['font.sans-serif']= ['SimHei'] #指定默认字体 

plt.rcParams['axes.unicode_minus']= False #解决保存图像是负号'-'显示为方块的问题
#看看各登船口岸的获救情况
Survived_1 =df_origin.Pclass[df_origin.Survived ==1].value_counts()
Survived_0 =df_origin.Pclass[df_origin.Survived ==0].value_counts()
pd.DataFrame({u"获救":Survived_1,u"未获救":Survived_0}).plot(kind = 'bar')
plt.title(u"各乘客等级的获救情况")
plt.xlabel(u"乘客等级")

plt.ylabel(u"人数")

#看看各乘客等级的获救情况
Survived_1 =df_origin.Embarked[df_origin.Survived ==1].value_counts()
Survived_0 =df_origin.Embarked[df_origin.Survived ==0].value_counts()
df =pd.DataFrame({u"获救":Survived_1,u"未获救":Survived_0})
df.plot(kind = 'bar')
plt.title(u"各登录港口乘客的获救情况")
plt.xlabel(u"登录港口")

plt.ylabel(u"人数")

#看看不同性别的获救情况
Survived_1 =df_origin.Sex[df_origin.Survived ==1].value_counts()
Survived_0 =df_origin.Sex[df_origin.Survived ==0].value_counts()
df =pd.DataFrame({u"获救":Survived_1,u"未获救":Survived_0})
df.plot(kind = 'bar')
plt.title(u"不同性别的获救情况")
plt.xlabel(u"性别")

plt.ylabel(u"人数")

#看看兄弟姐妹个数与的获救情况的关系
Survived_1 =df_origin.SibSp[df_origin.Survived ==1].value_counts()
Survived_0 =df_origin.SibSp[df_origin.Survived ==0].value_counts()
df =pd.DataFrame({u"获救":Survived_1,u"未获救":Survived_0})
df.plot(kind = 'bar')
plt.title(u"不同SibSp的获救情况")
plt.xlabel(u"SibSp")
plt.ylabel(u"人数")

# #看看父母个数与的获救情况的关系
Survived_1 =df_origin.Parch[df_origin.Survived ==1].value_counts()
Survived_0 =df_origin.Parch[df_origin.Survived ==0].value_counts()
df =pd.DataFrame({u"获救":Survived_1,u"未获救":Survived_0})
df.plot(kind = 'bar')
plt.title(u"不同Parch的获救情况")
plt.xlabel(u"Parch")
plt.ylabel(u"人数")

plt.show()

4、经过上述分析，女性，高级舱可能获救概率更大，是不是这样？做个组合看一看。
'''
 ***********对特征进行组合再与最后的获救情况的关系****************
可视化版
'''
#看看舱等级和性别的获救情况
fig =plt.figure()fig.set(alpha = 0.2)#显示图的背景灰度颜色plt.title(u"根据舱等级和性别的获救情况")
plt.subplot(141)
df_origin.Survived[df_origin.Pclass!= 3][df_origin.Sex == 'female'].value_counts().plot(kind = 'bar',label="female highclass", color='#FA2479')
plt.xlabel([u'获救',u'未获救'],rotation = 0)

plt.legend(['女性/高级舱'],loc='best')
plt.subplot(142)
df_origin.Survived[df_origin.Pclass== 3][df_origin.Sex == 'female'].value_counts().plot(kind = 'bar',label="female lowclass", color='pink')plt.xlabel([u'获救',u'未获救'],rotation =
0) plt.legend(['女性/低级舱'], loc='best')
plt.subplot(143)
df_origin.Survived[df_origin.Pclass!= 3][df_origin.Sex == 'male'].value_counts().plot(kind = 'bar',label="male highclass", color='lightblue')
plt.xlabel([u'未获救',u'获救'],rotation = 0)
 plt.legend(['男性/高级舱'], loc='best')
plt.subplot(144)
df_origin.Survived[df_origin.Pclass== 3][df_origin.Sex == 'male'].value_counts().plot(kind = 'bar',label="male lowclass", color='steelblue')
plt.xlabel([u'未获救',u'获救'],rotation = 0)
 plt.legend(['男性/低级舱'], loc='best')
plt.show()
'''
********对特征进行组合再与最后的获救情况的关系*******
groupby版
'''
g =df_origin.groupby(['SibSp', 'Survived'])df =pd.DataFrame(g.count['PassengerId'])
print(df)
5、对特殊特征进行处理含有缺失值的量：Cabin，Age
对类目型，缺失较多的Cabin处理由于缺失较多，采用有无缺失值办法分类
df_origin.loc[(df_origin.Cabin.isnull()),'Cabin']= 'No'
df_origin.loc[(df_origin.Cabin.notnull()),'Cabin']= 'Yes'
Age为连续值，且缺失值较少，考虑拟合补全或者离散化，对不同年龄段加权重(考虑老人和孩子获救的可能性大)

这里先采用拟合方法
from sklearn.ensembleimport RandomForestRegressor
age_df =df_origin[['Age', 'Fare','Pclass', 'SibSp', 'Parch','Survived']]
Know_age =age_df[age_df.Age.notnull()].as_matrix()
unKnow_age =age_df[age_df.Age.isnull()].as_matrix()
y = Know_age[:,0]
X = Know_age[:,1:]
rfr =RandomForestRegressor(random_state=0, n_estimators = 2000, n_jobs = -1)
rfr.fit(X, y)
predictAge =rfr.predict(unKnow_age[:,1::])
df_origin.loc[(df_origin.Age.isnull()),'Age'] = predictAge
6、对类别型特征进行处理
类别型转化成数值型

方法：离散化，因子化，one-hot编码，哑变量，pd.getdummies

以Embarked为例，原本一个属性维度，因为其取值可以是[‘S’,’C’,’Q‘]，而将其平展开为’Embarked_C’,’Embarked_S’, ‘Embarked_Q’三个属性

原本Embarked取值为S的，在此处的”Embarked_S”下取值为1，在’Embarked_C’, ‘Embarked_Q’下取值为0

原本Embarked取值为C的，在此处的”Embarked_C”下取值为1，在’Embarked_S’, ‘Embarked_Q’下取值为0

原本Embarked取值为Q的，在此处的”Embarked_Q”下取值为1，在’Embarked_C’, ‘Embarked_S’下取值为0
dummies_Cabin =pd.get_dummies(df_origin['Cabin'], prefix= 'Cabin')
dummies_Embarked =pd.get_dummies(df_origin['Embarked'], prefix= 'Embarked')
dummies_Sex =pd.get_dummies(df_origin['Sex'], prefix= 'Sex')
dummies_Pclass =pd.get_dummies(df_origin['Pclass'], prefix= 'Pclass')
#将编码后的值添加到原df中，并去除原变量
df_origin.drop(['Cabin','Name','Embarked',  'Ticket','Sex','Pclass'], axis=1)
df =pd.concat([df_origin,dummies_Cabin,dummies_Embarked,dummies_Sex,dummies_Pclass],axis = 1)
7、对数值型特征进行处理

数值幅度偏差太大，各属性值之间scale差距太大，将对收敛速度造成几万点伤害值！甚至不收敛！

做一个scaling，所谓scaling，其实就是将一些变化幅度较大的特征化到[-1,1]之内。

方法：sklearn.preprocessing
fromsklearn.preprocessing import StandardScaler
df['Age_Scaled'] =StandardScaler().fit_transform(df['Age'])
df['Fare_Scaled'] =StandardScaler().fit_transform(df['Fare'])
8、构造新的训练集包含label和feature，以Matrix形式，开始寻找学习算法训练模型，这里采用逻辑回归
from sklearn importlinear_model
train_df =df.filter(regex ='PassengerId|Survived|Age_.*|SibSp|Parch|Fare_.*|Cabin_.*|Embarked_.*|Sex_.*|Pclass_.*')
train_np =train_df.as_matrix()
train_df.to_csv('train_feature_1.csv',index = False)
#设定输入输出矩阵，X，y
y = train_np[:,1]
X = train_np[:,2:]
lm =linear_model.LogisticRegression(C = 1.0, penalty='l1', tol = 1e-6)
lm.fit(X,y)
9、同样在测试集中进行相同操作，获取同类型特征
data_test =pd.read_csv("test.csv")
data_test.loc[(data_test.Fare.isnull()), 'Fare' ] = np.mean(data_test.Fare.notnull())
# 接着我们对test_data做和train_data中一致的特征变换
# 首先用同样的RandomForestRegressor模型填上丢失的年龄
tmp_df =data_test[['Age','Fare', 'Parch', 'SibSp', 'Pclass']]
null_age =tmp_df[data_test.Age.isnull()].as_matrix()
notnull_age =tmp_df[data_test.Age.notnull()].as_matrix()
y = notnull_age[:,0]
X = notnull_age[:,1:]
rfr =RandomForestRegressor(random_state=0, n_estimators = 2000, n_jobs = -1)
rfr.fit(X, y)
X = null_age[:, 1:]
predictedAges =rfr.predict(X)
# 根据特征属性X预测年龄并补上
data_test.loc[(data_test.Age.isnull()), 'Age' ] = predictedAges
 
data_test.loc[(data_test.Cabin.isnull()),'Cabin']= 'No'
data_test.loc[(data_test.Cabin.notnull()),'Cabin']= 'Yes'
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']= StandardScaler().fit_transform(df_test['Age'])
df_test['Fare_Scaled']= StandardScaler().fit_transform(df_test['Fare'])
test =df_test.filter(regex='PassengerId|Age_.*|SibSp|Parch|Fare_.*|Cabin_.*|Embarked_.*|Sex_.*|Pclass_.*')
test.to_csv('test_feature_1.csv',index = False)
***********************至此，前期工作完成，下面开始特征层面的工作**********************

1、模型建立的好不好怎么判断？
交叉验证！交叉验证！交叉验证！。。。
train_data =pd.read_csv('train_feature_1.csv')
train_data.head(10)
train_data.describe()
train_data =train_data.as_matrix()
y = train_data[:,1]#因为train_data,第二列才是survived
X = train_data[:,2:]
C = 1.0
'''
交叉验证,即验证阶段，而不是优化阶段
model_selection
Cross-validation:evaluating estimator performance
'''
fromsklearn.model_selection import KFold
fromsklearn.model_selection import cross_val_score
kf =KFold(n_splits=5)
scores =cross_val_score(lr, X, y, scoring='f1', cv=kf)
# Take the mean ofthe scores (because we have one for each fold)
#验证集上的得分
print(scores.mean())
这里能知道在验证集上准确率是多少？

2、但模型到底如何，欠拟合还是过拟合？利用学习曲线看看！！！
著名的learning curve可以帮我们判定我们的模型现在所处的状态。

我们以样本数为横坐标，训练和交叉验证集上的错误率作为纵坐标
欠拟合Underfit           高偏差High bias
正常拟合Just right      偏差和方差均较小
过拟合Overfit              高方差High variance
overfitting的表现一般是训练集上得分高，而交叉验证集上要低很多，中间的gap比较大。

如果没有overfitting，再做些feature engineering的工作，添加一些新产出的特征或者组合特征到模型中。
(这里讲究很多，会专门介绍如何评价模型好坏？)
fromsklearn.model_selection import learning_curve
train_sizes_abs,train_scores, test_scores = learning_curve(lr, X, y, groups=None,train_sizes=np.linspace(.01, 1., 100),cv = kf)
train_scores_mean =np.mean(train_scores, axis=1)
test_scores_mean =np.mean(test_scores, axis=1)
train_scores_std =np.std(train_scores, axis=1)
test_scores_std =np.std(test_scores, axis=1) 

title = '学习曲线'
 
plt.figure()
plt.rcParams['font.sans-serif']= ['SimHei'] #指定默认字体 

plt.rcParams['axes.unicode_minus']= False #解决保存图像是负号'-'显示为方块的问题
plt.grid()
plt.plot(train_sizes_abs,train_scores_mean,color="b", label=u"训练集上得分")
plt.plot(train_sizes_abs,test_scores_mean,color="r", label=u"交叉验证集上得分")
plt.fill_between(train_sizes_abs,train_scores_mean-train_scores_std,train_scores_mean+train_scores_std,alpha=0.1,color="r")
plt.fill_between(train_sizes_abs,test_scores_mean-test_scores_std,test_scores_mean+test_scores_std,alpha=0.1,color="b")
plt.xlabel(u"训练样本数")
plt.ylabel(u"得分")
plt.title(title)
plt.show()
3、很明显underfitting了，因此需要对Baseline进行优化！
但是对哪些属性优化？如何进行优化？方法是交叉验证(得到可靠稳定的模型)
先得到的模型的系数(coef_)，因为系数和它们最终的判定能力强弱是正相关的
print(pd.DataFrame({'coef':list(lr.coef_.T),'columns':list(train_data[1:].columns)}))
对训练数据分割，看测试集上的预测结果，查看badcase，对比bad case，我们仔细看看我们预测错的样本，到底是哪些特征有问题，咱们处理得还不够细？
# 分割数据
origin_data_train =pd.read_csv('train_feature_1.csv')
fromsklearn.model_selection import train_test_split
train_cv,test_cv =train_test_split(origin_data_train)
# 生成模型
train_df =train_cv.filter(regex='Survived|Age_.*|SibSp|Parch|Fare_.*|Cabin_.*|Embarked_.*|Sex_.*|Pclass_.*')
clf =linear_model.LogisticRegression(C=1.0, penalty='l1', tol=1e-6)
clf.fit(train_df.as_matrix()[:,1:],train_df.as_matrix()[:,0])
# 对cross validation数据进行预测
cv_df =test_cv.filter(regex='Survived|Age_.*|SibSp|Parch|Fare_.*|Cabin_.*|Embarked_.*|Sex_.*|Pclass_.*')
predictions =clf.predict(cv_df.as_matrix()[:,1:])
# 去除预测错误的case看原始dataframe数据
train_data =pd.read_csv('train_feature_1.csv')
bad_cases = train_data.loc[train_data['PassengerId'].isin(test_cv[predictions!=test_cv.as_matrix()[:0]]['PassengerId'].values)]
print(bad_cases)
********************************************至此，优化前的工作全部完成*********************************************
下面可以尝试其他学习算法，当然，在Baseline最好先用LR，之后再用模型融合算法，xgboost，GBDT等等
'''
各种算法尝试与比较
'''
#逻辑回归
from sklearn importlinear_model, model_selection
lr =linear_model.LogisticRegression(penalty='l2',tol=0.0001, C=C)
lr.fit(X,y)
 
#支持向量机
from sklearn.svmimport SVC
rbf_svc = SVC(C=C,kernel='rbf', degree=3)
rbf_svc.fit(X,y)
#神经网络
fromsklearn.neural_network import MLPClassifier
nn =MLPClassifier(hidden_layer_sizes=(100,100, ), activation='relu', solver='adam',alpha=0.0001, batch_size='auto', learning_rate='constant',learning_rate_init=0.001, power_t=0.5,
max_iter=400,  tol=0.0001)
nn.fit(X,y)
'''
xgboost:模型融合与优化
'''
 
'''
sklearn.ensemble:模型融合与优化
'''
#Random Forest
from sklearn.ensembleimport RandomForestClassifier
rf =RandomForestClassifier(n_estimators=10, max_depth=9, min_samples_split=6,min_samples_leaf=4)
rf.fit(X,y)
#Bagging
from sklearn.ensembleimport BaggingClassifier
clf = SVC(C=C,kernel='rbf', degree=3)
bagging_clf =BaggingClassifier(clf, n_estimators=20, max_samples=0.8, max_features=1.0,bootstrap=True, bootstrap_features=False)
bagging_clf.fit(X, y)
#AdaBoost
from sklearn.ensembleimport AdaBoostClassifier
adb =AdaBoostClassifier()
adb.fit(X,y)
#VotingClassifier
from sklearn.ensembleimport VotingClassifier
vc =VotingClassifier(estimators =[('lr', lr), ('rf', rf), ('adb', adb)],voting='soft', weights=None, n_jobs=1)
vc.fit(X,y)
比较以上算法在Baseline后，SVC效果更好点，在leaderboard中3000多名，哈哈，自嘲一下，很明显需要优化了！

总结图如下：之后会丰富