milvus-logo
LFAI
フロントページへ
  • ユーザーガイド

ハイブリッド検索

ハイブリッド検索とは、複数のANN検索を同時に行い、それらのANN検索から得られた複数の結果セットを再ランク付けし、最終的に単一の結果セットを返す検索手法である。ハイブリッド検索を使用することで、検索精度を高めることができます。Zillizは、複数のベクトル・フィールドを持つコレクションに対してハイブリッド検索を行うことをサポートしています。

ハイブリッド検索は、疎密ベクトル検索やマルチモーダル検索を含むシナリオで最も一般的に使用される。このガイドでは、Zillizでハイブリッド検索を行う方法を具体的な例を挙げて説明します。

シナリオ

ハイブリッド検索は以下の2つのシナリオに適しています。

異なるタイプのベクトルは異なる情報を表現することができ、様々な埋め込みモデルを使用することで、データの異なる特徴や側面をより包括的に表現することができます。例えば、同じ文に対して異なる埋め込みモデルを使用することで、意味的な意味を表す密なベクトルと、文中の単語頻度を表す疎なベクトルを生成することができる。

  • スパース・ベクトル：スパースベクトルは、ベクトル次元が高く、非ゼロ値が少ないという特徴がある。この構造により、従来の情報検索アプリケーションに特に適している。ほとんどの場合、スパースベクトルで使用される次元数は、1つ以上の言語にわたる異なるトークンに対応します。各次元には、文書内のそのトークンの相対的な重要度を示す値が割り当てられます。このレイアウトは、テキストのマッチングを伴うタスクに有利です。

  • 密なベクトル：密なベクトルは、ニューラルネットワークに由来する埋め込みである。順序付けられた配列に配置されたとき、これらのベクトルは入力テキストの意味的本質を捉える。密なベクトルはテキスト処理に限定されるものではなく、視覚データの意味を表現するためにコンピュータビジョンでも広く使用されている。これらの密なベクトルは、通常テキスト埋め込みモデルによって生成され、ほとんどの要素またはすべての要素が非ゼロであることを特徴とする。したがって、密なベクトルは意味検索アプリケーションに特に効果的であり、テキストが完全に一致しない場合でも、ベクトル距離に基づいて最も類似した結果を返すことができる。この機能により、キーワードベースのアプローチでは見逃されがちな概念間の関係性を捉えることができ、よりニュアンスや文脈を考慮した検索結果を得ることができます。

詳しくは、Sparse Vectorと Dense Vectorをご参照ください。

マルチモーダル検索とは、複数のモダリティ（画像、動画、音声、テキストなど）にまたがる非構造化データの類似検索を指す。例えば、人物は指紋、声紋、顔の特徴など様々なモダリティのデータを使って表現することができる。ハイブリッド検索は、複数の検索を同時にサポートする。例えば、指紋と声紋の両方が似ている人物を検索することができます。

ワークフロー

ハイブリッド検索を行うための主なワークフローは以下の通りである。

  1. BERTや Transformersのような埋め込みモデルを使って密なベクトルを生成する。

  2. BM25、BGE-M3、SPLADEなどの埋め込みモデルを使ってスパース・ベクトルを生成する。

  3. Zillizでコレクションを作成し、密なベクトル・フィールドと疎なベクトル・フィールドの両方を含むコレクション・スキーマを定義する。

  4. 前のステップで作成したコレクションに、スパース密なベクトルを挿入する。

  5. ハイブリッド検索を実行する：密なベクトルでのANN検索は、上位K個の最も類似した結果のセットを返し、疎なベクトルでのテキストマッチも上位K個の結果のセットを返します。

  6. 正規化：上位K個の結果の2つのセットのスコアを正規化し、スコアを[0,1]の間の範囲に変換する。

  7. 適切な再ランク付け戦略を選択し、2つのトップK結果セットをマージして再ランク付けし、最終的にトップK結果セットを返す。

Hybrid Search Workflow ハイブリッド検索ワークフロー

例

このセクションでは、テキスト検索の精度を高めるために、疎な密度を持つベクトルでハイブリッド検索を行う方法を、具体的な例を使って説明する。

複数のベクトル・フィールドでコレクションを作成する

コレクションを作成するプロセスには、コレクション・スキーマの定義、インデックス・パラメータの構 成、コレクションの作成の3つの部分があります。

スキーマの定義

この例では、コレクションスキーマ内で複数のベクトルフィールドを定義する必要があります。現在、各コレクションはデフォルトで最大4つのベクトルフィールドを含むことができます。しかし proxy.maxVectorFieldNum の値を変更することもできます。

以下の例では、dense とsparse の2つのベクトル・フィールドをコレクション・スキーマに定義しています。

  • id:このフィールドは、テキストIDを格納するプライマリキーの役割を果たす。このフィールドのデータ型はINT64である。

  • text:このフィールドはテキストコンテンツを格納するために使用される。このフィールドのデータ型は VARCHAR で、最大長は 1000 文字である。

  • dense:このフィールドはテキストの密なベクトルを格納するために使用される。このフィールドのデータ型はFLOAT_VECTORで、ベクトル次元は768である。

  • sparse:このフィールドはテキストのスパース・ベクトルを格納するために使用される。このフィールドのデータ型は SPARSE_FLOAT_VECTOR である。

Python Java Node.js cURL
# Create a collection in customized setup mode
from pymilvus import (
    MilvusClient, DataType
)

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

# Create schema
schema = MilvusClient.create_schema(
    auto_id=False,
    enable_dynamic_field=True,
)
# Add fields to schema
schema.add_field(field_name="id", datatype=DataType.INT64, is_primary=True)
schema.add_field(field_name="text", datatype=DataType.VARCHAR, max_length=1000)
schema.add_field(field_name="sparse", datatype=DataType.SPARSE_FLOAT_VECTOR)
schema.add_field(field_name="dense", datatype=DataType.FLOAT_VECTOR, dim=5)


import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.common.DataType;
import io.milvus.v2.service.collection.request.AddFieldReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build());

CreateCollectionReq.CollectionSchema schema = client.createSchema();
schema.addField(AddFieldReq.builder()
        .fieldName("id")
        .dataType(DataType.Int64)
        .isPrimaryKey(true)
        .autoID(false)
        .build());

schema.addField(AddFieldReq.builder()
        .fieldName("text")
        .dataType(DataType.VarChar)
        .maxLength(1000)
        .build());

schema.addField(AddFieldReq.builder()
        .fieldName("dense")
        .dataType(DataType.FloatVector)
        .dimension(768)
        .build());

schema.addField(AddFieldReq.builder()
        .fieldName("sparse")
        .dataType(DataType.SparseFloatVector)
        .build());


// WIP


import { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";

const address = "http://localhost:19530";
const token = "root:Milvus";
const client = new MilvusClient({address, token});

// Create a collection in customized setup mode
// Define fields
const fields = [
    {
        name: "id",
        data_type: DataType.Int64,
        is_primary_key: true,
        auto_id: false
    },
    {
        name: "text",
        data_type: DataType.VarChar,
        max_length: 1000
    },
    {
        name: "sparse",
        data_type: DataType.SPARSE_FLOAT_VECTOR
    },
    {
        name: "dense",
        data_type: DataType.FloatVector,
        dim: 768
    }
]


export schema='{
        "autoId": false,
        "enabledDynamicField": true,
        "fields": [
            {
                "fieldName": "id",
                "dataType": "Int64",
                "isPrimary": true
            },
            {
                "fieldName": "text",
                "dataType": "VarChar",
                "elementTypeParams": {
                    "max_length": 1000
                }
            },
            {
                "fieldName": "sparse",
                "dataType": "SparseFloatVector"
            },
            {
                "fieldName": "dense",
                "dataType": "FloatVector",
                "elementTypeParams": {
                    "dim": "768"
                }
            }
        ]
    }'

スパース・ベクトル検索では、全文検索機能を活用することで、スパース埋め込みベクトルの生成プロセスを簡素化できます。詳細については、全文検索を参照してください。

インデックスの作成

コレクションスキーマを定義した後、ベクトルインデックスと類似度メトリクスを設定する必要があります。この例では、IVF_FLAT インデックスが密ベクトル・フィールドdense に対して作成され、SPARSE_INVERTED_INDEX が疎ベクトル・フィールドsparse に対して作成されます。サポートされているインデックスの種類については、インデックスの説明を参照してください。

Python Java Node.js cURL
from pymilvus import MilvusClient

# Prepare index parameters
index_params = client.prepare_index_params()

# Add indexes
index_params.add_index(
    field_name="dense",
    index_name="dense_index",
    index_type="IVF_FLAT",
    metric_type="IP",
    params={"nlist": 128},
)

index_params.add_index(
    field_name="sparse",
    index_name="sparse_index",
    index_type="SPARSE_INVERTED_INDEX",  # Index type for sparse vectors
    metric_type="IP",  # Currently, only IP (Inner Product) is supported for sparse vectors
    params={"drop_ratio_build": 0.2},  # The ratio of small vector values to be dropped during indexing
)


import io.milvus.v2.common.IndexParam;
import java.util.*;

Map<String, Object> denseParams = new HashMap<>();
denseParams.put("nlist", 128);
IndexParam indexParamForDenseField = IndexParam.builder()
        .fieldName("dense")
        .indexName("dense_index")
        .indexType(IndexParam.IndexType.IVF_FLAT)
        .metricType(IndexParam.MetricType.IP)
        .extraParams(denseParams)
        .build();

Map<String, Object> sparseParams = new HashMap<>();
sparseParams.put("drop_ratio_build", 0.2);
IndexParam indexParamForSparseField = IndexParam.builder()
        .fieldName("sparse")
        .indexName("sparse_index")
        .indexType(IndexParam.IndexType.SPARSE_INVERTED_INDEX)
        .metricType(IndexParam.MetricType.IP)
        .extraParams(sparseParams)
        .build();

List<IndexParam> indexParams = new ArrayList<>();
indexParams.add(indexParamForDenseField);
indexParams.add(indexParamForSparseField);


const index_params = [{
    field_name: "dense",
    index_type: "IVF_FLAT",
    metric_type: "IP"
},{
    field_name: "sparse",
    index_type: "SPARSE_INVERTED_INDEX",
    metric_type: "IP"
}]


export indexParams='[
        {
            "fieldName": "dense",
            "metricType": "IP",
            "indexName": "dense_index",
            "indexType":"IVF_FLAT",
            "params":{"nlist":128}
        },
        {
            "fieldName": "sparse",
            "metricType": "IP",
            "indexName": "sparse_index",
            "indexType": "SPARSE_INVERTED_INDEX"
        }
    ]'

コレクションの作成

前の2つのステップで設定したコレクションスキーマとインデックスを使用して、demo という名前のコレクションを作成します。

Python Java Node.js cURL
from pymilvus import MilvusClient

client.create_collection(
    collection_name="hybrid_search_collection",
    schema=schema,
    index_params=index_params
)


CreateCollectionReq createCollectionReq = CreateCollectionReq.builder()
        .collectionName("hybrid_search_collection")
        .collectionSchema(schema)
        .indexParams(indexParams)
        .build();
client.createCollection(createCollectionReq);


res = await client.createCollection({
    collection_name: "hybrid_search_collection",
    fields: fields,
    index_params: index_params,
})


export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d "{
    \"collectionName\": \"hybrid_search_collection\",
    \"schema\": $schema,
    \"indexParams\": $indexParams
}"

データの挿入

疎密ベクトルをコレクションdemo に挿入する。

Python Java Node.js cURL
from pymilvus import MilvusClient

data=[
    {"id": 0, "text": "Artificial intelligence was founded as an academic discipline in 1956.", "sparse":{9637: 0.30856525997853057, 4399: 0.19771651149001523, ...}, "dense": [0.3580376395471989, -0.6023495712049978, 0.18414012509913835, ...]},
    {"id": 1, "text": "Alan Turing was the first person to conduct substantial research in AI.", "sparse":{6959: 0.31025067641541815, 1729: 0.8265339135915016, ...}, "dense": [0.19886812562848388, 0.06023560599112088, 0.6976963061752597, ...]},
    {"id": 2, "text": "Born in Maida Vale, London, Turing was raised in southern England.", "sparse":{1220: 0.15303302147479103, 7335: 0.9436728846033107, ...}, "dense": [0.43742130801983836, -0.5597502546264526, 0.6457887650909682, ...]}

res = client.insert(
    collection_name="hybrid_search_collection",
    data=data
)



import com.google.gson.Gson;
import com.google.gson.JsonObject;
import io.milvus.v2.service.vector.request.InsertReq;

Gson gson = new Gson();
JsonObject row1 = new JsonObject();
row1.addProperty("id", 1);
row1.addProperty("text", "Artificial intelligence was founded as an academic discipline in 1956.");
row1.add("dense", gson.toJsonTree(dense1));
row1.add("sparse", gson.toJsonTree(sparse1));

JsonObject row2 = new JsonObject();
row2.addProperty("id", 2);
row2.addProperty("text", "Alan Turing was the first person to conduct substantial research in AI.");
row2.add("dense", gson.toJsonTree(dense2));
row2.add("sparse", gson.toJsonTree(sparse2));

JsonObject row3 = new JsonObject();
row3.addProperty("id", 3);
row3.addProperty("text", "Born in Maida Vale, London, Turing was raised in southern England.");
row3.add("dense", gson.toJsonTree(dense3));
row3.add("sparse", gson.toJsonTree(sparse3));

List<JsonObject> data = Arrays.asList(row1, row2, row3);
InsertReq insertReq = InsertReq.builder()
        .collectionName("hybrid_search_collection")
        .data(data)
        .build();

InsertResp insertResp = client.insert(insertReq);


const { MilvusClient, DataType } = require("@zilliz/milvus2-sdk-node")

var data = [
    {id: 0, text: "Artificial intelligence was founded as an academic discipline in 1956.", sparse:[9637: 0.30856525997853057, 4399: 0.19771651149001523, ...] , dense: [0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592]},
    {id: 1, text: "Alan Turing was the first person to conduct substantial research in AI.", sparse:[6959: 0.31025067641541815, 1729: 0.8265339135915016, ...] , dense: [0.19886812562848388, 0.06023560599112088, 0.6976963061752597, 0.2614474506242501, 0.838729485096104]},
    {id: 2, text: "Born in Maida Vale, London, Turing was raised in southern England." , sparse:[1220: 0.15303302147479103, 7335: 0.9436728846033107, ...] , dense: [0.43742130801983836, -0.5597502546264526, 0.6457887650909682, 0.7894058910881185, 0.20785793220625592]}       
]

var res = await client.insert({
    collection_name: "hybrid_search_collection",
    data: data,
})


curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/insert" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "data": [
        {"id": 0, "text": "Artificial intelligence was founded as an academic discipline in 1956.", "sparse":{"9637": 0.30856525997853057, "4399": 0.19771651149001523}, "dense": [0.3580376395471989, -0.6023495712049978, 0.18414012509913835, ...]},
        {"id": 1, "text": "Alan Turing was the first person to conduct substantial research in AI.", "sparse":{"6959": 0.31025067641541815, "1729": 0.8265339135915016}, "dense": [0.19886812562848388, 0.06023560599112088, 0.6976963061752597, ...]},
        {"id": 2, "text": "Born in Maida Vale, London, Turing was raised in southern England.", "sparse":{"1220": 0.15303302147479103, "7335": 0.9436728846033107}, "dense": [0.43742130801983836, -0.5597502546264526, 0.6457887650909682, ...]}
    ],
    "collectionName": "hybrid_search_collection"
}'

複数のAnnSearchRequestインスタンスを作成する。

ハイブリッド検索は、hybrid_search() 関数で複数のAnnSearchRequest を作成することで実装される。各AnnSearchRequest は、特定のベクトル・フィールドに対する基本的な ANN 検索リクエストを表す。したがって、ハイブリッド・サーチを行う前に、各ベクトル・フィールドのAnnSearchRequest を作成する必要がある。

ハイブリッド検索では、各AnnSearchRequest は1つのクエリ・ベクトルのみをサポートする。

例えば、"Who started AI research? "というクエリ・テキストが既にスパース・ベクトルとデンス・ベクトルに変換されているとする。これに基づいて、次の例に示すように、sparse とdense のベクトル・フィールドに対して、それぞれ2つのAnnSearchRequest 検索リクエストが作成される。

Python Java Node.js cURL
from pymilvus import AnnSearchRequest

query_dense_vector = [0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592]

search_param_1 = {
    "data": [query_dense_vector],
    "anns_field": "dense",
    "param": {
        "metric_type": "IP",
        "params": {"nprobe": 10}
    },
    "limit": 2
}
request_1 = AnnSearchRequest(**search_param_1)

query_sparse_vector = {3573: 0.34701499565746674}, {5263: 0.2639375518635271}
search_param_2 = {
    "data": [query_sparse_vector],
    "anns_field": "sparse",
    "param": {
        "metric_type": "IP",
        "params": {"drop_ratio_build": 0.2}
    },
    "limit": 2
}
request_2 = AnnSearchRequest(**search_param_2)

reqs = [request_1, request_2]



import io.milvus.v2.service.vector.request.AnnSearchReq;
import io.milvus.v2.service.vector.request.data.BaseVector;
import io.milvus.v2.service.vector.request.data.FloatVec;
import io.milvus.v2.service.vector.request.data.SparseFloatVec;

float[] dense = new float[]{-0.0475336798f,  0.0521207601f,  0.0904406682f, ...};
SortedMap<Long, Float> sparse = new TreeMap<Long, Float>() {{
    put(3573L, 0.34701499f);
    put(5263L, 0.263937551f);
    ...
}};


List<BaseVector> queryDenseVectors = Collections.singletonList(new FloatVec(dense));
List<BaseVector> querySparseVectors = Collections.singletonList(new SparseFloatVec(sparse));

List<AnnSearchReq> searchRequests = new ArrayList<>();
searchRequests.add(AnnSearchReq.builder()
        .vectorFieldName("dense")
        .vectors(queryDenseVectors)
        .metricType(IndexParam.MetricType.IP)
        .params("{\"nprobe\": 10}")
        .topK(2)
        .build());
searchRequests.add(AnnSearchReq.builder()
        .vectorFieldName("sparse")
        .vectors(querySparseVectors)
        .metricType(IndexParam.MetricType.IP)
        .params("{\"drop_ratio_build\": 0.2}")
        .topK(2)
        .build());


const search_param_1 = {
    "data": query_vector, 
    "anns_field": "dense", 
    "param": {
        "metric_type": "IP", // 参数值需要与 Collection Schema 中定义的保持一致
        "params": {"nprobe": 10}
    },
    "limit": 2 // AnnSearchRequest 返还的搜索结果数量
}

const search_param_2 = {
    "data": query_sparse_vector, 
    "anns_field": "sparse", 
    "param": {
        "metric_type": "IP", // 参数值需要与 Collection Schema 中定义的保持一致
        "params": {"drop_ratio_build": 0.2}
    },
    "limit": 2 // AnnSearchRequest 返还的搜索结果数量
}


export req='[
    {
        "data": [[0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592,....]],
        "annsField": "dense",
        "params": {
            "params": {
                "nprobe": 10
             }
        },
        "limit": 2
    },
    {
        "data": [{"3573": 0.34701499565746674}, {"5263": 0.2639375518635271}],
        "annsField": "sparse",
        "params": {
            "params": {
                "drop_ratio_build": 0.2
             }
        },
        "limit": 2
    }
 ]'

パラメータlimit は 2 に設定されているため、各AnnSearchRequest は 2 つの検索結果を返す。この例では、AnnSearchRequest が2つ作成されるため、合計4つの検索結果が返される。

再ランク付け戦略の設定

2組のANN検索結果をマージしてランク付けし直すには、適切なランク付けストラテジーを選択する必要があります。Zillizは2種類のリランキング戦略をサポートしています：WeightedRankerと RRFRankerである。リランキング戦略を選択する際に考慮すべき点は、1つ以上の基本的なANN検索がベクトルフィールド上で強調されているかどうかである。

  • WeightedRanker：この戦略は、特定のベクトル・フィールドを強調する結果を必要とする場合に推奨される。WeightedRankerでは、特定のベクトル・フィールドに高いウェイトを割り当て、より強調することができる。例えば、マルチモーダル検索では、画像の色よりも画像のテキスト説明が重要視されるかもしれません。

  • RRFRanker（Reciprocal Rank Fusion Ranker）：このストラテジーは、特定の重点がない場合に推奨される。RRFは各ベクトル場の重要度のバランスを効果的にとることができる。

これら2つのリランキング戦略のメカニズムの詳細については、リランキングを参照。

以下の2つの例は、WeightedRankerとRRFRankerの再ランク戦略の使い方を示している。

  1. 例1：WeightedRankerの使用

    WeightedRankerストラテジーを使用する場合、WeightedRanker 関数に重み値を入力する必要があります。ハイブリッド探索の基本ANN探索数は、入力する必要のある値の数に対応する。入力値は[0,1]の範囲で、1に近いほど重要度が高いことを示す。

    Python JavaNode.jscURL

    from pymilvus import WeightedRanker

rerank= WeightedRanker(0.8, 0.3) 


    import io.milvus.v2.service.vector.request.ranker.BaseRanker;
import io.milvus.v2.service.vector.request.ranker.WeightedRanker;

BaseRanker reranker = new WeightedRanker(Arrays.asList(0.8f, 0.3f));


    import { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";

const rerank = WeightedRanker(0.8, 0.3);


    export rerank='{
        "strategy": "ws",
        "params": {"weights": [0.8,0.3]}
    }'

  2. 例2：RRFRankerの使用

    RRFRankerストラテジーを使う場合、パラメータ値k をRRFRankerに入力する必要がある。k のデフォルト値は60です。このパラメータは、異なるANN検索からのランクをどのように組み合わせるかを決定するのに役立ち、すべての検索にわたる重要性のバランスと調和を目指します。

    Python JavaNode.jscURL

    from pymilvus import RRFRanker

ranker = RRFRanker(100)


    import io.milvus.v2.service.vector.request.ranker.BaseRanker;
import io.milvus.v2.service.vector.request.ranker.RRFRanker;

BaseRanker reranker = new RRFRanker(100);


    import { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";

const rerank = RRFRanker("100");


    export rerank='{
        "strategy": "rrf",
        "params": { "k": 100}
    }'

ハイブリッド検索を実行する前に、コレクションをメモリにロードする必要がある。コレクション内のベクトル・フィールドにインデックスがないか、ロードされていない場合、Hybrid Searchメソッドを呼び出すときにエラーが発生する。

Python Java Node.js cURL
from pymilvus import MilvusClient

res = client.hybrid_search(
    collection_name="hybrid_search_collection",
    reqs=reqs,
    ranker=ranker,
    limit=2
)
for hits in res:
    print("TopK results:")
    for hit in hits:
        print(hit)


import io.milvus.v2.common.ConsistencyLevel;
import io.milvus.v2.service.vector.request.HybridSearchReq;
import io.milvus.v2.service.vector.response.SearchResp;

HybridSearchReq hybridSearchReq = HybridSearchReq.builder()
        .collectionName("hybrid_search_collection")
        .searchRequests(searchRequests)
        .ranker(reranker)
        .topK(2)
        .consistencyLevel(ConsistencyLevel.BOUNDED)
        .build();

SearchResp searchResp = client.hybridSearch(hybridSearchReq);


const { MilvusClient, DataType } = require("@zilliz/milvus2-sdk-node")

res = await client.loadCollection({
    collection_name: "hybrid_search_collection"
})

import { MilvusClient, RRFRanker, WeightedRanker } from '@zilliz/milvus2-sdk-node';

const search = await client.search({
  collection_name: "hybrid_search_collection",
  data: [search_param_1, search_param_2],
  limit: 2,
  rerank: RRFRanker(100)
});


curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/advanced_search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d "{
    \"collectionName\": \"hybrid_search_collection\",
    \"search\": ${req},
    \"rerank\": {
        \"strategy\":\"rrf\",
        \"params\": {
            \"k\": 10
        }
    },
    \"limit\": 3,
    \"outputFields\": [
        \"user_id\",
        \"word_count\",
        \"book_describe\"
    ]
}"

以下はその出力である。

["['id: 844, distance: 0.006047376897186041, entity: {}', 'id: 876, distance: 0.006422005593776703, entity: {}']"]

ハイブリッド検索でlimit=2 が指定されているため、Zillizはステップ3の4つの検索結果を再ランク付けし、最終的に最も類似した検索結果の上位2つだけを返します。

翻訳DeepL

目次

Try Managed Milvus for Free

Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.

Get Started
フィードバック

このページは役に立ちましたか ？