python财政收入预测分析_python 数据分析-- 实战1（收入预测分析）

说明：

本文用途只做学习记录：

参考书籍：从零开始学Python数据分析与挖掘／刘顺祥著．—北京：清华大学出版社，2018

首先看一下刘老师介绍的数据分析和数据挖掘的区别：

1. 预览数据集，明确分析目的

通过Excel工具打开income文件，可发现该数据集一共有 32 561条样本数据，共有15个数据变量，其中9个离散型变量，6个数值型变量。数据项主要包括：年龄，工作类型，受教育程度，收入等，具体可见下面两个图：

拿到上面的数据集，我们观察这些数据都有什么用，想一想这张数据表中income比较特殊，有分析价值，其他变量的不同会对income产生一定的影响。

实验目的：因此，基于上面的数据集，需要预测居民的年收入是否会超过5万美元？

2. 导入数据集，预处理数据

在jupyter notebook中导入相应包，读取数据，进行预处理。在上述数据集中，有许多变量都是离散型的，如受教育程度、婚姻状态、职业、性别等。通常数据拿到手后，都需要对其进行清洗，例如检查数据中是否存在重复观测、缺失值、异常值等，而且，如果建模的话，还需要对字符型的离散变量做相应的重编码。

import numpy as np

import pandas as pd

import seaborn as sns

# 下载的数据集存放的路径：

income = pd.read_excel(r'E:\Data\1\income.xlsx')

# 查看数据集是否存在缺失

income.apply(lambda x:np.sum(x.isnull()))

age 0

workclass 1836

fnlwgt 0

education 0

education-num 0

marital-status 0

occupation 1843

relationship 0

race 0

sex 0

capital-gain 0

capital-loss 0

hours-per-week 0

native-country 583

income 0

dtype: int64

从上面的结果可以发现，居民的收入数据集中有3个变量存在数值缺失，分别是居民的工作类型(离散型)缺1836、职业(离散型)缺1843和国籍(离散型)缺583。缺失值的存在一般都会影响分析或建模的结果，所以需要对缺失数值做相应的处理。

缺失值的处理一般采用三种方法：

1.删除法，缺失的数据较少时适用；

2.替换法，用常数替换缺失变量，离散变量用众数，数值变量用均值或中位数；

3.插补法：用未缺失的预测该缺失变量。

根据上述方法，三个缺失变量都为离散型，可用众数替换。pandas中fillna()方法，能够使用指定的方法填充NA/NaN值。

函数形式：

fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs)

参数：

value：用于填充的空值的值。(该处为字典)

method： {'backfill', 'bfill', 'pad', 'ffill', None}, default None。定义了填充空值的方法， pad/ffill表示用前面行/列的值，填充当前行/列的空值， backfill / bfill表示用后面行/列的值，填充当前行/列的空值。

axis：轴。0或'index'，表示按行删除；1或'columns'，表示按列删除。

inplace：是否原地替换。布尔值，默认为False。如果为True，则在原DataFrame上进行操作，返回值为None。

limit：int，default None。如果method被指定，对于连续的空值，这段连续区域，最多填充前 limit 个空值(如果存在多段连续区域，每段最多填充前 limit 个空值)。如果method未被指定， 在该axis下，最多填充前 limit 个空值(不论空值连续区间是否间断)

downcast：dict, default is None，字典中的项，为类型向下转换规则。或者为字符串“infer”，此时会在合适的等价类型之间进行向下转换，比如float64 to int64 if possible。

# 缺失值处理，采用众数替换法(mode()方法取众数)

income.fillna(value={'workclass':income['workclass'].mode()[0],

'ouccupation':income['occupation'].mode()[0],

'native-country':income['native-country'].mode()[0]},

inplace = True)

3. 探索数据背后的特征

对缺失值采用了替换处理的方法，接下来对居民收入数据集做简单的探索性分析，目的是了解数据背后的特征如数据的集中趋势、离散趋势、数据形状和变量间的关系等。首先，需要知道每个变量的基本统计值，如均值、中位数、众数等，只有了解了所需处理的数据特征，才能做到“心中有数”。

3.1 数值型变量统计描述

# 3.1 数值型变量统计描述

income.describe()

age

fnlwgt

education-num

capital-gain

capital-loss

hours-per-week

count

32561.000000

3.256100e+04

32561.000000

32561.000000

32561.000000

32561.000000

mean

38.581647

1.897784e+05

10.080679

1077.648844

87.303830

40.437456

std

13.640433

1.055500e+05

2.572720

7385.292085

402.960219

12.347429

min

17.000000

1.228500e+04

1.000000

0.000000

0.000000

1.000000

25%

28.000000

1.178270e+05

9.000000

0.000000

0.000000

40.000000

50%

37.000000

1.783560e+05

10.000000

0.000000

0.000000

40.000000

75%

48.000000

2.370510e+05

12.000000

0.000000

0.000000

45.000000

max

90.000000

1.484705e+06

16.000000

99999.000000

4356.000000

99.000000

上面的结果描述了有关数值型变量的简单统计值，包括非缺失观测的个数(count)、平均值(mean)、标准差(std)、最小值(min)、下四分位数(25%)、中位数(50%)、上四分位数(75%)和最大值(max)。

3.2 离散型变量统计描述

# 2. 离散型变量统计描述

income.describe(include= ['object'])

workclass

education

marital-status

occupation

relationship

race

sex

native-country

income

count

32561

32561

32561

30718

32561

32561

32561

32561

32561

unique

8

16

7

14

6

5

2

41

2

top

Private

HS-grad

Married-civ-spouse

Prof-specialty

Husband

White

Male

United-States

<=50K

freq

24532

10501

14976

4140

13193

27816

21790

29753

24720

上面为离散变量的统计值，包含每个变量非缺失观测的数量(count)、不同离散值的个数(unique)、出现频次最高的离散值(top)和最高频次数(freq)。以受教育水平变量为例，一共有16种不同的教育水平；3万多居民中，高中毕业的学历是出现最多的；并且一共有10 501名。

3 .3 了解数据的分布形状

为了了解数据的分布形状(如偏度、峰度等)可以通过可视化的方法进行展现。

#以被调查居民的年龄和每周工作小时数为例，绘制各自的分布形状图：

import matplotlib.pyplot as plt

# 设置绘图风格

plt.style.use('ggplot')

# 设置多图形的组合

fig, axes = plt.subplots(3,1)

# 绘制不同收入水平下的年龄核密度图，观察连续型变量的分布情况

income.age[income.income == ' <=50K'].plot(kind = 'kde', label = '<=50K', ax = axes[0], legend = True, linestyle = '-')

income.age[income.income == ' >50K'].plot(kind = 'kde', label = '>50K', ax = axes[0], legend = True, linestyle = '--')

# 绘制不同收入水平下的周工作小时核密度图

income['hours-per-week'][income.income == ' <=50K'].plot(kind = 'kde', label = '<=50K', ax = axes[1], legend = True, linestyle = '-')

income['hours-per-week'][income.income == ' >50K'].plot(kind = 'kde', label = '>50K', ax = axes[1], legend = True, linestyle = '--')

# 绘制不同收入水平下的受教育时长核密度图

income['education-num'][income.income == ' <=50K'].plot(kind = 'kde', label = '<=50K', ax = axes[2], legend = True, linestyle = '-')

income['education-num'][income.income == ' >50K'].plot(kind = 'kde', label = '>50K', ax = axes[2], legend = True, linestyle = '--')

第一幅图展现的是，在不同收入水平下，年龄的核密度分布图，对于年收入超过5万美元的居民来说，他们的年龄几乎呈现正态分布，而收入低于5万美元的居民，年龄呈现右偏特征，即年龄偏大的居民人数要比年龄偏小的人数多。

第二幅图展现了不同收入水平下，周工作小时数的核密度图，很明显，两者的分布趋势非常相似，并且出现局部峰值。

第三幅图展现了不同收入水平下，教育时长的核密度图，很明显，两者的分布趋势非常相似，并且也多次出现局部峰值。

针对离散型变量，对比居民的收入水平高低在性别、种族状态、家庭关系等方面的差异，进而可以发现这些离散变量是否影响收入水平：

# 构造不同收入水平下各种族人数的数据

race = pd.DataFrame(income.groupby(by = ['race','income']).aggregate(np.size).loc[:,'age'])

#print(race)

# 重设行索引

race = race.reset_index()

#print(race)

# 变量重命名

race.rename(columns={'age':'counts'}, inplace=True)

#print(race)

# 排序

race.sort_values(by = ['race','counts'], ascending=False, inplace=True)

#print(race)

# 构造不同收入水平下各家庭关系人数的数据

relationship = pd.DataFrame(income.groupby(by = ['relationship','income']).aggregate(np.size).loc[:,'age'])

relationship = relationship.reset_index()

relationship.rename(columns={'age':'counts'}, inplace=True)

relationship.sort_values(by = ['relationship','counts'], ascending=False, inplace=True)

# 构造不同收入水平下各男女人数的数据

sex = pd.DataFrame(income.groupby(by = ['sex','income']).aggregate(np.size).loc[:,'age'])

sex = sex.reset_index()

sex.rename(columns={'age':'counts'}, inplace=True)

sex.sort_values(by = ['sex','counts'], ascending=False, inplace=True)

# 设置图框比例，并绘图

plt.figure(figsize=(9,5))

sns.barplot(x="race", y="counts", hue = 'income', data=race)

plt.show()

plt.figure(figsize=(9,5))

sns.barplot(x="relationship", y="counts", hue = 'income', data=relationship)

plt.show()

plt.figure(figsize=(9,5))

sns.barplot(x="sex", y="counts", hue = 'income', data=sex)

plt.show()

图一、反映的是相同的种族下，居民年收入水平高低的人数差异；图二、反映的是相同的家庭成员关系下，居民年收入水平高低的人数差异。但无论怎么比较，都发现一个规律，即在某一个相同的水平下(如白种人或未结婚人群中)，年收入低于5万美元的人数都要比年收入高于5万美元的人数多，这个应该是抽样导致的差异(数据集中年收入低于5万和高于5万的居民比例大致在75%:25%)。图三、反映的是相同的性别下，居民收入水平高低人数的差异；其中，女性收入低于5万美元的人数比高于5万美元人数的差异比男性更严重，比例大致为90%:10%， 男性大致为70%：30%。

4. 数据建模

4.1 对离散变量重编码

由于数据集中有很多离散型变量，这些变量的值为字符串，不利于建模，因此，需要先对这些变量进行重新编码。编码的方法有很多种：

将字符型的值转换为整数型的值

哑变量处理(0-1变量)

One-Hot热编码(类似于哑变量)

在本案例中，将采用“字符转数值”的方法对离散型变量进行重编码

# 离散型变量的重编码

for feature in income.columns:

if income[feature].dtype == 'object':

income[feature] = pd.Categorical(income[feature]).codes

income.head(10)

age

workclass

fnlwgt

education

education-num

marital-status

occupation

relationship

race

sex

capital-gain

capital-loss

hours-per-week

native-country

income

0

39

6

77516

9

13

4

0

1

4

1

2174

0

40

38

0

1

50

5

83311

9

13

2

3

0

4

1

0

0

13

38

0

2

38

3

215646

11

9

0

5

1

4

1

0

0

40

38

0

3

53

3

234721

1

7

2

5

0

2

1

0

0

40

38

0

4

28

3

338409

9

13

2

9

5

2

0

0

0

40

4

0

5

37

3

284582

12

14

2

3

5

4

0

0

0

40

38

0

6

49

3

160187

6

5

3

7

1

2

0

0

0

16

22

0

7

52

5

209642

11

9

2

3

0

4

1

0

0

45

38

1

8

31

3

45781

12

14

4

9

1

4

0

14084

0

50

38

1

9

42

3

159449

9

13

2

3

0

4

1

5178

0

40

38

1

对字符型离散变量的重编码效果，所有的字符型变量都变成了整数型变量，接下来就基于这个处理好的数据集对收入水平income进行预测。

在原本的居民收入数据集中，关于受教育程度的有两个变量，一个是education(教育水平)，另一个是education-num(受教育时长)，而且这两个变量的值都是一一对应的，只不过一个是字符型，另一个是对应的数值型，如果将这两个变量都包含在模型中的话，就会产生信息的冗余；fnlwgt变量代表的是一种序号，其对收入水平的高低并没有实际意义。故为了避免冗余信息和无意义变量对模型的影响，考虑将education变量和fnlwgt变量从数据集中删除。

income.drop(['education','fnlwgt'], axis=1, inplace=True)

income.head(10)

age

workclass

education-num

marital-status

occupation

relationship

race

sex

capital-gain

capital-loss

hours-per-week

native-country

income

0

39

6

13

4

0

1

4

1

2174

0

40

38

0

1

50

5

13

2

3

0

4

1

0

0

13

38

0

2

38

3

9

0

5

1

4

1

0

0

40

38

0

3

53

3

7

2

5

0

2

1

0

0

40

38

0

4

28

3

13

2

9

5

2

0

0

0

40

4

0

5

37

3

14

2

3

5

4

0

0

0

40

38

0

6

49

3

5

3

7

1

2

0

0

0

16

22

0

7

52

5

9

2

3

0

4

1

0

0

45

38

1

8

31

3

14

4

9

1

4

0

14084

0

50

38

1

9

42

3

13

2

3

0

4

1

5178

0

40

38

1

上面表格呈现的就是经处理“干净”的数据集，所要预测的变量就是income，该变量是二元变量，对其预测的实质就是对年收入水平的分类(一个新样本进来，通过分类模型，可以将该样本分为哪一种收入水平)。

关于分类模型有很多种：

Logistic模型

决策树

K近邻

朴素贝叶斯模型

支持向量机

随机森林

梯度提升树GBDT模型等。

本案例将对比使用K近邻和GBDT两种分类器，因为通常情况下，都会选用多个模型作为备选，通过对比才能得知哪种模型可以更好地拟合数据。

4.2 拆分数据集

接下来就进一步说明如何针对分类问题，从零开始完成建模的步骤。基于上面的“干净”数据集，需要将其拆分为两个部分，一部分用于分类器模型的构建，另一部分用于分类器模型的评估，这样做的目的是避免分类器模型过拟合或欠拟合。如果模型在训练集上表现很好，而在测试集中表现很差，则说明分类器模型属于过拟合状态；如果模型在训练过程中都不能很好地拟合数据，那说明模型属于欠拟合状态。通常情况下，会把训练集和测试集的比例分配为75%和25%。

# 导入sklearn包中的函数

from sklearn.model_selection import train_test_split

# 拆分数据

X_train, X_test, y_train, y_test = train_test_split(income.loc[:,'age':'native-country'],

income['income'],train_size = 0.75,test_size=0.25, random_state = 1234)

# print(X_train)

# print(y_train)

print("训练数据集中共有 %d 条观测" %X_train.shape[0])

print("测试数据集中共有 %d 条测试" %X_test.shape[0])

训练数据集中共有 24420 条观测

测试数据集中共有 8141 条测试

上面的结果，运用随机抽样的方法，将数据集拆分为两部分，其中训练数据集包含24 420条样本，测试数据集包含8 141条样本，下面将运用拆分好的训练数据集开始构建K近邻和GBDT两种分类器。

4.3 搭建模型

# 导入K近邻模型的类

from sklearn.neighbors import KNeighborsClassifier

from sklearn.ensemble import GradientBoostingClassifier

# 构件K近邻模型

kn = KNeighborsClassifier()

kn.fit(X_train,y_train)

print(kn)

#构件GBDT模型

gbdt = GradientBoostingClassifier()

gbdt.fit(X_train, y_train)

print(gbdt)

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',

metric_params=None, n_jobs=1, n_neighbors=5, p=2,

weights='uniform')

GradientBoostingClassifier(criterion='friedman_mse', init=None,

learning_rate=0.1, loss='deviance', max_depth=3,

max_features=None, max_leaf_nodes=None,

min_impurity_decrease=0.0, min_impurity_split=None,

min_samples_leaf=1, min_samples_split=2,

min_weight_fraction_leaf=0.0, n_estimators=100,

presort='auto', random_state=None, subsample=1.0, verbose=0,

warm_start=False)

首先，针对K近邻模型，这里直接调用sklearn子模块neighbors中的KNeighborsClassifier类，并且使用模型的默认参数，即让K近邻模型自动挑选最佳的搜寻近邻算法(algorithm='auto')、使用欧氏距离公式计算样本间的距离(p=2)、指定未知分类样本的近邻个数为5(n_neighbors=5)而且所有近邻样本的权重都相等(weights='uniform')。其次，针对GBDT模型，可以调用sklearn子模块ensemble中的GradientBoostingClassifier类，同样先尝试使用该模型的默认参数，即让模型的学习率(迭代步长)为0.1(learning_rate=0.1)、损失函数使用的是对数损失函数(loss='deviance')、生成100棵基础决策树(n_estimators=100)，并且每棵基础决策树的最大深度为3(max_depth=3)，中间节点(非叶节点)的最小样本量为2(min_samples_split=2)，叶节点的最小样本量为1(min_samples_leaf=1)，每一棵树的训练都不会基于上一棵树的结果(warm_start=False)。

4.4 模型网格搜索法，探寻模型最佳参数

# K 近邻模型网格搜索法

# 导入网格搜索函数

from sklearn.grid_search import GridSearchCV

# 选择不同的参数

k_options = list(range(1,12))

parameters = {'n_neighbors':k_options}

# 搜索不同的K值

grid_kn = GridSearchCV(estimator= KNeighborsClassifier(), param_grid=parameters, cv=10, scoring='accuracy')

grid_kn.fit(X_train, y_train)

# 结果输出

grid_kn.grid_scores_, grid_kn.best_params_, grid_kn.best_score_

([mean: 0.81507, std: 0.00711, params: {'n_neighbors': 1},

mean: 0.83882, std: 0.00696, params: {'n_neighbors': 2},

mean: 0.83722, std: 0.00843, params: {'n_neighbors': 3},

mean: 0.84586, std: 0.01039, params: {'n_neighbors': 4},

mean: 0.84222, std: 0.00916, params: {'n_neighbors': 5},

mean: 0.84713, std: 0.00900, params: {'n_neighbors': 6},

mean: 0.84316, std: 0.00719, params: {'n_neighbors': 7},

mean: 0.84525, std: 0.00629, params: {'n_neighbors': 8},

mean: 0.84394, std: 0.00678, params: {'n_neighbors': 9},

mean: 0.84570, std: 0.00534, params: {'n_neighbors': 10},

mean: 0.84464, std: 0.00444, params: {'n_neighbors': 11}],

{'n_neighbors': 6},

0.8471334971334972)

GridSearchCV函数中的几个参数含义，estimator参数接受一个指定的模型，这里为K近邻模型的类；param_grid用来指定模型需要搜索的参数列表对象，这里是K近邻模型中n_neighbors参数的11种可能值；cv是指网格搜索需要经过10重交叉验证；scoring指定模型评估的度量值，这里选用的是模型预测的准确率。通过网格搜索的计算，得到三部分的结果，第一部分包含了11种K值下的平均准确率(因为做了10重交叉验证)；第二部分选择出了最佳的K值，K值为6；第三部分是当K值为6时模型的最佳平均准确率，且准确率为84.78%。

# GBDT 模型的网格搜索法

# 选择不同的参数

from sklearn.grid_search import GridSearchCV

learning_rate_options = [0.01, 0.05, 0.1]

max_depth_options = [3,5,7,9]

n_estimators_options = [100, 300, 500]

parameters = {'learning_rate':learning_rate_options,

'max_depth':max_depth_options,

'n_estimators':n_estimators_options}

grid_gbdt = GridSearchCV(estimator= GradientBoostingClassifier(),param_grid=parameters,cv=10,scoring='accuracy')

grid_gbdt.fit(X_train, y_train)

# 结果输出

grid_gbdt.grid_scores_,grid_gbdt.best_params_, grid_gbdt.best_score_

([mean: 0.84267, std: 0.00727, params: {'learning_rate': 0.01, 'max_depth': 3, 'n_estimators': 100},

mean: 0.85360, std: 0.00837, params: {'learning_rate': 0.01, 'max_depth': 3, 'n_estimators': 300},

mean: 0.85930, std: 0.00746, params: {'learning_rate': 0.01, 'max_depth': 3, 'n_estimators': 500},

mean: 0.85213, std: 0.00821, params: {'learning_rate': 0.01, 'max_depth': 5, 'n_estimators': 100},

mean: 0.86327, std: 0.00751, params: {'learning_rate': 0.01, 'max_depth': 5, 'n_estimators': 300},

mean: 0.86929, std: 0.00767, params: {'learning_rate': 0.01, 'max_depth': 5, 'n_estimators': 500},

mean: 0.85459, std: 0.00767, params: {'learning_rate': 0.01, 'max_depth': 7, 'n_estimators': 100},

mean: 0.87076, std: 0.00920, params: {'learning_rate': 0.01, 'max_depth': 7, 'n_estimators': 300},

mean: 0.87342, std: 0.00983, params: {'learning_rate': 0.01, 'max_depth': 7, 'n_estimators': 500},

mean: 0.85438, std: 0.00801, params: {'learning_rate': 0.01, 'max_depth': 9, 'n_estimators': 100},

mean: 0.86855, std: 0.00907, params: {'learning_rate': 0.01, 'max_depth': 9, 'n_estimators': 300},

mean: 0.87248, std: 0.00974, params: {'learning_rate': 0.01, 'max_depth': 9, 'n_estimators': 500},

mean: 0.85962, std: 0.00778, params: {'learning_rate': 0.05, 'max_depth': 3, 'n_estimators': 100},

mean: 0.86974, std: 0.00689, params: {'learning_rate': 0.05, 'max_depth': 3, 'n_estimators': 300},

mean: 0.87326, std: 0.00697, params: {'learning_rate': 0.05, 'max_depth': 3, 'n_estimators': 500},

mean: 0.86978, std: 0.00790, params: {'learning_rate': 0.05, 'max_depth': 5, 'n_estimators': 100},

mean: 0.87543, std: 0.00897, params: {'learning_rate': 0.05, 'max_depth': 5, 'n_estimators': 300},

mean: 0.87445, std: 0.00962, params: {'learning_rate': 0.05, 'max_depth': 5, 'n_estimators': 500},

mean: 0.87338, std: 0.00927, params: {'learning_rate': 0.05, 'max_depth': 7, 'n_estimators': 100},

mean: 0.87391, std: 0.00964, params: {'learning_rate': 0.05, 'max_depth': 7, 'n_estimators': 300},

mean: 0.87072, std: 0.01012, params: {'learning_rate': 0.05, 'max_depth': 7, 'n_estimators': 500},

mean: 0.87211, std: 0.00989, params: {'learning_rate': 0.05, 'max_depth': 9, 'n_estimators': 100},

mean: 0.86851, std: 0.01048, params: {'learning_rate': 0.05, 'max_depth': 9, 'n_estimators': 300},

mean: 0.86229, std: 0.00857, params: {'learning_rate': 0.05, 'max_depth': 9, 'n_estimators': 500},

mean: 0.86626, std: 0.00660, params: {'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 100},

mean: 0.87355, std: 0.00802, params: {'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 300},

mean: 0.87449, std: 0.00842, params: {'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 500},

mean: 0.87383, std: 0.00878, params: {'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 100},

mean: 0.87310, std: 0.01001, params: {'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 300},

mean: 0.87236, std: 0.00939, params: {'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 500},

mean: 0.87502, std: 0.01037, params: {'learning_rate': 0.1, 'max_depth': 7, 'n_estimators': 100},

mean: 0.86953, std: 0.00873, params: {'learning_rate': 0.1, 'max_depth': 7, 'n_estimators': 300},

mean: 0.86192, std: 0.00823, params: {'learning_rate': 0.1, 'max_depth': 7, 'n_estimators': 500},

mean: 0.87154, std: 0.01075, params: {'learning_rate': 0.1, 'max_depth': 9, 'n_estimators': 100},

mean: 0.85995, std: 0.00848, params: {'learning_rate': 0.1, 'max_depth': 9, 'n_estimators': 300},

mean: 0.85328, std: 0.00828, params: {'learning_rate': 0.1, 'max_depth': 9, 'n_estimators': 500}],

{'learning_rate': 0.05, 'max_depth': 5, 'n_estimators': 300},

0.8754299754299755)

4.5 模型预测与评估

在模型构建好后，下一步做的就是使用得到的分类器对测试数据集进行预测，进而验证模型在样本外的表现能力。通常，验证模型好坏的方法有多种。

对于预测的连续变量来说，常用的衡量指标有均方误差(MSE)和均方根误差(RMSE)；

对于预测的分类变量来说，常用的衡量指标有混淆矩阵中的准确率、ROC曲线下的面积AUC、K-S值等。

接下来，依次对上文中构建的四种模型(K近邻、K近邻网格搜索法、GDBT模型、GDBT网格搜索法模型)进行预测和评估。

4.5.1 K近邻模型在测试集上的预测

kn_pred = kn.predict(X_test)

print(pd.crosstab(kn_pred, y_test))

# 模型得分

print("模型在训练集上的准确率为%f" % kn.score(X_train, y_train))

print("模型在测试集上的准确率为%f" % kn.score(X_test, y_test))

income 0 1

row_0

0 5644 725

1 582 1190

模型在训练集上的准确率为0.889844

模型在测试集上的准确率为0.839455

第一部分是混淆矩阵，矩阵中的行是模型的预测值，矩阵中的列是测试集的实际值，主对角线就是模型预测正确的数量(income <=50K有 5644 人 和 income >50K 有 1190人)，582和725就是模型预测错误的数量。经过计算，得到第二部分的结论，即模型在训练集中的准确率为88.9%，但在测试集上的错误率超过16%(1-0.839)，说明默认参数下的KNN模型可能存在过拟合的风险。

模型的准确率就是基于混淆矩阵计算的，但是该方法存在一定的弊端，即如果数据本身存在一定的不平衡时(正负样本的比例差异较大)，一定会导致准确率很高，但并不一定说明模型就是理想的。所以可以绘制ROC曲线，并计算曲线下的面积AUC值

from sklearn import metrics

# 计算ROC曲线的x轴 和 y轴数据

fpr, tpr, _ = metrics.roc_curve(y_test, kn.predict_proba(X_test)[:,1])

# 绘制ROC曲线

plt.plot(fpr, tpr, linestyle = 'solid', color ='red')

# 添加阴影

plt.stackplot(fpr, tpr, color='steelblue')

# 绘制参考线

plt.plot([0,1],[0,1],linestyle='dashed', color='black')

# 添加文本

plt.text(0.6, 0.4, 'AUC=%.3f' % metrics.auc(fpr,tpr), fontdict=dict(size =16))

plt.show()

上图绘制了模型的ROC曲线，经计算得知，该曲线下的面积AUC为0.864。使用AUC来评估模型的好坏，那应该希望AUC越大越好。一般而言，当AUC的值超过0.8时，基本上就可以认为模型比较合理。所以，基于默认参数的K近邻模型在居民收入数据集上的表现还算理想。

4.5.2 K近邻网格搜索模型在测试集上的预测

from sklearn import metrics

grid_kn_pred = grid_kn.predict(X_test)

print(pd.crosstab(grid_kn_pred, y_test))

# 模型得分

print("模型在训练集上的准确率为%f" % grid_kn.score(X_train, y_train))

print("模型在测试集上的准确率为%f" % grid_kn.score(X_test, y_test))

fpr, tpr, _ = metrics.roc_curve(y_test, grid_kn.predict_proba(X_test)[:,1])

plt.plot(fpr, tpr, linestyle = 'solid', color ='red')

plt.stackplot(fpr, tpr, color='steelblue')

plt.plot([0,1],[0,1],linestyle='dashed', color='black')

plt.text(0.6, 0.4, 'AUC=%.3f' % metrics.auc(fpr,tpr), fontdict=dict(size =16))

plt.show()

income 0 1

row_0

0 5838 861

1 388 1054

模型在训练集上的准确率为0.882924

模型在测试集上的准确率为0.846579

相比于默认参数的K近邻模型来说，经过网格搜索后的模型在训练数据集上的准确率下降了，但在测试数据集上的准确率提高了，这也是我们所期望的，说明优化后的模型在预测效果上更加优秀，并且两者差异的缩小也能够降低模型过拟合的可能。再来看看ROC曲线下的面积，网格搜索后的K近邻模型所对应的AUC为0.87，相比于原先的KNN模型提高了一点。所以，从模型的稳定性来看，网格搜索后的K近邻模型比原始的K近邻模型更加优秀。

4.5.3 GBDT模型在测试集上的预测

from sklearn import metrics

gbdt_pred = gdbt.predict(X_test)

print(pd.crosstab(gbdt_pred, y_test))

# 模型得分

print("模型在训练集上的准确率为%f" % gbdt.score(X_train, y_train))

print("模型在测试集上的准确率为%f" % gbdt.score(X_test, y_test))

fpr, tpr, _ = metrics.roc_curve(y_test, gbdt.predict_proba(X_test)[:,1])

plt.plot(fpr, tpr, linestyle = 'solid', color ='red')

plt.stackplot(fpr, tpr, color='steelblue')

plt.plot([0,1],[0,1],linestyle='dashed', color='black')

plt.text(0.6, 0.4, 'AUC=%.3f' % metrics.auc(fpr,tpr), fontdict=dict(size =16))

plt.show()

income 0 1

row_0

0 5869 780

1 357 1135

模型在训练集上的准确率为0.869861

模型在测试集上的准确率为0.860337

集成算法GBDT在测试集上的表现明显要比K近邻算法优秀，这就是基于多棵决策树进行投票的优点。该模型在训练集和测试集上的表现都非常好，准确率均超过85%，而且AUC值也是前面两种模型中最高的，达到了0.914。

4.5.4 网格搜索的GBDT模型在测试集上的预测

from sklearn import metrics

grid_gbdt_pred = grid_gbdt.predict(X_test)

print(pd.crosstab(grid_gbdt_pred , y_test))

# 模型得分

print("模型在训练集上的准确率为%f" % grid_gbdt.score(X_train, y_train))

print("模型在测试集上的准确率为%f" % grid_gbdt.score(X_test, y_test))

fpr, tpr, _ = metrics.roc_curve(y_test, grid_gbdt.predict_proba(X_test)[:,1])

plt.plot(fpr, tpr, linestyle = 'solid', color ='red')

plt.stackplot(fpr, tpr, color='steelblue')

plt.plot([0,1],[0,1],linestyle='dashed', color='black')

plt.text(0.6, 0.4, 'AUC=%.3f' % metrics.auc(fpr,tpr), fontdict=dict(size =16))

plt.show()

income 0 1

row_0

0 5835 669

1 391 1246

模型在训练集上的准确率为0.889271

模型在测试集上的准确率为0.869795

基于网格搜索后的GBDT模型的表现，从准确率来看，是4个模型中表现最佳的，该模型在训练集上的准确率接近89%，同时，在测试集上的准确率也超过86%；从绘制的ROC曲线来看，AUC的值也是最高的，超过0.92。

不论是K近邻模型，还是梯度提升树GBDT模型，都可以通过网格搜索法找到各自的最佳模型参数，而且这些最佳参数的组合一般都会使模型比较优秀和健壮。所以，纵向比较默认参数的模型和网格搜索后的最佳参数模型，后者可能是比较好的选择(尽管后者可能会花费更多的运行时间)；横向比较单一模型和集成模型，集成模型一般会比单一模型表现优秀。

5.实验总结

本次收入预测问题属于机器学习中的聚类问题，主要是通过数据集中的income变量将数据分成了两个类别(年收入大于5W和年收入小于等于5W)。

本次实验主要收获是：

1.熟悉了数据挖掘的重要流程(预览数据集，明确分析的目的--导入数据并数据预处理--探索数据特征--清洗数据，构建模型--模型预测，模型评估)。

2.初步了解了python sklearn中的两个机器学习模型K近邻和GBDT(梯度提升树)和用网格搜索法改进模型参数优化模型。

3.本章还学习到了pands,matplotlib。