id: search.md related_key: search

summary: Conduct a vector similarity search with Milvus.

向量相似性搜索

本主题介绍如何使用 Milvus 搜索 entities 。

Milvus 中的向量相似度搜索计算查询向量与 collection 中具有指定相似度度量的向量之间的距离，并返回最相似的结果。通过指定过滤标量 field 或者 primary key field 的 布尔表达式 ，你可以执行 混合搜索，甚至使用 Time Travel 来进行搜索。

下面的例子展示了如何对一个拥有 2000 行数据的数据集进行向量相似度搜索，模拟你基于书籍介绍的特征向量搜索某些书籍的情况。该数据集包含 book ID (primary key) 、 word count (scalar field) 和 book introduction (vector field)。 Milvus 会根据你定义的查询向量和搜索参数返回最相似的结果。

加载 collection

Milvus 中的所有搜索和结构化匹配操作都在内存中执行。在执行向量相似性搜索之前将 collection 加载到内存中。

{{fragments/multiple_code.md}}

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.load()

await milvusClient.collectionManager.loadCollection({
  collection_name: "book",
});

err := milvusClient.LoadCollection(
    context.Background(),   // ctx
    "book",                 // CollectionName
    false                   // async
    )
if err != nil {
    log.Fatal("failed to load collection:", err.Error())
}

milvusClient.loadCollection(
        LoadCollectionParam.newBuilder()
                .withCollectionName("book")
                .build());

load -c book

准备搜索参数

准备适合你的搜索场景的参数。下面的示例定义了搜索将使用欧式距离计算，并从 IVF_FLAT 索引构建的十个最近的聚类中检索向量。

{{fragments/multiple_code.md}}

search_params = {"metric_type": "L2", "params": {"nprobe": 10}}

const searchParams = {
  anns_field: "book_intro",
  topk: "2",
  metric_type: "L2",
  params: JSON.stringify({ nprobe: 10 }),
};

sp, _ := entity.NewIndexFlatSearchParam( // NewIndex*SearchParam func
    10,                                  // searchParam
)

final Integer SEARCH_K = 2;                       // TopK
final String SEARCH_PARAM = "{\"nprobe\":10}";    // Params

search
Collection name (book): book
The vectors of search data(the length of data is number of query (nq), the dim of every vector in data must be equal to vector field’s of collection. You can also import a csv file without headers): [[0.1, 0.2]]
The vector field used to search of collection (book_intro): book_intro
Metric type: L2
Search parameter nprobe's value: 10
The max number of returned record, also known as topk: 10
The boolean expression used to filter attribute []: 
The names of partitions to search (split by "," if multiple) ['_default'] []: 
timeout []:
Guarantee Timestamp(It instructs Milvus to see all operations performed before a provided timestamp. If no such timestamp is provided, then Milvus will search all operations performed to date) [0]: 
Travel Timestamp(Specify a timestamp in a search to get results based on a data view) [0]:

进行向量搜索

使用 Milvus 搜索向量。要在特定的partition中搜索，请指定 partition 名称列表。

Milvus 支持专门为搜索或结构化匹配设置一致性级别（目前仅在 PyMilvus 上）。在创建 collection 时，搜索或结构化匹配请求中设置的一致性级别将覆盖设置的一致性级别。在本例中，搜索请求的一致性级别设置为 “Strong”，这意味着 Milvus 将在搜索或结构化匹配请求出现的确切时间点读取最新的数据视图。如果在搜索或结构化匹配期间不指定一致性级别，Milvus 将采用创建 collection 的原始一致性级别。

{{fragments/multiple_code.md}}

results = collection.search(
    data=[[0.1, 0.2]], 
    anns_field="book_intro", 
    param=search_params, 
    limit=10, 
    expr=None,
    consistency_level="Strong"
)

const results = await milvusClient.dataManager.search({
  collection_name: "book",
  expr: "",
  vectors: [[0.1, 0.2]],
  search_params: searchParams,
  vector_type: 101,    // DataType.FloatVector
});

searchResult, err := milvusClient.Search(
    context.Background(),                    // ctx
    "book",                                  // CollectionName
    []string{},                              // partitionNames
    "",                                      // expr
    []string{"book_id"},                     // outputFields
    []entity.Vector{entity.FloatVector([]float32{0.1, 0.2})}, // vectors
    "book_intro",                            // vectorField
    entity.L2,                               // metricType
    2,                                       // topK
    sp,                                      // sp
)
if err != nil {
    log.Fatal("fail to search collection:", err.Error())
}

List<String> search_output_fields = Arrays.asList("book_id");
List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(0.1f, 0.2f));
SearchParam searchParam = SearchParam.newBuilder()
        .withCollectionName("book")
        .withMetricType(MetricType.L2)
        .withOutFields(search_output_fields)
        .withTopK(SEARCH_K)
        .withVectors(search_vectors)
        .withVectorFieldName("book_intro")
        .withParams(SEARCH_PARAM)
        .build();
R<SearchResults> respSearch = milvusClient.search(searchParam);

# Follow the previous step.

查看最相似向量的 primary key 及其距离值。

{{fragments/multiple_code.md}}

results[0].ids
results[0].distances

console.log(results.results)

fmt.Printf("%#v\n", searchResult)
for _, sr := range searchResult {
    fmt.Println(sr.IDs)
    fmt.Println(sr.Scores)
}

SearchResultsWrapper wrapperSearch = new SearchResultsWrapper(respSearch.getData().getResults());
System.out.println(wrapperSearch.getIDScore(0));
System.out.println(wrapperSearch.getFieldData("book_id", 0));

# Milvus CLI automatically returns the primary key values of the most similar vectors and their distances.

搜索完成时释放 Milvus 中加载的 collection 以减少内存消耗。

{{fragments/multiple_code.md}}

collection.release()

await milvusClient.collectionManager.releaseCollection({  collection_name: "book",});

err := milvusClient.ReleaseCollection(
    context.Background(),                            // ctx
    "book",                                          // CollectionName
)
if err != nil {
    log.Fatal("failed to release collection:", err.Error())
}

milvusClient.releaseCollection(
        ReleaseCollectionParam.newBuilder()
                .withCollectionName("book")
                .build());

release -c book

限制

更多内容

• 了解更多关于 Milvus 的基本操作:
  • 查询向量
  • 进行混合搜索
  • 使用 Time Travel 搜索
• 探索 Milvus SDKs 的 API 参考:
  • PyMilvus API 参考
  • Node.js API 参考