泰坦尼克号数据集_泰坦尼克号生存率预测

目录

一、泰坦尼克号生存率预测

1.提出问题

2.理解数据

2.1采集数据

2.2导入数据

2.3查看数据集信息

3.数据清洗

3.1数据预处理

3.2特征工程

4.构建模型

5.模型评估

6.方案实施

6.1得到预测结果

6.2报告撰写

二、学习笔记

1.简单线性回归

1.1示例

1.2从线性回归到实现

2.逻辑回归

---

一、泰坦尼克号生存率预测

1.提出问题

什么样的人在泰坦尼克号中更容易存活？

2.理解数据

2.1采集数据

从Kaggle泰坦尼克号项目页面下载数据：https://www.kaggle.com/c/titanic

2.2导入数据

#忽略警告提示
import warnings
warnings.filterwarnings('ignore')

#导入数据处理包
import numpy as np
import pandas as pd

#导入数据
#训练数据集
train=pd.read_csv("/Users/yanshuangzeng/Desktop/train.csv")
#测试数据集
test=pd.read_csv("/Users/yanshuangzeng/Desktop/test.csv ")

print('训练数据集:',train.shape,'测试数据集:',test.shape)

rowNum_train=train.shape[0]
rowNum_test=test.shape[0]
print('kaggle训练数据集有多少行数据:',rowNum_train,
       ',kaggle测试数据集有多少行数据:',rowNum_test,)

#合并数据集，方便同时对两个数据集进行清洗
full=train.append(test, ignore_index=True)

print('合并后的数据集:',full.shape)

2.3查看数据集信息

#查看数据
full.head()

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

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

我们发现数据总共有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.数据清洗

3.1数据预处理

缺失值处理

在理解数据阶段我们发现数据总共有1309行。其中数据类型列：年龄、船舱号里面有缺失数据。字符串列：登陆港口、船舱号有缺失数据。

很多机器学习算法为了训练模型，要求所传入的特征中不能有空值。

1.如果是数值类型，用平均值取代

2.如果是分类数据，用最常见的类别取代

3.使用模型预测缺失值，例如：K-NN

print('处理前:')
full.info()
#年龄
full['Age']=full['Age'].fillna(full['Age'].mean())
#船票价格
full['Fare']=full['Fare'].fillna(full['Fare'].mean())
print('处理后:')
full.info()

#检查数据处理是否正常
full.head()

'''
总数据是1309
字符串列：
1）登船港口（Embarked）里面数据总数是1307，只缺失了2条数据，缺失比较少
2）船舱号（Cabin）里面数据总数是295，缺失了1309-295=1014，缺失率=1014/1309=77.5%，缺失比较大
'''
#登船港口：查看里面的数据
'''
出发地点：S=英国南安普顿Southampton
途径地点1：C=法国 瑟堡市Cherbourg
途径地点2：Q=爱尔兰 昆士敦Queenstown
'''
full['Embarked'].head()

'''
分类变量登船港口（Embarked），查看最常见的类别，用其填充
'''
full['Embarked'].value_counts()

'''
从结果来看，S类别最常见，我们将缺失值填充为最频繁出现的值：
S=英国南安普顿Southampton
'''
full['Embarked']=full['Embarked'].fillna('S')

#船舱号（Cabin）：查看里面数据
full['Cabin'].head()

#缺失数据比较多，船舱号（Cabin）缺失值填充为U，表示未知（Uknow） 
full['Cabin']=full['Cabin'].fillna('U')

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

#查看最终缺失值处理情况，记住生成情况（Survived）这里一列是我们的标签，用来做机器学习预测的，不需要处理这一列
full.info()

3.2特征提取

3.2.1数据分类

查看数据类型，分为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）
'''
full.info()

3.2.1分类数据：有直接类别的

1.乘客性别（Sex）：男性male，女性female

2.登船港口（Embarked）：出发地点S=英国南安普顿Southampton，途径地点1：C=法国 瑟堡市Cherbourg，出发地点2：Q=爱尔兰 昆士敦Queenstown

3.客舱等级（Pclass）：1=1等舱，2=2等舱，3=3等舱

性别(Sex)

#查看性别数据这一列
full['Sex'].head()

'''
将性别的值映射为数值
男（male）对应数值1，女（female）对应数值0
'''
sex_mapDict={'male':1,
                     'female':0}
#map函数：对series每个数据应用自定义的函数计算
full['Sex']=full['Sex'].map(sex_mapDict)
full.head()

登船港口

'''
登船港口(Embarked)的值是：
出发地点：S=英国南安普顿Southampton
途径地点1：C=法国 瑟堡市Cherbourg
途径地点2：Q=爱尔兰 昆士敦Queenstown
'''
#存放提取后的特征
embarkedDf = pd.DataFrame()

'''
使用get_dummies进行one-hot编码，产生虚拟变量（dummy variables），列名前缀是Embarked
'''
embarkedDf = pd.get_dummies( full['Embarked'] , prefix='Embarked' )
embarkedDf.head()

#添加one-hot编码产生的虚拟变量（dummy variables）到泰坦尼克号数据集full
full = pd.concat([full,embarkedDf],axis=1)

'''
因为已经使用登船港口(Embarked)进行了one-hot编码产生了它的虚拟变量（dummy variables）
所以这里把登船港口(Embarked)删掉
'''
full.drop('Embarked',axis=1,inplace=True)
full.head()

客舱等级（Pclass）

'''
客舱等级（Pclass）:
1=1等舱，2=2等舱，3=3等舱
'''
#存放提取后的特征

PclassDf=pd.DataFrame

#使用get_dummies进行one-hot编码，列名前缀是Pclass
PclassDf=pd.get_dummies(full['Pclass'],prefix='Pclass')
PclassDf.head()

#添加one-hot编码产生的虚拟变量（dummy variables）到泰坦尼克号数据集full
full=pd.concat([full,PclassDf],axis=1)

#删掉客舱等级（Pclass）这一列
full.drop('Pclass',axis=1,inplace=True)
full.head()

3.2.1分类数据：字符串类型

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

1. 乘客姓名（Name）
2. 客舱号（Cabin）
3. 船票编号（Ticket

从姓名提取头衔

'''
查看姓名这一列长啥样
注意到在乘客名字（Name）中，有一个非常显著的特点：
乘客头衔每个名字当中都包含了具体的称谓或者说是头衔，将这部分信息提取出来后可以作为非常有用一个新变量，可以帮助我们进行预测。
例如：
Braund, Mr. Owen Harris
Heikkinen, Miss. Laina
Oliva y Ocana, Dona. Fermina
Peter, Master. Michael J
'''
full['Name'].head()

#split用于字符串分割，返回一个列表
#我们看到姓名中'Braund, Mr. Owen Harris'，逗号前面的是“名”，逗号后面是‘头衔. 姓’

'''
定义函数：从姓名获取头衔
'''
def getTitle(name):
      str1=name.split(',')[1]
      str2=str1.split('.')[0]
      #strip() 方法用于移除字符串头尾指定的字符（默认为空格）
      str3=str2.strip()
      return str3

#存放提取后的特征
titleDf=pd.DataFrame()
#map函数：对Series每个数据应用自定义的函数计算
titleDf['Title']=full['Name'].map(getTitle)
titleDf.head()

'''
定义以下几种头衔类别：
Officer政府官员
Royalty王室（皇室）
Mr已婚男士
Mrs已婚妇女
Miss年轻未婚女子
Master有技能的人/教师
'''
#姓名中头衔字符串与定义头衔类别的映射关系
title_mapDict={
                    "Capt":       "Officer",
                    "Col":        "Officer",
                    "Major":      "Officer",
                    "Jonkheer":   "Royalty",
                    "Don":        "Royalty",
                    "Sir" :       "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"
                    }

#map函数：对Series每个数据应用自定义的函数计算
titleDf['Title'] = titleDf['Title'].map(title_mapDict)

#使用get_dummies进行one-hot编码
titleDf = pd.get_dummies(titleDf['Title'])
titleDf.head()

#添加one-hot编码产生的虚拟变量（dummy variables）到泰坦尼克号数据集full
full=pd.concat([full,titleDf],axis=1)

#删掉姓名这一列
full.drop('Name',axis=1,inplace=True)
full.head()

从客舱号中提取客舱类别

#补充知识：匿名函数
'''
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数，预防如下：
lambda 参数1，参数2：函数体或者表达式
'''

'''
客舱号的首字母是客舱的类别
'''
#查看客舱号的内容
full['Cabin'].head()

#存放客舱号信息
cabinDf=pd.DataFrame()

'''
客场号的类别值是首字母，例如：
C85 类别映射为首字母C
'''

full['Cabin']=full['Cabin'].map(lambda c:c[0])

##使用get_dummies进行one-hot编码，列名前缀是Cabin
cabinDf=pd.get_dummies(full['Cabin'],prefix='Cabin')

cabinDf.head()

#添加one-hot编码产生的虚拟变量（dummy variables）到泰坦尼克号数据集full
full=pd.concat([full,cabinDf],axis=1)

#删除客舱号这一列
full.drop('Cabin',axis=1,inplace=True)
full.head()

建立家庭人数和家庭类别

#存放家庭信息
familyDf=pd.DataFrame()

'''
家庭人数=同代直系亲属数（Parch）+不同代直系亲属数（SibSp）+乘客自己
（因为乘客自己也是家庭成员的一个，所以这里加1）
'''
familyDf['FamilySize']=full['Parch']+full['SibSp']+1

'''
家庭类别：
小家庭Family_Single：家庭人数=1
中等家庭Family_Small: 2<=家庭人数<=4
大家庭Family_Large: 家庭人数>=5
'''

#if 条件为真的时候返回if前面内容，否则返回0
familyDf['family_Single']=familyDf['FamilySize'].map(lambda s: 1 if s==1 else 0)
familyDf['Family_Small']=familyDf['FamilySize'].map(lambda s: 1 if 2<=s<=4 else 0)
familyDf['Family_Large']=familyDf['FamilySize'].map(lambda s: 1 if 5<=s else 0)

familyDf.head()

#添加one-hot编码产生的虚拟变量（dummy variables）到泰坦尼克号数据集full
full = pd.concat([full,familyDf],axis=1)
full.head()

部分截图

full.shape

3.3特征选择

相关系数法：计算各个特征的相关系数

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

截取部分图片

'''
查看各个特征与生成情况（Survived）的相关系数，
ascending=False表示按降序排列
'''
corrDf['Survived'].sort_values(ascending =False)

根据各个特征与生成情况（Survived）的相关系数大小，我们选择了这几个特征作为模型的输入：

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

#特征选择
full_X=pd.concat([titleDf,#头衔
                     pclassDf,#客舱等级
                     familyDf,#家庭大小
                     full['Fare'],#船票价格
                     cabinDf,#船舱号
                     embarkedDf,#登船港口
                     full['Sex']#性别
                    ] , axis=1 )
full_X.head()

4.构建模型

用训练数据和某个机器学习算法得到机器学习模型，用测试数据评估模型

4.1建立训练数据和测试数据集

'''
1）坦尼克号测试数据集因为是我们最后要提交给Kaggle的，里面没有生存情况的值，所以不能用于评估模型。
我们将Kaggle泰坦尼克号项目给我们的测试数据，叫做预测数据集（记为pred,也就是预测英文单词predict的缩写）。
也就是我们使用机器学习模型来对其生存情况就那些预测。
2）我们使用Kaggle泰坦尼克号项目给的训练数据集，做为我们的原始数据集（记为source），
从这个原始数据集中拆分出训练数据集（记为train：用于模型训练）和测试数据集（记为test：用于模型评估）。

'''

#原始数据集有891行
sourceRow=891

#原始数据集：特征
source_X=full_X.loc[0:sourceRow-1,:]
#原始数据集：标签
source_y=full.loc[0:sourceRow-1,'Survived']

#测试数据集：特征
pred_X = full_X.loc[sourceRow:,:]

'''
[sourceRow:,:]就是从891行开始到最后一行作为预测数据集
'''

'''
确保这里原始数据集取的是前891行的数据，不然后面模型会有错误
'''
#原始数据集有多少行
print('原始数据集有多少行:',source_X.shape[0])
#预测数据集大小
print('预测数据集有多少行:',pred_X.shape[0])

from sklearn.model_selection import train_test_split

#建立模型用的训练数据集和测试数据集
train_X, test_X, train_y, test_y = train_test_split(source_X ,
                                                    source_y,
                                                    train_size=.8)

#输出数据集大小
print ('原始数据集特征：',source_X.shape, 
       '训练数据集特征：',train_X.shape ,
      '测试数据集特征：',test_X.shape)

print ('原始数据集标签：',source_y.shape, 
       '训练数据集标签：',train_y.shape ,
      '测试数据集标签：',test_y.shape)

4.2选择机器学习算法

选择一个机器学习算法，用于模型的训练。因为是新手，所以尝试着从逻辑回归算法开始

第1步：导入逻辑算法

from sklearn.linear_model import LogisticRegression

第2步：创建模型：逻辑回归

model = LogisticRegression()

4.3训练模型

第3步：训练模型

model.fit( train_X , train_y )

5.评估模型

# 分类问题，score得到的是模型的正确率
model.score(test_X , test_y )

6.方案实施

6.1得到预测结果

#使用机器学习模型，对预测数据集中的生存情况进行预测
pred_Y = model.predict(pred_X)

#转换为整数型
pred_Y=pred_Y.astype(int)
#乘客id
passenger_id = full.loc[sourceRow:,'PassengerId']
#数据框：乘客id，预测生存情况的值
predDf = pd.DataFrame( 
    { 'PassengerId': passenger_id , 
     'Survived': pred_Y } )
predDf.shape
predDf.head()
#保存结果
predDf.to_csv( 'titanic_pred.csv' , index = False )

6.2报告撰写

待补充，后期更。

---

二、学习笔记

1.简单线性回归

1.1示例：以学习时间与分数之间的关系

第1步:建立数据集

from 

第2步：通过数据集了解两个变量的相关系数

#提取特征和标签
#特征features
exam_X=examDf.loc[:,'学习时间']
#标签labes
exam_y=examDf.loc[:,'分数‘]
#绘制散点图
import matplotlib.pyplot as plt
#散点图
put.scatter(exam_X,exam_y,color='b',label='exam data')
#添加图标标签
plt.xlabel("Hours")
plt.ylabel("Score")
#显示图像
plt.show()

#相关系数：corr返回结果是一个数据框，存放的是相关系数矩阵
rDf=examDf.corr()
print('相关系数矩阵:')
rDf

1.2线性回归到实现

1.2.1提取特征和标签

#特征features
exam_X=examDf.loc[:,'学习时间']
#标签labes
exam_y=examDf.loc[:,'分数']

1.2.2建立训练数据和测试数据

from sklearn.model_selection import train_test_split
#建立训练数据和测试数据
X_train , X_test , y_train , y_test = train_test_split(exam_X ,
                                                       exam_y ,
                                                       train_size = .8)
#输出数据大小
print('原始数据特征：',exam_X.shape ,
      '，训练数据特征：', X_train.shape , 
      '，测试数据特征：',X_test.shape )

print('原始数据标签：',exam_y.shape ,
      '训练数据标签：', y_train.shape ,
      '测试数据标签：' ,y_test.shape)

#绘制散点图
import matplotlib.pyplot as plt

#散点图
plt.scatter(X_train,y_train,color="blue",label="train data")
plt.scatter(X_test,y_test,color="red",label="test data")

#添加图标标签
plt.legend(loc=2)
plt.xlabel("Hours")
plt.ylabel("Score")

#显示图像
plt.show()

1.2.3训练模型（使用训练数据）

第1步：导入线性回归

from sklearn.linear_model import LinearRegression

第2步：创建模型：线性回归

model=LinearRegression()

第3步：训练模型

model.fit(Xtrain,y_trian)

注意：在这里我们输入完会出现报错信息：Reshape your data either using array.reshape(-1, 1) if your data has a single feature

因为sklearn要求输入的特征必须是二维数组的类型，但是因为我们目前只有1个特征，所以需要用安装错误提示用reshape转行成二维数组的类型

#将训练数据特征转换成二维数组xx行*1列
X_train=X_train.values.reshape(-1,1)
#将测试数据特征转换成二维数组行数*1列
X_test=X_test.values.reshape(-1,1)

转换后，重新运行第1-3步的代码，得到如下结果

'''
最佳拟合线：z= + x
截距intercept：a
回归系数：b
'''
#截距
a=model.intercept_
#回归系数
b=model.coef_
print('最佳拟合线：截距a=',a,',回归系数b=',b)

绘图

import matplotlib.pyplot as plt
#训练数据散点图
plt.scatter(X_train,y_train,color='blue',label="train data")

#训练数据的预测值
y_train_pred=model.predict(X_train)
#绘制最佳拟合线
plt.plot(X_train,y_train_pred,color='black',linewidth=3,label="best line")

#添加图标标签
pit.legend(loc=2)
plt.xlabel("Hours")
plt.ylabel("Score")

#显示图像
plt.show()

1.2.4模型评估（使用测试数据）

#线性回归的scroe方法得到的是决定系数R平方
#评估模型:决定系数R平方
model.score(X_test,y_test)

绘图

import matplotlib.pyplot as plt

#绘制训练数据散点图
plt.scatter(X_train,y_train,color='blue',label="train data")

#用训练数据绘制最佳线
y_train_pred=model.predict(X_train)
plt.plot(X_train,y_train_pred,color='black',linewidth=3,label="best line")

#绘制测试数据的散点图
plt.scatter(X_test, y_test, color='red', label="test data")

#添加图标标签
plt.legend(loc=2)
plt.xlabel("Hours")
plt.ylabel("Score")
#显示图像
plt.show()

2.逻辑回归

用于二分分类的算法

2.1建立数据集

from collections import OrderedDict
import pandas as pd
#数据集
examDict={
          '学习时间':[0.50,0.75,1.00,1.25,1.50,1.75,1.75,2.00,2.25,2.50,
            2.75,3.00,3.25,3.50,4.00,4.25,4.50,4.75,5.00,5.50],
           '通过考试':[0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1]
}
examOrderDict=OrderedDict(examDict)
examDf=pd.DataFrame(examOrderDict)
examDf.head

2.2提取特征和标签

#特征features
exam_X=examDf.loc[:,'学习时间']
#标签labes
exam_y=examDf.loc[:,'通过考试']

2.3绘制散点图

import matplotlib.pyplot as plt

#散点图
plt.scatter(exam_X,exam_y,color='b',label="exam data")

#添加图标标签
plt.xlabel("Hours")
plt.ylabel("Pass")

#显示图像
plt.show()

2.4建立训练数据集和测试数据集

from sklearn.model_selection import train_test_split
#建立训练数据和测试数据
X_train,X_test,y_train,y_test=train_test_split(exam_X,exam_y,train_size=0.8)

#输出数据大小
print('原始数据特征:',exam_X.shape,
       ',训练数据特征:',X_train.shape,
       ',测试数据特征:'X_test.shape)

print('原始数据标签:',exam_y.shape,
       '训练数据标签:'y_train.shape,
       '测试数据标签:',y_test.shape)

2.5绘制散点图

import matplotlib.pyplot as plt

#散点图
plt.scatter(X_train,y_train,color="blue",label="train data")
plt.scatter(X_test,y_test,color="red",label="test data")

#添加图标标签
plt.legend(loc=2)
plt.xlabe("Hours")
plt.ylabel("Pass")

#显示图像
plt.show()

2.6训练模型（使用训练数据）

第1步：导入逻辑回归

from sklearn.linear_model import LogisticRegression

第2步：创建模型：逻辑回归

model=LogisticRegression()

第3步：训练模型

model.fit(X_train,y_train)

注意：这里会出现报错信息，最后一行是这样提示我们的“Reshape your data either using array.reshape(-1, 1) if your data has a single feature or array.reshape(1, -1) if it contains a single sample.”

sklearn要求输入的特征必须是二维数组的类型，但是因为我们目前只有1个特征，所以需要用安装错误提示用reshape转行成二维数组的类型。

#将训练数据特征转换成二维数组XX行*1列
X_train=X_train.values.reshape(-1,1)
#将测试数据特征转换成二维数组行数*1列
X_test=X_test.values.reshape(-1,1)

接着重复第1-3步，结果如下

model.score(X_test,y_test)

---

感恩阅读至此。