一篇文章带你学会向量数据库Milvus

一篇文章带你学会向量数据库Milvus
索引管理

Milvus 提供多种索引类型来对字段值举行排序，以实现高效的相似性搜刮。它还提供三种度量类型：余弦相似度 (COSINE)、欧几里得间隔 (L2) 和内积 （IP）来测量向量嵌入之间的间隔。
   建议对常常利用的向量字段和标量字段创建索引
  如果集合创建哀求中指定了以下任一条件，Milvus 在创建集合时会自动生成索引并将其加载到内存中：

• 向量的维度和类型
  
• schema 和索引参数
  

下面的代码片断重新调整了现有代码的用途，以建立与 Milvus 实例的毗连并创建一个集合，而无需指定其索引参数。在这种情况下，集合缺少索引而且保持卸载状态。

1. from pymilvus import MilvusClient, DataType
2. ​
3. # 实例化客户端，连接 Milvus 服务
4. client = MilvusClient(
5.      uri="http://localhost:19530"
6. )
7. ​
8. # 创建 schema
9. schema = MilvusClient.create_schema(
10.      auto_id=False,
11.      enable_dynamic_field=True,
12. )
13. ​
14. # schema 添加字段 id、vector
15. schema.add_field(field_name="id", datatype=DataType.INT64, is_primary=True)
16. schema.add_field(field_name="vector", datatype=DataType.FLOAT_VECTOR, dim=5)
17. ​
18. # 创建集合
19. client.create_collection(
20.      collection_name="demo_v4",
21.      schema=schema,
22. )

复制代码

集合索引

要为集合创建索引或为集合建立索引，我们需要设置索引参数并调用create_index()。

1. # 设置索引的参数
2. index_params = MilvusClient.prepare_index_params()
3. ​
4. # 在向量字段 vector 上面添加一个索引
5. index_params.add_index(
6.      field_name="vector",
7.      metric_type="COSINE",
8.      index_type=,
9.      index_name="vector_index"
10. )
11. ​
12. # 在集合demo_v4创建索引文件
13. client.create_index(
14.      collection_name="demo_v4",
15.      index_params=index_params
16. )

复制代码

  Milvus 现在只支持为集合的每个字段创建一个索引文件
  检察索引详细信息

创建索引后我们可以检索索引的详细信息：

1. res = client.list_indexes(
2.      collection_name="demo_v4"
3. )
4. ​
5. # Output
6. #
7. # [
8. #     "vector_index",
9. # ]
10. ​
11. res = client.describe_index(
12.      collection_name="demo_v4",
13.      index_name="vector_index"
14. )
15. ​
16. # Output
17. #
18. # {
19. #     "index_type": ,
20. #     "metric_type": "COSINE",
21. #     "field_name": "vector",
22. #     "index_name": "vector_index"
23. # }

复制代码

  我们可以检察针对特定字段创建的索引文件，并统计利用该索引简历的索引行数。类比 关系性数据库的索引。
  删除索引

如果不在需要索引，我们可以删除相关的索引

1. client.drop_index(
2.      collection_name="demo_v4",
3.      index_name="vector_index"
4. )

复制代码

检索标量字段

什么是标量字段？变量字段就是除 vector 字段，id 字段之外的字段。在 Milvus 中，标量索引用于加速特定非向量字段值的元过滤，类似于传统的数据库索引。
变量索引类型

• auto-index Milvus 根据标量字段的数据类型自动决定索引类型。这实用于不需要控制详细索引类型的情况。
  
• custom-index 可以指定明确的索引类型，好比倒排索引。这就提供了对索引的类型的更多选择。
  

Auto index 自动索引

要利用自动索引，请省略 index_type 参数，以便 Milvus 可以根据标量字段类型推断索引类型。
例子：

1. # Auto indexing
2. client = MilvusClient(
3.      uri="http://localhost:19530"
4. )
5. #准备一个空的IndexParams对象，无需指定任何索引参数。
6. index_params = client.create_index_params()
7. ​
8. index_params.add_index(
9.      field_name="scalar_1", # 要索引的标量字段的名称
10.      index_type="", # 要创建的索引类型。对于自动索引，请将其留空或省略此参数。
11.      index_name="default_index" # 要创建的指数名称
12. )
13. ​
14. # 在集合中添加索引
15. client.create_index(
16.    collection_name="demo_v4", # 指定集合名称
17.    index_params=index_params
18. )

复制代码

自界说索引

如果我们要利用自界说索引，请在 index_type 参数中指定特定索引类型。
看下面的例子：

1. index_params = client.create_index_params() #  准备一个 IndexParams 对象
2. ​
3. index_params.add_index(
4.      field_name="scalar_2", # 标量字段名称
5.      index_type="INVERTED", # 明确索引类型
6.      index_name="inverted_index" # 索引的名称
7. )
8. ​
9. client.create_index(
10.    collection_name="demo_v4", # 将索引添加到集合中
11.    index_params=index_params
12. )

复制代码

对于自界说索引，有效值为：

• INVERTED：（推荐）倒排索引由术语词典组成，此中包罗按字母顺序排序的全部标记化单词。有关详细信息，请参阅标量索引。
  
• STL_SORT：利用标准模板库排序算法对标量字段举行排序。支持布尔和数字字段（比方 INT8、INT16、INT32、INT64、FLOAT、DOUBLE）。
  
• Trie：用于快速前缀搜刮和检索的树形数据布局。支持 VARCHAR 字段。
  

索引检索

利用 list_indexes() 方法验证标量索引的创建：

1. client.list_indexes(
2.      collection_name="demo_v4"  # 指定集合名称
3. )
4. ​
5. # Output:
6. # ['default_index','inverted_index']

复制代码

索引限定

现在，标量索引支持 INT8、INT16、INT32、INT64、FLOAT、DOUBLE、BOOL 和 VARCHAR 数据类型，但不支持 JSON 和 ARRAY 类型。
数据 CRUD

在 Milvus 集合的上下文中，实体是集合中单个、可识别的实例。它代表特定种别的独特成员，无论是图书馆中的一本书、基因组中的基因还是任何其他可识别的实体。
集合中的实体共享一组通用的属性，称为schema，概述了每个实体必须遵守的布局，包括字段名称、数据类型和任何其他束缚。
将实体成功插入集合中要求提供的数据应包罗目标集合的全部架构界说字段。别的，仅当您启用了动态字段时，您还可以包罗非架构界说的字段。
准备工作

1. from pymilvus import MilvusClient
2. ​
3. # Milvus 连接数据库
4. client = MilvusClient(
5.      uri="http://localhost:19530"
6. )
7. ​
8. # 创建 collection
9. client.create_collection(
10.      collection_name="demo_v5",
11.      dimension=5,
12.      metric_type="IP"
13. )

复制代码

插入实体

要插入实体，您需要将数据组织到字典列表中，此中每个字典代表一个实体。每个字典都包罗与目标集合中的预界说字段和动态字段对应的键。

1. # 3. Insert some data
2. data=[
3.     {"id": 0, "vector": [0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592], "color": "pink_8682"},
4.     {"id": 1, "vector": [0.19886812562848388, 0.06023560599112088, 0.6976963061752597, 0.2614474506242501, 0.838729485096104], "color": "red_7025"},
5.     {"id": 2, "vector": [0.43742130801983836, -0.5597502546264526, 0.6457887650909682, 0.7894058910881185, 0.20785793220625592], "color": "orange_6781"},
6.     {"id": 3, "vector": [0.3172005263489739, 0.9719044792798428, -0.36981146090600725, -0.4860894583077995, 0.95791889146345], "color": "pink_9298"},
7.     {"id": 4, "vector": [0.4452349528804562, -0.8757026943054742, 0.8220779437047674, 0.46406290649483184, 0.30337481143159106], "color": "red_4794"},
8.     {"id": 5, "vector": [0.985825131989184, -0.8144651566660419, 0.6299267002202009, 0.1206906911183383, -0.1446277761879955], "color": "yellow_4222"},
9.     {"id": 6, "vector": [0.8371977790571115, -0.015764369584852833, -0.31062937026679327, -0.562666951622192, -0.8984947637863987], "color": "red_9392"},
10.     {"id": 7, "vector": [-0.33445148015177995, -0.2567135004164067, 0.8987539745369246, 0.9402995886420709, 0.5378064918413052], "color": "grey_8510"},
11.     {"id": 8, "vector": [0.39524717779832685, 0.4000257286739164, -0.5890507376891594, -0.8650502298996872, -0.6140360785406336], "color": "white_9381"},
12.     {"id": 9, "vector": [0.5718280481994695, 0.24070317428066512, -0.3737913482606834, -0.06726932177492717, -0.6980531615588608], "color": "purple_4976"}
13. ]
15. res = client.insert(
16.     collection_name="demo_v5",
17.     data=data
18. )

复制代码

插入分区

要将数据插入到特定分区，可以在插入哀求中指定分区名称，如下所示：

1. data=[
2.     {"id": 10, "vector": [-0.5570353903748935, -0.8997887893201304, -0.7123782431855732, -0.6298990746450119, 0.6699215060604258], "color": "red_1202"},
3.     {"id": 11, "vector": [0.6319019033373907, 0.6821488267878275, 0.8552303045704168, 0.36929791364943054, -0.14152860714878068], "color": "blue_4150"},
4.     {"id": 12, "vector": [0.9483947484855766, -0.32294203351925344, 0.9759290319978025, 0.8262982148666174, -0.8351194181285713], "color": "orange_4590"},
5.     {"id": 13, "vector": [-0.5449109892498731, 0.043511240563786524, -0.25105249484790804, -0.012030655265886425, -0.0010987671273892108], "color": "pink_9619"},
6.     {"id": 14, "vector": [0.6603339372951424, -0.10866551787442225, -0.9435597754324891, 0.8230244263466688, -0.7986720938400362], "color": "orange_4863"},
7.     {"id": 15, "vector": [-0.8825129181091456, -0.9204557711667729, -0.935350065513425, 0.5484069690287079, 0.24448151140671204], "color": "orange_7984"},
8.     {"id": 16, "vector": [0.6285586391568163, 0.5389064528263487, -0.3163366239905099, 0.22036279378888013, 0.15077052220816167], "color": "blue_9010"},
9.     {"id": 17, "vector": [-0.20151825016059233, -0.905239387635804, 0.6749305353372479, -0.7324272081377843, -0.33007998971889263], "color": "blue_4521"},
10.     {"id": 18, "vector": [0.2432286610792349, 0.01785636564206139, -0.651356982731391, -0.35848148851027895, -0.7387383128324057], "color": "orange_2529"},
11.     {"id": 19, "vector": [0.055512329053363674, 0.7100266349039421, 0.4956956543575197, 0.24541352586717702, 0.4209030729923515], "color": "red_9437"}
12. ]
14. # 创建分区
15. client.create_partition(
16.     collection_name="demo_v4",
17.     partition_name="partitionA"
18. )
20. # 分区中插入数据
21. res = client.insert(
22.     collection_name="demo_v4",
23.     data=data,
24.     partition_name="partitionA"
25. )

复制代码

更新插入数据

更新插入数据是更新和插入操作的组合。在 Milvus 中，upsert 操作实行数据级操作，根据集合中是否已存在主键来插入或更新实体。详细来说：

• 如果集合中已存在该实体的主键，则现有实体将被覆盖。
  
• 如果集合中不存在主键，则将插入一个新实体。
  

1. data=[
2.     {"id": 0, "vector": [-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911], "color": "black_9898"},
3.     {"id": 1, "vector": [0.4762662251462588, -0.6942502138717026, -0.4490002642657902, -0.628696575798281, 0.9660395877041965], "color": "red_7319"},
4.     {"id": 2, "vector": [-0.8864122635045097, 0.9260170474445351, 0.801326976181461, 0.6383943392381306, 0.7563037341572827], "color": "white_6465"},
5.     {"id": 3, "vector": [0.14594326235891586, -0.3775407299900644, -0.3765479013078812, 0.20612075380355122, 0.4902678929632145], "color": "orange_7580"},
6.     {"id": 4, "vector": [0.4548498669607359, -0.887610217681605, 0.5655081329910452, 0.19220509387904117, 0.016513983433433577], "color": "red_3314"},
7.     {"id": 5, "vector": [0.11755001847051827, -0.7295149788999611, 0.2608115847524266, -0.1719167007897875, 0.7417611743754855], "color": "black_9955"},
8.     {"id": 6, "vector": [0.9363032158314308, 0.030699901477745373, 0.8365910312319647, 0.7823840208444011, 0.2625222076909237], "color": "yellow_2461"},
9.     {"id": 7, "vector": [0.0754823906014721, -0.6390658668265143, 0.5610517334334937, -0.8986261118798251, 0.9372056764266794], "color": "white_5015"},
10.     {"id": 8, "vector": [-0.3038434006935904, 0.1279149203380523, 0.503958664270957, -0.2622661156746988, 0.7407627307791929], "color": "purple_6414"},
11.     {"id": 9, "vector": [-0.7125086947677588, -0.8050968321012257, -0.32608864121785786, 0.3255654958645424, 0.26227968923834233], "color": "brown_7231"}
12. ]
14. # 插入与更新
15. res = client.upsert(
16.     collection_name='demo_v4',
17.     data=data
18. )

复制代码

分区更新也是同样的操作：

1. res = client.upsert(
2.     collection_name="demo_v4",
3.     data=data,
4.     partition_name="partitionA" # 指定分区名称
5. )

复制代码

删除实体

如果不再需要某个实体，您可以将其从集合中删除。 Milvus 提供两种方式供您识别要删除的实体。

• 通过过滤器删除实体。
  
• 按 ID 删除实体。
  

1. # 按过滤器删除
2. res = client.delete(
3.     collection_name="quick_setup",
4.     filter="id in [4,5,6]"
5. )

复制代码

1. # 按 id 删除
2. res = client.delete(
3.     collection_name="quick_setup",
4.     ids=[18, 19],
5.     partition_name="partitionA"
6. )

复制代码

向量查询

插入数据后，下一步是在 Milvus 中检索集合实行相似性搜刮。
Milvus 允许您举行两种类型的搜刮，详细取决于集合中向量字段的数量：

• 单向量搜刮：如果您的集合只有一个向量字段，请利用search()方法查找最相似的实体。此方法将您的查询向量与集合中的现有向量举行比较，并返回最接近匹配的 ID 以及它们之间的间隔。或者，它还可以返回效果的向量值和元数据。
  
• 多向量搜刮：对于具有两个或多个向量场的集合，请利用hybrid_search()方法。此方法实行多个近似近来邻 (ANN) 搜刮哀求，并组合效果以在重新排名后返回最相关的匹配项。
  

多种搜刮类型可以满足不同的搜刮需求：

• 基本搜刮：包括单向量搜刮、批量向量搜刮、分区搜刮和指定输出字段搜刮。
  
• 过滤搜刮： 应用基于标量字段的过滤条件来细化搜刮效果。
  
• 范围搜刮： 查找距查询向量特定间隔范围内的向量。
  
• 分组搜刮： 根据特定字段对搜刮效果举行分组，以确保效果的多样性。
  

基本搜刮：

发送 search 哀求时，我们可以提供一个或多个表示查询嵌入的向量值以及指示要返回的效果数的 limit 值。根据数据和查询向量，我们获得的效果可能会少于 limit 个。当 limit 大于查询可能匹配向量的数量时，就会发生这种情况。
单向量搜刮

单向量搜刮是 Milvus 中search操作的最简朴形式，旨在查找与给定查询向量最相似的向量。
要实行单向量搜刮，请指定目标集合名称、查询向量和所需的效果数量 (limit)。此操作返回一个效果集，此中包罗最相似的向量、它们的 ID 以及与查询向量的间隔。
批量向量搜刮

批量向量搜刮通过允许在单个哀求中搜刮多个查询向量来扩展单向量搜刮概念。这种类型的搜刮非常适合需要为一组查询向量查找相似向量的场景，从而显着减少所需的时间和计算资源。
在批量向量搜刮中，您可以在 data 字段中包罗多个查询向量。系统并行处理这些向量，为每个查询向量返回一个单独的效果集，每个效果集包罗在集合中找到的最接近的匹配项。
下面是从两个查询向量中搜刮两个不同的最相似实体集的示例：

1. # 批量向量搜索
2. res = client.search(
3.     collection_name="demo_v4",
4.     data=[
5.         [0.19886812562848388, 0.06023560599112088, 0.6976963061752597, 0.2614474506242501, 0.838729485096104],
6.         [0.3172005263489739, 0.9719044792798428, -0.36981146090600725, -0.4860894583077995, 0.95791889146345]
7.     ],
8.     limit=2,
9.     search_params={"metric_type": "IP", "params": {}}
10. )
12. result = json.dumps(res, indent=4)

复制代码

分区搜刮

分区搜刮将搜刮范围缩小到集合的特定子集或分区。这对于有组织的数据集特殊有效，此中数据被分段为逻辑或分类部分，从而通过减少要扫描的数据量来实现更快的搜刮操作。
要举行分区搜刮，只需在搜刮哀求的 partition_names 中包罗目标分区的名称即可。这指定search操作仅考虑指定分区内的向量。

1. res = client.search(
2.     collection_name="test_collection",
3.     data=[[0.02174828545444263, 0.058611125483182924, 0.6168633415965343, -0.7944160935612321, 0.5554828317581426]],
4.     limit=5,
5.     search_params={"metric_type": "IP", "params": {}},
6.     partition_names=["partition_1"] # 这里指定搜索的分区
7. )

复制代码

利用输出字段举行搜刮

利用输出字段举行搜刮允许您指定搜刮效果中应包罗匹配向量的哪些属性或字段。
您可以在哀求中指定output_fields以返回包罗特定字段的效果。

1. # 输出字段搜索
2. res = client.search(
3.     collection_name="test_collection",
4.     data=[[0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592]],
5.     limit=5,
6.     search_params={"metric_type": "IP", "params": {}},
7.     output_fields=["color"] # 返回定义的字段
8. )

复制代码

过滤搜刮

筛选搜刮将标量筛选器应用于矢量搜刮，允许我们根据特定条件优化搜刮效果。
比方，要根据字符串模式优化搜刮效果，可以利用 like 运算符。此运算符通过考虑前缀、中缀和后缀来启用字符串匹配：

• 若要匹配以特定前缀开头的值，请利用语法. 如: ‘like “prefix%”’ 。
  
• 若要匹配字符串中任意位置包罗特定字符序列的值，请利用语法 ‘like “%infix%”’
  
• 若要匹配以特定后缀结尾的值，请利用语法: ‘like “%suffix”’ .
  
• like 运算符还可以通过利用下划线 （_） 表示任何单个字符来用于单字符匹配。 ‘like “y_llow”’ .
  

筛选颜色以绿色为前缀的效果：

1. # 过滤器搜索
2. res = client.search(
3.     collection_name="test_collection",
4.     data=[[0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592]],
5.     limit=5,
6.     search_params={"metric_type": "IP", "params": {}},
7.     output_fields=["color"],
8.     filter='color like "gree%"'
9. )

复制代码

范围搜刮

范围搜刮允许查找距查询向量指定间隔范围内的向量。
通过设置 radius 和可选的 range_filter，可以调整搜刮的广度以包罗与查询向量有些相似的向量，从而提供潜在匹配的更全面的视图。

• radius：界说搜刮空间的外界限。只有距查询向量在此间隔内的向量才被视为潜在匹配。
  
• range_filter：固然radius设置搜刮的外部限定，但可以选择利用range_filter来界说内部界限，创建一个间隔范围，在该范围内向量必须落下才被视为匹配。
  

1. # 范围搜索
2. search_params = {
3.     "metric_type": "IP",
4.     "params": {
5.         "radius": 0.8, # 搜索圆的半径
6.         "range_filter": 1.0 # 范围过滤器，用于过滤出不在搜索圆内的向量。
7.     }
8. }
10. res = client.search(
11.     collection_name="test_collection",
12.     data=[[0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592]],
13.     limit=3, # 返回的搜索结果最大数量
14.     search_params=search_params,
15.     output_fields=["color"],
16. )

复制代码

更多搜刮方式可以参考 Milvus 官网。
多向量搜刮

在 Milvus2.4 版本开始，引入了多想两支持和混合搜刮功能。这就意味着用户可以将多个向量字段引入到单个集合中。不同的向量长可以表示不同的方面，不同的 embedding Model 以致表征同一实体的不同数据模态。这同时意味着扩展了信息的丰富性。有了这个功能我们可以在综合场景利用，好比：根据图片、语言、指纹等各种属性来识别向量中最相似的人。
多向量搜刮支持在各种字段上实行搜刮哀求，并利用重新排名策略的组合效果。
示例：

1. from pymilvus import connections, Collection, FieldSchema, CollectionSchema, DataType
2. import random
4. # 连接 Milvus
5. connections.connect(
6.     host="127.0.0.1", # 可以替换为自己的服务地址
7.     port="19530"
8. )
10. # 创建 schema
11. fields = [
12.     FieldSchema(name="film_id", dtype=DataType.INT64, is_primary=True),
13.     FieldSchema(name="filmVector", dtype=DataType.FLOAT_VECTOR, dim=5), # 向量字段
14.     FieldSchema(name="posterVector", dtype=DataType.FLOAT_VECTOR, dim=5)] # 向量字段
16. schema = CollectionSchema(fields=fields,enable_dynamic_field=False)
18. # 创建 collection
19. collection = Collection(name="test_collection", schema=schema)
21. # 添加索引
22. index_params = {
23.     "metric_type": "L2",
24.     "index_type": "IVF_FLAT",
25.     "params": {"nlist": 128},
26. }
27. # 字段 filmVector 创建索引
28. collection.create_index("filmVector", index_params)
29. # 字段 posterVector 创建索引
30. collection.create_index("posterVector", index_params)
32. # 向量数据库中插入的实体
33. entities = []
35. for _ in range(1000):
36.     # 构造实体
37.     film_id = random.randint(1, 1000)
38.     film_vector = [ random.random() for _ in range(5) ]
39.     poster_vector = [ random.random() for _ in range(5) ]
41.     entity = {
42.         "film_id": film_id,
43.         "filmVector": film_vector,
44.         "posterVector": poster_vector
45.     }
46.     entities.append(entity)
47. # 集合中插入实体   
48. collection.insert(entities)

复制代码

创建 AnnSearchRequest 实例

多向量搜刮利用 hybrid_search() API 在一次调用中实行多个 ANN 搜刮哀求。每个 AnnSearchRequest 代表特定矢量场上的单个搜刮哀求。
示例创建两个 AnnSearchRequest 实例以对两个向量字段实行单独的相似性搜刮。

1. from pymilvus import AnnSearchRequest
3. # 创建多搜索请求 filmVector
4. query_filmVector = [[0.8896863042430693, 0.370613100114602, 0.23779315077113428, 0.38227915951132996, 0.5997064603128835]]
6. search_param_1 = {
7.     "data": query_filmVector, # 请求查询的向量数据
8.     "anns_field": "filmVector", # 搜索的向量字段 filmVector
9.     "param": {
10.         "metric_type": "L2", # 该参数值必须与集合模式中使用的值相同。
11.         "params": {"nprobe": 10}
12.     },
13.     "limit": 2 # 限定 AnnSearchRequest 搜索中返回的结束数量
14. }
15. request_1 = AnnSearchRequest(**search_param_1)
17. # 创建多搜索请求 posterVector
18. query_posterVector = [[0.02550758562349764, 0.006085637357292062, 0.5325251250159071, 0.7676432650114147, 0.5521074424751443]]
19. search_param_2 = {
20.     "data": query_posterVector, #请求查询的向量数据
21.     "anns_field": "posterVector", # 搜索的向量字段 posterVector
22.     "param": {
23.         "metric_type": "L2", # 该参数值必须与集合模式中使用的值相同。
24.         "params": {"nprobe": 10}
25.     },
26.     "limit": 2 # 限定 AnnSearchRequest 搜索中返回的结束数量
27. }
28. request_2 = AnnSearchRequest(**search_param_2)
30. reqs = [request_1, request_2]

复制代码

设置排名策略

创建 AnnSearchRequest 实例后，设置重新排名策略以组合效果并重新排名。现在有两个选项：WeightedRanker 和 RRFRanker。

• 利用加权评分：WeightedRanker 用于为每个具有指定权重的向量场搜刮效果分配重要性。如果将某些向量字段的优先级置于其他向量字段之上，WeightedRanker(value1, value2, ..., valueN) 可以在组合搜刮效果中提现出来。
  

1. from pymilvus import WeightedRanker
2. # 使用 WeightedRanker 来结合具有指定权重的结果
3. # 将文本搜索赋予权重 0.8，将图像搜索赋予权重 0.2。
4. rerank = WeightedRanker(0.8, 0.2)  

复制代码

  利用WeightedRanker时，请注意：
  每个权重值的范围从 0（最不重要）到 1（最重要），影响终极的总分。
  WeightedRanker 中提供的权重值总数应便是您创建的 AnnSearchRequest 实例的数量。
  实行混合搜刮

设置 AnnSearchRequest 实例和重新排名策略后，利用 hybrid_search() 方法实行多向量搜刮。

1. # 在进行多向量搜索之前，将集合加载到内存中。
2. collection.load()
4. res = collection.hybrid_search(
5.     reqs, # 第1步创建的AnnSearchRequests列表
6.     rerank, # 在第2步指定的重新排序策略
7.     limit=2 # 限定最终返回数据量
8. )

复制代码

参数说明：

• reqs： 搜刮哀求列表，此中每个哀求都是一个 ANNSearchRequest 对象。每个哀求可以对应于不同的矢量场和不同的搜刮参数集。
  
• rerank（对象）：用于混合搜刮的重新排名策略。可能的值：WeightedRanker(value1, value2, ..., valueN) 和 RRFRanker()。
  
• limit (int)：混合搜刮中返回的终极效果的最大数量。
  

limits 限定

• 通常，每个集合默认允许最多 4 个向量字段。但是，您可以选择调整 proxy.maxVectorFieldNum 设置以扩展集合中矢量字段的最大数量，每个集合的最大限定为 10 个矢量字段
  
• 集合中部分索引或加载的向量字段将导致错误。
  
• 现在，混合搜刮中的每个 AnnSearchRequest 只能携带一个查询向量。
  

怎样学习AI大模型？

我在一线互联网企业工作十余年里，指导过不少同行子弟。资助很多人得到了学习和成长。
自己也整理很多AI大模型资料：AI大模型入门学习头脑导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

第一阶段： 从大模型系统设计入手，讲解大模型的主要方法；
第二阶段： 在通过大模型提示词工程从Prompts角度入手更好发挥模型的作用；
第三阶段： 大模型平台应用开发借助阿里云PAI平台构建电商领域假造试衣系统；
第四阶段： 大模型知识库应用开发以LangChain框架为例，构建物流行业咨询智能问答系统；
第五阶段： 大模型微调开发借助以大健康、新零售、新媒体领域构建适合当前领域大模型；
第六阶段： 以SD多模态大模型为主，搭建了文生图小步调案例；
第七阶段： 以大模型平台应用与开发为主，通过星火大模型，文心大模型等成熟大模型构建大模型行业应用。