机器学习基础-有监督模型(分类、回归)、无监督模型(聚合、降维)

基本知识

1.1.1 机器学习的任务

机器学习的任务种类较多,但是常规来讲可以以监督学习(Supervised Learning)和无监督学习(Unsupervised Learning)。其中监督学习关注对事物未知表现的预测,一般包括分类问题(classification)、回归问题(Regression)。无监督学习则倾向于对事物本身特性的分析,常用的技术包括数据降维(Dimensionality Reduction)和聚类问题(Clustering)。

分类问题,便是对其所在类别进行预测,类别是离散的,同时也是预先知道数量的。例如根据一个人的身高、体重和三维判定性别,性别是离散的,男和女,同时预先知道其数量。或者说更经典的例子,根据鸢尾花的花瓣、花萼的长宽等数据,判断其所属的鸢尾花亚种,因为鸢尾花的亚种的种类和数量也满足离散和预先知道这两项特征,因此也是分类预测问题。

回归同样是预测问题,只是预测的目标往往是连续的变量,比如根据房屋的面积、地理位置、建筑年代等对房屋销售价格进行预测,销售价格一定是一个连续的变量。

数据降维度是对事物的特征进行压缩和筛选。如果没有特定领域的知识,无法预先确定采样哪些数据,而现如今采样数据成本较低,但是筛选的成本比较高,比如在图像识别中,如今像素分辨率极大,因而若直接使用这些像素信息那么数据维度非常高,所以很难对数据进行处理。因此这样的数据通常需要进行降维,保存其最有区分度的像素组合,从此便能不影响效果,但是数据维度降低,降低运算难度,也更容易理解。

聚类则是依赖于数据的相似性,把相似的数据样本划分为一个簇,不同于分类问题,我们在大多数情况下不会预先知道簇的数量和每个簇的具体含义。例如购物网站对用户信息和购买习惯进行聚类分析,这样就可以进行分类的广告投放。

1.1.2 机器学习中应用的经验

习惯性的认为数据就是经验,只有那些对学习任务有用的特定信息才会被列入考虑范围,通常把这些反映数据内在规律的信息叫做特征(Feature)。譬如经典的人脸识别,很少直接用原始图像来进行经验来学习,而是先进行建委,把复杂的数据处理成有助于人脸识别的轮廓特征。

对于监督学习问题,所需要的经验一般包括特征,以及标记/目标(Label/Target)这样才能知道结果是什么,标记/目标的表现形式则取决于监督学习的种类。

无监督学习并不用于做结果预测,那么自然就不需要标记/目标,但是却更加适合对于数据结构的分析。正式因为这个区别可以尝尝获得大量无监督数据,而监督数据的标注因为经常耗费大量的时间、金钱和人力,所以数据量相对较少。

更重要的是,标记/目标的表现形式存在离散、连续变量的区别,从原始数据到特征数据的转换过程中也会遭遇到多种数据类型:类别型特征、数值型特征、甚至是缺失的数据。而学习的过程中需要将这些特征转换为具体的数据参与计算,所以通常要经过缺失数据补全、部分数据过滤、和数据标准化等预先对数据进行处理。

而通常所说的训练集就是既有特征,同时带有目标/标记的数据集。

1.1.3 机器学习的性能、精度表现形式

所谓的性能,便是评价完成任务的质量指标。通常为了评价其完成的质量,我们需要具有相同特征的数据,并将模型的预测结果与相对应的正确结果进行对比。这样的数据成为测试集。(测试集的数据一定不能出现在训练集中,也就是说他们说相互排斥的。)

预测精度问题:

- 对于分类问题来讲,需要根据预测正确类别的百分比来评判其性能,这个指标也通常成为准确性(Accuracy).
- 对于回归问题需要衡量预测值与实际值之间的偏差大小。
- 而通常这两种预测指标的表现形式有些不足。对于分类问题一般还有召回率(Recall)、精确率(Percision)以及F1指标。
- 对于回归问题一般又有三种关于回归的特有的评价机制如R-squared。【p69】
- 对于聚类问题,如果评估的数据有具体的所属类别,一般采用ARI(Adjust Rand Index)指标,他与分类问题的准确性(Accuracy)类似,但是它也兼顾的考虑到了类簇无法和分类标记意义对应的问题。如果没有具体的所属类别,那么一般使用轮廓系数(Slihouette Coefficient)来度量聚类的结果质量。取值范围【-1,1】数值越大表明效果越好。【P85】
- 对于数据降维如PCA,一般用处理过的数据与未降维的数据来进行对比即可。对比参数可根据数据所属类别来选择。

监督学习:

机器学习的监督学习模型的任务重点在于,根据已有经验的知识对未知样本的目标/标记进行预测,根据目标预测变量的类别不同,把监督学习任务大体分为分类学习与回归预测两类。

流程即如上体所示,首先需要准备训练数据,可以是文本、图像、音频等,然后抽取所需要的特征,形成特征向量(Feature Vectors),接着把这些特征向量连同对应的标记/目标(即结果)一同送入学习算法(Machine Learning Algorithm)中,训练出一个预测模型(Predictive Model),然后采用同样的特征抽取方法作用于新的测试数据,得到用于测试的特征向量,最后使用预测模型对这些待测试的特征向量进行预测并得到结果(Expected Label).

2.1.1分类学习(Classifier)

分类学习是最为常见的监督学习问题,最为基础的是二分类问题,即是判断是非,从两个类别中选择一个作为预测结果,除此之外还有多类分类即是在多余两个类别中选择一个作为预测结果,甚至还有多标签多分类问题,多标签多分类问题判断一个样本是否同时属于多个不同的类别。

比如实际生活中,遇到许多分类问题,如医生对肿瘤性质进行判定,邮件系统对手写数字进行识别,互联网公司对新闻进行分类,生物学家对物种类型进行鉴定。

2.1.1.1 线性分类器(Linear Classifier)

模型介绍:线性分类器(Linear Classifiers),是一种假设特征与分类结果存在线性关系的模型,这个模型通过累加计算每个维度的特征与各自的权重的乘积来帮助决策。常用的有LogisticRegression与SGDClassifiler。

数据描述:采用UCI的良/恶性乳腺癌肿瘤预测,分别是逻辑斯蒂回归分类,与随机梯度下降分类。

性能分析:准确率(Accuracy)、召回率(Recall)、精确率(Percision)以及F1指标。

特点分析:线性分类器可以说是最为基本和常用的机器学习模型,尽管受限于数据特征与分类目标之间的线性假设,仍然可以在科学研究和工程实践中吧线性分类器作为基准,所使用的模型包括LogisticRegression与SGDClassifiler,相比较,前者对参数的计算采用精确的解析方式,计算时间长但是模型性略高,后者采取随机梯度下降算法估计模型参数,计算时间段,但是模型性能略低。一般而言顺联的数据规模如果超过10W条,考虑到时间的耗用等因素,运用随机梯度算法对模型参数进行估计。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
# 导入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('https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data', names = column_names )
# 将?替换为标准缺失值表示。
data = data.replace(to_replace='?', value=np.nan)
# 丢弃带有缺失值的数据(只要有一个维度有缺失)。
data = data.dropna(how='any')
# 输出data的数据量和维度。
data.shape
(683, 11)
# 使用sklearn.cross_valiation里的train_test_split模块用于分割数据。
from sklearn.cross_validation import train_test_split
# 随机采样25%的数据用于测试,剩下的75%用于构建训练集合。
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)
# 查验训练样本的数量和类别分布。
y_train.value_counts()
2 344
4 168
Name: Class, dtype: int64
# 查验测试样本的数量和类别分布。
y_test.value_counts()
Out[4]:
2 100
4 71
Name: Class, dtype: int64
# 从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)
# 使用训练好的模型lr对X_test进行预测,结果储存在变量lr_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)
# 从sklearn.metrics里导入classification_report模块。
from sklearn.metrics import classification_report
# 使用逻辑斯蒂回归模型自带的评分函数score获得模型在测试集上的准确性结果。
print 'Accuracy of LR Classifier:', lr.score(X_test, y_test)
# 利用classification_report模块获得LogisticRegression其他三个指标的结果。
print classification_report(y_test, lr_y_predict, target_names=['Benign', 'Malignant'])
Accuracy of LR Classifier: 0.988304093567
precision recall f1-score support
Benign 0.99 0.99 0.99 100
Malignant 0.99 0.99 0.99 71
avg / total 0.99 0.99 0.99 171
# 使用随机梯度下降模型自带的评分函数score获得模型在测试集上的准确性结果。
print 'Accuarcy of SGD Classifier:', sgdc.score(X_test, y_test)
# 利用classification_report模块获得SGDClassifier其他三个指标的结果。
print classification_report(y_test, sgdc_y_predict, target_names=['Benign', 'Malignant'])
Accuarcy of SGD Classifier: 0.953216374269
precision recall f1-score support
Benign 0.93 0.99 0.96 100
Malignant 0.98 0.90 0.94 71
avg / total 0.95 0.95 0.95 171
```
#### 2.1.1.2 支持向量机(Support Vector Classifier)
![](http://ocef6bnjz.bkt.clouddn.com/17-6-11/50533102.jpg)
模型介绍: 例如线性分类可能获得多个线性分类线,但是我们更希望选取更好的那一条,即如上图的H3线,可以对更多的数据点有更好的容忍度。所以支持向量机分类器便是根据训练样本的分布,搜索所有可能的线性分类器中最佳的那个。
而其中可以用来真正帮助决策最优线性分类器模型的数据点叫做“支持向量”,如上图中的虚线连接的两个点。
数据描述:
使用支持向量机分类器处理框架Scikit-learn内部集成的手写数字图片集。
性能分析:准确率(Accuracy)、召回率(Recall)、精确率(Percision)以及F1指标。需要进一步指出的是以上三个参数最先适用于二分类任务,但是在拥有多个类别的项目中(如此例数据的识别有0-910个数字),因此无法直接计算上述三个指标,通常的做法是注意评估每个类别的三个指标,也就相当于10个二分类任务。而此学习库也的确是这样的做的。
特点分析:支持向量机模型在机器学习领域繁荣了一段时间,主要原因在于其精妙的模型假设,可以帮助我们在海量甚至更高维度的数据中筛选出对预测任务最为有效的少数训练样本。这样不仅节省了模型学习所需要的数据内存,同时也提高了模型的预测性能。然后要获得此性能,就必须付出更多的计算代价(CPU资源和计算时间)。
```python
# 从sklearn.datasets里导入手写体数字加载器。
from sklearn.datasets import load_digits
# 从通过数据加载器获得手写体数字的数码图像数据并储存在digits变量中。
digits = load_digits()
# 检视数据规模和特征维度。
digits.data.shape
(1797, 64
# 从sklearn.cross_validation中导入train_test_split用于数据分割。
from sklearn.cross_validation 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
(1347,)
y_test.shape
(450,)
# 从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)
# 初始化线性假设的支持向量机分类器LinearSVC。
lsvc = LinearSVC()
#进行模型训练
lsvc.fit(X_train, y_train)
# 利用训练好的模型对测试样本的数字类别进行预测,预测结果储存在变量y_predict中。
y_predict = lsvc.predict(X_test)
# 使用模型自带的评估函数进行准确性测评。
print 'The Accuracy of Linear SVC is', lsvc.score(X_test, y_test)
The Accuracy of Linear SVC is 0.953333333333
# 依然使用sklearn.metrics里面的classification_report模块对预测结果做更加详细的分析。
from sklearn.metrics import classification_report
print classification_report(y_test, y_predict, target_names=digits.target_names.astype(str))
precision recall f1-score support
0 0.92 1.00 0.96 35
1 0.96 0.98 0.97 54
2 0.98 1.00 0.99 44
3 0.93 0.93 0.93 46
4 0.97 1.00 0.99 35
5 0.94 0.94 0.94 48
6 0.96 0.98 0.97 51
7 0.92 1.00 0.96 35
8 0.98 0.84 0.91 58
9 0.95 0.91 0.93 44
avg / total 0.95 0.95 0.95 450

2.1.1.3 朴素贝叶斯(Native Bayes)

模型介绍:
朴素贝叶斯是一个非常简单,但是实用性很强的分类模型,不过和基于线性假设的(线性分类器、支持向量机)不同,朴素贝叶斯分类器的构造基础是贝叶斯理论。

数据描述:
朴素贝叶斯模型有着广泛的应用环境,特别是在文本分类的任务中间,包括互联网新闻的分类、垃圾邮件的筛选等。本次实例就采取新闻文本作为实验数据。
性能分析:
准确率(Accuracy)、召回率(Recall)、精确率(Percision)以及F1指标。通过这个测度对朴素贝叶斯模型在20类新闻文本分类任务上的性能进行评估。
特点分析:
朴素贝叶斯模型被广泛的运用于海量互联网文本分类任务。由于其较强的特征条件独立假设,使得模型预测所需估计的参数规模从幂指数向线性量级别减少,极大的节约了内存消耗和计算时间。但是也正因为这种强假设的限制,模型训练无法将各个特征之间的联系考量在内,使得该模型在其他数据特征关联性较强的分类任务上的性能表现不佳。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
# 从sklearn.datasets里导入新闻数据抓取器fetch_20newsgroups。
from sklearn.datasets import fetch_20newsgroups
# 与之前预存的数据不同,fetch_20newsgroups需要即时从互联网下载数据。
news = fetch_20newsgroups(subset='all')
# 查验数据规模和细节。
print len(news.data)
print news.data[0]
WARNING:sklearn.datasets.twenty_newsgroups:Downloading dataset from http://people.csail.mit.edu/jrennie/20Newsgroups/20news-bydate.tar.gz (14 MB)
18846
From: Mamatha Devineni Ratnam <mr47+@andrew.cmu.edu>
Subject: Pens fans reactions
Organization: Post Office, Carnegie Mellon, Pittsburgh, PA
Lines: 12
NNTP-Posting-Host: po4.andrew.cmu.edu
I am sure some bashers of Pens fans are pretty confused about the lack
of any kind of posts about the recent Pens massacre of the Devils. Actually,
I am bit puzzled too and a bit relieved. However, I am going to put an end
to non-PIttsburghers' relief with a bit of praise for the Pens. Man, they
are killing those Devils worse than I thought. Jagr just showed you why
he is much better than his regular season stats. He is also a lot
fo fun to watch in the playoffs. Bowman should let JAgr have a lot of
fun in the next couple of games since the Pens are going to beat the pulp out of Jersey anyway. I was very disappointed not to see the Islanders lose the final
regular season game. PENS RULE!!!
# 从sklearn.cross_validation 导入 train_test_split。
from sklearn.cross_validation 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=33)
# 从sklearn.feature_extraction.text里导入用于文本特征向量转化模块。详细介绍请读者参考3.1.1.1 特征抽取一节。
from sklearn.feature_extraction.text import CountVectorizer
vec = CountVectorizer()
X_train = vec.fit_transform(X_train)
X_test = vec.transform(X_test)
# 从sklearn.naive_bayes里导入朴素贝叶斯模型。
from sklearn.naive_bayes import MultinomialNB
# 从使用默认配置初始化朴素贝叶斯模型。
mnb = MultinomialNB()
# 利用训练数据对模型参数进行估计。
mnb.fit(X_train, y_train)
# 对测试样本进行类别预测,结果存储在变量y_predict中。
y_predict = mnb.predict(X_test)
# 从sklearn.metrics里导入classification_report用于详细的分类性能报告。
from sklearn.metrics import classification_report
print 'The accuracy of Naive Bayes Classifier is', mnb.score(X_test, y_test)
print classification_report(y_test, y_predict, target_names = news.target_names)
The accuracy of Naive Bayes Classifier is 0.839770797963
precision recall f1-score support
alt.atheism 0.86 0.86 0.86 201
comp.graphics 0.59 0.86 0.70 250
comp.os.ms-windows.misc 0.89 0.10 0.17 248
comp.sys.ibm.pc.hardware 0.60 0.88 0.72 240
comp.sys.mac.hardware 0.93 0.78 0.85 242
comp.windows.x 0.82 0.84 0.83 263
misc.forsale 0.91 0.70 0.79 257
rec.autos 0.89 0.89 0.89 238
rec.motorcycles 0.98 0.92 0.95 276
rec.sport.baseball 0.98 0.91 0.95 251
rec.sport.hockey 0.93 0.99 0.96 233
sci.crypt 0.86 0.98 0.91 238
sci.electronics 0.85 0.88 0.86 249
sci.med 0.92 0.94 0.93 245
sci.space 0.89 0.96 0.92 221
soc.religion.christian 0.78 0.96 0.86 232
talk.politics.guns 0.88 0.96 0.92 251
talk.politics.mideast 0.90 0.98 0.94 231
talk.politics.misc 0.79 0.89 0.84 188
talk.religion.misc 0.93 0.44 0.60 158
avg / total 0.86 0.84 0.82 4712

2.1.1.4 K近邻(K-Nearest Neighbor)

模型介绍:

假设有一些携带分类标记的训练样本,分布于特征空间中。(有三类颜色蓝绿红,但图黑白将就看吧),不同颜色代表各自的类别,对于一个待分类的样本,选取待分类样本在特征空间中距离最近的K个已标记样本作为参考,来帮助做出分类决策。因此可以得知K值不同得到的分类器可能不同。
数据描述:
使用K临近算法对生物物种进行分类,并且使用最为著名的鸢尾数据集。
性能分析:
准确率(Accuracy)、召回率(Recall)、精确率(Percision)以及F1指标。通过这个测度对朴素贝叶斯模型在20类新闻文本分类任务上的性能进行评估。
特点分析:
K临近分类是非常直观的机器学习模型,K临近算法与其他模型的最大不同在于该模型没有参数训练过程。也就是说没有通过任何学习算法分析训练数据,而只是根据测试样本在训练数据的分布直接作出决策。所以K临近算法属于无参数模型中非常简单的一种。但是这样的决策算法导致了非常高的计算复杂度和内存消耗。因为该模型每处理一个测试样本都需要对所有预先加载在内存的训练样本进行遍历、逐一计算相似度、排序并且选取K个最近邻训练样本的标记,进而做出决策。这是平方级别的算法复杂度,一旦数据量较大,时间消耗会很大。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
# 从sklearn.datasets 导入 iris数据加载器。
from sklearn.datasets import load_iris
# 使用加载器读取数据并且存入变量iris。
iris = load_iris()
# 查验数据规模。
iris.data.shape
(150L, 4L)
# 查看数据说明。对于一名机器学习的实践者来讲,这是一个好习惯。
print iris.DESCR
Iris Plants Database
Notes
-----
Data Set Characteristics:
:Number of Instances: 150 (50 in each of three classes)
:Number of Attributes: 4 numeric, predictive attributes and the class
:Attribute Information:
- sepal length in cm
- sepal width in cm
- petal length in cm
- petal width in cm
- class:
- Iris-Setosa
- Iris-Versicolour
- Iris-Virginica
:Summary Statistics:
============== ==== ==== ======= ===== ====================
Min Max Mean SD Class Correlation
============== ==== ==== ======= ===== ====================
sepal length: 4.3 7.9 5.84 0.83 0.7826
sepal width: 2.0 4.4 3.05 0.43 -0.4194
petal length: 1.0 6.9 3.76 1.76 0.9490 (high!)
petal width: 0.1 2.5 1.20 0.76 0.9565 (high!)
============== ==== ==== ======= ===== ====================
:Missing Attribute Values: None
:Class Distribution: 33.3% for each of 3 classes.
:Creator: R.A. Fisher
:Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)
:Date: July, 1988
This is a copy of UCI ML iris datasets.
http://archive.ics.uci.edu/ml/datasets/Iris
The famous Iris database, first used by Sir R.A Fisher
This is perhaps the best known database to be found in the
pattern recognition literature. Fisher's paper is a classic in the field and
is referenced frequently to this day. (See Duda & Hart, for example.) The
data set contains 3 classes of 50 instances each, where each class refers to a
type of iris plant. One class is linearly separable from the other 2; the
latter are NOT linearly separable from each other.
References
----------
- Fisher,R.A. "The use of multiple measurements in taxonomic problems"
Annual Eugenics, 7, Part II, 179-188 (1936); also in "Contributions to
Mathematical Statistics" (John Wiley, NY, 1950).
- Duda,R.O., & Hart,P.E. (1973) Pattern Classification and Scene Analysis.
(Q327.D83) John Wiley & Sons. ISBN 0-471-22361-1. See page 218.
- Dasarathy, B.V. (1980) "Nosing Around the Neighborhood: A New System
Structure and Classification Rule for Recognition in Partially Exposed
Environments". IEEE Transactions on Pattern Analysis and Machine
Intelligence, Vol. PAMI-2, No. 1, 67-71.
- Gates, G.W. (1972) "The Reduced Nearest Neighbor Rule". IEEE Transactions
on Information Theory, May 1972, 431-433.
- See also: 1988 MLC Proceedings, 54-64. Cheeseman et al"s AUTOCLASS II
conceptual clustering system finds 3 classes in the data.
- Many, many more ...
# 从sklearn.cross_validation里选择导入train_test_split用于数据分割。
from sklearn.cross_validation 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)
# 从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)
# 使用模型自带的评估函数进行准确性测评。
print 'The accuracy of K-Nearest Neighbor Classifier is', knc.score(X_test, y_test)
The accuracy of K-Nearest Neighbor Classifier is 0.894736842105
# 依然使用sklearn.metrics里面的classification_report模块对预测结果做更加详细的分析。
from sklearn.metrics import classification_report
print classification_report(y_test, y_predict, target_names=iris.target_names)
precision recall f1-score support
setosa 1.00 1.00 1.00 8
versicolor 0.73 1.00 0.85 11
virginica 1.00 0.79 0.88 19
avg / total 0.92 0.89 0.90 38

2.1.1.5 决策树(Decision Tree)


模型介绍:
无论是logistic回归还是支持向量机模型,都在某种程度上要求被学习的数据特征和目标之间遵循着线性假设。但实际中很多情况这是不可能的。如一个人的年龄与患流感而死亡之间不存在线程关系,如果非要描述这种非线性关系,那么使用分段函数最为合理。而在机器学习中,决策树就是描述这种非线性关系的不二之选。
多层决策树的时候,模型在学习的时候就需要考虑特征节点的选取顺序,常用的度量方式包括信息熵(information Gain)和基尼不纯性(Gini Impurity)。
数据描述:
泰坦尼克号数据,预测事故中人生存的可能性。
性能分析:
准确率(Accuracy)、召回率(Recall)、精确率(Percision)以及F1指标。
特点分析:
相比于其他模型,决策树在模型描述上有巨大的优势,决策树的推断逻辑非常直观,具有清晰的可解释性,也方便了模型的可视化。这些特性同时保证了在使用决策树模型时,是无需考虑对数据量化甚至标准化的,并且仍然属于有参数模型,需要花费更多的时间在训练上。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
# 导入pandas用于数据分析。
import pandas as pd
# 利用pandas的read_csv模块直接从互联网收集泰坦尼克号乘客数据。
titanic = pd.read_csv('http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt')
# 观察一下前几行数据,可以发现,数据种类各异,数值型、类别型,甚至还有缺失数据。
titanic.head()
row.names pclass survived name age embarked home.dest room ticket boat sex
0 1 1st 1 Allen, Miss Elisabeth Walton 29.0000 Southampton St Louis, MO B-5 24160 L221 2 female
1 2 1st 0 Allison, Miss Helen Loraine 2.0000 Southampton Montreal, PQ / Chesterville, ON C26 NaN NaN female
2 3 1st 0 Allison, Mr Hudson Joshua Creighton 30.0000 Southampton Montreal, PQ / Chesterville, ON C26 NaN (135) male
3 4 1st 0 Allison, Mrs Hudson J.C. (Bessie Waldo Daniels) 25.0000 Southampton Montreal, PQ / Chesterville, ON C26 NaN NaN female
4 5 1st 1 Allison, Master Hudson Trevor 0.9167 Southampton Montreal, PQ / Chesterville, ON C22 NaN 11 male
# 使用pandas,数据都转入pandas独有的dataframe格式(二维数据表格),直接使用info(),查看数据的统计特性。
titanic.info()
<class 'pandas.core.frame.DataFrame'>
Int64Index: 1313 entries, 0 to 1312
Data columns (total 11 columns):
row.names 1313 non-null int64
pclass 1313 non-null object
survived 1313 non-null int64
name 1313 non-null object
age 633 non-null float64
embarked 821 non-null object
home.dest 754 non-null object
room 77 non-null object
ticket 69 non-null object
boat 347 non-null object
sex 1313 non-null object
dtypes: float64(1), int64(2), object(8)
memory usage: 123.1+ KB
# 机器学习有一个不太被初学者重视,并且耗时,但是十分重要的一环,特征的选择,这个需要基于一些背景知识。根据我们对这场事故的了解,sex, age, pclass这些都很有可能是决定幸免与否的关键因素。
X = titanic[['pclass', 'age', 'sex']]
y = titanic['survived']
# 对当前选择的特征进行探查。
X.info()
<class 'pandas.core.frame.DataFrame'>
Int64Index: 1313 entries, 0 to 1312
Data columns (total 3 columns):
pclass 1313 non-null object
age 633 non-null float64
sex 1313 non-null object
dtypes: float64(1), object(2)
memory usage: 41.0+ KB
# 借由上面的输出,我们设计如下几个数据处理的任务:
# 1) age这个数据列,只有633个,需要补完。
# 2) sex 与 pclass两个数据列的值都是类别型的,需要转化为数值特征,用0/1代替。
# 首先我们补充age里的数据,使用平均数或者中位数都是对模型偏离造成最小影响的策略。
X['age'].fillna(X['age'].mean(), inplace=True)
# 对补完的数据重新探查。
X.info()
<class 'pandas.core.frame.DataFrame'>
Int64Index: 1313 entries, 0 to 1312
Data columns (total 3 columns):
pclass 1313 non-null object
age 1313 non-null float64
sex 1313 non-null object
dtypes: float64(1), object(2)
memory usage: 41.0+ KB
# 由此得知,age特征得到了补完。
# 数据分割。
from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state = 33)
# 我们使用scikit-learn.feature_extraction中的特征转换器,详见3.1.1.1特征抽取。
from sklearn.feature_extraction import DictVectorizer
vec = DictVectorizer(sparse=False)
# 转换特征后,我们发现凡是类别型的特征都单独剥离出来,独成一列特征,数值型的则保持不变。
X_train = vec.fit_transform(X_train.to_dict(orient='record'))
['age', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', 'sex=female', 'sex=male']
# 同样需要对测试数据的特征进行转换。
X_test = vec.transform(X_test.to_dict(orient='record'))
# 从sklearn.tree中导入决策树分类器。
from sklearn.tree import DecisionTreeClassifier
# 使用默认配置初始化决策树分类器。
dtc = DecisionTreeClassifier()
# 使用分割到的训练数据进行模型学习。
dtc.fit(X_train, y_train)
# 用训练好的决策树模型对测试特征数据进行预测。
y_predict = dtc.predict(X_test)
# 从sklearn.metrics导入classification_report。
from sklearn.metrics import classification_report
# 输出预测准确性。
print dtc.score(X_test, y_test)
# 输出更加详细的分类性能。
print classification_report(y_predict, y_test, target_names = ['died', 'survived'])
0.781155015198
precision recall f1-score support
died 0.91 0.78 0.84 236
survived 0.58 0.80 0.67 93
avg / total 0.81 0.78 0.79 329

2.1.1.6 集成模型(Ensemble):随机森林:Random Forest Classifier,梯度提升决策树:Gradient Tree Boosting。

模型介绍:
集成分类模型便是综合考量多个分类器的预测结果,从而做出决策。这种综合考量大体上分为两种:
1.一种是利用相同的训练数据同时搭建多个独立的分类模型,然后通过投票的方式,以少数服从多数的原则做出最终的分类决策。比较具有代表性的模型为随机森林分类器。即是在相同的训练数据上同时搭建多棵决策树,一株标准的决策树根据每维特征对预测结果的影响程度进行排序,进而决定不同特征从上至下构建分裂节点的顺序,但如果都这样,那么每一棵树都类似,那么就丧失了多样性,而随机森林分类器在构建过程中放弃了这一固定的排序算法,转而随机选取特征。【也是工业上对比的基准线】
2.另一种是按照一定次序搭建多个分类模型。这些模型之间彼此存在依赖关系。每一个后续模型的加入都需要对现有的集成模型的综合性能有所贡献,进而不断的提升更新后的集成模型的性能,并最终期望借助整合多个分类能力较弱的分类器,搭建出具有更强分类能力的模型。比较有代表性的就是梯度提升决策树。与构建随机森林分类器模型不同,每一棵决策树在生成的过程中对吼尽可能的降低整体集成模型在训练集上的拟合误差。
数据描述:
仍然用泰坦尼克号数据。
性能分析:
使用多种用于评价分类任务性能的指标,将单一决策树、随机森林分类器以及随机梯度提升决策树进行以下四种参数的对比。准确率(Accuracy)、召回率(Recall)、精确率(Percision)以及F1指标。
特点分析:
相比于其他单一的学习模型,集成模型可以整合多种模型,或者多次就一种类型的模型进行建模,由于模型估计参数的过程也同样受到概率的影响,具有一定的不确定性,因此集成模型虽然在训练过程中要耗费更多的时间,但是得到的综合模型往往具有更高的性能和更好的稳定性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
# 导入pandas,并且重命名为pd。
import pandas as pd
# 通过互联网读取泰坦尼克乘客档案,并存储在变量titanic中。
titanic = pd.read_csv('http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt')
# 人工选取pclass、age以及sex作为判别乘客是否能够生还的特征。
X = titanic[['pclass', 'age', 'sex']]
y = titanic['survived']
# 对于缺失的年龄信息,我们使用全体乘客的平均年龄代替,这样可以在保证顺利训练模型的同时,尽可能不影响预测任务。
X['age'].fillna(X['age'].mean(), inplace=True)
# 对原始数据进行分割,25%的乘客数据用于测试。
from sklearn.cross_validation 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'))
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_pred = dtc.predict(X_test
# 使用随机森林分类器进行集成模型的训练以及预测分析。
from sklearn.ensemble import RandomForestClassifier
rfc = RandomForestClassifier()
rfc.fit(X_train, y_train)
rfc_y_pred = rfc.predict(X_test)
# 使用梯度提升决策树进行集成模型的训练以及预测分析。
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier()
gbc.fit(X_train, y_train)
gbc_y_pred = gbc.predict(X_test)
# 从sklearn.metrics导入classification_report。
from sklearn.metrics import classification_report
# 输出单一决策树在测试集上的分类准确性,以及更加详细的精确率、召回率、F1指标。
print 'The accuracy of decision tree is', dtc.score(X_test, y_test)
print classification_report(dtc_y_pred, y_test)
The accuracy of decision tree is 0.781155015198
precision recall f1-score support
0 0.91 0.78 0.84 236
1 0.58 0.80 0.67 93
avg / total 0.81 0.78 0.79 329
# 输出随机森林分类器在测试集上的分类准确性,以及更加详细的精确率、召回率、F1指标。
print 'The accuracy of random forest classifier is', rfc.score(X_test, y_test)
print classification_report(rfc_y_pred, y_test)
The accuracy of random forest classifier is 0.77811550152
precision recall f1-score support
0 0.90 0.77 0.83 235
1 0.58 0.79 0.67 94
avg / total 0.81 0.78 0.79 329
# 输出梯度提升决策树在测试集上的分类准确性,以及更加详细的精确率、召回率、F1指标。
print 'The accuracy of gradient tree boosting is', gbc.score(X_test, y_test)
print classification_report(gbc_y_pred, y_test)
The accuracy of gradient tree boosting is 0.790273556231
precision recall f1-score support
0 0.92 0.78 0.84 239
1 0.58 0.82 0.68 90
avg / total 0.83 0.79 0.80 329

2.1.2 回归预测(Regressor)

回归问题和分类问题的区别在于其预测的目标是连续的变量,比如:价格、降水量等等。比如经典的例子房价预测,以下小节都采用这个例子。

2.1.2.1 线性回归器

模型介绍:
在线性分类器的时候,为了方便将实数域的结果映射到(0,1)区间,引入了逻辑斯蒂函数,而在线性回归问题中,预测目标直接就是实数域上的数值。因此优化目标更为简单,即最小化预测结果与真实值之间的差值。

此处采用线性回归模型LinearRegression和SGDRegressor两种线性模型。
数据描述:
美国波士顿地区的房价预测。
性能分析:
不同于类别预测,不能苛求回归预测的数值结果严格的与真实值相同。一般情况下,希望衡量预测值与真实值之间的差距。因此可以通过多种测评函数进行评价,最为直观的评价指标包括平均绝对误差(Mean Absolute Error,MAE),均方误差(Mean Squared Error,MSE),这些都是线性模型所优化的额目标。以及最传统的R-squared(用来衡量模型回归结果的波动可被真实值验证的百分比,也暗示了模型在数值回归方面的能力,同时即考量了回归值与真实值之间的差异,同时也反映了真实值的变动)


特点分析:
线性回归其是最为简单的、易用的回归模型。正是因为其对特征与回归目标之间的线性假设,从某种程度上也局限了其应用范围,特别是现实生活中的许多实例数据的各个特征与回归目标之间,绝大数不能保证严格的线性关系。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
# 从sklearn.datasets导入波士顿房价数据读取器。
from sklearn.datasets import load_boston
# 从读取房价数据存储在变量boston中。
boston = load_boston()
# 输出数据描述。
print (boston.DESCR)
Boston House Prices dataset
===========================
Notes
------
Data Set Characteristics:
:Number of Instances: 506
:Number of Attributes: 13 numeric/categorical predictive
:Median Value (attribute 14) is usually the target
:Attribute Information (in order):
- CRIM per capita crime rate by town
- ZN proportion of residential land zoned for lots over 25,000 sq.ft.
- INDUS proportion of non-retail business acres per town
- CHAS Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)
- NOX nitric oxides concentration (parts per 10 million)
- RM average number of rooms per dwelling
- AGE proportion of owner-occupied units built prior to 1940
- DIS weighted distances to five Boston employment centres
- RAD index of accessibility to radial highways
- TAX full-value property-tax rate per $10,000
- PTRATIO pupil-teacher ratio by town
- B 1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town
- LSTAT % lower status of the population
- MEDV Median value of owner-occupied homes in $1000's
:Missing Attribute Values: None
:Creator: Harrison, D. and Rubinfeld, D.L.
This is a copy of UCI ML housing dataset.
http://archive.ics.uci.edu/ml/datasets/Housing
This dataset was taken from the StatLib library which is maintained at Carnegie Mellon University.
The Boston house-price data of Harrison, D. and Rubinfeld, D.L. 'Hedonic
prices and the demand for clean air', J. Environ. Economics & Management,
vol.5, 81-102, 1978. Used in Belsley, Kuh & Welsch, 'Regression diagnostics
...', Wiley, 1980. N.B. Various transformations are used in the table on
pages 244-261 of the latter.
The Boston house-price data has been used in many machine learning papers that address regression
problems.
**References**
- Belsley, Kuh & Welsch, 'Regression diagnostics: Identifying Influential Data and Sources of Collinearity', Wiley, 1980. 244-261.
- Quinlan,R. (1993). Combining Instance-Based and Model-Based Learning. In Proceedings on the Tenth International Conference of Machine Learning, 236-243, University of Massachusetts, Amherst. Morgan Kaufmann.
- many more! (see http://archive.ics.uci.edu/ml/datasets/Housing)
# 从sklearn.cross_validation导入数据分割器。
from sklearn.cross_validation import train_test_split
# 导入numpy并重命名为np。
import numpy as np
X = boston.data
y = boston.target
# 随机采样25%的数据构建测试样本,其余作为训练样本。
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=33, test_size=0.25)
# 分析回归目标值的差异。
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))
('The max target value is', 50.0)
('The min target value is', 5.0)
('The average target value is', 22.532806324110677)
# 从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)
y_test = ss_y.transform(y_test)
# 从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_absoluate_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 absoluate 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 SGDRegressor is', sgdr.score(X_test, y_test)
# 使用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 absoluate error of SGDRegressor is', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(sgdr_y_predict))
The value of default measurement of SGDRegressor is 0.659853975749
The value of R-squared of SGDRegressor is 0.659853975749
The mean squared error of SGDRegressor is 26.3753630607
The mean absoluate error of SGDRegressor is 3.55075990424

2.1.2.2 支持向量机

模型介绍:
与分类中的解释一致,只是用法不同,前者用来分类,而这里进行回归预测,具体的数值预测(在回归中可以对SVM配置不同的核函数)。
数据描述:
同上文支持向量机分类的数据
性能分析:
就不同的核函数装配下的支持向量机回归模型在测试集上的回归性能做出评估。会发现在不同的核函数下存在着很大的性能差异,在此例中使用了径向量(Radial basis function)核函数对特征进行非线性映射之后,支持向量机展现了最佳的回归性能。
特点分析:
可以帮助我们在海量甚至更高维度的数据中筛选出对预测任务最为有效的少数训练样本。这样不仅节省了模型学习所需要的数据内存,同时也提高了模型的预测性能。然后要获得此性能,就必须付出更多的计算代价(CPU资源和计算时间)。不同核函数下性能有差异,所以要多尝试几种核函数模型。
核函数:
核函数就是通过某种函数计算,将原有的特征映射到更高的维度空间,从而尽可能的达到新的高纬度特征线性可分程度。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# 从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)
# 使用R-squared、MSE和MAE指标对三种配置的支持向量机(回归)模型在相同测试集上进行性能评估。
from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_error
print 'R-squared value of linear SVR is', linear_svr.score(X_test, y_test)
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))
print 'The mean absoluate error of linear SVR is', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(linear_svr_y_predict))
R-squared value of linear SVR is 0.65171709743
The mean squared error of linear SVR is 0.31360572651
The mean absoluate error of linear SVR is 0.369259810963
print 'R-squared value of Poly SVR is', poly_svr.score(X_test, y_test)
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))
print 'The mean absoluate error of Poly SVR is', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(poly_svr_y_predict)
R-squared value of Poly SVR is 0.404454058003
The mean squared error of Poly SVR is 0.536249745341
The mean absoluate error of Poly SVR is 0.404323590015
print 'R-squared value of RBF SVR is', rbf_svr.score(X_test, y_test)
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))
print 'The mean absoluate error of RBF SVR is', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(rbf_svr_y_predict))
R-squared value of RBF SVR is 0.756406891227
The mean squared error of RBF SVR is 0.21933948892
The mean absoluate error of RBF SVR is 0.280992190922

2.1.2.3 K近邻

模型介绍:
不需要训练参数,对于待预测的测试样本选取K个最邻近的点进行回归值的决策。(自然也衍生出了待测试样本回归值的不同方式,即到底是对K个临近目标值使用普通的算术平均算法,还是同时考虑距离的差异进行加权平均,一下代码也会配置不同配置的K临近回归模型来比较性能差异)【预测方式为平均回归的K临近回归和加权回归的K临近回归】
数据描述:
仍然使用波士顿房价数据。
性能分析:
仍然使用R-squared、MSE、MAE三种指标。发现此例中加权平均的方式回归预测房价更具有好的预测性。
特点分析:
K临近回归于K临近分类一样,都属于无参数模型,同样没有训练的过程。但是模型的计算方法非常直观。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 从sklearn.neighbors导入KNeighborRegressor(K近邻回归器)。
from sklearn.neighbors import KNeighborsRegressor
# 初始化K近邻回归器,并且调整配置,使得预测的方式为平均回归:weights='uniform'。
uni_knr = KNeighborsRegressor(weights='uniform')
uni_knr.fit(X_train, y_train)
uni_knr_y_predict = uni_knr.predict(X_test)
# 初始化K近邻回归器,并且调整配置,使得预测的方式为根据距离加权回归:weights='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 KNeighorRegression:', uni_knr.score(X_test, y_test)
print 'The mean squared error of uniform-weighted KNeighorRegression:', 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 KNeighorRegression', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(uni_knr_y_predict))
R-squared value of uniform-weighted KNeighorRegression: 0.690345456461
The mean squared error of uniform-weighted KNeighorRegression: 0.278823443175
The mean absoluate error of uniform-weighted KNeighorRegression 0.319836405678
# 使用R-squared、MSE以及MAE三种指标对根据距离加权回归配置的K近邻模型在测试集上进行性能评估。
print 'R-squared value of distance-weighted KNeighorRegression:', dis_knr.score(X_test, y_test)
print 'The mean squared error of distance-weighted KNeighorRegression:', 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 KNeighorRegression:', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(dis_knr_y_predict))
R-squared value of distance-weighted KNeighorRegression: 0.719758997016
The mean squared error of distance-weighted KNeighorRegression: 0.252338494627
The mean absoluate error of distance-weighted KNeighorRegression: 0.302274187769

2.1.2.4 回归树

模型介绍:
回归树的叶节点的数据类型不是离散型,而是连续型的。决策树每个叶节点依照训练数据表现的概率倾向决定了其最终的预测类别,而回归树的叶节点却是一个个具体的值,从预测连续这个意义上严格来讲,回归树不能称为回归算法,因为回归树的叶子节点返回的是一团训练数据的均值,而不是具体的连续的预测值。
数据描述:
仍然采用波士顿房价数据。
性能分析:
效果显著优于LinearRegression和SGDRegression,所以可知道美国波士顿房价预测问题的特征与目标之间存在一定的非线性关系。
特点分析:

- 优点
    - 数模型可以解决非线性特征的问题。
    - 树模型不要求对特征数据进行标准化和统一量化,即数值型和类别型特征都可以直接被应用在树模型的构建和预测过程中
    - 因为上面的优点,树模型也可以直观的输出决策过程,使得预测结果具有可解释性。
- 缺点
    - 因为其可以解决复杂的非线性拟合问题,所以更加容易因为模型搭建过于复杂而丧失对新数据预测的精度(泛化力)
    - 树模型从上至下的预测流程会因为数据细微的更改而发生较大的结构变化,因此预测稳定下较差
    - 依托训练数据构架的最佳树模型是个NP-hard问题,所以有限时间内无法找到最优解,所以经常借助集成模型,在多个次优解中找到更高的模型性能。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 从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 absoluate error of DecisionTreeRegressor:', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(dtr_y_predict))
R-squared value of DecisionTreeRegressor: 0.692592549712
The mean squared error of DecisionTreeRegressor: 0.276800084273
The mean absoluate error of DecisionTreeRegressor: 0.340675749137

2.1.2.5 集成模型

模型介绍:
同样有随机森林回归和随机梯度提升树模型,此外还加入了随机森林的变种:极限随机森林(Extremely Randomized Tree),与普通随机森林模型不同的是,极限随机森林在每当构建一棵树的分裂节点(node)的时候,不会任意选取特征,而是先随机收集一部分特征,然后利用信息熵(Information Gain)和基尼不纯性(Gini Impurity)等指标挑选最佳节点特征。
数据描述:
仍然是波士顿房价数据。
性能分析:
同样采用R-Squared、MAE、MSE三种预测指标。
特点分析:
许多业界从事商业分析系统开发和搭建的工作者更加青睐集成模型,并且经常以这些模型的性能表现为基准,与新设计的其他模型性能进行对比。虽然这些集成模型在训练过程中需要耗费更多的时间,但是往往可以提供更高的表现性能和更好的稳定性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# 从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 value of RandomForestRegressor: 0.840592481412
The mean squared error of RandomForestRegressor: 0.143535931018
The mean absoluate error of RandomForestRegressor: 0.237149352743
# 使用R-squared、MSE以及MAE指标对默认配置的极端回归森林在测试集上进行性能评估。
print 'R-squared value of ExtraTreesRegessor:', etr.score(X_test, y_test)
print 'The mean squared error of ExtraTreesRegessor:', mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(etr_y_predict))
print 'The mean absoluate error of ExtraTreesRegessor:', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(etr_y_predict))
# 利用训练好的极端回归森林模型,输出每种特征对预测目标的贡献度。
print np.sort(zip(etr.feature_importances_, boston.feature_names), axis=0)
R-squared value of ExtraTreesRegessor: 0.835582207186
The mean squared error of ExtraTreesRegessor: 0.148047351696
The mean absoluate error of ExtraTreesRegessor: 0.250649106588
[['0.0148831885456' 'AGE']
['0.0164137658185' 'B']
['0.0186619396796' 'CHAS']
['0.0189673119564' 'CRIM']
['0.0205761600375' 'DIS']
['0.0255369237188' 'INDUS']
['0.025890473054' 'LSTAT']
['0.0295863020532' 'NOX']
['0.0309240655832' 'PTRATIO']
['0.0417999802912' 'RAD']
['0.0463531289155' 'RM']
['0.314967578338' 'TAX']
['0.395439182008' 'ZN']]
# 使用R-squared、MSE以及MAE指标对默认配置的梯度提升回归树在测试集上进行性能评估。
print 'R-squared value of GradientBoostingRegressor:', gbr.score(X_test, y_test)
print 'The mean squared error of GradientBoostingRegressor:', mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(gbr_y_predict))
print 'The mean absoluate error of GradientBoostingRegressor:', mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(gbr_y_predict))
R-squared value of GradientBoostingRegressor: 0.842602871434
The mean squared error of GradientBoostingRegressor: 12.2047771094
The mean absoluate error of GradientBoostingRegressor: 2.28597618665

2.2 无监督学习

无监督学习着重于发现数据本身的分布特点,与监督学习不同,无监督学习不需要对数据进行标记。这样,在节省大量人工的同时,也让可以利用的数据规模变得不可限量。

从功能角度来说无监督学习模型帮助我们发现数据的“群落”(聚类,分布情况),同样也可以寻找离群的样本,另外对于特征维度非常高的数据样本,我们同样可以通过无监督学习对数据进行降维,但是保留最具有区分性的低纬度特征。这些都是在海量数据处理中非常实用的技术。

2.2.1 数据聚类

数据聚类是无监督学习的主流应用之一,最为经典并且易用的聚类模型就是K-Means算法。该算法要求我们预先设定聚类的个数,然后不断更新聚类中心,经过几轮这样的迭代后,最终的目标就是让所有数据点到其所属数据类中心距离的平方和趋于稳定。

2.2.1.1 K均值算法(K-means)

模型介绍:
K-means的流程可以分为四个阶段。

- 1.随机分布K个特徵空间内的点作为初始的聚类中心。
- 2.然后,对于根据每个数据的特性向量从K个聚类中心中寻找距离最近的一个,并且把该数据标记为从属于这个聚类中心。
- 3.接着,在所有的数据都被标记过聚类中心之后,根据这些数据新分配的类簇,重新对K个聚类中心做计算。
- 4.如果一轮下来,所有的数据点从属的聚类中心与上一次的分配的类簇没有变化,那么迭代可以停止,否则回到步骤2继续循环。

过程如下图:

数据描述:
手写体数字图像数据的完整版本。
性能分析:
1.如果被用来评估的数据本身带有正确的类别信息,就使用Adjusted Rand Index(ARI),这个指标与分类问题中计算准确性的方法类似,同时也兼顾到了类簇无法和分类标记一一对应的问题。

特点分析:
K-means聚类模型所采用的迭代算法,直观易懂并且非常实用,但有2大缺陷:1.容易收敛到局部最优解2.需要预先设定簇的数量。


为了解决以上问题可以参考肘部观察法。

从这个拐点对应的K开始,类簇中心的增加不会破坏数据聚类的结构。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
# 分别导入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)]
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)
0.671267090907
# 导入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)
# 初始化原始数据点。
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(zip(x1, x2)).reshape(len(x1), 2)
# 在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:
subplot_counter += 1
plt.subplot(3, 2, subplot_counter)
kmeans_model = KMeans(n_clusters=t).fit(X)
for i, l in enumerate(kmeans_model.labels_):
plt.plot(x1[i], x2[i], color=colors[l], marker=markers[l], ls='None')
plt.xlim([0, 10])
plt.ylim([0, 10])
sc_score = silhouette_score(X, kmeans_model.labels_, metric='euclidean')
sc_scores.append(sc_score)
# 绘制轮廓系数与不同类簇数量的直观显示图。
plt.title('K = %s, silhouette coefficient= %0.03f' %(t, sc_score))
# 绘制轮廓系数与不同类簇数量的关系曲线。
plt.figure()
plt.plot(clusters, sc_scores, '*-')
plt.xlabel('Number of Clusters')
plt.ylabel('Silhouette Coefficient Score')
plt.show()


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# 导入必要的工具包。
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))
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
print X.shape
print X.shape[0]
plt.scatter(X[:,0], X[:, 1])
plt.xlabel('x1')
plt.ylabel('x2')
plt.show()
# 测试9种不同聚类中心数量下,每种情况的聚类质量,并作图。
K = range(1, 10)
meandistortions = []
for k in K:
kmeans = KMeans(n_clusters=k)
kmeans.fit(X)
meandistortions.append(sum(np.min(cdist(X, kmeans.cluster_centers_, 'euclidean'), axis=1))/X.shape[0])
plt.plot(K, meandistortions, 'bx-')
plt.xlabel('k')
plt.ylabel('Average Dispersion')
plt.title('Selecting k with the Elbow Method')
plt.show()
[[ 0.65437221 0.60824287 1.37405521 1.06883557 0.56351077 0.83423208
0.74072001 0.76639986 1.29815858 0.54004198]
[ 0.95506086 1.28734408 0.58704345 1.21770559 0.97949615 0.9624782
1.39353203 1.13024559 1.1295162 0.86733591]]
(30, 2)
30

2.2.2 特征降维

模型介绍:
特征降维是无监督学习的另一个应用,其一我们经常在实际项目中遭遇特征维度非常高的训练样本,往往无法借助自己领域的知识人工构建有效特征,其二在数据表现上,我们无法用肉眼观测到超过3个维度的特征。因此特征将为不仅重构了有效的低纬度特征向量,同时也为数据展现提供了可能,在数据降维方法中,主成分分析(Principal Component Analysis)是最为经典和使用的特征降维技术,特别是在辅助图像识别方面,尤为突出的表现。以下示例一PCA压缩为例。

2.2.2.1 主成分分析(Principal Component Analysis:PCA)

数据描述:
使用手写字体图像全集数据。
性能分析:
可以在降维后再用数据进行训练,再用于分类,与未经过降维分类的实验来进行比较,来验证效果的好坏。
会发现经过PCA特征亚索和重建后,特征数据会损失2%左右的预测准确性,但是相比于原始数据的六十四维度的特征而言,使用PCA会压缩并且降低68.75%的维度。在于海量数据时候非常有效。
特点分析:
降维/压缩问题则是选取数据具有代表性的特征,在保持数据多样性的基础上,规避掉大量的特征冗余和噪声,不过这个过程也很有可能会损失一些有用的模式信息,经过大量的时间证明,相较于损失的少部分模型性能,维度压缩能够节省大量用于模型训练的时间,这样一来,使得PCA所带来的模型総合効率变得更为划算。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
# 导入numpy工具包。
import numpy as np
# 初始化一个2*2的线性相关矩阵。
M = np.array([[1, 2], [2, 4]])
# 计算2*2线性相关矩阵的秩。
np.linalg.matrix_rank(M, tol=None)
1
# 导入pandas用于数据读取和处理。
import pandas as pd
# 从互联网读入手写体图片识别任务的训练数据,存储在变量digits_train中。
digits_train = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/optdigits/optdigits.tra', header=None)
# 从互联网读入手写体图片识别任务的测试数据,存储在变量digits_test中。
digits_test = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/optdigits/optdigits.tes', header=None)
# 分割训练数据的特征向量和标记。
X_digits = digits_train[np.arange(64)]
y_digits = digits_train[64]
# 从sklearn.decomposition导入PCA。
from sklearn.decomposition import PCA
# 初始化一个可以将高维度特征向量(64维)压缩至2个维度的PCA。
estimator = PCA(n_components=2)
X_pca = estimator.fit_transform(X_digits)
# 显示10类手写体数字图片经PCA压缩后的2维空间分布。
from matplotlib import pyplot as plt
def plot_pca_scatter():
colors = ['black', 'blue', 'purple', 'yellow', 'white', 'red', 'lime', 'cyan', 'orange', 'gray']
for i in xrange(len(colors)):
px = X_pca[:, 0][y_digits.as_matrix() == i]
py = X_pca[:, 1][y_digits.as_matrix()== i]
plt.scatter(px, py, c=colors[i])
plt.legend(np.arange(0,10).astype(str))
plt.xlabel('First Principal Component')
plt.ylabel('Second Principal Component')
plt.show()
plot_pca_scatter()
# 对训练数据、测试数据进行特征向量(图片像素)与分类目标的分隔。
X_train = digits_train[np.arange(64)]
y_train = digits_train[64]
X_test = digits_test[np.arange(64)]
y_test = digits_test[64]
# 导入基于线性核的支持向量机分类器。
from sklearn.svm import LinearSVC
# 使用默认配置初始化LinearSVC,对原始64维像素特征的训练数据进行建模,并在测试数据上做出预测,存储在y_predict中。
svc = LinearSVC()
svc.fit(X_train, y_train)
y_predict = svc.predict(X_test)
# 使用PCA将原64维的图像数据压缩到20个维度。
estimator = PCA(n_components=20)
# 利用训练特征决定(fit)20个正交维度的方向,并转化(transform)原训练特征。
pca_X_train = estimator.fit_transform(X_train)
# 测试特征也按照上述的20个正交维度方向进行转化(transform)。
pca_X_test = estimator.transform(X_test)
# 使用默认配置初始化LinearSVC,对压缩过后的20维特征的训练数据进行建模,并在测试数据上做出预测,存储在pca_y_predict中。
pca_svc = LinearSVC()
pca_svc.fit(pca_X_train, y_train)
pca_y_predict = pca_svc.predict(pca_X_test)
# 从sklearn.metrics导入classification_report用于更加细致的分类性能分析。
from sklearn.metrics import classification_report
# 对使用原始图像高维像素特征训练的支持向量机分类器的性能作出评估。
print svc.score(X_test, y_test)
print classification_report(y_test, y_predict, target_names=np.arange(10).astype(str))
# 对使用PCA压缩重建的低维图像特征训练的支持向量机分类器的性能作出评估。
print pca_svc.score(pca_X_test, y_test)
print classification_report(y_test, pca_y_predict, target_names=np.arange(10).astype(str))
0.930996104619
precision recall f1-score support
0 0.99 0.98 0.99 178
1 0.94 0.84 0.89 182
2 0.99 0.97 0.98 177
3 0.97 0.92 0.94 183
4 0.95 0.97 0.96 181
5 0.89 0.96 0.93 182
6 0.99 0.98 0.99 181
7 0.98 0.90 0.94 179
8 0.78 0.91 0.84 174
9 0.86 0.89 0.87 180
avg / total 0.93 0.93 0.93 1797
0.909293266555
precision recall f1-score support
0 0.96 0.96 0.96 178
1 0.78 0.85 0.82 182
2 0.96 0.98 0.97 177
3 0.99 0.89 0.94 183
4 0.95 0.92 0.93 181
5 0.84 0.97 0.90 182
6 0.96 0.97 0.96 181
7 0.93 0.92 0.93 179
8 0.83 0.83 0.83 174
9 0.92 0.82 0.86 180
avg / total 0.91 0.91 0.91 1797

坚持原创技术分享,您的支持将鼓励我继续创作!