《Python机器学习及实践---- 从零开始通往Kaggle竞赛之路》课后代码整理与总结

《Python机器学习及实践---- 从零开始通往Kaggle竞赛之路》课后代码整理与总结

又是一年假期，今年最让我感兴趣的课程可能就是这个《Python机器学习及实践---- 从零开始通往Kaggle竞赛之路》，虽然没学完，但是感觉挺有意思的，下面整理一下本学期的代码，提供给需要的学弟学妹们使用。

逐条运行

就是就是上面这个书。

-------------------------------线性划分-----------------------------------

代码12数据：

train数据
test数据

代码12 ：“良恶性乳腺肿瘤预测”

import pandas as pd
df_train = pd.read_csv('train.csv')
df_test = pd.read_csv('test.csv')

df_test_negative = df_test.loc[df_test['Class'] == 2][['Clump Thickness','Uniformity of Cell Size']] 
df_test_positive = df_test.loc[df_test['Class'] == 4][['Clump Thickness','Uniformity of Cell Size']]

 #导入matplotlib工具包中的pyplot
import matplotlib.pyplot as plt

#绘制图中的良性肿瘤样本点，标记为红色的o
plt.scatter(df_test_negative['Clump Thickness'],df_test_negative['Uniformity of Cell Size'],marker='o',s=200,c='red')
#绘制图中的恶性肿瘤样本点，标记为黑色的x
plt.scatter(df_test_positive['Clump Thickness'],df_test_positive['Uniformity of Cell Size'],marker='x',s=150,c='black')
plt.xlabel('Clump Thickness')
plt.ylabel('Uniformity of Cell Size')
plt.show()

import numpy as np
#利用numpy中的random函数随机采样直线的截距和系数
intercept = np.random.random([1])
coef = np.random.random([2])
lx = np.arange(0,12)
ly = (-intercept - lx* coef[0])/coef[1]
#绘制一条随机直线
plt.plot(lx,ly,c = 'yellow')
plt.scatter(df_test_negative['Clump Thickness'],df_test_negative['Uniformity of Cell Size'],marker='o',s=200,c='red')
plt.scatter(df_test_positive['Clump Thickness'],df_test_positive['Uniformity of Cell Size'],marker='x',s=150,c='black')
plt.xlabel('Clump Thickness')
plt.ylabel('Uniformity of Cell Size')
plt.show()

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
 
#使用前10条训练样本学习直线的系数和截距
lr.fit(df_train[['Clump Thickness','Uniformity of Cell Size']][:40],df_train['Class'][:40])
print('Testing accuracy(10 training samples):',lr.score(df_test[['Clump Thickness','Uniformity of Cell Size']],df_test['Class']))
  
intercept = lr.intercept_
coef = lr.coef_[0,:]
#原本这个分类面应该是 lx * coef[0] + ly * coef[1]+intercept = 0,映射到2维平面上之后，应该是
ly = (-intercept - lx * coef[0])/coef[1]

intercept = lr.intercept_
coef = lr.coef_[0,:]
#原本这个分类面应该是 lx * coef[0] + ly * coef[1]+intercept = 0,映射到2维平面上之后，应该是
ly = (-intercept - lx * coef[0])/coef[1]

#绘图
plt.plot(lx,ly,c = 'green')
plt.scatter(df_test_negative['Clump Thickness'],df_test_negative['Uniformity of Cell Size'],marker='o',s=200,c='red')
plt.scatter(df_test_positive['Clump Thickness'],df_test_positive['Uniformity of Cell Size'],marker='x',s=150,c='black')
plt.xlabel('Clump Thickness')
plt.ylabel('Uniformity of Cell Size')
plt.show()
 
lr = LogisticRegression()
#使用所有训练样本学习直线的系数和截距
lr.fit(df_train[['Clump Thickness','Uniformity of Cell Size']],df_train['Class'])
# print'Testing accuracy(all training samples):',lr.score(df_test[['Clump Thickness','Cell Size']],df_test['Type'])
print ('Testing accuracy (all training samples):',lr.score(df_test[['Clump Thickness','Uniformity of Cell Size']],df_test['Class']))
# intercept = lr.intercept_
intercept = lr.intercept_
coef = lr.coef_[0,:]
#原本这个分类面应该是 lx * coef[0] + ly * coef[1]+intercept = 0,映射到2维平面上之后，应该是
ly = (-intercept - lx * coef[0])/coef[1]
    

代码13-15数据下载源：

https://download.csdn.net/download/qq_46836833/72818472

代码13：“良恶性乳腺肿瘤数据预处理”

# 代码13：“良恶性乳腺肿瘤数据预处理”
# 导入pandas与numpy工具包
import pandas as pd
import numpy as np
# 创建特征列表
column_names = ['Sample code number','Clump Thickness','Uniformity of Cell Size','Uniformity of Cell Shape',
                'Marginal Adhesion','Single Epithelial Cell Size','Bare Nuclei','Bland Chromatin','Normal Nucleoli','Mitoses','Class']
#使用pandas.read_csv 读取数据
data = pd.read_csv('train.csv')
# 将？替换为标准缺失值表示
data = data.replace(to_replace='?',value = np.nan)
# 丢弃带有缺少值的数据（只要有一个维度缺失）
data = data.dropna(how = 'any')
#作用：删除缺失值，how='any'意为在给定的任何一列中有缺失值就删除
# 输出data的数据和维度
data.shape

代码14：“准备良恶性乳腺肿瘤训练、测试数据”

# 使用sklearn.model_selection里的train_test_split模块用于分割数据
from sklearn.model_selection import train_test_split
# 随机采样1/4的数据用于测试，剩下的3/4用于构建训练集合。
X_train,X_test,y_train,y_test = train_test_split(data[column_names[1:10]],data[column_names[10]],test_size = 0.25,random_state=33)
# 
# random_state设置相同的随机数种子，让拆分的数据集每次拆分的结果是相同的，每一次训练集和测试集都相同
# 查验训练样本的数量和类别分布
y_train.value_counts()
# 查验测试样本的数量和类别分布
y_test.value_counts()

代码15：线性模型和随机梯度下降(SGD)分类器

# 从sklearn.preprocessing里导入StandardScaler
from sklearn.preprocessing import StandardScaler
#从sklearn.linear model里导人LogisticRegression与SGDClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.linear_model import SGDClassifier
#标准化数据,保证每个维度的特征数据方差为1,均值为0。使得预测结果不会被某些维度过大的特征值而主导。
ss= StandardScaler ()
X_train=ss.fit_transform(X_train)
X_test=ss.transform(X_test)
#初始化LogisticRegression与SGDClassifier
lr= LogisticRegression()
sgdc= SGDClassifier ()
#调用LogisticRegression中的fit函数/模块用来训练模型参数。
lr.fit(X_train,y_train)
#使用训练好的模型1r对X_test进行预测,结果储存在变量1r_y_predict中
lr_y_predict=lr.predict(X_test)
# 调用SGDClassifier中的fit 函数/模块用来训练模型参数
sgdc.fit(X_train,y_train)
#使用训练好的模型sgdc对x_ test 进行预测，结果储存在变量sgdc_ y predict中。
sgdc_y_predict= sgdc.predict(X_test)

lr.score(X_test,y_test)

sgdc.score(X_test,y_test)

-------------------------------支持向量机-----------------------------------

代码17-20数据来源：

从sklearn.datasets里导入手写体数字

代码17：手写体数据读取代码样例

# 代码17：手写体数据读取代码样例
# 从sklearn.datasets里导入手写体数字
from sklearn.datasets import load_digits
# 从通过数据加载器获得手写体数字的数码图像数据并在digits变量中
digits=load_digits()
#检验数据规模和特征维度
digits.data.shape
digits.data[1]

代码18：手写体数据分割代码样例

# 代码18：手写体数据分割代码样例
# 从sklearn.model_selection里的train_test_split模块用于分割数据。
from sklearn.model_selection import train_test_split
# 随机数选取75%的数据作为训练样本，其余25%数据作为测试样本
X_train,X_test,y_train,y_test = train_test_split(digits.data,digits.target,test_size = 0.25,random_state=33)
#分别检验训练数据
y_train.shape

代码19：使用支持向量机（分类）对手写体数字图像进行识别

#代码19：使用支持向量机（分类）对手写体数字图像进行识别
# 从 sklearn.preprocessing 里导入数据标准化模块
from sklearn.preprocessing import StandardScaler
# 从 sklearn.svm 里导入基于线性假设的支持向量机分类器LinearSVC
from sklearn.svm import LinearSVC
# 从仍然需要对训练和测试的特征数据进行标准化
ss= StandardScaler ()
X_train=ss.fit_transform(X_train)
X_test=ss.transform(X_test)
# 初始化线性假设的支持向量机分类器
lsvc=LinearSVC(max_iter=10000)
# 进行模型训练
lsvc.fit(X_train,y_train)
#使用训练好的模型对测试样本的数字类别进行预测，预测结果储存在变量X_test进行预测,结果储存在变量y_predict中
y_predict=lsvc.predict(X_test)

代码20：支持向量机（分类）模型对手写体数码图像识别能力评估

# 代码20：支持向量机（分类）模型对手写体数码图像识别能力评估
# 使用模型自带的评估函数进行准确性评测
print ('The Accuracy of Linear SVC is',lsvc.score(X_test,y_test))
# 依然使用sklearn.metrics 里面的 classification_report模块对预测结果做更加详细的分析
from sklearn.metrics import classification_report
print (classification_report(y_test,y_predict,target_names=digits.target_names.astype(str)))

-------------------------------朴素贝叶斯-----------------------------------

代码20-24数据来源：

从sklearn.datasets里导入新闻数据抓取器

代码20：读取20类新闻文本的数据细节

# 代码20：读取20类新闻文本的数据细节
## 从sklearn.datasets里导入新闻数据抓取器fetch_20newsgroups
from sklearn.datasets import fetch_20newsgroups
# 与之前预存的数据不同，fetch_20newsgroups需要即使从互联网下载数据。
news=fetch_20newsgroups(subset='all')
print (len(news.data))
print (news.data[188])

代码22：20类新闻文本数据分割

# 代码22：20类新闻文本数据分割
# 从sklearn.model_selection里导入新闻数据抓取器ftrain_test_split
from sklearn.model_selection import train_test_split
#随机采样25%样本数据作为测试集
X_train,X_test,y_train,y_test = train_test_split(news.data,news.target,test_size = 0.25,random_state=23)

代码23：使用贝叶斯分类器对新闻文本数据进行类别预测

#代码23：使用贝叶斯分类器对新闻文本数据进行类别预测
#从sklearn.feature_extraction.text里导入用于文本特征向量化的模块
#分别使用CountVectorizer与TfidfVectorizer
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfVectorizer
#N-gram模型
#在朴素贝叶斯算法中，为了避免维度灾难，有一个大胆的假设，即X的n个维度之间相互独立:这个假设下，条件分布大大的简化了，但是这也可能带来预测的
#不准确性。n个维度相互独立，就是完全没有考虑上下文语境，把每个词拆开单独看，这么看的话，猫吃鱼、鱼吃猫得到的特征向量是完全一样的。
#N-gram模型就是假设
#与附近n个词是相关的，比如当n=(1,2)时，猫吃鱼提取到的特征就是[‘猫’,‘吃’,‘鱼’,‘猫吃’,‘吃鱼’]，为了平衡计算量和上下文关系，
#N一般取2或者3。朴素贝叶斯n个维度之间完全相互独立的假设，就是N-gram的n=1时的情况
#TF-IDF（term frequency–inverse document frequency），词频-逆文件频率。
#是一种用于资讯检索与资讯探勘的常用加权技术。TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。
#字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降
### 实例化vec
#vec_Count=CountVectorizer()
#vec_Count=CountVectorizer(analyzer='word', stop_words=stpwrdlst)
vec_Count=CountVectorizer(analyzer='word',stop_words='english',ngram_range=(1,3),lowercase=True,)
#vec_Count=CountVectorizer(analyzer='word', stop_words=None,max_df=0.5)
vec_Tfidf=TfidfVectorizer(analyzer='word',stop_words='english',ngram_range=(1,3),lowercase=True,)
X_train1=vec_Count.fit_transform(X_train)
X_train2=vec_Tfidf.fit_transform(X_train)
#导入朴素贝叶斯模型
from sklearn.naive_bayes import MultinomialNB
#利用训练数据对模型参数进行估计
mub1.fit(X_train1,y_train)
mub2.fit(X_train2,y_train)
#对测试样本进行类别预测，结果储存在变量y_predict中
Count_y_predict=mub1.predict(X_test1)
Tfidf_y_predict=mub2.predict(X_test2)

代码24 对朴素贝叶斯公式在新闻文本数据上的表现幸能进行评估

from sklearn.metrics import classification_report
print ('The accuracy of Naive Bayes Classifier is',mub1.score(X_test1,y_test)*100,'by CountVectorizer')
print ('The accuracy of Naive Bayes Classifier is',mub2.score(X_test2,y_test)*100,'by TfidfVectorizer')

-------------------------------K近邻-----------------------------------

代码25-24数据来源：

代码25：读取Iris数据集细节资料

# 代码25：读取Iris数据集细节资料
# 从sklearn.datasets导入iris数据加载器
from sklearn.datasets import load_iris
# 使用加载器读取数据并且存入变量iris
iris=load_iris()
# 查验数据规模
iris.data.shape
# 查看数据说明。对于一名机器学习的实践者来讲，这是一个好习惯。
print (iris.DESCR)

代码26 对Iris数据集进行分割

# 代码26 对Iris数据集进行分割
# 从sklearn.model_selection 里导入train_test_split 用于数据分割。
from sklearn.model_selection import train_test_split
# 从使用train_test_split，利用随机种子random_state 采样25%的数据作为测试集。
X_train,X_test,y_train,y_test = train_test_split(iris.data,iris.target,test_size = 0.25,random_state=33)

代码27 使用K近邻分类器对鸢尾花lris数据进行类别预测

# 代码27 使用K近邻分类器对鸢尾花lris数据进行类别预测
#从sklearn.preprocessing 里选择导入数据标准化模块。
from sklearn.preprocessing import StandardScaler
#从sklearn.neighbors 里选择导入KNeighborsClassifier ，即K邻近分类器
from sklearn.neighbors import KNeighborsClassifier
#对训练和测试的特征数据进行标准化
ss=StandardScaler()
X_train=ss.fit_transform(X_train)
X_test=ss.transform(X_test)
#使用K近邻分类器对测试进行类别预测，预测结果储存在变量y_predict中
knc=KNeighborsClassifier()
knc.fit(X_train,y_train)
y_predict=knc.predict(X_test)

代码28 对K近邻分类器在鸢尾花lris数据上的预测性能进行评估

# 代码28 对K近邻分类器在鸢尾花lris数据上的预测性能进行评估
print ('The accuracy of K-Nearest Classifier is',knc.score(X_test,y_test)*100,'by CountVectorizer')
from sklearn.metrics import classification_report
print (classification_report(y_test,y_predict,target_names=iris.target_names))

-------------------------------决策树-----------------------------------

数据来源：

https://download.csdn.net/download/qq_46836833/72829641

代码29 决策树数据导入

# 导入pandas用于数据分析
import pandas as pd
#利用pandas的read_csv模块直接对互联网上的数据收集的泰坦尼克号乘客数据进行导入
titanic=pd.read_excel("taitanic.xls")
#观察前几行数据
titanic.head()
#查看数据统计特性：使用pandas，数据都转入pandas独有的dataframe格式（二维数据表格），直接使用info（），查看数据统计特性
titanic.info()
#特征选择，sex，age，pclass这些特征很有可能是决定幸免与否的关键因素
X=titanic[['Pclass','Age','Sex']]
y=titanic['Survived']
#对当前选择的特征进行探查
X.info()

代码30 对泰坦尼克号数据补齐和划分

#代码30
#补全age里面的数据，使用平均数或者中位数都是对模型偏离造成最小影响的策略
#第一个参数是填充的数据的平均数，第二个是替换设置为真
X['Age'].fillna(X['Age'].mean(),inplace=True)
#重新检查
X.info()
#对以上数据输出的理解 每行都有1309个数据，无需补全 not-null非空 dtype是数据类型，sex是需要转化的数值特征，用0/1替代。
#划分数据
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.25,random_state=33)
#导入特征转化器
from sklearn.feature_extraction import DictVectorizer
vec=DictVectorizer(sparse=False)
X_train=vec.fit_transform(X_train.to_dict(orient='record'))
print (vec.feature_names_)
#print (X_train)
X_test=vec.transform(X_test.to_dict(orient='record'))

代码31 使用决策树对结果预测

#导入决策树
from sklearn.tree import DecisionTreeClassifier
dtc=DecisionTreeClassifier()
#使用分割到的训练数据进行模型学习
dtc.fit(X_train,y_train)
y_predict=dtc.predict(X_test)
#决策树模型对泰坦尼克号乘客是否生还的预测性能
from sklearn.metrics import classification_report
#输出预测的准确性
print(dtc.score(X_test,y_test))
#输出更加详细的分类性能
print(classification_report(y_test,y_predict,target_names=['died','survived']))

-------------------------------集成模型-----------------------------------

代码32，33 集成模型对泰坦尼克号的预测

# 导入pandas用于数据分析
import pandas as pd
#利用pandas的read_csv模块直接对互联网上的数据收集的泰坦尼克号乘客数据进行导入
titanic=pd.read_excel("taitanic.xls")
#观察前几行数据
titanic.head()
#人工选取，sex，age，pclass这些特征很有可能是决定幸免与否的关键因素
X=titanic[['Pclass','Age','Sex']]
y=titanic['Survived']
#对当前选择的特征进行探查
X.info()
#补全age里面的数据，使用平均数或者中位数都是对模型偏离造成最小影响的策略
#第一个参数是填充的数据的平均数，第二个是替换设置为真
X['Age'].fillna(X['Age'].mean(),inplace=True) 
#重新检查
X.info()
#划分数据
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.25,random_state=33)
#导入特征转化器
from sklearn.feature_extraction import DictVectorizer
vec=DictVectorizer(sparse=False)
X_train=vec.fit_transform(X_train.to_dict(orient='record'))
print (vec.feature_names_)
#print (X_train)
X_test=vec.transform(X_test.to_dict(orient='record'))
#使用单一决策树进行模型训练以及预测分析
from sklearn.tree import DecisionTreeClassifier
dtc=DecisionTreeClassifier()
#使用分割到的训练数据进行模型学习
dtc.fit(X_train,y_train)
dtc_y_predict=dtc.predict(X_test)
#使用随机森林分类器进行模型训练以及预测分析
from sklearn.ensemble import RandomForestClassifier
rfc=RandomForestClassifier()
#使用分割到的训练数据进行模型学习
rfc.fit(X_train,y_train)
rfc_y_predict=rfc.predict(X_test)
#使用梯度提升决策树进行模型训练以及预测分析
from sklearn.ensemble import GradientBoostingClassifier
gbc=GradientBoostingClassifier()
#使用分割到的训练数据进行模型学习
gbc.fit(X_train,y_train)
gbc_y_predict=gbc.predict(X_test)
#代码33 集成模型对泰坦尼克号乘客是否生还性能预测
#决策树模型对泰坦尼克号乘客是否生还的预测性能
from sklearn.metrics import classification_report
#输出预测的准确性
print(dtc.score(X_test,y_test))
#输出更加详细的分类性能
print(classification_report(y_test,dtc_y_predict,target_names=['died','survived']))
#决策树模型对泰坦尼克号乘客是否生还的预测性能
from sklearn.metrics import classification_report
#输出预测的准确性
print(rfc.score(X_test,y_test))
#输出更加详细的分类性能
print(classification_report(y_test,rfc_y_predict,target_names=['died','survived']))
from sklearn.metrics import classification_report
#输出预测的准确性
print(gbc.score(X_test,y_test))
#输出更加详细的分类性能
print(classification_report(y_test,gbc_y_predict,target_names=['died','survived']))

-------------------------------回归模型-----------------------------------

代码 34-35-36美国波士顿房价预测

# 从sklearn.datasets导入波士顿房价数据读取器
from sklearn.datasets import load_boston
# 从读取房价数据存储在变量boston中
boston = load_boston()
# 输出数据描述
print (boston.DESCR)
x = boston['data']  # 影响房价的特征信息
y = boston['target']  # 房价
name = boston['feature_names']
name
#从sklearn.model_selection中导入数据分割器
from sklearn.model_selection import train_test_split
import numpy as np

X = boston.data
y = boston.target

# 随机采样25%的数据构建测试样本，其余作为训练样本
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=33)

# 分析回归目标值的差异
print("The max target value is", np.max(boston.target))
print("The min target value is", np.min(boston.target))
print("The average target value is", np.mean(boston.target))

# 从sklearn.preprocessing导入数据标准化模块
from sklearn.preprocessing import StandardScaler

# 分别初始化对特征和目标值的标准化器
ss_X = StandardScaler()
ss_y = StandardScaler()

# 分别对训练和测试数据的特征以及目标值进行标准化处理
X_train = ss_X.fit_transform(X_train)
X_test = ss_X.transform(X_test)
y_train = ss_y.fit_transform(y_train.reshape(-1,1))
y_test = ss_y.transform(y_test.reshape(-1,1))

# 从sklearn.linear_model导入LinearRegression
from sklearn.linear_model import LinearRegression

# 使用默认配置初始化线性回归器LinearRegression
lr = LinearRegression()

# 使用训练数据进行参数估计
lr.fit(X_train, y_train)

# 对测试数据进行回归预测
lr_y_predict = lr.predict(X_test)

# 从sklearn.linear_model导入SGDRegressor
from sklearn.linear_model import SGDRegressor

# 使用默认配置初始化线性回归器SGDRegressor
sgdr = SGDRegressor()

# 使用训练数据进行参数估计
sgdr.fit(X_train, y_train)

# 对测试数据进行回归预测
sgdr_y_predict = sgdr.predict(X_test)

# 使用LinearRegression模型自带的评估模块，输出评估结果
print('The value of default measurement of LinearRegression is', lr.score(X_test, y_test))

# 从sklearn.metrics依次导入r2_score、mean_squared_error以及mean_absolute_error用于回归性能的评估
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error

# 使用r2_score模块,并输出评估结果
print('The value of R-squared of LinearRegression is', r2_score(y_test, lr_y_predict))

# 使用mean_squared_error模块,并输出评估结果
print('The mean squared error of LinearRegression is', mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict)))

# 使用mean_absolute_error模块,并输出评估结果
print('The mean absolute error of LinearRegression is', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict)))

# 使用SGDRegressor模型自带的评估模块，输出评估结果
print('The value of default measurement of SGDRegression is', sgdr.score(X_test, y_test))

# 从sklearn.metrics依次导入r2_score、mean_squared_error以及mean_absolute_error用于回归性能的评估
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error

# 使用r2_score模块,并输出评估结果
print('The value of R-squared of SGDRegressor is', r2_score(y_test, sgdr_y_predict))

# 使用mean_squared_error模块,并输出评估结果
print('The mean squared error of SGDRegressor is', mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(sgdr_y_predict)))

# 使用mean_absolute_error模块,并输出评估结果
print('The mean absolute error of SGDRegressor is', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(sgdr_y_predict)))

# 从sklearn.svm中导入支持向量机(回归)模型
from sklearn.svm import SVR

# 使用线性核函数配置的支持向量机进行回归训练,并且对测试样本进行预测
linear_svr = SVR(kernel='linear')
linear_svr.fit(X_train, y_train)
linear_svr_y_predict = linear_svr.predict(X_test)

# 使用多项式核函数配置的支持向量机进行回归训练,并且对测试样本进行预测
poly_svr = SVR(kernel='poly')
poly_svr.fit(X_train, y_train)
poly_svr_y_predict = poly_svr.predict(X_test)

# 使用径向量核函数配置的支持向量机进行回归训练,并且对测试样本进行预测
rbf_svr = SVR(kernel='rbf')
rbf_svr.fit(X_train, y_train)
rbf_svr_y_predict = rbf_svr.predict(X_test)

# 从sklearn.metrics依次导入R-squared、MSE以及MAE用于回归性能的评估
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error

# 输出评估结果
print('R-squared value of linear SVR is', linear_svr.score(X_test, y_test))

# 使用mean_squared_error模块,并输出评估结果
print('The mean squared error of linear SVR is', mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(linear_svr_y_predict)))

# 使用mean_absolute_error模块,并输出评估结果
print('The mean absolute error of linear SVR is', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(linear_svr_y_predict)))

# 输出评估结果
print('R-squared value of poly SVR is', poly_svr.score(X_test, y_test))

# 使用mean_squared_error模块,并输出评估结果
print('The mean squared error of poly SVR is', mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(poly_svr_y_predict)))

# 使用mean_absolute_error模块,并输出评估结果
print('The mean absolute error of poly SVR is', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(poly_svr_y_predict)))

# 输出评估结果
print('R-squared value of rbf SVR is', rbf_svr.score(X_test, y_test))

# 使用mean_squared_error模块,并输出评估结果
print('The mean squared error of rbf SVR is', mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(rbf_svr_y_predict)))

# 使用mean_absolute_error模块,并输出评估结果
print('The mean absolute error of rbf SVR is', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(rbf_svr_y_predict)))

# 从sklearn.neighbors导入KNeighborRegressor
from sklearn.neighbors import KNeighborsRegressor

# 初始化K近邻回归器,并且调整配置,使得预测的方式为平均回归:weight='uniform'
uni_knr = KNeighborsRegressor(weights='uniform')
uni_knr.fit(X_train, y_train)
uni_knr_y_predict = uni_knr.predict(X_test)

# 初始化K近邻回归器,并且调整配置,使得预测的方式为平均回归:weight='distance'
dis_knr = KNeighborsRegressor(weights='distance')
dis_knr.fit(X_train, y_train)
dis_knr_y_predict = dis_knr.predict(X_test)

# 使用R-squared.MSE以及MAE三种指标对平均回归配置的K近邻模型在测试集上进行性能评估
print('R-squared value of uniform-weighted KNeighborRegression:', uni_knr.score(X_test, y_test))
print('The mean squared error of uniform-weighted KNeighborRegression:', mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(uni_knr_y_predict)))
print('The mean absoluate error of uniform-weighted KNeighborRegression:', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(uni_knr_y_predict)))

# 使用R-squared、MSE以及MAE三种指标对根据距离加权回归配置的K近邻模型在测试集上进行性能评估
print('R-squared value of distance-weighted KNeighborRegression:', dis_knr.score(X_test, y_test))
print('The mean squared error of distance-weighted KNeighborRegression:', mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(dis_knr_y_predict)))
print('The mean absoluate error of distance-weighted KNeighborRegression:', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(dis_knr_y_predict)))

# 从sklearn.tree中导入DecisionTreeRegressor
from sklearn.tree import DecisionTreeRegressor

# 使用默认配置初始化DecisionTreeRegressor
dtr = DecisionTreeRegressor()

# 用波士顿房价的训练数据构建回归树
dtr.fit(X_train, y_train)

# 使用默认配置的单一回归树对测试数据进行预测,并将预测值存储在变量dtr_y_predict中
dtr_y_predict = dtr.predict(X_test)

# 使用R-squared、MSE以及MAE指标对默认配置的回归树在测试集上进行性能评估
print('R-squared value of DecisionTreeRegressor:', dtr.score(X_test, y_test))
print('The mean squared error of DecisionTreeRegressor:', mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(dtr_y_predict)))
print('The mean absolute error of DecisionTreeRegressor:', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(dtr_y_predict)))

# 从sklearn.ensemble中导入RandomForestRegressor、ExtraTreesGressor以及GradientBoostingRegressor
from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor, GradientBoostingRegressor
# 使用RandomForestRegressor训练模型,并对测试数据做出预测,结果存储在变量rfr_y_predict中
rfr = RandomForestRegressor()
rfr.fit(X_train, y_train)
rfr_y_predict = rfr.predict(X_test)

# 使用ExtraTreesRegressor训练模型,并对测试数据做出预测,结果存储在变量etr_y_predict中
etr = ExtraTreesRegressor()
etr.fit(X_train, y_train)
etr_y_predict = etr.predict(X_test)

# 使用GradientBoostingRegressor训练模型,并对测试数据做出预测,结果存储在变量gbr_y_predict中
gbr = GradientBoostingRegressor()
gbr.fit(X_train, y_train)
gbr_y_predict = gbr.predict(X_test)

# 使用R-squared.MSE以及MAE指标对默认配置的随即回归森林在测试集上进行性能评估
print('R-squared value of RandomForestRegressor:', rfr.score(X_test, y_test))
print('The mean squared error of RandomForestRegressor:', mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(rfr_y_predict)))
print('The mean absoluate error of RandomForestRegressor:', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(rfr_y_predict)))

# 使用R-squared.MSE以及MAE指标对默认配置的极端回归森林在测试集上进行性能评估
print('R-squared value of ExtraTreesRegressor:', etr.score(X_test, y_test))
print('The mean squared error of ExtraTreesRegressor:', mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(etr_y_predict)))
print('The mean absoluate error of ExtraTreesRegressor:', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(etr_y_predict)))

# 使用训练好的极端回归森林模型,输出每种特征对预测目标的贡献度
print(np.sort(list(zip(etr.feature_importances_, boston.feature_names)), axis=0))

# 使用R-squared.MSE以及MAE指标对默认配置的梯度上升回归森林在测试集上进行性能评估
print('R-squared value of GrandientBoostingRegressor:', gbr.score(X_test, y_test))
print('The mean squared error of GrandientBoostingRegressor:', mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(gbr_y_predict)))
print('The mean absoluate error of GrandientBoostingRegressor:', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(gbr_y_predict)))

-------------------------------轮廓系数 K-means算法-----------------------------------

代码 46 48 49 50 轮廓系数 K-means算法

# coding: utf-8
# 分别导入numpy、matplotlib以及pandas，用于数学运算、作图以及数据分析。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
 
# 使用pandas分别读取训练数据与测试数据集。
digits_train = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/optdigits/optdigits.tra', header=None)
digits_test = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/optdigits/optdigits.tes', header=None) 
# 从训练与测试数据集上都分离出64维度的像素特征与1维度的数字目标。
X_train = digits_train[np.arange(64)]#64个属性值
y_train = digits_train[64]#一个结果值
 
X_test = digits_test[np.arange(64)]
y_test = digits_test[64]

# 从sklearn.cluster中导入KMeans模型。
from sklearn.cluster import KMeans
 
# 初始化KMeans模型，并设置聚类中心数量为10。
kmeans = KMeans(n_clusters=10)
kmeans.fit(X_train)
 
# 逐条判断每个测试图像所属的聚类中心。
y_pred = kmeans.predict(X_test)

# 从sklearn导入度量函数库metrics。
from sklearn import metrics
# 使用ARI进行KMeans聚类性能评估。
print (metrics.adjusted_rand_score(y_test, y_pred))

# 导入numpy。
import numpy as np
# 从sklearn.cluster中导入KMeans算法包。
from sklearn.cluster import KMeans
# 从sklearn.metrics导入silhouette_score用于计算轮廓系数。
from sklearn.metrics import silhouette_score
import matplotlib.pyplot as plt

# 分割出3*2=6个子图，并在1号子图作图。
plt.subplot(3,2,1)#这里的意思是这六个子图是呈3行2列排序的。

# 初始化原始数据点。
x1 = np.array([1, 2, 3, 1, 5, 6, 5, 5, 6, 7, 8, 9, 7, 9])
x2 = np.array([1, 3, 2, 2, 8, 6, 7, 6, 7, 1, 2, 1, 1, 3])
X = np.array(list(zip(x1, x2))).reshape(len(x1), 2)#zip(x1, x2)的意思就是拼接起来变成一个坐标。
#X就是点的坐标的集合
#reshape的作用就是让列表的元素也是列表，如果没有reshape这个函数，那么列表的元素是元组
#所以reshape对输出功能没有影响，只是让输出的形式发生了改变。

# 在1号子图做出原始数据点阵的分布。
plt.xlim([0, 10])
plt.ylim([0, 10])
plt.title('Instances')
plt.scatter(x1, x2)
 
colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'b']
markers = ['o', 's', 'D', 'v', '^', 'p', '*', '+']

clusters = [2, 3, 4, 5, 8]#这里就是分成几类的意思
subplot_counter = 1
sc_scores = []
for t in clusters:#t表示上面list中的某个参数的具体值
    print('t=',t)
    subplot_counter += 1
    print('subplot_counter=',subplot_counter)#参数subplot_counter之所以从2开始计数，是因为前面已经画过一个图了
    plt.subplot(3, 2, subplot_counter)#subplot表示画在同一张图中的子图
    kmeans_model = KMeans(n_clusters=t).fit(X)#表示将数据集X，分成t类
    for i, l in enumerate(kmeans_model.labels_):#i和l都是标记，一个用来指代坐标值，一个用来指代颜色和标记。
        plt.plot(x1[i], x2[i], color=colors[l], marker=markers[l], ls='None')#i用来选定坐标，color表示画marker时填充的颜色，marker表示画图时用的图形标记
    plt.xlim([0, 10])
    plt.ylim([0, 10])
    sc_score = silhouette_score(X, kmeans_model.labels_, metric='euclidean')#这个讲的是轮廓系数
    sc_scores.append(sc_score)#sc_scores是前面定义的

# 绘制轮廓系数与不同类簇数量的直观显示图。
plt.title('K = %s, silhouette coefficient= %0.03f' %(t, sc_score))#句子中两个%分别对应后面得t和sc_score

# 绘制轮廓系数与不同类簇数量的关系曲线。对应书本P88图2-12中的曲线
plt.figure()
plt.plot(clusters, sc_scores, '*-')
plt.xlabel('Number of Clusters')
plt.ylabel('Silhouette Coefficient Score')
 
plt.show()

# 导入必要的工具包。
import numpy as np
from sklearn.cluster import KMeans
from scipy.spatial.distance import cdist
import matplotlib.pyplot as plt

# 使用均匀分布函数随机三个簇，每个簇周围10个数据样本。
cluster1 = np.random.uniform(0.5, 1.5, (2, 10))#random.uniform(x, y)表示随机范围在x和y之间
cluster2 = np.random.uniform(5.5, 6.5, (2, 10))
cluster3 = np.random.uniform(3.0, 4.0, (2, 10))

# 绘制30个数据样本的分布图像。
X = np.hstack((cluster1, cluster2, cluster3)).T#hstack用来串行连接3个数组
print('X=',X)
plt.scatter(X[:,0], X[:, 1])
print('X[:,0]=',X[:,0])#取得X中的第一列数据
print('X[:,1]=',X[:,1])#取得X中的第二列数据
plt.xlabel('x1')
plt.ylabel('x2')
plt.show()

# 测试9种不同聚类中心数量下，每种情况的聚类质量，并作图。
#下面代码就是为了绘制图2-15的
K = range(1, 10)
print("------------------------------")
print("K=",K)
meandistortions = []

for k in K:#K是个范围
    kmeans = KMeans(n_clusters=k)#这里的意思是分成k类
    kmeans.fit(X)
    meandistortions.append(sum(np.min(cdist(X, kmeans.cluster_centers_, 'euclidean'), axis=1))/X.shape[0])
    #cdist来自scipy，用来计算距离，这里特别代指欧氏距离
plt.plot(K, meandistortions, 'bx-')
plt.xlabel('k')
plt.ylabel('Average Dispersion')
plt.title('Selecting k with the Elbow Method')
plt.show()