构建scikit-learn_buildroot scikit-learn-CSDN博客

scikit-learn构建模型

sklearn转换器处理数据
构建并评价聚类模型
构建并评价分类模型
构建并评价回归模型

sklearn转换器处理数据

sklean有model_selection模型选择模块、preprocessing数据预处理模块与decomposition特征分解模块。通过这三个模块能够实现数据的预处理与模型构建前的数据标准化、二值化、数据集的分割、交叉验证和PCA降维等工作。

加载datasets模块中的数据集

sklearn库的datasets模块集成了部分数据分析的经典数据集。使用data：获取数据集数据；target：标签；feature_names：特征名称；DECSR：描述信息

datasets模块常用数据集加载函数及其解释

数据集加载函数	数据集任务类型	数据集加载函数	数据集任务类型
load_boston	回归	load_breast_cancer	分类、聚类
fetch_california_housing	回归	load_iris	分类、聚类
load_digits	分类	load_wine	分类

加载breast_cancer数据集

from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()##将数据集赋值给iris变量
print('breast_cancer数据集的长度为：',len(cancer))
print('breast_cancer数据集的类型为：',type(cancer))

   
   
   
   1
2
3
4

breast_cancer数据集的长度为： 6
breast_cancer数据集的类型为： <class 'sklearn.utils.Bunch'>

   
   
   
   1
2

sklearn自带数据集内部信息获取

cancer_data = cancer['data']
print('breast_cancer数据集的数据为：','\n',cancer_data)

cancer_target = cancer[‘target’] # 取出数据集的标签
print(‘breast_cancer数据集的标签为：\n’,cancer_target)

cancer_names = cancer[‘feature_names’] # 取出数据集的特征名
print(‘breast_cancer数据集的特征名为：\n’,cancer_names)

cancer_desc = cancer[‘DESCR’] # 取出数据集的描述信息
print(‘breast_cancer数据集的描述信息为：\n’,cancer_desc)

breast_cancer数据集的数据为： 
 [[1.799e+01 1.038e+01 1.228e+02 ... 2.654e-01 4.601e-01 1.189e-01]
 [2.057e+01 1.777e+01 1.329e+02 ... 1.860e-01 2.750e-01 8.902e-02]
 [1.969e+01 2.125e+01 1.300e+02 ... 2.430e-01 3.613e-01 8.758e-02]
 ...
 [1.660e+01 2.808e+01 1.083e+02 ... 1.418e-01 2.218e-01 7.820e-02]
 [2.060e+01 2.933e+01 1.401e+02 ... 2.650e-01 4.087e-01 1.240e-01]
 [7.760e+00 2.454e+01 4.792e+01 ... 0.000e+00 2.871e-01 7.039e-02]]
breast_cancer数据集的标签为：
 [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 1 0 0 0 0 0 0 0 0 1 0 1 1 1 1 1 0 0 1 0 0 1 1 1 1 0 1 0 0 1 1 1 1 0 1 0 0
 1 0 1 0 0 1 1 1 0 0 1 0 0 0 1 1 1 0 1 1 0 0 1 1 1 0 0 1 1 1 1 0 1 1 0 1 1
 1 1 1 1 1 1 0 0 0 1 0 0 1 1 1 0 0 1 0 1 0 0 1 0 0 1 1 0 1 1 0 1 1 1 1 0 1
 1 1 1 1 1 1 1 1 0 1 1 1 1 0 0 1 0 1 1 0 0 1 1 0 0 1 1 1 1 0 1 1 0 0 0 1 0
 1 0 1 1 1 0 1 1 0 0 1 0 0 0 0 1 0 0 0 1 0 1 0 1 1 0 1 0 0 0 0 1 1 0 0 1 1
 1 0 1 1 1 1 1 0 0 1 1 0 1 1 0 0 1 0 1 1 1 1 0 1 1 1 1 1 0 1 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 0 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1
 1 0 1 1 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 0 1 1 1 1 0 0 0 1 1
 1 1 0 1 0 1 0 1 1 1 0 1 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 0
 0 1 0 0 1 1 1 1 1 0 1 1 1 1 1 0 1 1 1 0 1 1 0 0 1 1 1 1 1 1 0 1 1 1 1 1 1
 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1 0 1 1 1 1 1 0 1 1
 0 1 0 1 1 0 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 0 1
 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 0 0 1 0 1 0 1 1 1 1 1 0 1 1 0 1 0 1 0 0
 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 0 0 0 0 0 0 1]
breast_cancer数据集的特征名为：
 ['mean radius' 'mean texture' 'mean perimeter' 'mean area'
 'mean smoothness' 'mean compactness' 'mean concavity'
 'mean concave points' 'mean symmetry' 'mean fractal dimension'
 'radius error' 'texture error' 'perimeter error' 'area error'
 'smoothness error' 'compactness error' 'concavity error'
 'concave points error' 'symmetry error' 'fractal dimension error'
 'worst radius' 'worst texture' 'worst perimeter' 'worst area'
 'worst smoothness' 'worst compactness' 'worst concavity'
 'worst concave points' 'worst symmetry' 'worst fractal dimension']
breast_cancer数据集的描述信息为：
 .. _breast_cancer_dataset:

Breast cancer wisconsin (diagnostic) dataset

Data Set Characteristics:

:Number of Instances: 569

:Number of Attributes: 30 numeric, predictive attributes and the class

:Attribute Information:
    - radius (mean of distances from center to points on the perimeter)
    - texture (standard deviation of gray-scale values)
    - perimeter
    - area
    - smoothness (local variation in radius lengths)
    - compactness (perimeter^2 / area - 1.0)
    - concavity (severity of concave portions of the contour)
    - concave points (number of concave portions of the contour)
    - symmetry 
    - fractal dimension ("coastline approximation" - 1)

    The mean, standard error, and "worst" or largest (mean of the three
    largest values) of these features were computed for each image,
    resulting in 30 features.  For instance, field 3 is Mean Radius, field
    13 is Radius SE, field 23 is Worst Radius.

    - class:
            - WDBC-Malignant
            - WDBC-Benign

:Summary Statistics:

===================================== ====== ======
                                       Min    Max
===================================== ====== ======
radius (mean):                        6.981  28.11
texture (mean):                       9.71   39.28
perimeter (mean):                     43.79  188.5
area (mean):                          143.5  2501.0
smoothness (mean):                    0.053  0.163
compactness (mean):                   0.019  0.345
concavity (mean):                     0.0    0.427
concave points (mean):                0.0    0.201
symmetry (mean):                      0.106  0.304
fractal dimension (mean):             0.05   0.097
radius (standard error):              0.112  2.873
texture (standard error):             0.36   4.885
perimeter (standard error):           0.757  21.98
area (standard error):                6.802  542.2
smoothness (standard error):          0.002  0.031
compactness (standard error):         0.002  0.135
concavity (standard error):           0.0    0.396
concave points (standard error):      0.0    0.053
symmetry (standard error):            0.008  0.079
fractal dimension (standard error):   0.001  0.03
radius (worst):                       7.93   36.04
texture (worst):                      12.02  49.54
perimeter (worst):                    50.41  251.2
area (worst):                         185.2  4254.0
smoothness (worst):                   0.071  0.223
compactness (worst):                  0.027  1.058
concavity (worst):                    0.0    1.252
concave points (worst):               0.0    0.291
symmetry (worst):                     0.156  0.664
fractal dimension (worst):            0.055  0.208
===================================== ====== ======

:Missing Attribute Values: None

:Class Distribution: 212 - Malignant, 357 - Benign

:Creator:  Dr. William H. Wolberg, W. Nick Street, Olvi L. Mangasarian

:Donor: Nick Street

:Date: November, 1995

This is a copy of UCI ML Breast Cancer Wisconsin (Diagnostic) datasets.
https://goo.gl/U2Uwz2

Features are computed from a digitized image of a fine needle
aspirate (FNA) of a breast mass. They describe
characteristics of the cell nuclei present in the image.

Separating plane described above was obtained using
Multisurface Method-Tree (MSM-T) [K. P. Bennett, “Decision Tree
Construction Via Linear Programming.” Proceedings of the 4th
Midwest Artificial Intelligence and Cognitive Science Society,
pp. 97-101, 1992], a classification method which uses linear
programming to construct a decision tree. Relevant features
were selected using an exhaustive search in the space of 1-4
features and 1-3 separating planes.

The actual linear program used to obtain the separating plane
in the 3-dimensional space is that described in:
[K. P. Bennett and O. L. Mangasarian: “Robust Linear
Programming Discrimination of Two Linearly Inseparable Sets”,
Optimization Methods and Software 1, 1992, 23-34].

This database is also available through the UW CS ftp server:

ftp ftp.cs.wisc.edu
cd math-prog/cpo-dataset/machine-learn/WDBC/

… topic:: References

W.N. Street, W.H. Wolberg and O.L. Mangasarian. Nuclear feature extraction
for breast tumor diagnosis. IS&T/SPIE 1993 International Symposium on
Electronic Imaging: Science and Technology, volume 1905, pages 861-870,
San Jose, CA, 1993.
O.L. Mangasarian, W.N. Street and W.H. Wolberg. Breast cancer diagnosis and
prognosis via linear programming. Operations Research, 43(4), pages 570-577,
July-August 1995.
W.H. Wolberg, W.N. Street, and O.L. Mangasarian. Machine learning techniques
to diagnose breast cancer from fine-needle aspirates. Cancer Letters 77 (1994)
163-171.

将数据集划分为训练集和测试集

为了保证模型在实际系统中能够起到预期作用，数据量多的时候，一般需要将样本分成独立的三部分：训练集（train set）：估计模型、验证集（validation set）：确定网络结构或者控制模型复杂程度的参数、测试集（test set）：检验最优模型的性能。典型划分方式训练集50%、验证集25%、测试集25%。；数据量较少的时候，常用的方法是留少部分做测试机，然后对其余N个样本采用K折交叉验证法：将样本打乱，然后均匀分成K份，轮流选择其中K-1份做训练，剩余的一份做验证，计算预期误差平方和，然后把K次的预测误差平方和的均值作为选择最优模型结构的依据。拆分语法：sklearn.model_selection_train_test_split(*arrays,**options)

train_test_split常用参数及其说明

参数名称	说明
*arrays	接收一个或多个数据集。代表需要划分的数据集。若为分类回归，则分别传入数据和标签；若为聚类，则传入数据。无默认
test_size	接收float、int类型的数据或者None。代表测试集的大小。如果传入的为float类型的数据，则需要限定在0-1之间，代表测试集在总数中的占比；如果传入的为int类型的数据，则表示测试集记录的绝对数目。该参数与test_size可以只传入一个。
train_size	接收float、int类型的数据或者None。代表训练集的大小。该参数与test_size可以只传入一个
random_state	接收int。代表随机种子编号，相同随机种子编号产生相同的随即结果，不同的随机种子编号产生不同的随机结果。默认为None
shuffle	接收boolean。代表是否进行有放回抽样。若该参数取值为True，则stratify参数必需不能为空
stratify	接收array或者None。如果不为None，则使用传的标签进行分层抽样

使用train_test_split划分数据集

print('原始数据集数据的形状为：',cancer_data.shape)
print('原始数据集标签的形状为：',cancer_target.shape)

from sklearn.model_selection import train_test_split
cancer_data_train, cancer_data_test,cancer_target_train, cancer_target_test = train_test_split(cancer_data, cancer_target,
test_size=0.2, random_state=42)
print(‘训练集数据的形状为：’,cancer_data_train.shape)
print(‘训练集标签的形状为：’,cancer_target_train.shape)
print(‘测试集数据的形状为：’,cancer_data_test.shape)
print(‘测试集标签的形状为：’,cancer_target_test.shape)

原始数据集数据的形状为： (569, 30)
原始数据集标签的形状为： (569,)
训练集数据的形状为： (455, 30)
训练集标签的形状为： (455,)
测试集数据的形状为： (114, 30)
测试集标签的形状为： (114,)

 
 
 
 1
2
3
4
5
6

使用sklearn转换器进行数据预处理与降维

转换器的是单个方法及其说明

方法名称	说明
fit	fit方法主要通过分析特征和目标值提取有价值的信息，这些信息可以是统计量，也可以是权值系数等
transform	transform方法主要用来对特征值进行转换。从可利用信息的角度分为无信息转化和有信息转化。无信息转化是指不利用任何其他信息进行转换，比如指数和对数函数转换等。有信息转换根据是否利用目标值向量又可以分为无监督转换和有监督转换。无监督转换指只利用特征的统计信息的转换，比如标准化和PCA降维等。有监督转换指既利用了特征信息又利用了目标值信息的转换，比如通过模型选择特征和LDA降维等
fit_transform	fit_transform方法就是先调用fit方法，然后调用transform方法

使用sklearn转换器能够实现对传入的Numpy数组进行标准化处理、归一化处理、二值化处理和PCA降维等操作。
离差标准化

import numpy as np
from sklearn.preprocessing import MinMaxScaler
Scaler = MinMaxScaler().fit(cancer_data_train)  # 生成规则
# 将规则应用于训练集
cancer_trainScaler = Scaler.transform(cancer_data_train) 
# 将规则应用于测试集
cancer_testScaler = Scaler.transform(cancer_data_test)
print('离差标准化前训练集数据的最小值为：',np.min(cancer_data_train))
print('离差标准化后训练集数据的最小值为：',np.min(cancer_trainScaler))
print('离差标准化前训练集数据的最大值为：',np.max(cancer_data_train))
print('离差标准化后训练集数据的最大值为：',np.max(cancer_trainScaler))
print('离差标准化前测试集数据的最小值为：',np.min(cancer_data_test))
print('离差标准化后测试集数据的最小值为：',np.min(cancer_testScaler))
print('离差标准化前测试集数据的最大值为：',np.max(cancer_data_test))
print('离差标准化后测试集数据的最大值为：',np.max(cancer_testScaler))

 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

离差标准化前训练集数据的最小值为： 0.0
离差标准化后训练集数据的最小值为： 0.0
离差标准化前训练集数据的最大值为： 4254.0
离差标准化后训练集数据的最大值为： 1.0000000000000002
离差标准化前测试集数据的最小值为： 0.0
离差标准化后测试集数据的最小值为： -0.057127602776294695
离差标准化前测试集数据的最大值为： 3432.0
离差标准化后测试集数据的最大值为： 1.3264399566986453

 
 
 
 1
2
3
4
5
6
7
8

sklearn除了提供离差标准化函数MinMaxScaler外，还提供了一系列数据预处理函数。

sklearn部分预处理函数与其作用

函数名称	说明
StandarScaler	对特征进行标准差标准化
Normalizer	对特征进行归一化
Binarizer	对定量特征进行二值化处理
OneHotEncoder	对送行特征进行热度编码处理
FunctionTransformer	对特征进行自定义函数变换

PCA降维算法函数常用参数及其作用

函数名称	说明
n_components	接收None、int、float或mle。未指定时，代表所有特征均会被保留下来；如果为int，则表示将原始数据降低到n个维度；如果为float，则PCA根据样本特征方差来决定降维后的维度数；赋值为“mle”，PCA会用MLE算法根据特征的方差分布情况自动选择一定数量的主成分特征来降维。默认为None
copy	接收boolean。代表是否在运行算法时将原始数据复制一份，如果为True，则运行后，原始数据的值不会有任何改变；如果为False，则运行PCA算法后，原始数据的值会发生改变。默认为False
whiten	接收boolean。表示白化。所谓白化，就是对降维后的数据的每个特征进行归一化，让方差都为1。默认为False
svd_solver	接收auto、full、arpack、randomized。代表使用的SVD算法。randomized一般适用于数据量大，数据维度多，同时主成分数目比例又较低的PCA降维，它使用了一些加快SVD的随机算法。full是使用SciPy库实现的传统SVD算法。arpack和randomized的适用场景类似，区别是，randomized使用的是sklearn自己的SVD实现，而arpack直接使用了SciPy库的sparseSVD实现。auto则代表PCA类会自动在上述三种算法中去均衡，选择一个合适的SVD算法来降维。默认为auto

对breast_cancer数据集PCA降维

from sklearn.decomposition import PCA
pca_model = PCA(n_components=10).fit(cancer_trainScaler)  # 生成规则
cancer_trainPca = pca_model.transform(cancer_trainScaler)  # 将规则应用于训练集
cancer_testPca = pca_model.transform(cancer_testScaler)  # 将规则应用于测试集
print('PCA降维前训练集数据的形状为：',cancer_trainScaler.shape)
print('PCA降维后训练集数据的形状为：',cancer_trainPca.shape)
print('PCA降维前测试集数据的形状为：',cancer_testScaler.shape)
print('PCA降维后测试集数据的形状为：',cancer_testPca.shape)

 
 
 
 1
2
3
4
5
6
7
8

PCA降维前训练集数据的形状为： (455, 30)
PCA降维后训练集数据的形状为： (455, 10)
PCA降维前测试集数据的形状为： (114, 30)
PCA降维后测试集数据的形状为： (114, 10)

 
 
 
 1
2
3
4

任务实现

读取数据–读取自带的boston数据集

from sklearn.datasets import load_boston
boston = load_boston()
boston_data = boston['data']
boston_target = boston['target']
boston_names = boston['feature_names']
print('boston数据集数据的形状为：',boston_data.shape)
print('boston数据集标签的形状为：',boston_target.shape)
print('boston数据集特征名的形状为：',boston_names.shape)

 
 
 
 1
2
3
4
5
6
7
8

boston数据集数据的形状为： (506, 13)
boston数据集标签的形状为： (506,)
boston数据集特征名的形状为： (13,)

 
 
 
 1
2
3

将数据集划分为训练集和测试集

from sklearn.model_selection import train_test_split
boston_data_train, boston_data_test, boston_target_train, boston_target_test = \
train_test_split(boston_data, boston_target, test_size=0.2, random_state=42)
print('训练集数据的形状为：',boston_data_train.shape)
print('训练集标签的形状为：',boston_target_train.shape)
print('测试集数据的形状为：',boston_data_test.shape)
print('测试集标签的形状为：',boston_target_test.shape)

 
 
 
 1
2
3
4
5
6
7

训练集数据的形状为： (404, 13)
训练集标签的形状为： (404,)
测试集数据的形状为： (102, 13)
测试集标签的形状为： (102,)

 
 
 
 1
2
3
4

使用转换器进行数据预处理

from sklearn.preprocessing import StandardScaler
stdScale = StandardScaler().fit(boston_data_train)  # 生成规则
# 将规则应用于训练集
boston_trainScaler = stdScale.transform(boston_data_train) 
# 将规则应用于测试集
boston_testScaler = stdScale.transform(boston_data_test)
print('标准差标准化后训练集数据的方差为：',np.var(boston_trainScaler))
print('标准差标准化后训练集数据的均值为：',
    np.mean(boston_trainScaler))
print('标准差标准化后测试集数据的方差为：',np.var(boston_testScaler))
print('标准差标准化后测试集数据的均值为：',np.mean(boston_testScaler))

 
 
 
 1
2
3
4
5
6
7
8
9
10
11

标准差标准化后训练集数据的方差为： 1.0
标准差标准化后训练集数据的均值为： 1.3637225393110834e-15
标准差标准化后测试集数据的方差为： 0.9474773930196593
标准差标准化后测试集数据的均值为： 0.030537934487192598

 
 
 
 1
2
3
4

使用转化器进行PCA降维

from sklearn.decomposition import PCA
pca = PCA(n_components=5).fit(boston_trainScaler)  # 生成规则
# 将规则应用于训练集
boston_trainPca = pca.transform(boston_trainScaler) 
# 将规则应用于测试集
boston_testPca = pca.transform(boston_testScaler)
print('降维后boston数据集数据测试集的形状为：',boston_trainPca.shape)
print('降维后boston数据集数据训练集的形状为：',boston_testPca.shape)

 
 
 
 1
2
3
4
5
6
7
8

降维后boston数据集数据测试集的形状为： (404, 5)
降维后boston数据集数据训练集的形状为： (102, 5)

 
 
 
 1
2

构建并评价聚类模型

聚类分析是在没有给定划分类别的情况下，根据数据相似度进行样本分组的一种方法。可以将无类标记的数据汇聚为多个簇，视为一类，是一种非监督的学习算法。聚类可以帮助市场分析人员从消费者数据库中区分不同的消费群体，而且概括出每一类消费者的消费模式或消费习惯。也能作为数据分析算法中其他分析算法的一个预处理步骤，比如异常值识别、连续型特征离散化等。

使用sklearn估计器构建聚类模型

聚类的输入是一组违背标记的样本，聚类根据数据自身的距离或相似度将他们划分为若干组，划分的原则是组内（内部）距离最小化，而组间（外部）距离最大化.

聚类算法类别

算法类别	包括的主要算法
划分（分裂）方法	K-Means算法（K-平均）、K-MEDOIDS算法（K-中心点）和CLARANS算法（基于选择的算法）
层次分析方法	BIRCH算法（平衡迭代规约和聚类）、CURE算法（代表点聚类）和CHAMELEON算法（动态模型）
基于密度的方法	DBSCAN算法（基于高密度链接区域）、DENCLUE算法（密度分布函数）和OPTICS算法（对象排序识别）
基于网格的方法	STING算法（统计信息网络）、CLIOUE算法（聚类高维空间）和WAVE-CLUSTER算法（小波变换）

cluster提供的聚类算法及其适用范围

函数名称	参数	适用范围	距离度量
K-Means	簇数	可用于样本数量很大，聚类数目中等的场景	点之间的距离
Spectral clustering	簇数	可用于样本数目中等、聚类数目较小的场景	图距离
Ward hierarchical clustering	簇数	可用于样本数目较大、聚类数目较大的场景	点之间的距离
Agglomerative clustering	簇数、链接类型、距离	可用于样本数目较大、聚类数目较大的场景	任意成对点线图间的距离
DBSCAN	半径大小、最低成员数目	可用于样本数目很大、聚类数目中等的场景	最近的点之间的距离
Birch	分支因子、阈值、可选全局集群	可用于样本数目很大、聚类数目较大的场景	点之间的欧氏距离

估计器Estimator两个方法的说明

方法名称	说明
fit	fit方法主要用于训练算法。该方法可接收用于有监督学习的训练集及其标签两个参数，也可以接收用于无监督学习的数据
predict	predict用于预测有监督学习的测试集标签，亦可用于划分传入数据的类别

使用sklearn估计器构建K-Means聚类模型

from sklearn.datasets import load_iris
from sklearn.preprocessing import MinMaxScaler
from sklearn.cluster import KMeans
iris = load_iris()
iris_data = iris['data'] # 提取数据集中的特征
iris_target = iris['target']  # 提取数据集中的标签
iris_names = iris['feature_names']  # 提取特征名
scale = MinMaxScaler().fit(iris_data)  # 训练规则
iris_dataScale = scale.transform(iris_data)  # 应用规则
kmeans = KMeans(n_clusters = 3,
    random_state=123).fit(iris_dataScale)  # 构建并训练模型
print('构建的K-Means模型为：\n',kmeans)

result = kmeans.predict([[1.5,1.5,1.5,1.5]])
print(‘花瓣花萼长度宽度全为1.5的鸢尾花预测类别为：’, result[0])

构建的K-Means模型为：
 KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,
       n_clusters=3, n_init=10, n_jobs=None, precompute_distances='auto',
       random_state=123, tol=0.0001, verbose=0)
花瓣花萼长度宽度全为1.5的鸢尾花预测类别为： 0

 
 
 
 1
2
3
4
5

使用sklearn中manifold模块对聚类结果可视化

import pandas as pd
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
# 使用TSNE进行数据降维,降成两维
tsne = TSNE(n_components=2,init='random',random_state=177).fit(iris_data)
df=pd.DataFrame(tsne.embedding_)  # 将原始数据转换为DataFrame
df['labels'] = kmeans.labels_  # 将聚类结果存储进df数据表
# 提取不同标签的数据
df1 = df[df['labels']==0]
df2 = df[df['labels']==1] 
df3 = df[df['labels']==2] 
# 绘制图形
fig = plt.figure(figsize=(9,6))  # 设定空白画布，并制定大小
# 用不同的颜色表示不同数据
plt.plot(df1[0],df1[1],'bo',df2[0],df2[1],'r*',
    df3[0],df3[1],'gD')
plt.savefig('./聚类结果.png') 
plt.show()  # 显示图片

 
 
 
 
  
  
 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在这里插入代码片
分析：本次聚类类别分布比较均匀，不同类别数目差别不大。除个别点意外，类与类间的界限明显，聚类效果良好。

评价聚类模型

聚类评价的指标是组内的对象相互之间是相似的（相关的），而不同组中的对象是不同的（不相关的）。即组内的相似性越大，组间差别越大，聚类效果就越好。

metrics模块提供的聚类模型评价指标

方法名称	真实值	最佳值	sklearn函数
ARI评价法（兰德系数）	需要	1.0	adjusted_rand_score
AMI评价法（互信息）	需要	1.0	adjusted_mutual_info_score
V-measure评分	需要	1.0	completeness_score
FMI评价法	需要	1.0	fowlkes_mallows_score
轮廓系数评价法	不需要	畸变程度最大	silhouette_score
Calinski_Harabasz指标评价法	不需要	相较最大	calinske_harabaz_score

前四中方法评价的效果更具有说服力，并且在实际运行的过程中，在有真实值做参考的情况下，聚类方法的评价可以等同于分类算法的评价。除轮廓系数外，在不考虑业务场景的情况下得分越高效果越好，最高分值为1。轮廓系数评价则需要判断不同类别情况下的轮廓系数的走势，寻找最优的聚类数目。

使用FMI评价法评价K-Means聚类模型

from sklearn.metrics import fowlkes_mallows_score
for i in range(2,7):
    # 构建并训练模型
    kmeans = KMeans(n_clusters = i,random_state=123).fit(iris_data)
    score = fowlkes_mallows_score(iris_target,kmeans.labels_)
    print('iris数据聚%d类FMI评价分值为：%f' %(i,score))

 
 
 
 1
2
3
4
5
6

iris数据聚2类FMI评价分值为：0.750473
iris数据聚3类FMI评价分值为：0.820808
iris数据聚4类FMI评价分值为：0.756593
iris数据聚5类FMI评价分值为：0.725483
iris数据聚6类FMI评价分值为：0.614345

 
 
 
 1
2
3
4
5

分析：iris聚三类的时候FMI评价法得分最高，故聚类为3的时候K-Means聚类模型最好。

使用轮廓系数评价法评价K-Means聚类模型

from sklearn.metrics import silhouette_score
import matplotlib.pyplot as plt
silhouettteScore = []
for i in range(2,15):
    # 构建并训练模型
    kmeans = KMeans(n_clusters = i,random_state=123).fit(iris_data)
    score = silhouette_score(iris_data,kmeans.labels_)
    silhouettteScore.append(score)
plt.figure(figsize=(10,6))
plt.plot(range(2,15),silhouettteScore,linewidth=1.5, linestyle="-")
plt.show()

 
 
 
 1
2
3
4
5
6
7
8
9
10
11

在这里插入图片描述
分析：从图中结果可以看出，聚类数目为2、3和5、6时平均畸变程度最大。由于iris数据本身就是3种鸢尾花的花瓣、花萼长度和宽度的数据，侧面说明了聚类数目为3的时候效果最佳。

使用Calinski-Harabasz指数评价K-Means聚类模型

from sklearn.metrics import calinski_harabaz_score
for i in range(2,7):
    # 构建并训练模型
    kmeans = KMeans(n_clusters = i,random_state=123).fit(iris_data)
    score = calinski_harabaz_score(iris_data,kmeans.labels_)
    print('iris数据聚%d类calinski_harabaz指数为：%f'%(i,score))

 
 
 
 1
2
3
4
5
6

iris数据聚2类calinski_harabaz指数为：513.924546
iris数据聚3类calinski_harabaz指数为：561.627757
iris数据聚4类calinski_harabaz指数为：530.765808
iris数据聚5类calinski_harabaz指数为：495.541488
iris数据聚6类calinski_harabaz指数为：469.836633

 
 
 
 1
2
3
4
5

分析：calinski_harabaz指数评价K-Means聚类模型的时候，聚类数目为3的时候得分最高，所以可以认为iris数据聚类为3类的时候效果最优。

在没有真实值作为参考的时候，轮廓系数评价法和calinski_harabaz指数评价法可以结合使用。

任务实现

Seeds数据集存放了不同品种小麦种子的区域、周长、压实度、籽粒长度、籽粒宽度、不对称系数、籽粒腹沟长度以及类别数据。该数据集总共210条记录，7个特征、一个标签，标签分为3类。

构建K-Means聚类模型

import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
seeds = pd.read_csv('./data/seeds_dataset.txt',sep = '\t')
print('数据集形状为：', seeds.shape)
# 处理数据
seeds_data = seeds.iloc[:,:7].values
seeds_target = seeds.iloc[:,7].values
sees_names = seeds.columns[:7]
stdScale = StandardScaler().fit(seeds_data)
seeds_dataScale = stdScale.transform(seeds_data)
# 构建并训练模型
kmeans = KMeans(n_clusters = 3,random_state=42).fit(seeds_data)
print('构建的KM-eans模型为：\n',kmeans)

 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14

数据集形状为： (210, 8)
构建的KM-eans模型为：
 KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,
       n_clusters=3, n_init=10, n_jobs=None, precompute_distances='auto',
       random_state=42, tol=0.0001, verbose=0)

 
 
 
 1
2
3
4
5

评价构建的K-Means聚类模型

from sklearn.metrics import calinski_harabaz_score
for i in range(2,7):
    # 构建并训练模型
    kmeans = KMeans(n_clusters = i,random_state=12).fit(seeds_data)
    score = calinski_harabaz_score(seeds_data,kmeans.labels_)
    print('seeds数据聚%d类calinski_harabaz指数为：%f'%(i,score))

 
 
 
 1
2
3
4
5
6

seeds数据聚2类calinski_harabaz指数为：351.179992
seeds数据聚3类calinski_harabaz指数为：375.804961
seeds数据聚4类calinski_harabaz指数为：327.439099
seeds数据聚5类calinski_harabaz指数为：309.769975
seeds数据聚6类calinski_harabaz指数为：302.393627

 
 
 
 1
2
3
4
5

分析：在聚类数目为3的时候，Calinski-Harabasz系数最大，表明此时聚类模型效果最好，故Seeds数据集最优聚类数目为3类。结合元数据种的target，类别数目恰好为3类。

构建并评价分类模型

分类是指构造一个分类模型，输入样本的特征集，输入样本的特征值，输出对应的类别，将每个样本映射到预先设定好的类别。分类模型建立在已有类标记的数据集上，属于有监督学习。在实际应用场景种，分类算法被用于行为分析、物品标记、图像检测等。

使用sklearn估计器构建分类模型

sklearn库的常用分类算法

模块名称	函数名称	算法名称
linear_model	LogisticRegression	逻辑斯蒂回归
svm	SVC	支持向量机
neighbors	KNeighborsClassifier	K最近邻分类
naive_bayes	GaussianNB	高斯朴素贝叶斯
tree	DecisionTreeClassifier	分类决策树
ensemble	RandomForestClassifier	随机森林分类
ensemble	GradientBoostingClassifier	梯度提升分类树

使用sklearn估计器构建SVM模型

# 加载所需的函数
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
cancer = load_breast_cancer()
cancer_data = cancer['data']
cancer_target = cancer['target']
cancer_names = cancer['feature_names']
# 将数据划分为训练集测试集
cancer_data_train,cancer_data_test, \
cancer_target_train,cancer_target_test = \
train_test_split(cancer_data,cancer_target,
      test_size = 0.2,random_state = 22)
# 数据标准化
stdScaler = StandardScaler().fit(cancer_data_train)
cancer_trainStd = stdScaler.transform(cancer_data_train)
cancer_testStd = stdScaler.transform(cancer_data_test)
# 建立SVM模型
svm = SVC().fit(cancer_trainStd,cancer_target_train)
print('建立的SVM模型为：\n',svm)
# 预测训练集结果
cancer_target_pred = svm.predict(cancer_testStd)
print('预测前20个结果为：\n',cancer_target_pred[:20])

 
 
 
 
  
  
 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

建立的SVM模型为：
 SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',
    max_iter=-1, probability=False, random_state=None, shrinking=True,
    tol=0.001, verbose=False)
预测前20个结果为：
 [1 0 0 0 1 1 1 1 1 1 1 1 0 1 1 1 0 0 1 1]

 
 
 
 1
2
3
4
5
6
7

分类结果的混淆矩阵与准确性

# 求出预测和真实一样的数目
true = np.sum(cancer_target_pred == cancer_target_test )
print('预测对的结果数目为：', true)
print('预测错的的结果数目为：', cancer_target_test.shape[0]-true)
print('预测结果准确率为：', true/cancer_target_test.shape[0])

 
 
 
 1
2
3
4
5

预测对的结果数目为： 111
预测错的的结果数目为： 3
预测结果准确率为： 0.9736842105263158

 
 
 
 1
2
3

分析：将预测结果和真实结果做对比，求出预测对的结果和预测错的结果，并求出准确率。SVM模型预测结果的准确率为97.4，只有3个测试样本识别错误，说明了整体效果比较理想。

评价分类模型

准确率并不能很好的反映模型的性能，为了有效判断一个预测模型的性能表现，需要结合真实值计算出精确率、召回率、F1值和Cohen’s Kappa系数等指标来衡量。

分类模型评价方法

方法名称	最佳值	sklearn函数
Precision(精确率)	1.0	metrics.precision_score
Recall(召回率)	1.0	metrics.recall_score
F1值	1.0	metrics.f1_score
Cohen’s Kappa系数	1.0	metrics.cohen_kappa_score
ROC曲线	最靠近y轴	metrics.roc_curve

前4种都是分值越高越好，其使用方法基本相同。

分类模型常用评价方法

from sklearn.metrics import accuracy_score,precision_score, recall_score,f1_score,cohen_kappa_score
print('使用SVM预测breast_cancer数据的准确率为：',
      accuracy_score(cancer_target_test,cancer_target_pred))
print('使用SVM预测breast_cancer数据的精确率为：',
      precision_score(cancer_target_test,cancer_target_pred))
print('使用SVM预测breast_cancer数据的召回率为：',
      recall_score(cancer_target_test,cancer_target_pred))
print('使用SVM预测breast_cancer数据的F1值为：',
      f1_score(cancer_target_test,cancer_target_pred))
print('使用SVM预测breast_cancer数据的Cohen’s Kappa系数为：',
      cohen_kappa_score(cancer_target_test,cancer_target_pred))

 
 
 
 1
2
3
4
5
6
7
8
9
10
11

使用SVM预测breast_cancer数据的准确率为： 0.9736842105263158
使用SVM预测breast_cancer数据的精确率为： 0.9594594594594594
使用SVM预测breast_cancer数据的召回率为： 1.0
使用SVM预测breast_cancer数据的F1值为： 0.9793103448275862
使用SVM预测breast_cancer数据的Cohen’s Kappa系数为： 0.9432082364662903

 
 
 
 1
2
3
4
5

分析：多种方法的得分十分接近1，说明了建立的SVM模型是有效的。sklearn的metrics模型处理除了提供Precision等单一评价指标的函数外，还提供了一个能够输出分类模型评价指标报告的函数classification_report。

分类模型评价报告

from sklearn.metrics import classification_report
print('使用SVM预测iris数据的分类报告为：','\n',classification_report(cancer_target_test,cancer_target_pred))

 
 
 
 1
2

使用SVM预测iris数据的分类报告为： 
               precision    recall  f1-score   support
       0       1.00      0.93      0.96        43
       1       0.96      1.00      0.98        71

accuracy                           0.97       114

macro avg 0.98 0.97 0.97 114
weighted avg 0.97 0.97 0.97 114

绘制ROC曲线

from sklearn.metrics import roc_curve
import matplotlib.pyplot as plt
# 求出ROC曲线的x轴和y轴
fpr, tpr, thresholds = roc_curve(cancer_target_test,cancer_target_pred)
plt.figure(figsize=(10,6))
plt.xlim(0,1)  # 设定x轴的范围
plt.ylim(0.0,1.1)  # 设定y轴的范围
plt.xlabel('False Postive Rate')
plt.ylabel('True Postive Rate')
plt.plot(fpr,tpr,linewidth=2, linestyle="-",color='red')
x=np.arange(0,1.1,0.1)
y=np.arange(0,1.1,0.1)
plt.plot(x,y,linewidth=2, linestyle="-.",color='blue')
plt.show()

 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这里插入图片描述

分析：ROC曲线与x轴形成的面积越大，表示模型性能越好。当ROC曲线如图中虚线时，表明了模型的计算结果都是随机来的，在此情况下，模型起到的作用几乎为零。在实际情况下，ROC曲线离曲线越远，表示模型效果越好。

任务实现

常规的鲍鱼的年龄时通过显微镜查看切割、染色后的外壳上环的数量得到的，十分耗时，一些常规的物理量（如性别、长度、高度、壳体重量等）的测量十分容易获得，若能使用这些物理量预测年龄，将节省大量时间。

构建SVM分类模型

import pandas as pd
from sklearn.svm import SVC
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
abalone = pd.read_csv('./data/abalone.data',sep=',')
# 将数据和标签拆开
abalone_data = abalone.iloc[:,:8]
abalone_target = abalone.iloc[:,8]
# 连续型特征离散化
sex = pd.get_dummies(abalone_data['sex'])
abalone_data = pd.concat([abalone_data,sex],axis = 1 )
abalone_data.drop('sex',axis = 1,inplace = True)
# 划分训练集，测试集
abalone_train,abalone_test, abalone_target_train,abalone_target_test = train_test_split(abalone_data,abalone_target,
      train_size = 0.8,random_state = 42) 
# 标准化
stdScaler = StandardScaler().fit(abalone_train)
abalone_std_train = stdScaler.transform(abalone_train)
abalone_std_test = stdScaler.transform(abalone_test)
# 建模
svm_abalone = SVC().fit(abalone_std_train,abalone_target_train)
print('建立的SVM模型为：','\n',svm_abalone)

 
 
 
 
  
  
 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

建立的SVM模型为： 
 SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',
    max_iter=-1, probability=False, random_state=None, shrinking=True,
    tol=0.001, verbose=False)

 
 
 
 1
2
3
4
5

评价构建的SVM分类模型

abalone_target_pred = svm_abalone.predict(abalone_std_test)
print('abalone数据集的SVM分类报告为：\n',
      classification_report(abalone_target_test,abalone_target_pred))

 
 
 
 1
2
3

abalone数据集的SVM分类报告为：
               precision    recall  f1-score   support
       3       0.00      0.00      0.00         3
       4       0.45      0.69      0.55        13
       5       0.54      0.22      0.31        32
       6       0.40      0.33      0.36        48
       7       0.41      0.44      0.42        84
       8       0.37      0.36      0.37        99
       9       0.28      0.57      0.38       142
      10       0.24      0.33      0.28       139
      11       0.25      0.25      0.25        93
      12       0.00      0.00      0.00        51
      13       0.00      0.00      0.00        31
      14       0.00      0.00      0.00        26
      15       0.00      0.00      0.00        21
      16       0.00      0.00      0.00        13
      17       0.00      0.00      0.00         8
      18       0.00      0.00      0.00        12
      19       0.00      0.00      0.00         7
      20       0.00      0.00      0.00         4
      21       0.00      0.00      0.00         3
      22       0.00      0.00      0.00         3
      23       0.00      0.00      0.00         4

accuracy                           0.31       836

macro avg 0.14 0.15 0.14 836
weighted avg 0.25 0.31 0.26 836

构建并评价回归模型

分类算法的标签是离散的，回归算法的标签是连续的。回归算法在交通、物流、社交网络和金融领域都能发挥巨大作用。

使用sklearn估计器构建线性回归模型

在回归模型中，自变量与因变量具有相关关系，自变量的值是已知的，因变量是要预测的。回归算法的实现步骤和分类算法基本相同，分为学习和预测两个步骤。学习是通过训练样本数据来拟合回归方程的；预测是利用学习过程中拟合出的回归方程，将测试数据放入方差种求出预测值。

常用的回归模型

回归模型名称	适用条件	算法描述
线性回归	因变量与自变量是线性关系	对一个或多个自变量和因变量之间的线性关系进行建模，可利用最小二乘估计法求解模型系数
非线性回归	因变量与自变量之间不都是线性关系	对一个或多个自变量之间的非线性关系进行建模。如果非线性关系可以通过简单的函数变换转化为线性关系，则可用线性回归的思想求解；如果不能转化，可用非线性最小二乘估计法求解
Logistic回归	自变量一般有1和0（是与否）两种取值	是广义线性回归模型的特例，利用Logistic函数将因变量的取值范围控制在0~1，表示取值为1的概率
岭回归	参与建模的自变量之间具有多重共线性	是一种改进最小二乘估计法的方法
主成分回归	参与建模的自变量之间具有多重共线性	主成分回归是根据主成分分析的思想提出来的，是对最小二乘估计法的一种改进，是参数估计的一种有偏估计。可以消除自变量之间的多重共线性

sklearn库内部的常用回归算法

模块名称	函数名称	算法名称
linear_model	LinearRegression	线性回归
svm	SVR	支持向量回归
neighbors	KNeighborsRegressor	最近邻回归
tree	DecisionTreeRegressor	回归决策树
ensemble	RandomForestRegressor	随机森林回归
ensembleGradientBoostingRegressor	梯度提升回归

使用sklearn估计器构建线性回归模型

# 加载所需函数
from sklearn.linear_model import LinearRegression
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
# 加载boston数据
boston = load_boston()
X = boston['data']
y = boston['target']
names = boston['feature_names']
# 将数据划分为训练集测试集
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.2,random_state=125)
# 建立线性回归模型
clf = LinearRegression().fit(X_train,y_train)
print('建立的LinearRegression模型为：','\n',clf)
# 预测训练集结果
y_pred = clf.predict(X_test)
print('预测前20个结果为：','\n',y_pred[:20])

 
 
 
 
  
  
 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

建立的LinearRegression模型为： 
 LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)
预测前20个结果为： 
 [21.16289134 19.67630366 22.02458756 24.61877465 14.44016461 23.32107187
 16.64386997 14.97085403 33.58043891 17.49079058 25.50429987 36.60653092
 25.95062329 28.49744469 19.35133847 20.17145783 25.97572083 18.26842082
 16.52840639 17.08939063]

 
 
 
 1
2
3
4
5
6
7

回归结果可视化

import matplotlib.pyplot as plt
from matplotlib import rcParams
rcParams['font.sans-serif'] = 'SimHei'
fig = plt.figure(figsize=(10,6))  # 设定空白画布，并制定大小
# 用不同的颜色表示不同数据
plt.plot(range(y_test.shape[0]),y_test,color="blue", linewidth=1.5, linestyle="-")
plt.plot(range(y_test.shape[0]),y_pred,color="red", linewidth=1.5, linestyle="-.")
plt.legend(['真实值','预测值'])
plt.savefig('./聚类结果.png') 
plt.show()  # 显示图片

 
 
 
 1
2
3
4
5
6
7
8
9
10

在这里插入图片描述
分析：除了部分预测值和原值相差较大外，绝大多数拟合效果良好，与实际偏差不大。

评价回归模型

回归模型的性能评价不同于分类模型，虽然都是对照真实值进行评价，但由于回归模型的预测结果和真实值都是连续的，所以不能够求取Precision、Recall和F1值等评价指标。回归模型拥有一套独立的评价指标。

回归模型评价指标

方法名称	最优值	sklearn函数
平均绝对误差	0.0	metrics.mean_absolute_error
均方误差	0.0	metrics.mean_squared_error
中值绝对误差	0.0	metrics.median_absolute_error
可解释平方差	1.0	metrics.explained_variance_error
R^2值	1.0	metrics.r2_score

平均绝对误差、均方误差和中值绝对误差的值越靠近0、模型性能越好。可解释方差值和R^2值越靠近0，模型性能越好。

回归模型评价

from sklearn.metrics import explained_variance_score,mean_absolute_error,mean_squared_error,median_absolute_error,r2_score
print('Boston数据线性回归模型的平均绝对误差为：', mean_absolute_error(y_test,y_pred))
print('Boston数据线性回归模型的均方误差为：', mean_squared_error(y_test,y_pred))
print('Boston数据线性回归模型的中值绝对误差为：', median_absolute_error(y_test,y_pred))
print('Boston数据线性回归模型的可解释方差值为：', explained_variance_score(y_test,y_pred))
print('Boston数据线性回归模型的R方值为：', r2_score(y_test,y_pred))

 
 
 
 1
2
3
4
5
6

Boston数据线性回归模型的平均绝对误差为： 3.3775517360082032
Boston数据线性回归模型的均方误差为： 31.150517390315635
Boston数据线性回归模型的中值绝对误差为： 1.7788996425420756
Boston数据线性回归模型的可解释方差值为： 0.7105475650096659
Boston数据线性回归模型的R方值为： 0.7068961686076838

 
 
 
 1
2
3
4
5

任务实现

房子的估值是一件相对繁琐的事情，使用加利福尼亚住房数据集，可以通过房子的8个外在条件来评估房子的平均价值。

构建线性回归模型

import pandas as pd
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import train_test_split
house = pd.read_csv('./data/cal_housing.data',sep=',')
house_data = house.iloc[:,:-1]
house_target = house.iloc[:,-1]
house_names = ['longitude','latitude','housingMedianAge', 'totalRooms','totalBedrooms','population', 'households', 'medianIncome']
house_train,house_test,house_target_train,house_target_test = train_test_split(house_data,house_target,test_size = 0.2, random_state = 42)
GBR_house = GradientBoostingRegressor().fit(house_train,house_target_train)
print('建立的梯度提升回归模型为：','\n',GBR_house)

 
 
 
 1
2
3
4
5
6
7
8
9
10

建立的梯度提升回归模型为： 
 GradientBoostingRegressor(alpha=0.9, ccp_alpha=0.0, criterion='friedman_mse',
                          init=None, learning_rate=0.1, loss='ls', 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,
                          n_iter_no_change=None, presort='deprecated',
                          random_state=None, subsample=1.0, tol=0.0001,
                          validation_fraction=0.1, verbose=0, warm_start=False)

 
 
 
 1
2
3
4
5
6
7
8
9
10

评价构建的线性回归模型

house_target_pred = GBR_house.predict(house_test)
from sklearn.metrics import explained_variance_score,mean_absolute_error,mean_squared_error,median_absolute_error,r2_score
print('california_housing数据梯度提升回归树模型的平均绝对误差为：', mean_absolute_error(house_target_test,house_target_pred))
print('california_housing数据梯度提升回归树模型的均方误差为：', mean_squared_error(house_target_test,house_target_pred))
print('california_housing数据梯度提升回归树模型的中值绝对误差为：', median_absolute_error(house_target_test,house_target_pred))
print('california_housing数据梯度提升回归树模型的可解释方差值为：', explained_variance_score(house_target_test, house_target_pred))
print('california_housing数据梯度提升回归树模型的R方值为：', r2_score(house_target_test,house_target_pred))

 
 
 
 1
2
3
4
5
6
7

california_housing数据梯度提升回归树模型的平均绝对误差为： 38055.938236527836
california_housing数据梯度提升回归树模型的均方误差为： 3103219873.747233
california_housing数据梯度提升回归树模型的中值绝对误差为： 26179.478445698274
california_housing数据梯度提升回归树模型的可解释方差值为： 0.7618957368088867
california_housing数据梯度提升回归树模型的R方值为： 0.7618483669912332

 
 
 
 1
2
3
4
5

分析：本次构建的梯度提升的回归树模型的平均绝对误差和均方误差相对合理，同时可解释方差值和R^2值较接近1，故本次构建的模型是一个较为有效的模型。