sklearn学习笔记1

Image recognition with Support Vector Machines

#our dataset is provided within scikit-learn
#let's start by importing and printing its description
import sklearn as sk
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_olivetti_faces
faces = fetch_olivetti_faces()
print(faces.DESCR)

Modified Olivetti faces dataset. The original database was available from (now defunct)

http://www.uk.research.att.com/facedatabase.html

The version retrieved here comes in MATLAB format from the personal web page of Sam Roweis:

http://www.cs.nyu.edu/~roweis/

There are ten different images of each of 40 distinct subjects. For some subjects, the images were taken at different times, varying the lighting, facial expressions (open / closed eyes, smiling / not smiling) and facial details (glasses / no glasses). All the images were taken against a dark homogeneous background with the subjects in an upright, frontal position (with tolerance for some side movement). The original dataset consisted of 92 x 112, while the Roweis version consists of 64x64 images.

print(faces.keys())
print(faces.images.shape)
print(faces.data.shape)
print(faces.target.shape)

print(np.max(faces.data))
print(np.min(faces.data))
print(np.mean(faces.data))

Before learning, let’s plot some faces.

def print_faces(images, target, top_n):
    #set up the figure size in inches
    fig = plt.figure(figsize=(12, 12))
    fig.subplots_adjust(left = 0, right = 1, bottom = 0, top = 1, hspace = 0.05,wspace = 0.05)
    for i in range(top_n):
        #plot the images in a matrix of 20x20
        p = fig.add_subplot(20, 20, i + 1, xticks = [], yticks = [])
        p.imshow(images[i], cmap = plt.cm.bone)
        #label the image with target value
        p.text(0, 14, str(target[i]))
        p.text(0, 60, str(i))

If we print the first 20 images, we can see faces from two faces.(但是不知道为什么，打印不出图片)

print_faces(faces.images, faces.target, 20)

Training a Support Vector machine

Import the SVC class from the sklearn.svm module:

from sklearn.svm import SVC
To start, we will use the simplest kernel, the linear one

svc_1 = SVC(kernel = 'linear')

Before continuing, we will split our dataset into training and testing datasets.

from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(faces.data,faces.target, test_size = 0.25, random_state = 0)

And we will define a function to evaluate K-fold cross-validation.

from sklearn.cross_validation import cross_val_score, KFold
from scipy.stats import sem
def evaluate_cross_validation(clf, X, y, K):
    #create a k-fold cross validation iterator
    cv = KFold(len(y), K, shuffle=True, random_state=0)
    #by default the score used is the one return by score method of the estimator (accuracy)
    scores = cross_val_score(clf, X, y, cv = cv)
    print(scores)
    print(("Mean score: {0: .3f} (+/-{1: .3f})").format(np.mean(scores), sem(scores)))
evaluate_cross_validation(svc_1, X_train, y_train, 5)

[ 0.93333333  0.86666667  0.91666667  0.93333333  0.91666667]
Mean score:  0.913 (+/- 0.012)

We will also define a function to perform training on the training set and evaluate the performance on the testing set.

from sklearn import metrics
def train_and_evaluate(clf, X_train, X_test, y_train, y_test):
    clf.fit(X_train, y_train)
    print("Accuracy on training set:")
    print(clf.score(X_train, y_train))
    print("Accuracy on testing set:")
    print(clf.score(X_test, y_test))

    y_pred = clf.predict(X_test)

    print("Classification Report:")
    print(metrics.classification_report(y_test, y_pred))
    print("Confusion Matrix:")
    print(metrics.confusion_matrix(y_test, y_pred))
train_and_evaluate(svc_1, X_train, X_test, y_train, y_test)

Accuracy on training set: 1.0 Accuracy on testing set: 0.99

classify the faces as people with and without glasses

First thing to do is to defne the range of the images that show faces wearing glasses.
The following list shows the indexes of these images:

# the index ranges of images of people with glasses
glasses = [
(10, 19), (30, 32), (37, 38), (50, 59), (63, 64),
(69, 69), (120, 121), (124, 129), (130, 139), (160, 161),
(164, 169), (180, 182), (185, 185), (189, 189), (190, 192),
(194, 194), (196, 199), (260, 269), (270, 279), (300, 309),
(330, 339), (358, 359), (360, 369)
]

Then we'll defne a function that from those segments returns a new target array that marks with 1 for the faces with glasses and 0 for the faces without glasses (our new target classes):

def create_target(segments):
    # create a new y array of target size initialized with zeros
    y = np.zeros(faces.target.shape[0])
    # put 1 in the specified segments
    for (start, end) in segments:
        y[start:end + 1] = 1
    return y
target_glasses = create_target(glasses)

So we must perform the training/testing split again.

X_train, X_test, y_train, y_test = train_test_split(faces.data, target_glasses, test_size=0.25, random_state=0)

Now let's create a new SVC classifer, and train it with the new target vector using the following command:

svc_2 = SVC(kernel='linear')

If we check the performance with cross-validation by the following code:

evaluate_cross_validation(svc_2, X_train, y_train, 5)

[ 1.          0.95        0.98333333  0.98333333  0.93333333]
Mean score:  0.970 (+/- 0.012)

We obtain a mean accuracy of 0.970 with cross-validation if we evaluate on our testing set.

 train_and_evaluate(svc_2, X_train, X_test, y_train, y_test)

Accuracy on training set:
1.0
Accuracy on testing set:
0.99
Classification Report:
             precision    recall  f1-score   support

        0.0       1.00      0.99      0.99        67
        1.0       0.97      1.00      0.99        33

avg / total       0.99      0.99      0.99       100

Confusion Matrix:
[[66  1]
 [ 0 33]]

Could it be possible that our classifer has learned to identify peoples' faces associated with glasses and without glasses precisely? How can we be sure that this is not happening and that if we get new unseen faces, it will work as expected? Let's separate all the images of the same person, sometimes wearing glasses and sometimes not. We will also separate all the images of the same person, the ones with indexes from 30 to 39, train by using the remaining instances, and evaluate on our new 10 instances set. With this experiment we will try to discard the fact that it is remembering faces, not glassed-related features.

X_test = faces.data[30:40]
y_test = target_glasses[30:40]
print(y_test.shape[0])
select = np.ones(target_glasses.shape[0])
select[30:40] = 0
X_train = faces.data[select == 1]
y_train = target_glasses[select == 1]
print(y_train.shape[0])
svc_3 = SVC(kernel='linear')
train_and_evaluate(svc_3, X_train, X_test, y_train, y_test)

10
390
Accuracy on training set:
1.0
Accuracy on testing set:
0.9
Classification Report:
             precision    recall  f1-score   support

        0.0       0.83      1.00      0.91         5
        1.0       1.00      0.80      0.89         5

avg / total       0.92      0.90      0.90        10

Confusion Matrix:
[[5 0]
 [1 4]]

From the 10 images, only one error, still pretty good results, let's check out which one was incorrectly classifed. First, we have to reshape the data from arrays to 64 x 64 matrices:

y_pred = svc_3.predict(X_test)
eval_faces = [np.reshape(a, (64, 64)) for a in X_test]

Then plot with our print_faces function:

print_faces(eval_faces, y_pred, 10)

The image number 8 in the preceding fgure has glasses and was classifed as no glasses. If we look at that instance, we can see that it is different from the rest of the images with glasses (the border of the glasses cannot be seen clearly and the person is shown with closed eyes), which could be the reason it has been misclassifed.