Examples for Chapter 8

Author: jesolem

examples/ch8_bayes_points.py

@@ -0,0 +1,43 @@
+from pylab import *
+from numpy import *
+import pickle
+
+from PCV.classifiers import bayes
+from PCV.tools import imtools
+
+"""
+This is the simple 2D classification example in Section 8.2
+using Bayes classifier.
+
+If you have created the data files, it will reproduce the plot
+in Figure 8-4.
+"""
+
+
+# load 2D points using Pickle
+with open('../data/points_normal.pkl', 'r') as f:
+    class_1 = pickle.load(f)
+    class_2 = pickle.load(f)
+    labels = pickle.load(f)
+
+# train Bayes classifier
+bc = bayes.BayesClassifier()
+bc.train([class_1,class_2], [1,-1])
+
+# load test data using Pickle
+with open('../data/points_normal_test.pkl', 'r') as f:
+    class_1 = pickle.load(f)
+    class_2 = pickle.load(f)
+    labels = pickle.load(f)
+
+# test on the 10 first points
+print bc.classify(class_1[:10])[0]
+
+# define function for plotting
+def classify(x, y, bc=bc):
+    points = vstack((x,y))
+    return bc.classify(points.T)[0]
+
+# plot the classification boundary
+imtools.plot_2D_boundary([-6,6,-6,6], [class_1,class_2], classify, [1,-1])
+show()

examples/ch8_dsift.py

@@ -0,0 +1 @@
+from PIL import Imagefrom pylab import *from numpy import *from PCV.localdescriptors import dsift, sift"""This is the dense SIFT illustration, it will reproduce the plotin Figure 8-2."""dsift.process_image_dsift('../data/empire.jpg', 'empire.sift', 90, 40, True)l,d = sift.read_features_from_file('empire.sift')im = array(Image.open('../data/empire.jpg'))sift.plot_features(im, l, True)show()

examples/ch8_generate_dataset.py

@@ -0,0 +1,72 @@
+from numpy import *
+from numpy.random import randn
+import pickle
+
+"""
+This generates the 2D point data sets used in chapter 8.
+
+(both training and test)
+"""
+
+###
+# Training data
+###
+
+# create sample data of 2D points
+n = 200
+
+# two normal distributions
+class_1 = 0.6 * randn(n,2)
+class_2 = 1.2 * randn(n,2) + array([5,1])
+labels = hstack((ones(n),-ones(n)))
+
+# save with Pickle
+with open('../data/points_normal.pkl', 'w') as f:
+    pickle.dump(class_1,f)
+    pickle.dump(class_2,f)
+    pickle.dump(labels,f)
+
+# normal distribution and ring around it
+class_1 = 0.6 * randn(n,2)
+r = 0.8 * randn(n,1) + 5
+angle = 2*pi * randn(n,1)
+class_2 = hstack((r*cos(angle),r*sin(angle)))
+labels = hstack((ones(n),-ones(n)))
+
+# save with Pickle
+with open('../data/points_ring.pkl', 'w') as f:
+    pickle.dump(class_1,f)
+    pickle.dump(class_2,f)
+    pickle.dump(labels,f)
+
+
+###
+# Test data
+###
+
+# create sample data of 2D points
+n = 200
+
+# two normal distributions
+class_1 = 0.6 * randn(n,2)
+class_2 = 1.2 * randn(n,2) + array([5,1])
+labels = hstack((ones(n),-ones(n)))
+
+# save with Pickle
+with open('../data/points_normal_test.pkl', 'w') as f:
+    pickle.dump(class_1,f)
+    pickle.dump(class_2,f)
+    pickle.dump(labels,f)
+
+# normal distribution and ring around it
+class_1 = 0.6 * randn(n,2)
+r = 0.8 * randn(n,1) + 5
+angle = 2*pi * randn(n,1)
+class_2 = hstack((r*cos(angle),r*sin(angle)))
+labels = hstack((ones(n),-ones(n)))
+
+# save with Pickle
+with open('../data/points_ring_test.pkl', 'w') as f:
+    pickle.dump(class_1,f)
+    pickle.dump(class_2,f)
+    pickle.dump(labels,f)

examples/ch8_gesture_recognition.py

@@ -0,0 +1,134 @@
+from PIL import Image
+from numpy import *
+from pylab import *
+
+from svmutil import *
+import os
+
+from PCV.classifiers import knn, bayes
+from PCV.tools import imtools
+from PCV.localdescriptors import dsift, sift
+
+
+"""
+This script collects the three classifiers applied to the hand gesture
+recognition test.
+
+If you have created the data files with the dsift features, this will
+reproduce all confucion matrices in Chapter 8.
+
+Use the if statements at the bottom to turn on/off different combinations.
+"""
+
+
+def read_gesture_features_labels(path):
+    # create list of all files ending in .dsift
+    featlist = [os.path.join(path,f) for f in os.listdir(path) if f.endswith('.dsift')]
+
+    # read the features
+    features = []
+    for featfile in featlist:
+        l,d = sift.read_features_from_file(featfile)
+        features.append(d.flatten())
+    features = array(features)
+
+    # create labels
+    labels = [featfile.split('/')[-1][0] for featfile in featlist]
+
+    return features,array(labels)
+
+
+def convert_labels(labels,transl):
+    """ Convert between strings and numbers. """
+    return [transl[l] for l in labels]
+
+
+def print_confusion(res,labels,classnames):
+
+    n = len(classnames)
+
+    # confusion matrix
+    class_ind = dict([(classnames[i],i) for i in range(n)])
+
+    confuse = zeros((n,n))
+    for i in range(len(test_labels)):
+        confuse[class_ind[res[i]],class_ind[test_labels[i]]] += 1
+
+    print 'Confusion matrix for'
+    print classnames
+    print confuse
+
+
+# read training data
+####################
+features,labels = read_gesture_features_labels('../data/hand_gesture/train/')
+print 'training data is:', features.shape, len(labels)
+
+# read test data
+####################
+test_features,test_labels = read_gesture_features_labels('../data/hand_gesture/test/')
+print 'test data is:', test_features.shape, len(test_labels)
+
+classnames = unique(labels)
+nbr_classes = len(classnames)
+
+
+if False:
+    # reduce dimensions with PCA
+    from PCV.tools import pca
+
+    V,S,m = pca.pca(features)
+
+    # keep most important dimensions
+    V = V[:50]
+    features = array([dot(V,f-m) for f in features])
+    test_features = array([dot(V,f-m) for f in test_features])
+
+
+if True:
+    # test kNN
+    k = 1
+    knn_classifier = knn.KnnClassifier(labels,features)
+    res = array([knn_classifier.classify(test_features[i],k) for i in range(len(test_labels))]) # TODO kan goras battre
+
+
+if False:
+    # test Bayes
+    bc = bayes.BayesClassifier()
+    blist = [features[where(labels==c)[0]] for c in classnames]
+
+    bc.train(blist,classnames)
+    res = bc.classify(test_features)[0]
+
+
+if False:
+    # test SVM
+    # convert to lists for libsvm
+    features = map(list,features)
+    test_features = map(list,test_features)
+
+    # create conversion function for the labels
+    transl = {}
+    for i,c in enumerate(classnames):
+        transl[c],transl[i] = i,c
+
+    # create SVM
+    prob = svm_problem(convert_labels(labels,transl),features)
+    param = svm_parameter('-t 0')
+
+    # train SVM on data
+    m = svm_train(prob,param)
+
+    # how did the training do?
+    res = svm_predict(convert_labels(labels,transl),features,m)
+
+    # test the SVM
+    res = svm_predict(convert_labels(test_labels,transl),test_features,m)[0]
+    res = convert_labels(res,transl)
+
+
+# accuracy
+acc = sum(1.0*(res==test_labels)) / len(test_labels)
+print 'Accuracy:', acc
+
+print_confusion(res,test_labels,classnames)

examples/ch8_knn_points.py

@@ -0,0 +1,39 @@
+from pylab import *
+from numpy import *
+import pickle
+
+from PCV.classifiers import knn
+from PCV.tools import imtools
+
+"""
+This is the simple 2D classification example in Section 8.1.
+
+If you have created the data files, it will reproduce the plot
+in Figure 8-1.
+"""
+
+
+# load 2D points using Pickle
+with open('../data/points_normal.pkl', 'r') as f:
+    class_1 = pickle.load(f)
+    class_2 = pickle.load(f)
+    labels = pickle.load(f)
+
+model = knn.KnnClassifier(labels,vstack((class_1,class_2)))
+
+# load test data using Pickle
+with open('../data/points_normal_test.pkl', 'r') as f:
+    class_1 = pickle.load(f)
+    class_2 = pickle.load(f)
+    labels = pickle.load(f)
+
+# test on the first point
+print model.classify(class_1[0])
+
+# define function for plotting
+def classify(x, y, model=model):
+    return array([model.classify([xx,yy]) for (xx,yy) in zip(x,y)])
+
+# plot the classification boundary
+imtools.plot_2D_boundary([-6,6,-6,6], [class_1,class_2], classify, [1,-1])
+show()

examples/ch8_process_handgestures.py

@@ -0,0 +1,36 @@
+from PIL import Image
+from pylab import *
+from numpy import *
+import os
+
+from PCV.localdescriptors import dsift, sift
+from PCV.tools import imtools
+
+"""
+This will process all hand gesture images with the dense SIFT descriptor.
+
+Assumes you downloaded the hand images to ..data/hand_gesture.
+The plot at the end generates one of the images of Figure 8-3.
+"""
+
+path = '../data/hand_gesture/train/'
+imlist = []
+for filename in os.listdir(path):
+    if os.path.splitext(filename)[1] == '.ppm':
+        imlist.append(path+filename)
+
+
+# process images at fixed size (50,50)
+for filename in imlist:
+    featfile = filename[:-3]+'dsift'
+    dsift.process_image_dsift(filename, featfile, 10, 5, resize=(50,50))
+
+
+# show an image with features
+l,d = sift.read_features_from_file(featfile)
+im = array(Image.open(filename).resize((50,50)))
+print im.shape
+
+figure()
+sift.plot_features(im, l, True)
+show()

examples/ch8_svm_points.py

@@ -0,0 +1,56 @@
+from pylab import *
+from numpy import *
+from svmutil import *
+import pickle
+
+from PCV.tools import imtools
+
+"""
+This is the simple 2D classification example in Section 8.2
+using a SVM classifier.
+
+If you have created the data files, it will reproduce the plot
+in Figure 8-5.
+"""
+
+
+# load 2D points using Pickle
+with open('../data/points_normal.pkl', 'r') as f:
+    class_1 = pickle.load(f)
+    class_2 = pickle.load(f)
+    labels = pickle.load(f)
+
+# convert to lists for libsvm
+class_1 = map(list, class_1)
+class_2 = map(list, class_2)
+labels = list(labels)
+samples = class_1+class_2 # concatenate the two lists
+
+# create SVM
+prob = svm_problem(labels, samples)
+param = svm_parameter('-t 2')
+# train SVM on data
+m = svm_train(prob, param)
+
+# how did the training do?
+res = svm_predict(labels, samples, m)
+
+
+# load test data using Pickle
+with open('../data/points_normal_test.pkl', 'r') as f:
+    class_1 = pickle.load(f)
+    class_2 = pickle.load(f)
+    labels = pickle.load(f)
+
+# convert to lists for libsvm
+class_1 = map(list, class_1)
+class_2 = map(list, class_2)
+
+
+# define function for plotting
+def predict(x, y, model=m):
+    return array(svm_predict([0]*len(x), map(list, zip(x,y)), model)[0])
+
+# plot the classification boundary
+imtools.plot_2D_boundary([-6,6,-6,6], [array(class_1),array(class_2)], predict, [-1,1])
+show()