利用Python sklearn的SVM对AT&T人脸数据进行人脸识别

要求：使用10-fold交叉验证方法实现SVM的对人脸库识别，列出不同核函数参数对识别结果的影响，要求画对比曲线。

使用Python完成，主要参考文献【4】，其中遇到不懂的功能函数一个一个的查官方文档和相关资料。其中包含了使用Python画图，遍历文件，读取图片，PCA降维，SVM，交叉验证等知识。

0.数据说明预处理

下载AT&T人脸数据（http://www.cl.cam.ac.uk/research/dtg/attarchive/facedatabase.html），解压缩后为40个文件夹，每个文件夹是一个人的10张人脸照片。使用Python的glob库和PIL的Image读取照片，并转化为一维向量。这里需要注意，glob并非按照顺序读取，所以需要按照文件夹一个人一个人的读取数据，并标记对应分类。

PICTURE_PATH = u"F:\att_faces"

all_data_set = [] #原始总数据集，二维矩阵n*m，n个样例，m个属性
all_data_label = [] #总数据对应的类标签
def get_picture():
    label = 1
    #读取所有图片并一维化
    while (label <= 20):
        for name in glob.glob(PICTURE_PATH + "\s" + str(label) + "\*.pgm"):
            img = Image.open(name)
            #img.getdata()
            #np.array(img).reshape(1, 92*112)
            all_data_set.append( list(img.getdata()) )
            all_data_label.append(label)
        label += 1

get_picture()

1.PCA降维

获得原始数据后，对数据使用PCA降维处理，其中设定降维后的特征数目时遇到了问题，参考资料中n_components设定为150，但是该数据集采用大的该值后识别率会非常低，即虽然可以百分百识别出训练集人脸，但无法预测识别出新的脸，发生了过拟合（？）。经过把参数n_components设置为16后，产生了非常好的结果。PCA降维后数据的维数取多少比较好？有什么标准判断？注意，若维数较高，SVM训练会非常慢并且占用很高内存，维数小反而取得了很好的结果和效率。

另外，例子中是分别对测试集与训练集使用PCA降维，即PCA fit时只用了训练集。将数据转换为numpy的array类型是为了后面编程方便。

n_components = 16#这个降维后的特征值个数如果太大，比如100，结果将极其不准确，为何？？
pca = PCA(n_components = n_components, svd_solver='auto', 
          whiten=True).fit(all_data_set)
#PCA降维后的总数据集
all_data_pca = pca.transform(all_data_set)
#X为降维后的数据，y是对应类标签
X = np.array(all_data_pca)
y = np.array(all_data_label)

2. SVM训练与识别

对降维后的数据进行训练与识别。

#输入核函数名称和参数gamma值，返回SVM训练十折交叉验证的准确率
def SVM(kernel_name, param):
    #十折交叉验证计算出平均准确率
    #n_splits交叉验证，随机取
    kf = KFold(n_splits=10, shuffle = True)
    precision_average = 0.0
    param_grid = {'C': [1e3, 5e3, 1e4, 5e4, 1e5]}#自动穷举出最优的C参数
    clf = GridSearchCV(SVC(kernel=kernel_name, class_weight='balanced', gamma = param),
                       param_grid)
    for train, test in kf.split(X):
        clf = clf.fit(X[train], y[train])
        #print(clf.best_estimator_)
        test_pred = clf.predict(X[test])
        #print classification_report(y[test], test_pred)
        #计算平均准确率
        precision = 0
        for i in range(0, len(y[test])):
            if (y[test][i] == test_pred[i]):
                precision = precision + 1
        precision_average = precision_average + float(precision)/len(y[test])
    precision_average = precision_average / 10    
    #print (u"准确率为" + str(precision_average))
    return precision_average

3.主程序，设置不同参数对比分析

根据例子中的gamma值选择，发现其可以从非常小开始，即0.0001，经过人工实验，到1时rbf kernel出现了较差的结果，所以画图对比时在0.0001至1之间取100个点，因为点多后程序运行会非常慢。程序中的x_label即枚举的gamma参数值。为了节省时间，数据只选择了前20个人，最终执行时间为366.672秒。

t0 = time()    
kernel_to_test = ['rbf', 'poly', 'sigmoid']
#rint SVM(kernel_to_test[0], 0.1)
plt.figure(1)

for kernel_name in kernel_to_test:
    x_label = np.linspace(0.0001, 1, 100)
    y_label = []
    for i in x_label:
        y_label.append(SVM(kernel_name, i))
    plt.plot(x_label, y_label, label=kernel_name)
    
         
print("done in %0.3fs" % (time() - t0))    
plt.xlabel("Gamma")
plt.ylabel("Precision")
plt.title('Different Kernels Contrust') 
plt.legend()
plt.show()    
    
    

 

Figure 1 不同核函数不同参数识别率对比图

参考：

[1] Philipp Wagner.Face Recognition with Python. July 18, 2012

[2] Chih-Wei Hsu, Chih-Chung Chang, and Chih-Jen Lin. A Practical Guide to Support Vector Classication. National Taiwan University, Taipei 106, Taiwan.

[3] http://www.cnblogs.com/cvlabs/archive/2010/04/13/1711470.html

[4]http://scikit-learn.org/stable/auto_examples/applications/face_recognition.html#sphx-glr-auto-examples-applications-face-recognition-py

[5] http://blog.csdn.net/ikerpeng/article/details/20370041

附录完整代码：

# -*- coding: utf-8 -*-
"""
Created on Fri Dec 02 15:51:14 2016

@author: JiaY
"""
from time import time
from PIL import Image
import glob
import numpy as np
import sys
from sklearn.model_selection import KFold
from sklearn.model_selection import train_test_split
from sklearn.decomposition import PCA
from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC
from sklearn.metrics import classification_report
import matplotlib.pyplot as plt

#设置解释器为utf8编码，不知为何文件开头的注释没用。
#尽管这样设置，在IPython下仍然会出错，只能用原装Python解释器执行本程序
reload(sys)
sys.setdefaultencoding("utf8")
print sys.getdefaultencoding()

PICTURE_PATH = u"F:\课程相关资料\研究生——数据挖掘\16年作业\att_faces"

all_data_set = [] #原始总数据集，二维矩阵n*m，n个样例，m个属性
all_data_label = [] #总数据对应的类标签
def get_picture():
    label = 1
    #读取所有图片并一维化
    while (label <= 20):
        for name in glob.glob(PICTURE_PATH + "\s" + str(label) + "\*.pgm"):
            img = Image.open(name)
            #img.getdata()
            #np.array(img).reshape(1, 92*112)
            all_data_set.append( list(img.getdata()) )
            all_data_label.append(label)
        label += 1

get_picture()

n_components = 16#这个降维后的特征值个数如果太大，比如100，结果将极其不准确，为何？？
pca = PCA(n_components = n_components, svd_solver='auto', 
          whiten=True).fit(all_data_set)
#PCA降维后的总数据集
all_data_pca = pca.transform(all_data_set)
#X为降维后的数据，y是对应类标签
X = np.array(all_data_pca)
y = np.array(all_data_label)


#输入核函数名称和参数gamma值，返回SVM训练十折交叉验证的准确率
def SVM(kernel_name, param):
    #十折交叉验证计算出平均准确率
    #n_splits交叉验证，随机取
    kf = KFold(n_splits=10, shuffle = True)
    precision_average = 0.0
    param_grid = {'C': [1e3, 5e3, 1e4, 5e4, 1e5]}#自动穷举出最优的C参数
    clf = GridSearchCV(SVC(kernel=kernel_name, class_weight='balanced', gamma = param),
                       param_grid)
    for train, test in kf.split(X):
        clf = clf.fit(X[train], y[train])
        #print(clf.best_estimator_)
        test_pred = clf.predict(X[test])
        #print classification_report(y[test], test_pred)
        #计算平均准确率
        precision = 0
        for i in range(0, len(y[test])):
            if (y[test][i] == test_pred[i]):
                precision = precision + 1
        precision_average = precision_average + float(precision)/len(y[test])
    precision_average = precision_average / 10    
    #print (u"准确率为" + str(precision_average))
    return precision_average

t0 = time()    
kernel_to_test = ['rbf', 'poly', 'sigmoid']
#rint SVM(kernel_to_test[0], 0.1)
plt.figure(1)

for kernel_name in kernel_to_test:
    x_label = np.linspace(0.0001, 1, 100)
    y_label = []
    for i in x_label:
        y_label.append(SVM(kernel_name, i))
    plt.plot(x_label, y_label, label=kernel_name)
    
         
print("done in %0.3fs" % (time() - t0))    
plt.xlabel("Gamma")
plt.ylabel("Precision")
plt.title('Different Kernels Contrust') 
plt.legend()
plt.show()    
    
    
    
"""
clf = GridSearchCV(SVC(kernel='rbf', class_weight='balanced'), param_grid)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.1, random_state=42)
clf = clf.fit(X_train, y_train)
test_pred = clf.predict(X_test)
print classification_report(y_test, test_pred)

#十折交叉验证计算出平均准确率
precision_average = 0.0
for train, test in kf.split(X):
    clf = clf.fit(X[train], y[train])
    #print(clf.best_estimator_)
    test_pred = clf.predict(X[test])
    #print classification_report(y[test], test_pred)
    #计算平均准确率
    precision = 0
    for i in range(0, len(y[test])):
        if (y[test][i] == test_pred[i]):
            precision = precision + 1
    precision_average = precision_average + float(precision)/len(y[test])
precision_average = precision_average / 10    
print ("准确率为" + str(precision_average))
print("done in %0.3fs" % (time() - t0))
"""
"""               
print("Fitting the classifier to the training set")
t0 = time()
param_grid = {'C': [1e3, 5e3, 1e4, 5e4, 1e5],
              'gamma': [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.1], }
clf = GridSearchCV(SVC(kernel='rbf', class_weight='balanced'), param_grid)
clf = clf.fit(all_data_pca, all_data_label)
print("done in %0.3fs" % (time() - t0))
print("Best estimator found by grid search:")
print(clf.best_estimator_)
all_data_set_pred = clf.predict(all_data_pca)
#target_names = range(1, 11)
print(classification_report(all_data_set_pred, all_data_label))
"""