kaggle磨炼:titanic之灾

这几天体验了下kaggle，感觉和CTF类似的地方就是经常做的都是无用功。记录一下对泰坦尼克这个题的瞎折腾。
题目就是根据已有的信息预测这个人是否能生还。首先导入库和数据,观察下样本的情况

1
2
3
4
5
6
7
8
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from pylab import mpl
data_train = pd.read_csv('train.csv')
data_test = pd.read_csv('test.csv')
data = pd.concat([data_train,data_test],sort='False',ignore_index=False)
data.info()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<class 'pandas.core.frame.DataFrame'>
Int64Index: 1309 entries, 0 to 417
Data columns (total 12 columns):
Age            1046 non-null float64
Cabin          295 non-null object
Embarked       1307 non-null object
Fare           1308 non-null float64
Name           1309 non-null object
Parch          1309 non-null int64
PassengerId    1309 non-null int64
Pclass         1309 non-null int64
Sex            1309 non-null object
SibSp          1309 non-null int64
Survived       891 non-null float64
Ticket         1309 non-null object
dtypes: float64(3), int64(4), object(5)
memory usage: 132.9+ KB

可以看到age字段缺失了比较多，fare和embarked(登船地点)缺了几个，cabin(舱号)缺了非常多。感觉少的可以用众数中位数之类的补齐，年龄可以用其他特征拟合，至于缺了三分之二的舱号还是换个方法用吧。
之后可以先计算下各个特征的IV值，看一下哪些对结果影响比较大

1
2
3
4
5
6
7
8
9
10
11
12
13
train <- read_csv('train.csv')

all_iv <- data.frame(vars=colnames(train),
                     iv=numeric(length(colnames(train))),
                     strength=character(length(colnames(train))),
                     stringsAsFactors = F)

for (i in colnames(train)){
     all_iv[all_iv$vars==i,]$iv <- IV(X=factor(train[[i]]), Y=train$Survived)
     all_iv[all_iv$vars==i,]$strength <- attr(IV(X=factor(train[[i]]), Y=train$Survived),"howgood")
     }

(all_iv<-all_iv[order(-all_iv$iv),] )

看到影响最大的是性别，很好理解，第二个因素是船票的价格emmm，有钱真好。还有就是Pclass也就是几号舱，年龄也有很大影响，小孩应该会先走，其他影响都不大。
直观的观察下各个特征与生存情况的关系，先定义一个画图的函数：

1
2
3
4
5
6
7
8
9
10
11
12
mpl.rcParams['font.sans-serif'] = ['SimHei']//显示中文
def survivedFactorPlot(data_train,col,k='bar'):
    Survived_0 = data_train[col][data_train.Survived == 0].value_counts()
    Survived_1 = data_train[col][data_train.Survived == 1].value_counts()
    df=pd.DataFrame({u'未获救':Survived_0,u'获救':Survived_1})
    df.plot(kind=k)
    plt.title(f"各{col}幸存人数")
    plt.xlabel(col) 
    plt.ylabel(u"人数") 
    plt.show()
survivedFactorPlot(data_train,'Sex')
survivedFactorPlot(data_train,'Pclass')

看下性别的影响，女性生还率特别高

然后是一号舱也是正相关

c港口登船的活下来的多一些

不过对于ticket和name两个字段也可以废物处理一下，虽然基本是没有规律的，但也有有规律的部分，比如名字中间的称呼可以提取出来，而ticket可以用来看看有没有用同一张联票的，这些人可能会在一起。

大致把称呼分成五个类，有些类别人数很少生还率差不多的就合并了

然后观察联票对生还率的影响，明显有联票的高一些，无依无靠还是很危险的

至于cabin字段，因为是否有记录本身也反映了一定信息，可能人死了就不知道具体船舱了。所以把无记录定义为一类，其他类根据第一个字母来划分。

可以看到有记录的里面大部分还是活下来的多。
还有两个字段关于子女数兄弟数的，看了下趋势是相同的，合并成一个family字段，总体就是适中的生还率高，太少或者太多都有不利影响。

最后拟合年龄，选择用随机森林，当时想的是这个比较复杂，可能效果会比较好，其实也未必。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
from sklearn.ensemble import RandomForestRegressor

def set_missing_ages(df,cols):
    # 把已有的数值型特征取出来丢进Random Forest Regressor中
    age_df = df[cols]

    # 乘客分成已知年龄和未知年龄两部分
    known_age = age_df[age_df.Age.notnull()].as_matrix()
    unknown_age = age_df[age_df.Age.isnull()].as_matrix()

    # y即目标年龄
    y = known_age[:, 0]

    # X即特征属性值
    X = known_age[:, 1:]

    # fit到RandomForestRegressor之中
    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

然后fare和embarked的缺失值用中位数众数之类的填一下就行，缺的不是太多。这样特征基本就处理好了，下一步就是选择用什么模型。
因为是一个二分类问题，决定比较朴实的选择用逻辑回归做。那么对分类特征进行one-hot编码方便回归运算。然后把连续数值标准化，避免不收敛。标准化的时候应该把训练集和测试集分开，不然会有信息泄露。编码和标准化都有现成的方法，很简单。
直接逻辑回归算一下训练集准确率，看看有没有欠拟合

1
2
3
4
5
6
7
8
9
10
11
from sklearn import linear_model
# 用正则取出我们要的属性值
train_np = data_dummies[:891].as_matrix()
# y即第0列：Survival结果
y = np.array(data_train.Survived)
# X即第1列及以后：特征属性值
X = train_np
# fit到LogisticRegression之中
clf = linear_model.LogisticRegression(C=1.0, penalty='l1', tol=1e-6)
clf.fit(X, y)
sum(clf.predict(X)==y)/X.shape[0]
1
0.8406285072951739

还不错，要是运气好点可能测试集也能有个80的准确率？(想多了)
然后计算测试集，结果存到csv，提交kaggle。结果是0.77511
针对训练好的模型可以做一下交叉验证，看看有没有明显的过拟合，这里还有个现成的可以画图的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import numpy as np
import matplotlib.pyplot as plt
# from sklearn.learning_curve import learning_curve  修改以fix learning_curve DeprecationWarning
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()
        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.gca().invert_yaxis()
        plt.show()
    
    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

plot_learning_curve(clf, u"学习曲线", X, y)

看着还可以。其实逻辑回归我也不知道还能调点什么，也就是再细分特征了，但感觉这已经很细了。。。
所以还是大力出奇迹吧，做个boost、bagging啥的模型融合，应该会有进步

1
2
3
4
5
6
7
8
from sklearn.ensemble import BaggingRegressor
# fit到BaggingRegressor之中
clf1 = linear_model.LogisticRegression(C=1.0, tol=1e-6)
bagging_clf = BaggingRegressor(clf1, n_estimators=20, max_samples=0.8, max_features=1.0, bootstrap=True, bootstrap_features=False, n_jobs=-1)
bagging_clf.fit(X, y)
predictions = bagging_clf.predict(data_dummies[891:])
result = pd.DataFrame({'PassengerId':data_test['PassengerId'].as_matrix(), 'Survived':predictions.astype(np.int32)})
result.to_csv("bagging2.csv", index=False)

因为我特征调了很多次，有时候bagging后结果有进步，有时候反倒下降了，感觉并不是万能的，还是跟特征选取有关。
这里之后就没有什么好办法改进，试了好几种模型，准确率都在75、76徘徊。从这张图上看还没有单纯只靠性别分准确率高，日

最后用到了gradientboosting梯度提升树，并且进行了艰苦的(玄学)调参，大部分时间也就跟逻辑回归一个结果。最后终于得到了进步，准确率到了0.799，排名1473/10113，排14.5%

折腾到这觉得可以告一段落了，就去看了看别人的kernel，结果发现了一些比较牛逼的东西
简单的分析最明显的特征，一个是性别，一个是pclass，还有一个是embarked。所以用一个手写的三层决策树(其实就是三个if)就可以做个简单预测：
先判断所有男性都没活下来
因为大部分女性都活了，但pclass=3的大部分人都死了，所以判断pclass!=3的女性都活了
然后对于pclass=3的，因为embarked=s的大部分人都死了，所以判断embarked!=s的女性都活了
其实也就是假设男性都死。女性除了pclass=3&&embarked=s的，都活。

1
2
3
data_train['Surv'] = 0
data_train.loc[(data_train.Sex=='female')&(data_train.Pclass!=3),'Surv'] = 1
data_train.loc[(data_train.Sex=='female')&(data_train.Pclass==3)&(data_train.Embarked!='S'),'Surv'] = 1

这么两行的准确率是多少呢？0.7799(微笑)
还有一个准确率83还是85的模型，他只判断了两件事，一个是性别，另外就是这个人一家的人的生还状况(可以从name字段判断)。毕竟一家人就是要整整齐齐。
所以可以看出来，最重要的还是特征分析这步，再牛逼的模型也没办法代替人来提取相关的信息。因为人可以从正向来进行思考，当这件事发生的时候，当时的人是怎么做决策的，是不是会女士优先，小孩先走，一家人互相帮助，同生共死。而机器和模型只能从已有的数据中以偏概全的去还原。这点倒是挺值得思考的。

参考链接：
https://www.kesci.com/home/project/5bfe39b3954d6e0010681cd1
https://www.kaggle.com/ldfreeman3/a-data-science-framework-to-achieve-99-accuracy
https://www.kaggle.com/mauricef/titanic

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家