对人脸数据集“Labeled Faces in the Wild”：sklearn.datasets.fetch_lfw_people，下载地址aka LFW:http://vis-www.cs.umass.edu/lfw/lfw-funneled.tgz， 采用PCA,KPCA,MDS,LLE,ISOMAPE五种方式降维，比较基于SVM或决策树等分类器的识别效果。

一、课题设计背景

随着人工智能、大数据时代的到来，人们需要在众多场合验证身份信息。如今，身份认证技术已广泛应用于国家、社会的各领域，如政府、军队、银行、社会福利保障、电子商务、安全防护等。近年来，随着电子银行、线上商业等模式的推广，人们对于保障身份信息的安全性愈来愈重视。传统的身份认证方法（如密码、身份证等）因其容易盗取、假冒，已无法满足人们对个人信息安全的需求。生物特征识别技术因其稳定高效、单一快速等优势在身份认证领域迅速崛起，已成为人工智能时代学者们研究的热点。用于识别的人类生物特征一般有：人脸、虹膜、掌纹、指纹和步态等，而人脸图像识别（Face Recognition）因其方便获取，具有丰富的鉴别信息和非接触性的优势，已成为了生物特征识别技术研究的焦点之一。

人脸图像识别就是通过模式识别和图像处理技术，对现实空间的待识别人脸与人脸样本进行比较，根据相似度判断身份信息。在现实生活中存在大量人脸识别的例子，例如智能无人超市人脸识别、网上支付人脸识别、私人办公室人脸识别、安检人脸识别等。在国家以及社会的安全保障中，人脸识别也体现了其应用价值，对危险分子和境内外违法人员的及时监控和抓捕起到了极大作用，维护了国家和社会秩序的安全稳定。在信息安全防护中，人脸识别可以防止人们的身份信息泄露或者被窃取，遏制犯罪份子利用伪冒身份认证信息违法犯罪，有效保护人民群众的财产和隐私安全。

人脸图像采集质量的高低直接影响人脸识别的性能，因为人脸图像采集过程中易受到光照、姿态、角度以及采集设备等因素的影响，现实生活中获取的人脸图像数据往往具有复杂的高维非线性特性。因此，为了有效提高人脸识别性能，剔除人脸图像数据中的冗余信息，在不破坏人脸图像数据内在结构的同时降低人脸图像数据的维度，使得降维后的人脸数据可以被更加方便的存储和更加有效的识别是非常有必要的。

二、设计方案概述

 

图1 降维方法系统分类

人脸图像降维方法，即利用线性或者非线性变换将高维空间中的原始人脸数据投影到一个合适的低维空间中，同时尽量保持人脸数据的几何结构不被改变，进而获取人脸数据的低维表达。通常，人脸图像降维技术按不同角度可分为有监督降维和无监督降维、线性降维和非线性降维等方法。

1）人脸图像数据的有监督降维是利用已有标签信息的人脸数据（训练）样本完成目标模型的训练，将输入的高维原始人脸数据映射到低维表达空间，再利用训练好的模型参数对新的人脸样本数据进行有效的降维处理。人脸图像数据的无监督降维相较于有监督降维方法，省去了样本信息标注的成本跟时间，但以牺牲部分降维性能为代价。

2）人脸图像的线性降维是通过假设人脸数据具有全局线性结构，然后利用线性映射函数将原始人脸数据映射到低维表达空间，完成线性降维模型的训练，再利用算法模型训练好的参数直接提取出新的人脸低维数据表达。人脸图像的非线性降维相较于线性方法，可以充分挖掘人脸样本数据的内在几何结构，更加准确地挖掘人脸图像的有效信息。

PCA 算法是常用的面向人脸图像的无监督线性降维算法，其核心思想是寻找一组包含较多信息的线性向量去描述原始人脸数据的分布结构。PCA 算法是一种优秀的统计特征提取方法，其通过选取少量有效人脸数据对人脸样本进行描述表达，在降维的同时尽量保留原始人脸识别的有用信息。

MDS 算法的降维思想同 PCA 算法相似，利用低维人脸特征来表达原始人脸信息，不同之处在于 MDS算法是通过计算人脸样本间的距离（一般选用欧式距离）来获取合适的低维表达数据，使得降维后的低维特征仍然保持原始人脸数据的潜在线性结构，从而达到人脸数据降维的目的。

为了克服线性降维算法在人脸图像降维中存在的缺陷，充分挖掘人脸数据潜在的非线性结构，非线性数据降维方法逐渐成为了人脸图像降维的研究热点，如核主成分分析（KPCA），但是核函数降维技术在人脸图像的降维过程中，也存在不少问题，比如核函数映射后的人脸样本特征分布无法明确、无选择核函数的统一标准、只能用于小样本的人脸数据训练，对于大样本人脸数据同样存在“维度灾难” 等问题。

流形学习不同于核非线性降维，其核心思想是通过挖掘人脸数据的潜在规律，从人脸数据中获得数据的内在结构分布，将原始人脸数据映射到低维流形空间，同时保持低维样本数据在原始空间的几何关系。LLE 是一种是常用于处理人脸数据的经典的流形学习算法，其核心思想是假设数据的局部结构是线性的，通过找到局部近邻样本组合来线性表达样本。ISOMAP寻求一种低维表示，以保持点之间的“距离”。

经过上述对PCA、KPCA、LLE、MDS、ISOMAP的分析，为了验证上述降维方法的效果，因此设计对人脸数据集“Labeled Faces in the Wild”采用上述五种方式降维，比较基于SVM分类器的识别效果。

三、详细设计

3.1 LFW人脸数据集介绍

LFW (Labled Faces in the Wild)人脸数据集：是目前人脸识别的常用测试集，其中提供的人脸图片均来源于生活中的自然场景，因此识别难度会增大，尤其由于多姿态、光照、表情、年龄、遮挡等因素影响导致即使同一人的照片差别也很大。并且有些照片中可能不止一个人脸出现，对这些多人脸图像仅选择中心坐标的人脸作为目标，其他区域的视为背景干扰。LFW数据库是为了研究无约束的人脸识别问题而设计的。它包含超过13000张从网上收集的人脸图像。每张人脸图像都标有人的名字,在数据集中, 1680个人有两个或更多个不同的照片。每张图片的尺寸为250X250，绝大部分为彩色图像，但也存在少许黑白人脸图片。图2中显示的是LFW数据库中一个人的人脸样本。

图2 LFW数据样本

3.2 人脸识别流程

(1)图像预处理

人脸检测的关键性任务是从待检测的图像或一段视频中判定出人脸的存在与否,进而把图像分为两个区域,人脸和非人脸。人脸检测自身在图像检索等领域有着广泛的应用,但光照变化的强弱、姿态变化的样式、复杂背景的出现等都会对检测结果产生不同层次的影响。图像的预处理是能否成功将人脸检测出来的基础环节。

将读取图像从RGB值转化到Lab空间是预处理第一环节,将像素和灰度值去均值后,进行边缘检测,清除不必要的背景区域或者噪音等无关信息,最后将收纳的图像统一缩放为标准大小。

图像的预处理一般分为六个技术模块,其中二值法技术在进行处理过程中同样占有举足轻重的地位。它的工作主要是将已经处理过的灰度图像值生成黑白的二值图像,非黑即白,图像的二值化处理案例如下图3。图3是实验对象人脸五官的二值化处理。通过实现简单的二值化处理,设置一定的阙值范围(使提取轮廓的物体与背景区分割开、平滑边缘的轮廓)来实现图像从灰度到黑白的转化。

 

图3二值化处理

（2）人脸检测

人脸检测的任务是判别被检测者与所在的周围背景颜色等方面是否有计算机可察觉的明显区别。首先检测输入图像或视频序列中是否存在人脸图像或者人脸边缘。如果不存在,则检测框内不会出现任何变化;如果存在,检测框会定位到除去背景人脸所在位置和尺寸的大小。

经过对LFW人脸数据集分析后，大部分的图片都主要集中在人脸部位，被检测者与所在的周围背景颜色等方面无明显区别，因此在本设计中不在进行进行人脸检测。

（3）人脸鉴别

人脸鉴别,也称为人脸识别,鉴别过程就是把要识别的人脸与放在数据库中的人脸模板进行对比。它的核心点是如何选择正确的匹配规则和策略,依据恰当的表示方式和对比方式搜索到数据库中与它相匹配的待检测人脸。由此可见,它与人脸特征表示紧密相关。

在本设计中，利用降维算法，对数据进行降维后提取主要特征，再利用SVM进行识别，实现人脸的鉴别。

四、结果及分析

4.1参数对识别效果的影响

       为了观察降低的维度对SVM分类器的影响程度，记录不同维度与准确率的关系，结果如下图4所示，根据下图分析可知，提高维度理论上可以保留更多的信息，并且会提高分类器的精度，但是PCA在提高到一定维度时，分类器的分类器的分类效果下降，因此对于PCA而言，在选择主成分个数时，应该选择合适的个数，这样才能达到理想的效果。

    对于其他四种降维方法，在本次实验中，并未出现如PCA这种情况，整体呈提升维度，保留的信息增多，分类器的效果逐渐变好。

但在这个过程中，MDS出现增长缓慢的情况，MDS算法是通过计算人脸样本间的距离（一般选用欧式距离）来获取合适的低维表达数据，使得降维后的低维特征仍然保持原始人脸数据的潜在线性结构，从而达到人脸数据降维，但是最后的分类效果却不是很理想，可能与使用的分类器有关。

 

图4 维度与识别效果关系

4.2 识别结果显示

4.2.1 直接使用SVM识别结果

   图5：SVM识别结果可视化

表1：SVM性能指标

人名	precision	recall	f1-score	support
Ariel Sharon	0.77	0.67	0.71	15
Colin Powell	0.75	0.85	0.80	68
Donald Rumsfeld	0.73	0.77	0.75	31
George W Bush	0.87	0.78	0.82	126
Gerhard Schroeder	0.50	0.70	0.58	23
Hugo Chavez	0.81	0.65	0.72	20
Junichiro Koizumi	0.92	1.00	0.96	12
Tony Blair	0.75	0.71	0.73	42
性能指标
accuracy			0.77	337
macro avg	0.76	0.77	0.76	337
weighted avg	0.79	0.77	0.78	337

4.2.2通过PCA对人脸数据集降维后SVM识别结果

图6：PCA降维后SVM识别结果可视化

表2：PCA+SVM性能指标               

人名	precision	recall	f1-score	support
Ariel Sharon	1.00	0.80	0.89	15
Colin Powell	0.64	0.96	0.76	68
Donald Rumsfeld	0.96	0.81	0.88	31
George W Bush	0.91	0.84	0.88	126
Gerhard Schroeder	0.89	0.70	0.78	23
Hugo Chavez	1.00	0.70	0.82	20
Junichiro Koizumi	1.00	0.75	0.86	12
Tony Blair	0.90	0.86	0.88	42
性能指标
accuracy			0.84	337
macroavg	0.91	0.80	0.84	337
weightedavg	0.87	0.84	0.84	337

4.2.3 通过KPCA对人脸数据集降维后SVM识别结果

图7：KPCA降维后SVM识别结果可视化

表3：KPCA+SVM性能指标

人名	precision	recall	f1-score	support
Ariel Sharon	0.77	0.67	0.71	15
Colin Powell	0.81	0.85	0.83	68
Donald Rumsfeld	0.75	0.77	0.76	31
George W Bush	0.84	0.82	0.83	126
Gerhard Schroeder	0.50	0.61	0.55	23
Hugo Chavez	0.92	0.60	0.73	20
Junichiro Koizumi	0.92	0.92	0.92	12
Tony Blair	0.70	0.74	0.72	42
性能指标
accuracy			0.78	337
macro avg	0.78	0.75	0.76	337
weighted avg	0.79	0.78	0.78	337

4.2.4 通过LLE对人脸数据集降维后SVM识别结果

图8：LLE降维后SVM识别结果可视化

表4：LLE+SVM性能指标                            

人名	precision	recall	f1-score	support
Ariel Sharon	0.77	0.67	0.71	15
Colin Powell	0.92	0.84	0.88	68
Donald Rumsfeld	0.78	0.81	0.79	31
George W Bush	0.88	0.89	0.88	126
Gerhard Schroeder	0.62	0.65	0.64	23
Hugo Chavez	0.93	0.65	0.76	20
Junichiro Koizumi	0.92	1.00	0.96	12
Tony Blair	0.71	0.86	0.77	42
性能指标
accuracy			0.83	337
macro avg	0.82	0.79	0.80	337
weighted avg	0.84	0.83	0.83	337

4.2.5 通过ISOMAP对人脸数据集降维后SVM识别结果

 

图9：ISOMAP降维后SVM识别结果可视化

表5：ISOMAP+SVM性能指标

	precision	recall	f1-score	support
Ariel Sharon	0.70	0.47	0.56	15
Colin Powell	0.57	0.82	0.67	68
Donald Rumsfeld	0.73	0.61	0.67	31
George W Bush	0.73	0.66	0.69	126
Gerhard Schroeder	0.45	0.43	0.44	23
Hugo Chavez	0.50	0.20	0.29	20
Junichiro Koizumi	0.53	0.83	0.65	12
Tony Blair	0.55	0.52	0.54	42
性能指标
accuracy			0.63	337
macro avg	0.60	0.57	0.56	337
weighted avg	0.63	0.63	0.62	337

4.2.6 通过MDS对人脸数据集降维后SVM识别结果

图10：MDS降维后SVM识别结果可视化

表6：MDS+SVM性能指标

	precision	recall	f1-score	support
Ariel Sharon	0.00	0.00	0.00	13
Colin Powell	0.19	0.20	0.20	60
Donald Rumsfeld	0.08	0.11	0.09	27
George W Bush	0.50	0.47	0.48	146
Gerhard Schroeder	0.12	0.24	0.16	25
Hugo Chavez	0.00	0.00	0.00	15
Tony Blair	0.05	0.03	0.03	36
性能指标
accuracy			0.28	322
macro avg	0.13	0.15	0.14	322
weighted avg	0.29	0.28	0.28	322

4.3结果分析

 

图11：宏平均ROC曲线

 

图12：微平均ROC曲线

为了比较在人脸数据集上，采用降维后，利用SVM分类识别的性能，我设计了五组实验分别为：PCA,KPCA,LLE,ISOMAP、MDS以及不使用降维，将五组降维方法与不使用降维的SVM进行对比，为了便于观察降维前后时间差距，总结如下表7所示，并且为了判断模型性能，绘制了不同降维算法的ROC曲线，结果如上图11，12所示。

表7：时间对比表

方法	降维时间	训练时间	准确率	Macro-AUC	Micro-AUC
SVM	0.000s	3.370s	0.77	0.936	0.95
SVM+PCA	0.270s	0.364s	0.84	0.951	0.959
SVM+KPCA	0.275s	0.311s	0.78	0.94	0.956
SVM+LLE	16.822s	0.359s	0.83	0.944	0.959
SVM+ISOMAP	10.830s	0.343s	0.63	0.884	0.91
SVM+MDS	13.237s	0.305s	0.28	0.451	0.596

注：以下描述中PCA代表SVM和PCA(即使用降维后的SVM)，SVM代表没有进行降维。

由上表显示结果，可以看出降维时间对比：LLE>MDS>ISOMAP>PCA≈KPCA，训练时间：SVM>PCA>LLE>ISOMAP>KPCA，准确率:PCA>LLE>KPCA>SVM>ISOMAP>MDS。

根据上述结果显示，经过降维后的数据训练时间大幅度降低，并且合适的降维方法在保证了基本的信息得以保留的前提下，去除了冗余的信息，增加了对噪声的抵抗能力，最终识别效果也得到了提升，但是不合适的降维算法，会让最终的识别效果大幅度下降，出现适得其反的效果。

因此选择选择合适的降维方法，可以在去除冗余信息、缩短训练的时间的同时，提高识别效果，经过最后的对比，综合时间指标与准确率，降维后的训练速度比较，KPCA与PCA会更适合人脸识别。

五、总结

在大数据的时代,对大规模、呈指数级增长的复杂数据进行高效的组织、处理和分析,都离不开数据的降维处理。数据降维需要解决的问题是找到一个合适的投影,简洁、有效地表达出样本在原始高维空间的分布,使原始数据从高维空间变换到低维子空间。数据降维算法可以应用到人脸识别、场景分析、对象分类和生物统计等各种各样的场景中,因此许多降维算法已经被提出并应用。

本文以降维算法为背景,在仔细了解PCA，KPCA,LLE，ISOMAP，MDS几种降维算法的方法原理和涉及的知识基础后,利用这次模式识别课程设计，并结合资料与课本，动手实践了模式识别的经典降维算法和降维框架。降维算法部分包括各种经典算法的原理、公式推导和算法过程，以及它们在线性降维、流动学习、核方法（监督、无监督和半监督）中的优化算法。经过这次实验，结合课本，我总结以下关于降维的作用：

1.降低时间复杂度和空间复杂度

2.节省了提取不必要特征的开销

3.去掉数据集中夹杂的噪音

4.较简单的模型在小数据集上有更强的鲁棒性

5.当数据能有较少的特征进行解释，我们可以更好的解释数据，使得我们可以提取知识。

    本次课程设计重点是：学习各种降维方法，并将上述方法运用到实际的人脸识别中，在这次实验中，因为对于脸部识别，其维度比较大，如果数据量非常大并且数据维度也非常高，程序运行效率就会很低。我利用了PCA，KPCA,LLE，ISOMAP，MDS降维方法，首先对人脸数据进行降维，其后再使用SVM进行识别。并与降维之前进行对比，效率提升了很多，各种方法对比见下表。

方法	降维时间	训练时间	准确率	Macro-AUC	Micro-AUC
SVM	0.000s	3.370s	0.77	0.936	0.95
SVM+PCA	0.270s	0.364s	0.84	0.951	0.959
SVM+KPCA	0.275s	0.311s	0.78	0.94	0.956
SVM+LLE	16.822s	0.359s	0.83	0.944	0.959
SVM+ISOMAP	10.830s	0.343s	0.63	0.884	0.91
SVM+MDS	13.237s	0.305s	0.28	0.451	0.596

       在这个过程中，结合本案例我总结了以上五种降维方法的优缺点，结合实例，加强印象，锻炼能力，以PCA的优点与局限性为例：

       优点：

1. 易于实现,计算成本较低
2. 不需要了解图像(如:面部特征)

限制：

1. 训练集/测试集需要适当的中心脸
2. 该算法对光照、阴影和图像中的人脸尺度都很敏感
3. 该算法需要正面人脸视图才能正常工作

代码

代码太久了不知道对不对了

1.导入库

1. import matplotlib.pyplot as plt  
2. import numpy as np  
3. from scipy import interp  
4. from sklearn.model_selection import train_test_split  
5. from sklearn.model_selection import GridSearchCV  
6. from sklearn.datasets import fetch_lfw_people  
7. from sklearn.metrics import classification_report  
8. from sklearn.metrics import *  
9. from sklearn.decomposition import PCA, KernelPCA  
10. from sklearn.manifold import LocallyLinearEmbedding, Isomap, MDS  
11. from sklearn.svm import SVC  
12. from sklearn.preprocessing import label_binarize  
13. from time import time  

2.数据处理类

1. # 构建自己的数据集  
2. class my_dataset():  
3.     def __init__(self, min_faces_per_person=70, resize=0.4):  
4.         self.dataset = fetch_lfw_people(min_faces_per_person=min_faces_per_person, resize=resize)  
5.         self.n_samples, self.h, self.w = self.dataset.images.shape  
6.         # 获取图像  
7.         X = self.dataset.data  
8.         # 每个人都有一个标签  
9.         y = self.dataset.target  
10.         # 获取标签对应的名字  
11.         self.target_names = self.dataset.target_names  
12.         self.n_features = X.shape[1]  
13.         self.n_classes = self.target_names.shape[0]  
14.         print("样本数: %d" % self.n_samples)  
15.         print("选择的人物个数: %d" % self.n_classes)  
16.         # 划分训练和测试数据集  
17.         self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(  
18.             X, y, test_size=0.25, random_state=42)  
19.         # print(self.X_train[0])  
20.         # print(self.X_test.shape)  
21.     # 获取训练测试数据  
22.   
23.     def get_data(self):  
24.   
25.         return self.X_train, self.X_test, self.y_train, self.y_test  
26.   
27.     def get_traindata(self):  
28.   
29.         return self.X_train, self.y_train,  
30.   
31.     def get_test_data(self):  
32.         return self.X_test, self.y_test  

3.降维类

1. # 降维类  
2. class my_decomposition():  
3.     def __init__(self, dataset, choice, n_components):  
4.   
5.         self.dataset = dataset  # 数据集  
6.         self.choice = choice  # 选择的降维算法  
7.         self.X_train, self.X_test, self.y_train, self.y_test = self.dataset.get_data()  # 通过数据集获取数据  
8.         self.decom(choice, n_components)  # 构架降维类以后自动将数据降维  
9.   
10.     def decom(self, choice, n_components):  
11.         """ 
12.             对数据集进行降维 
13.         args: 
14.             choice:string 选择的降维算法 
15.             n_components: 维数 
16.         """  
17.         self.choice = choice  
18.         self.n_components = n_components  
19.         t0 = time()  
20.         if self.choice == "pca+svm":  
21.             self.re_model = PCA(n_components=self.n_components, svd_solver='randomized',  
22.                                 whiten=True).fit(self.X_train)  
23.             self.X_train_re = self.re_model.transform(self.X_train)  
24.             self.X_test_re = self.re_model.transform(self.X_test)  
25.         elif self.choice == "mds+svm":  
26.             self.re_model = MDS(n_components=self.n_components,metric=True, n_init=5, max_iter=100, verbose=0,  
27.                                 eps=1e-4, n_jobs=None, random_state=None, dissimilarity="euclidean")  
28.             self.X_train_re = self.re_model.fit_transform(self.X_train)  
29.             self.X_test_re = self.re_model.fit_transform(self.X_test)  
30.         elif self.choice == "kpca+svm":  
31.             self.re_model = KernelPCA(  
32.                 n_components=self.n_components, kernel='cosine').fit(self.X_train)  
33.   
34.             self.X_train_re = self.re_model.transform(self.X_train)  
35.             self.X_test_re = self.re_model.transform(self.X_test)  
36.         elif self.choice == "lle+svm":  
37.             self.re_model = LocallyLinearEmbedding(  
38.                 n_components=self.n_components,  
39.                 n_neighbors=200,  
40.                 neighbors_algorithm='auto').fit(self.X_train)  
41.   
42.             self.X_train_re = self.re_model.transform(self.X_train)  
43.             self.X_test_re = self.re_model.transform(self.X_test)  
44.         elif self.choice == "isomap+svm":  
45.             self.re_model = Isomap(  
46.                 n_components=self.n_components,  
47.                 n_neighbors=200,  
48.                 neighbors_algorithm='auto').fit(self.X_train)  
49.   
50.             self.X_train_re = self.re_model.transform(self.X_train)  
51.             self.X_test_re = self.re_model.transform(self.X_test)  
52.         elif self.choice == "svm":  
53.             self.X_train_re = self.X_train  
54.             self.X_test_re = self.X_test  
55.         self.re_time = time() - t0  
56.     def model_report(self):  
57.         """ 
58.             打印模型耗费的时间等信息 
59.         """  
60.         print("%s降维时间：%0.3fs" % (self.choice,(self.re_time)))  
61.       
62.     def get_X_train_re(self):  
63.         """ 
64.             获取降维后的数据 
65.         """  
66.         return self.X_train_re  
67.   
68.     def get_X_test_re(self):  
69.         return self.X_test_re  

4.SVM类

1. class svm():  
2.     def __init__(self, dataset, decomposition, kernel='rbf', class_weight='balanced'):  
3.         self.dataset = dataset  
4.         self.decomposition = decomposition  
5.         self.target_names = self.dataset.target_names  
6.         self.choice = self.decomposition.choice  
7.         self.n_samples, self.h, self.w = self.dataset.n_samples, self.dataset.h, self.dataset.w  
8.   
9.         self.kernel = kernel  
10.         self.class_weight = class_weight  
11.   
12.         self.X_train, self.X_test, self.y_train, self.y_test = self.dataset.get_data()  
13.         self.X_train_re = self.decomposition.get_X_train_re()  
14.         self.X_test_re = self.decomposition.get_X_test_re()  
15.   
16.     def my_fit(self):  
17.         """ 
18.             模型训练函数 
19.         """  
20.         # 可以选择网格调参  
21.         # param_grid = {'C': [1e3, 5e3, 1e4, 5e4, 1e5],  
22.         #       'gamma': [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.1], }  
23.         # clf = GridSearchCV(  
24.         #         SVC(kernel=self.kernel, class_weight=self.class_weight), param_grid  
25.         #     )  
26.         clf = SVC(kernel=self.kernel, class_weight=self.class_weight)  
27.         t0 = time()  
28.         self.clf = clf.fit(self.X_train_re, self.y_train)  
29.         self.train_time = time() - t0  
30.         # print("训练时间：%0.3fs" % ((time() - t0)))  
31.         return self.clf  
32.   
33.     def my_predict(self):  
34.         """ 
35.             模型预测函数 
36.         """  
37.         self.y_pred = self.clf.predict(self.X_test_re)  
38.         self.titles = [self.title(i) for i in range(self.y_pred.shape[0])]  
39.         return self.y_pred  
40.     def decision_function(self,X_test):  
41.         return self.clf.decision_function(X_test)  
42.           
43.     def model_report(self):  
44.         """ 
45.             打印模型耗费的时间等信息 
46.         """  
47.         print("训练时间：%0.3fs" % ((self.train_time)))  
48.         print("模型性能：")  
49.         print(classification_report(self.y_test,  
50.               self.y_pred, target_names=self.target_names))  
51.   
52.     def plot_gallery(self, plot_type="test", start=0, n_row=3, n_col=4):  
53.         """ 
54.             绘制肖像画廊的函数  
55.         Args: 
56.             plot_type:string 选择绘制预测图还是特征脸（废除，只能绘制肖像图） 
57.             start: 选择绘制图片的起始位置 
58.             n_row: 绘制图片的行数 
59.             n_col: 绘制图片的列数 
60.         """  
61.         plt.figure(self.choice, figsize=(1.8 * n_col, 2.4 * n_row))  
62.         plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)  
63.         if plot_type == "test":  
64.             images = self.X_test  
65.             titles = self.titles  
66.         elif plot_type == "eigenface":  
67.             images = self.eigenfaces  
68.             titles = ["eigenface %d" % i for i in range(images.shape[0])]  
69.         elif plot_type == "train":  
70.             images = self.X_train  
71.             # titles = self.titles  
72.         for i in range(n_row * n_col):  
73.             plt.subplot(n_row, n_col, i + 1)  
74.             plt.imshow(  
75.                 images[i+start].reshape((self.h, self.w)), cmap=plt.cm.gray)  
76.             # plt.title(titles[i+start], size=12)  
77.             plt.xticks(())  
78.             plt.yticks(())  
79.         plt.show()  
80.   
81.     def title(self, i):  
82.         """ 
83.             为plot_gallery函数提供帮助 
84.         """  
85.         pred_name = self.target_names[self.y_pred[i]].rsplit(' ', 1)[-1]  
86.         true_name = self.target_names[self.y_test[i]].rsplit(' ', 1)[-1]  
87.         return 'predicted: %s\ntrue:      %s' % (pred_name, true_name)  

5.绘制参数与模型性能函数

1. def create_model(dataset, choice, components):  
2.     decomposition = my_decomposition(dataset, choice, components)  
3.     my_svc = svm(dataset, decomposition, kernel='rbf', class_weight='balanced')  
4.     my_svc.my_fit()  
5.     return my_svc  
6.   
7.   
8. def acc_components(dataset, choice):  
9.     """ 
10.         绘制特征数和精度的关系，选择最好的特征数 
11.     """  
12.     total_acc = []  
13.     acc_dict = {}  
14.     for j in range(1, 150+1):  
15.         decomposition = my_decomposition(dataset, choice, j)  
16.         my_svc = svm(dataset, decomposition, kernel='rbf',  
17.                      class_weight='balanced')  
18.         my_svc.my_fit()  
19.         y_pred = my_svc.my_predict()  
20.         y_true = my_svc.y_test  
21.         total_acc.append(accuracy_score(y_true, y_pred))  
22.         print(choice, "  ", j)  
23.     return total_acc  
24.   
25.   
26. def plot_acc_components(my_dataset):  
27.     """ 
28.         基于多个降维算法，绘制特征数和精度的关系，选择最好的特征数 
29.     """  
30.     acc_pca = acc_components(my_dataset, "pca")  
31.     acc_kpca = acc_components(my_dataset, "kpca")  
32.     acc_mds = acc_components(my_dataset, "mds")  
33.     acc_lle = acc_components(my_dataset, "lle")  
34.     acc_isomap = acc_components(my_dataset, "isomap")  
35.   
36.     x = range(1, (len(acc_pca)+1))  
37.     plt.figure()  
38.     # 去除顶部和右边框框  
39.     ax = plt.axes()  
40.     ax.spines['top'].set_visible(False)  
41.     ax.spines['right'].set_visible(False)  
42.   
43.     plt.xlabel('components')    # x轴标签  
44.     plt.ylabel('accuracy')     # y轴标签  
45.   
46.     # 以x_train_loss为横坐标，y_train_loss为纵坐标，曲线宽度为1，实线，增加标签，训练损失，  
47.     # 默认颜色，如果想更改颜色，可以增加参数color='red',这是红色。  
48.     plt.plot(x, acc_pca, linewidth=1, linestyle="solid", label="PCA")  
49.     plt.plot(x, acc_kpca, linewidth=1, linestyle="solid", label="KPCA")  
50.     plt.plot(x, acc_mds, linewidth=1, linestyle="solid", label="MDS")  
51.     plt.plot(x, acc_lle, linewidth=1, linestyle="solid", label="LLE")  
52.     plt.plot(x, acc_isomap, linewidth=1, linestyle="solid", label="ISOMAP")  
53.   
54.     plt.legend()  
55.     plt.title('accuracy curve')  
56.     plt.savefig("./模式识别课设/filename.png")  
57.     # plt.show()  

6.绘制ROC曲线

1. def plot_Macro_roc(dataset,choices,colors,components=150,save=True, dpin=100):  
2.     """ 
3.         将使用多个降维算法的模型的roc图输出到一张图上 
4.      
5.     Args: 
6.         choice: list, 多个模型的名称 
7.         sampling_methods: list, 多个模型的实例化对象 
8.         save: 选择是否将结果保存（默认为png格式） 
9.          
10.     Returns: 
11.         返回图片对象plt 
12.     """  
13.     n_classes = dataset.n_classes  
14.     plt.figure(figsize=(20, 20), dpi=dpin)  
15.     # 计算每个类别的ROC曲线和AUC面积  
16.     fpr = dict()  
17.     tpr = dict()  
18.     roc_auc = dict()  
19.     for (choice, colorname) in zip(choices, colors):  
20.         print(choice)  
21.         model = create_model(dataset, choice, components)  
22.         y_test = model.y_test  
23.         y_test = label_binarize(y_test,classes=range(n_classes))  
24.         X_test = model.X_test_re  
25.         y_scores = model.decision_function(X_test)  
26.         # print(y_test.shape)  
27.         # print(y_scores.shape)  
28.         # print(X_test)  
29.         for i in range(n_classes):  
30.               
31.             fpr[i], tpr[i], _ = roc_curve(y_test[:,i], y_scores[:, i])  
32.             roc_auc[i] = auc(fpr[i], tpr[i])  
33.         # 首先收集所有的假正率  
34.         all_fpr = np.unique(np.concatenate([fpr[i] for i in range(n_classes)]))  
35.   
36.         # 然后在此点内插所有ROC曲线  
37.         mean_tpr = np.zeros_like(all_fpr)  
38.         for i in range(n_classes):  
39.             mean_tpr += interp(all_fpr, fpr[i], tpr[i])  
40.   
41.         # 最终计算平均和ROC  
42.         mean_tpr /= n_classes  
43.         fpr["macro"] = all_fpr  
44.         tpr["macro"] = mean_tpr  
45.         roc_auc["macro"] = auc(fpr["macro"], tpr["macro"])  
46.         plt.plot(fpr["macro"], tpr["macro"], lw=5, label='{} (AUC={:.3f})'.format(choice, roc_auc["macro"]),color = colorname)  
47.       
48.       
49.     # 绘制对角线  
50.     plt.plot([0, 1], [0, 1], '--', lw=5, color = 'grey')  
51.     plt.axis('square')  
52.     plt.xlim([0, 1])  
53.     plt.ylim([0, 1])  
54.     plt.xlabel('False Positive Rate',fontsize=20)  
55.     plt.ylabel('True Positive Rate',fontsize=20)  
56.     plt.title('Macro-averaged One-vs-Rest \n Receiver Operating Characteristic',fontsize=25)  
57.     plt.legend(loc='lower right',fontsize=20)  
58.     if save:  
59.         plt.savefig('Macro Curve.png')  
60.           
61.     return plt  
62.   
63. def plot_Micro_roc(dataset,choices,colors,components=150,save=True, dpin=100):  
64.     """ 
65.         将使用多个降维算法的模型的roc图输出到一张图上 
66.      
67.     Args: 
68.         choice: list, 多个模型的名称 
69.         sampling_methods: list, 多个模型的实例化对象 
70.         save: 选择是否将结果保存（默认为png格式） 
71.          
72.     Returns: 
73.         返回图片对象plt 
74.     """  
75.     n_classes = dataset.n_classes  
76.     plt.figure(figsize=(20, 20), dpi=dpin)  
77.     # 计算每个类别的ROC曲线和AUC面积  
78.     fpr = dict()  
79.     tpr = dict()  
80.     roc_auc = dict()  
81.     for (choice, colorname) in zip(choices, colors):  
82.         print(choice)  
83.         model = create_model(dataset, choice, components)  
84.         y_test = model.y_test  
85.         y_test = label_binarize(y_test,classes=range(n_classes))  
86.         X_test = model.X_test_re  
87.         y_scores = model.decision_function(X_test)  
88.   
89.         # 计算ROC曲线和AUC面积的微观平均（micro-averaging）  
90.         fpr["micro"], tpr["micro"], _ = roc_curve(y_test.ravel(), y_scores.ravel())  
91.         roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])  
92.         plt.plot(fpr["micro"], tpr["micro"], lw=5, label='{} (AUC={:.3f})'.format(choice, roc_auc["micro"]),color = colorname)  
93.   
94.       
95.     # 绘制对角线  
96.     plt.plot([0, 1], [0, 1], '--', lw=5, color = 'grey')  
97.     plt.axis('square')  
98.     plt.xlim([0, 1])  
99.     plt.ylim([0, 1])  
100.     plt.xlabel('False Positive Rate',fontsize=20)  
101.     plt.ylabel('True Positive Rate',fontsize=20)  
102.     plt.title('Micro-averaged One-vs-Rest \n Receiver Operating Characteristic',fontsize=25)  
103.     plt.legend(loc='lower right',fontsize=20)  
104.     if save:  
105.         plt.savefig('Micro Curve.png')  
106.           
107.     return plt  

7.主函数设计

1. choices = ["pca+svm",  
2.            "kpca+svm",  
3.            "lle+svm",  
4.            "isomap+svm",  
5.            "mds+svm",  
6.            'svm'  
7.            ]  
8. colors = ['crimson',  
9.           'orange',  
10.           'gold',  
11.           'mediumseagreen',  
12.           'steelblue',  
13.           'red'  
14.          ]  
15. choice, n_components = "pca+svm", 150  
16.   
17. # min_faces_per_person每个人至少选取x张图像  
18. my_dataset = my_dataset(min_faces_per_person=70, resize=0.4)  
19. ## 绘制指标图  
20. plot_Macro_roc(my_dataset,choices,colors)  
21. plot_Micro_roc(my_dataset,choices,colors)  
22. ## 绘制维数参数与准确率关系  
23. plot_acc_components(my_dataset)  
24. # 绘制样本图  
25. my_decomposition = my_decomposition(my_dataset,choice,n_components)  
26. my_svc = svm(my_dataset,my_decomposition,kernel='rbf', class_weight='balanced')  
27. my_svc.my_fit()  
28. my_svc.plot_gallery(plot_type="train",start=0,n_row=4, n_col=4)  
29.   
30. # my_decomposition = my_decomposition(my_dataset,choice,n_components)  
31. # my_svc = svm(my_dataset,my_decomposition,kernel='rbf', class_weight='balanced')  
32. t0 = time()  
33. # PCA降维  
34. my_svc.my_fit()  
35. # print("经过PCA降维训练时间 %0.3fs" % (time() - t0))  
36. y_pred = my_svc.my_predict()  
37. my_svc.model_report()  
38. my_decomposition.model_report()  
39. # 画测试结果  
40. my_svc.plot_gallery(plot_type="test",start=0,n_row=4, n_col=4)  
41. plt.show()  
42.   
43.   
44. t0 = time()  
45. # KPCA降维  
46. my_svc.my_fit(n_components=150,choice="kpca")  
47. y_pred = my_svc.my_predict()  
48. # print("经过KPCA降维训练时间 %0.3fs" % (time() - t0))  
49. # 画测试结果  
50. my_svc.plot_gallery(plot_type="test",start=50,n_row=4, n_col=4)  
51. plt.show()  
52.   
53. t0 = time()  
54. # lle降维  
55. my_svc.my_fit(n_components=150,choice="lle")  
56. # print("经过LLE降维训练时间 %0.3fs" % (time() - t0))  
57. y_pred = my_svc.my_predict()  
58. # 画测试结果  
59. my_svc.plot_gallery(plot_type="test",start=50,n_row=4, n_col=4)  
60. plt.show()  
61.   
62. t0 = time()  
63. # isomap降维  
64. my_svc.my_fit(n_components=150,choice="isomap")  
65. # print("经过ISOMAP降维训练时间 %0.3fs" % (time() - t0))  
66. y_pred = my_svc.my_predict()  
67. # 画测试结果  
68. my_svc.plot_gallery(plot_type="test",start=50,n_row=4, n_col=4)  
69. plt.show()  
70.   
71. t0 = time()  
72. # mds降维  
73. my_svc.my_fit(n_components=150,choice="mds")  
74. # print("经过ISOMAP降维训练时间 %0.3fs" % (time() - t0))  
75. y_pred = my_svc.my_predict()  
76. # 画测试结果  
77. my_svc.plot_gallery(plot_type="test",start=50,n_row=4, n_col=4)  
78. plt.show()