机器学习建模分析

机器学习

机器学习分类

1、递进关系：深度学习–>机器学习–>人工智能
2、机器学习任务分为两大类方法：
（1）有监督的学习：利用经验数据，学习表示事物的模型，关注利用模型预测未来（数据）。包括：

• 分类问题：对事物所属类型的判别，类别数量是已知的。如：鸟类型识别、垃圾邮件分类
• 回归问题：预测的目标是连续变量。它是基于连续性数据的预测建模分析技术。如：根据父母身高预测孩子身高；根据近几年的房价预测未来房价

（2）无监督的学习：倾向于对事物本身特性的分分析，常见问题包括：

• 数据降维：对描述事物的特征数量进行压缩的方法。如：从已有的100个特征中选取部分特征表示音乐信号
• 聚类问题：将事物划分为不同的类别（事先不知道类别的数量，现分的），根据事物之间的相似性，将相似的事物归为一簇。如：电子商务网站将具有类似背景与购买习惯的用户自动归为一类。

在解决实际领域问题时，通常要先根据应用背景和分析目标，将应用转换成以上某类问题及组合问题，然后选用合适的学习算法训练模型

额外知识—深度学习

为机器学习的分支领域之一，是基于机器学习的神经网络模型发展起来的技术。用到了GPU(图形处理)。
GPU提供了强大的计算能力

机器学习方法库—Scikit-learn

优点：

• 该库是基于Numpy、Scipy、Pandas、Matplotlib的开发
• 该库封装了大量经典以及最新的机器学习模型
• 基本功能包括：分类、回归、聚类、数据降维、模型选择和数据项预处理

缺点：

• 本身不支持深度学习与GPU加速

注意：

Scikit-learn的model_selection类提供了数据集切分的方法。
metrics类实现了Scikit-learn包中各类机器学习算法的性能评估。

有监督的学习—回归问题分析

1、定义：预测的目标是连续变量，它是基于连续性数据的预测建模分析技术
2、常用方法：线性回归、逻辑回归、多项式回归
3、预测分析过程：
（1）训练：通过样本数据，学习目标变量和自变量之间的因果关系，建立数学模型
（2）目标：根据自变量预测相应的目标变量。

回归模型学习

由于回归问题是属于有监督的学习，所以我们要提前给定经验数据（也就是数据集），来获得相应的模型参数{w1,w2,…,wd,b}。其中：
wi：回归系数
b：截距，其作用是为了让模型在数据集上预测的误差最小。

求解线性回归模型

目标：使得线性模型预测所有的训练数据时误差平方和最小—即均方根误差最小
方法：

最小二乘法------矩阵解析计算
梯度下降法------逐步逼近，更便于计算机实现

![在这里插入图片描述](https://img-blog.csdnimg.cn/0603de6299c344b08fea69831a263e1a.png

回归分析代码实现

Scikit-learn库下的linear_model类下的LinearRegression类提供了回归分析模型初始化的方法；Scikit-learn库下的model_selection类和Metrics类分别实现了数据切分和各类机器学习算法的性能评估的方法。

导入相应的库（实际运用中可能不止这几个库，具体问题具体分析）：
from sklearn.linear_model import LinearRegression
from sklearn import model_selection
from sklearn import metrics

模型初始化：linreg= LinearRegression()
模型学习：linreg.fit(X, y)
模型预测：y_pred= linreg.predict(X)
回归模型的截距：linreg.intercept_
回归模型的回归系数：linreg.coef_
数据切分为训练集和测试集：X_train, X_test, y_train, y_test= model_selection.train_test_split(X, y, test_size, random_state, shuffle, stratify)
均方根误差(RMSE)计算：err= metrics.mean_squared_error(y, y_pred)
决定系数计算：decision_score= linreg.score(X, y)

参数详解如下：

参数	解释
X[m,n]	样本特征二维数组，m样本数，n特征项个数，，数值型
y[n]	分类标签的一维数组，必须为整数
test_size	测试集比例，若为整数则是样本数量
random_state	随机数种子。1：每次得到相同样本的划分，否则每次划分不一样。
shuffle	bool类型，是否在拆分之前对数据进行打乱，默认为True
stratify	输入类数组对象，如果不是None，则数据以分层方式拆分，使用此作为类标签，默认为None

回归模型保存—模型文件以.pkl结尾

利用joblib库

import joblib
joblib.dump(filename, value)------回归模型保存
joblib.load(filename)------回归模型加载

filename------模型保存的文件位置及所设定的文件名
value------回归模型学习时你所设置的模型名

import joblib
joblib.dump(filename= 'E:\qwe.pkl', value= linreg)
'''
等同于joblib.dump(linreg, 'E:\qwe.pkl')
'''
load_linreg= joblib.load('E:\qwe.pkl')#从保存的文件中读取模型

回归模型实现步骤

• 第一步：从文件中读取数据并对数据进行处理，按照题目要求划分训练集和测试集。
  -需要导入的库：import pandas as pd 和 from sklearn import model_selection
• 第二步：回归模型初始化
  -需要导入的库：from sklearn.linear_model import LinearRegression
• 第三步：模型评价（即性能评估）
  -需要导入的库：from sklearn import metrics
• 第四步：回归模型保存（看题目是否要求）
  -需要导入的库：import joblib

注意：不要硬搬步骤，实际问题灵活运用。

例题5-1

从案例5-1的advertising.csv中读取历史数据，建立广告投入和销量关系的模型，并根据下个月的预计投入预测销量。

import joblib#模型保存及引用
import pandas as pd#读取数据
from sklearn import metrics#性能评估
from sklearn.linear_model import LineaRegression#模型初始化
import matplotlib.pyplot as plt#可视化分析
#第一步：读取数据并对数据进行处理
data= pd.read_scv('E:\data/advertising.csv',index_col= 0)
#以散点图的形式进行不同渠道的广告投资费用与产品销量的关系
data.plot.scatter(x= 'TV', y= 'Slaes')
data.plot.scatter(x= 'Weibo', y= 'Slaes')
data.plot.scatter(x= 'WeChat', y= 'Slaes')
#将每组数据的广告投资费用作为一个小列表保存在大列表X中
X= data.iloc[:,:-1].values.astype(float)
#将每组数据对应的产品销量保存在列表y中
y= data.iloc[:,-1].values.astype(float)
#第二步：全部数据的回归模型初始化
linreg= LinearRegression()
linreg.fit(X, y)
#显示全部数据的回归模型的截距和回归系数
print(linreg.intercept_, linreg.coef_)
#数据切分
X_train, X_test, y_train, y_test= model_selection.train_test_split(X, y, test_size= 0.35, random_state= 1)
#训练集数据的回归模型初始化
linregTr= LinearRegression()
linregTr.fit(X_train, y_train)
#显示训练集的回归模型的截图和回归系数
print(linregTr.intercept_, linregTr.coef_)
#训练集和测试集的模型预测
y_train_pred= linregTr.predict(X_train)
y_test_pred= linregTr.predict(X_test)
#训练集和测试集的均方根误差(RMSE)
train_err= metrics.mean_squared_error(y_train, y_train_pred)
test_err= metrics.mean_squared_error(y_test, y_test_pred)
#测试集的决定系数
test_predict_score= linregTr.score(X_test, y_test)
print(test_predict_score)
#第三步：将其保存到E:\qwe.pkl
joblib.dump(linreg, 'E:\qwe.pkl')
load_linreg= joblib.load('E:\qwe.pkl')
#给定一份数据进行预测
new_X= [[130.1, 87.8, 69.2]]
print(load_linreg.predict(new_X))

运行结果显示为：

例题5-2

使用UCI数据集的波士顿房价数据集（Boston House PriceDataset），这是一个经典的回归数据集，我们会分析数据集中的各个特征对于房价的影响，最后会对房价进行预测。数据存在boston_housing_data.csv中，包含506行、14列，其中最后一列为房价，有部分值为空。

import pandas as pd#读取数据
from sklearn import metrics#模型评价（性能评估）
from sklearn import model_selection#数据切分
import pyplotlib.pyplot as plt#可视化分析
from sklearn.linear_model import LinearRegression#回归模型初始化
#第一步：读取数据并对数据进行处理
data= pd.read_csv('E:\data/boston_housing_data.csv')
#数据打乱
data= data.sample(frac= 1)
'''
注意：此处不用print来显示前五行的原因：display会将数据以表格的形式呈现出来，看的更清楚更直观。
'''
display(data.head())
#由于.csv的数据中有部分值为空，所以要进行预处理
display(data.shape)
display(data.isnull().any())#按列查看是否有空值
data.dropna(inplace= True)#滤除含有缺失值的行
display(data.shape)#显示处理后的数据的行列数

运行结果显示为：

#可视化分析
pd.plotting.scatter_matrix(data, diagonal= 'kde', c= 'k')
plt.show()

运行结果显示为：

#数据划分
train_num= int(data.shape[0]*0.8)#划分训练集为前80%的数据
X_train= data.iloc[:train_num, :-1].values.astype(float)
y_train= data.iloc[:train_num, -1].values.astype(float)
X_test= data.iloc[train_num:, :-1].values.astype(float)
y_test= data.iloc[train_num:, -1].values.astype(float)

#第二步：训练集回归模型初始化
linregTr= LinearRegression()
linregTr.fit(X_train, y_train)
display(linregTr.intercept_, linreg.coef_)#显示训练集回归模型的截距和回归系数
'''
注意：此处不用print的原因：若用print，则回归系数会以列表的形式呈现出来并且会紧跟在截距的数字之后，
并不会自动换行。而display会自动换行，并且会使回归系数以一维数组的形式呈现出来。
可自行在jupyter notebook上实验一下看看
'''

运行结果显示为：

#第三步：模型评价（性能评估）
#得到训练集和测试集的模型预测
y_train_pred= linregTr.predict(X_train)
y_test_pred= linregTr.predict(X_test)
#得到训练集和测试集的均方根误差（RMSE）
train_err= metrics.mean_squared_error(y_train, y_train_pred)
test_err= metrics.mean_squared_error(y_test, y_test_pred)
print("训练集和测试集的均方根误差分别为:{:.2f},{:.2f}".format(train_err, test_err))
#得到测试集的决定系数
test_predict_score= linregTr.score(y_test, y_test_pred)
print("测试集上的决定系数为：{:.2f}".format(test_predict_score))

运行结果显示为：

#第四步：预测结果图形比较
fig= plt.figure(figsize= (8,5))
plt.plot(y_test, label= '真实值')
plt.plot(y_test_pred, label= '预测值')
plt.legend()
plt.show()

运行结果显示为：

思考与练习1

第一题：

import pandas as pd
from sklearn import metrics
from sklearn import model_selection
from sklearn.linear_model import LinearRegression

"""
第一步：读取数据并对数据进行处理
"""
data= pd.read_csv('E:\data/advertising.csv', index_col= 0)
X= data.iloc[:,:-1].values.astype(float)
y= data.iloc[:,-1].values.astype(float)

"""
第二步：根据题目要求给X、y、X_test、X_train、y_train、y_test赋值
"""
#划分为训练集和测试集并得到训练集的回归模型linregTr
X_train, X_test, y_train, y_test= model_selection.train_test_split(X, y, test_size= 0.35, random_state= 1)
"""
第三步：相关回归模型初始化
"""
#得到全部数据的回归模型linreg
linreg= LinearRegression()
linreg.fit(X, y)
print(linreg.intercept_, linreg.coef_)
#得到训练集数据的回归模型linreg
linregTr= LinearRegression()
linregTr.fit(X_train, y_train)
print(linregTr.intercept_,linregTr.coef_)
"""
第四步：模型评价
"""
#得到测试集在linreg和linregTr上的预测值
y_test_pred1= linreg.predict(X_test)
y_test_pred2= linregTr.predict(X_test)

#测试集在linreg上的RMSE和决定系数:
err= metrics.mean_squared_error(y_test, y_test_pred1)
predict_score= linreg.score(X_test, y_test)
print("回归模型linreg在测试集上的RMSE和决定系数分别为：{:.3f},{:.3f}".format(err, predict_score))

#测试集在linregTr上的RMSE和决定系数:
y_test_err= metrics.mean_squared_error(y_test, y_test_pred2)
y_test_predict_score= linregTr.score(X_test, y_test)
print("训练集模型linregTr在测试集上的RMSE和决定系数分别为：{:.3f},{:.3f}".format(y_test_err, y_test_predict_score))
"""
由分析知：因为使用全部数据所得到的回归模型在测试集上的RMSE比训练集的回归模型linregTr在测试集上的RMSE小，且决定系数要比linregTr决定系数
大，所以回归模型inreg在测试集上的性能更好。
"""

运行结果显示为：

第二题：

import pandas as pd
from sklearn import metrics
from sklearn import model_selection
from sklearn.linear_model import LinearRegression

data= pd.read_csv('E:\data/advertising.csv', index_col= 0)
X= data.iloc[:,:-1].values.astype(float)
y= data.iloc[:,-1].values.astype(float)
#得到全部数据的回归模型linreg即200条样本
linreg= LinearRegression()
linreg.fit(X, y)
print("200条样本的回归模型linreg:\n{}{}".format(linreg.intercept_, linreg.coef_))

#得到100条样本的回归模型linregHalf
X_Half= data.iloc[:100,:-1].values.astype(float)
y_Half= data.iloc[:100,-1].values.astype(float)
linregHalf= LinearRegression()
linregHalf.fit(X_Half, y_Half)
print("100条样本的回归模型linregHalf:\n{}{}".format(linregHalf.intercept_, linregHalf.coef_))

#划分训练集和测试集
X_train, X_test, y_train, y_test= model_selection.train_test_split(X, y, test_size= 0.35, random_state= 1)

#测试集在linreg和linregHalf上的预测值
y_test_pred1= linreg.predict(X_test)
y_test_pred2= linregHalf.predict(X_test)

#测试集在linreg和linregHalf上的RMSE和决定系数
y_test_err1= metrics.mean_squared_error(y_test, y_test_pred1)
y_test_predict_score1= linreg.score(X_test, y_test)
print("测试集在linreg上的RMSE和决定系数分别为：{:.3f},{:.3f}".format(y_test_err1, y_test_predict_score1))

y_test_err2= metrics.mean_squared_error(y_test, y_test_pred2)
y_test_predict_score2= linregHalf.score(X_test, y_test)
print("测试集在linregHalf上的RMSE和决定系数分别为：{:.3f},{:.3f}".format(y_test_err2, y_test_predict_score2))

"""
由分析可知：前100条样本的回归模型linregHalf在测试集上的RMSE比200条样本的回归模型linregPre200的
RMSE要大，且其决定系数比linregPre200的决定系数要小，所以200条样本学习的模型预测性能更好。
"""

运行结果显示为：

有监督的学习—分类问题分析

1、分类分析是最常见的监督学习问题，又可细分为：

• 二分类问题：如手机垃圾短信的识别
• 多分类问题：停车场车牌数字识别

2、分类学习会采用不同的算法得到不同的分类模型。

常见算法如下：

• 决策树(Decision Tree)
• 集成学习(Ensemble learning)—先做了解
• 支持向量机(SVM,Support Vector Machine)
• KNN(K-近邻算法)
• 神经网络(Neural Network)
• 贝叶斯分类等等

分类模型性能评估

用到的性能分析函数如下：

准确率(Accuracy)计算：clf.score(X, y)
模型预测：predicted_y= clf.predict(X)
混淆矩阵计算：metrics.confusion_matrix(y, predicted_y)
分类性能报告：metrics.classification_report(y, predicted_y)
显示特征重要程度：clf.feature_importances_

分类学习方式一------决策树

决策树原理

决策树构造算法：ID3、C4.5和CART等

决策树分类代码实现及决策树绘制

Scikit-learn库下的tree下的DecisionTreeClassifier类实现了模型的初始化,该类支持二分类和多分类的问题。

导入相应的库（实际运用中可能不止这几个库，具体问题具体分析）：
from sklearn import tree或from sklearn.tree import DecisionTreeClassifier------决策树初始化
import pandas as pd------读取数据
from sklearn import metrics------性能评估
from graphviz import Source------将决策树保存到文件中
from IPython.display import Image—决策树显示

模型初始化：clf= tree.DecisionTreeClassifier()或clf= DecisionTreeClassifier()
模型学习：clf.fit(X, y)
准确率(Accuracy)计算：clf.score(X, y)
模型预测：predicted_y= clf.predict(X)
混淆矩阵计算：metrics.confusion_matrix(y, predicted_y)
分类性能报告：metrics.classification_report(y, predicted_y)
显示特征重要程度：clf.feature_importances_
决策树绘制：sklearn.tree.export_graphviz(decision_tree, out_file= None, feature_names= None, class_names= None)

参数详解如下：

参数	解释
X[m,n]	样本特征二维数组，m样本数，n特征项个数，，数值型
y[n]	分类标签的一维数组，必须为整数
decision_tree	决策树分类器，即输出的树对象
out_file	对象或字符串，即输出的文件名，默认=无
feature_names	str列表，即输出的字符串列表，表示特征名称，默认=无------每个函数的名称。如果 None 将使用通用名称(“feature_0”、“feature_1”、…)
class_names	str 或 bool 的列表，即输入字符串列表，目标类的名称，默认 = 无------每个目标类别的名称按数字升序排列。仅与分类相关

决策树模型保存—模型文件以.model保存

利用joblib库

import joblib
joblib.dump(filename, value)------决策树模型保存
joblib.load(filename)------决策树模型加载

filename------模型保存的文件位置及所设定的文件名
value------回归模型学习时你所设置的模型名

import joblib
joblib.dump(filename= 'E:\qwe.model', value= clf)
'''
等同于joblib.dump(clf, 'E:\qwe.model')
'''
load_linreg= joblib.load('E:\qwe.model')#从保存的文件中读取模型

决策树模型实现步骤

• 第一步：导入数据并对数据进行处理，根据题目要求进行数据划分（即划分特征值和标签）
  -需要导入的库：import pandas as pd和from sklearn import model_selection
• 第二步：决策树模型初始化并进行决策树图的生成
  -需要导入的库：from sklearn import tree、from graphviz import Source、from IPython.display import Image
• 第三步：评估分类器性能
  -需要导入的库：from sklearn import metrics
• 第四步：分类模型保存（根据题目要求看是否有该步骤）

例题5-3

银行贷款偿还数据集共包括15个样本，保存在文本文件bankdebt.csv中。每个样本包含3个特征项，1个分类标签，二分类

#第一步：读取数据,进行数据预处理（字符类型替换为数字）
data= pd.read_csv(r'E:\data\bankdebt.csv', index_col= 0, header= None)

data.loc[data[1]=='Yes', 1]= 1
data.loc[data[1]=='No', 1]= 0
data.loc[data[4]=='Yes', 4]= 1
data.loc[data[4]=='No', 4]= 0
data.loc[data[2]=='Single', 2]= 1
data.loc[data[2]=='Married', 2]=2
data.loc[data[2]=='Divorced', 2]=3
print(data.loc[1:5,:])

运行结果显示为：

#第二步：设置X、y，训练分类器
X= data.loc[:,1:3].values.astype(float)
y= data.loc[:,4].values.astype(float)
#导入决策树，训练分类器
from sklearn import tree
clf= tree.DecisionTreeClassifier()#模型初始化
clf.fit(X,y)#模型学习
clf.score(X,y)#Accuracy计算,即计算分类器的准确率
	>>> 1.0

#第三步：评估分类器性能
predicted_y= clf.predict(X)#模型预测
from sklearn import metrics
print(metrics.classification_report(y, predicted_y))#分类性能报告
print('Confusion matrix:')
print(metrics.confusion_matrix(y, predicted_y))#混淆矩阵计算

运行结果显示为：

#第四步：生成并显示决策树图
#第一列定义为是否有房，第二列是否结婚，第三列收入情况
featureName= ['House', 'Marital', 'Income']
#是否有能力偿还贷款
className= ['Cheat', 'Not Cheat']
#生成决策树图
#注意：若无graphviz库，则pip install graphviz即可
from graphviz import Source
graph= Source(tree.export_graphviz(clf,out_file= None, feature_names= featureName,class_names=className))
#保存到文件中并显示
"""
format:生成的图片格式
将决策树图保存为.png文件并赋给名为png_bytes的文件
"""
png_bytes= graph.pipe(format='png')

#打开dectree.png文件（若无该文件，则会在当前目录下创建该文件）并用f来引用
#wb：以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
#此为文件的读写的知识代码块
with open('dectree.png','wb') as f:
    f.write(png_bytes)#write():写入数据。将该图片写入文件dectree.png中并保存。

#显示该决策树图片
from IPython.display import Image
Image(png_bytes)#若想在notebook中显示图像则为：display(Image(png_bytes))

运行结果显示为：

完整实现代码为：

import pandas as pd
from sklearn import tree#导入决策树并进行操作
from graphviz import Source#生成决策树图
from IPython.display import Image#显示决策树图
"""
第一步：导入数据，并对数据进行处理
需要导入的库：
import pandas as pd
"""
data= pd.read_csv(r'E:\data\bankdebt.csv', header= None, index_col= 0)
data.loc[data.loc[:,1]=='Yes',1]= 1
data.loc[data.loc[:,1]=='No', 1]= 0
data.loc[data.loc[:,4]=='Yes', 4]= 1
data.loc[data.loc[:,4]=='No', 4]= 0
data.loc[data.loc[:,2]=='Single', 2]= 1
data.loc[data.loc[:,2]=='Married', 2]= 2
data.loc[data.loc[:,2]=='Divorced', 2]= 3
"""
第二步：根据题目要求给X、y、X_test、X_train、y_train、y_test赋值，即划分特征值和标签
"""
X= data.loc[:,:3].values.astype(float)
y=data.loc[:,4].values.astype(float)
"""
第三步：决策数模型初始化（分类模型初始化）并进行决策树图的生成
需要的库
from sklearn import tree
from graphviz import Source
from IPython.display import Image
"""
clf= tree.DecisionTreeClassifier()#模型初始化
clf.fit(X,y)#模型学习
clf.score(X, y)#计算分类器的准确率（Accuracy）
#生成并显示决策树图
featureName= ['House', 'Marital', 'Income']
className= ['Cheat', 'Not Cheat']
#生成图
from graphviz import Source
graph= Source(tree.export_graphviz(clf, out_file= None, feature_names= featureName, class_names= className))
png_bytes= graph.pipe(format= 'png')
with open('E:\决策树图.png', 'wb') as f:
    f.write(png_bytes)
from IPython.display import Image
display(Image(png_bytes))
"""
第四步：评估分类器性能
需要导入的库：
from sklearn import metrics
"""
predicted_y= clf.predict(X)#模型预测
from sklearn import metrics
print("分类性能报告:\n{}".format(metrics.classification_report(y,predicted_y)))
print("混淆矩阵计算：\n{}".format(metrics.confusion_matrix(y, predicted_y)))

运行结果显示为：

例题5-4 水果

#第一步：读取数据并进行处理
import pandas as pd
data= pd.read_csv('E:\data/fruit_data_with_colors.csv', index_col= 0)
print(data.shape)#查看数据的行列数
data.head()#查看数据的前五行

#对数据进行预处理，字符类型替换为数字
print(data.groupby('fruit_name').size())#查看不同种类的水果数量
fruit_type= data.iloc[:,0:2].drop_duplicates()#将完全相同的两行或多行删减为一行，作用：获取水果的类型
print(fruit_type)
#将水果类型转换为字典类型
fruit_type= dict([(str(fruiy_type.iloc[i,0]), fruit_type.iloc[i, 1]) for i in range(fruit_type.shape[0])])
print(fruit_type)

运行结果显示为：

#绘图观察数据
#绘制箱形图
import matplotlib.pyplot as plt
data.iloc[:,3:].plot(kind= 'box', subplots= True, layout=(2,2), sharex= False, sharey= False, figsize=(9,9))
#绘制散点图
pd.plotting.scatter_matrix(data.iloc[:,3:], diagonal= 'hist', c=data.iloc[:,0], figsize=(9,9))
plt.show()
'''
subplots------是否单独显示每个columns，默认为False。设置为True时，会将每个columns的数据单独在一个子图中显示
layout------当“subplots”为True时，用于布置图片显示布局，图片按几行、几列显示，参数为元组。
'''

运行结果显示为：

#第二步：划分特征值和标签
X= data.iloc[:,3:]#取'mass','width','height','color_score'作为特征
y= data['fruit_label']#y为label标签
#数据划分
from sklearn import model_selection
X_train, X_test, y_train, y_test= model_selection.train_test_split(X, y, test_size= 0.3, random_state= 1)

#第三步：决策树模型初始化并进行决策树图的生成
from sklearn import tree
clf= tree.DecisionTreeClassifier()
clf.fit(X_train, t_train)
print("决策树模型在训练集上的准确率为：{:.2f}".format(clf.score(X_train, y_train)))
print("决策树模型在测试集上的准确率为：{:.2f}".format(clf.score(X_test, y_test)))
	>>> 
	决策树模型在训练集上的准确率为：1.00
	决策树模型在测试集上的准确率为：0.94

#生成并显示决策树图
featureName= ['mass', 'width', 'height', 'color_score']
className= ['apple', 'lemon', 'mandarin', 'orange']
#生成决策树
from graphviz import Source
graph= Source(tree.export_graphviz(clf, out
_file= None, feature_names= featureName, class_names= className, filled= True, rounded= True))
png_bytes= graph.pipe(format= 'png')
with open('fruit.png', 'wb') as f:
	f.write(png_bytes)
from IPython.display import Image
Image(png_bytes)

运行结果显示为：

#第四步：评估分类器性能
from sklearn import metrics
#分类性能报告
print(metrics.classification_report(y_test,clf.predict(X_test)))
#显示特征重要程度
for i in zip(featureName, clf.feature_importances_):
	print(i)

运行结果显示为：

#第五步：决策树模型保存
import joblib
joblib.dump(filename= 'clf2.model', value= clf)
#等同于joblib.dump(clf, 'clf2.model')
test_clf= joblib.load('clf2.model')
test_data= [[192, 8.4, 7.3, 0.55]]
print("模型对[192,8.4,7.3,0.55]预测类型为：",fruit_type[str(test_clf2.predict(test_data)[0])])

运行结果显示为：

分类学习方式二------集成学习

Sklearn没有集成学习，需要在线安装pip install xgboost
过拟合：即泛化能力低，指为了得到一致假设而使假设变得过度严格，即过于紧密或精确地匹配待定数据集以至于无法良好地预测未来地观察结果。换种说法就是：其在训练集上的表现很好，但在训练集之外的数据上表现的不好，可详见https://www.jianshu.com/p/3bcbc0a3cccc。

集成方法1—随机森林(Bagging)

原理：随机森林是通过随机的方式建立一个森林，每棵树都是从训练集中抽取的部分样本，且基于部分随机选择的特征子集构建。
在预测未知数据时，多个决策树投票决定最终结果。

集成方法2—梯度提升机（Boosting）

原理：利用梯度提升的方法，通过迭代不断地训练新模型，并且新模型会专门针对之前的模型弱点进行改进，以此来提升模型的性能。

分类学习方式三------SVM(支持向量机)

SVM是基于数学优化方法的分类学习算法

原理：将数据看做多维空间的点，求解一个最优的超平面，将两种不同类别的点分割开来

SVM分类

SVM最基本的应用：分类
分类：求解一个最优的分类面，并将数据集分割为两个子集。
注意：数据集在低维空间中无法使用超平面划分，所以SVM需要借助核函数将低维数据映射到高维空间，以此来寻找超平面分割。

核函数有多种，目的是为了适应不同特性的数据集，它是影响SVM分类性能的关键因素。
常用核函数为：线性核、多项式核、高斯核和sigmoid核等。

SVM分类代码实现

Scikit-learn库中的SVM中的SupportVectorClassification类------只支持二分类。

导入相应的库（实际运用中可能不止这几个库，具体问题具体分析）：
from sklearn import svm------SVM初始化
import pandas as pd------读取数据
from sklearn import metrics------性能评估

SVM模型初始化：clf= svm.SVC(kernel= , gamma, C)
模型学习：clf.fit(X, y)
准确率(Accuracy)计算：clf.score(X, y)
模型预测：predicted_y= clf.predict(X)
混淆矩阵计算：metrics.confusion_matrix(y, predicted_y)
分类性能报告：metrics.classification_report(y, predicted_y)
显示特征重要程度：clf.feature_importances_

参数	解释
kernel	使用的核函数类型。linear：线性核函数；poly：多项式核函数；rbf：高斯核函数； sigmoid：sigmoid核函数；系统默认为rbf高斯核函数
gamma	poly、rbf、或sigmoid的核系数，一般取值在(0,1)之间，默认为’auto’
C	误差项的惩罚参数，一般取10n，如：1、0.1、0.01…

注意：参数gamma主要是对低维样本进行高维映射，gamma值越大则映射的维度越高，训练的结果越好。但是越容易引起过拟合，即泛化能力低。

SVM离散型数据处理

norminal（离散型）数据: 反映对象属于哪一类，各类别之间没有先后之分。是数据的第一个等级，其结构最弱。只需要按照名称来分类比如 性别（男/女），肤色（白/黄/黑），国籍（中国/英国/法国/其他）等。

若某列索引下的数据为离散型数据，则可将其转换为one-hot(独热)矩阵（即dummies矩阵）
相关代码如下：
dumm_column缩写= pd.get_dummies(data, prefix= None, prefix_sep=’_’)

参数	解释
data	传入的data为需要进行one-hot编码的数据
prefix	用于附加到DataFrame上的列名的字符串
prefix_sep= ‘_’	默认为‘_’，还可以为’/'。作用：将字符串与原列名用_连起来，让编程人员能够清楚的知道附加的字符串代表什么。

SVM数据标准化方法的代码实现

用到了sklearn-learn库中的preprocessing类

数据的标准化是将数据按比例缩放，使之落入一个小的特定区间。在某些比较和评价的指标处理中经常会用到，去除数据的单位限制，将其转化为无量纲的纯数值，便于不同单位或量级的指标能够进行比较和加权。
在SVM中，使用所有跟距离计算相关的的kernel都需要对数据进行标准化

SVM样本距离计算，数值型数据需要进行标准化处理，然后再次进行划分训练集和测试集进行检验预测性能

from sklearn import preprocessing
X_scale= preprocessing.scale(X)
数据标准化之后，数据的均值为0，方差为1。

SVM参数调优的代码实现

Scikit-learn的算法参数调优类：GridSearchCV

代码如下：
from sklearn.model_selection import GridSearchCV
参数调优初始化：gc= GridSearchCV(estimator, param_grid, scoring= ,cv ,...)
模型学习：gc.fit(X, y)
准确率：gc.score(X, y)
优化过程期间观察到的最好的评分：gc.best_score_
已取得最佳效果的参数的组合(调优后最好的参数)是：gc.best_params_
效果最好的分类器(调优后最好的模型)是：gc.best_estimator_

参数详解如下：

参数	解释
estimator	指定选择使用的分类器，为一个字符串。如：estimator= svc
param_grid	指定需要最优化的参数的取值，为字典或者列表
cv	交叉验证参数，为一个数字；默认为None，使用三折交叉验证
X[M,n]	自变量二维数组，m为样本数，n为特征项个数，数值型
y[n]	分类标签的一维数组，必须为整数

SVM模型保存—模型文件以.model保存

利用joblib库

import joblib
joblib.dump(filename, value)------SVM模型保存
joblib.load(filename)------SVM模型加载

filename------模型保存的文件位置及所设定的文件名
value------回归模型学习时你所设置的模型名

import joblib
joblib.dump(filename= 'E:\svc.model', value= clf)
'''
等同于joblib.dump(clf, 'E:\svc.model')
'''
load_clf= joblib.load('E:\svc.model')#从保存的文件中读取模型

SVM模型实现步骤

• 第一步：导入数据并对数据进行处理
  -需要导入的库：import pandas as pd
• 第二步：全部数据的svm模型初始化并测试性能
  -需要导入的库：from sklearn import svm, metrics
• 第三步：划分训练集和测试集，并初始化训练集的svm模型，在测试集上检验预测性能
  -需要导入的库：from sklearn import model_selection、from sklearn import svm, metrics
• 第四步：SVM样本距离计算(数值型数据需要进行标准化处理)，然后再次划分训练集和测试集，并初始化训练集的svm模型，在测试集上检验预测性能。
  -需要导入的库：from sklearn import svm、from sklearn import model_selection、from sklearn import metrics、from sklearn import preprocessing
• 第五步~第n步：进一步调整svm模型参数，提高正确率
• 第五步~第n步可变为：svm模型参数调优，调整出正确率最高的svm模型参数，然后在测试集上验证预测性能以此来提高正确率。
  -需要导入的库：from sklearn.model_selection import GridSearchCV

例题5-5

使用Scikit-learn建立svm模型，预测银行客户是否接受推荐的投资计划并评估分类器性能。

#第一步：导入数据并进行数据处理
data= pd.read_csv('E:\data/bankpep.csv', index_col= 'id')
data.head()

运行结果显示为：

data.loc[data['sex']== 'MALE', 'sex']= 0
data.loc[data['sex']== 'FEMALE', 'sex']= 1
feature=  ['married', 'car', 'save_act', 'current_act', 'mortgage', 'pep']
for i in feature:
    data.loc[data[i]== 'YES', i]= 1
    data.loc[data[i]== 'NO', i]= 0
data.head()

运行结果显示为：

#将norminal数据转换为dummies矩阵
dumm_reg= pd.get_dummies(data['region'], prefix= 'reg', prefix_sep='_')
dumm_child= pd.get_dummies(data['children'], prefix= 'child', prefix_sep='_')
#删除dataframe中原来的两列后再 join dummies
df1 = data.drop(['region','children'], axis = 1)
df2 = df1.join([dumm_reg,dumm_child], how='outer')
df2.head()
X= df2.drop('pep', axis= 1).values.astype(float)
y= df2['pep'].values.astype(int)
df2.head()

运行结果显示为：

#第二步：训练全部数据的SVM模型并测试性能
from sklearn import svm
svc= svm.SVC(kernel= 'rbf', gamma= 0.6, C=1.0)
svc.fit(X, y)
print(svc.score(X, y))
from sklearn import metrics
predicted_y= svc.predict(X)
print(metrics.confusion_matrix(y, predicted_y))
print(metrics.classification_report(y, predicted_y))

运行结果显示为：

#第三步：划分测试集和训练集，在测试集上检验预测性能
from sklearn import model_selection
X_train, X_test, y_train, y_test= model_selection.train_test_split(X, y, test_size= 0.3, random_state= 1)
svc= svm.SVC(kernel= 'rbf', gamma= 0.7, C= 1.0)
svc.fit(X_train, y_train)
print(svc.score(X_train, y_train))
print(svc.score(X_test, y_test))

运行结果显示为：

#第四步：SVM样本距离计算，数值型数据需要进行标准化处理，然后再次进行划分训练集和测试集进行检验预测性能
"""
SVM样本距离计算，数值型数据需要标准化(scale)处理
#数据的标准化是将数据按比例缩放，使之落入一个小的特定区间。在某些比较和评价的指标处理中经常会用到，去除数据的单位限制，将其转化为无量纲的纯数值，便于不同单位或量级的指标能够进行比较和加权。
#在SVM中，使用所有跟距离计算相关的的kernel都需要对数据进行标准化
"""
from sklearn import preprocessing
X_scale= preprocessing.scale(X)
X_train, X_test, y_train, y_test= model_selection.train_test_split(X_scale, y, test_size= 0.3, random_state= 1)
svc=svm.SVC(kernel= 'rbf', gamma= 0.7, C=1.0)
svc.fit(X_train, y_train)
print(svc.score(X_test, y_test))
	>>> 0.964444444444

'''
第五步~第n步：进一步调整SVM模型参数，提高正确率;此处直接进行参数调优
'''
from sklearn.model_selection import GridSearchCV
import pandas as pd
import numpy as np

#初始化参数
from sklearn import svm
svc= svm.SVC()
param= {'kernel':['poly','rbf'],"gamma":[0.4,0.5,0.6,0.7],'C':[0.001,0.1,0.0001]}
#进行网格搜索
gc= GridSearchCV(svc, param_grid= param, cv= 6)
#gc训练
gc.fit(X_train, y_train)
print("评价测试集的准确率", gc.score(X_test, y_test))
print("在交叉验证中最好的结果", gc.best_score_ )
print("调优后最好参数是：", gc.best_params_ )
print("调优后最好的模型是", gc.best_estimator_ )

运行结果显示为：

分类学习方式四------KNN(K-近邻算法)

• 基本原理：待分类样本的类别，由距离最近的k个邻居投票决定
• 基本目标：给定一个样本数据集合，样本集中每一个数据都存在标签。输入没有标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进行比较，根据距离公式求出两者之间的距离，然后根据距离大小进行排序，提取样本集中特征最相似数据（最近邻）的分类标签。

K-近邻算法三要素

• 第一要素—K值：K值的选择对分类结果有着非常大的影响，不同的k值得到不同的分类结果。
  若k值较小，用较小邻域中的训练实例进行预测，预测结果会对近邻的实例非常敏感，“学习”的估计误差会增大。
  若k值较大，用较大邻域中的训练实例进行预测。与待分类实例较远的训练实例也
  会对预测起作用，“学习”的估计误差会减少、近似误差会增大。

• 第二要素—度量距离：
  特征空间中两个实例的距离是两个实例相似程度的反映，不同的距离度 量所确定的近邻点是不同的。
  常见距离方法：闵可夫斯基距离（minkowski）、汉明距离等。
  距离度量时涉及数值计算和不同数值的影响，因此计算前需要进行数值 化预处理、归一化预处理。

• 第三要素—分类决策规则：
  分类决策通常采用多数表决，多数表决规则等价于经验风险最小化。也 可以基于距离的远近进行加权投票，距离越近的样本权重越大。

KNN分类代码实现1

Scikit-learnKNN算法：KNeighborsClassifier类支持二分类和多分类问题。

需要导入的库：
import pandas as pd
from sklearn.neighbors import KNeighborsClassifier

KNN模型初始化：clf= neighbors.KNeighborsClassifier(n_neighbors= , weights= ,algorithm= ,leaf_size= , metric= , p= , ...)
模型学习：clf.fit(X, y)
Accuracy计算：clf.score(X, y)
模型预测：predicted_y= clf.predict(X)
混淆矩阵计算：metrics.confusion_matrix(y, predicted_y)
分类性能报告：metrics.classification_report(y, predicted_y)

参数详解如下：

参数	解释
n_neighbors	指定K值，必须为一个整数，缺省值为5
weights	指定投票权重类型，邻居投票权可以为相同或不同，一个字符串或者可调用对象。取值类型有：‘uniform’，本节点的所有邻居接点的投票权重都相同；’distance’，本节点的所有邻居节点的投票权中与距离成反比，即越近的节点，其投票权重越大；[callable]，一个可调用对象，传入距离的数组，返回同样形状的权重数组。缺省值为’uniform’。
algorithm	指定计算最近邻的算法，一个字符串。取值类型有：’ball_tree’：使用BallTree算法；‘kd_tree’：使用KDTree算法；’brute’：使用暴力搜索法；’auto’:自动决定最合适的算法。缺省值为’auto’
leaf_size	指定BallTree或者KDTree叶节点规模，影响树的构建和查询速度，为一个整数。缺省值为30。
metric	指定距离度量，为一个字符串。缺省值为’minkowski’。
p	指定在’minkowski’度量上的指数，为一个整数值。值为1时，对应曼哈顿距离；值为2时对应欧式距离,缺省值为2。
X[m,n]	样本特征二维数组，m 样本数，n 特征项个数，数值型
y[n]	分类标签的一维数组，必须为整数

KNN分类代码实现2—数据归一化

Scikit-learn的数据归一化处理类：preprocessing

需要导入的库：
from sklearn.preprocesssing import MinMaxScaler

• 类初始化：X_scale= preprocessing.MinMaxScaler(feature_range= , copy)
• 归一化参数生成：fit(X)------求x进行归一化处理所需的统计信息，如每个特征的最小值和最大值
• 数据归一化处理：transform(X)------根据X的统计信息、feature_range缩放X的特征，需在fit（X）或fit_transform(X)之后执行，否则会报错
• 参数生成并处理：fit_transform(X)------包含两个步骤，先执行 fit 方法提取统计信息, 再执行transform用提取的数据特征、feature_range缩放X 的特征。

KNN分类代码实现3—参数调优

Scikit-learn的算法参数调优类：GridSearchCV

代码如下：
from sklearn.model_selection import GridSearchCV
参数调优初始化：gc= GridSearchCV(estimator, param_grid, scoring= ,cv ,...)
模型学习：gc.fit(X, y)
准确率：gc.score(X, y)
优化过程期间观察到的最好的评分：gc.best_score_
已取得最佳效果的参数的组合(调优后最好的参数)是：gc.best_params_
效果最好的分类器(调优后最好的模型)是：gc.best_estimator_

参数详解如下：

参数	解释
estimator	指定选择使用的分类器，为一个字符串。如：estimator= svc
param_grid	指定需要最优化的参数的取值，为字典或者列表
cv	交叉验证参数，为一个数字；默认为None，使用三折交叉验证
X[M,n]	自变量二维数组，m为样本数，n为特征项个数，数值型
y[n]	分类标签的一维数组，必须为整数

例题5-7—海伦交友数据集

使用Scikit-learn的KNN算法对海伦交友数据集的聚类分析。

import pandas as pd
data= pd.read_csv('E:\data/datingTestSet1.csv')
display(data.head())
display(data.shape)

运行结果显示为：

import matplotlib.pyplot as plt
pd.plotting.scatter_matrix(data, diagonal= 'hist')
plt.show()

运行结果显示为：

#第二步：数据预处理，标签数值化,提取特征集、标签集并划分测试集、训练集，对特征数据(训练集和测试集)进行归一化处理

#数据预处理，字符类型标签替换为数字
data_type= dict({'0':'didntLike','1':'smallDoses','2':'largeDoses'})
data.loc[data['type']== 'didntLike', 'type']= 0
data.loc[data['type']== 'smallDoses', 'type']= 1
data.loc[data['type']== 'largeDoses', 'type']= 2
display(data.head())
#提取特征集、标签集
X= data.iloc[:,:-1].values.astype(float)
y= data.iloc[:,-1].values.astype(int)
#划分测试集、训练集
from sklearn import model_selection
#stratify的作用是：保持测试集与整个数据集里result的数据分类比例一致
X_train, X_test, y_train, y_test= model_selection.train_test_split(X, y, test_size= 0.25, random_state= 0, stratify= y)

#训练数据和测试数据归一化
from sklearn.preprocessing import MinMaxScaler
mms= MinMaxScaler()
X_train= mms.fit_transform(X_train)#对训练数据进行归一化处理
X_test= mms.transform(X_test)#对测试数据进行归一化处理

运行结果显示为：

#第三步：训练算法（1）参数调优，获取最优参数
import pandas as pd
import numpy as np
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV

#初始化参数
knn= KNeighborsClassifier()#初始化k-近邻模型
#初始化k值列表
Kl= np.linspace(1, int(y_train.size/2), num= int(y_train.size/2), endpoint= True, dtype= 'int')
#k值得上限与gc中的cv关联，避免交叉验证时训练集样本数量小于k值
param= {"n_neighbors": Kl,"weights":['uniform','distance']}
#进行网格搜索
gc= GridSearchCV(knn, param_grid=param, cv=6)
#gc训练
gc.fit(X_train, y_train)
print("评价测试集的准确率", gc.score(X_test, y_test) )
print("在交叉验证中最好的结果", gc.best_score_ )
print("调优后最好参数是：", gc.best_params_ )
print("调优后最好的模型是", gc.best_estimator_ )

运行结果显示为：

#第四步：模型初始化及训练
#k-近邻模型初始化
knc= KNeighborsClassifier(n_neighbors= 21, weights= 'distance')
knc.fit(X_train, y_train)

#第五步：评价模型，在测试集上计算分类转却屡、混淆矩阵、分类性能报告
predicted_y= knc.predict(X_test)
from sklearn import metrics
print("测试集上的分类准确率为：",knc.score(X_test, y_test))
print("混淆矩阵：\n",metrics.confusion_matrix(y_test, predicted_y))
print("分类性能报告：\n",metrics.classification_report(y_test, predicted_y, target_names= ['didntLike', 'smallDoses', 'largeDoses']))
#target_names= ['didntLike', 'smallDoses', 'largeDoses']此为分类标签

运行结果显示为：

#第六步：保存训练模型，并加载模型进行预测
import joblib
joblib.dump(knc, 'knc2.model')
knc2= joblib.load('knc2.model')
test_data=[[40920,8.326976,0.953952]]
#对预测数据作归一化处理
test_data= mms.transform(test_data)
print(data_type[str(knc2.predict(test_data)[0])])
	>>> largeDoses

分类学习方式五------神经网络(Neural Network)MLP

训练神经网络

神经网络代码实现

Scikit-learn的神经网络实现：MLPClassifier类

需要导入的库：
from sklearn.neural_network import MLPClassifier

神经网络模型初始化：mlp= MLPClassifier(solver, activation,hidden_layer_sizes,alpha,max_iter,random_state,...)
模型学习：mlp.fit(X, y)
准确率(Accuracy)计算：mlp.score(X, y)
模型预测：predicted_y= mlp.predict(X)
混淆矩阵计算：metrics.confusion_matrix(y, predicted_y)
分类性能报告：metrics.classification_report(y, predicted_y)
显示特征重要程度：mlp.feature_importances_

例题5-8

使用神经网络对鸢尾花数据集进行分类分析。

import pandas as pd
data= pd.read_csv('E:\data/iris.data', header= None)
data.columns= ['sepal length','sepal width', 'petal length', 'petal width', 'class']
print(data['class'].value_counts())#每类花的样本数
data.groupby('class').mean()#每类花各特征的均值

运行结果显示为：

#数据预处理,类别使用整数表示
data.loc[ data['class'] == 'Iris-setosa', 'class' ] = 0
data.loc[ data['class'] == 'Iris-versicolor', 'class' ] = 1
data.loc[ data['class'] == 'Iris-virginica', 'class' ] = 2
X = data.iloc[:,0:4].values.astype(float)
y = data.iloc[:,4].values.astype(int)

#创建神经网络分类器，训练网格结点连接权重以及偏差
from sklearn.neural_network import MLPClassifier
mlp= MLPClassifier(solver= 'lbfgs', alpha=1e-5, hidden_layer_sizes= (5,5), random_state= 1)
mlp.fit(X, y)
mlp.score(X, y)
	>>> 0.9866666666666667

#分类性能评估
from sklearn import metrics
predicted_y= mlp.predict(X)
print("Classification report for %s" % mlp)
#分类性能报告
print (metrics.classification_report(y, predicted_y))
#混淆矩阵计算
print( "Confusion matrix:\n", metrics.confusion_matrix(y, predicted_y))

运行结果显示为：

思考与练习2

import pandas as pd
from sklearn import model_selection

#导入数据集，对数据进行处理并把数据集分为训练集和测试集
data= pd.read_csv('E:\data/bankpep.csv', index_col= 'id')
display(data.head())

data.loc[data['sex']== 'MALE', 'sex']= 0
data.loc[data['sex']== 'FEMALE', 'sex']= 1
data.loc[data['region']=='SUBURBAN', 'region']= 0
data.loc[data['region']=='RURAL', 'region']= 1
data.loc[data['region']=='TOWN', 'region']= 2
data.loc[data['region']=='INNER_CITY', 'region']= 3
feature=  ['married', 'car', 'save_act', 'current_act', 'mortgage', 'pep']
for i in feature:
    data.loc[data[i]== 'YES', i]= 1
    data.loc[data[i]== 'NO', i]= 0
display(data.head())
#将数据划分为训练集和测试集
X= data.drop(['pep'], axis= 1).values.astype(float)
y= data['pep'].values.astype(int)
X_train, X_test, y_train, y_test= model_selection.train_test_split(X, y, test_size= 0.3, random_state= 1)

运行结果显示为：

#1.训练决策树分类器，查看决策数据分类器的性能
from sklearn import tree
clf= tree.DecisionTreeClassifier()
clf.fit(X, y)
print("准确度为：\n",clf.score(X, y))
from sklearn import metrics
predicted_y= clf.predict(X)
print("混淆矩阵为：\n",metrics.confusion_matrix(y, predicted_y))
print("分类性能报告为：\n",metrics.classification_report(y, predicted_y))

运行结果显示为：

#2.将例5-5的分类器保存在文件中，然后重新加载预测给出的新数据。
import joblib
joblib.dump(svc, "E:\svc.mode")
svc2= joblib.load("E:\svc.mode")
new_data=[[63, 0, 35689, 2, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0]]
predicted_y2= svc2.predict(new_data)
predicted_y2[0]
	>>> 0

#3.训练决策树分类器，观察在测试集上的分类效果，与SVM分类器的效果进行比较。
#1.训练决策树分类器，查看决策数据分类器的性能
from sklearn import tree
clf= tree.DecisionTreeClassifier()
clf.fit(X_train, y_train)
print("准确度为：\n",clf.score(X_test, y_test))
from sklearn import metrics
predicted_y_test= clf.predict(X_test)
print("混淆矩阵为：\n",metrics.confusion_matrix(y_test, predicted_y_test))
print("分类性能报告为：\n",metrics.classification_report(y_test, predicted_y_test))

"""
由分析可知，训练决策树分类器在测试集上准确率为87%,在SVM分类器上的准确率为69%,
所以训练决策树分类器在测试集上的分类效果比SVM分类器的效果要好。
"""

运行结果显示为：

#4.训练SVM分类器时，使用‘rbf’核函数，调整参数gamma的值；使用不同的核函数，分别观察在测试集上的分类效果
#gamma=0.3
X_train, X_test, y_train, y_test= model_selection.train_test_split(X_scale, y, test_size= 0.3, random_state= 1)
svc=svm.SVC(kernel= 'rbf', gamma= 0.3, C=1.0)
svc.fit(X_train, y_train)
print(svc.score(X_test, y_test))
	>>> 0.7888888888888889

#gamma=0.4
X_train, X_test, y_train, y_test= model_selection.train_test_split(X_scale, y, test_size= 0.3, random_state= 1)
svc=svm.SVC(kernel= 'rbf', gamma= 0.4, C=1.0)
svc.fit(X_train, y_train)
print(svc.score(X_test, y_test))
	>>> 0.7944444444444444

#gamma=0.9
X_train, X_test, y_train, y_test= model_selection.train_test_split(X_scale, y, test_size= 0.3, random_state= 1)
svc=svm.SVC(kernel= 'rbf', gamma= 0.9, C=1.0)
svc.fit(X_train, y_train)
print(svc.score(X_test, y_test))
	>>> 0.6666666666666666

无监督的学习—聚类分析

• 定义：根据数据内在性质及规律将其划分为若干个不相交的子集，每个子集成为一个簇(Cluster)，即将数据划分到不同簇的过程，目标是使同一个簇中的样本的相似度较高，而不同簇间的样本相似度较低。
  注意：自动获得的簇需要人为对应“类别”概念，不同算法会得到不同的结果。

聚类可以作为分类等其他任务的预处理过程。

聚类分析方法

划分法(Paritition)：K-means
层次法(Hierarchical)
基于密度聚类(Density based)
基于图/网格聚类(Graph/Grid based)
基于模型聚类(Model based)

聚类过程

1.根据样本与簇中心的距离相似度，将数据集中的每个样本划分到与其最相似的一个簇
2.计算每个簇的中心
3.不断重复这一过程直到每个簇中心点不再变化

Step1:随机选择3个中心点
Step2:计算每个样本所属的簇
Step3:根据每个簇的样本重新计算中心点
经过多次迭代之后，中心点不再变化

聚类方法性能评估

• 有分类标签的数据集：

使用兰德指数(ARI)（Adjusted Rand Index）
计算真实标签与聚类标签两种分布相似性之间的相似性，取值范围为[0,1]
1:表示最好的结果，即聚类类别和真实类别的分布完全一致
from sklearn import metrics
metrics.adjusted_rand_score(y, kmeans.labels_)

• 没有分类标签的数据集：

使用轮廓系数(Silhouette Coefficient)来度量聚类的质量
轮廓系数同时考虑聚类结果的簇内凝聚度和簇间分离度
取值范围：[-1,1],轮廓系数越大，聚类效果越好
from sklearn import metrics
metrics.silhouette_score(X, kmeans.labels_,metric= ‘euclidean’)

聚类方式一—K-means算法

• K-means算法是划分法中的经典算法
• 基本目标：将数据聚为若干簇，簇内的点足够近，簇间的点足够远
• 方法：首先假定数据集划分为的簇数为k，从数据集中任意选择k个样本作为各簇的中心。
• 核心：相似度的计算
• 由于其数值型数据为欧氏距离，所以要先进行标准化处理

K-means算法代码实现

Scikit-learn的聚类：Cluster类

需要导入的库： import pandas as pd
from sklearn.cluster import KMeans

K-Means模型初始化：kmeans= KMeans(n_clusters)
模型学习：kmeans.fit(X)

参数	解释
n_clusters	簇的个数
X	特征二维数组，数值型

K-means算法初始k值确定

• 肘部原理：
  尝试多个k值聚类，比较轮廓系数，然后选择合适的k作为最终模型
• 步骤：
  1.设置多个簇的个数，eg:clusters= [2, 3, 4, 5, 6, 7, 8]
  2.设置一个记录轮廓系数的空列表，eg:sc_scores= []
  3.不同的簇的个数对应的K-means模型初始化并计算相对应的轮廓系数加到记录轮廓系数的空列表中。
  4.可通过折线图查看轮廓系数与簇数的关系（看现实要求，有则画折线图，无则可以省略4）

代码如下：

clusters= [2, 3, 4, 5, 6, 7, 8]#设置不同的簇个数
sc_scores= []#用来记录不同个数的簇所对应的轮廓系数
#计算各个簇模型的轮廓系数
for i in clusters:
    kmeans= KMeans(n_clusters= i).fit(X)
    sc= metrics.silhouette_score(X, kmeans.labels_, metric= 'euclidean')
    sc_scores.append(sc)
#绘制曲线图反应轮廓系数与簇数的关系
import matplotlib.pyplot as plt
plt.plot(clusters, sc_scores, marker= 'o')
plt.xlabel('Number of Clusters')
plt.ylabel('Sihouette Coefiicient Score')
plt.show()

例题5-6

使用Scikit-learn的K-means算法对鸢尾花数据集的聚类分析。

import pandas as pd
#花萼sepal  花瓣petal
columns= ['sepal length', 'sepal width', 'petal length', 'petal width', 'class']
data= pd.read_csv('E:\data/iris.data', header= None, names= columns)
data.head()

运行结果显示为：

#通过绘制特征散点图矩阵，观察每两种特征的区分度
import matplotlib.pyplot as plt
pd.plotting.scatter_matrix(data, diagonal= 'hist')
plt.show()

运行结果显示为：

#定义簇的个数为3，取前4列特征值，训练聚类模型
X= data.iloc[:,0:4].values.astype(float)
from sklearn.cluster import KMeans
kmeans= KMeans(n_clusters= 3)
kmeans.fit(X)

#使用样本簇编号作为类型标签，绘制特征对的散点图矩阵用不同颜色表示不同的簇
pd.plotting.scatter_matrix(data, c=[kmeans.labels_], diagonal= 'hist')
plt.show()
#Kmeans为X中的每个训练数据点分配一个簇标签。我们可以在kmeans.labels_中找到这些标签

运行结果显示为：

#聚类方法性能评估
#使用兰德指数(ARI)对有分类标签的数据集进行性能评估
from sklearn import metrics
data.loc[data['class']=='Iris-setosa', 'class']= 0
data.loc[ data['class'] == 'Iris-versicolor', 'class' ] = 1
data.loc[ data['class'] == 'Iris-virginica', 'class' ] = 2
y= data['class'].values.astype(int)
print(metrics.adjusted_rand_score(y, kmeans.labels_))

#比较数据类别标签与聚类结果ARI,但在比较前数据需要做个比较
data['kmeans_labels_']= kmeans.labels_#加上一列簇标签
import numpy as np
tt= data[['class', 'kmeans_labels_']]
#pd.crosstab(obj[col1], obj[col2])
#统计col1的col2分布或先根据col1分组，然后对col2进行计数
pd.crosstab(tt['class'], tt['kmeans_labels_'])

运行结果显示为：

#初始k值确定
clusters= [2, 3, 4, 5, 6, 7, 8]#设置不同的簇个数
sc_scores= []#用来记录不同个数的簇所对应的轮廓系数
#计算各个簇模型的轮廓系数
for i in clusters:
    kmeans= KMeans(n_clusters= i).fit(X)
    sc= metrics.silhouette_score(X, kmeans.labels_, metric= 'euclidean')
    sc_scores.append(sc)
#绘制曲线图反应轮廓系数与簇数的关系
import matplotlib.pyplot as plt
plt.plot(clusters, sc_scores, marker= 'o')
plt.xlabel('Number of Clusters')
plt.ylabel('Sihouette Coefiicient Score')
plt.show()
#折线图可知：当k=2时，聚类的轮廓系数最大

运行结果显示为：

思考与练习3