Kaggle 泰坦尼克

入门kaggle，开始机器学习应用之旅。

参看一些入门的博客，感觉pandas，sklearn需要熟练掌握，同时也学到了一些很有用的tricks，包括数据分析和机器学习的知识点。下面记录一些有趣的数据分析方法和一个自己撸的小程序。

1.Tricks

1) df.info():数据的特征属性，包括数据缺失情况和数据类型。

df.describe(): 数据中各个特征的数目，缺失值为NaN,以及数值型数据的一些分布情况，而类目型数据看不到。

缺失数据处理：缺失的样本占总数比例极高，则直接舍弃；缺失样本适中，若为非连续性特征则将NaN作为一个新类别加到类别特征中（0/1化），若为连续性特征可以将其离散化后把NaN作为新类别加入，或用平均值填充。

2）数据分析方法：将特征分为连续性数据：年龄、票价、亲人数目；类目数据：生存与否、性别、等级、港口；文本类数据：姓名、票名、客舱名

3）数据分析技巧（画图、求相关性）

• 画图

类目特征分布图&&特征与生存情况关联柱状图：

fig1 = plt.figure(figsize=(12,10))  # 设定大尺寸后使得图像标注不重叠
fig1.set(alpha=0.2)  # 设定图表颜色alpha参数

plt.subplot2grid((2,3),(0,0))             # 在一张大图里分列几个小图
data_train.Survived.value_counts().plot(kind='bar')# 柱状图
plt.title(u"获救情况 (1为获救)") # 标题
plt.ylabel(u"人数")

plt.subplot2grid((2,3),(0,1))
data_train.Pclass.value_counts().plot(kind="bar")
plt.ylabel(u"人数")
plt.title(u"乘客等级分布")

plt.subplot2grid((2,3),(0,2))
plt.scatter(data_train.Survived, data_train.Age)
plt.ylabel(u"年龄")                         # 设定纵坐标名称
plt.grid(b=True, which='major', axis='y')
plt.title(u"按年龄看获救分布 (1为获救)")

plt.subplot2grid((2,3),(1,0), colspan=2)
data_train.Age[data_train.Pclass == 1].plot(kind='kde')
data_train.Age[data_train.Pclass == 2].plot(kind='kde')
data_train.Age[data_train.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.

                   

以上为3种在一张画布实现多张图的画法：

ax1 = plt.subplot2grid((3,3), (0,0), colspan=3)
ax2 = plt.subplot2grid((3,3), (1,0), colspan=2)
ax3 = plt.subplot2grid((3,3), (1, 2), rowspan=2)
ax4 = plt.subplot2grid((3,3), (2, 0))
ax5 = plt.subplot2grid((3,3), (2, 1))
plt.suptitle("subplot2grid")  

                 

此外，还有两种方法等效：

f=plt.figure()
ax=fig.add_subplot(111)
ax.plot(x,y)

plt.figure()
plt.subplot(111)
plt.plot(x,y)

连续性特征分布可以用直方图hist来实现（见上图-年龄分布直方图）:

figure1 = plt.figure(figsize=(6,6))
value_age = train_data['Age']
value_age.hist(color='b', alpha=0.5)  # 年龄分布直方图
plt.xlabel(u'年龄')
plt.ylabel(u'人数')
plt.title(u'年龄分布直方图')

类目特征与生存关系柱状图（见上图-各乘客等级的获救情况）：

fig2 = plt.figure(figsize=(6,5))
fig2.set(alpha=0.2)
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_1, u'未获救':Survived_0})
df.plot(kind='bar', stacked=True)  # stacked=False时不重叠
plt.title(u"各乘客等级的获救情况")
plt.xlabel(u"乘客等级")
plt.ylabel(u"人数")
plt.show()

各属性与生存率进行关联：

eg:舱位和性别 与存活率的关系：利用pandas中的groupby函数

Pclass_Gender_grouped=dt_train_p.groupby(['Sex','Pclass'])  #按照性别和舱位分组聚合
PG_Survival_Rate=(Pclass_Gender_grouped.sum()/Pclass_Gender_grouped.count())['Survived']  #计算存活率  

x=np.array([1,2,3])
width=0.3
plt.bar(x-width,PG_Survival_Rate.female,width,color='r')
plt.bar(x,PG_Survival_Rate.male,width,color='b')
plt.title('Survival Rate by Gender and Pclass')
plt.xlabel('Pclass')
plt.ylabel('Survival Rate')
plt.xticks([1,2,3])
plt.yticks(np.arange(0.0, 1.1, 0.1))
plt.grid(True,linestyle='-',color='0.7')
plt.legend(['Female','Male'])
plt.show()  #画图  

可以看到，不管是几等舱位，都是女士的存活率远高于男士。

将连续性数据年龄分段后，画不同年龄段的分布以及存活率：

age_train_p=dt_train_p[~np.isnan(dt_train_p['Age'])]  #去除年龄数据中的NaN
ages=np.arange(0,85,5)  #0~85岁，每5岁一段（年龄最大80岁）
age_cut=pd.cut(age_train_p.Age,ages)
age_cut_grouped=age_train_p.groupby(age_cut)
age_Survival_Rate=(age_cut_grouped.sum()/age_cut_grouped.count())['Survived']  #计算每年龄段的存活率
age_count=age_cut_grouped.count()['Survived']  #计算每年龄段的总人数 

ax1=age_count.plot(kind='bar')
ax2=ax1.twinx()  #使两者共用X轴
ax2.plot(age_Survival_Rate.values,color='r')
ax1.set_xlabel('Age')
ax1.set_ylabel('Number')
ax2.set_ylabel('Survival Rate')
plt.title('Survival Rate by Age')
plt.grid(True,linestyle='-',color='0.7')
plt.show()   

可以看到年龄主要在15~50岁左右，65~80岁死亡率较高，后面80岁存活率高是因为只有1人。

• 相关性分析：

Parch、SibSp取值少，分布不均匀，不适合作为连续值来处理。可以将其分段化。这里分析一下Parch和SibSp与生存的关联性

from sklearn.feature_selection import chi2
print("Parch:", chi2(train_data.filter(["Parch"]), train_data['Survived']))
print("SibSp:", chi2(train_data.filter(["SibSp"]), train_data['Survived']))
# chi2（X，y）  X.shape(n_samples, n_features_in)   y.shape(n_samples,)
# 返回 chi2 和 pval，  chi2值描述了自变量与因变量之间的相关程度：chi2值越大，相关程度也越大，
# http://guoze.me/2015/09/07/chi-square/
# 可以看到Parch比SibSp的卡方校验取值大，p-value小，相关性更强。

4）数据预处理：

PassengerId 舍掉

Pclass为类目属性，3类。本身有序的，暂时不进行dummy coding

Name 为文本属性，舍掉，暂时不考虑

Sex为类目属性，2类。本身无序，进行dummy coding

Age为连续属性，确实较多可以用均值填充。幅度变化大。可以将其以5岁为step进行离散化或利用scaling将其归一化到[-1,1]之间

SibSp为连续属性，但比较离散，不适合按照连续值处理，暂时不用处理。或者可以按照其数量>3和<=3进行dummy coding

Parch为连续属性。但比较离散，不适合按照连续值处理，暂时不用处理。

Ticket为文本属性，舍掉，暂时不考虑

Fare为连续属性，幅度变化大，可以利用scaling将其归一化到[-1,1]之间

Cabin为类目属性，但缺失严重，可以按照是否缺失来0/1二值化，进行dummy coding

Embarked为类目属性，缺失值极少，先填充后进行dummy coding

综上，可用的数据特征有：Pclass，Sex，Age，SibSp，Parch，Fare，Cabin，Embarked

此外需注意的是，需对训练集和测试集的数据做同样的处理。

2.实例。

根据以上思路，一个小baseline诞生了：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from pandas import Series, DataFrame
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report
from learning_curve import *
from pylab import mpl
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
mpl.rcParams['font.sans-serif'] = ['SimHei']  #使得plt操作可以显示中文
from sklearn.feature_extraction import DictVectorizer

data_train = pd.read_csv('train.csv')
data_test = pd.read_csv('test.csv')

feature = ['Pclass','Age','Sex','Fare','Cabin','Embarked','SibSp','Parch']  # 考虑的特征

X_train = data_train[feature]
y_train = data_train['Survived']

X_test = data_test[feature]

X_train.loc[data_train['SibSp']<3, 'SibSp'] = 1   #按照人数3来划分
X_train.loc[data_train['SibSp']>=3, 'SibSp'] = 0
X_train['Age'].fillna(X_train['Age'].mean(), inplace=True)
X_test.loc[data_test['SibSp']<3, 'SibSp']=1
X_test.loc[data_test['SibSp']>=3, 'SibSp'] = 0
X_test['Age'].fillna(X_test['Age'].mean(), inplace=True)  # 缺失的年龄补以均值
X_test['Fare'].fillna(X_test['Fare'].mean(), inplace=True)
# X_train.loc[X_train['Age'].isnull(), 'Age'] = X_train['Age'].mean()

dummies_SibSp = pd.get_dummies(X_train['SibSp'], prefix='SibSp')  #进行dummy coding
dummies_Sex = pd.get_dummies(X_train['Sex'], prefix= 'Sex')
dummies_Pclass = pd.get_dummies(X_train['Pclass'], prefix='Pclass')
dummies_Emabrked = pd.get_dummies(X_train['Embarked'], prefix='Embarked')

ss=StandardScaler()

X_train.loc[X_train['Cabin'].isnull(), 'Cabin'] = 1
X_train.loc[X_train['Cabin'].notnull(), 'Cabin'] = 0
X_train['Age_new'] = (X_train['Age']/5).astype(int)
X_train['Fare_new'] = ss.fit_transform(X_train.filter(['Fare']))
X_train = pd.concat([X_train, dummies_Sex, dummies_Pclass, dummies_Emabrked, dummies_SibSp], axis=1)
X_train.drop(['Age', 'Sex', 'Pclass', 'Fare','Embarked', 'SibSp'], axis=1, inplace=True)

dummies_SibSp = pd.get_dummies(X_test['SibSp'], prefix='SibSp')
dummies_Sex = pd.get_dummies(X_test['Sex'], prefix= 'Sex')
dummies_Pclass = pd.get_dummies(X_test['Pclass'], prefix='Pclass')
dummies_Emabrked = pd.get_dummies(X_test['Embarked'], prefix='Embarked')

X_test['Age_new'] = (X_test['Age']/5).astype('int')
X_test['Fare_new'] = ss.fit_transform(X_test.filter(['Fare']))
X_test = pd.concat([X_test, dummies_Sex, dummies_Pclass, dummies_Emabrked, dummies_SibSp], axis=1)
X_test.drop(['Age', 'Sex', 'Pclass', 'Fare','Embarked','SibSp'], axis=1, inplace=True)
X_test.loc[X_test['Cabin'].isnull(), 'Cabin'] = 1
X_test.loc[X_test['Cabin'].notnull(), 'Cabin'] = 0

dec = LogisticRegression()  # logistic回归
dec.fit(X_train, y_train)
y_pre = dec.predict(X_test)

# 交叉验证
all_data = X_train.filter(regex='Cabin|Age_.*|Fare_.*|Sex.*|Pclass_.*|Embarked_.*|SibSp_.*_Parch')
X_cro = all_data.as_matrix()
y_cro = y_train.as_matrix()
est = LogisticRegression(C=1.0, penalty='l1', tol=1e-6)
print(cross_val_score(dec, X_cro, y_cro, cv=5))

# 保存结果
# result = pd.DataFrame({'PassengerId':data_test['PassengerId'].as_matrix(), 'Survived':y_pre.astype(np.int32)})
# result.to_csv("my_logisticregression_1.csv", index=False)

# 学习曲线
plot_learning_curve(dec, u"学习曲线", X_train, y_train)

# 查看各个特征的相关性
columns = list(X_train.columns)
plt.figure(figsize=(8,8))
plot_df = pd.DataFrame(dec.coef_.ravel(), index=columns)
plot_df.plot(kind='bar')
plt.show()

# 分析SibSp
# survived_0 = data_train.SibSp[data_train['Survived']==0].value_counts()
# survived_1 = data_train.SibSp[data_train['Survived']==1].value_counts()
# df = pd.DataFrame({'获救':survived_1, '未获救':survived_0})
# df.plot(kind='bar', stacked=True)
# plt.xlabel('兄妹个数')
# plt.ylabel('获救情况')
# plt.title('兄妹个数与获救情况')

# 不加SibSp [ 0.70  0.80446927  0.78651685  0.76966292  0.79661017]
# 加上SibSp [ 0.70  0.78212291  0.80337079  0.79775281  0.81355932]

# logistic:[ 0.78212291  0.80446927  0.78651685  0.76966292  0.80225989] why?

3.结果分析与总结

1）学习曲线函数：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import learning_curve

# 用sklearn的learning_curve得到training_score和cv_score，使用matplotlib画出learning curve
def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None, n_jobs=1,
                        train_sizes=np.linspace(.05, 1., 20), verbose=0, plot=True):
    """
    画出data在某模型上的learning curve.
    参数解释
    ----------
    estimator : 你用的分类器。
    title : 表格的标题。
    X : 输入的feature，numpy类型
    y : 输入的target vector
    ylim : tuple格式的(ymin, ymax), 设定图像中纵坐标的最低点和最高点
    cv : 做cross-validation的时候，数据分成的份数，其中一份作为cv集，其余n-1份作为training(默认为3份)
    n_jobs : 并行的的任务数(默认1)
    """
    train_sizes, train_scores, test_scores = learning_curve(
        estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes, verbose=verbose)

    train_scores_mean = np.mean(train_scores, axis=1)
    train_scores_std = np.std(train_scores, axis=1)
    test_scores_mean = np.mean(test_scores, axis=1)
    test_scores_std = np.std(test_scores, axis=1)

    if plot:
        plt.figure(1)
        plt.title(title)
        if ylim is not None:
            plt.ylim(*ylim)
        plt.xlabel(u"训练样本数")
        plt.ylabel(u"得分")
        plt.gca().invert_yaxis()
        plt.grid()

        plt.fill_between(train_sizes, train_scores_mean - train_scores_std, train_scores_mean + train_scores_std,
                         alpha=0.1, color="b")
        plt.fill_between(train_sizes, test_scores_mean - test_scores_std, test_scores_mean + test_scores_std,
                         alpha=0.1, color="r")
        plt.plot(train_sizes, train_scores_mean, 'o-', color="b", label=u"训练集上得分")
        plt.plot(train_sizes, test_scores_mean, 'o-', color="r", label=u"交叉验证集上得分")

        plt.legend(loc="best")

        plt.draw()
        plt.show()
        plt.gca().invert_yaxis()

    midpoint = ((train_scores_mean[-1] + train_scores_std[-1]) + (test_scores_mean[-1] - test_scores_std[-1])) / 2
    diff = (train_scores_mean[-1] + train_scores_std[-1]) - (test_scores_mean[-1] - test_scores_std[-1])
    return midpoint, diff

learning_curve.py

见下图：将learning_curve画出可以看到两者在0.8左右趋于平行，但是正确率不够高，应该是属于欠拟合。所以可以考虑加入新的特征，再对特征进行更深的挖掘 。

2）特征相关性分析图

columns = list(X_train.columns)
plt.figure(figsize=(8,8))
plot_df = pd.DataFrame(dec.coef_.ravel(), index=columns)
plot_df.plot(kind='bar')
plt.show()

结果见下图：通过logistic学到的参数权重

性别、等级和亲属相关性较强，而亲属在前面已经了解到相关性并不强，所以可以对这一特征加以优化，例如将Parch+SibSp作为一个新特征。

其他特征或正相关或负相关，但都不太明显。

cabin怎么没有相关性呢？

3）交叉验证

# 交叉验证
all_data = X_train.filter(regex='Cabin|Age_.*|Fare_.*|Sex.*|Pclass_.*|Embarked_.*|SibSp_.*_Parch')
X_cro = all_data.as_matrix()
y_cro = y_train.as_matrix()
est = LogisticRegression(C=1.0, penalty='l1', tol=1e-6)
print(cross_val_score(dec, X_cro, y_cro, cv=5))

每次通过训练集学习到参数后进行分类，但是怎么评价结果的好坏呢，可以利用交叉验证来实现，根据交叉验证的结果大致可以知道运用于测试集的结果。

这是本次测试的交叉验证结果：  [ 0.78212291 0.80446927 0.78651685 0.76966292 0.80225989]

实际提交到Kaggle上时候准确率为0.7751

参考：

机器学习系列(3)_逻辑回归应用之Kaggle泰坦尼克之灾

机器学习笔记(1)-分析框架-以Kaggle Titanic问题为例

机器学习一小步：Kaggle上的练习Titanic: Machine Learning from Disaster（一）