Kaggle泰坦尼克号预测—

整理了一下全部流程，写成了一个ipynb文件

导入数据集

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')##载入数据集
data_path = 'D:/Now/Titanic/'train_data = pd.read_csv(data_path + 'train.csv',sep = ',')
test_data = pd.read_csv(data_path + 'test.csv',sep = ',')train_data.info()

数据探索性分析

##查看缺失值
train_miss_data = train_data.isnull().sum()train_miss_data = train_miss_data[train_miss_data>0]
train_miss_data.plot.bar()

在train_data的缺失值中，可以看到Cabin的缺失值比较多。Age的缺失值相对来说也比较多

train_data.head(10)

Pclass,Cabin,Embarked,Ticket,Sex,Survived是定性数据，Fare,SibSp,Parch,Age是定量数据。

查看Embarked数据
查阅资料得知：泰坦尼克号从英国南安普敦(Southampton)港出发，途经法国瑟堡-奥克特维尔(Cherbourg-Octeville)以及爱尔兰昆士敦(Queenstown)，计划中的目的地为美国纽约(New York)，开始了这艘“梦幻客轮”的处女航。

train_data['Embarked'].value_counts()

将Embarked转换成数值型数据

#train_data将S转为1，C转为2，Q转为3
train_data['Embarked'].replace('S',1,inplace=True)
train_data['Embarked'].replace('C',2,inplace=True)
train_data['Embarked'].replace('Q',3,inplace=True)
train_data['Embarked'].value_counts()'''
1.0    644
2.0    168
3.0     77
Name: Embarked, dtype: int64
'''#test_data将S转为1，C转为2，Q转为3
test_data['Embarked'].replace('S',1,inplace=True)
test_data['Embarked'].replace('C',2,inplace=True)
test_data['Embarked'].replace('Q',3,inplace=True)
test_data['Embarked'].value_counts()
'''
1    270
2    102
3     46
Name: Embarked, dtype: int64
'''

查看Sex数据

train_data['Sex'].value_counts()

将Sex转换成数值型数据

#train_data将male转换成1，female转换成2
train_data['Sex'].replace('male',1,inplace=True)
train_data['Sex'].replace('female',2,inplace=True)
train_data['Sex'].value_counts()
'''
1    577
2    314
Name: Sex, dtype: int64
'''#test_data将male转换成1，female转换成2
test_data['Sex'].replace('male',1,inplace=True)
test_data['Sex'].replace('female',2,inplace=True)
test_data['Sex'].value_counts()
'''
1    266
2    152
Name: Sex, dtype: int64
'''

转换之后查看相关性

abs(train_data.corr(method='pearson')).plot(kind='bar')
plt.legend(loc = 'best')
abs(train_data.corr(method='pearson'))

查看存活情况和其他数据的相关性

abs(train_data.corr(method='pearson'))['Survived']

可以看到，Sex，Pclass，Fare与Survived都有较明显的相关性

换个图看看：

sns.heatmap(abs(train_data.corr(method='kendall')))

train_data['Survived'].value_counts(normalize=True)
#空准确率 有38%的人获救

##对每一列绘制图观察
cols = ['Age','SibSp','Parch','Fare']
for i in cols:sns.distplot(train_data[train_data['Survived']==0][i],label='notSurvived',kde=False)sns.distplot(train_data[train_data['Survived']==1][i],label='Survived',kde=False)
#     plt.hist(train_data[train_data['Survived']==0][i],10,alpha = 0.5,label='notSurvived')
#     plt.hist(train_data[train_data['Survived']==1][i],10,alpha = 0.5,label='Survived')plt.legend(loc = 'best')plt.xlabel(i)plt.ylabel('count')plt.show()col = ['Pclass','Sex','Embarked']
for i in col:plt.hist(train_data[train_data['Survived']==0][i],10,alpha = 0.5,label='notSurvived')plt.hist(train_data[train_data['Survived']==1][i],10,alpha = 0.5,label='Survived')plt.legend(loc = 'best')plt.xlabel(i)plt.ylabel('count')plt.show()

图片太长，可以自己运行一下看看
根据图片可以得到以下信息：

从Pclass来看，Pclass = 3 的乘客较多，而Pclass = 1 的乘客存活率明显高于其他两个等级，只有Pclass = 1的乘客是存活人数大于死亡人数的

从Age来看，低于18岁的未成年人的存活率远高于其他年龄段的，而年龄大于60的老人的存活率远低于其他年龄段的，

从SibSp（兄弟姐妹/配偶在船上）来看，SibSp=1时和SibSp=2时存活率较高。

从Parch（一同上船的父母或子女）来看，基本和SibSp相差不多

从Fare来看，船票价格越高存活率越高，基本上船票价格高的存活人数都大于死亡人数。（不愧是有钱人）

从Sex来看，男性（1）的存活率不如女性（0）高

从Embarked来看，在第二个港口上船的存活率明显高于第一个港口上船的。

填补缺失值

##训练数据缺失情况
train_miss_data
'''
Age         177
Cabin       687
Embarked      2
dtype: int64
'''

test_miss_data = test_data.isnull().sum()
test_miss_data = test_miss_data[test_miss_data>0]##测试数据缺失情况
test_miss_data
'''
Age       86
Fare       1
Cabin    327
dtype: int64
'''

abs(train_data.corr(method='pearson'))['Age']

从数据中可以看出，Pclass和SibSp是较为重要的变量

##查看数据的基本描述
train_data.describe()

缺失值填充

基于目前的特征描述实现了机器学习在多个参数上的一次拟合，希望取得最佳模型

Age填充
导入数据库

from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestRegressor

###使用随机森林回归
###通过Name和Pclass和SibSp和Parch作为feature来训练Age
###再通过预测来填补Age缺失值
rfr = RandomForestRegressor(random_state=666,n_estimators = 3000,oob_score=True)##############################               train_data
##名字含有Mr的年龄预测
ages_df = train_data[['Name', 'Age', 'SibSp', 'Pclass', 'Parch']]
age_Mr = ages_df[ages_df.Name.str.contains('Mr.')]
train_age_Mr = age_Mr[['Age', 'SibSp', 'Pclass', 'Parch']]
train = train_age_Mr[train_age_Mr.Age.notnull()]
test = train_age_Mr[train_age_Mr.Age.isnull()]
X = train.drop('Age',axis = 1)
y = train['Age']
rfr.fit(X, y)
result = rfr.predict(test.drop('Age',axis = 1))
train_age_Mr.loc[(train_age_Mr.Age.isnull()), 'Age'] = result##年龄含有Mrs的年龄预测
ages_df = train_data[['Name', 'Age', 'SibSp', 'Pclass', 'Parch']]
age_Mrs = ages_df[ages_df.Name.str.contains('Mrs.')]
train_age_Mrs = age_Mrs[['Age', 'SibSp', 'Pclass', 'Parch']]
train = train_age_Mrs[train_age_Mrs.Age.notnull()]
test = train_age_Mrs[train_age_Mrs.Age.isnull()]
X = train.drop('Age',axis = 1)
y = train['Age']
rfr.fit(X, y)
result = rfr.predict(test.drop('Age',axis = 1))
train_age_Mrs.loc[(train_age_Mrs.Age.isnull()), 'Age'] = result##年龄含有Miss的年龄预测
ages_df = train_data[['Name', 'Age', 'SibSp', 'Pclass', 'Parch']]
age_Miss = ages_df[ages_df.Name.str.contains('Miss.')]
train_age_Miss = age_Miss[['Age', 'SibSp', 'Pclass', 'Parch']]
train = train_age_Miss[train_age_Miss.Age.notnull()]
test = train_age_Miss[train_age_Miss.Age.isnull()]
X = train.drop('Age',axis = 1)
y = train['Age']
rfr.fit(X, y)
result = rfr.predict(test.drop('Age',axis = 1))
train_age_Miss.loc[(train_age_Miss.Age.isnull()), 'Age'] = result##年龄含有Dr的年龄预测
ages_df = train_data[['Name', 'Age', 'SibSp', 'Pclass', 'Parch']]
age_Dr = ages_df[ages_df.Name.str.contains('Dr.')]
train_age_Dr = age_Dr[['Age', 'SibSp', 'Pclass', 'Parch']]
train = train_age_Dr[train_age_Dr.Age.notnull()]
test = train_age_Dr[train_age_Dr.Age.isnull()]
X = train.drop('Age',axis = 1)
y = train['Age']
rfr.fit(X, y)
result = rfr.predict(test.drop('Age',axis = 1))
train_age_Dr.loc[(train_age_Dr.Age.isnull()), 'Age'] = result##年龄含有Master的年龄预测
ages_df = train_data[['Name', 'Age', 'SibSp', 'Pclass', 'Parch']]
age_Master = ages_df[ages_df.Name.str.contains('Master.')]
train_age_Master = age_Master[['Age', 'SibSp', 'Pclass', 'Parch']]
train = train_age_Master[train_age_Master.Age.notnull()]
test = train_age_Master[train_age_Master.Age.isnull()]
X = train.drop('Age',axis = 1)
y = train['Age']
rfr.fit(X, y)
result = rfr.predict(test.drop('Age',axis = 1))
train_age_Master.loc[(train_age_Master.Age.isnull()), 'Age'] = result###########################################   test_data
##名字含有Mr的年龄预测
ages_df = test_data[['Name', 'Age', 'SibSp', 'Pclass', 'Parch']]
test_age_Mr = ages_df[ages_df.Name.str.contains('Mr.')]
test_age_Mr = test_age_Mr[['Age', 'SibSp', 'Pclass', 'Parch']]
train = test_age_Mr[test_age_Mr.Age.notnull()]
test = test_age_Mr[test_age_Mr.Age.isnull()]
X = train.drop('Age',axis = 1)
y = train['Age']
rfr.fit(X, y)
result = rfr.predict(test.drop('Age',axis = 1))
test_age_Mr.loc[(test_age_Mr.Age.isnull()), 'Age'] = result##年龄含有Mrs的年龄预测
ages_df = test_data[['Name', 'Age', 'SibSp', 'Pclass', 'Parch']]
test_age_Mrs = ages_df[ages_df.Name.str.contains('Mrs.')]
test_age_Mrs = test_age_Mrs[['Age', 'SibSp', 'Pclass', 'Parch']]
train = test_age_Mrs[test_age_Mrs.Age.notnull()]
test = test_age_Mrs[test_age_Mrs.Age.isnull()]
X = train.drop('Age',axis = 1)
y = train['Age']
rfr.fit(X, y)
result = rfr.predict(test.drop('Age',axis = 1))
test_age_Mrs.loc[(test_age_Mrs.Age.isnull()), 'Age'] = result##年龄含有Miss的年龄预测
ages_df = test_data[['Name', 'Age', 'SibSp', 'Pclass', 'Parch']]
test_age_Miss = ages_df[ages_df.Name.str.contains('Miss.')]
test_age_Miss = test_age_Miss[['Age', 'SibSp', 'Pclass', 'Parch']]
train = test_age_Miss[test_age_Miss.Age.notnull()]
test = test_age_Miss[test_age_Miss.Age.isnull()]
X = train.drop('Age',axis = 1)
y = train['Age']
rfr.fit(X, y)
result = rfr.predict(test.drop('Age',axis = 1))
test_age_Miss.loc[(test_age_Miss.Age.isnull()), 'Age'] = result##年龄含有Master的年龄预测
ages_df = test_data[['Name', 'Age', 'SibSp', 'Pclass', 'Parch']]
test_age_Master = ages_df[ages_df.Name.str.contains('Master.')]
test_age_Master = test_age_Master[['Age', 'SibSp', 'Pclass', 'Parch']]
train = test_age_Master[test_age_Master.Age.notnull()]
test = test_age_Master[test_age_Master.Age.isnull()]
X = train.drop('Age',axis = 1)
y = train['Age']
rfr.fit(X, y)
result = rfr.predict(test.drop('Age',axis = 1))
test_age_Master.loc[(test_age_Master.Age.isnull()), 'Age'] = result

###将数据填入train_data中
train_data.loc[train_age_Mr.index.values,'Age'] = train_age_Mr
train_data.loc[train_age_Mrs.index.values,'Age'] = train_age_Mrs
train_data.loc[train_age_Miss.index.values,'Age'] = train_age_Miss##将数据填入test_data中
test_data.loc[test_age_Mr.index.values,'Age'] = test_age_Mr
test_data.loc[test_age_Mrs.index.values,'Age'] = test_age_Mrs
test_data.loc[test_age_Miss.index.values,'Age'] = test_age_Miss
test_data.loc[test_age_Master.index.values,'Age'] = test_age_Master

通过查看数据发现test_data的Age还有一个缺失值，train_data也还有5个缺失值

test_data[test_data['Age'].isnull()]

这个人也看不出来是Miss还是Mrs，不过看她是自己一个人，又是7.75的便宜票，就当她是Miss吧！按Miss的均值进行填充。

test_data['Age'].fillna(test_age_Miss['Age'].mean(),inplace = True)

查看train_data的数据

train_data[train_data['Age'].isnull()]

名字里带有Master的意思一般是硕士之类的，但是看到岁数也有2岁的，去查了一下资料，发现也有可能是少爷，所以这5名缺失年龄的Master需要再分析。

查看数据发现，所有名字里带Master的年龄都不大，所以Master应该是少爷的意思。

index=65这位和index=709这位是同样的ticket而且都是男性，有可能是两个小少爷，所以应该是同一个父母。年龄相差应该不远，甚至是同岁。

嗷train_age_Master预测的这两位的年龄也是一样的。

那就直接将train_age_Master的数据填充进去。

##填充名字含有Master的人缺失的年龄
train_data.loc[[65,709,159,176],'Age']= train_age_Master.loc[[65,709,159,176],'Age']  train_data.loc[[65,709,159,176],'Age']
'''
65     5.226088
709    5.226088
159    6.923337
176    3.197636
Name: Age, dtype: float64
'''

##填充名字含有Dr的人缺失的年龄
train_data.loc[766,'Age'] = train_age_Dr.loc[766,'Age'] train_data.loc[766,]

Embarked填充
```
train_data[train_data['Embarked'].isnull()]
```
Ticket一样Cabin一样，应该是一起的，所以应该是在同一个港口上的船，可以合在一起看
看看相关性
```
abs(train_data.corr(method='pearson')['Embarked'])
```
根据相关性可以看到，没啥相关的。。。因为两人都存活了，那就按存活率最高的港口给她们填上！
```
train_data['Embarked'].fillna(2.0,inplace = True)
train_data['Embarked'].isnull().sum() ##0
```

Cabin缺失值处理
不知道咋处理。。。但是删掉又感觉不合适。就按有无Cabin数据看一下吧
将有Cabin的改为1，Cabin缺失的改为0.

####train_data
df = train_data
df.loc[ (df.Cabin.notnull()), 'Cabin' ] = "Yes"
df.loc[ (df.Cabin.isnull()), 'Cabin' ] = "No"dummies_Cabin = pd.get_dummies(train_data['Cabin'], prefix= 'Cabin')pd.concat([train_data,dummies_Cabin],axis=1) ##test_data
df = test_data
df.loc[ (df.Cabin.notnull()), 'Cabin' ] = "Yes"
df.loc[ (df.Cabin.isnull()), 'Cabin' ] = "No"dummies_Cabin = pd.get_dummies(test_data['Cabin'], prefix= 'Cabin')pd.concat([test_data,dummies_Cabin],axis=1)

查看缺失值

train_data.isnull().sum()

训练集缺失值填充完毕

test_data.isnull().sum()

测试集缺失值还差一个Fare缺失

Fare缺失值处理
```
test_data[test_data['Fare'].isnull()]
```
Fare和Pclass的相关性较高，可以根据Pclass=3的Fare求均值填充。（船票价格高船舱等级自然高）
```
test_data['Fare'].fillna(test_data[test_data['Pclass']==3]['Fare'].mean(),inplace=True)
test_data.isnull().sum()
```
至此缺失值全部填充完毕！

归一化和标准化

Fare和Age的变化幅度较大，会影响模型收敛，所以需要将他们归一化。就是将值特征到[-1,1]之间

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegressiondf = train_data.copy()scaler = StandardScaler()
# age_scale_param = scaler.fit(df[['Age']])
df['Age_scaled'] = scaler.fit_transform(df[['Age']])
# fare_scale_param = scaler.fit(df[['Fare']])
df['Fare_scaled'] = scaler.fit_transform(df[['Fare']])

对test_data进行同样的操作

df2 = test_data.copy()
df2['Age_scaled'] = scaler.fit_transform(df2[['Age']])
df2['Fare_scaled'] = scaler.fit_transform(df2[['Fare']])

df['Cabin'].replace('No',0,inplace=True)
df['Cabin'].replace('Yes',1,inplace=True)df2['Cabin'].replace('No',0,inplace=True)
df2['Cabin'].replace('Yes',1,inplace=True)

将数据保存下来，方便以后使用

df.to_csv('D:/Now/Titanic/clean_train_data.csv')
df2.to_csv('D:/Now/Titanic/clean_test_data.csv')

建模与预测

线性模型预测

from sklearn import linear_model
from sklearn import svm
from sklearn.model_selection import train_test_split,GridSearchCV

x_train, x_test, y_train, y_test = train_test_split(df.drop(['Survived','Name','PassengerId','Ticket','Fare','Age'],axis=1),df['Survived'], test_size=.3)
clf = svm.SVC(kernel='rbf',class_weight='balanced')
c_range = np.logspace(-5, 15, 11, base=2)
gamma_range = np.logspace(-9, 3, 13, base=2)
# 网格搜索交叉验证的参数范围，cv=3,3折交叉，n_jobs=-1，多核计算
param_grid = [{'kernel': ['rbf'], 'C': c_range, 'gamma': gamma_range}]
grid = GridSearchCV(clf, param_grid, cv=3, n_jobs=-1)
# 训练模型
clf = grid.fit(x_train, y_train)
# 计算测试集精度
score = grid.score(x_test, y_test)
print('精度为%s' % score)

精度为0.8283582089552238

预测

pred = clf.predict(df2.drop(['Name','PassengerId','Ticket','Fare','Age'],axis=1))
id = test_data['PassengerId']
sub=pd.DataFrame({ 'PassengerId': id, 'Survived': pred})
sub

将预测结果导出到文件中

sub.to_csv('D:/Now/Titanic/pred.csv',index=False)

提交到Kaggle中，成绩为0.7606