大规模底库搜索特征比对库Milvus（二），使用，减少reid评估时间_milvusclient.flush

作者：IT小白 | 2024-07-14 05:55:38

踩

milvusclient.flush

1.1、安装问题1

Milvus0.6版本安装使用教程

Milvus 0.8 开源向量搜索引擎使用教程

官网各种版本选择链接,选择最新的安装

版本很多，小伙伴门安装最新的，2020/7月现在是0.10.1，根据教程安装即可，教程都是中文，很友好了。
在这里插入图片描述

1.2、安装过程2

ubutn16安装过后，可以正常安装
但是跑例子时候，会报错（不知道是否是不同的系统导致，安装教程中是推荐ubuntu18，)

Milvus 避坑攻略
以上是开发者写的注意事项

milvus.client.exceptions.NotConnectError: Fail connecting to server on 127.0.0.1:19530. Timeout
所以下面再容器内部，手动开启一下server ，就可以跑例子了

在这里插入图片描述
Docker 19.03，增加了对–gpus选项的支持,不要用低版本

2 使用

零基础实战行人重识别ReID项目-基于Milvus的以图搜图
 官方网站
在这里插入图片描述

2.1 example.py 的测试代码中的参数设置问题

如何设置 Milvus 客户端参数

在这里插入图片描述
1、IVFLAT 和 SQ8 索引都是通过聚类算法把大量的向量划分成很多‘簇’（也可以叫‘桶’）

IVFLAT 和 SQ8（ ivfsq8）前者是4个字节表示一个浮点数，后者是一个字节表示浮点数，所以占用内存更少但是精度会有一点损失，更适合超大规模数据评估。ivfsq8的搜索速度没有ivflat快，因为它涉及到一次解码操作,sq8搜索的时候需要把每一个维度上的uint8还原成float数，所以会需要一部分时间（具体细节可以和作者沟通）

2、index_file_size=1024 对精度没有影响，对速度有影响
例如 2.5个G的数据会分割成为2个 segment,每个segment 1024的容量，
然后会为每个segment 建立例如SQ8索引，剩下0.5G不够1024容量，不会建立索引index，所以这部分会慢一点。
实际操作是可以手动建立一个不足 index_file_size容量的索引，加快处理速度

3、nlist 和 nprobe 对精度有影响

1024/32 =nlist/nprobe 表示为每一个segment，建立1024个聚类中心，选择距离最近的32个中心，进行搜索，剩下的会丢弃，所以会有精度的损失，如果想要遍历所有底库数据，那么nprobe==nlist，这时候也是精度最准确（遍历了所有底库数据），耗时最高的方式，作者实验文档中，有各种测试的精度差异，根据此来选择一个最合适的时间和精度测试

2.2 修改例子，进行reid 的rank map 测试，减少评估时间

但是没有 rerank 的过程，以下是余弦距离搜索过程，根据官方提供的接口

status, ids = milvus.insert(collection_name=collection_name, records=vectors,ids =vector_ids )
一次加载不超过256M大小，所以循环调用这句话， id不重复，加载大量数据
输入特征向量改成自己模型的输出向量(都需要做归一化）
如果查询很大集也很大，分批次search 统计结果
status, results = milvus.search(**param)

github example.py 接口使用范例

# This program demos how to connect to Milvus vector database,
# create a vector collection,
# insert 10 vectors,
# and execute a vector similarity search.

import random
import numpy as np
from sklearn import preprocessing
from milvus import Milvus, IndexType, MetricType, Status
import time
# Milvus server IP address and port.
# You may need to change _HOST and _PORT accordingly.
_HOST = '127.0.0.1'
_PORT = '19530'  # default value
# _PORT = '19121'  # default http value

# Vector parameters
_DIM = 2048  # dimension of vector
_INDEX_FILE_SIZE = 32  # max file size of stored index
# create index of vectors, search more rapidly
index_param = {
    'nlist': 2048
}

def load_gallery_feat(milvus,collection_name):
    t1=time.time()
    vectors = np.random.rand(5000, _DIM).astype(np.float32)
    vectors = preprocessing.normalize(vectors)

    # Insert vectors into demo_collection, return status and vectors id list
    vector_ids = [id for id in range(5000)]
    status, ids = milvus.insert(collection_name=collection_name, records=vectors,ids =vector_ids ) #一次数据不超过256M, 2048*4*1000
    vectors = np.random.rand(5000, _DIM).astype(np.float32)
    vectors = preprocessing.normalize(vectors)

    # Insert vectors into demo_collection, return status and vectors id list
    vector_ids = [id for id in range(5000,10000)]
    status, ids = milvus.insert(collection_name=collection_name, records=vectors,ids =vector_ids ) #一次数据不超过256M,太大报错写个for循环
    print("********************加载底库数据时间***************")
    print(time.time()-t1)
    if not status.OK():
        print("Insert failed: {}".format(status))
    # Flush collection  inserted data to disk.
    milvus.flush([collection_name])
    # Get demo_collection row count
    status, result = milvus.count_entities(collection_name)

    # present collection statistics info
    _, info = milvus.get_collection_stats(collection_name)
    # print(info)

    # Obtain raw vectors by providing vector ids
    status, result_vectors = milvus.get_entity_by_id(collection_name, ids[:10])

def map_top_test(milvus,collection_name,query_ids,query_vectors,query_camids):
    '''

    :param milvus: 调用库接口名字
    :param collection_name:
    :param query_ids:  一维列表
    :param query_vectors:  二维向量
    :return: map@topk  rank
    '''
    # execute vector similarity search
    search_param = {
        "nprobe": 16
    }
    print("Searching ... ")


    top_k = 100
    n=50 #一次搜索n张查询图片
    interval= len(query_vectors)//n  +1  #分批次处理，一次处理5000个查询图片

    all_AP = []
    rank = []
    # 因为计算容量问题，分批次搜索，
    for i in range(interval):
        if i==interval-1: #没有整除的间隔， 当前到最后剩下的向量
            query_vectors[(n * i):]
        else:
            query_vectors[(n*i):(n*(i+1))]

        param = {
            'collection_name': collection_name,
            'query_records': query_vectors,
            'top_k': top_k,
            'params': search_param,
        }
        status, results = milvus.search(**param)  #调用搜索接口，返回排序后的 id 和 距离值

        '''
        返回result格式  表示每张张图片有top2个结果返回
        [
            [
            (id:5424, distance:0.7716852426528931),
            (id:6754, distance:0.7707215547561646)
            ],
            
            [
            (id:8222, distance:0.7703074216842651),
            (id:3993, distance:0.7664945721626282)
        ],
        '''
        num_valid_q=0
        for i,out in enumerate(results):  # milvus返回的数据结果格式解析，i 用来访问查询lab
            # id 解析， 12305  最后两位是camid  前面的是 底库图片 id
            topk = []
            gcamid = []
            for i in range(top_k): #得到排序后的图片对应的，id 和 camid，列表
                t=int,str(out[i].id)
                topk.append((map(int,t[:-2]))) #一维列表，一张图片的topk个搜寻结果 id，字符串格式)
                gcamid.append(map(int,t[-2:]))# 字符串格式
            match = (np.array(topk) == query_ids[i]).astype(np.int32)  # 一个向量和一个值比对，实现的功能是 一个查询图片label ,和底库topk张label,比对，相等1，不等0

            remove = (query_ids[i] == np.array(topk)) & (query_camids[i] == gcamid)  # 1 和[1 2 1] ==后返回[true false true]
            keep = np.invert(remove)  # true false 反过来，为了下面一行删除 keep 的 true 对应位置底库图片比对
            match= match[keep]  #删除了底库中搜索的对应相同相机id下行人检索结果，[1 0 1 ][true false false] ->[0 1]，相当于删除底库的一个比对图片，排序索引应该移动变化的操作

            if not np.any(match):  # 全是0执行这里， 全是0表示 ，底库没有这张查询图片的label
                continue
            num_rel = match.sum()
            cmc = match.cumsum() #累加和[1 1 0]  返回[1  1+1  1+1+0]= [1 2 2],维度不变，对应位置匹配的数量，计算precise的分子
            tmp_cmc = [x / (i + 1.) for i, x in enumerate(cmc)]  # 循环列表元素，索引加1 top的位置也就是分母，列表元素是当前位置累加正确lab个数，分子
            tmp_cmc = np.asarray(tmp_cmc) * match  #上面是每个位置都计算了值，但是id不匹配位置的值不需要，对应match中的0
            AP = tmp_cmc.sum() / num_rel  # 一张查询图片得到的 ap
            all_AP.append(AP)  #长度是查询数据集的长度

            cmc[cmc > 1] = 1
            rank.append(cmc) #添加的是[[0 1 1] [1 1 1]]这样，当前位置id相等1， 后面全都是1 ，因为top 计算
            num_valid_q += 1.  # 这个绝对不等于num_q 注意上面有个continue,情况


    all_cmc = np.asarray(rank).astype(np.float32)  #所有测试图片匹配结果 （n,topk), n个，每个测试图片[0 1 1...]结果
    all_cmc = all_cmc.sum(0) / (num_valid_q)
    # Delete demo_collection
    status = milvus.drop_collection(collection_name)
    return all_AP,all_cmc  

def main():
    # Specify server addr when create milvus client instance
    # milvus client instance maintain a connection pool, param
    # `pool_size` specify the max connection num.
    milvus = Milvus(_HOST, _PORT)
    # Create collection demo_collection if it dosen't exist.
    collection_name = 'example_collection_'

    status, ok = milvus.has_collection(collection_name)
    if not ok:
        param = {
            'collection_name': collection_name,
            'dimension': _DIM,
            'index_file_size': _INDEX_FILE_SIZE,  # optional
            'metric_type': MetricType.IP  # optional L2 IP， 距离需要归一化输入
        }

        milvus.create_collection(param)

    # Show collections in Milvus server
    _, collections = milvus.list_collections()

    # Describe demo_collection
    _, collection = milvus.get_collection_info(collection_name)
    print(collection)

    ####################################################################################
    #添加自己的底库数据
    load_gallery_feat(milvus, collection_name)

    # Create ivflat index in demo_collection
    # You can search vectors without creating index. however, Creating index help to
    # search faster
    print("Creating index: {}".format(index_param))
    status = milvus.create_index(collection_name, IndexType.IVF_FLAT, index_param)

    # describe index, get information of index
    status, index = milvus.get_index_info(collection_name)
    # print(index)

    query_vectors =  np.random.rand(56, _DIM).astype(np.float32)
    query_vectors = preprocessing.normalize(query_vectors)
    query_ids = [id for id in range(56)]

    all_AP ,rank = map_top_test(milvus, collection_name, query_ids, query_vectors)
    if len(all_AP)<=0:
        print ("没有在底库中搜索到同样label的图片")
        return
    mAP = np.mean(all_AP)
    print("map@50:",mAP)
    print("top1:",rank[0])
    print("top10:",rank[9])


if __name__ == '__main__':
    main()
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195