Bag of features 图像检索

import re
from collections import defaultdict

from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
import numpy as np
from scipy.sparse import csr_matrix, spdiags
from scipy.sparse.linalg import norm

PTN_SYMBOL = re.compile(r‘[.!?\‘",]‘)


def tokenize(doc):
    """
    英文分词，小写输出
    """
    for word in PTN_SYMBOL.sub(‘ ‘, doc).split(‘ ‘):
        if word and word != ‘ ‘:
            yield word.lower()


def count_vocab(raw_documents):
    """
    返回文档词频的稀疏矩阵
    参考sklearn.feature_extraction.text.CountVectorizer._count_vocab

    矩阵大小：M*N, M个文档, 共计N个单词
    :param raw_documents: [‘Hello world.‘, ‘Hello word‘, ...]
    :return: csc_matrix, vocabulary
    """
    vocab = {}
    data, indices, indptr = [], [], [0]

    for doc in raw_documents:
        doc_feature = defaultdict(int)
        for term in tokenize(doc):
            # 词在词表中的位置
            index = vocab.setdefault(term, len(vocab))
            # 统计当前文档的词频
            doc_feature[index] += 1
        # 存储当前文档的词及词频
        indices.extend(doc_feature.keys())
        data.extend(doc_feature.values())
        # 累加词数
        indptr.append(len(indices))

    # 构造稀疏矩阵
    X = csr_matrix((data, indices, indptr), shape=(len(indptr) - 1, len(vocab)), dtype=np.int64)

    # 将单词表排序，同时更新压缩矩阵数据的位置
    map_index = np.empty(len(vocab), dtype=np.int32)
    for new_num, (term, old_num) in enumerate(sorted(vocab.items())):
        vocab[term] = new_num
        map_index[old_num] = new_num
    X.indices = map_index.take(X.indices, mode=‘clip‘)

    X.sort_indices()

    return X, vocab


def tfidf_transform(X, smooth_idf=True, normalize=True):
    """
    将词袋矩阵转换为TF-IDF矩阵

    :param X: 压缩的词袋矩阵 M*N， 文本数M, 词袋容量N
    :param smooth_idf: 是否对DF平滑处理
    :param normalize: 是否对TF-IDF执行l2标准化
    :return: TF-IDF压缩矩阵(csc_matrix)
    """
    n_samples, n_features = X.shape

    df = np.bincount(X.indices, minlength=X.shape[1])
    df += int(smooth_idf)
    new_n_samples = n_samples + int(smooth_idf)
    idf = np.log(float(new_n_samples) / df) + 1.0

    # 对角稀疏矩阵N*N，元素值对应单词的IDF
    idf_diag = spdiags(idf, diags=0, m=n_features, n=n_features, format=‘csr‘)

    # 等价于 DF * IDF
    X = X * idf_diag

    # 执行l2正则化
    if normalize:
        norm_l2 = 1. / norm(X, axis=1)
        tmp = spdiags(norm_l2, diags=0, m=n_samples, n=n_samples, format=‘csr‘)
        X = tmp * X

    return X


if __name__ == ‘__main__‘:
    # 源文档
    raw_documents = [
        ‘This is the first document.‘,
        ‘This is the second second document.‘,
        ‘And the third one.‘,
        ‘Is this the first document?‘,
    ]
    # 转换为词袋模型
    X, vocab = count_vocab(raw_documents)
    # X = CountVectorizer().fit_transform(raw_documents)
    """
    >> vocab
    {‘this‘: 8, ‘is‘: 3, ‘the‘: 6, ‘first‘: 2, ‘document‘: 1, ‘second‘: 5, ‘and‘: 0, ‘third‘: 7, 
    ‘one‘: 4}
    
    >> X.toarray()
    [[0 1 1 1 0 0 1 0 1]
     [0 1 0 1 0 2 1 0 1]
     [1 0 0 0 1 0 1 1 0]
     [0 1 1 1 0 0 1 0 1]]
    """

    # 计算TF-IDF
    tfidf_x = tfidf_transform(X)
    # tfidf_x = TfidfVectorizer().fit_transform(raw_documents)
    """
    >> tfidf_x.toarray()
    [   [0.       0.439       0.542       0.439       0.          0.      0.359   0.         0.439]
        [0.       0.272       0.          0.272       0.          0.853   0.223   0.         0.272]
        [0.553    0.          0.          0.          0.553       0.      0.288   0.553      0.   ]
        [0.       0.439       0.542       0.439       0.          0.      0.359   0.         0.439]	]

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

#获取图像列表
imlist = get_imlist(‘E:/BaiduNetdiskDownload/PCV-book-data/data/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.Vocabulary(‘ukbenchtest‘)
voc.train(featlist, 1000, 10)
#保存词汇
# saving vocabulary
with open(‘E:/BaiduNetdiskDownload/PCV-book-data/data/first1000/vocabulary.pkl‘, ‘wb‘) as f:
    pickle.dump(voc, f)
print ‘vocabulary is:‘, voc.name, voc.nbr_words

# -*- coding: utf-8 -*-
import pickle
from PCV.imagesearch import imagesearch
from PCV.localdescriptors import sift
from sqlite3 import dbapi2 as sqlite
from PCV.tools.imtools import get_imlist

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

# load vocabulary
#载入词汇
with open(‘./first1000/vocabulary.pkl‘, ‘rb‘) as f:
    voc = pickle.load(f)
#创建索引
indx = imagesearch.Indexer(‘testImaAdd.db‘,voc)
indx.create_tables()
# go through all images, project features on vocabulary and insert
#遍历所有的图像，并将它们的特征投影到词汇上
for i in range(nbr_images)[:500]:
    locs,descr = sift.read_features_from_file(featlist[i])
    indx.add_to_index(imlist[i],descr)
# commit to database
#提交到数据库
indx.db_commit()

con = sqlite.connect(‘testImaAdd.db‘)
print con.execute(‘select count (filename) from imlist‘).fetchone()
print con.execute(‘select * from imlist‘).fetchone()

# -*- 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]) #重排后的结果