Pencarian Hibrida
Pencarian Hibrida mengacu pada metode pencarian yang melakukan beberapa pencarian ANN secara bersamaan, memberi peringkat ulang beberapa set hasil dari pencarian ANN ini, dan pada akhirnya mengembalikan satu set hasil. Menggunakan Pencarian Hibrida dapat meningkatkan akurasi pencarian. Zilliz mendukung melakukan Pencarian Hibrida pada koleksi dengan beberapa bidang vektor.
Pencarian Hibrida paling sering digunakan dalam skenario yang mencakup pencarian vektor yang jarang dan pencarian multimodal. Panduan ini akan mendemonstrasikan cara melakukan Pencarian Hibrida di Zilliz dengan contoh spesifik.
Skenario
Pencarian Hibrida cocok untuk dua skenario berikut.
Pencarian Vektor Jarang-Padat
Jenis vektor yang berbeda dapat merepresentasikan informasi yang berbeda, dan menggunakan berbagai model penyematan dapat merepresentasikan fitur dan aspek data yang berbeda secara lebih komprehensif. Sebagai contoh, menggunakan model penyematan yang berbeda untuk kalimat yang sama dapat menghasilkan vektor padat untuk mewakili makna semantik dan vektor jarang untuk mewakili frekuensi kata dalam kalimat.
Vektor jarang: Vektor jarang dicirikan oleh dimensi vektor yang tinggi dan adanya beberapa nilai yang bukan nol. Struktur ini membuatnya sangat cocok untuk aplikasi pencarian informasi tradisional. Dalam banyak kasus, jumlah dimensi yang digunakan dalam vektor jarang sesuai dengan token yang berbeda di satu atau lebih bahasa. Setiap dimensi diberi nilai yang menunjukkan tingkat kepentingan relatif token tersebut dalam dokumen. Tata letak ini terbukti menguntungkan untuk tugas-tugas yang melibatkan pencocokan teks.
Vektor padat: Vektor padat adalah penyematan yang berasal dari jaringan saraf. Ketika disusun dalam larik yang teratur, vektor-vektor ini menangkap esensi semantik dari teks masukan. Perhatikan bahwa vektor padat tidak terbatas pada pemrosesan teks; vektor padat juga digunakan secara luas dalam visi komputer untuk merepresentasikan semantik data visual. Vektor padat ini, biasanya dihasilkan oleh model penyematan teks, dicirikan oleh sebagian besar atau semua elemen yang tidak nol. Dengan demikian, vektor padat sangat efektif untuk aplikasi pencarian semantik, karena dapat mengembalikan hasil yang paling mirip berdasarkan jarak vektor meskipun tidak ada kecocokan teks yang tepat. Kemampuan ini memungkinkan hasil pencarian yang lebih bernuansa dan sadar konteks, sering kali menangkap hubungan antar konsep yang mungkin terlewatkan oleh pendekatan berbasis kata kunci.
Untuk lebih jelasnya, lihat Vektor Jarang dan Vektor Padat.
Pencarian Multimodal
Pencarian multimodal mengacu pada pencarian kemiripan data yang tidak terstruktur di berbagai modalitas (seperti gambar, video, audio, teks, dll.). Misalnya, seseorang dapat direpresentasikan dengan menggunakan berbagai modalitas data seperti sidik jari, rekaman suara, dan fitur wajah. Pencarian Hibrida mendukung beberapa pencarian secara bersamaan. Misalnya mencari seseorang dengan sidik jari dan sidik suara yang mirip.
Alur kerja
Alur kerja utama untuk melakukan Pencarian Hibrida adalah sebagai berikut.
Hasilkan vektor padat melalui model penyisipan seperti BERT dan Transformers.
Menghasilkan vektor yang jarang melalui model embedding seperti BM25, BGE-M3, SPLADE, dll.
Buat koleksi di Zilliz dan tentukan skema koleksi yang mencakup bidang vektor padat dan jarang.
Masukkan vektor jarang-padat ke dalam koleksi yang baru saja dibuat pada langkah sebelumnya.
Lakukan Pencarian Hibrida: Pencarian ANN pada vektor padat akan mengembalikan satu set hasil K teratas yang paling mirip, dan pencocokan teks pada vektor jarang juga akan mengembalikan satu set hasil K teratas.
Normalisasi: Menormalkan skor dari dua set hasil top-K, mengubah skor menjadi rentang antara [0,1].
Pilih strategi pemeringkatan ulang yang sesuai untuk menggabungkan dan memeringkat ulang dua set hasil top-K dan pada akhirnya mengembalikan satu set hasil top-K terakhir.
Alur Kerja Pencarian Hibrida
Contoh
Bagian ini akan menggunakan contoh spesifik untuk mengilustrasikan cara melakukan Pencarian Hibrida pada vektor yang jarang-jarang untuk meningkatkan akurasi pencarian teks.
Membuat koleksi dengan beberapa bidang vektor
Proses membuat koleksi mencakup tiga bagian: menentukan skema koleksi, mengonfigurasi parameter indeks, dan membuat koleksi.
Menentukan skema
Dalam contoh ini, beberapa bidang vektor perlu ditentukan dalam skema koleksi. Saat ini, setiap koleksi dapat menyertakan hingga 4 bidang vektor secara default. Namun Anda juga dapat memodifikasi nilai proxy.maxVectorFieldNum untuk menyertakan hingga 10 bidang vektor dalam koleksi sesuai kebutuhan.
Contoh berikut ini mendefinisikan skema koleksi, di mana dense dan sparse adalah dua bidang vektor.
id: Bidang ini berfungsi sebagai kunci utama untuk menyimpan ID teks. Tipe data dari field ini adalah INT64.text: Bidang ini digunakan untuk menyimpan konten tekstual. Tipe data dari field ini adalah VARCHAR, dengan panjang maksimum 1000 karakter.dense: Field ini digunakan untuk menyimpan vektor padat dari teks. Tipe data dari field ini adalah FLOAT_VECTOR, dengan dimensi vektor 768.sparse: Field ini digunakan untuk menyimpan vektor jarang dari teks. Tipe data dari field ini adalah SPARSE_FLOAT_VECTOR.
# 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"
}
}
]
}'
Selama pencarian vektor jarang, Anda dapat menyederhanakan proses pembuatan vektor sematan jarang dengan memanfaatkan kemampuan Pencarian Teks Lengkap. Untuk lebih jelasnya, lihat Pencarian Teks Lengkap.
Membuat indeks
Setelah menentukan skema koleksi, Anda perlu menyiapkan indeks vektor dan metrik kemiripan. Dalam contoh ini, indeks IVF_FLAT dibuat untuk bidang vektor padat dense, dan indeks SPARSE_INVERTED_INDEX dibuat untuk bidang vektor jarang sparse. Untuk mempelajari jenis-jenis indeks yang didukung, lihat Penjelasan Indeks.
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={"inverted_index_algo": "DAAT_MAXSCORE"}, # 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("inverted_index_algo": "DAAT_MAXSCORE");
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"
}
]'
Membuat koleksi
Buat koleksi bernama demo dengan skema koleksi dan indeks yang telah dikonfigurasi dalam dua langkah sebelumnya.
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
}"
Masukkan data
Masukkan vektor-vektor yang jarang-jarang ke dalam koleksi demo.
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"
}'
Membuat beberapa instance AnnSearchRequest
Pencarian Hibrida diimplementasikan dengan membuat beberapa AnnSearchRequest dalam fungsi hybrid_search(), di mana setiap AnnSearchRequest merepresentasikan permintaan pencarian ANN dasar untuk bidang vektor tertentu. Oleh karena itu, sebelum melakukan Pencarian Hibrida, perlu untuk membuat AnnSearchRequest untuk setiap bidang vektor.
Dalam Pencarian Hibrida, setiap AnnSearchRequest hanya mendukung satu vektor kueri.
Misalkan teks kueri "Siapa yang memulai penelitian AI?" telah dikonversi menjadi vektor jarang dan padat. Berdasarkan hal ini, dua permintaan pencarian AnnSearchRequest dibuat untuk bidang vektor sparse dan dense, seperti yang ditunjukkan pada contoh berikut.
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": {}
},
"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()
.topK(2)
.build());
const search_param_1 = {
"data": query_vector,
"anns_field": "dense",
"param": {
"metric_type": "IP",
"params": {"nprobe": 10}
},
"limit": 2
}
const search_param_2 = {
"data": query_sparse_vector,
"anns_field": "sparse",
"param": {
"metric_type": "IP",
"params": {}
},
"limit": 2
}
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": {}
},
"limit": 2
}
]'
Karena parameter limit disetel ke 2, maka setiap AnnSearchRequest mengembalikan 2 hasil pencarian. Dalam contoh ini, 2 AnnSearchRequest dibuat, oleh karena itu total 4 hasil pencarian akan dikembalikan.
Mengonfigurasi strategi perankingan ulang
Untuk menggabungkan dan memberi peringkat ulang dua set hasil pencarian ANN, Anda perlu memilih strategi perangkingan ulang yang sesuai. Zilliz mendukung dua jenis strategi pemeringkatan ulang: WeightedRanker dan RRFRanker. Saat memilih strategi perankingan ulang, satu hal yang perlu dipertimbangkan adalah apakah ada penekanan untuk satu atau lebih pencarian ANN dasar pada bidang vektor.
WeightedRanker: Strategi ini direkomendasikan jika Anda membutuhkan hasil untuk menekankan bidang vektor tertentu. WeightedRanker memungkinkan Anda untuk memberikan bobot yang lebih tinggi pada bidang vektor tertentu, sehingga lebih menekankannya. Misalnya, dalam pencarian multimodal, deskripsi tekstual dari sebuah gambar mungkin dianggap lebih penting daripada warna pada gambar tersebut.
RRFRanker (Reciprocal Rank Fusion Ranker): Strategi ini direkomendasikan apabila tidak ada penekanan khusus. RRF secara efektif dapat menyeimbangkan pentingnya setiap bidang vektor.
Untuk detail lebih lanjut tentang mekanisme kedua strategi pemeringkatan ulang ini, lihat Pemeringkatan Ulang.
Dua contoh berikut ini menunjukkan cara menggunakan strategi perangkingan ulang WeightedRanker dan RRFRanker.
Contoh 1: Menggunakan WeightedRanker
Saat menggunakan strategi WeightedRanker, Anda perlu memasukkan nilai bobot ke dalam fungsi
WeightedRanker. Jumlah pencarian ANN dasar dalam Pencarian Hibrida sesuai dengan jumlah nilai yang perlu dimasukkan. Nilai input harus berada dalam rentang [0,1], dengan nilai yang lebih dekat ke 1 menunjukkan kepentingan yang lebih besar.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]} }'Contoh 2: Menggunakan RRFRanker
Ketika menggunakan strategi RRFRanker, Anda perlu memasukkan nilai parameter
kke dalam RRFRanker. Nilai default darikadalah 60. Parameter ini membantu menentukan bagaimana peringkat digabungkan dari pencarian ANN yang berbeda, yang bertujuan untuk menyeimbangkan dan memadukan kepentingan di semua pencarian.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} }'
Melakukan Pencarian Hibrida
Sebelum melakukan Pencarian Hibrida, koleksi harus dimuat ke dalam memori. Jika ada bidang vektor dalam koleksi yang tidak memiliki indeks atau tidak dimuat, kesalahan akan terjadi saat memanggil metode Pencarian Hibrida.
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\"
]
}"
Berikut ini adalah keluarannya.
["['id: 844, distance: 0.006047376897186041, entity: {}', 'id: 876, distance: 0.006422005593776703, entity: {}']"]
Karena limit=2 ditentukan dalam Pencarian Hibrida, Zilliz akan memberi peringkat ulang empat hasil pencarian dari langkah 3 dan pada akhirnya hanya mengembalikan 2 hasil pencarian yang paling mirip.