hello，大家好。博主前一段时间比较忙，过去的一周考完了二专的最后一科，结束了答辩，又考完了初会。当初考完初会我就不该去网上找答案，对过答案后黯然失色，唉！
好了，不说了，这次想带大家讲的是python计算机视觉_图像内容的分类
说到分类，这里先提出一个简单有效的分类方法——K邻近分类法
1、K邻近分类法（KNN）
在分类方法中，最简单且用的最多的一种方法之一就是KNN，这种算法把要分类的对象（如一个特征向量）与训练集中已知类标记的所有对象进行对比，并由K近邻对指派到哪个类进行投票。下面见
代码：
（1）
# -*- coding: utf-8 -*-
from numpy.random import randn
import pickle
from pylab import *
# 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('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) + 10
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!")
可以看出，代码（1）负责生成需要分类的数据，并保存这些数据。以上代码生成了两类不同类型的数据：
class_1 = 0.6 * randn(n,2)
class_2 = 1.2 * randn(n,2) + array([5,1])
和
class_1 = 0.6 * randn(n,2)
r = 0.8 * randn(n,1) + 10
angle = 2*pi * randn(n,1)
class_2 = hstack((r*cos(angle),r*sin(angle)))
第一类数据自然不用多说，生成的数据大致分为左右两堆；第二类数据则生成的是环状数据，类似于行星和星环。
（2）
# -*- 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):
print(pklfile[:-4])
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()
from numpy import *
class KnnClassifier(object):
def __init__(self,labels,samples):
""" Initialize classifier with training data. """
self.labels = labels
self.samples = samples
def classify(self,point,k=3):
""" Classify a point against k nearest
in the training data, return label. """
# compute distance to all training points
dist = array([L2dist(point,s) for s in self.samples])
# sort them
ndx = dist.argsort()
# use dictionary to store the k nearest
votes = {}
for i in range(k):
label = self.labels[ndx[i]]
votes.setdefault(label,0)
votes[label] += 1
return max(votes, key=lambda x: votes.get(x))
def L2dist(p1,p2):
return sqrt( sum( (p1-p2)**2) )
def L1dist(v1,v2):
return sum(abs(v1-v2))
代码（2）导入刚才生成的数据，并对每一类数据进行分类，画出分界线，结果如下：
2、用稠密SIFT作为图像特征
说到稠密SIFT，自然会想到一般的SIFT算法，那么它们俩有什么区别和相似之处呢？
（1）相似点：稠密SIFT和SIFT算法都是为了生成图像的特征向量
（2）区别：顾名思义，稠密SIFT算法能够得到比SIFT算法更加稠密的特征点
为什么教材在做图像分类时用dense-sift，而不用sift？这一点博主没有深究，不过这点应该很容易想到，dense-sift算法得到的特征点更加稠密，利于提高分类的精确性。
下面请看代码：
# -*- coding: utf-8 -*-
from PCV.localdescriptors import sift, dsift
from pylab import *
from PIL import Image
dsift.process_image_dsift('gesture/火烧云.jpg','火烧云.dsift',90,40,True)
#dsift('gesture/火烧云.jpg', '火烧云.dsift')
l,d = sift.read_features_from_file('火烧云.dsift')
im = array(Image.open('gesture/火烧云.jpg'))
sift.plot_features(im,l,True)
title('dense SIFT')
show()
from PIL import Image
from numpy import *
import os
from PCV.localdescriptors import sift
def process_image_dsift(imagename,resultname,size=20,steps=10,force_orientation=False,resize=None):
""" Process an image with densely sampled SIFT descriptors
and save the results in a file. Optional input: size of features,
steps between locations, forcing computation of descriptor orientation
(False means all are oriented upwards), tuple for resizing the image."""
im = Image.open(imagename).convert('L')
if resize!=None:
im = im.resize(resize)
m,n = im.size
if imagename[-3:] != 'pgm':
#create a pgm file
im.save('tmp.pgm')
imagename = 'tmp.pgm'
# create frames and save to temporary file
scale = size/3.0
x,y = meshgrid(range(steps,m,steps),range(steps,n,steps))
xx,yy = x.flatten(),y.flatten()
frame = array([xx,yy,scale*ones(xx.shape[0]),zeros(xx.shape[0])])
savetxt('tmp.frame',frame.T,fmt='%03.3f')
path = os.path.abspath(os.path.join(os.path.dirname("__file__"),os.path.pardir))
path = path + "\\python3-ch08\\win32vlfeat\\sift.exe "
if force_orientation:
cmmd = str(path+imagename+" --output="+resultname+
" --read-frames=tmp.frame --orientations")
else:
cmmd = str(path+imagename+" --output="+resultname+
" --read-frames=tmp.frame")
os.system(cmmd)
print ('processed', imagename, 'to', resultname)
运行结果：
1）dsift.process_image_dsift(‘gesture/火烧云.jpg’,‘火烧云.dsift’,90,40,True)
2）dsift.process_image_dsift(‘gesture/火烧云.jpg’,‘火烧云.dsift’,200,90,True)
根据这两张运行结果图，这里讲解一下此段代码：dsift.process_image_dsift(‘gesture/火烧云.jpg’,‘火烧云.dsift’,200,90,True)的意思
这里还要从dense-sift的原理说起，dense-sift是先对图像进行分块，然后再对每个分块中的图像做特征提取，因此（90,40）和（200,90）指的便是分块区域的大小了。
3、图像分类：手势识别
手势识别分为两步，第一步是训练数据，第二部是测试数据
（1）训练数据
# -*- coding: utf-8 -*-
import os
from PCV.localdescriptors import sift, dsift
from pylab import *
from PIL import Image
imlist=['gesture/train2/C-uniform01.jpg','gesture/train2/B-uniform01.jpg',
'gesture/train2/A-uniform01.jpg','gesture/train2/Five-uniform01.jpg',
'gesture/train2/Point-uniform01.jpg','gesture/train2/V-uniform01.jpg']
figure()
for i, im in enumerate(imlist):
print(im)
dsift.process_image_dsift(im, im[:-3]+'dsift', 15, 6, 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()
训练结果：
（2）测试数据
# -*- 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/train2')
filelist_test = get_imagelist('gesture/test2')
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/train2/')
test_features,test_labels = read_gesture_features_labels('gesture/test2/')
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)
测试结果：
可以看到accuracy为1，这说明测试结果的正确率为100%。
为什么正确率会这么高呢？先给大家看一下博主测试的图片吧：
可以看到，测试图片可以说是非常的规范了。那么如果测试图片“很丑”时，分类结果又会怎样呢？
这是接下来要测试的图像集：
这些图像理论上应该分类给“B”这一类，下面我们来看一下实验效果：
可以看到accuracy为0.375，正确率大大下降，这说明在做手势识别时，测试的手势的角度不同，对结果有很大的影响。
谢谢阅读！
162
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
