博客

Kaggle泰坦尼克号沉船生存预测，已经是数据挖掘界国际经典入门案例了。

那，小试“牛”刀。

#Titanic: Machine Learning from Disaster#

# 导入常用数据模块
import pandas as pd
import numpy as np

# 导入训练集数据文件
train1=pd.read_csv("D:/2018_BigData/Python/Kaggle_learning/Titanic Machine Learning from Disaster/titanic/train.csv")
train1.head(5)

# 看下数据基本统计信息

#先看数字类型的整体情况
train1.describe()

# 平均Survived存活率38.4%，不到四成的人活下来。
# 平均Age年龄29.7，整体偏年轻。
# SibSp兄弟姐妹数量加上Parch父母子女数量，平均0.9个人（这里可以归纳为“家庭成员”），相当于，平均每人带一个同伴。当然，有人携家带口人多，也会有人独自出行。
# 平均Fare票价32.2.从常识推断，高票价人数会比普通票价人数少，并且票价高很多。票价的中位数和众数应该在32以下。
# Pclass船舱等级平均2.3，说明三等舱的乘客比一、二等舱乘客多。

# Age字段缺失两百多个数据量，后期待补，可用均值mean或中位数median直接补上。

# 然后看看字符串类型（非数值）的整体情况
train1.describe(include="O")

# Ticket票有681种，有可能是681批人。
# Embarked码头有3个。
# Cabin舱位有147种，不过因为该列数据缺失较多，这个值147无法采用。

# 看下各字段信息
train1.info()

# 总891条数据，Age、Cabin、Embarked有缺失
# 那接下来看看怎么让这些缺失数据更直观

<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

# 用 isnull 查看各列有没有缺失值
train1.isnull().any()

# ——有三列缺失，Age、Cabin、Embarked。但是还不够直观，我们不知道是大部分数据缺失还是个别数据缺失。
# 接下来可以试试在isnull后面加sum来统计总缺失个数

PassengerId    False
Survived       False
Pclass         False
Name           False
Sex            False
Age             True
SibSp          False
Parch          False
Ticket         False
Fare           False
Cabin           True
Embarked        True
dtype: bool

# sum统计出个数之后，为了更直观一些，将统计出的数据排序
train1.isnull().sum().sort_values(ascending=False)

# 这样就更直观了，不仅知道哪些列有缺失数据，还知道缺失了多少个数据，而且降序排列更加一目了然。
# Cabin          687
# Age            177
# Embarked         2
# 以上三个字段缺失，其中：
# Age可以用均值 mean 或中位数 median 来填充。
# Embarked登船地点只缺两个数据，或许可以通过其他关联数据（例如票号）找到对应的登陆港口。
# Cabin暂时还想不出怎么补，我们得继续看看具体数据内容，找到它们的逻辑所在。或者直接舍弃该字段。

Cabin          687
Age            177
Embarked         2
Fare             0
Ticket           0
Parch            0
SibSp            0
Sex              0
Name             0
Pclass           0
Survived         0
PassengerId      0
dtype: int64

# 查看 Embarked 列缺失值的信息
train1[train1.Embarked.isnull()]

# 这两位，票号一致，舱位一致，说明是同行的两个人。既不是sibsp，也不是parch，说明是朋友。
# 那问题来了，他们会从哪个登船地点上来呢？

# 在下一步，我们把train1的所有数据放出来看（考虑到占篇幅太大，得出结论后已清空原数据显示），浏览一下发现：
# 票号Ticket六位数且以“113***”开头的乘客，Embarked登船地点都是S。由此我们推测，这两位的登船口也是S，直接填充进缺失值。

# 用 fillna 函数来填充

train2=train1.fillna({"Embarked":"S"})
train2.head(20)

# 如果要展示某一列，可以train1["Embarked"].fillna({"Embarked":"S"}) 这样展示

# 确认一下 Embarked 缺失值是否已填充成功
train2[train2.Embarked.isnull()]

# 结果显示已经没有缺失记录，说明已填充成功。

# 看看其他列是不是还缺失
train2.isnull().sum().sort_values(ascending=False)

# 发现其他两列仍然和填充 Embarked 前一致，一切正常，继续下一步。

Cabin          687
Age            177
Embarked         0
Fare             0
Ticket           0
Parch            0
SibSp            0
Sex              0
Name             0
Pclass           0
Survived         0
PassengerId      0
dtype: int64

# 下面，用中位数median来填充 Age 列缺失值
train3=train2.fillna(train2['Age'].median())
train3.head(20)

# 填充完毕，重新看看 train 的基础信息
train3.isnull().sum()

# 发现 Carbin 列也全部没缺失了，为什么呢？而且出现了很多次“28”，估计是age的median值28。
# 是不是在填充 Age 列的时候，影响到 Carbin 列了呢？接下来要证实。

PassengerId    0
Survived       0
Pclass         0
Name           0
Sex            0
Age            0
SibSp          0
Parch          0
Ticket         0
Fare           0
Cabin          0
Embarked       0
dtype: int64

# 换一种方式，还是用中位数 median 填充 Age 列缺失值
train2["Age"]=train2["Age"].fillna(train2["Age"].median())
train2.isnull().sum().sort_values(ascending=False)

# 这种方式与上一种方式的区别，是train2后面加了["Age"]来限定某列。
# 特别注意，语句 train2["Age"]=train2["Age"].fillna(train2["Age"].median()) 中，等号前面的train2["Age"] 不能把["Age"]去掉，如果去掉尝试，整个文件都得重头运行一遍。不信试试。

Cabin          687
Embarked         0
Fare             0
Ticket           0
Parch            0
SibSp            0
Age              0
Sex              0
Name             0
Pclass           0
Survived         0
PassengerId      0
dtype: int64

train2.head(20)

# 接下来看看test测试数据

# 导入测试集数据文件
test1=pd.read_csv("D:/2018_BigData/Python/Kaggle_learning/Titanic Machine Learning from Disaster/titanic/test.csv")
test1.head(5)

# 查看缺失列及缺失数量
test1.isnull().sum().sort_values(ascending=False)

# Cabin又上榜，估计可以先当弃子，搁一边先不管。
# Age也上榜，用均值mean或中位数median填充。
# Fare缺失一个数据，可以回到数据集中查看一下规律，手动填充。

Cabin          327
Age             86
Fare             1
Embarked         0
Ticket           0
Parch            0
SibSp            0
Sex              0
Name             0
Pclass           0
PassengerId      0
dtype: int64

# 查看某列（Fare）缺失值
test1[test1.Fare.isnull()]

# Fare缺失的这位乘客，3等舱，男性，65岁，单独出行。其实可以用Pclass三等舱的平均票价或中位数来填充，想来这样填充对整体评估还是比价契合的。

# 用某列各个组中的平均值填充相应缺失值
# 例如，将Pclass分组，用各组Fare平均值来填充对应的Fare
test1["Fare"] = test1.groupby("Pclass").transform(lambda x: x.fillna(x.mean()))
test1.isnull().sum().sort_values(ascending=False)

# 填充完毕，从缺失值数量上看，OK。

# 接下来验证一下填充的是不是Pclass=3的平均值

Cabin          327
Age             86
Embarked         0
Fare             0
Ticket           0
Parch            0
SibSp            0
Sex              0
Name             0
Pclass           0
PassengerId      0
dtype: int64

# 我们发现缺失了Fare值的那位乘客,PassengerId是1044,行索引是152，我们可以索引出来看看结果。
test1.loc[152,["Pclass","Name","Age","Fare"]]
# 或 test1.loc[152] 或 test1.loc[152,:] 可以查看152行的所有列

Pclass                     3
Name      Storey, Mr. Thomas
Age                     60.5
Fare                    1044
Name: 152, dtype: object

# 最便捷的方法，是直接 用 loc 函数，查看第152行所有列
test1.loc[152]

# 发现填充的Fare数值是1044，那我们看看Pclass=3（即三等舱）的票价Fare平均值是不是1044。

PassengerId                  1044
Pclass                          3
Name           Storey, Mr. Thomas
Sex                          male
Age                          60.5
SibSp                           0
Parch                           0
Ticket                       3701
Fare                         1044
Cabin                         NaN
Embarked                        S
Name: 152, dtype: object

Fare_Pclass_mean = test1.groupby("Pclass")["Fare"].mean()
Fare_Pclass_mean
# 或不用赋值，直接用 test1.groupby("Pclass")["Fare"].mean()得出结果即可，达到验证目的即可。

# 然而验证发现，Pclass=3的均值是1094，并不是上面填充的1044。这是为何呢？
# 说明这个函数填充，错了——test1["Fare"] = test1.groupby("Pclass").transform(lambda x: x.fillna(x.mean()))

Pclass
1    1098.224299
2    1117.935484
3    1094.178899
Name: Fare, dtype: float64

# 接下来找找其他方法，同时先恢复填充前的源状态。
# 重新导入数据
test2=pd.read_csv("D:/2018_BigData/Python/Kaggle_learning/Titanic Machine Learning from Disaster/titanic/test.csv")
test2.head(35)

test2.isnull().sum().sort_values(ascending=False)

# Fare还在缺失中，这是我们的源数据。

Cabin          327
Age             86
Fare             1
Embarked         0
Ticket           0
Parch            0
SibSp            0
Sex              0
Name             0
Pclass           0
PassengerId      0
dtype: int64

# 既然我们知道了三等舱平均票价1094，那直接填充进 缺失的那列NaN。
test2["Fare"]=test2["Fare"].fillna("1094")
test2.isnull().sum().sort_values(ascending=False)

# 填充Fare列成功

Cabin          327
Age             86
Embarked         0
Fare             0
Ticket           0
Parch            0
SibSp            0
Sex              0
Name             0
Pclass           0
PassengerId      0
dtype: int64

# Age年龄一列缺失值也用平均值替代，将前面训练集数据的填充方法复制过来直接用。
test2["Age"]=test2["Age"].fillna(test2["Age"].median())
test2.isnull().sum().sort_values(ascending=False)

# 填充Age列成功

Cabin          327
Embarked         0
Fare             0
Ticket           0
Parch            0
SibSp            0
Age              0
Sex              0
Name             0
Pclass           0
PassengerId      0
dtype: int64

# 看看Age列年龄均值多少，验证下。
Age_mean = test2["Age"].mean()
Age_mean

29.599282296650717

# 看看填充缺失值后的测试集数据test2

test2.head(35)

# 发现缺失行（索引10/22/29/33）的Age缺失值都填充了27，而前面Age_mean计算结果又是29.6.
# （本来存疑。后来发现把median中位数当成mean均值了。不过无碍，两者皆可。2019.4.9）
# 鉴于实际填充的27与计算平均值结果29相差不大，考虑进度，此处暂且忽略。容后再探讨。2019.4.8

# 经过对数据集中影响因素的分析，
# 我们筛选了潜在影响因素"Survived","Pclass","Sex","Age","SibSp","Parch","Fare","Embarked"，
# 剔除了"PassengerId"/"Ticket"/"Cabin"三个或缺失或无关因素。

train2[["Survived","Pclass","Sex","Age","SibSp","Parch","Fare","Embarked"]].corr(method="pearson")
# 查看各因素之间关联性

# 与Survived强相关的因素：无
# 与Survived弱相关的因素：Pclass/Fare——船舱等级和票价，果然是，社会经济地位影响生存概率。
# 与Survived极弱相关或无相关的因素："Age","SibSp","Parch"——从电影来看，明明是小孩和妇女优先，所以这里三个因素可能可以进一步分析探讨。
# 因为不是连续变量，没能通过pearson相关性展示的因素有"Sex"和"Embarked"，这两个我们另外找其他方法。

# 此处补充一个知识点（来自MOOC课程）
# ——Pearson相关系数

# r 取值范围[-1,1]
# 0.8-1.0 极强相关
# 0.6-0.8 强相关
# 0.4-0.6 中等强度相关
# 0.2-0.4 弱相关
# 0-0.2 极弱相关或无相关

# 需要进一步了解，可以去找概率论的书来看

# 关于"SibSp"和"Parch"，一个父母子女，一个兄弟朋友，我们统一归类为同伴，并将他们相加更新一个新因素。

train2["Family"]=train2["SibSp"]+train2["Parch"]
train2.head(5)

# 关于"Age"，我们做一个年龄分层。

# 1婴幼儿童：0-11
# 2少年：12-18
# 3青年：19-35
# 4中年：36-52
# 5中老年:53-65
# 6老年：66以上

# 从网上搜索Python数值分组方法，处理如下：

#分组依据，注意最小值要减1，最大最要加1.因为pandas的数值分组是左开右闭，或左闭右开
#使用了开区间、闭区间的概念，可百度了解
bins=[-1,12,19,36,53,66,150]
 
#分组对应的标签，-1到11对应婴幼儿童，12到18对应少年……
labels=['婴幼儿童','少年','青年','中年','中老年','老年']

#使用pandas中的cut进行数值分组，right=False表示左闭右开，省略参数right表示左开右闭
train2['age_group']=pd.cut(
        train2['Age'],
        bins,
        right=False,
        labels=labels)

train2.head(5)

# Python数值分组 参考来源 https://blog.csdn.net/qq_35990702/article/details/82313055 

# 为方便做相关性分析，把['婴幼儿童','少年','青年','中年','中老年','老年']转化成数值型[1,2,3,4,5,6]

train2['age_group0'] = train2['age_group'].map({'婴幼儿童': 1, '少年': 2,'青年':3,'中年':4,'中老年':5,'老年':6}).astype(int)
train2.head(5)

# 关于“Sex”，我们也要把类别属性（性别sex）转化为1，2

train2['Sex0'] = train2['Sex'].map({'female': 1, 'male': 2}).astype(int)
train2.head(5)

# 关于"Embarked"，同样类似Sex处理方式，将其类别属性转化为数值属性。
# 先看看"Embarked"总共有多少种不重复的值
train2['Embarked'].value_counts()

S    646
C    168
Q     77
Name: Embarked, dtype: int64

# 将 Embarked 类别属性(S/C/Q)转化为数值属性(1/2/3)
train2["Embarked0"] = train2["Embarked"].map({'S': 1, 'C': 2, 'Q': 2}).astype(int)
train2.head(5)

# 这次，我们再来看看相关性分析
# 注意:"Age"——age_group；"SibSp"及"Parch"——Family；"Embarked"——Embarked0
train2[["Survived","Pclass","Sex0","age_group0","Family","Fare","Embarked0"]].corr(method="pearson")

# 这次结果，性别sex0与survived存活是强相关的关系，甚至超过了社会经济地位（船舱等级和票价）的影响程度。
# 而根据本次相关性分析，Family人数和age_group年龄层反而对存活没有产生很大的影响作用。
# （在一些大神帖子里看到，family人数和年龄对个人存活影响很大，那这两个悬念就留着先，等学有所成再抽时间回来撸。）

# 忍不住，看看family。
train2[["Family","Survived"]].groupby("Family",as_index=False).mean().sort_values(by="Survived",ascending=False)

# 结果发现，家庭人数1-3人的乘客，存活率均高于50%，远高于其他情形。

# 年龄层Age_group 也按照family的方法看一下
train2[["age_group","Survived"]].groupby("age_group",as_index=False).mean().sort_values(by="Survived",ascending=False)

# 年龄层age_group介于婴幼儿童和少年（0-18岁）的乘客，存活率较高，均四成以上，而老年人存活率则不足13%。

# 特征工程
# 据说，特征工程是影响最终预测准确率的最关键因素，甚至超过了各类神奇的算法本身。

# 以上相关性分析我们发现，Fare与Pclass之间的相关系数达到了0.55，强相关关系，所以我们应该对这两个因素做统一处理。
# 作为新手，为了效率和简便，就粗暴地直接取其中一个因素，与Survived相关性最强的Pclass，同时舍弃另一个。

# 那，根据前面corr分析，与survived存活息息相关的因素：Sex0 > Pclass > Embarked （已舍弃Fare）
# 而根据双因素分析，family人数在1-3之间，或者年龄层age_group介于婴幼儿童和少年（0-18岁）的乘客，存活率较高。

# 既然在训练集数据train中提取了一些相关因素，那也得在测试集test中对应转化。
test2["Family"]=test2["SibSp"]+test2["Parch"]
test2.head(5)

bins=[-1,12,19,36,53,66,150]
 
#分组对应的标签，-1到11对应婴幼儿童，12到18对应少年……
labels=['婴幼儿童','少年','青年','中年','中老年','老年']

test2['age_group']=pd.cut(
        test2['Age'],
        bins,
        right=False,
        labels=labels)

test2.head(5)

test2['age_group0'] = test2['age_group'].map({'婴幼儿童': 1, '少年': 2,'青年':3,'中年':4,'中老年':5,'老年':6}).astype(int)
test2.head(5)

test2['Sex0'] = test2['Sex'].map({'female': 1, 'male': 2}).astype(int)
test2.head(5)

test2["Embarked0"] = test2["Embarked"].map({'S': 1, 'C': 2, 'Q': 2}).astype(int)
test2.head(5)

# 模型构建与评估
# 划分训练集、训练集数据

x_train = train2[["Pclass","Fare","Family","age_group0","Sex0","Embarked0"]]
y_train =train2["Survived"]
x_test = test2[["Pclass","Fare","Family","age_group0","Sex0","Embarked0"]]

# Logistic回归
from sklearn.linear_model import LogisticRegression
Classifier1 = LogisticRegression()
#训练模型
Classifier1.fit(x_train,y_train)
#预测
Y1_prediction = Classifier1.predict(x_test)
#模型评估
score_Logit = Classifier1.score(x_train,y_train)
score_Logit

# 可喜可贺，预测准确率0.805，比官方sample的0.766高了一丢丢。

0.8047138047138047

Classifier1.coef_

array([[-0.74124862,  0.00496064, -0.17449562, -0.33260786, -2.28141631,
         0.58615422]])

Final = pd.DataFrame({"PassengerId":test2["PassengerId"],
                       "Survived":Y1_prediction
                       })
Final.head(10)

Final.to_csv(r"D:/2018_BigData/Python/Kaggle_learning/Titanic Machine Learning from Disaster/titanic/Final1.csv",index=False)

# submission score 0.75598,低于sample 0.766.看来需要再接再励，调调参，或者试试其他算法。

# 把“fare”因素去掉，同样logistics 回归，重新试试。
x_train1 = train2[["Pclass","Family","age_group0","Sex0","Embarked0"]]
y_train1 =train2["Survived"]
x_test1 = test2[["Pclass","Family","age_group0","Sex0","Embarked0"]]

from sklearn.linear_model import LogisticRegression
Classifier1 = LogisticRegression()   #训练模型
Classifier1.fit(x_train1,y_train1)   #预测
Y1_prediction = Classifier1.predict(x_test1)   #模型评估
score_Logit = Classifier1.score(x_train1,y_train1)
score_Logit

# 预测准确率0.799，比刚刚同类方法预测值0.805还低了0.006。
# 不过无妨，可以试试导入竞赛submission试试。

0.7991021324354658

Final = pd.DataFrame({"PassengerId":test2["PassengerId"],
                       "Survived":Y1_prediction
                       })
Final.to_csv(r"D:/2018_BigData/Python/Kaggle_learning/Titanic Machine Learning from Disaster/titanic/Final2.csv",index=False)

# submission score 0.75598,与刚刚结果一致。

x_train2 = train2[["Pclass","Family","age_group0","Sex0"]]
y_train2 =train2["Survived"]
x_test2 = test2[["Pclass","Family","age_group0","Sex0"]]

from sklearn.linear_model import LogisticRegression
Classifier1 = LogisticRegression()   #训练模型
Classifier1.fit(x_train2,y_train2)   #预测
Y1_prediction = Classifier1.predict(x_test2)   #模型评估
score_Logit = Classifier1.score(x_train2,y_train2)
score_Logit

# 结果0.806，比刚刚较高的0.805还高了0.001，算是小进步。

0.8058361391694725

Final = pd.DataFrame({"PassengerId":test2["PassengerId"],
                       "Survived":Y1_prediction
                       })
Final.to_csv(r"D:/2018_BigData/Python/Kaggle_learning/Titanic Machine Learning from Disaster/titanic/Final3.csv",index=False)

# submission score 0.77511，总算比官方sample 0.766高一些了。

# 减小变量至三个。
x_train3 = train2[["Pclass","Family","Sex0"]]
y_train3 =train2["Survived"]
x_test3 = test2[["Pclass","Family","Sex0"]]

from sklearn.linear_model import LogisticRegression
Classifier1 = LogisticRegression()   #训练模型
Classifier1.fit(x_train3,y_train3)   #预测
Y1_prediction = Classifier1.predict(x_test3)   #模型评估
score_Logit = Classifier1.score(x_train3,y_train3)
score_Logit

0.8002244668911336

Final = pd.DataFrame({"PassengerId":test2["PassengerId"],
                       "Survived":Y1_prediction
                       })
Final.to_csv(r"D:/2018_BigData/Python/Kaggle_learning/Titanic Machine Learning from Disaster/titanic/Final4.csv",index=False)

# submission score 0.77033。

x_train4 = train2[["Pclass","age_group0","Sex0"]]
y_train4 =train2["Survived"]
x_test4 = test2[["Pclass","age_group0","Sex0"]]

from sklearn.linear_model import LogisticRegression
Classifier1 = LogisticRegression()   #训练模型
Classifier1.fit(x_train4,y_train4)   #预测
Y1_prediction = Classifier1.predict(x_test4)   #模型评估
score_Logit = Classifier1.score(x_train4,y_train4)
score_Logit

0.8002244668911336

Final = pd.DataFrame({"PassengerId":test2["PassengerId"],
                       "Survived":Y1_prediction
                       })
Final.to_csv(r"D:/2018_BigData/Python/Kaggle_learning/Titanic Machine Learning from Disaster/titanic/Final5.csv",index=False)

# submission score 0.76076，又低了。

# 最后试试两个因素。
x_train5 = train2[["Pclass","Sex0"]]
y_train5 =train2["Survived"]
x_test5 = test2[["Pclass","Sex0"]]

from sklearn.linear_model import LogisticRegression
Classifier1 = LogisticRegression()   #训练模型
Classifier1.fit(x_train5,y_train5)   #预测
Y1_prediction = Classifier1.predict(x_test5)   #模型评估
score_Logit = Classifier1.score(x_train5,y_train5)
score_Logit

0.7867564534231201

Final = pd.DataFrame({"PassengerId":test2["PassengerId"],
                       "Survived":Y1_prediction
                       })
Final.to_csv(r"D:/2018_BigData/Python/Kaggle_learning/Titanic Machine Learning from Disaster/titanic/Final6.csv",index=False)

# submission score 0.76555，回到原始持平。

# Logistic回归 尝试结束。接下来试试其他算法。

# 先把清洗后的train2和test2保存成CSV，下次分析直接导入使用。

train2.to_csv(r"D:/2018_BigData/Python/Kaggle_learning/Titanic Machine Learning from Disaster/titanic/train2.csv",index=False)
test2.to_csv(r"D:/2018_BigData/Python/Kaggle_learning/Titanic Machine Learning from Disaster/titanic/test2.csv",index=False)