数据分析——Kaggle 泰坦尼克之灾

发表于 | 分类于 | | 浏览 次

之前只是做了简单的分析，对数据很多方面考虑得十分不全面，特征工程做得很差，所以这次学习借鉴了 Kaggle 上一些大佬的经验并结合自己之前做的重新来一遍，下面详细的记录下来。

环境

  • Python 3.6
  • MacOS
  • 主要工具：jupyter notebook；pandas；matplotlib；seaborn；sklearn

思路

0）业务场景或者问题的理解

0）获得数据。

1）观察数据：检查属性信息，缺失值。

2）初步分析数据：各种属性的分布情况。

3）进行特征工程：包括特征选择，特征提取，特征构造。（非常重要）

4）选择算法建立模型。

5）可视化，报告，记录整理过程。

背景和目标

在分析一个业务或者问题之前先要熟悉他们背景以及一些业务知识才能更好的理解问题。

泰坦尼克号事故

相信大家都知道这场事故：泰坦尼克号是一艘客运轮船，在航行过程中撞上冰山，船裂成两半后沉入大西洋，死亡人数超过 1500 人，堪称 20 世纪最大的海难事件，同时也是最广为人知的海难之一。

目标

预测泰坦尼克号每一位乘客的生存可能性，使其准确率尽可能达到最高。

获取数据

Kaggle 上的下载地址。包含：

  • test.csv：测试集
  • train.csv：训练集

读取数据

引入库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# base
import numpy as np
import pandas as pd
from pandas import DataFrame
import re
# visualize
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline
# machine learning
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC, LinearSVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import Perceptron, SGDClassifier
from sklearn.tree import DecisionTreeClassifier

读取训练集和测试集

1
2
3
4
# 训练集和测试集
train_df = pd.read_csv('data/train.csv')
test_df = pd.read_csv('data/test.csv')
combine = [train_df, test_df]

将两个数据存入列表中，后续更方便处理。

观察数据

在做分析之前，先要简单的观察数据的情况，比如他们的属性个数、属性类别、缺失值情况等等，对数据有个大概的认识。

观察属性情况

1、属性的个数

1
list(train_df.columns.values)

结果：

1
2
3
4
5
6
7
8
9
10
11
12
['PassengerId',
 'Survived',
 'Pclass',
 'Name',
 'Sex',
 'Age',
 'SibSp',
 'Parch',
 'Ticket',
 'Fare',
 'Cabin',
 'Embarked']

一共 12 个属性

2、属性类别

1
train_df.head()

结果：

属性：

  • Survived：是否生存，0 = No，1 = Yes
  • Pclass：船票的等级，有 1，2，3 三种等级，1 等级最好
  • Sex：性别，female（女） 和 male（男）
  • Age：年龄
  • SibSp：兄弟姐妹或者配偶在船上的个数
  • Parch：父母或者小孩在船上的个数
  • Ticket：船票编号
  • Fare：船价
  • Cabin：船舱的编号
  • Embarked：乘客上船的港口，C = Cherbourg, Q = Queenstown, S = Southampton

其中Survived是类标号。

Quantitative 定量型属性有：Age、Fare、SibSp、Parch。其中「连续型」有：Age、Fare，「离散型」有：SibSp, Parch。

Qualitative 定性型属性有：Survived、Pclass、Sex、Embarked。其中「Categorical 型（无先后顺序）」有：Survived、Sex、Embarked，「Ordinal 型（又先后顺序）」有：Pclass。

Quantitative 定量数据：

  • Continuous 连续性的
  • Discrete 离散性的

Qualitative 定性数据：

  • Categorical 绝对性的（无先后顺序）
  • Ordinal 顺序的（有先后顺序）

连续数据代表测量的结果是不能被数出来的，它只能被区间所描述。

观察缺失值

1
2
3
4
# 训练集和测试集的缺失值
train_df.info()
print('-'*40)
test_df.info()

结果：

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
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
PassengerId    891 non-null int64
Survived       891 non-null int64
Pclass         891 non-null int64
Name           891 non-null object
Sex            891 non-null object
Age            714 non-null float64
SibSp          891 non-null int64
Parch          891 non-null int64
Ticket         891 non-null object
Fare           891 non-null float64
Cabin          204 non-null object
Embarked       889 non-null object
dtypes: float64(2), int64(5), object(5)
memory usage: 83.6+ KB
----------------------------------------
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 418 entries, 0 to 417
Data columns (total 11 columns):
PassengerId    418 non-null int64
Pclass         418 non-null int64
Name           418 non-null object
Sex            418 non-null object
Age            332 non-null float64
SibSp          418 non-null int64
Parch          418 non-null int64
Ticket         418 non-null object
Fare           417 non-null float64
Cabin          91 non-null object
Embarked       418 non-null object
dtypes: float64(2), int64(4), object(5)
memory usage: 36.0+ KB

训练集：

  • 没有缺失值的属性有：PassengerId, Survived, Pclass, Name, Sex, SibSp, Parch, Ticket, Fare
  • 有缺失值：Cabin > Age > Embarked

测试集：

  • 有缺失值：Cabin > Age > Fare

属性的描述

1、观察数值型属性、二元属性、序数属性的情况

1
train_df.describe()

结果：

可以看到：

  • 有 891 个样本数据，其中只有 38% 的人最后活了下来
  • 船上乘客的平均年龄为 29 岁，最大的有 80 岁
  • 大多数乘客（75%）没有和小孩或者父母一起旅行
  • 大多数乘客（50% 以上）没有和兄弟姐妹或者配偶一起旅行
  • 高年龄的人只有很少一部分，大多数都是中少年
  • 最高的票价是 $512，75% 的乘客票价只是在 \$31 以下，票价相差极大

2、观察标称型（字符）属性的情况

1
train_df.describe(include=['O'])

结果：

可以看出：

  • 乘客的名字都是唯一的，891 个名字都不一样
  • 乘客中男性占多数，577/891
  • 在船票编号上按理说应该是唯一的，但是 891 张船票只有 681 张是唯一的
  • 船舱也不唯一，应该是有人共享了船舱的使用
  • 一共有三个港口，上岸乘客最多的港口是 S

初步分析

初步确定可以用来后面训练模型的属性，以及保留考虑一些属性。

首先我们先根据上面的观察结果和经验做一些假设：

  • 女人和小孩乘客更可能生存（电影里面的船长要求妇女小孩先走）
  • 高级乘客（Pclass=1）更可能生存
  • 有亲人（父母、兄弟姐妹、配偶）的更可能生存
  • 不同港口上船的人可能生存率不一样
  • 不同等级的乘客上船的港口分布

根据假设进行分析（无连续型）

1、Pclass

1
train_df[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False).mean()

结果：

观察：

  • 不同船票等级生存率不一样，按等级来分布
  • 船票等级为 1 的乘客生存率最高

决定：

  • 船票等级对生存结果有影响，将 Pclass 属性纳入后面模型训练中

2、Sex

1
train_df[['Sex', 'Survived']].groupby(['Sex'], as_index=False).mean()

结果：

观察：

  • 不同性别等级生存率不一样，也按性别来分布
  • 女性生存率比男性高出很多

决定：

  • 性别对生存结果有影响，将 Sex 属性纳入后面模型训练中

3、SibSp

1
train_df[['SibSp', 'Survived']].groupby(['SibSp'], as_index=False).mean()

结果：

观察：

  • 无法观察出明显特征

结论：

  • SibSp 属性做为考虑保留

4、Parch

1
train_df[['Parch', 'Survived']].groupby(['Parch'], as_index=False).mean()

结果：

观察：

  • 无法观察出明显特征

结论：

  • Parch 属性做为考虑保留

5、Embarked

1
train_df[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False).mean()

结果：

观察：

  • 不同港口上岸的乘客生存率不一样，也按港口来分布
  • C 港口生存率最高，S 最低

决定：

  • 港口对生存结果有影响，将 Embarked 属性纳入后面模型训练中

可视化进行分析

继续可视化分析数据，验证假设。在这个步骤可以对单个或者多个属性同时进行观察，得到更准确的结论。

1、数值型数据：Age

1
2
g = sns.FacetGrid(train_df, col='Survived')
g.map(plt.hist, 'Age', bins=30)

结果：

观察：

  • 80 岁的乘客活下来了
  • 15-30 岁的乘客大多数没有活下来
  • 大多数乘客在 15-35 这个年龄段
  • 小朋友存活率比较高

决定：

  • 将 Age 属性纳入后面模型训练中
  • 由于年龄在具有缺失值，需要填充
  • 为了训练方便，需要将年龄离散化

2、数值型和序数型：Age、Pclass

1
2
3
grid = sns.FacetGrid(train_df, col='Survived', row='Pclass', size=2.2, aspect=1.6)
grid.map(plt.hist, 'Age', alpha=0.5, bins=20)
grid.add_legend()

结果：

观察：

  • Pclass=3 的乘客数最多，但是大多数都没有活下来
  • Pclass=1 的乘客数最少，但是大多数都活下来了
  • 在 Pclass=1 和 Pclass=2 的小朋友都活了下来

决定：

  • 更加确定 Pclass 属性纳入后面模型训练中

3、对属性 Sex、Pclass、Embarked

1
2
3
grid = sns.FacetGrid(train_df, row='Embarked', size=2.2, aspect=1.6)
grid.map(sns.pointplot, 'Pclass', 'Survived', 'Sex', palette='deep')
grid.add_legend()

结果：

观察：

  • 在 S 和 Q 港口，女性乘客的存活率无论是那种等级都比男性高
  • 在 C 港口，男性乘客的存活率无论是那种等级都比女性高，这表明了性别个港口两个属性之间的相关性
  • 对于男性来说不同的港口有不同的存活率

决定：

  • 确认 Sex 属性纳入后面模型训练中
  • 确认 Embarked 属性纳入后面模型训练中
  • 由于 Embarked 在具有缺失值，需要填充

4、对属性 Embarked、Sex、Fare

1
2
3
grid = sns.FacetGrid(train_df, row='Embarked', col='Survived', size=2.2, aspect=1.6)
grid.map(sns.barplot, 'Sex', 'Fare', alpha=0.5, ci=None)
grid.add_legend()

结果：

观察：

  • 高票价的乘客更容易存活下来
  • 港口与存活率有关，C 港口的男性大多数活下来了

决定：

  • Fare 属性考虑保留
  • 需要将 Fare 值离散化

特征工程

根据之前的步骤，我们初步确认了属性Pclass，Sex，Age，Embarked可用于后面的模型训练，属性SibSp，Parch，Fare作为考虑，可以考虑删除、组合、构建其它特征。

还有Cabin，Ticket，Name以及PassengerId没有考虑过。

注意，为了后面训练方便：

  • 对于连续型属性需要将其离散化为序数型
  • 对于标称型属性需要将属性的值用数字表示，最后也是序数型

去除属性（数据量少，没有明显特征）

现在来看Cabin和Ticket，从之前的步骤可以发现Cabin的缺失值十分多，Ticket的值也没有什么明显的特征，所以这两个属性没有研究意义，可以删除提高后面训练模型的准确率和速度。

1
2
3
4
5
print("Before: ", train_df.shape, test_df.shape, combine[0].shape, combine[1].shape)
train_df = train_df.drop(['Ticket', 'Cabin'], axis=1)
test_df = test_df.drop(['Ticket', 'Cabin'], axis=1)
combine = [train_df, test_df]
print("After: ", train_df.shape, test_df.shape, combine[0].shape, combine[1].shape)

结果：

1
2
Before:  (891, 12) (418, 11) (891, 12) (418, 11)
After:  (891, 10) (418, 9) (891, 10) (418, 9)

分析 Name 属性保留或者去除或者其它

现在来看Name和PassengerId属性。

首先观察一下乘客的名字都是什么样的：

1
train_df['Name'].head()

结果：

1
2
3
4
5
6
0                              Braund, Mr. Owen Harris
1    Cumings, Mrs. John Bradley (Florence Briggs Th...
2                               Heikkinen, Miss. Laina
3         Futrelle, Mrs. Jacques Heath (Lily May Peel)
4                             Allen, Mr. William Henry
Name: Name, dtype: object

关于他们名字的结构我还没有搞清楚，但是Mr.，Dr.，Miss.等等就是他们的人际称谓，从人际称谓中可以体现这个人的身份地位。所以猜想这些人际称谓对生存几率有一定影响。

现在利用正则表达式将训练集和测试集的所有名字的人际称谓都提取出来分析

1
2
3
4
for dataset in combine:
    dataset['Title'] = dataset.Name.str.extract(' ([A-Za-z]+)\.', expand=False)
    
pd.crosstab(train_df['Title'], train_df['Sex'])

结果：

可以看到有 17 种人际称谓，其中Master，Miss，Mr，Mrs比较多，剩下的大部分比如具有Capt，Countess，Col等等这些称谓的人在阶级社会中都处于较高的位置，为了好统计将剩下的都合并为Rare这种称谓，在合并之前，先将Mlle，Ms，Mme这几种和Miss身份地位比较接近的人际称谓都加到Miss里面去，这样提高的准确率。

从这里就可以看出，特征工程要严谨的完成，不能放过任何一个微小的数据。只要设计跟分析相关的知识都要掌握清楚，才能做好特征工程，才能提高模型的准确率。

1
2
3
4
5
6
7
8
for dataset in combine:
    dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess', 'Capt', 'Col', 'Don', 'Dr', 'Major',
                                                'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
    dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
    dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
    dataset['Title'] = dataset['Title'].replace('Mme', 'Miss')
    
train_df[['Title', 'Survived']].groupby(['Title'], as_index=False).mean()

结果：

果然有一定的关系，女性存活率非常高，但是很奇怪的是 Rare的存活率并不是很高，他们都是处于社会阶层的上层。

为了后面的训练模型方便，将Title属性值用数字表示

1
2
3
4
5
6
title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in combine:
    dataset['Title'] = dataset['Title'].map(title_mapping)
    dataset['Title'] = dataset['Title'].fillna(0)
    
train_df.head()

结果：

1
2
3
4
5
6
0      Mr
1     Mrs
2    Miss
3     Mrs
4      Mr
Name: Title, dtype: object

在前面说了，对于Title这种用字符表示的属性，需要转换为序数型，用数字表示

1
2
3
4
5
6
7
# 将 Title 属性的值用数字表示
title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in combine:
    dataset['Title'] = dataset['Title'].map(title_mapping)
    dataset['Title'] = dataset['Title'].fillna(0)
    
train_df.head()

结果：

PassengerId乘客编号，对研究没有作用，因为有了Title属性所以Name属性也不必保留了。现在删除Name和PassengerId属性

1
2
3
4
train_df = train_df.drop(['Name', 'PassengerId'], axis=1)
test_df = test_df.drop(['Name'], axis=1)
combine = [train_df, test_df]
train_df.shape, test_df.shape

结果：

1
((891, 9), (418, 9))

将 Sex 属性的值用数字表示

解决了未考虑的那些属性，现在来看已经确认了的属性，在确认的属性当中只有Pclass属性已经满足要求：既没有缺失值，属性值又是数字表示。

现在来看Sex属性，该属性满足没有缺失值，但是属性值是字符表示，所以只需完成这个转换工作即可

1
2
3
4
for dataset in combine:
    dataset['Sex'] = dataset['Sex'].map({'female': 1, 'male': 0}).astype(int)
    
train_df.head()

结果：

填充 Age 属性的缺失值并离散化

关于填充缺失值的方法有很多，针对不同的属性可能有不同的方针，对 Age 属性的缺失值进行填充的话，可以有以下方法：

  • 方法 1：比较简单的一种是用该属性未缺失数据的均值或者中位数填充
  • 方法 2：更精确的是，用与 Age 属性有相关性的其它属性，比如在这个例子中就是 Sex 和 Pclass，将数据集分为 6 块（比如，Sex=0 and Pclass=1，Sex=0 and Pclass=2，Sex=0 and Pclass=3， Sex=1 and Pclass = 1，等等），计算每一块所有元组中 Age 属性的中位数，所以一共会得到六个中位数，将这几个中位数填充到对应的具有缺失值的 Age 上
  • 方法 3：在 2 的基础上用随机数来填充

方法 2 产生的噪音应该是最少的，选择方法 2 是最佳的。

所以先观察Age和Pclass、Sex的关系

1
2
3
grid = sns.FacetGrid(train_df, row='Pclass', col='Sex', size=2.2, aspect=1.6)
grid.map(plt.hist, 'Age', alpha=.5, bins=20)
grid.add_legend()

结果：

填充值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
guess_ages = np.zeros((2, 3))
for dataset in combine:
    
    # 对每种 Sex 和 Pclass 的组合找出 Age 的众数
    for i in range(0, 2):
        for j in range(0, 3):
            guess_df = dataset[(dataset['Sex'] == i) &
                               (dataset['Pclass'] == j+1)]['Age'].dropna()
            age_guess = guess_df.median()
            # 使值更接近
            guess_ages[i, j] = int(age_guess/0.5 + 0.5) * 0.5
    
    # 对每种 Sex 和 Pclass 的组合为空的 Age 值填值
    for i in range(0, 2):
        for j in range(0, 3):
            dataset.loc[(dataset.Age.isnull()) & 
                        (dataset.Sex == i) & 
                        (dataset.Pclass == j+1), 'Age'] = guess_ages[i, j]
    
    dataset['Age'] = dataset['Age'].astype(int)
train_df.head()

结果：

填充完后，将Age离散化为序数型，先将其分区

1
2
3
# turn the Age into ordinal
train_df['AgeBand'] = pd.cut(train_df['Age'], 5)
train_df[['AgeBand', 'Survived']].groupby(['AgeBand'], as_index=False).mean()

结果：

将每个数据按照之前的分区重新分配值

1
2
3
4
5
6
7
8
for dataset in combine:
    dataset.loc[dataset['Age'] <= 16, 'Age'] = 0
    dataset.loc[(dataset['Age'] > 16) & (dataset['Age'] <= 32), 'Age'] = 1
    dataset.loc[(dataset['Age'] > 32) & (dataset['Age'] <= 48), 'Age'] = 2
    dataset.loc[(dataset['Age'] > 48) & (dataset['Age'] <= 64), 'Age'] = 3
    dataset.loc[(dataset['Age'] > 64) & (dataset['Age'] <= 80), 'Age'] = 4
train_df.head()

结果：

现在删除AgeBand属性

1
2
3
train_df = train_df.drop(['AgeBand'], axis=1)
combine = [train_df, test_df]
train_df.head()

结果：

创建新属性结合 SibSp 和 Parch

由于SibSp是该乘客在船上的兄弟姐妹或者配偶的个数，Parch是该乘客在船上的父母或小孩的个数。从之前的初步分析步骤发现这两个属性并没有什么明显的特征，并且这两个都是关于在船上亲人的个数，所以我们把它们的个数加起来创建一个新属性FamilySize看看

1
2
3
4
for dataset in combine:
    dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1
train_df[['FamilySize', 'Survived']].groupby(['FamilySize'], as_index=False).mean().sort_values(by='Survived', ascending=False)

多加了一个1是因为，家庭成员数量也要算上自己

结果：

这样看也看不出什么明显的特征，所以再构建一个新属性IsAlone，成员个数为 1 的IsAlone为 1，表示这类人是独自的，其他的IsAlone为 0，表示有家庭成员一起不是独自的

1
2
3
4
for dataset in combine:
    dataset['IsAlone'] = 0
    dataset.loc[dataset['FamilySize'] == 1, 'IsAlone'] = 1
train_df[['IsAlone', 'Survived']].groupby(['IsAlone'], as_index=False).mean()

结果：

从结果来看可以观察到独自一人的乘客生存率更低，原因我猜想可能是灾难发生时一个人确实比较无助比较害怕，自己心里面都燃不起希望。

删除 Parch，SibSp 以及 FamilySize 属性，它们没有研究意义了，保留 IsAlone

1
2
3
4
5
train_df = train_df.drop(['Parch', 'SibSp', 'FamilySize'], axis=1)
test_df = test_df.drop(['Parch', 'SibSp', 'FamilySize'], axis=1)
combine = [train_df, test_df]
train_df.head()

结果：

创建一个新属性Age*Pclass

1
2
3
4
for dataset in combine:
    dataset['Age*Pclass'] = dataset.Age * dataset.Pclass
    
train_df.loc[:, ['Age*Pclass', 'Age', 'Pclass']].head(10)

结果：

填充 Embarked 属性的缺失值

Embarked属性的缺失值只有两个，这里为了方便，直接用众数填充缺失值，若要做到更加精确，可以用与具有缺失值的元组同样类标号的元组的该属性的中位数或者众数来填充

1
2
3
4
5
freq_port = train_df.Embarked.dropna().mode()[0]
for dataset in combine:
    dataset['Embarked'] = dataset['Embarked'].fillna(freq_port)
    
train_df[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False).mean()

结果：

将 Embarked 属性的值用数字表示

方法跟之前一样

1
2
3
4
for dataset in combine:
    dataset['Embarked'] = dataset['Embarked'].map({'S': 0, 'C': 1, 'Q': 2}).astype(int)
    
train_df.head()

结果：

可以看到还有Fare属性没有规范化了。

填充 Fare 属性的缺失值并离散化

先来看一下目前的缺失值情况

1
2
3
train_df.info()
print('-'*40)
test_df.info()

结果：

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
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 9 columns):
Survived      891 non-null int64
Pclass        891 non-null int64
Sex           891 non-null int64
Age           891 non-null int64
Fare          891 non-null float64
Embarked      891 non-null int64
Title         891 non-null int64
IsAlone       891 non-null int64
Age*Pclass    891 non-null int64
dtypes: float64(1), int64(8)
memory usage: 62.7 KB
----------------------------------------
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 418 entries, 0 to 417
Data columns (total 9 columns):
PassengerId    418 non-null int64
Pclass         418 non-null int64
Sex            418 non-null int64
Age            418 non-null int64
Fare           417 non-null float64
Embarked       418 non-null int64
Title          418 non-null int64
IsAlone        418 non-null int64
Age*Pclass     418 non-null int64
dtypes: float64(1), int64(8)
memory usage: 29.5 KB

只有测试集的Fare属性有缺失值，所以先来填充测试集的缺失值，这里采用中位数进行填充

1
2
test_df['Fare'].fillna(test_df['Fare'].dropna().median(), inplace=True)
test_df.head()

结果：

同样的，将 Fare 进行分区

1
2
train_df['FareBand'] = pd.qcut(train_df['Fare'], 4)
train_df[['FareBand', 'Survived']].groupby(['FareBand'], as_index=False).mean()

这里使用的是qcut和在 Age 属性分区时使用的cut不一样

cut：根据这些值大小来选择箱子均匀间隔

qcut：根据这些值的频率来选择箱子的均匀间隔

结果：

现在还剩下将训练集和测试集的Fare属性的值离散化，转换为序数型

1
2
3
4
5
6
7
8
9
10
11
for dataset in combine:
    dataset.loc[dataset['Fare'] <= 7.91, 'Fare'] = 0
    dataset.loc[(dataset['Fare'] > 7.91) & (dataset['Fare'] <= 14.454), 'Fare'] = 1
    dataset.loc[(dataset['Fare'] > 14.454) & (dataset['Fare'] <= 31.0), 'Fare'] = 2
    dataset.loc[(dataset['Fare'] > 31.0) & (dataset['Fare'] <= 512.329), 'Fare'] = 3
    dataset['Fare'] = dataset['Fare'].astype(int)
    
train_df = train_df.drop(['FareBand'], axis=1)
combine = [train_df, test_df]
train_df.head(10)

结果：

测试集

1
test_df.head(10)

结果：

都正常，可以开始训练了。

建立模型与评估

Python 的 sklearn 库可以做的真是太多了！等哪天一定要系统的学习一下

先准备数据

1
2
3
4
5
# prepare
X_train = train_df.drop("Survived", axis=1)
Y_train = train_df['Survived']
X_test = test_df.drop("PassengerId", axis=1).copy()
X_train.shape, Y_train.shape, X_test.shape

Logistic Regression

1
2
3
4
5
logreg = LogisticRegression()
logreg.fit(X_train, Y_train)
Y_pred = logreg.predict(X_test)
acc_log = round(logreg.score(X_train, Y_train) * 100, 6)
acc_log

结果：

1
81.369248

用逻辑回归计算出属性的相关系数

可以通过用逻辑回归计算出属性的相关系数来验证我们的假设和分析。

正系数表示该属性值增加从而会增加概率（生存），负系数表示该属性值增加从而会降低概率（生存）。

1
2
3
4
5
coeff_df = pd.DataFrame(train_df.columns.delete(0))
coeff_df.columns = ['Feature']
coeff_df["Correlation"] = pd.Series(logreg.coef_[0])
coeff_df.sort_values(by='Correlation', ascending=False)

coef_相当于是模型（假设函数）的斜率，其实就是每个属性值前面的一次项系数，一共有八个属性，所以有八个系数。

还有个参数是intercept_，相当于是模型（假设函数）的截距。

可以得出：

  • Sex 性别具有最高正相关性，表示当性别的值增加（从 0（male） 到 1（female）），生存（Survived）的概率增加得最多
  • 相反地，Pclass 等级具有最高负相关性，示当 Pclass 的值增加（1，2，3），生存（Survived）的概率降低得最多
  • 同样的，可以看到 Title 具有第二高正相关性，还好我们没有轻易删除 Name 属性
  • IsAlone 的值从 0 到 1，生存（Survived）的概率增加，即表示是独自一人的反而生存率更高

SVM

1
2
3
4
5
svc = SVC()
svc.fit(X_train, Y_train)
Y_pred = svc.predict(X_test)
acc_svc = round(svc.score(X_train, Y_train) * 100, 6)
acc_svc

结果：

1
83.72615

KNN

1
2
3
4
5
knn = KNeighborsClassifier()
knn.fit(X_train, Y_train)
Y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_train, Y_train) * 100, 6)
acc_knn

结果：

1
84.399551

Gaussian Naive Bayes

1
2
3
4
5
gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)
Y_pred = gaussian.predict(X_test)
acc_gaussian = round(gaussian.score(X_train, Y_train) * 100, 6)
acc_gaussian

结果：

1
73.737374

Perceptron

感知机是一种二分类的线性分类模型。感知机对应于输入空间中将实例划分为两类的分离超平面。感知机旨在求出该超平面，为求得超平面导入了基于误分类的损失函数，利用梯度下降法对损失函数进行最优化（最优化）。

1
2
3
4
5
perceptron = Perceptron()
perceptron.fit(X_train, Y_train)
Y_pred = perceptron.predict(X_test)
acc_perceptron = round(perceptron.score(X_train, Y_train) * 100, 6)
acc_perceptron

结果：

1
77.777778

Linear SVC

1
2
3
4
5
linear_svc = LinearSVC()
linear_svc.fit(X_train, Y_train)
Y_pred = linear_svc.predict(X_test)
acc_linear_svc = round(linear_svc.score(X_train, Y_train) * 100, 6)
acc_linear_svc

结果：

1
79.461279

Stochastic Gradient Descent

随机梯度下降的方法更快，更快收敛，虽然不是全局最优，但很多时候是我们可以接受的。

1
2
3
4
5
sgd = SGDClassifier()
sgd.fit(X_train, Y_train)
Y_pred = sgd.predict(X_test)
acc_sgd = round(sgd.score(X_train, Y_train) * 100, 6)
acc_sgd

结果：

1
74.074074

Decision Tree

1
2
3
4
5
decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)
Y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, Y_train) * 100, 6)
acc_decision_tree

结果：

1
86.756453

Random Forest

1
2
3
4
5
6
random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, Y_train)
Y_pred = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train) * 100, 6)
acc_random_forest

结果：

1
86.756453

总览

虽然决策树和随机森林的都是最高的，但是还是选择随机森林算法，因为该算法可以防止过你和问题。

1
2
3
4
5
6
7
8
9
10
models = pd.DataFrame({
    'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression', 
              'Random Forest', 'Naive Bayes', 'Perceptron', 
              'Stochastic Gradient Decent', 'Linear SVC', 
              'Decision Tree'],
    'Score': [acc_svc, acc_knn, acc_log, 
              acc_random_forest, acc_gaussian, acc_perceptron, 
              acc_sgd, acc_linear_svc, acc_decision_tree]
})
models.sort_values(by='Score', ascending=False)

结果：

Submission

1
2
3
4
5
submission = pd.DataFrame({
    "PassengerId": test_df["PassengerId"],
    "Survived": Y_pred
})
submission.head(10)

结果：

将测试集的每一个乘客都做了预测。

生成文件保存到本地

1
submission.to_csv('data/submission.csv', index=False)

总结

尽管这只是一个小项目，但是从写完一个 Kernel 到整理到博客，这个过程收获了非常多非常多的知识和技巧：

  • 特征工程真的特别特别重要，比最后的算法选择更重要！所以在处理数据时一定要全面周到，不能凭借一己之见，要去验证自己的想法
  • 使用 sklearn 库和可视化的技巧
  • 在使用训练模型前，将数据规范化
  • 按照步骤有条理的进行
  • 对于缺失值非常多的属性考虑丢弃
  • 对缺失值的处理

准备下一个～