特征工程(八)特征工程案例分析(2)—利用逻辑回归预测泰坦尼克号生存率

泰坦尼克号将乘客分为一等舱、二等舱、三等舱三个等级，等级不同决定了安全设施、娱乐设施、餐饮等的不同，对生存率有一定影响。
那是个绅士的年代，船难时，很多男士放弃逃生机会优先女士孩子逃生，然后慷慨赴死，性别年龄也是影响生存率的因素之一。　
根据背景初步判断船舱等级、乘客年龄、性别是影响生存率的因素。

一些人比其他人更有可能生存，比如妇女，儿童和上层阶级。什么样的人在泰坦尼克号中更容易存活？

下载数据地址如下：
https://www.kaggle.com/competitions/titanic/data

1、导入数据

import warnings
warnings.filterwarnings('ignore')# 导入处理数据包
import numpy as np
import pandas as pd

# 导入数据
train_data = pd.read_csv("./titanic_data/train.csv")
test_data = pd.read_csv("./titanic_data/test.csv")print('训练数据集:',train_data.shape,'测试数据集:',test_data.shape)

训练数据集: (891, 12) 测试数据集: (418, 11)

# 合并数据集，方便同时对两个数据集进行清洗
full_data = train_data.append(test_data,ignore_index=True)
print('合并后的数据集:',full_data.shape)

合并后的数据集: (1309, 12)

2、查看数据集的信息

# 查看数据
full_data.head()

# 获取数据类型列的描述性统计信息
full_data.describe()

describe只能查看数据类型的描述统计信息，对于其他类型的数据不显示，比如字符串类型姓名（name），客舱号（Cabin）。
这很好理解，因为描述统计指标是计算数值，所以需要该列的数据类型是数据

# 查看每一列的数据类型和数据总数
full_data.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1309 entries, 0 to 1308
Data columns (total 12 columns):#   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  0   PassengerId  1309 non-null   int64  1   Survived     891 non-null    float642   Pclass       1309 non-null   int64  3   Name         1309 non-null   object 4   Sex          1309 non-null   object 5   Age          1046 non-null   float646   SibSp        1309 non-null   int64  7   Parch        1309 non-null   int64  8   Ticket       1309 non-null   object 9   Fare         1308 non-null   float6410  Cabin        295 non-null    object 11  Embarked     1307 non-null   object 
dtypes: float64(3), int64(4), object(5)
memory usage: 122.8+ KB

我们发现数据总共有1309行。

其中数据类型列：年龄（Age）、船舱号（Cabin）里面有缺失数据：

• 1）年龄（Age）里面数据总数是1046条，缺失了1309-1046=263，缺失率263/1309=20%

• 2）船票价格（Fare）里面数据总数是1308条，缺失了1条数据

字符串列：

• 1）登船港口（Embarked）里面数据总数是1307，只缺失了2条数据，缺失比较少

• 2）船舱号（Cabin）里面数据总数是295，缺失了1309-295=1014，缺失率=1014/1309=77.5%，缺失比较大

这为我们下一步数据清洗指明了方向，只有知道哪些数据缺失数据，我们才能有针对性的处理。

3.数据清洗（Data Preparation ）

3.1 数据预处理

缺失值处理：

在前面，理解数据阶段，我们发现数据总共有1309行。

• 其中数据类型列：年龄（Age）、船票价格（Fare）里面有缺失数据。
• 字符串列：登船港口（Embarked）、船舱号（Cabin）里面有缺失数据。

这为我们下一步数据清洗指明了方向，只有知道哪些数据缺失数据，我们才能有针对性的处理。很多机器学习算法为了训练模型，要求所传入的特征中不能有空值。

• 如果是数值类型，用平均值取代
• 如果是分类数据，用最常见的类别取代
• 使用模型预测缺失值，例如：K-NN

# 1、对于数值类型年龄(Age)和船票价格(Fare)这两列数值类型，我们用平均值进行填充
full_data['Age'] = full_data['Age'].fillna(full_data['Age'].mean())full_data['Fare'] = full_data['Fare'].fillna(full_data['Fare'].mean())# 可以看到Age列和Fare列已经没有空值了
full_data.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1309 entries, 0 to 1308
Data columns (total 12 columns):#   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  0   PassengerId  1309 non-null   int64  1   Survived     891 non-null    float642   Pclass       1309 non-null   int64  3   Name         1309 non-null   object 4   Sex          1309 non-null   object 5   Age          1309 non-null   float646   SibSp        1309 non-null   int64  7   Parch        1309 non-null   int64  8   Ticket       1309 non-null   object 9   Fare         1309 non-null   float6410  Cabin        295 non-null    object 11  Embarked     1307 non-null   object 
dtypes: float64(3), int64(4), object(5)
memory usage: 122.8+ KB

# 2、填充登船港口（Embarked) 这一列
'''
出发地点:  S=英国   南安普顿  Southampton
途径地点1: C=法国   瑟堡市    Cherbourg
途径地点2: Q=爱尔兰 昆士敦    Queenstown
'''
# 可以看到S类别是最常见的，我们将缺失值填充为最频繁出现的
full_data['Embarked'].value_counts()

S    914
C    270
Q    123
Name: Embarked, dtype: int64

# 将缺失值填充为最频繁出现的S
full_data['Embarked'] = full_data['Embarked'].fillna('S')# 可以看到Embarked列已经没有空值了
full_data.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1309 entries, 0 to 1308
Data columns (total 12 columns):#   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  0   PassengerId  1309 non-null   int64  1   Survived     891 non-null    float642   Pclass       1309 non-null   int64  3   Name         1309 non-null   object 4   Sex          1309 non-null   object 5   Age          1309 non-null   float646   SibSp        1309 non-null   int64  7   Parch        1309 non-null   int64  8   Ticket       1309 non-null   object 9   Fare         1309 non-null   float6410  Cabin        295 non-null    object 11  Embarked     1309 non-null   object 
dtypes: float64(3), int64(4), object(5)
memory usage: 122.8+ KB

# 3、填充船舱号（Cabin) 这一列
full_data['Cabin'].value_counts()

C23 C25 C27        6
G6                 5
B57 B59 B63 B66    5
C22 C26            4
F33                4..
A14                1
E63                1
E12                1
E38                1
C105               1
Name: Cabin, Length: 186, dtype: int64

# 缺失值比较多，填充为U，表示未知(unknown)
full_data['Cabin'] = full_data['Cabin'].fillna('U')# 可以看到所有列已经没有空值了,Survived这一列是标签列，不需要进行处理
full_data.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1309 entries, 0 to 1308
Data columns (total 12 columns):#   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  0   PassengerId  1309 non-null   int64  1   Survived     891 non-null    float642   Pclass       1309 non-null   int64  3   Name         1309 non-null   object 4   Sex          1309 non-null   object 5   Age          1309 non-null   float646   SibSp        1309 non-null   int64  7   Parch        1309 non-null   int64  8   Ticket       1309 non-null   object 9   Fare         1309 non-null   float6410  Cabin        1309 non-null   object 11  Embarked     1309 non-null   object 
dtypes: float64(3), int64(4), object(5)
memory usage: 122.8+ KB

# 查看数据是否正常
full_data.head()

3.2 特征提取

查看数据类型，分为3种数据类型。并对类别数据处理：用数值代替类别，并进行One-hot编码

（1）数值类型：
乘客编号（PassengerId），年龄（Age），船票价格（Fare），同代直系亲属人数（SibSp），不同代直系亲属人数（Parch）

（2）时间序列：无
（3) 分类数据：

• 1）有直接类别的

    乘客性别（Sex）：男性male，女性female登船港口（Embarked）：出发地点S=英国南安普顿Southampton，途径地点1：C=法国 瑟堡市Cherbourg，出发地点2：Q=爱尔兰 昆士敦Queenstown客舱等级（Pclass）：1=1等舱，2=2等舱，3=3等舱
  

• 2）字符串类型：可能从这里面提取出特征来，也归到分类数据中

    乘客姓名（Name）客舱号（Cabin）船票编号（Ticket）
  

3.2.1 直接类别的分类数据

# 1、将性别值映射为数值,男（male）对应数值1，女（female）对应数值0
sex_dict = {'male':1,'female':0
}full_data['Sex'] = full_data['Sex'].map(sex_dict)
full_data.head()

# 2、登船港口（Embarked)进行one-hot编码
'''
使用get_dummies进行one-hot编码，产生虚拟变量
'''
embarkedDf = pd.get_dummies(full_data['Embarked'],prefix='Embarked')
embarkedDf.head()

# 在原始数据集上添加one-hot编码产生的虚拟变量
full_data = pd.concat([full_data,embarkedDf],axis=1)'''
因为已经对Embarked进行了one-hot编码，产生了虚拟变量，因此我们把Embarked列删除drop删除某一列代码解释:
因为drop(name,axis=1)里面指定了name是哪一列，比如指定的是A这一列，axis=1表示按行操作
那么结合起来就是把A列里面每一行删除，最终结果是删除了A这一列。
简单来说，使用drop删除某几列的方法记住这个语法就可以了: drop([列名1,列名2],axis=1)
'''
full_data.drop('Embarked',axis=1,inplace=True)full_data.head()

# 3、客舱等级（Pclass）进行one-hot编码
# 客舱等级（Pclass）：1=1等舱，2=2等舱，3=3等舱pclassDf = pd.get_dummies(full_data['Pclass'],prefix='Pclass')
pclassDf.head()

# 在原始数据集上添加one-hot编码产生的虚拟变量
full_data = pd.concat([full_data,pclassDf],axis=1)full_data.drop('Pclass',axis=1,inplace=True)full_data.head()

3.2.2 字符串类别的分类数据

# 1、从姓名列[Name]提取头衔
'''
注意到在乘客名字 (Name) 中，有一个非常显著的特点:
乘客头衔每个名字当中都包含了具体的称谓或者说是头衔，将这部分信息提取出来后可以作为非常有用一个新变量，可以帮助我们进行预测。
'''
full_data['Name'].head(10)

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
5                                     Moran, Mr. James
6                              McCarthy, Mr. Timothy J
7                       Palsson, Master. Gosta Leonard
8    Johnson, Mrs. Oscar W (Elisabeth Vilhelmina Berg)
9                  Nasser, Mrs. Nicholas (Adele Achem)
Name: Name, dtype: object

'''
定义函数，从姓名中获取头衔
'''
def getTitle(name):str1 = name.split(',')[1]str2 = str1.split('.')[0]str3 = "".join(str2.strip())return str3
titleDf = pd.DataFrame()
titleDf['Title'] = full_data['Name'].map(getTitle)
titleDf

1309 rows × 1 columns

'''
定义以下几种头衔类别:
Officer  政府官员
Royalty  王室
Mr       已婚男士
Mrs      已婚妇女
Miss     年轻未婚女子
Master   有技能的人/教师
'''# 姓名中头衔字符串与定义头衔类别的映射关系
title_dict = {"Capt": "Officer","Col": "Officer","Major": "Officer","Don": "Royalty","Sir": "Royalty","Jonkheer": "Royalty","Dr": "Officer","Rev": "Officer","the Countess": "Royalty","Dona": "Royalty","Mme": "Mrs","Mlle": "Miss","Ms": "Mrs","Mr": "Mr","Mrs": "Mrs","Miss": "Miss","Master": "Master","Lady": "Royalty"
}titleDf['Title'] = titleDf['Title'].map(title_dict)# one-hot编码
titleDf = pd.get_dummies(titleDf['Title'])
titleDf.head()

# 添加one-hot编码到full_data，bing'q并且删除Name这一列
full_data = pd.concat([full_data,titleDf],axis=1)full_data.drop('Name',axis=1,inplace=True)
full_data

1309 rows × 21 columns

# 2、从Cabin列提取客舱号信息
full_data['Cabin'] = full_data['Cabin'].map(lambda c:c[0])
full_data.head()

5 rows × 21 columns

# 进行one-hot编码
cabinDf = pd.get_dummies(full_data['Cabin'],prefix='Cabin')
cabinDf.head()

full_data = pd.concat([full_data,cabinDf],axis=1)full_data.drop('Cabin',axis=1,inplace=True)
full_data.head()

5 rows × 29 columns

# 3、建立家庭人数和家庭类别
familyDf = pd.DataFrame()'''
家庭人数 = 同代直系亲属数(Parch) + 不同代直系亲属数(SibSp) + 乘客自己
'''familyDf['FamilySize'] = full_data['Parch'] + full_data['SibSp'] + 1familyDf.head()

'''
家庭类别
小家庭Family_Small:     家庭人数=1
中等家庭Family_Middle:  2<=家庭人数<=4
大家庭Family_Large:     家庭人数>=5
'''familyDf['Family_Small']  =  familyDf['FamilySize'].map(lambda cnt: 1 if cnt == 1 else 0 )
familyDf['Family_Middle'] =  familyDf['FamilySize'].map(lambda cnt: 1 if 2 <= cnt <= 4 else 0 )
familyDf['Family_Large']  =  familyDf['FamilySize'].map(lambda cnt: 1 if cnt >= 5 else 0 )familyDf.head()

# 拼接到full_data
full_data = pd.concat([full_data,familyDf],axis=1)full_data.head()

5 rows × 33 columns

# 目前的特征
full_data.shape

(1309, 33)

3.3 特征选择

# 相关性矩阵
corrDf = full_data.corr()
corrDf

32 rows × 32 columns

'''
查看各个特征与存活(Survived)的相关系数,倒序排列
'''
corrDf['Survived'].sort_values(ascending=False)

Survived         1.000000
Mrs              0.344935
Miss             0.332795
Pclass_1         0.285904
Family_Middle    0.279855
Fare             0.257307
Cabin_B          0.175095
Embarked_C       0.168240
Cabin_D          0.150716
Cabin_E          0.145321
Cabin_C          0.114652
Pclass_2         0.093349
Master           0.085221
Parch            0.081629
Cabin_F          0.057935
Royalty          0.033391
Cabin_A          0.022287
FamilySize       0.016639
Cabin_G          0.016040
Embarked_Q       0.003650
PassengerId     -0.005007
Cabin_T         -0.026456
Officer         -0.031316
SibSp           -0.035322
Age             -0.070323
Family_Large    -0.125147
Embarked_S      -0.149683
Family_Small    -0.203367
Cabin_U         -0.316912
Pclass_3        -0.322308
Sex             -0.543351
Mr              -0.549199
Name: Survived, dtype: float64

根据各个特征与Survived的相关系数大小，选择这几个特征作为模型的输入：

头衔（前面所在的数据集titleDf）、客舱等级（pclassDf）、家庭大小（familyDf）、船票价格（Fare）、船舱号（cabinDf）、登船港口（embarkedDf）、性别（Sex）

full_X = pd.concat([titleDf,pclassDf,familyDf,full_data['Fare'],cabinDf,embarkedDf,full_data['Sex']],axis=1
)full_X.head()

5 rows × 27 columns

4、构建模型

• 坦尼克号测试数据集因为是我们最后要提交给Kaggle的，里面没有生存情况的值，所以不能用于评估模型。

• 使用Kaggle泰坦尼克号项目给的训练数据集，做为我们的原始数据集（记为source），从这个原始数据集中拆分出训练数据集（记为train：用于模型训练）和测试数据集（记为test：用于模型评估）

# 原始数据集有891行
source_row = 891# 原始数据集的特征
source_X = full_X.loc[0:source_row-1,:]
# 原始数据集的标签
source_y = full_data.loc[0:source_row-1,'Survived']# 预测数据集特征
pred_X = full_X.loc[source_row:,:]print('原始数据集的大小：',source_X.shape[0])
print('预测数据集的大小：',pred_X.shape[0])

原始数据集的大小： 891
预测数据集的大小： 418

# 1、拆分原始数据集
from sklearn.model_selection import train_test_splittrain_X,test_X,train_y,test_y  = train_test_split(source_X,source_y,test_size=0.2,train_size=0.8
)# 2、选择机器学习算法，我们选择最基础的逻辑回归算法
from sklearn.linear_model import LogisticRegressionlr = LogisticRegression()# 3、训练模型
lr.fit(train_X,train_y)

# 4、评估模型，用精确率进行评估
lr.score(test_X,test_y)

0.8156424581005587

5、上传到Kaggle

# 对预测数据集进行预测
pred_y = lr.predict(pred_X)# 转换为kaggle要求是整形
pred_y = pred_y.astype(int)# 乘客id
passenger_id = full_data.loc[source_row:,'PassengerId']predDf = pd.DataFrame({'PassengerId':passenger_id,'Survived':pred_y}
)predDf.head()

# 保存结果
predDf.to_csv('./titanic_data/titanic_pred.csv',index=False)