Python入门之机器学习（非常详细）篇幅拉满，一般人看不完！
什么是机器学习？监督学习 supervised learning;非监督学习 unsupervised learning;半监督学习 semi-supervised learning;强化学习 reinforcement learning;监督学习是不断向计算机提供数据（特征），并告诉计算机对应的值（标签），最后通过大量的数据，让计算机自己学会判断和识别。例如Google Photo，你在APP中
文章共26,858字 · 阅读需要大约90分钟
一键AI生成摘要，助你高效阅读
问答
·
一、什么是机器学习
什么是机器学习？机器学习其实就是想让计算机像人一样思考而研发出的计算机理论，目前常用的机器学习有以下几种算法：
- 监督学习 supervised learning;
- 非监督学习 unsupervised learning;
- 半监督学习 semi-supervised learning;
- 强化学习 reinforcement learning;
监督学习是不断向计算机提供数据（特征），并告诉计算机对应的值（标签），最后通过大量的数据，让计算机自己学会判断和识别。例如Google Photo，你在APP中输入狗，这时就会弹出与狗相关的图片，这背后使用的算法就是监督学习。通过告诉计算机狗长什么样（特征），最后教会计算机认识狗（标签）。再比如今日头条，你使用APP的时间越长，给你推送的内容就越是你平时感兴趣的内容。通过对用户平时日常使用数据（特征）的分析，找到用户的兴趣爱好（标签），进而更精准的推送内容。
非监督学习与监督学习的区别是，只向计算机提供数据（特征），但并不提供对应的值（标签）。例如需要计算机学会识别猫和狗，这时仅提供猫和狗的图片（特征），但是并不告诉计算机，哪些图片是猫，哪些图片是狗，让计算机自己去总结归纳出两者的特征规律。
半监督学习是综合了监督学习和非监督学习两者的特点，利用少量有标签的样本，和大量没有标签的样本对计算机进行训练。
强化学习是将计算机放入一个陌生的环境中，让它自己去学习，其中包含了4个关键要素，分别是环境（environment）、状态（state）、行动（action）和奖励（reward）。例如要设计一款自动投篮机器，首先让机器自己去选择投篮的角度、力度等动作进行尝试，告诉机器如果投篮命中便能获得奖励，之后机器会根据练习所产生的数据，不断修改自身的动作策略，经过数次迭代之后，学习并完成投篮任务。战胜李世石的AlphaGo，所使用的就是强化学习。强化学习与监督学习和非监督学习最大的不同是，不需要使用海量的数据去“喂养”机器，而是通过不断地尝试去获取数据。
使用Python进行机器学习时，都会用到一个非常强大的第三方包，那就是scikit-learn。
Sklearn包含了四类算法，分别是回归（regression）、分类（classification）、聚类（clustering）和降维（dimensionality reduction）。其中回归和分类是监督式学习，下面使用Python对简单线性回归和逻辑回归分类进行简要介绍。
二、简单线性回归
线性回归（linear regression）是利用称为线性回归方程的最小二乘函数对一个或多个自变量和因变量之间关系进行建模的一种回归分析。这种函数是一个或多个称为回归系数的模型参数的线性组合。只有一个自变量的情况称为简单回归，大于一个自变量情况的叫做多元回归。
简单线性回归方程其实就像我们初中学习的二元一次方程:y=a+bx
其中a称作截距，b称作回归系数，x为自变量，y为因变量。
简单线性回归分析通常包含以下步骤：
- 提出问题
- 理解数据
- 数据清洗
- 构建模型
- 评估模型
1.提出问题
假设现在提出一个问题，通过收集学生学习时间和分数，得出学习时间与分数之间的相关关系，其中特征为学习时间，标签为分数。
2.理解数据
采集所需的数据，并导入Python。
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],
'分数':[10, 22, 13, 43, 20, 22, 33, 50, 62,
48, 55, 75, 62, 73, 81, 76, 64, 82, 90, 93]}
examDf = pd.DataFrame(examDict)
print(examDf.head())
学习时间 分数
0 0.50 10
1 0.75 22
2 1.00 13
3 1.25 43
4 1.50 20
#提取特征和标签
#特征features
exam_X=examDf.loc[:,'学习时间']
#标签labes
exam_y=examDf.loc[:,'分数']
#绘制散点图
import matplotlib.pyplot as plt
plt.scatter(exam_X,exam_y,color='b',label='exam data')
#添加图标标签
plt.xlabel('Hours') #X轴命名
plt.ylabel('Score') #Y轴命名
print(plt.show())
通过观察上面的散点图，我们可以对相关性做出初步的分析。相关性通常有3种情况，正线性相关、负线性相关和非线性相关。当线性回归方程中的回归系数b大于0，即直线朝上时，为正线性相关，回归系数b小于0，即直线朝下时，为负线性相关。我们还可以通过计算相关系数r，对相关性大小进行判断。相关系数公式如下：
#计算相关系数r
rDf = examDf.corr()
print('相关系数矩阵：\n',rDf)
print('相关系数r=',rDf.iloc[0,1])
相关系数矩阵：
学习时间 分数
学习时间 1.000000 0.923985
分数 0.923985 1.000000
相关系数r= 0.9239852119728443
3.数据清洗
本案例中数据较为简单，主要是为了介绍简单线性回归的操作过程，具体的步骤可查看，Python入门之Numpy与Pandas中的数据清洗一节。
4.构建模型
利用交叉验证函数中的train_test_split()进行建模分析。交叉验证是指：
交叉验证（Cross Validation）也称作循环估计（Rotation Estimation），是一种统计学上将数据样本切割成较小子集的实用方法。在给定的建模样本中，拿出大部分样本进行建模型，留小部分样本用刚建立的模型进行预测。交叉验证的基本思想是把在某种意义下将原始数据(dataset)进行分组,一部分做为训练集(train set),另一部分做为验证集(validation set or test set),首先用训练集对分类器进行训练,再利用验证集来测试训练得到的模型(model),以此来做为评价分类器的性能指标。
①创建模型
利用sklearn中train_test_split方法进行数据分割，将数据随机分成训练数据和测试数据，占比为8: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=0.8) #train_size指训练数据占比
#输出数据大小
print('原始数据特征：',exam_X.shape,
'训练数据特征：',X_train.shape,
'测试数据特征：',X_test.shape)
print('原始数据标签：',exam_y.shape,
'训练数据标签：',y_train.shape,
'测试数据标签：',y_test.shape)
原始数据特征： (20,) 训练数据特征： (16,) 测试数据特征： (4,)
原始数据标签： (20,) 训练数据标签： (16,) 测试数据标签： (4,)
#绘制散点图
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=4) #设置图签的位置
plt.xlabel("Hours")
plt.ylabel("Score")
#显示图像
plt.show()
②训练模型
#第1步：导入线性回归第三方包
from sklearn.linear_model import LinearRegression
#第2步：创建线性回归模型
model = LinearRegression()
#将训练数据特征和测试数据特征转换成二维数组
'''
reshape是重新定义行数和列数。如果行的参数是-1，就会根据所给的列数，
自动按照原始数组的大小形成一个新的数组，例如reshape(-1,1)就是改变
成1列的数组，这个数组的长度是根据原始数组的大小来自动形成的。
例如原始数组总共是2行*3列=6个数，那么这里就会形成6行*1列的数组。
'''
X_train = X_train.values.reshape(-1,1)
X_test = X_test.values.reshape(-1,1)
#第3步：训练模型
model.fit(X_train,y_train)
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)
③计算最佳拟合线
最佳拟合线：y= + x，截距intercept：a，回归系数：b
回归分析求最佳拟合线的常用方法为最小二乘法，通过最小二乘法，可以使得误差平方和最小，进而求出a和b的值。 这个数学问题过于复杂，如果想知道证明的原理可自行搜索学习。误差平方和的计算公式为：
#截距
a = model.intercept_
b = model.coef_
print('最佳拟合线：y=%f+%fx'%(a,b))
最佳拟合线：y=10.251797+15.840256x
#绘制训练数据散点图
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.legend(loc=4)
plt.xlabel("Hours")
plt.ylabel("Score")
#显示图像
plt.show()
5.模型评估
要想评估模型的精确度，可以使用决定系数R平方进行判断，R平方越大，表明回归模型越精确。使用测试数据进行模型评估，利用score方法，对第一个参数X_test用拟合曲线自动计算出y预测值。决定系数R平方计算公式如下：
#线性回归的scroe方法得到的是决定系数
#评估模型:决定系数
r2 = model.score(X_test , y_test)
print(r2)
0.8823686336975715
把训练数据集（图中蓝色的点），和测试数据集（图中红色的点）放到一张图上来进行比较，并在图上标注出决定系数R平方。
#第1步：绘制训练数据散点图
plt.scatter(X_train, y_train, color='blue', label="train data")
#第2步：用训练数据绘制最佳拟合线
#最佳拟合线训练数据的预测值
y_train_pred = model.predict(X_train)
#绘制最佳拟合线：标签用的是训练数据的预测值y_train_pred
plt.plot(X_train, y_train_pred, color='black', linewidth=3, label="best line")
#第3步：绘制测试数据的散点图
plt.scatter(X_test, y_test, color='red', label="test data")
#添加图标标签
plt.legend(loc=4)
plt.xlabel("Hours")
plt.ylabel("Score")
plt.show()
三、逻辑回归
逻辑回归（Logistic Regression）主要用来解决二分类问题，表示某件事情发生的可能性。什么是二分类呢，说简单点就是答案只有Yes和No两种可能。逻辑回归和线性回归一样，在机器算法中都属于监督学习，但是逻辑回归在Sklearn的4类算法中属于分类算法。
逻辑回归的公式如下：
逻辑函数图像如下：
可以看到，逻辑回归函数是一个s形的曲线，取值在[0,1]之间，在远离0的地方函数的值会很快接近0或者1。通常可以选择0.5作为阈值，划定一个决策面，当y>=0.5时，确定标签为1，当y<0.5时，确定标签为0。例如之前所举的今日头条的例子，就可以通过逻辑回归去找到关于用户喜好程度的决策面，通过下图可以帮助理解决策面的含义。
利用Python进行逻辑回归分析的方法与简单线性回归分析的步骤一致，同样是包括提出问题、理解问题、数据清洗、构建模型、模型评估5步。
1.提出问题
假设现在提出一个问题，通过收集学生学习时间和通过考试情况，得出学习时间与通过考试之间的相关关系，其中特征为学习时间，标签为通过考试。
2.理解数据
采集所需的数据，并导入Python。
import pandas as pd
#采集数据
exam2Dict = { '学习时间':[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]}
examDf = pd.DataFrame(exam2Dict)
print(examDf)
学习时间 通过考试
0 0.50 0
1 0.75 0
2 1.00 0
3 1.25 0
4 1.50 0
5 1.75 0
6 1.75 1
7 2.00 0
8 2.25 1
9 2.50 0
10 2.75 1
11 3.00 0
12 3.25 1
13 3.50 0
14 4.00 1
15 4.25 1
16 4.50 1
17 4.75 1
18 5.00 1
19 5.50 1
#特征features
exam2_X = examDf.loc[:,'学习时间']
exam2_y = examDf.loc[:,'通过考试']
#绘制散点图
import matplotlib.pyplot as plt
plt.scatter(exam2_X,exam2_y,color='b',label='exam data')
#添加图标标签
plt.xlabel('Hours') #X轴命名
plt.ylabel('Pass') #Y轴命名
print(plt.show())
3.数据清洗
本案例中数据较为简单，主要是为了介绍逻辑回归的操作过程，此步暂时省略。
4.创建模型
与线性回归创建模型一样，同样利用sklearn中train_test_split方法进行数据分割，将数据随机分成训练数据和测试数据，占比为8:2。
①创建模型
from sklearn.model_selection import train_test_split
#建立训练数据和测试数据
X_train,X_test,y_train,y_test = train_test_split(exam2_X,exam2_y,train_size=0.8) #train_size指训练数据占比
#输出数据大小
print('原始数据特征：',exam2_X.shape,
'训练数据特征：',X_train.shape,
'测试数据特征：',X_test.shape)
print('原始数据标签：',exam2_y.shape,
'训练数据标签：',y_train.shape,
'测试数据标签：',y_test.shape)
原始数据特征： (20,) 训练数据特征： (16,) 测试数据特征： (4,)
原始数据标签： (20,) 训练数据标签： (16,) 测试数据标签： (4,)
#绘制散点图
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=4) #设置图签的位置
plt.xlabel("Hours")
plt.ylabel("Pass")
#显示图像
plt.show()
②训练模型
#第1步：导入逻辑回归
from sklearn.linear_model import LogisticRegression
#第2步：创建模型：逻辑回归
model = LogisticRegression()
X_train = X_train.values.reshape(-1,1)
X_test = X_test.values.reshape(-1,1)
#第3步：训练模型
model.fit(X_train,y_train)
LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
intercept_scaling=1, l1_ratio=None, max_iter=100,
multi_class='warn', n_jobs=None, penalty='l2',
random_state=None, solver='warn', tol=0.0001, verbose=0,
warm_start=False)
5.模型评估
与线性回归不同，线性回归是使用决定系数R平方进行判断，而逻辑回归则是利用准确率进行判断。利用score方法，通过输入测试数据，利用刚才的逻辑回归模型，计算出预测结果。
#评估模型:决定系数
accuracy = model.score(X_test , y_test)
print(accuracy)
0.75
#获取概率值：使用predict_proba方法获取通过考试的概率
#第1个值是标签为0（不通过考试）的概率值，第2个值是标签为1（通过考试）的概率值
print(model.predict_proba([[3]])) #计算学习时间3小时通过考试的概率
[[0.38237083 0.61762917]]
#预测数据：使用模型的predict方法可以进行预测。
pred=model.predict([[3]]) #学习时间3小时通过的概率为61.76%，概率大于0.5，因此预测该学生通过考试，模型应返回结果标签1。
print(pred)
[1]
#计算逻辑回归函数
import numpy as np
#第1步：计算回归方程的z值
#回归方程：z= + x
#截距
a=model.intercept_
#回归系数
b=model.coef_
print('回归方程为：z=%f+%fx'%(a,b))
#第2步：假设学习时间3小时，进一步计算出通过考试概率
x=3
z=a+b*x
y_pred=1/(1+np.exp(-z))
print('预测的概率值：',y_pred)
回归方程为：z=-1.093589+0.524362x
预测的概率值： [[0.61762917]]
小结
通过对回归（regression）和分类（classification）算法的介绍，对两类算法进行简单比较，可发现3点区别。
- 输出数据类型不同：回归为连续数据，分类为离散数据。
- 目的不同：回归目标为找到最优拟合线，分类目标为找到决策面
- 评价方法不同：回归评价方法为决定系数R平方，分类评价方法为准确率。
四、案例：泰坦尼克号生存预测
结合之前介绍的线性回归算法和逻辑回归算法，对经典的泰坦尼克号生存率数据分析案例进行实操。首先，在Kaggle数据平台下载泰坦尼克号案例的分析数据。之后同样按照提出问题、理解数据、数据清洗、构建模型、模型评估的步骤进行分析。
1.提出问题
什么人在泰坦尼克号中更容易存活？
2.理解数据
#导入数据
import numpy as np
import pandas as pd
#训练数据集
trainDf = pd.read_csv(r'C:\Users\gyl21\Desktop\数据分析（高级）（Python）\第4关：机器学习（入门）\3.泰坦尼克号\train.csv')
#测试数据集
testDf = pd.read_csv(r'C:\Users\gyl21\Desktop\数据分析（高级）（Python）\第4关：机器学习（入门）\3.泰坦尼克号\test.csv')
print('训练数据集:',trainDf.shape,'测试数据集：',testDf.shape)
训练数据集: (891, 12) 测试数据集： (418, 11)
#合并数据集，方便同时对两个数据集进行清洗
fullDf = trainDf.append(testDf,ignore_index = True)
print('合并后的数据集：',fullDf.shape)
#读取列标签名称
column_headers = list(fullDf.columns.values)
print('列标签名称：',column_headers)
print(fullDf.head())
合并后的数据集： (1309, 12)
列标签名称： ['Age', 'Cabin', 'Embarked', 'Fare', 'Name', 'Parch', 'PassengerId', 'Pclass', 'Sex', 'SibSp', 'Survived', 'Ticket']
Age Cabin Embarked Fare \
0 22.0 NaN S 7.2500
1 38.0 C85 C 71.2833
2 26.0 NaN S 7.9250
3 35.0 C123 S 53.1000
4 35.0 NaN S 8.0500
Name Parch PassengerId \
0 Braund, Mr. Owen Harris 0 1
1 Cumings, Mrs. John Bradley (Florence Briggs Th... 0 2
2 Heikkinen, Miss. Laina 0 3
3 Futrelle, Mrs. Jacques Heath (Lily May Peel) 0 4
4 Allen, Mr. William Henry 0 5
Pclass Sex SibSp Survived Ticket
0 3 male 1 0.0 A/5 21171
1 1 female 1 1.0 PC 17599
2 3 female 0 1.0 STON/O2. 3101282
3 1 female 1 1.0 113803
4 3 male 0 0.0 373450
观察输出的数据可以发现，将train和test合并之后的数据为一个1309行、12列的数组，包含的11个列标签,分别是Age、Cabin、Embarked、Fare、Name、Parch、PassengerId、Sex、SibSp、Survived、Ticket，为了方便记忆和使用，可创建一个字典方便查询。
columnDisc = {'Age':'年龄','Cabin':'客舱号','Embarked':'登船港口(S-英国，C-法国，Q-爱尔兰)','Fare':'船票价格','Name':'姓名',
'Parch':'不同代直系亲属数（在船上的父母及子女数）','PassengerId':'乘客编号','Pclass':'客舱等级','Sex':'性别',
'SibSp':'同代直系亲属数（在船上的兄弟姐妹及配偶数）','Survived':'生存情况','Ticket':'船票编号'}
print(columnDisc)
{'Age': '年龄', 'Cabin': '客舱号', 'Embarked': '登船港口(S-英国，C-法国，Q-爱尔兰)', 'Fare': '船票价格', 'Name': '姓名', 'Parch': '不同代直系亲属数（在船上的父母及子女数）', 'PassengerId': '乘客编号', 'Pclass': '客舱等级', 'Sex': '性别', 'SibSp': '同代直系亲属数（在船上的兄弟姐妹及配偶数）', 'Survived': '生存情况', 'Ticket': '船票编号'}
#获取数据类型列的描述统计信息
print(fullDf.describe())
Age Fare Parch PassengerId Pclass \
count 1046.000000 1308.000000 1309.000000 1309.000000 1309.000000
mean 29.881138 33.295479 0.385027 655.000000 2.294882
std 14.413493 51.758668 0.865560 378.020061 0.837836
min 0.170000 0.000000 0.000000 1.000000 1.000000
25% 21.000000 7.895800 0.000000 328.000000 2.000000
50% 28.000000 14.454200 0.000000 655.000000 3.000000
75% 39.000000 31.275000 0.000000 982.000000 3.000000
max 80.000000 512.329200 9.000000 1309.000000 3.000000
SibSp Survived
count 1309.000000 891.000000
mean 0.498854 0.383838
std 1.041658 0.486592
min 0.000000 0.000000
25% 0.000000 0.000000
50% 0.000000 0.000000
75% 1.000000 1.000000
max 8.000000 1.000000
#查看每一列的数据类型和数据总数
print(fullDf.info())
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1309 entries, 0 to 1308
Data columns (total 12 columns):
Age 1046 non-null float64
Cabin 295 non-null object
Embarked 1307 non-null object
Fare 1308 non-null float64
Name 1309 non-null object
Parch 1309 non-null int64
PassengerId 1309 non-null int64
Pclass 1309 non-null int64
Sex 1309 non-null object
SibSp 1309 non-null int64
Survived 891 non-null float64
Ticket 1309 non-null object
dtypes: float64(3), int64(4), object(5)
memory usage: 122.8+ KB
3.数据清洗
通过info()查看每一列的数据类型和数据总数，可以发现数据总行数为1309行，其中Age、Cabin、Embarked、Fare、Survived5列有缺失数据，其中Age、Cabin、Embarked、Fare需对缺失数据进行补充，而Survived是需要进行预测的数据。
（1）数据预处理
缺失值处理
#数据类型缺失值处理
#年龄（Age）列通过平均年龄进行填充
fullDf['Age']=fullDf['Age'].fillna(fullDf['Age'].mean())
#船票价格（Fare）列通过平均价格进行填充
fullDf['Fare']=fullDf['Fare'].fillna(fullDf['Fare'].mean())
'''
登船港口（Embarked）列通过查看其中列中的数量最多者进行补充。
通过value_counts()查询出Embarked列中的不同值数量，发现最多的值为S。
利用S进行补充。
'''
print(fullDf.loc[:,'Embarked'].value_counts())
fullDf['Embarked']=fullDf['Embarked'].fillna('S')
S 914
C 270
Q 123
Name: Embarked, dtype: int64
#船舱号（Cabin）：因缺失数据较多，船舱号（Cabin）缺失值填充为U，表示未知（Unknow）
fullDf['Cabin']=fullDf['Cabin'].fillna('U')
print(fullDf.info())
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1309 entries, 0 to 1308
Data columns (total 12 columns):
Age 1309 non-null float64
Cabin 1309 non-null object
Embarked 1309 non-null object
Fare 1309 non-null float64
Name 1309 non-null object
Parch 1309 non-null int64
PassengerId 1309 non-null int64
Pclass 1309 non-null int64
Sex 1309 non-null object
SibSp 1309 non-null int64
Survived 891 non-null float64
Ticket 1309 non-null object
dtypes: float64(3), int64(4), object(5)
memory usage: 122.8+ KB
None
（2）特征提取
①数据分类
查看数据类型，通常数据类型可分为数值数据、分类数据、时间序列3类。其中数值数据可直接使用，时间序列可转化为年月日，分类数据需用数值进行代替，并进行One-hot编码，One-Hot编码，又称为一位有效编码，主要是采用N位状态寄存器来对N个状态进行编码，N的大小通常要大于2时，才会用到。例如Embarked中包含了S、C、Q3种类型，这时需要针对不同的类型新建一列表格，这一列的表格就好像是一个容器，每一个容器中只装入这一种类型的信息，并用1和0表示，1表示有，零表示没有。如下图所示，其中Embarked_Q、Embarked_S、Embarked_C就是新创建的容器，也称为虚拟变量。
在本案例中，可将分类数据进一步分类，分为有直接类别的数据和字符串类型数据。
有直接类别的数据： 乘客性别（Sex）：男性male，女性female 登船港口（Embarked）：出发地点：S=英国南安普顿Southampton；途径地点1：C=法国 瑟堡市Cherbourg；出发地点2：Q=爱尔兰 昆士敦Queenstown * 客舱等级（Pclass）：1=1等舱，2=2等舱，3=3等舱
字符串类型数据：
- 乘客姓名（Name）
- 客舱号（Cabin）
- 家庭类别（Parch、SipSb）
分类数据：有直接类别的数据
性别(Sex)
#查看性别数据列
print(fullDf['Sex'].head())
0 male
1 female
2 female
3 female
4 male
Name: Sex, dtype: object
#将性别的值映射为数值，男性（male）对应数值1，女型（female）对应数值0
sex_mapDict = {'male':1,'female':0}
#map函数：对指定序列做映射，将male和female分别映射为1和0
fullDf['Sex']=fullDf['Sex'].map(sex_mapDict)
print(fullDf['Sex'].head())
0 1
1 0
2 0
3 0
4 1
Name: Sex, dtype: int64
登船港口（Embarked）
#查看该类数据内容
print(fullDf['Embarked'].head())
0 S
1 C
2 S
3 S
4 S
Name: Embarked, dtype: object
#存放提取后的特征
embarkedDf = pd.DataFrame()
#使用get_dummies进行one-hot编码，产生虚拟变量（dummy variables），列名前缀是Embarked
embarkedDf = pd.get_dummies(fullDf['Embarked'],prefix='Embarked')
print(embarkedDf.head())
Embarked_C Embarked_Q Embarked_S
0 0 0 1
1 1 0 0
2 0 0 1
3 0 0 1
4 0 0 1
#添加one-hot编码产生的虚拟变量（dummy variables）到泰坦尼克号数据集full
fullDf = pd.concat([fullDf,embarkedDf],axis=1)
'''
因为已经使用登船港口(Embarked)进行了one-hot编码产生了它的虚拟变量（dummy variables）
所以这里把登船港口(Embarked)删掉
'''
#使用drop删除列
fullDf.drop('Embarked',axis=1,inplace=True)
print(fullDf.head())
Age Cabin Fare Name \
0 22.0 U 7.2500 Braund, Mr. Owen Harris
1 38.0 C85 71.2833 Cumings, Mrs. John Bradley (Florence Briggs Th...
2 26.0 U 7.9250 Heikkinen, Miss. Laina
3 35.0 C123 53.1000 Futrelle, Mrs. Jacques Heath (Lily May Peel)
4 35.0 U 8.0500 Allen, Mr. William Henry
Parch PassengerId Pclass Sex SibSp Survived Ticket \
0 0 1 3 1 1 0.0 A/5 21171
1 0 2 1 0 1 1.0 PC 17599
2 0 3 3 0 0 1.0 STON/O2. 3101282
3 0 4 1 0 1 1.0 113803
4 0 5 3 1 0 0.0 373450
Embarked_C Embarked_Q Embarked_S
0 0 0 1
1 1 0 0
2 0 0 1
3 0 0 1
4 0 0 1
客舱等级（Pclass）
'''
客舱等级(Pclass):
1=1等舱，2=2等舱，3=3等舱
'''
#存放提取后的特征
pclassDf = pd.DataFrame()
#使用get_dummies进行one-hot编码，列名前缀是Pclass
pclassDf = pd.get_dummies( fullDf['Pclass'] , prefix='Pclass' )
print(pclassDf.head())
Pclass_1 Pclass_2 Pclass_3
0 0 0 1
1 1 0 0
2 0 0 1
3 1 0 0
4 0 0 1
#添加one-hot编码，将产生的类别加入泰坦尼克号数据集fullDf
fullDf = pd.concat([fullDf,pclassDf],axis=1)
#删掉客舱等级（Pclass）这一列
fullDf.drop('Pclass',axis=1,inplace=True)
print(fullDf.head())
Age Cabin Fare Name \
0 22.0 U 7.2500 Braund, Mr. Owen Harris
1 38.0 C85 71.2833 Cumings, Mrs. John Bradley (Florence Briggs Th...
2 26.0 U 7.9250 Heikkinen, Miss. Laina
3 35.0 C123 53.1000 Futrelle, Mrs. Jacques Heath (Lily May Peel)
4 35.0 U 8.0500 Allen, Mr. William Henry
Parch PassengerId Sex SibSp Survived Ticket Embarked_C \
0 0 1 1 1 0.0 A/5 21171 0
1 0 2 0 1 1.0 PC 17599 1
2 0 3 0 0 1.0 STON/O2. 3101282 0
3 0 4 0 1 1.0 113803 0
4 0 5 1 0 0.0 373450 0
Embarked_Q Embarked_S Pclass_1 Pclass_2 Pclass_3
0 0 1 0 0 1
1 0 0 1 0 0
2 0 1 0 0 1
3 0 1 1 0 0
4 0 1 0 0 1
分类数据：字符串类型数据
姓名(Name)
通过观察数据，可以发现名字一列中，包含有Mr、Mrs、Miss、Master的称呼。在国外，这些称谓都有特定的用法，不是一概而论的，所以需要将这些称呼进行分类。
#定义函数，从姓名中获取头衔。数据中Name一列的格式为：名+ ',' + 称为 + '.' + 姓
def getTitle(name):
str1 = name.split(',')[1]
str2 = str1.split('.')[0]
#strip()方法用于移除字符串头尾指定的字符
str3 = str2.strip()
return str3
#存放提取后的特征
titleDf = pd.DataFrame()
titleDf['Title'] = fullDf['Name'].map(getTitle)
print(titleDf.head())
Title
0 Mr
1 Mrs
2 Miss
3 Mrs
4 Mr
#姓名中头衔字符串与定义头衔类别的映射关系
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函数：对指定序列做映射
titleDf['Title'] = titleDf['Title'].map(title_mapDict)
#使用get_dummies进行one-hot编码，产生虚拟变量（dummy variables），列名前缀是Embarked
titleDf = pd.get_dummies(titleDf['Title'])
print(titleDf.head())
Master Miss Mr Mrs Officer Royalty
0 0 0 1 0 0 0
1 0 0 0 1 0 0
2 0 1 0 0 0 0
3 0 0 0 1 0 0
4 0 0 1 0 0 0
#添加one-hot编码，将产生的类别加入泰坦尼克号数据集fullDf
fullDf = pd.concat([fullDf,titleDf],axis=1)
#删掉姓名（Name）这一列
fullDf.drop('Name',axis=1,inplace=True)
print(fullDf.head())
Age Cabin Fare Parch PassengerId Sex SibSp Survived \
0 22.0 U 7.2500 0 1 1 1 0.0
1 38.0 C85 71.2833 0 2 0 1 1.0
2 26.0 U 7.9250 0 3 0 0 1.0
3 35.0 C123 53.1000 0 4 0 1 1.0
4 35.0 U 8.0500 0 5 1 0 0.0
Ticket Embarked_C ... Embarked_S Pclass_1 Pclass_2 \
0 A/5 21171 0 ... 1 0 0
1 PC 17599 1 ... 0 1 0
2 STON/O2. 3101282 0 ... 1 0 0
3 113803 0 ... 1 1 0
4 373450 0 ... 1 0 0
Pclass_3 Master Miss Mr Mrs Officer Royalty
0 1 0 0 1 0 0 0
1 0 0 0 0 1 0 0
2 1 0 1 0 0 0 0
3 0 0 0 0 1 0 0
4 1 0 0 1 0 0 0
[5 rows x 21 columns]
客舱(Cabin)
#查看客舱号的内容
print(fullDf['Cabin'].head())
0 U
1 C85
2 U
3 C123
4 U
Name: Cabin, dtype: object
观察客舱号，可以发现有A、B、C、D…U等类型，同样可以进行分类。
#存放客舱号信息
cabinDf = pd.DataFrame()
#利用lambda匿名函数，提取Cabin列中的第一个字母。lambda的格式为 参数1，参数2：函数体或者表达式。例如sum = lambda a,b: a + b
fullDf[ 'Cabin' ] = fullDf[ 'Cabin' ].map( lambda c : c[0] )
##使用get_dummies进行one-hot编码，列名前缀是Cabin
cabinDf = pd.get_dummies( fullDf['Cabin'] , prefix = 'Cabin' )
print(cabinDf.head())
Cabin_A Cabin_B Cabin_C Cabin_D Cabin_E Cabin_F Cabin_G Cabin_T \
0 0 0 0 0 0 0 0 0
1 0 0 1 0 0 0 0 0
2 0 0 0 0 0 0 0 0
3 0 0 1 0 0 0 0 0
4 0 0 0 0 0 0 0 0
Cabin_U
0 1
1 0
2 1
3 0
4 1
#添加one-hot编码，将产生的类别加入泰坦尼克号数据集fullDf
fullDf = pd.concat([fullDf,cabinDf],axis=1)
#删掉客舱号（Cabin）这一列
fullDf.drop('Cabin',axis=1,inplace=True)
print(fullDf.head())
Age Fare Parch PassengerId Sex SibSp Survived Ticket \
0 22.0 7.2500 0 1 1 1 0.0 A/5 21171
1 38.0 71.2833 0 2 0 1 1.0 PC 17599
2 26.0 7.9250 0 3 0 0 1.0 STON/O2. 3101282
3 35.0 53.1000 0 4 0 1 1.0 113803
4 35.0 8.0500 0 5 1 0 0.0 373450
Embarked_C Embarked_Q ... Royalty Cabin_A Cabin_B Cabin_C Cabin_D \
0 0 0 ... 0 0 0 0 0
1 1 0 ... 0 0 0 1 0
2 0 0 ... 0 0 0 0 0
3 0 0 ... 0 0 0 1 0
4 0 0 ... 0 0 0 0 0
Cabin_E Cabin_F Cabin_G Cabin_T Cabin_U
0 0 0 0 0 1
1 0 0 0 0 0
2 0 0 0 0 1
3 0 0 0 0 0
4 0 0 0 0 1
[5 rows x 29 columns]
家庭类别(Parch、SipSb)
在Parch和SibSp两列中，分别表示同代直系亲属数和不同代直系亲属数，可以将这两列的数量进行合并，得到家庭成员数据，并根据数量划分家庭类别。
#存放家庭信息
familyDf = pd.DataFrame()
familyDf['FamilySize'] = fullDf[ 'Parch' ] + fullDf[ 'SibSp' ] + 1#家庭人数=同代直系亲属数（Parch）+不同代直系亲属数（SibSp）+乘客自己
'''
家庭类别：
小家庭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 )
print(familyDf.head())
FamilySize Family_Single Family_Small Family_Large
0 2 0 1 0
1 2 0 1 0
2 1 1 0 0
3 2 0 1 0
4 1 1 0 0
#添加one-hot编码，将产生的类别加入泰坦尼克号数据集fullDf
fullDf = pd.concat([fullDf,familyDf],axis=1)
print(fullDf.head())
Age Fare Parch PassengerId Sex SibSp Survived Ticket \
0 22.0 7.2500 0 1 1 1 0.0 A/5 21171
1 38.0 71.2833 0 2 0 1 1.0 PC 17599
2 26.0 7.9250 0 3 0 0 1.0 STON/O2. 3101282
3 35.0 53.1000 0 4 0 1 1.0 113803
4 35.0 8.0500 0 5 1 0 0.0 373450
Embarked_C Embarked_Q ... Cabin_D Cabin_E Cabin_F Cabin_G Cabin_T \
0 0 0 ... 0 0 0 0 0
1 1 0 ... 0 0 0 0 0
2 0 0 ... 0 0 0 0 0
3 0 0 ... 0 0 0 0 0
4 0 0 ... 0 0 0 0 0
Cabin_U FamilySize Family_Single Family_Small Family_Large
0 1 2 0 1 0
1 0 2 0 1 0
2 1 1 1 0 0
3 0 2 0 1 0
4 1 1 1 0 0
[5 rows x 33 columns]
#查看目前的数据结构
print(fullDf.shape)
(1309, 33)
（3）特征选择
数据和特征决定了机器学习的上限，而模型和算法只是逼近这个上限而已。因此，如何去选择已经提取出来的特征，将影响到最终的评价结果。下面使用相关系数法，计算各个特征的相关系数，根据计算结果进行特征选择。
#相关型矩阵
corrDf = fullDf.corr()
print(corrDf)
Age Fare Parch PassengerId Sex SibSp \
Age 1.000000 0.171521 -0.130872 0.025731 0.057397 -0.190747
Fare 0.171521 1.000000 0.221522 0.031416 -0.185484 0.160224
Parch -0.130872 0.221522 1.000000 0.008942 -0.213125 0.373587
PassengerId 0.025731 0.031416 0.008942 1.000000 0.013406 -0.055224
Sex 0.057397 -0.185484 -0.213125 0.013406 1.000000 -0.109609
SibSp -0.190747 0.160224 0.373587 -0.055224 -0.109609 1.000000
Survived -0.070323 0.257307 0.081629 -0.005007 -0.543351 -0.035322
Embarked_C 0.076179 0.286241 -0.008635 0.048101 -0.066564 -0.048396
Embarked_Q -0.012718 -0.130054 -0.100943 0.011585 -0.088651 -0.048678
Embarked_S -0.059153 -0.169894 0.071881 -0.049836 0.115193 0.073709
Pclass_1 0.362587 0.599956 -0.013033 0.026495 -0.107371 -0.034256
Pclass_2 -0.014193 -0.121372 -0.010057 0.022714 -0.028862 -0.052419
Pclass_3 -0.302093 -0.419616 0.019521 -0.041544 0.116562 0.072610
Master -0.363923 0.011596 0.253482 0.002254 0.164375 0.329171
Miss -0.254146 0.092051 0.066473 -0.050027 -0.672819 0.077564
Mr 0.165476 -0.192192 -0.304780 0.014116 0.870678 -0.243104
Mrs 0.198091 0.139235 0.213491 0.033299 -0.571176 0.061643
Officer 0.162818 0.028696 -0.032631 0.002231 0.087288 -0.013813
Royalty 0.059466 0.026214 -0.030197 0.004400 -0.020408 -0.010787
Cabin_A 0.125177 0.020094 -0.030707 -0.002831 0.047561 -0.039808
Cabin_B 0.113458 0.393743 0.073051 0.015895 -0.094453 -0.011569
Cabin_C 0.167993 0.401370 0.009601 0.006092 -0.077473 0.048616
Cabin_D 0.132886 0.072737 -0.027385 0.000549 -0.057396 -0.015727
Cabin_E 0.106600 0.073949 0.001084 -0.008136 -0.040340 -0.027180
Cabin_F -0.072644 -0.037567 0.020481 0.000306 -0.006655 -0.008619
Cabin_G -0.085977 -0.022857 0.058325 -0.045949 -0.083285 0.006015
Cabin_T 0.032461 0.001179 -0.012304 -0.023049 0.020558 -0.013247
Cabin_U -0.271918 -0.507197 -0.036806 0.000208 0.137396 0.009064
FamilySize -0.196996 0.226465 0.792296 -0.031437 -0.188583 0.861952
Family_Single 0.116675 -0.274826 -0.549022 0.028546 0.284537 -0.591077
Family_Small -0.038189 0.197281 0.248532 0.002975 -0.255196 0.253590
Family_Large -0.161210 0.170853 0.624627 -0.063415 -0.077748 0.699681
Survived Embarked_C Embarked_Q Embarked_S ... Cabin_D \
Age -0.070323 0.076179 -0.012718 -0.059153 ... 0.132886
Fare 0.257307 0.286241 -0.130054 -0.169894 ... 0.072737
Parch 0.081629 -0.008635 -0.100943 0.071881 ... -0.027385
PassengerId -0.005007 0.048101 0.011585 -0.049836 ... 0.000549
Sex -0.543351 -0.066564 -0.088651 0.115193 ... -0.057396
SibSp -0.035322 -0.048396 -0.048678 0.073709 ... -0.015727
Survived 1.000000 0.168240 0.003650 -0.149683 ... 0.150716
Embarked_C 0.168240 1.000000 -0.164166 -0.778262 ... 0.107782
Embarked_Q 0.003650 -0.164166 1.000000 -0.491656 ... -0.061459
Embarked_S -0.149683 -0.778262 -0.491656 1.000000 ... -0.056023
Pclass_1 0.285904 0.325722 -0.166101 -0.181800 ... 0.275698
Pclass_2 0.093349 -0.134675 -0.121973 0.196532 ... -0.037929
Pclass_3 -0.322308 -0.171430 0.243706 -0.003805 ... -0.207455
Master 0.085221 -0.014172 -0.009091 0.018297 ... -0.042192
Miss 0.332795 -0.014351 0.198804 -0.113886 ... -0.012516
Mr -0.549199 -0.065538 -0.080224 0.108924 ... -0.030261
Mrs 0.344935 0.098379 -0.100374 -0.022950 ... 0.080393
Officer -0.031316 0.003678 -0.003212 -0.001202 ... 0.006055
Royalty 0.033391 0.077213 -0.021853 -0.054250 ... -0.012950
Cabin_A 0.022287 0.094914 -0.042105 -0.056984 ... -0.024952
Cabin_B 0.175095 0.161595 -0.073613 -0.095790 ... -0.043624
Cabin_C 0.114652 0.158043 -0.059151 -0.101861 ... -0.053083
Cabin_D 0.150716 0.107782 -0.061459 -0.056023 ... 1.000000
Cabin_E 0.145321 0.027566 -0.042877 0.002960 ... -0.034317
Cabin_F 0.057935 -0.020010 -0.020282 0.030575 ... -0.024369
Cabin_G 0.016040 -0.031566 -0.019941 0.040560 ... -0.011817
Cabin_T -0.026456 -0.014095 -0.008904 0.018111 ... -0.005277
Cabin_U -0.316912 -0.258257 0.142369 0.137351 ... -0.353822
FamilySize 0.016639 -0.036553 -0.087190 0.087771 ... -0.025313
Family_Single -0.203367 -0.107874 0.127214 0.014246 ... -0.074310
Family_Small 0.279855 0.159594 -0.122491 -0.062909 ... 0.102432
Family_Large -0.125147 -0.092825 -0.018423 0.093671 ... -0.049336
Cabin_E Cabin_F Cabin_G Cabin_T Cabin_U FamilySize \
Age 0.106600 -0.072644 -0.085977 0.032461 -0.271918 -0.196996
Fare 0.073949 -0.037567 -0.022857 0.001179 -0.507197 0.226465
Parch 0.001084 0.020481 0.058325 -0.012304 -0.036806 0.792296
PassengerId -0.008136 0.000306 -0.045949 -0.023049 0.000208 -0.031437
Sex -0.040340 -0.006655 -0.083285 0.020558 0.137396 -0.188583
SibSp -0.027180 -0.008619 0.006015 -0.013247 0.009064 0.861952
Survived 0.145321 0.057935 0.016040 -0.026456 -0.316912 0.016639
Embarked_C 0.027566 -0.020010 -0.031566 -0.014095 -0.258257 -0.036553
Embarked_Q -0.042877 -0.020282 -0.019941 -0.008904 0.142369 -0.087190
Embarked_S 0.002960 0.030575 0.040560 0.018111 0.137351 0.087771
Pclass_1 0.242963 -0.073083 -0.035441 0.048310 -0.776987 -0.029656
Pclass_2 -0.050210 0.127371 -0.032081 -0.014325 0.176485 -0.039976
Pclass_3 -0.169063 -0.041178 0.056964 -0.030057 0.527614 0.058430
Master 0.001860 0.058311 -0.013690 -0.006113 0.041178 0.355061
Miss 0.008700 -0.003088 0.061881 -0.013832 -0.004364 0.087350
Mr -0.032953 -0.026403 -0.072514 0.023611 0.131807 -0.326487
Mrs 0.045538 0.013376 0.042547 -0.011742 -0.162253 0.157233
Officer -0.024048 -0.017076 -0.008281 -0.003698 -0.067030 -0.026921
Royalty -0.012202 -0.008665 -0.004202 -0.001876 -0.071672 -0.023600
Cabin_A -0.023510 -0.016695 -0.008096 -0.003615 -0.242399 -0.042967
Cabin_B -0.041103 -0.029188 -0.014154 -0.006320 -0.423794 0.032318
Cabin_C -0.050016 -0.035516 -0.017224 -0.007691 -0.515684 0.037226
Cabin_D -0.034317 -0.024369 -0.011817 -0.005277 -0.353822 -0.025313
Cabin_E 1.000000 -0.022961 -0.011135 -0.004972 -0.333381 -0.017285
Cabin_F -0.022961 1.000000 -0.007907 -0.003531 -0.236733 0.005525
Cabin_G -0.011135 -0.007907 1.000000 -0.001712 -0.114803 0.035835
Cabin_T -0.004972 -0.003531 -0.001712 1.000000 -0.051263 -0.015438
Cabin_U -0.333381 -0.236733 -0.114803 -0.051263 1.000000 -0.014155
FamilySize -0.017285 0.005525 0.035835 -0.015438 -0.014155 1.000000
Family_Single -0.042535 0.004055 -0.076397 0.022411 0.175812 -0.688864
Family_Small 0.068007 0.012756 0.087471 -0.019574 -0.211367 0.302640
Family_Large -0.046485 -0.033009 -0.016008 -0.007148 0.056438 0.801623
Family_Single Family_Small Family_Large
Age 0.116675 -0.038189 -0.161210
Fare -0.274826 0.197281 0.170853
Parch -0.549022 0.248532 0.624627
PassengerId 0.028546 0.002975 -0.063415
Sex 0.284537 -0.255196 -0.077748
SibSp -0.591077 0.253590 0.699681
Survived -0.203367 0.279855 -0.125147
Embarked_C -0.107874 0.159594 -0.092825
Embarked_Q 0.127214 -0.122491 -0.018423
Embarked_S 0.014246 -0.062909 0.093671
Pclass_1 -0.126551 0.165965 -0.067523
Pclass_2 -0.035075 0.097270 -0.118495
Pclass_3 0.138250 -0.223338 0.155560
Master -0.265355 0.120166 0.301809
Miss -0.023890 -0.018085 0.083422
Mr 0.386262 -0.300872 -0.194207
Mrs -0.354649 0.361247 0.012893
Officer 0.013303 0.003966 -0.034572
Royalty 0.008761 -0.000073 -0.017542
Cabin_A 0.045227 -0.029546 -0.033799
Cabin_B -0.087912 0.084268 0.013470
Cabin_C -0.137498 0.141925 0.001362
Cabin_D -0.074310 0.102432 -0.049336
Cabin_E -0.042535 0.068007 -0.046485
Cabin_F 0.004055 0.012756 -0.033009
Cabin_G -0.076397 0.087471 -0.016008
Cabin_T 0.022411 -0.019574 -0.007148
Cabin_U 0.175812 -0.211367 0.056438
FamilySize -0.688864 0.302640 0.801623
Family_Single 1.000000 -0.873398 -0.318944
Family_Small -0.873398 1.000000 -0.183007
Family_Large -0.318944 -0.183007 1.000000
[32 rows x 32 columns]
#查看各个特征与生存情况（Survived）的相关系数
corrDf['Survived'].sort_values(ascending=False) #ascending=False表示降序排列
Survived 1.000000
Mrs 0.344935
Miss 0.332795
Pclass_1 0.285904
Family_Small 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_Single -0.203367
Cabin_U -0.316912
Pclass_3 -0.322308
Sex -0.543351
Mr -0.549199
Name: Survived, dtype: float64
通过观察不同特征与生成情况（Survived）的相关系数大小可以发现，头衔（Mrs、Miss）、客舱等级（Pclass_1）、家庭大小（Family_Small）、船票价格（Fare）、船舱号（Cabin_B）和登船港口（Embarked_C）有较强的正线性相关性；登船港口（Embarked_S）、家庭大小（Family_Single、Family_Large）、船舱号（Cabin_U）、客舱等级（Pclass_3）、头衔（Mr）、性别（Sex）有较强的负线性相关性，因此选择选择头衔（titleDf）、客舱等级（pclassDf）、家庭大小（familyDf）、船票价格（Fare）、船舱号（cabinDf）、登船港口（embarkedDf）、性别（Sex）这几个特征。
#特征选择
full_X = pd.concat( [titleDf,#头衔
pclassDf,#客舱等级
familyDf,#家庭大小
fullDf['Fare'],#船票价格
cabinDf,#船舱号
embarkedDf,#登船港口
fullDf['Sex']#性别
] , axis=1 )
print(full_X.head())
print(full_X.shape)
print(fullDf.shape)
Master Miss Mr Mrs Officer Royalty Pclass_1 Pclass_2 Pclass_3 \
0 0 0 1 0 0 0 0 0 1
1 0 0 0 1 0 0 1 0 0
2 0 1 0 0 0 0 0 0 1
3 0 0 0 1 0 0 1 0 0
4 0 0 1 0 0 0 0 0 1
FamilySize ... Cabin_D Cabin_E Cabin_F Cabin_G Cabin_T Cabin_U \
0 2 ... 0 0 0 0 0 1
1 2 ... 0 0 0 0 0 0
2 1 ... 0 0 0 0 0 1
3 2 ... 0 0 0 0 0 0
4 1 ... 0 0 0 0 0 1
Embarked_C Embarked_Q Embarked_S Sex
0 0 0 1 1
1 1 0 0 0
2 0 0 1 0
3 0 0 1 0
4 0 0 1 1
[5 rows x 27 columns]
(1309, 27)
(1309, 33)
4.构建模型
（1）创建模型
将项目所给的数据有train.csv数据和test.csv数据。因为坦尼克号测试数据集是我们最后要提交给Kaggle的结果，里面没有生存情况的值，所以不能用于评估模型。于是我们将train.csv数据设置为原始数据，test.csv数据设置为预测数据，利用原始数据（train.csv）创建模型。按照之前已经介绍过的sklearn中train_test_split方法进行数据分割，将数据随机分成训练数据和测试数据，占比为8:2。
num = fullDf['Survived'].isna().sum()
print(num)
418
#训练数据集有891行
sourceRow = 891
#原始数据集：特征
source_X = full_X.loc[0:sourceRow-1,:]#从特征集合full_X中提取原始数据集前891行数据时，需减去1，因为行号是从0开始
#原始数据集：标签
source_y = fullDf.loc[0:sourceRow-1,'Survived']
#预测数据集：特征
pred_X = full_X.loc[sourceRow:,:]#前891行是测试数据集，891行之后的是预测数据集
#原始数据集有多少行
print('原始数据集有多少行:',source_X.shape[0])
#预测数据集大小
print('预测数据集有多少行:',pred_X.shape[0])
原始数据集有多少行: 891
预测数据集有多少行: 418
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)
原始数据集特征： (891, 27) 训练数据集特征： (712, 27) 测试数据集特征： (179, 27)
原始数据集标签： (891,) 训练数据集标签： (712,) 测试数据集标签： (179,)
#原始数据查看
source_y.head()
0 0.0
1 1.0
2 1.0
3 1.0
4 0.0
Name: Survived, dtype: float64
（2）训练模型
因为最终得出的Survived数据为非连续性数据，使用逻辑回归算法进行训练。
#第1步：导入逻辑回归
from sklearn.linear_model import LogisticRegression
#第2步：创建模型：逻辑回归
model = LogisticRegression()
#第3步：训练模型
model.fit(train_X , train_y)
LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
intercept_scaling=1, l1_ratio=None, max_iter=100,
multi_class='warn', n_jobs=None, penalty='l2',
random_state=None, solver='warn', tol=0.0001, verbose=0,
warm_start=False)
5.模型评估
# 分类问题，score得到的是模型的正确率
model.score(test_X , test_y )
0.7877094972067039
6.实施方案
使用预测数据集进行预测，并保存到csv文件中，之后上传到Kaggle查看排名。
#使用机器学习模型，对预测数据集中的生存情况进行预测
pred_y = model.predict(pred_X)
#生成的预测值是浮点数,但是Kaggle要求提交的结果是整型,所以要对数据类型进行转换
pred_y = pred_y.astype(int)
#乘客id
passenger_id = fullDf.loc[sourceRow:,'PassengerId']
#数据框：乘客id，预测生存情况的值
predDf = pd.DataFrame(
{ 'PassengerId': passenger_id ,
'Survived': pred_y } )
print(predDf.shape)
print(predDf.head())
#保存结果
predDf.to_csv('titanic_pred.csv',index = False)
(418, 2)
PassengerId Survived
891 892 0
892 893 1
893 894 0
894 895 0
895 896 1
上传预测数据
点击头像中的My Profie，便可以查看当前的排名。
五、总结
1.常用的机器学习有监督学习 （supervised learning）、非监督学习（ unsupervised learning）、半监督学习 （semi-supervised learning）、强化学习 （reinforcement learning）。
2.介绍了简单线性回归与逻辑回归两种方法，按照提出问题、理解数据、数据清洗、构建模型、模型评估的步骤进行分析。
3.通过实践泰坦尼克号生存预测案例，进一步了解了数据预处理、特征提取、特征选择内容**。**
以上就是今天的全部内容分享，觉得有用的话欢迎点赞收藏哦！
Python经验分享
学好 Python 不论是用于就业还是做副业赚钱都不错，而且学好Python还能契合未来发展趋势——人工智能、机器学习、深度学习等。
小编是一名Python开发工程师，自己整理了一套最新的Python系统学习教程，包括从基础的python脚本到web开发、爬虫、数据分析、数据可视化、机器学习等。如果你也喜欢编程，想通过学习Python转行、做副业或者提升工作效率，这份【最新全套Python学习资料】 一定对你有用！
小编为对Python感兴趣的小伙伴准备了以下籽料 ！
对于0基础小白入门：
如果你是零基础小白，想快速入门Python是可以考虑培训的！
- 学习时间相对较短，学习内容更全面更集中
- 可以找到适合自己的学习方案
包括：Python激活码+安装包、Python web开发，Python爬虫，Python数据分析，人工智能、机器学习、Python量化交易等学习教程。带你从零基础系统性的学好Python！
一、Python所有方向的学习路线
Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
二、学习软件
工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。
三、入门学习视频
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。
四、实战案例
光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
五、面试资料
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
最新全套【Python入门到进阶资料 & 实战源码 &安装工具】（安全链接，放心点击）
我已经上传至CSDN官方，如果需要可以扫描下方官方二维码免费获取【保证100%免费】
*今天的分享就到这里，喜欢且对你有所帮助的话，记得点赞关注哦~下回见 ！
旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。
更多推荐
25
1- 0
已为社区贡献14条内容
所有评论(0)