实例-预测泰坦尼克号幸存者、乳腺癌检测

一、预测泰坦尼克号幸存者

泰坦尼克号是历史上最严重的一起海难事故的主角。我们通过决策树模型，来预测哪些人可能成为幸存者。
数据集中总共有两个文件，都是csv格式的数据。其中，train. csv 训练数据集，包含己标注的训练样本数据。 test.csv 是我们的模型要进行幸存者预测的数据。我们的任务就是根据train.csv 里的数据训练模型来，然后使用这个模型来预测 test.csv 里的数据，最后把预测结果提交到 kaggle com上。

1.数据分析

train.csv是一个892行、12列的数据表格。意味着我们有891个训练样本（ 除表头），每个样本有 12 个特征，我们需要先分析这些特征，以便决定哪个特征可以用来进行模型训练。

•Passengerld ：乘客的ID号，这是个顺序编号，用来唯一地标识一名乘客。这个特征和幸存与否无关，我们不使用这个特征
•Survived : 1表示幸存，0表示遇难。这个是我们的标注数据。
•Pclass ：仓位等级，是很重要的特征。高仓位等级的乘客能更快地到达甲板，从而更容易获救。
•Name ：乘客名字，这个特征和幸存与否无关，我们会丢弃这个特征。
•Sex ：乘客性别，由于救生艇数量不够，船民让妇女和儿童先上救生艇。所以这也是个很重要的特征
•Age ：乘客年龄。
•SibSp 兄弟姐妹同在船上的数量。
•Parch ：同船的父辈人员数量。
•Ticket:乘客票号。我们不使用这个特征。
• Fare ：乘客的体热指标
• Cabin ：乘客所在的船舱号。实际上这个特征和幸存与否有一定的关系，比如最早被水淹没的船舱位置，其乘客的幸存概率要低 但由于这个特征有大 的丢失
数据，而且没有更多的数据来对船舱进行归类，因此我们丢弃这个特征的数据。
• Embarked ：乘客登船的港口。我们需要把港口数据转换为数值型数据。
我们需要加载 csv 数据，并做 些预处理，包括：
•提取 Survived 列的数据作为模型的标注数据。
•丢弃不需要的特征数据。
•对数据进行转换，以便模型处理。比如性别数据，我们需要转换为0和1。
•处理缺失数据。比如年龄这个特征，有很多缺失的数据。
pandas 是完成这些任务的理想软件包。我们先把数据从文件里读取出来：

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

def read_dataset(fname):
    # 指定第一列作为行索引
    data = pd.read_csv(fname, index_col=0) 
    # 丢弃无用的数据
    data.drop(['Name', 'Ticket', 'Cabin'], axis=1, inplace=True)
    # 处理性别数据
    data['Sex'] = (data['Sex'] == 'male').astype('int')
    # 处理登船港口数据
    labels = data['Embarked'].unique().tolist()
    data['Embarked'] = data['Embarked'].apply(lambda n: labels.index(n))
    # 处理缺失数据(填充缺失数据为0)
    data = data.fillna(0)
    # 将处理后的数据集返回
    return data

# 利用函数处理数据集
train = read_dataset('datasets/titanic/train.csv')

pandas 是一个功能强大的时间序列数据集处理工具，处理完的数据样本如图示。

# 观察此文件的前5行的相关的数据以及标签
train.head()

2.模型训练

首先，需要把 Survived 列提取出来作为标签，然后在原数据集中将其丢弃。同时把数据集分成训练数据集和交叉验证数据集。

# 划分数据集

# train_test_split是sklearn中用于划分数据集，即将原始数据集划分成测试集和训练集两部分的函数。
from sklearn.model_selection import train_test_split

# 获取数据集中Survived一行中的值
y = train['Survived'].values
# 获取删除Survived后剩下的值
X = train.drop(['Survived'], axis=1).values

# 将数据划分为两部分的训练集和测试集（X为待划分数据样本集，y为待划分数据集样本的标签，test__size为测试数据占样本数据的比例，若整数则样本数量）
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# 输出x,y数据的行和列
print('train dataset: {0}; test dataset: {1}'.format(
    X_train.shape, X_test.shape))

train dataset: (712, 7); test dataset: (179, 7)

接下来,使用 scikit-learn 的决策树模型对数据进行拟合。

# 进行模型训练

# 使用scikit-learn的决策树模型对数据进行拟合
from sklearn.tree import DecisionTreeClassifier

clf = DecisionTreeClassifier()
clf.fit(X_train, y_train)
# 训练样本评分
train_score = clf.score(X_train, y_train)
# 交叉验证数据集评分
test_score = clf.score(X_test, y_test)
print('train score: {0}; test score: {1}'.format(train_score, test_score))
#从输出可以看出训练样本评分很高，但是测试集的评分却较低，从这可以看出此模型已经过拟合了，此时需要对模型进行处理

train score: 0.9817415730337079; test score: 0.7988826815642458

从输出数据中可以看出，针对训练样本评分很高，但针对交叉验证数据集评分比较低，两者差距较大。很明显，这是过拟合的特征。解决决策树过拟合的方法是剪枝，包括前剪枝和后剪枝。不幸的是， scikit-learn 不支持后剪枝，但提供一系列的模型参数进行前剪枝。
例如，我们通过max_depth参数限定决策树的深度，当决策树达到限定的深度时，就不再进行分裂了。这样就可以在一定程度上避免过拟合。

3.优化模型参数

一个最直观的解决办法是选择一系列参数的值，然后分别计算用指定参数训练出来的模型的评分数据。还可以把两者的关系画出来，直观地看到参数值与模型准确度的关系。
以模型深度 max_depth 为例，我们先创建一个函数，它使用不同的模型深度训练模型，并计算评分数据。

# 模型优化第一种方法：调整模型深度max_depth

# 参数选择1 对不同的模型深度max_depth对数据进行训练
def cv_score(d):
    # 函数的作用：对于不同的模型深度进行模型训练，最后返回得出训练集与测试集的样本评分
    clf = DecisionTreeClassifier(max_depth=d)
    clf.fit(X_train, y_train)
    tr_score = clf.score(X_train, y_train)
    cv_score = clf.score(X_test, y_test)
    return (tr_score, cv_score)

接着构造参数范围，在这个范围内分别计算模型评分，并找出评分最高的模型所对应的参数。

# 将模型深度从2到15进行取值
depths = range(2, 15)

# 利用上面函数得到各自的评分
scores = [cv_score(d) for d in depths]
tr_scores = [s[0] for s in scores]
cv_scores = [s[1] for s in scores]

# 获取cv_scores（即为测试集）中最大值的索引值
best_score_index = np.argmax(cv_scores)
# 获取测试集评分最大的评分
best_score = cv_scores[best_score_index]
# 获取使得测试集评分得到最高的模型深度
best_param = depths[best_score_index]
print('best param: {0}; best score: {1}'.format(best_param, best_score))

best param: 7; best score : 0 . 837988826816

可以看到，针对模型深度这个参数，最优的值是7，其对应的交叉验证数据集评分为0.83799。我们还可以把模型参数和模型评分画出来，更直观地观察其变化规律。

# 将模型参数与模型评分画出来
plt.figure(figsize=(10, 6), dpi=144)
plt.grid()
plt.xlabel('max depth of decision tree')
plt.ylabel('score')
# 两个曲线分别为训练集与测试的评分
plt.plot(depths, cv_scores, '.g-', label='cross-validation score')
plt.plot(depths, tr_scores, '.r--', label='training score')
plt.legend()

使用同样的方法，我们可以考察参数 min_impurity_split 。这个参数用来指定信息熵或基尼不纯度的阈值，当决策树分裂后，其信息增益低于这个阈值时，则不再分裂。

# 模型优化第二种方法：设置参数来指定信息熵或基尼不纯度的阈值（直接设置一个范围）

# 参数选择2 min_impurity_split，利用这个参数用来指定信息熵或基尼不纯度的阈值，当决策数分裂后，其信息增益低于这个阈值时，则不再分裂
# 训练模型，并计算评分
def cv_score(val):
    clf = DecisionTreeClassifier(criterion='gini', min_impurity_decrease=val)
    clf.fit(X_train, y_train)
    tr_score = clf.score(X_train, y_train)
    cv_score = clf.score(X_test, y_test)
    return (tr_score, cv_score)

# 指定参数范围，分别训练模型，并计算评分
values = np.linspace(0, 0.005, 50)
scores = [cv_score(v) for v in values]
tr_scores = [s[0] for s in scores]
cv_scores = [s[1] for s in scores]

# 找出评分最高的模型参数
best_score_index = np.argmax(cv_scores)
best_score = cv_scores[best_score_index]
best_param = values[best_score_index]
print('best param: {0}; best score: {1}'.format(best_param, best_score))

# 画出模型参数与模型评分的关系
plt.figure(figsize=(10, 6), dpi=144)
plt.grid()
plt.xlabel('threshold of entropy')
plt.ylabel('score')
plt.plot(values, cv_scores, '.g-', label='cross-validation score')
plt.plot(values, tr_scores, '.r--', label='training score')
plt.legend()

# 我们可以看到当训练集与测试集的评分下降最快时即此时说明模型出现了欠拟合

best param: 0.0014285714285714286; best score: 0.8324022346368715

需要注意的是，每次把数据集划分为训练样本和交叉验证样本时，是随机划分的，这样导致每次的训练数据集是有差异的，训练出来的模型也有差异（容易出现数据不稳定的问题）。解决这个问题的方法是多次计算，求平均值。具体来讲，就是针对模型的某个特定参数值，多次划分数据集，多次训练模型，计算出这个参数值时的最低评分、最高评分及平均评分。
scikit-learn在sklearn.model_selection 包里提供了大量的模型选择和评估的工具供我们使用。针对遇到的部分问题，可以使用GridSearchCV 类来解决。下面先看一下怎样用 GridSearchCV 类选择一个参数的最优值：

#通过模型模型训练用不同的参数获得最优的参数，最后获得最好的评分

#可在此包中直接使用GridSearchCV，GridSearchCV，它存在的意义就是自动调参，只要把参数输进去，就能给出最优化的结果和参数。但是这个方法适合于小数据集，一旦数据的量级上去了，很难得出结果。
from sklearn.model_selection import GridSearchCV

#从0到0.005生成50个元素的行向量
thresholds = np.linspace(0, 0.005, 50)
#通过交叉验证设置参数
param_grid = {'min_impurity_decrease': thresholds}
#GridSearchCV会枚举列表中所有值来构建模型，多次训练模型，计算出多次模型得到最优参数以及最优的评分，最后将这些写入clf.best_params_, clf.best_score_这两个模型中
#cv将模型数据集划分为5份，其中一份为交叉验证集，另外其它的都是训练集
#return_train_score=True 返回训练集的评分，如果为False，则就不返回训练集的评分
clf = GridSearchCV(DecisionTreeClassifier(), param_grid, cv=5, return_train_score=True)
clf.fit(X, y)

#打印出最好的验证集参数以及对应最好的评分
print("best param: {0}\nbest score: {1}".format(clf.best_params_, 
                                                clf.best_score_))
#将最后训练集和交叉验证集的评分进行画图对比
plot_curve(thresholds, clf.cv_results_, xlabel='gini thresholds')

best param: {‘min_impurity_decrease’: 0.0009183673469387756}
best score: 0.813709120582512

其中关键的参数是 param_grid ，它是一个字典，字典关键字所对应的值是一个列表。
GridSearchCV 会枚举列表里的所有值来构建模型，多次计算训练模型，并计算模型评分，
最终得出指定参数值的平均评分及标准差。另外一个关键的参数是cv，它用来指定交叉验证数据集的生成规则，代码中的 cv=5 表示每次计算都把数据集分成5份，拿其中一份作为交叉验证数据集，其他的作为训练数据集。最终得出的最优参数及最优评分保存在clf. best_params ＿和clf. best_ score＿里。此外， clf.cv results＿保存了计算过程的所有中间结果。
我们可以拿这个数据来画出模型参数与模型评分的关系图，如图。

# 保存了计算过程的所有中间结果
def plot_curve(train_sizes, cv_results, xlabel):
    train_scores_mean = cv_results['mean_train_score']
    train_scores_std = cv_results['std_train_score']
    test_scores_mean = cv_results['mean_test_score']
    test_scores_std = cv_results['std_test_score']
    plt.figure(figsize=(10, 6), dpi=144)
    plt.title('parameters turning')
    plt.grid()
    plt.xlabel(xlabel)
    plt.ylabel('score')
    plt.fill_between(train_sizes, 
                     train_scores_mean - train_scores_std,
                     train_scores_mean + train_scores_std, 
                     alpha=0.1, color="r")
    plt.fill_between(train_sizes, 
                     test_scores_mean - test_scores_std,
                     test_scores_mean + test_scores_std, 
                     alpha=0.1, color="g")
    plt.plot(train_sizes, train_scores_mean, '.--', color="r",
             label="Training score")
    plt.plot(train_sizes, test_scores_mean, '.-', color="g",
             label="Cross-validation score")

    plt.legend(loc="best")

接下来看一下如何在多组参数之间选择最优的参数：

# 可在此包中直接使用GridSearchCV，GridSearchCV，它存在的意义就是自动调参，只要把参数输进去，就能给出最优化的结果和参数。但是这个方法适合于小数据集，一旦数据的量级上去了，很难得出结果。
from sklearn.model_selection import GridSearchCV

#从0到0.01生成50个元素的行向量
entropy_thresholds = np.linspace(0, 0.01, 50)
#从0到0.005生成50个元素的行向量
gini_thresholds = np.linspace(0, 0.005, 50)

# 设置参数矩阵
param_grid = [{'criterion': ['entropy'], 
               'min_impurity_decrease': entropy_thresholds},
              {'criterion': ['gini'], 
               'min_impurity_decrease': gini_thresholds},
              {'max_depth': range(2, 10)},
              {'min_samples_split': range(2, 30, 2)}]

clf = GridSearchCV(DecisionTreeClassifier(), param_grid, cv=5, return_train_score=True)
clf.fit(X, y)
print("best param: {0}\nbest score: {1}".format(clf.best_params_, 
                                                clf.best_score_))

best param: {‘criterion’: ‘entropy’, ‘min_impurity_decrease’: 0.004897959183673469}
best score: 0.8226853304877284

代码中， 关键部分还是 param_grid 参数，它 是一个列表，列表中每个元素都是一个字典。例如，针对列表中的第一个字典，选择信息熵作为决策树特征选择的判断标准，同时其阔值范围是［0,1]之间分了 50 等分。GridSearchCV 会针对列表中的每个字典进行迭代，最终比较列表中每个字典所对应的参数组合，选择出最优的参数。

二、乳腺癌检测

在之前我们使用逻辑回归算法进行了乳腺癌检测模型的学习和训练。本次我们将使用支持向量机来解决这个问题。首先，我们载入数据：

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

# 载入数据
from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer()
X = cancer.data
y = cancer.target
print('data shape: {0}; no. positive: {1}; no. negative: {2}'.format(
    X.shape, y[y==1].shape[0], y[y==0].shape[0]))

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

输出：

data shape: (569, 30); no. positive: 357; no. negative: 212

可以看出，我们的数据集很小。高斯核函数太复杂，容易造成过拟合，模型效果应该不会很好。 我们先用高斯核函数试一下看与我们猜测的是否一致：

from sklearn.svm import SVC

clf = SVC(C=1.0, kernel='rbf', gamma=0.1)
clf.fit(X_train, y_train)
train_score = clf.score(X_train, y_train)
test_score = clf.score(X_test, y_test)
print('train score: {0}; test score: {1}'.format(train_score, test_score))

待续~