图像内容分类

本次关于图像分类的实验，一共分为以下三个部分：
1.K邻近分类法（KNN）
2.用稠密SIFT为图像特征
3.图像分类：手势识别
一、实验原理
K邻近分类法
在分类方法中最简单且用得最多的一种方法之一就是KNN,简单地说，k-近邻算法采用测量不同特征值之间的距离方法进行分类。
k-近邻算法是一种基本分类与回归方法；它是是监督学习中分类方法的一种，属于懒散学习法（惰性学习方法）。
存在一个样本数据集合，也称作为训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一个数据与所属分类的对应关系。输入没有标签的新数据后，将新的数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本最相似数据(最近邻)的分类标签。一般来说，我们只选择样本数据集中前k个最相似的数据，这就是k-近邻算法中k的出处，通常k是不大于20的整数。最后，选择k个最相似数据中出现次数最多的分类，作为新数据的分类。

KNN算法的一般流程
（1）收集数据：可以使用任何方法。
（2）准备数据：距离计算所需要的数值，最好是结构化的数据格式。
（3）分析数据：可以使用任何方法。
（4）训练算法：此步骤不适用于k-近邻算法。
（5）测试算法：计算错误率。
（6）使用算法：首先需要输入样本数据和结构化的输出结果，然后运行KNN算法判定输入数据分别属于哪个分类，最后应用对计算出的分类执行后续处理

用稠密SIFT为图像特征
在整幅图像上用一个规则的网格应用SIFT描述算子可以得到稠密SIFT的表示形式。
（以下参考： https://blog.youkuaiyun.com/breeze5428/article/details/25055291 ）
dense SIFT与做特征匹配所用到的SIFT的不同点。dense SIFT是提取我们感兴趣的patches中的每个位置的SIFT特征。而通常做特征匹配的SIFT算法只是得到感兴趣区域或者图像上若干个稳定的关键点的SIFT特征。目前关于dense SIFT提取比较流行的做法是，拿一个size固定的掩模或者bounding box，以一定的步长（stepsize）在图像上自左向右、从上到下提取dense SIFT的patch块。

手势识别
手势识别主要是用稠密SIFT描述子来表示这些手时图像，并建立一个简单的手势识别系统

二、代码及其实现
1、KNN
下面的脚本将创建两个不同的二维点集，每个点集有两类，用Pickle模块来保存创建的数据

# -*- coding: utf-8 -*-
from numpy.random import randn
import pickle
from pylab import *

# create sample data of 2D points
n =400
# 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('points_normal.pkl', 'w') as f:
with open('points_normal_test.pkl', 'wb') as f:
    pickle.dump(class_1,f)
    pickle.dump(class_2,f)
    pickle.dump(labels,f)
# normal distribution and ring around it
print ("save OK!")
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('points_ring.pkl', 'w') as f:
with open('points_ring_test.pkl', 'wb') as f:
    pickle.dump(class_1,f)
    pickle.dump(class_2,f)
    pickle.dump(labels,f)
    
print ("save OK!")

用不同的保存文件名运行该脚本两次，最终会得到4个二维数据集文件，每个分布都有两个文件，我们可以将一个用来训练，一个用来做测试。

用Pickle模块来创建一个KNN分类器模型，载入测试数据集，并在你的控制台上打印第一个数据点估计出来的类标记。

# -*- coding: utf-8 -*-
import pickle
from pylab import *
from PCV.classifiers import knn
from PCV.tools import imtools

pklist=['points_normal.pkl','points_ring.pkl']

figure()

# load 2D points using Pickle
for i, pklfile in enumerate(pklist):
    with open(pklfile, 'rb') as f:
        class_1 = pickle.load(f)
        class_2 = pickle.load(f)
        labels = pickle.load(f)
    # load test data using Pickle
    with open(pklfile[:-4]+'_test.pkl', 'rb') 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)))
    # 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)])

    # lot the classification boundary
    subplot(1,2,i+1)
    imtools.plot_2D_boundary([-6,6,-6,6],[class_1,class_2],classify,[1,-1])
    titlename=pklfile[:-4]
    title(titlename)
show()

下图为实验结果
K=3,N=200

K=3,N=400

K=6,N=200

K=6,N=400

K=10,N=400
小结：
a.k值越大运行速度越慢
b.k值越大，分类的不确定越大，多次运行以后才会没出现错误点

2.用稠密SIFT为图像特征

# -*- coding: utf-8 -*-
from PCV.localdescriptors import sift, dsift
from pylab import  *
from PIL import Image

dsift.process_image_dsift('gesture/school.jpg','school.dsift',90,40,True)
l,d = sift.read_features_from_file('school.dsift')
im = array(Image.open('gesture/school.jpg'))
sift.plot_features(im,l,True)
title('dense SIFT')
show()

运行结果如下：
像素越大的图片其稠密SIFT特征越多。


三、手势识别
在这个应用中，我们会用稠密SIFT描述子来表示这些手势图像，并建立一个简单的手势识别系统。用上面的稠密SIFT函数对图像进行处理，可以得到所有图像的特征向量。

# -*- coding: utf-8 -*-
import os
from PCV.localdescriptors import sift, dsift
from pylab import  *
from PIL import Image

imlist=['gesture/train1/five-uniform02.jpg','gesture/train1/good-uniform01.jpg',
        'gesture/train1/six-uniform01.jpg','gesture/train1/hit-uniform01.jpg',
        'gesture/train1/rock-uniform01.jpg','gesture/train1/ok-uniform01.jpg']

figure()
for i, im in enumerate(imlist):
    print (im)
    dsift.process_image_dsift(im,im[:-3]+'dsift',90,40,True)
    l,d = sift.read_features_from_file(im[:-3]+'dsift')
    dirpath, filename=os.path.split(im)
    im = array(Image.open(im))
    #显示手势含义title
    titlename=filename[:-14]
    subplot(2,3,i+1)
    sift.plot_features(im,l,True)
    title(titlename)
show()

运行结果如下图

train1是训练集，理论上越多越好。
test1是测试集，主要测试各种各样的手势。
把拍摄的6种手势18张照片放进train1训练集中

# -*- coding: utf-8 -*-
from PCV.localdescriptors import dsift
import os
from PCV.localdescriptors import sift
from pylab import *
from PCV.classifiers import knn

def get_imagelist(path):
    """    Returns a list of filenames for
        all jpg images in a directory. """

    return [os.path.join(path,f) for f in os.listdir(path) if f.endswith('.jpg')]

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 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)

filelist_train = get_imagelist('gesture/train1')
filelist_test = get_imagelist('gesture/test1')
imlist=filelist_train+filelist_test

# 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))

features,labels = read_gesture_features_labels('gesture/train1/')
test_features,test_labels = read_gesture_features_labels('gesture/test1/')
classnames = unique(labels)

# 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))])
# accuracy
acc = sum(1.0*(res==test_labels)) / len(test_labels)
print ('Accuracy:', acc)

print_confusion(res,test_labels,classnames)

把训练集的图片放进测试机test1,运行结果如下图

因为测试集中的图片与训练集中的图片一模一样，所以运行出来的结果分类完全正确，Accuracy为1.
接下来拍摄新的测试照片，并放入test1


运行结果如下图

可以看出，h类的图像没有分类成功，因为训练集基数太小，没有精准分类，但是o类的图像识别成功了，因为测试图与训练图的差异很小。