# sklearn数据库
import sklearn
sklearn.__version__

# 数据处理库
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
%matplotlib inline
from sklearn import datasets

'0.24.1'

第3章数据预处理与案例演示

3.1 导入数据库

（1）数据集分析

这里以scikit-learn自带的数据集：鸢尾花分类数据集为例。

根据鸢尾花的花萼和花瓣大小，区分鸢尾花的品种，实现一个基础的多分类问题：

Iris 鸢尾花数据集内包含 3 种类别，分别为山鸢尾（Iris-setosa）、变色鸢尾（Iris-versicolor）和维吉尼亚鸢尾（Iris-virginica）。

数据集共 150 条记录，每类各 50 个数据，每条记录有花萼长度、花萼宽度、花瓣长度、花瓣宽度4项特征，通过这4个特征预测鸢尾花卉属于哪一品种。
iris数据集包含在sklearn库当中，具体在sklearn\\datasets\\data文件夹下，文件名为iris.csv。
通常数据文件存储在\\Python36\\Lib\\site-packages\\sklearn\\datasets\\data\\iris.csv。
打开iris.csv，数据格式如下：

第一行数据意义为：
第1列：150：数据集中数据的总条数
第2列：4：特征值的类别数，即花萼长度、花萼宽度、花瓣长度、花瓣宽度。
第3-5列：setosa、versicolor、virginica：三种鸢尾花名

从第二行及以下数据的意义为：
第一列为花萼长度值，如5.1或4.9
第二列为花萼宽度值，如3.5或3
第三列为花瓣长度值，如1.4或1,3
第四列为花瓣宽度值，如0.2， 0.4
第五列对应是种类，如0，1，2

（2）导入数据

# 加载sklearn自带的数据集鸢尾花数据集yuān wěi huā
iris = datasets.load_iris()

（3）打印样本特征值

print("每个样本特征值:\\n", iris.data)

[[5.1 3.5 1.4 0.2]
 [4.9 3.  1.4 0.2]
 [4.7 3.2 1.3 0.2]
 [4.6 3.1 1.5 0.2]
 [5.  3.6 1.4 0.2]
 [5.4 3.9 1.7 0.4]
 [4.6 3.4 1.4 0.3]
 [5.  3.4 1.5 0.2]

..........................

（4）打印样本标签值

print("样本标签值:\\n", iris['target'])

样本标签值:
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 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 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 2 2 2 2 2 2 2 2 2 2 2
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
2 2]

（5）进一步通过pd.DataFrame可视化数据

# 利用dataframe 做简单的可视化分析
# 把特征数据导入df中
df = pd.DataFrame(iris.data, columns = iris.feature_names)

# 把标签数据导入df中
df['target'] = iris.target

# 打印数据12*8是图片尺寸
df.plot(figsize = (12,8))

从图片中可以看出：

有三种target标签类型0，1， 2，并且是按顺序排放的，先是类型0，然后是类型1，最后是类型2
不同类型的sepal length，petal length，petal width这三种特征则不同，类型越靠后，值越大。
不同类型的peta width这个特征，基本相同，无法通过该特征来区分花的类型。

3.2 数据预处理

预处理数据包括：

数据的标准化，数据的归一化，数据的二值化，非线性转换，数据特征编码，处理缺失值等。

# 定义一个在最大值和最小值区间内的放缩器
scaler = preprocessing.MinMaxScaler() 

# 进行放缩，
scaler.fit(iris.data) #先fit

# 进行数据转换，映射到[0,1]区间，获得转换后的样本数据
data = scaler.transform(iris.data)
print(data)

[[0.22222222 0.625      0.06779661 0.04166667]
 [0.16666667 0.41666667 0.06779661 0.04166667]
 [0.11111111 0.5        0.05084746 0.04166667]
 [0.08333333 0.45833333 0.08474576 0.04166667]
 [0.19444444 0.66666667 0.06779661 0.04166667]
 [0.30555556 0.79166667 0.11864407 0.125     ]
 [0.08333333 0.58333333 0.06779661 0.08333333]
 [0.19444444 0.58333333 0.08474576 0.04166667]
 [0.02777778 0.375      0.06779661 0.04166667]
 [0.16666667 0.45833333 0.08474576 0.        ]

# 获取样本标签
target = iris.target
print(target)

[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 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 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 2 2 2 2 2 2 2 2 2 2 2
 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
 2 2]

3.3 特征的提取

3.4 特征的选择

3.5 构建训练样本

# 把数据集分割训练样本：训练集(2/3) + 测试集(1/3)
X_train,X_test,y_train,y_test = train_test_split(data,target,test_size = 1/3)

# 显示样本个数
len(X_train),len(X_test)

(100, 50)

第4章算法/模型选择与案例演示

4.1 模型初选：

（1）模型选择

针对特定的数据集和要解决的问题，从Scikit-learn支持的众多的模型中初步选择一个模型。

根据问题特点选择适当的估计器estimater模型：分类(SVC,KNN,LR,NaiveBayes,...) 回归
(Lasso,ElasticNet,SVR,...) 聚类(KMeans,...) 降维(PCA,...)
https://blog.csdn.net/HiWangWenBing/article/details/123121592https://blog.csdn.net/HiWangWenBing/article/details/123121592

我们当前的问题是根据特征预测鸢尾花的类型，属于带标签的分类问题
并且samples个数为150个小于100K,所以根据sklearn使用地图我们选择Linear SVC模型进行分类。

（2）构建模型

from sklearn import svm

# 构建模型
model = svm.SVC(kernel = 'linear',C = 1,probability=True)

print(model)

SVC(C=1, kernel='linear', probability=True)

备注：模型的构建非常简单

4.2 模型训练：训练集

用输入数据对模型进行训练（这个过程，运行的时间最长）

#用训练集数据喂养模型：用训练数据训练模型
model.fit(X_train,y_train)

4.3 模型测试：测试集

对训练后的模型进行评估

（1）测试训练好的模型：分类预测

# 用测试集数据测试
model.predict(X_test) - y_test

array([ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0, -1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0, -1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0])

备注：

0：表示预测结果与标签一致

非0：表示预测结果与标签不一致，这里有两个值预测错误

（2）测试训练好的模型：可性能预测

model.predict_proba(X_test)

array([[0.00322914, 0.00130519, 0.99546567],
       [0.98579331, 0.00775802, 0.00644868],
       [0.0141099 , 0.11239802, 0.87349208],
       [0.01577928, 0.88639592, 0.0978248 ],
       [0.9708529 , 0.01675066, 0.01239643],
       [0.95091453, 0.03030118, 0.01878429],
       [0.01190137, 0.98138338, 0.00671525],
       [0.96241814, 0.02589007, 0.01169179],
       [0.97402273, 0.01467871, 0.01129856],
       [0.03436368, 0.95653188, 0.00910444],
       [0.0098553 , 0.01129788, 0.97884682],
       [0.02137946, 0.33521393, 0.64340661],

............................................................................

每一行表示一个测试样本的可能性预测结果。

[0.00322914, 0.00130519, 0.99546567],

表示：

类型1的可能性为：0.00322914

类型2的可能性为： 0.00130519

类型3的可能性为： 0.99546567

（3）查看测试集上模型的得分

#查看模型的得分，
#对不同类型的模型有不同的评分算法，由score方法内部所定义
model.score(X_test,y_test)

0.96

备注：正确率96%

4.4 模型评估：测试集

模型的评估和模型的优化相关功能都在sklearn.model_selection中。

除了使用estimator的score函数简单粗略地评估模型的质量之外，

在sklearn.metrics模块针对不同的问题类型提供了各种评估指标并且可以创建用户自定义的评估指
标。

# 分类模型评分报告
from sklearn.metrics import classification_report

report = classification_report(target,clf.predict(data), target_names = iris.target_names)

print(report)

              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        50
  versicolor       0.92      0.98      0.95        50
   virginica       0.98      0.92      0.95        50

    accuracy                           0.97       150
   macro avg       0.97      0.97      0.97       150
weighted avg       0.97      0.97      0.97       150

（1）每个种分类的评估指标

precision：准确率
recall：召回率
f1-score：f1分数

（2）整个测试集的整体的评估指标

accuracy：整体的正确率

关于每个评估指标的含义，后续有专门讨论

可以采用交叉验证方法评估模型的泛化能力，能够有效避免过度拟合。

K折交叉验证(K=10)示意图

from sklearn.model_selection import cross_val_score

#采用5折交叉验证
scores = cross_val_score(clf,data,target,cv=5)

print(scores)

#平均得分和95%置信区间
print("Accuracy: %0.2f(+/-%0.2f)"%(scores.mean(),scores.std()*2))

[0.96666667 0.96666667 0.96666667 0.93333333 1.        ]
Accuracy: 0.97(+/-0.04)

4.5 模型优化：

对训练后的模型进行超参数优化

优化模型的方法包括：

网格搜索法，随机搜索法，模型特定交叉验证，信息准则优化。

网格搜索法在指定的超参数空间中对每一种可能的情况进行交叉验证评分并选出最好的超参数组
合。

在上述模型中：

model = svm.SVC(kernel = 'linear',C = 1,probability=True)

超参数kernel='linear'。
C = 1
probability=True

用上述超参数和数据集，精度为：0.97

这个参数是最优的吗？有没有更好的参数参数，使得精度可以适当的提升。

超参数是不直接在估计器内学习的参数。在 scikit-learn 包中，它们作为估计器类中构造函数的参数进行传递。

典型的例子有：用于支持向量分类器的 C 、kernel 和 gamma ，用于Lasso的 alpha等。

搜索超参数空间以便获得最好交叉验证分数的方法是可能的而且是值得提倡的。
搜索超参数空间以优化超参数需要明确以下方面：

估计器
超参数空间
交叉验证方案
打分函数
搜寻或采样方法（网格搜索法或随机搜索法）

优化模型的方法包括网格搜索法，随机搜索法，模型特定交叉验证，信息准则优化

（1）网格搜索法 GridSearchCV

所谓网格：就是预先通过网格的方式给定每个超参数的可能数值，各种超参数可能的数值，组成了二维网格。

网格搜索法在指定的超参数空间中对每一种可能的情况进行交叉验证评分并选出最好的超参数组
合。使用网格搜索法或随机搜索法可以对Pipeline进行参数优化，也可以指定多个评估指标。

（2）随机搜索法（RandomizedSearchCV）

随机搜索法和网格搜索法作用类似，但是只在超参数空间中进行指定次数的不同采样。采样次数通
过n_iter参数指定，通过调整其大小可以在效率和性能方面取得平衡。其采样方法调用
ParameterSampler函数,采样空间必须用字典进行指定。
网格搜索法只能在有限的超参数空间进行暴力搜索，但随机搜索法可以在无限的超参数空间进行随
机搜索。

4.6 模型终选：

比较各种模型和优化结果，选择最终的模型

第5章模型存储的保存与加载

把训练好的模型存储起来，以便后续直接使用。

可以使用python内置的pickle模块或将训练好模型保存到磁盘或字符串，以便将来直接使用，而不
需要重复训练。

对于sklearn,使用joblib会更加有效，但是joblib只能保存到磁盘而不能保存成字符串。

5.1 使用pickle

import pickle

model_saved = pickle.dumps(model) #保存模型成字符串
print(model_saved)

b'\\x80\\x04\\x95\\x8d\\x0f\\x00\\x00\\x00\\x00\\x00\\x00\\x8c\\x14sklearn.svm._classes\\x94\\x8c\\x03SVC\\x94\\x93\\x94)\\x81\\x94\\x94(\\x8c\\x17decision_function_shape\\x94\\x8c\\x03ovr\\x94\\x8c\\nbreak_ties\\x94\\x89\\x8c\\x06kernel\\x94\\x8c\\x06linear\\x94\\x8c\\x06degree\\x94K\\x03\\x8c\\x05gamma\\x94\\x8c\\x05scale\\x94\\x8c\\x05coef0\\x94G\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x8c\\x03tol\\x94G?PbM\\xd2\\xf1\\xa9\\xfc\\x8c\\x01C\\x94K\\x01\\x8c\\x02nu\\x94G\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x8c\\x07epsilon\\x94G\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x8c\\tshrinking\\x94\\x88\\x8c\\x0bprobability\\x94\\x88\\x8c\\ncache_size\\x94K\\xc8\\x8c\\x0cclass_weight\\x94N\\x8c\\x07verbose\\x94\\x89\\x8c\\x08max_iter\\x94J\\xff\\xff\\xff\\xff\\x8c\\x0crandom_state\\x94N\\x8c\\x07_sparse\\x94\\x89\\x8c\\x0en_features_in_\\x94K\\x04\\x8c\\rclass_weight_\\x94\\x8c\\x15numpy.core.multiarray\\x94\\x8c\\x0c_reconstruct\\x94\\x93\\x94\\x8c\\x05numpy\\x94\\x8c\\x07ndarray\\x94\\x93\\x94K\\x00\\x85\\x94C\\x01b\\x94\\x87\\x94R\\x94(K\\x01K\\x03\\x85\\x94h\\x1f\\x8c\\x05dtype\\x94\\x93\\x94\\x8c\\x02f8\\x94\\x89\\x88\\x87\\x94R\\x94(K\\x03\\x8c\\x01<\\x94NNNJ\\xff\\xff\\xff\\xffJ\\xff\\xff\\xff\\xffK\\x00t\\x94b\\x89C\\x18\\x00\\x00\\x00\\x00\\x00\\x00\\xf0?\\x00\\x00\\x00\\x00\\x00\\x00\\xf0?\\x00\\x00\\x00\\x00\\x00\\x00\\xf0?\\x94t\\x94b\\x8c\\x08cla

model_loaded = pickle.loads(model_saved) #从字符串加载模型
print(model_loaded)

model_loaded.predict(data)

SVC(C=1, kernel='linear', probability=True)

Out[67]:

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 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, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

5.2 使用joblib

import joblib

joblib.dump(model,'model_saved_joblib.pkl') #保存模型到文件

['model_saved_joblib.pkl']

model_loaded = joblib.load('model_saved_joblib.pkl') #加载模型
print(model_loaded)

model_loaded.predict(data)

SVC(C=1, kernel='linear', probability=True)

Out[78]:

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 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, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])