scikit-learn库

柔光的暖阳◎ 2022-03-19 20:36 167阅读 0赞

**目录**

1.使用sklearn转换器处理数据

1.1 sklearn提供的模块：

1.2 sklearn库的datasets模块集成了部分数据分析的经典数据集，常用数据集的加载函数和解释如下：

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

1.4.sklearn除了提供基本的特征变换函数外，还提供了降维算法（如PCA）、特征选择算法，这些算法的使用也是通过转换器的方式进行的。

2.构建并评价聚类模型

2.1 聚类分析

2.2.评价聚类模型

3.构建并评价分类模型

3.1 sklearn库的常用分类算法：

3.2 评价分类模型：

4.构建并评价回归模型

4.1 常见的回归模型：

4.2 评价回归模型

--------------------

参看《python数据分析与应用》

**scikit-learn和tensorflow的区别**：[https://www.jianshu.com/p/0837b7c6ce10][https_www.jianshu.com_p_0837b7c6ce10]

**Scikit-learn使用总结，不错的总结：**[https://www.jianshu.com/p/516f009c0875][https_www.jianshu.com_p_516f009c0875]

## 1.使用sklearn转换器处理数据 ##

scikit-learn简称sklean整合了多种机器学习算法，使用方便。

### 1.1 sklearn提供的模块： ###

model\_selection（模型选择模块）、preprocessing （数据预处理模块）、decompisition （特征分解模块），通过这3个模块能够实现数据的预处理与模型构建前的数据标准化、二值化、数据集的分割、交叉验证和PCA降维等工作。

### 1.2 sklearn库的datasets模块集成了部分数据分析的经典数据集，常用数据集的加载函数和解释如下： ###

[https://blog.csdn.net/weixin\_41571493/article/details/82709345][https_blog.csdn.net_weixin_41571493_article_details_82709345]

<table> 
 <thead> 
 <tr> 
 <th style="vertical-align:middle;width:53px;"> &nbsp; </th> 
 <th style="text-align:center;vertical-align:middle;width:164px;"> 数据集名称 </th> 
 <th style="vertical-align:middle;width:213px;"> 调用方式 </th> 
 <th style="vertical-align:middle;width:144px;"> 适用算法 </th> 
 <th style="vertical-align:middle;width:179px;"> 数据规模 </th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="text-align:center;vertical-align:middle;width:53px;"> 小数据集 </td> 
 <td style="text-align:center;vertical-align:middle;width:164px;"> 波士顿房价数据集 </td> 
 <td style="vertical-align:middle;width:213px;"> load_boston() </td> 
 <td style="vertical-align:middle;width:144px;"> 回归 </td> 
 <td style="vertical-align:middle;width:179px;"> 506*13 </td> 
 </tr> 
 <tr> 
 <td style="text-align:center;vertical-align:middle;width:164px;"> 鸢尾花数据集 </td> 
 <td style="vertical-align:middle;width:213px;"> load_iris() </td> 
 <td style="vertical-align:middle;width:144px;"> 分类 </td> 
 <td style="vertical-align:middle;width:179px;"> 150*4 </td> 
 </tr> 
 <tr> 
 <td style="text-align:center;vertical-align:middle;width:164px;"> 糖尿病数据集 </td> 
 <td style="vertical-align:middle;width:213px;"> load_diabetes() </td> 
 <td style="vertical-align:middle;width:144px;"> 回归 </td> 
 <td style="vertical-align:middle;width:179px;"> 442*10 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:middle;width:164px;"> 乳腺癌数据集 </td> 
 <td style="vertical-align:middle;width:213px;"> load-breast-cancer（） </td> 
 <td style="vertical-align:middle;width:144px;"> 分类、聚类 </td> 
 <td style="vertical-align:middle;width:179px;"> &nbsp;569*30 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:middle;width:53px;"> &nbsp; </td> 
 <td style="text-align:center;vertical-align:middle;width:164px;"> &nbsp; </td> 
 <td style="vertical-align:middle;width:213px;"> &nbsp; </td> 
 <td style="vertical-align:middle;width:144px;"> &nbsp; </td> 
 <td style="vertical-align:middle;width:179px;"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="text-align:center;vertical-align:middle;width:53px;"> 大数据集 </td> 
 <td style="text-align:center;vertical-align:middle;width:164px;"> 手写数字数据集 </td> 
 <td style="vertical-align:middle;width:213px;"> load_digits() </td> 
 <td style="vertical-align:middle;width:144px;"> 分类 </td> 
 <td style="vertical-align:middle;width:179px;"> 5620*64 </td> 
 </tr> 
 <tr> 
 <td style="text-align:center;vertical-align:middle;width:164px;"> Olivetti脸部图像数据集 </td> 
 <td style="vertical-align:middle;width:213px;"> fetch_olivetti_facecs </td> 
 <td style="vertical-align:middle;width:144px;"> 降维 </td> 
 <td style="vertical-align:middle;width:179px;"> 400*64*64 </td> 
 </tr> 
 <tr> 
 <td style="text-align:center;vertical-align:middle;width:164px;"> 新闻分类数据集 </td> 
 <td style="vertical-align:middle;width:213px;"> fetch_20newsgroups() </td> 
 <td style="vertical-align:middle;width:144px;"> 分类 </td> 
 <td style="vertical-align:middle;width:179px;"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="text-align:center;vertical-align:middle;width:164px;"> 带标签的人脸数据集 </td> 
 <td style="vertical-align:middle;width:213px;"> fetch_lfw_people() </td> 
 <td style="vertical-align:middle;width:144px;"> 分类；降维 </td> 
 <td style="vertical-align:middle;width:179px;"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="text-align:center;vertical-align:middle;width:164px;"> 路透社新闻语料数据集 </td> 
 <td style="vertical-align:middle;width:213px;"> fetch_rcv1() </td> 
 <td style="vertical-align:middle;width:144px;"> 分类 </td> 
 <td style="vertical-align:middle;width:179px;"> 804414*47236 </td> 
 </tr> 
 </tbody> 
</table>

加载后的数据集可以视为一个字典，几乎所有的sklearn数据集均可以使用data、target、feature\_names、DESCR分别获取数据集的数据、标签、特征名称和描述信息。

# 代码 6-1
    from sklearn.datasets import load_breast_cancer
    cancer = load_breast_cancer()##将数据集赋值给iris变量
    print('breast_cancer数据集的长度为：',len(cancer))
    print('breast_cancer数据集的类型为：',type(cancer))
    
    
    # 代码 6-2
    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)

在数据分析过程中，为了保证模型在实际系统中能够起到预期作用，一般需要将样本分成独立的3部分，训练集（train\_set）、验证集（Validation set）和测试集（test set）。sklearn的model\_selection模块提供了train\_test\_split函数对数据集进行拆分。其中，训练集用于估计模型，验证集用于确定网络结构或训练模型复杂程度的参数，而测试集用于检验最优模型的性能。通常占比为50%+25%+25%。

train\_test\_split函数的常用参数：[https://scikit-learn.org/stable/modules/generated/sklearn.model\_selection.train\_test\_split.html\#sklearn.model\_selection.train\_test\_split][https_scikit-learn.org_stable_modules_generated_sklearn.model_selection.train_test_split.html_sklearn.model_selection.train_test_split]

train\_test\_split（\*array，\*\*options）：函数返回划分好的训练集和测试集数据。0.16版的新功能：如果输入是稀疏的，则输出将是scipy.sparse.csr\_矩阵。否则，输出类型与输入类型相同。

<table style="width:685px;"> 
 <thead> 
 <tr> 
 <th style="width:142px;">参数名称</th> 
 <th style="width:540px;">说明</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="width:142px;">*array</td> 
 <td style="width:540px;">接收一个或多个数据集，代表需要划分的数据集</td> 
 </tr> 
 <tr> 
 <td style="width:142px;">test_size</td> 
 <td style="width:540px;">代表测试集的大小。接收float，int类型数据或None。float：0~1之间，代表测试集在总数中占比；int：表示测试集的绝对数目。该参数与train_test可以只转入一个</td> 
 </tr> 
 <tr> 
 <td style="width:142px;">train_test</td> 
 <td style="width:540px;">代表训练集的大小，接收数据类型同上</td> 
 </tr> 
 <tr> 
 <td style="width:142px;">random_state</td> 
 <td style="width:540px;">代表随机种子编号，相同随机种子编号产生相同的随机结果，不同种子编号产生不同的随机结果。接收int</td> 
 </tr> 
 <tr> 
 <td style="width:142px;">shuffle</td> 
 <td style="width:540px;">代表是否进行有放回抽样，接收boolean，若shuffle = False，则stratify必须为空</td> 
 </tr> 
 <tr> 
 <td style="width:142px;">stratify</td> 
 <td style="width:540px;">为了保持split之前类的分布，非空时用于类分布不平衡的情况，接收array或None</td> 
 </tr> 
 </tbody> 
</table>

import numpy as np
    from sklearn.model_selection import train_test_split
    X, y = np.arange(10).reshape((5, 2)), range(5)
    print("X:",X)
    print("y:",list(y))
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)
    print("X_train: ",X_train)
    print("y_train:",y_train)
    print("X_test:",X_test)
    print("y_test:",y_test)
    '''
    X: [[0 1]
     [2 3]
     [4 5]
     [6 7]
     [8 9]]
    y: [0, 1, 2, 3, 4]
    X_train:  [[4 5]
     [0 1]
     [6 7]]
    y_train: [2, 0, 3]
    X_test: [[2 3]
     [8 9]]
    y_test: [1, 4]
    '''

# 代码 6-3
    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)  #测试集占20%
    print('训练集数据的形状为：',cancer_data_train.shape)
    print('训练集标签的形状为：',cancer_target_train.shape)
    print('测试集数据的形状为：',cancer_data_test.shape)
    print('测试集标签的形状为：',cancer_target_test.shape)

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

（什么是转换器）为帮助用户方便实现大量的特征处理相关操作，sklearn把相关的功能封装成**转换器**。

（转换器能实现什么功能）目前，使用sklearn的转换器能够实现对传入的Numpy数组进行标准化处理、归一化处理、二值化处理和PCA降维等处理。

**转换器主要包含3种方法：**

*  fit()：训练算法，设置内部参数。
 *  transform()：数据转换。将规则应用于训练集或者测试集
 *  fit\_transform()：合并fit和transform两个方法

sklearn预处理函数及其作用：（主要在**sklearn.preprcessing**包下）。

**规范化：**

*  MinMaxScaler :最大最小值规范化
 *  Normalizer :使每条数据各特征值的和为1
 *  StandardScaler :为使各特征的均值为0，方差为1

**编码：（数据预处理函数）**

*  LabelEncoder ：把字符串类型的数据转化为整型
 *  OneHotEncoder ：特征用一个二进制数字来表示
 *  Binarizer :对定量特征进行二值化处理
 *  MultiLabelBinarizer：多标签二值化
 *  FunctionTransformer：对特征进行自定义函数变换

minMaxScaler使用实例：

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))
    
    '''
    结果如下：
    离差标准化前训练集数据的最小值为： 0.0
    离差标准化后训练集数据的最小值为： 0.0
    离差标准化前训练集数据的最大值为： 4254.0
    离差标准化后训练集数据的最大值为： 1.0000000000000002
    离差标准化前测试集数据的最小值为： 0.0
    离差标准化后测试集数据的最小值为： -0.057127602776294695
    离差标准化前测试集数据的最大值为： 3432.0
    离差标准化后测试集数据的最大值为： 1.3264399566986453
    '''

结果表明：离差标准化之后的训练集数据的最小值、最大值限定在了\[0,1\]区间，但是由于测试集应用了训练集的离差标准化规则，导致数据超出了\[0,1\]的范围。

### 1.4.sklearn除了提供基本的特征变换函数外，还提供了降维算法（如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)
    
    '''
    PCA降维前训练集数据的形状为： (455, 30)
    PCA降维后训练集数据的形状为： (455, 10)
    PCA降维前测试集数据的形状为： (114, 30)
    PCA降维后测试集数据的形状为： (114, 10)
    '''

PCA（n\_components，\*\*options）

n\_components：接收None、int、float和mle。int：表示将原始数据降低到n个维度；float：PCA根据样本特征方差来决定降维后的维度数；mle：会用MLE算法根据特征的方差分布情况自动选择特征维度；未指定：所有特征均被保留。

## 2.构建并评价聚类模型 ##

### 2.1 聚类分析 ###

聚类分析是在没有给定划分类别的情况下，根据数据相似度进行样本分组的一种方法。划分的原则是组内（内部）距离最小化，而组间（外部）距离最大化。聚类算法实现需要sklearn估计器。sklearn估计器（可以直接理解成分类器）主要包含 fit 和 predict两个方法。

*  fit()：主要用于训练算法，设置内部参数。接收训练集和类别两个参数。（可接收用于有监督学习的训练集及其标签两个参数，也可以接收用于无监督学习的数据）
 *  predict()：用于预测有标签的测试集标签，参数为测试集。（用于预测有监督学习的测试集标签，也可以用于划分传入数据的类别）

\{大多数scikit-learn估计器接收和输出的数据格式均为numpy数组或类似格式。\}

例子：使用sklearn估计器构建K-Means聚类模型（sklearn的 manifold 模块中的TSNE函数可以实现多维数据的可视化展示。）

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])
    
    
    # 代码 6-11
    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('../tmp/聚类结果.png') 
    plt.show() ##显示图片
    
    '''
    构建的K-Means模型为：
     KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,
        n_clusters=3, n_init=10, n_jobs=1, precompute_distances='auto',
        random_state=123, tol=0.0001, verbose=0)
    花瓣花萼长度宽度全为1.5的鸢尾花预测类别为： 0
    '''

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p1bGlhcmp1bGlhcg_size_16_color_FFFFFF_t_70][]

### 2.2.评价聚类模型 ###

聚类评价的标准是组内的对象互相之间是相似的（相关的），而不同组中的对象是不同的（不相关的）。

下例为使用FMI评价法（对应函数：fowlkes\_mallows\_score，需要真实值）评价K-Means聚类模型：得分越高，其效果越好

# 代码 6-12
    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))
    
    
    
    # 代码 6-13
    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()
    
    '''
    iris数据聚2类FMI评价分值为：0.750473
    iris数据聚3类FMI评价分值为：0.820808
    iris数据聚4类FMI评价分值为：0.753970
    iris数据聚5类FMI评价分值为：0.725483
    iris数据聚6类FMI评价分值为：0.600691
    '''

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p1bGlhcmp1bGlhcg_size_16_color_FFFFFF_t_70 1][]

## 3.构建并评价分类模型 ##

###  3.1 sklearn库的常用分类算法： ###

逻辑斯蒂回归、支持向量机、k最近邻分类、高斯朴素贝叶斯、分类决策树、随机森林分类、梯度提升分类树。详见下图：

<table style="width:500px;"> 
 <thead> 
 <tr> 
 <th>算法名称</th> 
 <th>模块名称</th> 
 <th>函数名称</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>逻辑斯蒂回归</td> 
 <td>linear_model</td> 
 <td>LogisticRegression</td> 
 </tr> 
 <tr> 
 <td>支持向量机</td> 
 <td>svm</td> 
 <td>SVC</td> 
 </tr> 
 <tr> 
 <td>K最近邻分类</td> 
 <td>neighbors</td> 
 <td>KNeighborsClassifier</td> 
 </tr> 
 <tr> 
 <td>高斯朴素贝叶斯</td> 
 <td>naive_bayes</td> 
 <td>GaussianNB</td> 
 </tr> 
 <tr> 
 <td>分类决策树</td> 
 <td>tree</td> 
 <td>DecisionTreeClassifier</td> 
 </tr> 
 <tr> 
 <td>随机森林分类</td> 
 <td>ensemble</td> 
 <td>RandomForestClassifier</td> 
 </tr> 
 <tr> 
 <td>梯度提升分类树</td> 
 <td>ensemble</td> 
 <td>GradientBoostingClassifier</td> 
 </tr> 
 </tbody> 
</table>

可参看：[https://www.jianshu.com/p/0f4524c247e9][https_www.jianshu.com_p_0f4524c247e9]

下例：使用sklearn估计器构建SVM模型

# 代码 6-17
    ## 加载所需的函数,
    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])
    
    # 代码 6-18
    ## 求出预测和真实一样的数目
    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])
    
    '''
    建立的SVM模型为：
     SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
      decision_function_shape='ovr', degree=3, gamma='auto', 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]
    
    预测对的结果数目为： 111
    预测错的的结果数目为： 3
    预测结果准确率为： 0.9736842105263158
    '''

上述结果显示，SVM模型预测结果的准确率约为97.4%，只有3个测试样本识别错误，整体模型效果比较理想。

### 3.2 评价分类模型： ###

分类模型对测试集进行预测而得出的准确率并不能很好的反映模型的性能表现，需要结合真实值计算出精确率、召回率、FI值和Cohen‘s Kappa系数等指标来衡量。

分类模型评价方法：

<table style="width:500px;"> 
 <thead> 
 <tr> 
 <th>方法名称</th> 
 <th>sklearn函数</th> 
 <th>最佳值</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>Precision(精确率)</td> 
 <td>metrics.precision_score</td> 
 <td>1.0</td> 
 </tr> 
 <tr> 
 <td>Recall(召回率)</td> 
 <td>metrics.recall_score</td> 
 <td>1.0</td> 
 </tr> 
 <tr> 
 <td>F1值</td> 
 <td>metrics.f1_score</td> 
 <td>1.0</td> 
 </tr> 
 <tr> 
 <td>Cohen‘s Kappa系数</td> 
 <td>metrics.cohen_kappa_score</td> 
 <td>1.0</td> 
 </tr> 
 <tr> 
 <td>ROC曲线</td> 
 <td>metrics.roc_curve</td> 
 <td>最靠近y轴</td> 
 </tr> 
 </tbody> 
</table>

# 代码 6-19 基于前面代码
    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))
    
    '''
    使用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
    '''
    
    # 代码 6-20
    from sklearn.metrics import classification_report
    print('使用SVM预测iris数据的分类报告为：','\n',
          classification_report(cancer_target_test,
                cancer_target_pred))
    
    
    
    # 代码 6-21
    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')
    plt.show()

鲍鱼数据（abalone\_data）下载：   http://archive.ics.uci.edu/ml/machine-learning-databases/abalone/abalone.data

鲍鱼年龄预测：

# 代码 6-22
    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('E:/ruanjianinstall/daily_exercise/abalone.data',sep=',')
    print("abalone:",abalone)
    ## 将数据和标签拆开
    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)
    
    
    
    # 代码 6-23 评价构建的SVM分类模型
    abalone_target_pred = svm_abalone.predict(abalone_std_test)
    print('abalone数据集的SVM分类报告为：\n',
          classification_report(abalone_target_test,abalone_target_pred))

## 4.构建并评价回归模型 ##

分类和回归主要区别：分类的标签是离散的，回归的标签是连续的。回归算法的实现步骤分为**学习和预测**两个步骤，学习是通过训练样本数据来拟合回归方程的，预测则是利用学习过程中拟合出的回归方程，将测试数据放入方程中求出预测值。

### 4.1 常见的回归模型： ###

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

sklearn常用的回归算法：

import numpy as np
    from sklearn.linear_model import LinearRegression
    
    X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
    # y = 1 * x_0 + 2 * x_1 + 3
    y = np.dot(X, np.array([1, 2])) + 3
    reg = LinearRegression().fit(X, y)
    print("建立的Linear Regression模型为：",reg)
    print(reg.score(X, y))  #Returns the coefficient of determination R^2 of the prediction
    print(reg.coef_)   #存放方程的回归系数
    print(reg.intercept_)  #存放方程的截距
    print(reg.predict(np.array([[3, 5]])))  #预测方法，将返回预测值 1*3+2*5+3=16
    '''
    建立的Linear Regression模型为： LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)
    1.0
    [1. 2.]
    3.0000000000000018
    [16.]
    '''

### 4.2 评价回归模型 ###

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

<table style="width:500px;"> 
 <thead> 
 <tr> 
 <th>方法名称</th> 
 <th>最优值</th> 
 <th>sklearn函数</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td> 平均绝对误差 </td> 
 <td>0</td> 
 <td>metrics.mean_absolute_error</td> 
 </tr> 
 <tr> 
 <td>均方误差</td> 
 <td>0</td> 
 <td>metrics.mean_squared_error</td> 
 </tr> 
 <tr> 
 <td>中值绝对误差</td> 
 <td>0</td> 
 <td>metrics.median_absolute_error</td> 
 </tr> 
 <tr> 
 <td>可解释方差值</td> 
 <td>1</td> 
 <td>metrics.explained_variance_score</td> 
 </tr> 
 <tr> 
 <td>R^2值</td> 
 <td>1</td> 
 <td>metrics.r2_score</td> 
 </tr> 
 </tbody> 
</table>

[https_www.jianshu.com_p_0837b7c6ce10]: http://xn--scikit-learntensorflow-st60b23neqjg82v/
[https_www.jianshu.com_p_516f009c0875]: https://www.jianshu.com/p/516f009c0875
[https_blog.csdn.net_weixin_41571493_article_details_82709345]: https://blog.csdn.net/weixin_41571493/article/details/82709345
[https_scikit-learn.org_stable_modules_generated_sklearn.model_selection.train_test_split.html_sklearn.model_selection.train_test_split]: https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html#sklearn.model_selection.train_test_split
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p1bGlhcmp1bGlhcg_size_16_color_FFFFFF_t_70]: /images/20220320/b92161871bef4042b9f614ef26fb4c75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p1bGlhcmp1bGlhcg_size_16_color_FFFFFF_t_70 1]: /images/20220320/1f477ea941a64b3780afe448cb0f491f.png
[https_www.jianshu.com_p_0f4524c247e9]: https://www.jianshu.com/p/0f4524c247e9