综合实例

from sklearn import datasets
import pandas as pd
import numpy as np
import seaborn as sns
boston=datasets.load_boston()
print('boston.data的形状为：',boston.data.shape)
print('boston.target的形状为：',boston.target.shape)
print('boston.target的特征名称为：\n',boston.feature_names)
df_boston=pd.DataFrame(np.hstack((boston.data,boston.target.reshape(-1,1))))
#高手点拨，为两个数组合并后转化为的.DataFrame添加特征名称
#columns=np.append(boston.feature_names,'values')
#df_boston=pd.DataFrame(np.hstack((boston.data,boston.target.reshape(-1,1))),columns=columns)
sns.pairplot(df_boston)#必须是DataFrame对象
#创建或访问一个文件夹
import os
path='D:/my_python/ch5/data/'
if not os.path.exists(path):
  os.makedirs(path)
#保存为csv文本文件
df_boston.to_csv(path+'boston.csv',sep = ',',index = False) #保存为csv文本文件
loaded_boston=pd.read_table(path+'boston.csv',
      sep = ',',encoding = 'gbk')#读取csv文本文件
sns.pairplot(loaded_boston)#必须是DataFrame对象
#保存为Excel文件
df_boston.to_excel(path+'boston.xls') 
loaded_boston2=pd.read_excel(path+'boston.xls')
sns.pairplot(loaded_boston2)#必须是DataFrame对象

#6-12 综合实例——breast_cancer数据集特征关系分析、标准化、降维
from sklearn import datasets
from sklearn import preprocessing
import numpy as np
import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt
#加载scikit-learn自带数据集breast_cancer
breast_cancer=datasets.load_breast_cancer()
print('breast_cancer.data的形状为：',breast_cancer.data.shape)
print('breast_cancer的特征名称为：\n',breast_cancer.feature_names)
print('breast_cancer.target的形状为：',breast_cancer.target.shape)
print('breast_cancer.target的目标名称为：',breast_cancer.target_names)
sns.violinplot(data=pd.DataFrame(breast_cancer.data))
plt.title('breast_cancer.data的各特征小提琴图')#添加标题
#下行语句非常占内存，需要较长时间才能绘制成功，可以注释掉
#sns.pairplot(data=pd.DataFrame(breast_cancer.data))
from sklearn import decomposition
#PCA降维
pca = decomposition.PCA(n_components=10)
pca.fit(X_min_max)
pca_X=pca.transform(X_min_max)
print('经PCA降维后的形状为',pca_X.shape)
sns.violinplot(data=pd.DataFrame(pca_X))
plt.title('PCA降维后各特征小提琴图')#添加标题
sns.pairplot(data=pd.DataFrame(pca_X))
clf_lda=LDA(n_components=1)#n_components要小于类的数量
clf_lda.fit(X_min_max, breast_cancer.target)
lda_X=clf_lda.fit_transform(X_min_max,breast_cancer.target)
print('lda_X的形状为：',lda_X.shape)
ax = sns.stripplot(x=1,y=0,  
                   data=pd.DataFrame(np.hstack((lda_X, breast_cancer.target.reshape(-1,1)))),
                   jitter=True)
#TSNE降维
from sklearn.manifold import TSNE
tsne=TSNE(n_components=2)#n_components<4
tsne_X=tsne.fit_transform(X_min_max)
print('tsne_X的形状为：',tsne_X.shape)
#在二维平面上将二维特征分类可视化
plt.figure(figsize=(6, 4))
plt.scatter(tsne_X[np.where(breast_cancer.target==0),0],
            tsne_X[np.where(breast_cancer.target==0),1],marker='.',c='r')
plt.scatter(tsne_X[np.where(breast_cancer.target==1),0],
            tsne_X[np.where(breast_cancer.target==1),1],marker='*',c='g')
plt.title('breast_cancer数据集降为2维的分类别样本')#添加标题
plt.legend(breast_cancer.target_names)
plt.show()

#%%
#ch3-6,综合实例
#3-49. 分析scikit-learn自带数据集iris的特征及特征间关系
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn import datasets
iris = datasets.load_iris()
print('iris.data的形状为：',iris.data.shape)
print('iris.target的形状为：',iris.target.shape)
print('iris.data的特征名称为：',iris.feature_names)
#%%
#使用matplotlib.pyplot绘制图形
#以子图形式绘制特征的散点图、点线图、柱状图、饼图、箱形图、直方图
plt.rcParams['font.sans-serif'] = 'SimHei'#设置字体为SimHei显示中文
p = plt.figure(figsize=(12,10))
# 子图1，两特征的三点图
ax1 = p.add_subplot(3,2,1)
plt.scatter(iris.data[:,0],iris.data[:,1], marker='o')#绘制散点图
plt.xlabel(iris.feature_names[0])#添加横轴标签
plt.ylabel(iris.feature_names[1])#添加y轴名称
plt.title('iris数据集特征散点图')#添加标题
#子图2，4个特征的点线图
ax1 = p.add_subplot(3,2,2)
plt.plot(iris.data[:,0],color = 'r',linestyle = '--',marker = 'o')
plt.plot(iris.data[:,1],color = 'g',linestyle = '-',marker = '*')
plt.plot(iris.data[:,2],color = 'b',linestyle = '-',marker = '^')
plt.plot(iris.data[:,3],color = 'k',linestyle = '-',marker = '<')
plt.legend([iris.feature_names[0],iris.feature_names[1],
            iris.feature_names[2],iris.feature_names[3]])
plt.xlabel('index')#添加横轴标签
plt.ylabel('feature values')#添加y轴名称
plt.title('iris数据集特征点线图')#添加标题
# 子图3，特征的柱状图
ax1 = p.add_subplot(3,2,3)
plt.bar(range(len(iris.data[0:20,0])),iris.data[0:20,0],
        width = 0.5)## 绘制柱状图
plt.title('iris特征0柱状图')#添加标题
#labels=[iris.feature_names[0]]
plt.xlabel(iris.feature_names[0])#添加横轴标签
plt.ylabel('feature values')#添加y轴名称
#plt.xticks(range(0),labels)
# 子图4，各特征和的饼图
ax1 = p.add_subplot(3,2,4)
plt.pie([np.sum(iris.data[:,0]),np.sum(iris.data[:,1]),
         np.sum(iris.data[:,2]),np.sum(iris.data[:,3])],
        labels=iris.feature_names,autopct='%1.1f%%')#绘制饼图
plt.title('iris数据集各特征和的饼图')#添加标题
# 子图5，箱线图
ax1 = p.add_subplot(3,2,5)
plt.boxplot([iris.data[:,0],iris.data[:,1],
            iris.data[:,2],iris.data[:,3]],
            notch=True,labels =iris.feature_names, 
            meanline=True)
plt.title('iris数据集各特征箱线图')#添加标题
plt.xlabel('特征')#添加横轴标签
plt.ylabel('特征值')#添加y轴名称
plt.xticks([1,2,3,4],iris.feature_names,rotation=15)
# 子图6，特征直方图
ax1 = p.add_subplot(3,2,6)
plt.hist(iris.data[:,0],density=True,color='r')
plt.hist(iris.data[:,1],density=True,color='g')
plt.hist(iris.data[:,2],density=True,color='b')
plt.hist(iris.data[:,3],density=True,color='k')
plt.title('iris特征直方图（概率）')
plt.legend(iris.feature_names)
plt.tight_layout() #调整子图间距，避免重叠
plt.show()
#%%
#使用seaborn绘图，观察特征分布、特征间关系、分类别可视化
import seaborn as sns
#将iris的data和target合并
iris_data_target=np.hstack((iris.data,iris.target.reshape(-1,1)))
#转化为DataFrame对象
df_iris_data_target=pd.DataFrame(iris_data_target,
                                 columns=['sepal length', 'sepal width',
                                          'petal length', 'petal width',
                                          'species'])
g = sns.catplot(data=df_iris_data_target)
#%%
g = sns.catplot(x="species", y="sepal length",
                hue="species", data=df_iris_data_target)
#%%
#对类别特征添加核密度估计
sns.catplot(x="species", y="sepal width",
            hue="species", kind="violin",
            data=df_iris_data_target)
#%%
#按类别绘制特征的strip图
ax = sns.stripplot(x="species", y="petal length", 
                   data=df_iris_data_target,jitter=0.05)
#%%
#按类别绘制特征的swarm图
ax = sns.swarmplot(x="species", y="petal width",
                   hue='species', data=df_iris_data_target)
#%%
#按类别绘制各特征的小提琴图，并添加类别图例
ax = sns.violinplot(x="species", y="petal width",
                   hue='species', data=df_iris_data_target)
#%%
#分类别绘制特征的分布箱形图
ax = sns.boxenplot(x="species", y="sepal width",
                   hue='species', data=df_iris_data_target)
#%%
#绘制样本数量统计图，并添加类别图例
ax = sns.countplot(y="species",hue='species',
                   data=df_iris_data_target,orient='h')
#%%
#绘制数组的分布
sns.distplot(iris.data[:,0])
plt.title(iris.feature_names[0]+'的分布')
#%%
#绘制DataFrame对象切片的分布
sns.distplot(df_iris_data_target.iloc[:,1])
plt.title(iris.feature_names[1]+'的分布')
#%%
#使用多种方式访问DataFrame对象的特征、切片，绘制特征分布
sns.distplot(df_iris_data_target.iloc[:,0],color="r")
sns.distplot(df_iris_data_target.loc[:,'sepal width'],color="g")
sns.distplot(df_iris_data_target.loc[:,'petal length'],color="b")
sns.distplot(df_iris_data_target['petal width'],color="k")
plt.legend(iris.feature_names)#添加图例
plt.title('iris多个特征分布')
#%%
#绘制二维特征联合分布核密度估计
plt.rcParams['axes.unicode_minus']=False#显示负号
sns.jointplot(df_iris_data_target['petal length'],
              df_iris_data_target['petal width'],kind="kde")
#%%
#将iris.data转化为DataFrame对象，绘制两两特征间的散点图
df_iris_data=pd.DataFrame(iris.data,columns=iris.feature_names)
sns.pairplot(df_iris_data)
#%%

#%%
#ch4-4 综合实例——iris数据集统计分析
#4-31 加载scikit-learn自带数据集iris，分别使用numpy, pandas
#进行统计分析，按照等宽法、等频法离散特征，进行分组聚合，创建透视表、交叉表
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn import datasets
import seaborn as sns
iris = datasets.load_iris()
print('iris.data的形状为：',iris.data.shape)
print('iris.target的形状为：',iris.target.shape)
print('iris.data的特征名称为：',iris.feature_names)
#%%
#numpy统计分析，用热力图表示排序结果
ax = sns.heatmap(iris.data)#原始数据集
#%%
ax = sns.heatmap(np.sort(iris.data))#不指定axis时，默认沿着横轴排序
#%%
ax = sns.heatmap(np.sort(iris.data,axis=0))#沿着纵轴排序
#%%
print('iris.data各特征的和为：',iris.data.sum(axis = 0))  #沿着纵轴计算
print('iris.data各特征的均值为：',iris.data.mean(axis = 0))  #沿着纵轴计算
print('iris.data各特征的标准差为：',iris.data.std(axis = 0))  #沿着纵轴计算
print('iris.data各特征的方差为：',iris.data.var(axis = 0))  #沿着纵轴计算
print('iris.data的最大值为：',np.max(iris.data))
print('iris.data的最小值为：',np.min(iris.data))
print('iris.data特征0的最大值索引为：',np.argmax(iris.data[:,0]))
print('iris.data特征0的最小值索引为：',np.argmin(iris.data[:,0]))
print('iris.data的最大值索引为：',np.argmax(iris.data))
print('iris.data的最小值索引为：',np.argmin(iris.data))
print('iris.data特征0的中位数为：',np.median(iris.data[:,0]))
print('iris.data的中位数为：',np.median(iris.data))
print('iris.data特征0的极差为：',np.ptp(iris.data[:,0]))
print('iris.data的极差为：',np.ptp(iris.data))
print('iris.data特征0与特征1的协方差为：\n',np.cov(iris.data[:,0],iris.data[:,1]))
#%%
#pandas统计分析
#合并iris的数据集和目标集，转化为DataFrame对象
df_iris=pd.DataFrame(np.hstack((iris.data,iris.target.reshape(-1,1))),
                     columns=['f0','f1','f2','f3','species'])
print('iris的形状为：',df_iris.shape)
print('iris的列名为：',df_iris.columns)
print('iris的前5行为：\n',df_iris.head())
#%%
#查看iris特征0的各项统计数据
print('iris特征0的最小值为：',df_iris['f0'].min())
print('iris特征0的最大值为：',df_iris['f0'].max())
print('iris特征0的均值为：',df_iris['f0'].mean())
print('iris特征0的极差为：',df_iris['f0'].kurt())
print('iris特征0的方差为：',df_iris['f0'].var())
print('iris特征0的标准差为：',df_iris['f0'].std())
#%%
print('iris的协方差矩阵为：\n',df_iris[['f0', 'f1', 'f2', 'f3']].cov())
#%%
print('iris数据表的相关系数为：\n',df_iris[['f0', 'f1', 'f2', 'f3']].corr())
#%%
print('iris特征0的标准误差为：',df_iris['f0'].sem())
print('iris特征0的众数为：\n',df_iris['f0'].mode())
print('iris特征0的样本偏度为：',df_iris['f0'].skew())
print('iris特征0的样本峰度为：',df_iris['f0'].kurt())
#%%
print('iris特征0的中位数为：',df_iris['f0'].median())
#设置任意分位数
print('iris特征0的四分位数为：',df_iris['f0'].quantile(q=0.25))
print('iris特征0的非空值数目为：',df_iris['f0'].count())
print('iris特征0的平均绝对离差为：',df_iris['f0'].mad())
#%%
print('iris数据表的描述性统计为：\n',df_iris[['f0', 'f1', 'f2', 'f3']].describe())
#%%
#类别型数据描述性统计，先将类别转换为category类型
df_iris['species']=df_iris['species'].astype('category')
print('iris数据表的描述性统计为：\n', 
      df_iris[['f0', 'f1', 'f2', 'f3','species']].describe())
#%%
print('iris数据表category类别species的描述性统计为：\n', 
      df_iris['species'].describe())
#%%
print('iris品种的频数统计为：\n',df_iris['species'].value_counts())
#%%
print('iris特征0的频数统计为：\n',df_iris['f0'].value_counts())
#%%
k=5#离散化为等宽的k个区间
#返回k个区间，相当于k个类，以bins作为分割点
f0,bins=pd.cut(df_iris['f0'],k,retbins=True)
print('iris特征0分割成',k,'个等宽区间的分割点是：\n',bins)
#%%
print('iris特征0等宽离散化为5个区间后每个区间及其频数为：\n',
      f0.value_counts())
#%%
#可视化，按照频数降序排列
a_frequency=f0.value_counts()
labels=a_frequency.index[0:k]#将区间作为标签
#以下两行语句书本上没有，代码中新添加，用于在图中显示汉字，设置字号
plt.rcParams['font.sans-serif'] = 'SimHei'#设置字体为SimHei显示中文
plt.rc('font', size=14)#设置图中字号大小
plt.figure(figsize=(6,4))#设置画布
plt.bar(range(k),a_frequency,width=0.5)#绘制柱状图
plt.title('iris特征0等宽法频数统计图')#添加标题
plt.xlabel('iris特征0')#添加横轴标签
plt.ylabel('频数')#添加y轴名称
plt.xticks(range(k),labels,rotation=20)#横轴刻度与标签对准
plt.show()
#%%
#可视化，按照区间从小到大排列
a_frequency=f0.value_counts(sort=False)
labels=a_frequency.index[0:k]#将区间作为标签
plt.figure(figsize=(6,4))#设置画布
plt.bar(range(k),a_frequency,width=0.5)#绘制柱状图
plt.title('iris特征0等宽法频数统计图')#添加标题
plt.xlabel('iris特征0')#添加横轴标签
plt.ylabel('频数')#添加y轴名称
plt.xticks(range(k),labels,rotation=20)#横轴刻度与标签对准
plt.show()
#%%
#自定义等频法离散化函数
def same_frequency_cut(data,k):
    #产生k个分位数位置
    w=data.quantile(np.arange(0,1+1.0/k,1.0/k))
    data=pd.cut(data,w)#按照分位数位置离散化data
    return data
a_frequency= same_frequency_cut(df_iris['f0'],5).value_counts()
print('iris特征0等频法离散化后各个类别数目分布状况为：','\n',a_frequency)
#%%
#可视化，按照区间从小到大排列
a_frequency=same_frequency_cut(df_iris['f0'],5).value_counts(sort=False)
labels=a_frequency.index[0:k]#将区间作为标签
plt.figure(figsize=(6,4))#设置画布
plt.bar(range(k),a_frequency,width=0.5)#绘制柱状图
plt.title('iris特征0等频法频数统计图')#添加标题
plt.xlabel('iris特征0')#添加横轴标签
plt.ylabel('频数')#添加y轴名称
plt.xticks(range(k),labels,rotation=20)#横轴刻度与标签对准
plt.show()
#%%
#使用groupby按照鸢尾花品种(species)进行分组聚合
irisGroup = df_iris.groupby(by='species')
#各个特征使用相同的函数统计计算
print('iris数据表按species分组后前5组每组的数量为：\n', 
      irisGroup.count().head())
#%%
print('iris数据表按species分组后前5组每组的最大值为：\n', 
      irisGroup.max().head())
#%%
print('iris数据表按species分组后前5组每组的最小值为：\n', 
      irisGroup.min().head())
#%%
print('iris数据表按species分组后前5组每组的和为：\n', 
      irisGroup.sum().head())
#%%
print('iris数据表按species分组后前5组每组的均值为：\n', 
      irisGroup.mean().head())
#%%
print('iris数据表按species分组后前5组每组的标准差为：\n', 
      irisGroup.std().head())
#%%
print('iris数据表按species分组后前5组每组的中位数为：\n', 
      irisGroup.median().head())
#%%
print('iris数据表按species分组后前5组每组的大小为：\n', 
      irisGroup.size().head())
#%%
#使用agg()聚合，func使用函数列表
print('iris数据表的特征0总和与特征1的总和与均值为：\n',
      df_iris.agg({'f0':np.sum,'f1':[np.mean,np.sum]}))
#%%
print('iris数据表分组后前5组每组的均值为：\n', 
      irisGroup.agg(np.mean).head())
#%%
print('iris数据表分组后前5组每组的聚合结果为：\n',
      irisGroup.agg({'f0':np.sum,'f1':[np.mean,np.sum],
                    'f2':[np.mean,np.sum,np.std]}))
#%%
#创建透视表
irisPivot = pd.pivot_table(df_iris[['f0','f1','f2','f3','species']],
      index = 'species')#默认使用numpy.mean
#获取组名
print('iris数据表按species分组聚合后的组名为：\n',irisPivot.index)
#获取组的数量
print('iris数据表按species分组聚合后的组的数量为：',irisPivot.index.size)
#%%
print('iris数据表按species分组聚合后的各组平均值为：\n',irisPivot.values)
#%%
print('以species作为分组键创建的iris数据透视表为：\n',
       irisPivot.head())
#%%
#使用两个分组键，第一个为主分组键，第二个为次分组键
irisPivot = pd.pivot_table(df_iris[['f0','f1','f2','f3','species']],
      index = ['f0','species'],aggfunc = np.sum)#使用numpy.sum
print('以f0和species作为分组键创建的iris数据透视表为：\n',
       irisPivot.head(10))
#%%
irisPivot = pd.pivot_table(df_iris[['f0','f1','f2','f3','species']],
                           index = ['species','f0'],
                           aggfunc = np.sum)#使用numpy.sum
print('以species和f0作为分组键创建的iris数据透视表为：\n',
       irisPivot.head(10))
#%%
irisPivot = pd.pivot_table(df_iris[['f0','f1','f2','f3','species']],
                           index = 'species',
                           columns='f0',
                           aggfunc = np.sum)#使用numpy.sum
print('以species和f0作为分组键创建的iris数据透视表为：\n',
       irisPivot.head(10))
#%%
#创建交叉表
irisCross = pd.crosstab(
      index=df_iris['species'],
      columns=df_iris['f1'],
      values = df_iris['f0'],aggfunc = np.sum)
print('以species和f1为分组键、f0为值的iris数据交叉透视表前10行10列为：\n',
      irisCross.iloc[:10,:10])
#%%

#加载scikit-learn自带数据集iris
from sklearn import datasets
iris = datasets.load_iris()
print('iris.data的形状为：',iris.data.shape)
print('iris.data的特征名称为：',iris.feature_names)
print('iris.target的内容为：\n',iris.target)
print('iris.target的形状为：',iris.target.shape)
print('iris.target的鸢尾花名称为：',iris.target_names)


#%%

X=iris.data
y=iris.target
#导入scikit-learn的tree模块
from sklearn import tree
#调用决策树分类器，添加参数
clf_tree = tree.DecisionTreeClassifier(criterion='entropy',max_depth=2)
#将训练集和目标集进行匹配训练
clf_tree.fit(X,y)
dot_data=tree.export_graphviz(clf_tree, out_file=None,
                              feature_names=iris.feature_names,
                              class_names=True,
                              filled=True, rounded=True)
#观察dot_data决策结果数据文件
print('dot_data决策结果数据文件为：\n',dot_data)

#%%

#导入graphviz模块，将训练生成的决策树数据文件可视化。要求事先已安装好graphviz模块。
import graphviz
#设置环境变量，将graphviz的bin目录加到PATH
import os
os.environ["PATH"] += os.pathsep + 'D:/Program Files/Graphviz2.38/bin/'
#决策树可视化
graph=graphviz.Source(dot_data)
graph

#%%

y_predict=clf_tree.predict(X)
#可视化
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = 'SimHei'#设置字体为SimHei显示中文
#plt.rcParams['axes.unicode_minus']=False#坐标轴刻度显示负号
plt.rc('font', size=14)#设置图中字号大小
plt.figure(figsize=(10,4)) 
plt.scatter(range(len(y)),y,marker='o')
plt.scatter(range(len(y)),y_predict+0.1,marker='*')#将数据错开
plt.legend(['真实类别','预测类别'])
plt.title('使用决策树对iris数据集的预测结果与真实类别的对比')
plt.show()

#%%

#调用决策树分类器，添加参数
clf_tree2 = tree.DecisionTreeClassifier(criterion='gini',max_depth=2)
#将训练集和目标集进行匹配训练
clf_tree2.fit(X,y)
dot_data=tree.export_graphviz(clf_tree2, out_file=None,
                              feature_names=iris.feature_names,
                              class_names=True,
                              filled=True, rounded=True)
graph=graphviz.Source(dot_data)
graph

#%%

y_predict2=clf_tree2.predict(X)
#可视化
plt.figure(figsize=(10,4)) 
plt.scatter(range(len(y)),y,marker='o')
plt.scatter(range(len(y)),y_predict2+0.1,marker='*')#将数据错开
plt.legend(['真实类别','预测类别'])
plt.title('使用决策树对iris数据集的预测结果与真实类别的对比')
plt.show()

#%%

#调用决策树分类器，添加参数
clf_tree3 = tree.DecisionTreeClassifier(criterion='gini',max_depth=3)
#将训练集和目标集进行匹配训练
clf_tree3.fit(X,y)
dot_data=tree.export_graphviz(clf_tree3, out_file=None,
                              feature_names=iris.feature_names,
                              class_names=True,
                              filled=True, rounded=True)
graph=graphviz.Source(dot_data)
graph

#%%

y_predict3=clf_tree3.predict(X)
#可视化
plt.figure(figsize=(10,4)) 
plt.scatter(range(len(y)),y,marker='o')
plt.scatter(range(len(y)),y_predict3+0.1,marker='*')#将数据错开
plt.legend(['真实类别','预测类别'])
plt.title('使用决策树对iris数据集的预测结果与真实类别的对比')
plt.show()

#%%

#综合实例
#例10-6 对iris数据进行聚类
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn import datasets
#导入鸢尾花数据集iris
iris = datasets.load_iris()
# 取全部4列作为特征属性
#print('iris的内容为：\n',iris)
X = iris.data
y = iris.target
#计算K值从1到10对应的平均畸变程度，寻找较好的聚类数目K
DrawElbowKMeans(X=X)
plt.show() 

#%%

from sklearn.preprocessing import MinMaxScaler
from sklearn.cluster import KMeans
data = X#提取数据集中的特征
scale = MinMaxScaler().fit(data)# 训练规则，极差标准化
dataScale = scale.transform(data)# 应用规则
kmeans = KMeans(n_clusters = 3).fit(dataScale)#构建并训练模型
#观察聚类结果的数据文件
print('构建的K-Means模型为：\n',kmeans)

#%%

labels= kmeans.labels_ #提取聚类结果的类标签
print('iris数据集原始类别为：\n',y)
print('iris数据集聚类结果为：\n',labels)

#%%

print('簇的质心为：\n',kmeans.cluster_centers_)
print('样本到最近簇质心的距离和为：',kmeans.inertia_)

#%%

#可视化，观察聚类结果，与原始类别进行对比
plt.figure(figsize=(12,4))#设置画布
plt.scatter(range(y.size), y, c='k',marker='.')
plt.scatter(range(y.size), labels+.1, c='k',marker='x')#适当错开，便于观察
plt.xlim((0,y.size))
plt.xlabel('样本序号')
plt.ylabel('分类/聚类标签')
plt.title('鸢尾花K均值聚类结果与原始分类结果对比')
plt.legend(['原始分类','聚类结果'])
plt.show() 

#例9-10 综合实例. 使用支持向量机对scikit-learn自带数据集wine进行分类。
#要求将数据集拆分为训练集和测试集，使用训练集训练支持向量机模型，使用测试集测试模型
#加载scikit-learn自带数据集wine
import matplotlib.pyplot as plt
from sklearn import svm, datasets
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
wine=datasets.load_wine()
print('wine.data的形状为：',wine.data.shape)
print('wine.target的形状为：',wine.target.shape)
print('wine.target的特征名称为：\n',wine.target_names)
#将数据集拆分为训练集和测试集
X = wine.data
y = wine.target
X_train,X_test, y_train,y_test = train_test_split(
    X,y,train_size = 0.8,random_state = 42)
print('拆分后训练集特征集的形状为：',X_train.shape)
print('拆分后训练集目标集的形状为：',y_train.shape)
print('拆分后测试集特征集的形状为：',X_test.shape)
print('拆分后测试集目标集的形状为：',y_test.shape)
kernels=['linear', 'poly', 'rbf','sigmoid']
for kernel in kernels:
    #使用支持向量机进行训练
    clf_svm = svm.SVC(kernel=kernel,gamma=2)
    clf_svm.fit(X_train, y_train)
    y_pred = clf_svm.predict(X_test)#预测
    #可视化预测结果，将预测结果与实际类标签对比
    plt.rc('font', size=14)#设置图中字号大小
    plt.rcParams['font.sans-serif'] = 'SimHei'#设置字体为SimHei显示中文
    plt.figure(figsize=(8, 3))
    #绘制训练集原始数据散点图，以表示
    plt.scatter(range(len(y_test)),y_test, marker='o')
    plt.scatter(range(len(y_pred)),y_pred+0.1, marker='*')#将类标签错开
    plt.xlabel('样本索引')
    plt.ylabel('类标签')
    plt.legend(['实际类标签','预测类标签'])
    title=kernel+'核函数对测试集的预测结果与实际类标签对比'
    plt.title(title)#添加标题
    plt.show()

#例7-11 Boston房价回归模型
from sklearn.linear_model import LinearRegression
from sklearn.datasets import load_boston
boston = load_boston()
print('boston房价数据集的特征名字为：',boston.feature_names)
X = boston.data
y = boston.target
print('X的形状为：',X.shape)
print('y的形状为：',y.shape)
#线性回归
lin_reg = LinearRegression().fit(X,y)
#原书中语句：y_lin_reg_pred = clf_lin_reg.predict(X)
#应为：
y_lin_reg_pred = lin_reg.predict(X)
import matplotlib.pyplot as plt
#可视化
plt.rcParams['font.sans-serif'] = 'SimHei'#设置字体为SimHei显示中文
plt.rcParams['axes.unicode_minus']=False#坐标轴刻度显示负号
plt.rc('font', size=14)#设置图中字号大小
plt.figure(figsize=(15,4)) 
plt.rcParams['axes.unicode_minus']=False#坐标轴刻度显示负号
plt.plot(y,marker='o')
plt.plot(y_lin_reg_pred,marker='*')
plt.legend(['真实值','预测值'])
plt.title('Boston房价线性回归预测值与真实值的对比')
plt.show()
#2次多项式回归
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
boston_poly = PolynomialFeatures(2)
boston_poly.fit(X)#拟合多项式模型
X2=boston_poly.transform(X)#使用拟合模型变换X
print('原始数据集X的形状为：',X.shape)
print('X转换为X2后的形状为：',X2.shape)  
lin_reg = LinearRegression()#生成线性回归模型实例
lin_reg.fit(X2,y)#使用变换后的数据集拟合线性回归模型
y_poly2_predict=lin_reg.predict(X2)
#可视化
plt.figure(figsize=(15,4)) 
plt.plot(y,marker='o')
plt.plot(y_poly2_predict,marker='*')
plt.legend(['真实值','预测值'])
plt.title('Boston房价2次多项式回归预测值与真实值的对比')
plt.show()
#3次多项式回归
boston_poly3 = PolynomialFeatures(3)
boston_poly3.fit(X)#拟合多项式模型
X3=boston_poly3.transform(X)#使用拟合模型变换X
print('原始数据集X的形状为：',X.shape)
print('X转换为X3后的形状为：',X3.shape)  
lin_reg = LinearRegression()#生成线性回归模型实例
lin_reg.fit(X3,y)#使用变换后的数据集拟合线性回归模型
y_poly3_predict=lin_reg.predict(X3)
#可视化
plt.figure(figsize=(15,4)) 
plt.plot(y,marker='o')
plt.plot(y_poly3_predict,marker='*')
plt.legend(['真实值','预测值'])
plt.title('Boston房价3次多项式回归预测值与真实值的对比')
plt.show()
#计算三种回归模型预测值与真实值的相对误差
error_linear=(y_lin_reg_pred-y)/y
error_poly2=(y_poly2_predict-y)/y
error_poly3=(y_poly3_predict-y)/y
#可视化，绘制相对误差
plt.figure(figsize=(15,4)) 
plt.plot(error_linear,c='r')
plt.plot(error_poly2,c='y')
plt.plot(error_poly3,c='b')
plt.legend(['linear','ploy2','ploy3'])
plt.title('3个估计器对Boston房价预测值与真实值的相对误差')
plt.show()

#综合实例11-6. 加载scikit-learn自带数据集diabetes，使用集成学习方法进行分类
from sklearn.ensemble import BaggingClassifier,RandomForestClassifier
from sklearn.ensemble import AdaBoostClassifier,GradientBoostingClassifier
from xgboost import XGBClassifier
from sklearn import tree, datasets
import numpy as np
from sklearn.model_selection import train_test_split
digits=datasets.load_digits()
print('digits.data的形状为：',digits.data.shape)
print('digits.target的形状为：',digits.target.shape)
print('digits.target的特征名称为：\n',digits.target_names)
print('digits.images的形状为：\n',digits.images.shape)
#%%
X=digits.data
y=digits.target
X_train,X_test, y_train,y_test = train_test_split(
    X,y,train_size = 0.8,random_state = 42)
#%%
d_tree = tree.DecisionTreeClassifier()
bagging=BaggingClassifier(base_estimator=tree.DecisionTreeClassifier())
r_forest=RandomForestClassifier()
adaboost = AdaBoostClassifier(base_estimator=
                              tree.DecisionTreeClassifier())
gboost = GradientBoostingClassifier()
xgboost = XGBClassifier()
#%%
model_name=['决策树','Bagging','随机森林','AdaBoost','XGBoost']
models={d_tree,bagging, r_forest, adaboost, gboost, xgboost}
import time
for name_idx, model in zip([0,1,2,3,4],models):
    start = time.perf_counter()
    model.fit(X_train,y_train)
    end = time.perf_counter()
    print (model_name[name_idx],'模型拟合时间为：',end-start)
    y_pred=model.predict(X_test)
    wrong_pred_num=len(y[np.where(y_pred!=y_test)])
    print(model_name[name_idx],'预测错误的样本数量为：',wrong_pred_num)
    time.sleep(2)#延迟2秒