标签：name 搜图 image time collection 以图图像 import

以图搜图的基本原理：

　　以图搜图是一种基于内容的图像检索 (CBIR) 技术²，它的特点是无需关键字就能理解图像的相关内容，主要依赖于 AI 算法，目前一些排名较好的图像分类算法可以到达 99% 准确率（TOP5）³。本文将利用 AI 模型提取图像特征向量，通过特征向量计算来完成以图搜图。

一，Towhee & Milvus

　　Towhee (http://github.com/towhee-io/towhee)提供开箱即用的 Embedding 流水线可以将任何非结构化数据（图像，视频，音频等）转为特征向量，通过 Towhee 我们运行一条流水线就能轻松得到特征向量。

　　Milvus(http://github.com/milvus-io/milvus) 是一个开源的向量数据库项目，它支持丰富的向量索引算法和向量计算方式，轻松实现对数百万、数十亿甚至数万亿向量的相似性搜索，具有高度灵活、稳定可靠以及高速查询等特点。

　　通过 Towhee + Milvus 就可以实现端到端的图像等非结构化数据分析。我们先使用 Towhee 完成非结构化数据的特征向量提取，然后 Milvus 负责存储并搜索向量，最终获取与查询数据最相似的结果并展示。

Towhee 和 Milvus 的安装：

　　注意：Milvus 支持单机安装和集群安装，本文使用docker-compose(http://milvus.io/docs/v2.0.x/install_standalone-docker.md)方式安装单机 Milvus，在此之前请先检查本机环境的软硬件条件(http://milvus.io/docs/v2.0.x/prerequisite-docker.md)。

#安装 Towhee

$ pip install towhee

#安装单机版 Milvus
$ wget http://github.com/milvus-io/milvus/releases/download/v2.0.2/milvus-standalone-docker-compose.yml -O docker-compose.yml
$ docker-compose up -d

　　Towhee 支持图像 Embedding，音频 Embedding，视频 Embedding 等非结构化数据特征提取的方法，这些都被称为 Towhee 的算子（Operator），算子是流水线（Pipeline）中的单个节点，一个图像特征提取流水线就可以通过连接 image_decode(http://towhee.io/image-decode/cv2) 算子和 image_embedding.timm(http://towhee.io/image-embedding/timm) 算子实现，其中 Embedding 算子可以通过指定model_name="resnet50"利用 ResNet50 模型生成特征向量

代码：

import towhee
towhee.glob['path']('./test/lion/n02129165_13728.JPEG') \
      .image_decode['path', 'img']() \
      .image_embedding.timm['img', 'vec'](model_name='resnet50') \
      .select['img', 'vec']() \
      .show()

　　接下来在 Milvus 数据库中创建集合（Collection），集合中的 Fields 包含两列：id 和 embedding，其中 id 是集合的主键。另外我们可以为 embedding 创建 IVF_FLAT (http://milvus.io/docs/v2.0.x/index.md#IVF_FLAT) 基于量化的索引，其中索引的参数是 nlist=2048，计算方式是 "L2" 欧式距离：

代码：

from pymilvus import connections, FieldSchema, CollectionSchema, DataType, Collection, utility
def create_milvus_collection(collection_name, dim):
    connections.connect(host='127.0.0.1', port='19530')
    if utility.has_collection(collection_name):
        utility.drop_collection(collection_name)
    fields = [
    FieldSchema(name='id', dtype=DataType.INT64, descrition='ids', is_primary=True, auto_id=False),
    FieldSchema(name='embedding', dtype=DataType.FLOAT_VECTOR, descrition='embedding vectors', dim=dim)
    ]
    schema = CollectionSchema(fields=fields, description='reverse image search')
    collection = Collection(name=collection_name, schema=schema)
    # create IVF_FLAT index for collection.
    index_params = {
        'metric_type':'L2',
        'index_type':"IVF_FLAT",
        'params':{"nlist":2048}
    }
    collection.create_index(field_name="embedding", index_params=index_params)
    return collection
collection = create_milvus_collection('reverse_image_search', 2048)

图像数据入库

　　Towhee 不光拥有丰富的算子来处理非结构化数据，还提供了简单好用的接口来处理各种数据，当然也集成了 Milvus 的一些基本用法，通过在“流水线”中连接这些算子或接口，图像入库操作将变得十分Milvus简单。

import towhee
dc = (
towhee.read_csv('reverse_image_search.csv') #读取 CSV 格式的表格，包含了 id，path 和 label 列
.runas_op['id', 'id'](func=lambda x: int(x)) #将每一行的 id 从 str 类型转为 int 类型
.image_decode['path', 'img']() #读取每一行 path 对应的图像，并将其解码为 Towhee 的图像格式
.image_embedding.timm['img', 'vec'](model_name='resnet50') #提取特征向量
.tensor_normalize['vec', 'vec']() #将向量进行归一化
.to_milvus['id', 'vec'](collection=collection, batch=100) #将 id 和 vec 批量 100 条插入到 Milvus 集合
)

查询图像并展示

　　查询图像时需要的图像处理算子与前面类似，包括image_decode，image_embedding.timm和tensor_normalize，而在最后分析检索结果时，需用到数据准备部分定义好的read_images函数，通过指定runas_op中的func将该函数加入到 Towhee 流水线中。

(towhee.glob['path']('./test/w*/*.JPEG') #读取满足指定模式下的所有图片数据为 path
.image_decode['path', 'img']() #读取每一行 path 对应的图像，并将其解码为 Towhee 的图像格式
.image_embedding.timm['img', 'vec'](model_name='resnet50') #提取特征向量
.tensor_normalize['vec', 'vec']() #将向量进行归一化
.milvus_search['vec', 'result'](collection=collection, limit=5) #在 Milvus 集合中搜索向量，并返回结果
.runas_op['result', 'result_img'](func=read_images) #处理 Milvus 的检索结果，最终返回图像用于展示
.select['img', 'result_img']() #选择指定列；
.show()
)

二，

1，选用resnet网络提取图像特征

2，milvus建表，用milvus存放图像特征，通过唯一ID（此处称：milvus_id）与图像一一对应，sql建表将milvus_id作为唯一索引，存放图像的其他信息

3，异步添加图像，同步搜索图像，添加图像的量通常会很大，因此采用异步批量的方式将图像特征加载到milvus，图像添加服务会将每次的请求信息存到sql，写个脚本专门用来定时批量加载图像特征到milvus，由于是异步操作，可能会出现重复加载的情况，此处使用redis进行去重。图像搜索的请求通常会比图像添加少很多，因此图像搜索使采用同步方式返回结果；

(总结：需建立三个表：milvus表1，存放图像特征；sql表2，存放图像信息，数据与milvus表1一一对应；sql表3，存放图像添加请求信息，用于图像特征异步批量加载到milvus）

图像向量化

"""

功能：图像向量化 """ from keras.applications.resnet50 import ResNet50 from keras.preprocessing import image from keras.applications.resnet50 import preprocess_input, decode_predictions import numpy as np from numpy import linalg as LA import time model = ResNet50(weights='imagenet') # model.summary() def img2feature(img_path, input_dim=224): # 图像路径？？？图像数据 img = image.load_img(img_path, target_size=(input_dim, input_dim)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) x = model.predict(x) x = x / LA.norm(x) return x def main(): img_path = '1.jpg' t0 = time.time() res = img2feature(img_path) print(time.time() - t0, res.shape) # print(res, type(res), res.shape) if __name__ == "__main__": main()

milvus表的操作

# coding:utf-8 from functools import reduce import numpy as np import time from img2feature import img2feature from pymilvus import ( connections, list_collections, FieldSchema, CollectionSchema, DataType, Collection, utility ) field_name = 'image_feature' host = '***.***.***.***' port = '19530' dim = 1000 default_fields = [ FieldSchema(name="milvus_id", dtype=DataType.INT64, is_primary=True), FieldSchema(name="feature", dtype=DataType.FLOAT_VECTOR, dim=dim), FieldSchema(name="create_time", dtype=DataType.INT64) ] # create_table def create_table(): connections.connect(host=host, port=port) # create collection default_schema = CollectionSchema(fields=default_fields, description="test collection") print(f"\nCreate collection...") collection = Collection(name=field_name, schema=default_schema) print(f"\nCreate index...") default_index = {"index_type": "FLAT", "params": {"nlist": 128}, "metric_type": "L2"} collection.create_index(field_name="feature", index_params=default_index) print(print(f"\nCreate index...is OKOKOKOKOK")) collection.load() # insert data def insert_data(): connections.connect(host=host, port=port) default_schema = CollectionSchema(fields=default_fields, description="test collection") collection = Collection(name=field_name, schema=default_schema) vectors = img2feature('1.jpg').tolist()[0] print(type(vectors), len(vectors)) data1 = [ [123], [vectors], [int(time.time())] ] collection.insert(data1) print('insert compete') # search data def search_data(): print('search') connections.connect(host=host, port=port) collection = Collection(name=field_name) print('连接成功') # 首次查询建立索引和load() # default_index = {"index_type": "FLAT", "params": {"nlist": 128}, "metric_type": "L2"} # print(f"\nCreate index...") # collection.create_index(field_name="feature", index_params=default_index) # print(print(f"\nCreate index...is OKOKOKOKOK")) # collection.load() # exit() vectors = img2feature('1.jpg').tolist()[0] topK = 10 search_params = {"metric_type": "L2", "params": {"nprobe": 10}} res = collection.search( [vectors], "feature", search_params, topK, "create_time > {}".format(0), output_fields=["milvus_id"] ) print('>>>', res) for hits in res: print(len(hits)) for hit in hits: print(hit) print('查询结束') def show_nums(): connections.connect(host=host, port=port) collection = Collection(name=field_name) print('ok') print(collection.num_entities) # delete data def delete_table(): connections.connect(host=host, port=port) default_schema = CollectionSchema(fields=default_fields, description="test collection") collection = Collection(name=field_name, schema=default_schema) print('>>>', utility.has_collection(field_name)) collection.drop() print('>>>', utility.has_collection(field_name)) if __name__ == "__main__": t1 = time.time() # create_table() # insert_data() # search_data() show_nums() # delete_table() print('time cost: {}'.format(time.time() - t1))

图像添加、搜索服务

from rest_framework.views import APIView as View from kpdjango.response import SucessAPIResponse, ErrorAPIResponse from kpmysql.base import Kpmysql from core import search_image import kplog import logging log = logging.getLogger("console") class add_image(View): def post(self, requests): try: db = Kpmysql.connect("db168") cur = db.cursor() image_info = requests.POST.get('image_info') image_path = requests.POST.get('image_path') sql = "INSERT INTO t_image_search_image_add_log(image_path, info) VALUES(%s, %s)" cur.execute(sql, (image_path, image_info)) db.commit() log.info('添加图像成功:{}-{}'.format(image_path, image_info)) return SucessAPIResponse(msg="Success") except Exception as e: log.info('添加图像失败:{}'.format(e)) return ErrorAPIResponse(msg="Fail") class search_image(View): def post(self, requests): try: image_path = requests.POST.get('image_path') res = search_image(image_path) log.info('查询图像成功:{}-{}'.format(image_path, res)) return SucessAPIResponse(msg="Success", data={"data": res}) except Exception as e: log.info('查询图像成功:{}'.format(e)) return ErrorAPIResponse(msg="Fail")

图像异步批量加载

import time, datetime from kpmysql.base import Kpmysql from core import insert_data_many from concurrent.futures import ThreadPoolExecutor import redis from conf.setting import REDIS from core import str2time import kplog import logging log = logging.getLogger("console") log_addimgs = logging.getLogger("console_addimgs") def worker(datas): try: redis_cli = redis.Redis(host=REDIS.get('host'), port=REDIS.get('port'), password=REDIS.get('password'), db=REDIS.get('db')) dics = [] ids = [] for data in datas: if redis_cli.zscore('image_search', str(data[0])): # 基于redis去重 continue dics.append({'image_path': data[1], 'create_time': data[2]}) ids.append((data[0])) redis_cli.zadd('image_search', {str(data[0]): str2time(data[2])}) # 数据插入milvus insert_data_many(dics) # 更新 set t_image_search_image_add_log is_load=1 sql_update = """UPDATE t_image_search_image_add_log SET is_load=1 WHERE id=%s""" db168 = Kpmysql.connect("db168") cur168 = db168.cursor() cur168.executemany(sql_update, ids) db168.commit() except Exception as e: print(e) def main(): max_workers = 20 # 最大线程数 pool = ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix='Thread') task_list = [] init_time = datetime.datetime.now() - datetime.timedelta(hours=13) create_time_init = '2020-2-22 00:00:00' while True: now = datetime.datetime.now() diff = now - init_time if diff.seconds > 3600: # 加载 t_image_search_image_add_log where is_load=0 数据 db168 = Kpmysql.connect("db168") cur168 = db168.cursor() sql =

"""SELECT id, image_path, create_time FROM t_image_search_image_add_log WHERE is_load=0 and create_time >= %s ORDER BY create_time"""

cur168.execute(sql, create_time_init) datas = cur168.fetchall() create_time_init = datas[-1][2] while True: for _i, _n in enumerate(task_list): if _n.done(): task_list.pop(_i) if len(task_list) < int(max_workers * 0.9): break task_list.append(pool.submit(worker, datas)) init_time = now time.sleep(600) if __name__ == "__main__": main()

优化

1. keras在调用GPU时并开启多线程时不如pytorch方便，pytorch占用显存更少；

2. 定时从数据库拿数据，改成kafka生产消费模型，代码更简洁，逻辑更简单；

三，还有一些获取图片特征的VGG和Milvus组合使用：

参考：https://cloud.tencent.com/developer/article/1605032

参考：

1，https://maimai.cn/article/detail?fid=1743956531&efid=sTnHYzKAy8MK8AhgjSi7Bg

2，https://www.cnblogs.com/niulang/p/15921786.html

标签：name,搜图,image,time,collection,以图,图像,import
From： https://www.cnblogs.com/zwbsoft/p/16891539.html

以图搜图