计算机视觉——图像搜索_计算机视觉 图搜索

基于内容的图像检索

CBIR原理

利用文本标注的方式对图像中的内容进行描述，从而为每幅图像形成描述这幅图像内容的关键词，比如图像中的物体，或者景深更大的场景，在进行检索时，使用者可以根据自己的兴趣提供查询关键字，检索系统用使用者提供的查询关键字找出那些标注有该查询关键字对应的图片，最后将查询的结果返回给使用者。

主要流程为：
1、图像预处理.
2、特征提取（SIFT）
.3、对图像数据库建立图像特征索引
.4、抽取检索(Query)图像特征，构建特征向量.
5、设计检索模块(相似度设置准则)
6、返回相似性较高的结果

矢量空间模型

首先，我们需要一种方式让这些图片形成一种键值关系。
矢量空间模型是一个用于表示和搜索文本文档的模型，它基本可以应用于任何对象类型，包括图像。这些矢量是由文本词频直方图构成的，换句话说，矢量包含了每个单词出现的次数， 而且在其他别的地方包含很多0元素。由于其忽略了单词出现的顺序及位置，该模型也被称为BOW表示模型。

总结来看，这种方式将文本表示成特征矢量。它的基本思想是假定对于一个文本，忽略其词序和语法、句法，仅仅将其看做是一些词汇的集合，而文本中的每个词汇都是独立的。

我们需要找到图像的特征，类似于词汇作为文本的特征，而这种特征必须得对光照，图片的是否旋转，图片畸变等不敏感，而sift特征提取能够较好的满足上述要求，因此，我们使用sift特征提取的方法形成一个词汇

权重的设置

最常用的是权重是tf-idf（tern frequency-inverse document frequency，词频-逆向文档频率）

如何计算权重：

1. 计算词频
   
   
   用公式表示为
   

2. 计算逆文档频率
   
   用公式表示为：
   

3. 计算tf-idf
   

可以看出该值与一个词在文档中的出现次数成正比，与该词在整个语言中的出现次数成反比。
那么，算法关键流程是计算出文档的每个词的tf-idf值，然后按降序排列，取排在最前面的几个词。

视觉单词

将文本的关键词提取技术应用于图像检索中，需要建立一个类似于关键词的包含图像信息的单词，那么，可以通过sift特征提取出的特征作为视觉单词。

这个过程可进一步描述，将描述子空间量化成一些典型实例，并将图像中的每个描述子指派到其中的某个实例中。这些典型实例可以通过分析训练图像集确定，并被视为视觉单词。所有这些视觉单词构成的集合称为视觉词汇，有时也称为视觉码本。

BOW模型

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

视觉词袋（BoVW，Bag of Visual Words）模型，是“词袋”（BoW，ag of Words）模型从自然语言处理与分析领域向图像处理与分析领域的一次自然推广。对于任意一幅图像，BoVW模型提取该图像中的基本元素，并统计该图像中这些基本元素出现的频率，用直方图的形式来表示。通常使用“图像局部特征”来类比BoW模型中的单词，如SIFT、SURF、HOG等特征，所以也称视觉词袋模型。

创建词汇

为创建视觉单词词汇，首先需要提取特征描述子。这里，我们使用 SIFT 特征描述子。imlist 包含的是图像的文件名。运行下面的代码，可以得到每幅图像提取出的描述子，并将每幅图像的描述子保存在一个文件中：

nbr_images = len(imlist)
featlist = [ imlist[i][:-3]+'sift' for i in range(nbr_images)]

for i in range(nbr_images):
	sift.process_image(imlist[i],featlist[i])
1
2
3
4
5

创建名为 vocabulary.py 的文件，将下面代码添加进去。该代码创建了一个词汇类，以及在训练图像数据集上训练出一个词汇的方法：

from numpy import *
from scipy.cluster.vq import *

from PCV.localdescriptors import sift


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])
        # 将所有的特征并在一起，以便后面进行 K-means 聚类 
        descriptors = descr[0] 
        for i in arange(1,nbr_images):
            descr.append(sift.read_features_from_file(featurefiles[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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

Vocabulary 类包含了一个由单词聚类中心 VOC 与每个单词对应的逆向文档频率构成的向量，为了在某些图像集上训练词汇，train() 方法获取包含有
.sift 描后缀的述子文件列表和词汇单词数 k 。在 K-means 聚类阶段可以对训练数据下采样，因为如果使用过多特征，会耗费很长时间。
现在保存了图像及提取出来的 sift 特征文件，下面的代码会创建一个长为 k ≈ 1000 的词汇表。这里，再次假设 imlist 是一个包含了图像文件名的列表：

import pickle
from PCV.imagesearch import vocabulary
voc = vocabulary.Vocabulary('ukbenchtest')
voc.train(featlist, 888, 10) # 使用k-means算法在featurelist里边训练处一个词汇
                             # 注意这里使用了下采样的操作加快训练速度
                             # 将描述子投影到词汇上，以便创建直方图
#保存词汇
# saving vocabulary
with open('./BOW/vocabulary.pkl', 'wb') as f:
    pickle.dump(voc, f)
print ('vocabulary is:', voc.name, voc.nbr_words)

1
2
3
4
5
6
7
8
9
10
11
12

代码最后部分用 pickle 模块保存了整个词汇对象以便后面使用。

运行结果


对自建的图片库的每一张图片提取了其sift特征，同时，生成了词汇文件，共有888个视觉单词

图像索引

数据库建立

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

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

import pickle
from pysqlite2 import dbapi2 as sqlite
class Indexer(object):
 def __init__(self,db,voc):
 """ 初始化数据库的名称及词汇对象 """
 self.con = sqlite.connect(db)
 self.voc = voc
 def __del__(self):
 self.con.close()
 def db_commit(self):
 self.con.commit()

1
2
3
4
5
6
7
8
9
10
11
12

我们需要用 pickle 模块将这些数组编码成字符串以及将字符串进行解码；SQLite 可以从 pysqlite2 模块中导入。Indexer 类连接数据库，并且一旦创建（调用 init() 方法）后就可以保存词汇对象。del() 方法可以确保关闭数据库连接，db_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()

1
2
3
4
5
6
7
8
9
10
11
12

添加图像

有了数据库表单，便可以在索引中添加图像。为了实现该功能，需要在
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))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

该方法获取图像文件名与 Numpy 数组，该数组包含的是在图像找到的描述子。这些
描述子投影到词汇上，并插入到 imwords（逐字）和 imhistograms 表单中。我们使用
两个辅助函数：is_indxed() 用来检查图像是否已经被索引，get_id() 则对一幅图像
文件名给定 id 号。将下面的代码添加进 imagesearch.py：

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]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

遍历整个数据库的样本图像，并将其加入索引中。

mport pickle
from PCV.imagesearch import vocabulary
from PCV.tools.imtools import get_imlist
from PCV.localdescriptors import sift
from PCV.imagesearch import imagesearch
from PCV.geometry import homography
from sqlite3 import dbapi2 as sqlite # 使用sqlite作为数据库


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

# load vocabulary
#载入词汇
with open('./BOW/vocabulary.pkl', 'rb') as f:
    voc = pickle.load(f)
#创建索引
indx = imagesearch.Indexer('testImaAdd.db',voc) # 在Indexer这个类中创建表、索引，将图像数据写入数据库
indx.create_tables() # 创建表
# go through all images, project features on vocabulary and insert
#遍历所有的图像，并将它们的特征投影到词汇上
for i in range(nbr_images)[:888]:
    locs,descr = sift.read_features_from_file(featlist[i])
    indx.add_to_index(imlist[i],descr) # 使用add_to_index获取带有特征描述子的图像，投影到词汇上
                                       # 将图像的单词直方图编码存储
# commit to database
#提交到数据库
indx.db_commit()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

con = sqlite.connect('testImaAdd.db')
print (con.execute('select count (filename) from imlist').fetchone())
print (con.execute('select * from imlist').fetchone())
1
2
3

运行结果
一共添加了54张图片作为图片库

在数据库中搜索图像

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

如果图像数据库很大，逐一比较整个数据库中的所有直方图往往是不可行的，要找到一个大小合理的候选集，单词索引的作用就是这个：可以利用单词索引获得候选集，然后只需在候选集上进行逐一比较。

利用索引获取候选图像

利用建立起来的索引找到包含特定单词的所有图像，这不过是对数据库做一次简单的查询。在 Searcher 类中加入 candidates_from_word()

def candidates_from_word(self,imword):
  """ G 获取包含imword 的图像列表"""
  im_ids = self.con.execute(
      "select distinct imid from imwords where wordid=%d" % imword).fetchall()
  return [i[0] for i in im_ids]
1
2
3
4
5

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

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(cmp=lambda x,y:cmp(x[1],y[1]))
  tmp.reverse()
  # 返回排序后的列表，最匹配的排在最前面
  return [w[0] for w in tmp]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

该方法从图像单词直方图的非零项创建单词 id 列表，检索每个单词获得候选集并将其合并到candidates 列表中，然后创建一个元组列表每个元组由单词 id 和次数 count 构成，其中次数 count 是候选列表中每个单词出现的次数。

用来查询前四个图像的id

print (src.candidates_from_histogram(iw)[:4]) # 获取具有相似单词的图像列表
                                               # 这里获得所有唯一的单词，并按照出现次数反向排序
                                               # 所以返回的排序列表最匹配的排在最前边

src = imagesearch.Searcher('testImaAdd.db',voc) # Searcher类读入图像的单词直方图
print ('try a query...')

nbr_results = 4
res = [w[1] for w in src.query(imlist[18])[:nbr_results]]# 使用query检索单词直方图及候选列表图像
                                                        # 使用L2距离计算图像之间的相似性
                                                        # 返回的是一个已经排序的包含距离及图像id的元组列表
imagesearch.plot_results(src,res)
1
2
3
4
5
6
7
8
9
10
11
12

结果

用一幅图像查询

利用一幅图像进行查询时，没有必要进行完全的搜索。为了比较单词直方图，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]))
1
2
3
4
5
6
7
8

该 query() 方法获取图像的文件名，检索其单词直方图及候选图像列表。对于每个候选图像，我们用标准的欧式距离比较它和查询图像间的直方图，并返回一个经排序的包含距离及图像 id 的元组列表。

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 ) ) # 用L2 距离度量相似性
        matchscores.append( (cand_dist,imid) )
    # 返回排序后的距离及对应数据库ids 列表
    matchscores.sort()
    return matchscores
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果

确定对比基准

def compute_ukbench_score(src,imlist):
    """ 对查询返回的前4 个结果计算平均相似图像数，并返回结果"""
    nbr_images = len(imlist)
    pos = zeros((nbr_images,4))
    # 获取每幅查询图像的前4 个结果
    for i in range(nbr_images):
        pos[i] = [w[1]-1 for w in src.query(imlist[i])[:4]]
    # 计算分数，并返回平均分数
    score = array([ (pos[i]//4)==(i//4) for i in range(nbr_images)])*1.0
    return sum(score) / (nbr_images)
1
2
3
4
5
6
7
8
9
10

该函数获得搜索的前 4 个结果，将 query() 返回的索引减去 1，因为数据库索引是从 1 开始的，而图像列表的索引是从 0 开始的。然后，利用每 4 幅图像为一组时相似图像文件名是连续的这一事实，我们用整数相除计算得到最终的分数。分数为 4 时结果最理想；没有一个是准确的，分数为 0；仅检索到相同图像时，分数为 1；找到相同的图像并且其他三个中的两个相同时，分数为 3。

对结果进行排序

# -*- 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('E:/Python37_course/test7/first1000/')
imlist = get_imlist('./pic/')
nbr_images = len(imlist)
#载入特征列表
featlist = [imlist[i][:-3]+'sift' for i in range(nbr_images)]

#载入词汇

with open('./BOW/vocabulary.pkl', 'rb') as f:
    voc = pickle.load(f)

src = imagesearch.Searcher('testImaAdd.db',voc)# Searcher类读入图像的单词直方图执行查询

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

# 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[:6]) #常规查询
imagesearch.plot_results(src,res_geom[:6]) #重排后的结果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

运行结果
查询的图片

常规查询

对常规查询进行重新排序

建立Web程序

运行环境

pip install cherrypy
1

创建webdemo

import cherrypy, os, urllib, pickle
import imagesearch
class SearchDemo(object):
  def __init__(self):
    # 载入图像列表
    with open('webimlist.txt') as f:
      self.imlist = f.readlines()
  self.nbr_images = len(self.imlist)

  self.ndx = range(self.nbr_images)
  # 载入词汇
  with open('vocabulary.pkl', 'rb') as f:
    self.voc = pickle.load(f)
  # 设置可以显示多少幅图像
  self.maxres = 15
  # html 的头部和尾部
  self.header = """
    <!doctype html>
    <head>
    <title>Image search example</title>
    </head>
    <body>
    """
  self.footer = """
    </body>
    </html>
    """
  def index(self,query=None):
    self.src = imagesearch.Searcher('web.db',self.voc)
    html = self.header
    html += """
      <br />
      Click an image to search. <a href='?query='>Random selection</a> of images.
      <br /><br />
      """
  if query:
    # 查询数据库并获取靠前的图像
    res = self.src.query(query)[:self.maxres]
    for dist,ndx in res:
      imname = self.src.get_filename(ndx)

      html += "<a href='?query="+imname+"'>"
      html += "<img src='"+imname+"' width='100' />"
      html += "</a>"
  else:
    # 如果没有查询图像，则显示随机选择的图像
    random.shuffle(self.ndx)
    for i in self.ndx[:self.maxres]:
      imname = self.imlist[i]
      html += "<a href='?query="+imname+"'>"
      html += "<img src='"+imname+"' width='100' />"
      html += "</a>"
    html += self.footer
    return html
  index.exposed = True
cherrypy.quickstart(SearchDemo(), '/',
          config=os.path.join(os.path.dirname(__file__), 'service.conf'))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

配置service.conf

[global] 
server.socket_host = "127.0.0.1" 
server.socket_port = 8080 
server.thread_pool = 50 
tools.sessions.on = True 
[/] 
tools.staticdir.root = "./pic" 
tools.staticdir.on = True 
tools.staticdir.dir = ""
1
2
3
4
5
6
7
8
9

配置服务器可访问的文件夹范围为图片文件夹
打开http://127.0.0.1:8080/即可访问

query后面指定的参数为图片文件夹下指定的图片文件路径

运行结果

点击一个指定图片后


最左边的即为要查询的图片，可以看到，查询结果中猫的数量最多，其次为动物，再然后为整体轮廓较为接近的物体

再次测试结果较为稳定

实验总结

1. 查询的图片应尽可能的排除背景的干扰，这样会使结果更加精确
2. 进行单应性评估后的候选图片匹配度整体更优，但匹配度排名前3的图片不变，这也就说明，在找寻最匹配的图片的情况下，完全可以只选择计算代价小的简单匹配来匹配最接近的图片
3. 创建数据库表的时候要注意表是否已经存在，否则会产生创建重复表的错误