Python计算机视觉编程第七章 图像搜索

本章将展示如何利用文本挖掘技术对基于图像视觉内容进行图像搜索。本章阐明了提出利用视觉单词的基本思想，并解释了完整的安装细节，还在一个示例数据集上进行了测试。

1 基于内容的图像检索

在大型数据库上，CBIR(Content-Based Image Retrieval，基于内容的图像检索)技术用于检索在视觉上具有相似性的图像。这样返回的图像可以是颜色相似，纹理相似，图像中的物体或场景相似；总之，基本上可以是这些图像自身共有的任何信息。

对于高层查询，比如寻找相似的物体，将查询图像与数据库中所有的图像进行完全比较（比如用特征匹配）往往是不可行的。在数据库很大的情况下，这样的查询方式会消耗过多时间。在过去的几年里，研究者成功地引入文本挖掘技术到CBIR中处理问题，使在数百万图像中搜索具有相似内容的图像成为可能。

从文本挖掘中获取灵感——矢量空间模型
矢量空间模型是用于表示和搜索文本文档的模型。我们将看到，它基本上可以应用于任何对象类型，包括图像。该名字来源于用矢量来表示文本文档，这些矢量是有文本词频直方图构成的。换句话说，矢量包含了每个单词出现的次数，而且在其他别的地方包含很多0元素。由于其忽略了单词出现的顺序及位置，该模型也被称为BOW表示模型。

通过单词计算来构建文档直方图向量v，从而建立文档索引。通常，在单词计数时会忽略掉一些常用词，如“这”“和”“是”等，这些常用词称为停用词。由于每篇文档长度不同，故除以直方图总和将向量归一化成单位长度。对于直方图向量中的每个元素，一般根据每个单词的重要性来赋予相应的权重。通常，数据集（或语料库）中一个单词的重要性来赋予相应的权重。通常，数据集（或语料库）中一个单词的重要性与它在文档中出现的次数成正比，而与它在语料库中出现的次数为反比。

最常用的权重是tf-idf(term frequency-inverse document frequency，词频-逆向文档频率)，单词w在文档d中的词频是：$$t{f}_{w,d}=\frac{n_w}{{\sum }_j{n}_j}$$n_w是单词w在文档d中出现的次数。为了归一化，将n_w除以整个文档中单词的总数。

逆向文档频率为： i d f w , d = log ⁡ ∣ ( D ) ∣ ∣ { d : w ∈ d } ∣ idf_{w,d}=\log\frac{|(D)|}{|\{d:w\in d\}|} idfw,d​=log∣{d:w∈d}∣∣(D)∣​|D|是在语料库D中文档的数目，分母是语料库中包含单词w的文档数d。将两者相乘可以得到矢量v中对应元素的tf-idf权重。

用python3实现tf-idf算法：

from collections import defaultdict
import math
import operator

"""
函数说明：创建数据样本
Returns:
    dataset:实验样本切分的词条
    classvec：类别标签向量
"""
def loadDataSet():
    dataset = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],  # 切分的词条
               ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
               ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
               ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
               ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
               ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
    classvec = [0, 1, 0, 1, 0, 1]   # 类别标签向量，1代表好，0代表不好
    return dataset, classvec

"""
函数说明：特征选择TF-IDF算法
Parameters:
    list_words:词列表
Returns:
    dict_feature_select:特征选择词字典
"""
def feature_select(list_words):
    # 总词频统计
    doc_frequency = defaultdict(int)
    for word_list in list_words:
        for i in word_list:
            doc_frequency[i] += 1

    # 计算每个词的TF值
    word_tf = {}    # 存储每个单词的tf值
    for i in doc_frequency:
        word_tf[i] = doc_frequency[i] / sum(doc_frequency.values())

    # 计算每个词的IDF值
    doc_num = len(list_words)
    word_idf = {}   # 存储每个词的idf值
    word_doc = defaultdict(int)
    for i in doc_frequency:
        for j in list_words:
            if i in j:
                word_doc[i] += 1
    for i in doc_frequency:
        word_idf[i] = math.log(doc_num / (word_doc[i]+1))

    # 计算每个词的TF*IDF的值
    word_tf_idf = {}
    for i in doc_frequency:
        word_tf_idf[i] = word_tf[i] * word_idf[i]

    # 对字典按值由大到小排序
    dict_feature_select = sorted(word_tf_idf.items(), key=operator.itemgetter(1), reverse=True)
    return dict_feature_select

data_list,label_list=loadDataSet() #加载数据
features=feature_select(data_list) #所有词的TF-IDF值
print(features)
print(len(features))

2 视觉单词

为了将文本发掘技术应用到图像中，我们首先需要建立视觉等效单词；这通常可以采用2.2节中介绍的SIFT局部描述子做到。它的思想是将描述子空间量化成一些典型实例，并将图像中的每个描述子指派到其中的某个实例中。这些典型实例可以通过分析训练图像集确定，并被视为视觉单词。所有这些视觉单词构成的集合称为视觉词汇，有时也称为视觉码本。对于给定的问题、图像类型，或在通常情况下仅需呈现视觉内容，可以创建特定的词汇。

从一个（很大的训练图像）集提取特征描述子，利用一些聚类算法可以构建出视觉单词。聚类算法中最常用的是K-means，这里也将采用K-means。视觉单词并不高端。只是在给定特征描述子空间中的一组向量集，在采用K-means进行聚类时得到的视觉单词是聚类质心。用视觉单词直方图来表示图像，则该模型便称为BOW模型。

构建BOW词汇步骤：

1）利用SIFT算法从不同类别的图像中提取视觉词汇向量，这些向量代表的是图像中局部不变的特征点；
2）将所有特征点向量集合到一块，利用K-Means算法合并词义相近的视觉词汇，构造一个包含K个词汇的单词表；
3）统计单词表中每个单词在图像中出现的次数，从而将图像表示成为一个K维数值向量。

我们首先介绍一下示例数据集，并利用它来说明BOW概念。文件first1000.zip包含了有肯塔基大学物体识别数据集的前1000幅图像。

创建词汇
为创建视觉单词词汇，首先需要提取特征描述子。这里，我们使用SIFT特征描述子。如前面一样，imlist包含的是图像的文件名。创建名为vocabulary.py文件，下面代码创建一个词汇类，以及在训练图像数据集上训练处一个词汇的方法：

from numpy import *
from scipy.cluster.vq import *
import pickle
from PCV.localdescriptors import sift
from PCV.tools.imtools import get_imlist

class Vocabulary(object):

    def __init__(self,name):
        self.name = name
        self.voc = []
        self.idf = []
        self.trainingdata = []
        self.nbr_words = 0

    def train(self, featurefiles, k=100, subsampling=10):
        """用含有k个单词的K-means列出在featurefiles中的特征文件训练出一个词汇。
            对训练数据下采样可以加快训练速度"""

        nbr_images = len(featurefiles)
        # 从文件中读取特征
        descr = []
        descr.append(sift.read_features_from_file(featurefiles[0])[1])
        descriptors = descr[0]  # 所有的特征并在一起，以便后面进行K-means聚类
        for i in range(1, nbr_images):
            descr.append(sift.read_features_from_file([i])[1])
            descriptors = vstack((descriptors,descr[i]))

        # K-means：最后一个参数决定运行次数
        self.voc,distortion = kmeans(descriptors[::subsampling,:],k,1)
        self.nbr_words = self.voc.shape[0]

        # 遍历所有的训练图像，并投影到词汇上
        imwords = zeros((nbr_images, self.nbr_words))
        for i in range(nbr_images):
            imwords[i] = self.project(descr[i])

        nbr_occurences = sum((imwords > 0) * 1, axis=0)

        self.idf = log((1.0 * nbr_images) / (1.0 * nbr_occurences + 1))
        self.trainingdata = featurefiles

    def project(self, descriptors):
        """ 将描述子投影到词汇上，以创建单词直方图  """

        # 图像单词直方图
        imhist = zeros((self.nbr_words))
        words, distance = vq(descriptors, self.voc)
        for w in words:
            imhist[w] += 1

        return imhist

if __name__=='__main__':
    # 获取图像列表
    imlist = get_imlist('D:\\123\图像处理\Image Processing\Image Processing\Chapter7\\first1000\\')
    nbr_images = len(imlist)
    # 获取特征列表
    featlist = [imlist[i][:-3] + 'sift' for i in range(nbr_images)]

    # 提取文件夹下图像的sift特征
    for i in range(nbr_images):
        sift.process_image(imlist[i], featlist[i])

    # 生成词汇
    voc = Vocabulary('ukbenchtest')
    voc.train(featlist, 1000, 10)
    # 保存词汇
    with open('first1000/vocabulary.pkl', 'wb') as f:
        pickle.dump(voc, f)
    print('vocabulary is:', voc.name, voc.nbr_words)

Vocabulary 类包含了一个由单词聚类中心 VOC 与每个单词对应的逆向文档频率构成的向量，为了在某些图像集上训练词汇，train() 方法获取包含有 .sift 描后缀的述子文件列表和词汇单词数k。在 K-means 聚类阶段可以对训练数据下采样，因为如果使用过多特征，会耗费很长时间。可以看到在计算机文件夹中，保存了图像及提取出来的 sift 特征文件。代码最后部分用 pickle 模块保存了整个词汇对象以便后面使用。

3 图像索引

对图像进行索引就是从这些图像中提取描述子，利用词汇将描述子转换成视觉单词，并保存视觉单词及对应图像的单词直方图。从而可以利用图像对数据库进行查询，并返回相似的图像作为搜索结果。在开始搜索之前，需要建立图像数据库和图像的视觉单词表示。

3.1 建立数据库

在索引图像前，我们需要建立一个数据库。这里，对图像进行索引就是从这些图像中提取描述子，利用词汇将描述子转换成视觉单词，并保存视觉单词及对应图像的单词直方图。从而可以利用图像对数据库进行查询，并返回相似的图像作为搜索结果。

在开始之前，首先需要创建表、索引和索引器 Indexer 类，以便将图像数据写入数据库。首先，创建一个名为 imagesearch.py 的文件：

from numpy import *
import pickle
import sqlite3
from functools import cmp_to_key
import operator

class Indexer(object):
    
    def __init__(self,db,voc):
        """ 初始化数据库的名称及词汇对象  """
            
        self.con = sqlite3.connect(db)
        self.voc = voc
    
    def __del__(self):
        self.con.close()
    
    def db_commit(self):
        self.con.commit()
    
    def create_tables(self): 
        """ Create the database tables. """
        
        self.con.execute('create table imlist(filename)')
        self.con.execute('create table imwords(imid,wordid,vocname)')
        self.con.execute('create table imhistograms(imid,histogram,vocname)')        
        self.con.execute('create index im_idx on imlist(filename)')
        self.con.execute('create index wordid_idx on imwords(wordid)')
        self.con.execute('create index imid_idx on imwords(imid)')
        self.con.execute('create index imidhist_idx on imhistograms(imid)')
        self.db_commit()

3.2 添加图像

有了数据库表单，便可以在索引中添加图像。为了实现该功能，需要在 Indexer 类中添加 add_to_index() 方法。将下面的方法添加到 imagesearch.py 中：

def add_to_index(self,imname,descr):
        """ 获取一幅带有特征描述子的图像，投影到词汇上并添加进数据库  """
            
        if self.is_indexed(imname): return
        print 'indexing', imname
        
        # 获取图像id
        imid = self.get_id(imname)
        
        # 获取单词
        imwords = self.voc.project(descr)
        nbr_words = imwords.shape[0]
        
        #将每个单词与图像链接起来 
        for i in range(nbr_words):
            word = imwords[i]
        #  wordid 就是单词本身的数字 
            self.con.execute("insert into imwords(imid,wordid,vocname) values (?,?,?)", (imid,word,self.voc.name))
            
        # 存储图像的单词直方图
        # 用 pickle 模块将 NumPy 数组编码成字符串
        self.con.execute("insert into imhistograms(imid,histogram,vocname) values (?,?,?)", (imid,pickle.dumps(imwords),self.voc.name))

def is_indexed(self,imname):
        """ 如果图像名字（imname）被索引到，就返回 True"""
        
        im = self.con.execute("select rowid from imlist where filename='%s'" % imname).fetchone()
        return im != None
 def get_id(self,imname):
        """ 获取图像 id，如果不存在，就进行添加 ""
        
        cur = self.con.execute(
        "select rowid from imlist where filename='%s'" % imname)
        res=cur.fetchone()
        if res==None:
            cur = self.con.execute(
            "insert into imlist(filename) values ('%s')" % imname)
            return cur.lastrowid
        else:
            return res[0] 

下面的示例代码会遍历整个ukbench数据库中的样本图像，并将其加入我们的索引：

# 获取图像列表
    imlist = get_imlist('first1/')
    nbr_images = len(imlist)
    # 获取特征列表
    featlist = [imlist[i][:-3] + 'sift' for i in range(nbr_images)]

    # 提取文件夹下图像的sift特征
    for i in range(nbr_images):
        sift.process_image(imlist[i], featlist[i])

    # 生成词汇
    voc = vocabulary.Vocabulary('ukbenchtest')
    voc.train(featlist, 1000, 10)
    # 保存词汇
    with open('first1/vocabulary.pkl', 'wb') as f:
        pickle.dump(voc, f)
    print('vocabulary is:', voc.name, voc.nbr_words)

    with open('D:\\123\图像处理\Image Processing\Image Processing\Chapter7\\first1\\vocabulary.pkl', 'rb') as f:
        voc = pickle.load(f)

    # 创建索引器
    indx = Indexer('test1.db', voc)
    indx.create_tables()

    # 遍历所有的图像，并将它们的特征投影到词汇上
    for i in range(nbr_images)[:300]:
        locs, descr = sift.read_features_from_file(featlist[i])
        indx.add_to_index(imlist[i], descr)

    # 提交到数据库
    indx.db_commit()
    con = sqlite3.connect('test1.db')  # 连接到数据库
    print(con.execute('select count (filename) from imlist').fetchone())  # 数据库操作
    print(con.execute('select * from imlist').fetchone())

4 在数据库中搜索图像

建立好图像的索引，我们就可以在数据库中搜索相似的图像了。这里，我们用BoW（Bag-of-Word，词袋模型）来表示整个图像，不过这里介绍的过程是通用的，可以应用于寻找相似的物体、相似的脸、相似的颜色等，它完全取决于图像及所用的描述子。

为实现搜索，我们在imagesearch.py中添加Searcher类：

class Searcher(object):

    def __init__(self, db, voc):
        """ 初始化数据库的名称. """
        self.con = sqlite.connect(db)
        self.voc = voc

    def __del__(self):
        self.con.close()

一个新的 Searcher 对象连接到数据库，一旦删除便关闭连接，这与之前的 Indexer 类中的处理过程相同。如果图像数据库很大，逐一比较整个数据库中的所有直方图往往是不可行的。我们需要找到一个大小合理的候选集（这里的“合理”是通过搜索响应时间、所需内存等确定的），单词索引的作用便在于此：我们可以利用单词索引获得候选集，然后只需在候选集上进行逐一比较。

4.1 利用索引获取候选图像

我们可以利用建立起来的索引找到包含特定单词的所有图像，这不过是对数据集做一次简单的查询。在Searcher类中加入下面方法：

    def candidates_from_word(self, imword):
        """  获取包含 imword 的图像列. """

        im_ids = self.con.execute(
            "select distinct imid from imwords where wordid=%d" % imword).fetchall()
        return [i[0] for i in im_ids]

上面会给出包含特定单词的所有图像id号。为了获得包含多个单词的候选图像，例如一个单词直方图中的全部非零元素，我们在每个单词上进行遍历，得到包含该单词的图像，并合并这些列表。这里，我们仍然需要在合并了的列表中对每一个图像id出现的次数进行跟踪，因为这可以显示有多少单词与单词直方图中的单词匹配，该过程有下面的方法完成：

    def candidates_from_histogram(self, imwords):
        """ 获取具有相似单词的图像列表 """

        # 获取单词 id
        words = imwords.nonzero()[0]

        # 寻找候选图像
        candidates = []
        for word in words:
            c = self.candidates_from_word(word)
            candidates += c

        # 获取所有唯一的单词，并按出现次数反向排序 
        tmp = [(w, candidates.count(w)) for w in set(candidates)]
        tmp.sort(key=cmp_to_key(lambda x, y: operator.gt(x[1], y[1])))
        tmp.reverse()

        # 返回排序后的列表，最匹配的排在最前面
        return [w[0] for w in tmp]

该方法从图像单词直方图的非零项创建单词 id 列表，检索每个单词获得候选集并将其合并到candidates 列表中，然后创建一个元组列表每个元组由单词 id 和次数 count 构成，其中次数 count 是候选列表中每个单词出现的次数。同时，以元组中的第二个元素为准，用 sort() 方法和一个自定义的比较函数对列表进行排序（考虑到后面的效率）。该自定义比较函数进行用 lambda 函数内联声明，对于单行函数声明，使用 lambda 函数非常方便。最后结果返回一个包含图像 id 的列表，排在列表最前面的是最好的匹配图像。

	src = Searcher('test1.db', voc)
    locs, descr = sift.read_features_from_file(featlist[0])
    iw = voc.project(descr)

    print('ask using a histogram...')
    print(src.candidates_from_histogram(iw)[:10])

打印了从索引中查找出的前 10 个图像 id，结果如下：

4.2 用一幅图像进行查询

利用一幅图像进行查询时，没有必要进行完全的搜索。为了比较单词直方图，Searcher类需要从数据库读入图像的单词直方图。将下面的方法添加到Searcher类中：

 def get_imhistogram(self, imname):
        """ 返回一幅图像的单词直方图 . """

        im_id = self.con.execute(
            "select rowid from imlist where filename='%s'" % imname).fetchone()
        s = self.con.execute(
            "select histogram from imhistograms where rowid='%d'" % im_id).fetchone()

        # 用 pickle 模块从字符串解码 Numpy 数组
        return pickle.loads(str(s[0]))

这里，为了在字符串和NumPy数据间进行转换，我们再次用到了pickle模块，这次使用的是loads（）。

现在，我们可以全部合并到查询方法中：

    def query(self, imname):
        """ 查找所有与 imname 匹配的图像列表 . """

        h = self.get_imhistogram(imname)
        candidates = self.candidates_from_histogram(h)

        matchscores = []
        for imid in candidates:
            # 获取名字 
            cand_name = self.con.execute(
                "select filename from imlist where rowid=%d" % imid).fetchone()
            cand_h = self.get_imhistogram(cand_name)
            cand_dist = sqrt(sum(self.voc.idf * (h - cand_h) ** 2))
            matchscores.append((cand_dist, imid))

        # 返回排序后的距离及对应数据库 ids 列表 
        matchscores.sort()
        return matchscores

该 query() 方法获取图像的文件名，检索其单词直方图及候选图像列表（如果你的数据集很大，候选集的大小应该限制在某个最大值）。对于每个候选图像，用标准的欧式距离比较它和查询图像间的直方图，并返回一个经排序的包含距离及图像 id的元组列表。

尝试对前一节的图像进行查询;

	src = Searcher('test1.db', voc)
    # locs, descr = sift.read_features_from_file(featlist[0])
    # iw = voc.project(descr)

    # print('ask using a histogram...')
    # print(src.candidates_from_histogram(iw)[:10])
    print('try a query...')
    print(src.query(imlist[0])[:10])

5 使用几何特性对结果排序

BoW 模型的一个主要缺点是在用视觉单词表示图像时不包含图像特征的位置信息，这是为获取速度和可伸缩性而付出的代价。利用一些考虑到特征几何关系的准则重排搜索到的靠前结果，可以提高准确率。最常用的方法是在查询图像与靠前图像的特征位置间拟合单应性。

为了提高效率，可以将特征位置存储在数据库中，并由特征的单词 id 决定它们之间的关联（要注意的是，只有在词汇足够大，使单词 id 包含很多准确匹配时，它才起作用）。

下面是一个载入所有模型文件并用单应性对靠前的图像进行重排的完整例子：

# -*- coding: utf-8 -*-
import pickle
from PCV.localdescriptors import sift
from PCV.imagesearch import imagesearch
from PCV.geometry import homography
from PCV.tools.imtools import get_imlist

# load image list and vocabulary
#载入图像列表
imlist = get_imlist('first1000/')
nbr_images = len(imlist)
#载入特征列表
featlist = [imlist[i][:-3]+'sift' for i in range(nbr_images)]

#载入词汇
with open('first1000/vocabulary.pkl', 'rb') as f:
    voc = pickle.load(f)

src = imagesearch.Searcher('testImaAdd.db',voc)

# index of query image and number of results to return
#查询图像索引和查询返回的图像数
q_ind = 0
nbr_results = 20

# regular query
# 常规查询(按欧式距离对结果排序)
res_reg = [w[1] for w in src.query(imlist[q_ind])[:nbr_results]]
print 'top matches (regular):', res_reg

# load image features for query image
#载入查询图像特征
q_locs,q_descr = sift.read_features_from_file(featlist[q_ind])
fp = homography.make_homog(q_locs[:,:2].T)

# RANSAC model for homography fitting
#用单应性进行拟合建立RANSAC模型
model = homography.RansacModel()
rank = {}

# load image features for result
#载入候选图像的特征
for ndx in res_reg[1:]:
    locs,descr = sift.read_features_from_file(featlist[ndx])  # because 'ndx' is a rowid of the DB that starts at 1
    # get matches
    matches = sift.match(q_descr,descr)
    ind = matches.nonzero()[0]
    ind2 = matches[ind]
    tp = homography.make_homog(locs[:,:2].T)
    # compute homography, count inliers. if not enough matches return empty list
    try:
        H,inliers = homography.H_from_ransac(fp[:,ind],tp[:,ind2],model,match_theshold=4)
    except:
        inliers = []
    # store inlier count
    rank[ndx] = len(inliers)

# sort dictionary to get the most inliers first
sorted_rank = sorted(rank.items(), key=lambda t: t[1], reverse=True)
res_geom = [res_reg[0]]+[s[0] for s in sorted_rank]
print ('top matches (homography):', res_geom)

# 显示查询结果
imagesearch.plot_results(src,res_reg[:8]) #常规查询
imagesearch.plot_results(src,res_geom[:8]) #重排后的结果

这里由于整个实验都应该是由python2环境下运行，我使用的是python3的sqlite3包在运行，书上的代码都是python2的代码，其中pickle包中序列化在python2和python3中不同，我做了解码以后还是会产生栈下溢的错误，由于博主也是刚刚接触python，能力有限，这里就跑不出来了，感兴趣的朋友可以在python2环境下运行代码看一下结果。下面我放一下我的师姐运行的结果：