Pemeringkat RRF

Reciprocal Rank Fusion (RRF) Ranker adalah strategi pemeringkatan ulang untuk pencarian hibrida Milvus yang menyeimbangkan hasil dari beberapa jalur pencarian vektor berdasarkan posisi peringkatnya, bukan nilai kemiripannya. Seperti turnamen olahraga yang mempertimbangkan peringkat pemain daripada statistik individu, RRF Ranker menggabungkan hasil pencarian berdasarkan seberapa tinggi peringkat setiap item di jalur pencarian yang berbeda, menciptakan peringkat akhir yang adil dan seimbang.

Kapan menggunakan RRF Ranker

RRF Ranker dirancang khusus untuk skenario pencarian hibrida di mana Anda ingin menyeimbangkan hasil dari beberapa jalur pencarian vektor tanpa menetapkan bobot kepentingan secara eksplisit. Ini sangat efektif untuk:

Kasus Penggunaan	Contoh	Mengapa RRF Ranker Bekerja dengan Baik
Pencarian multimodal dengan tingkat kepentingan yang sama	Pencarian gambar-teks di mana kedua modalitas sama pentingnya	Menyeimbangkan hasil tanpa memerlukan penetapan bobot yang sewenang-wenang
Pencarian vektor ensemble	Menggabungkan hasil dari model penyematan yang berbeda	Menggabungkan peringkat secara demokratis tanpa mengutamakan distribusi penilaian model tertentu
Pencarian lintas bahasa	Menemukan dokumen dalam berbagai bahasa	Memberi peringkat hasil secara adil terlepas dari karakteristik penyematan bahasa tertentu
Rekomendasi pakar	Menggabungkan rekomendasi dari beberapa sistem pakar	Membuat peringkat konsensus ketika sistem yang berbeda menggunakan metode penilaian yang tidak sebanding

Jika aplikasi pencarian hibrida Anda memerlukan penyeimbangan beberapa jalur pencarian secara demokratis tanpa memberikan bobot eksplisit, RRF Ranker adalah pilihan ideal Anda.

Mekanisme RRF Ranker

Alur kerja utama dari strategi RRFRanker adalah sebagai berikut:

1. Kumpulkan Peringkat Pencarian: Kumpulkan peringkat hasil dari setiap jalur pencarian vektor (peringkat_1, peringkat_2).

2. Gabungkan Peringkat: Menggabungkan peringkat dari setiap jalur (rank_rrf_1, rank_rrf_2) sesuai dengan rumus.

   Rumus perhitungan melibatkan N, yang merepresentasikan jumlah pengambilan. ranki(d) adalah posisi peringkat dokumen d yang dihasilkan oleh pengambil ke-i. k adalah parameter perataan yang biasanya disetel pada angka 60.

3. Peringkat Agregat: Beri peringkat ulang hasil pencarian berdasarkan peringkat gabungan untuk menghasilkan hasil akhir.

Pemeringkat Rrf

Contoh Pemeringkat RRF

Contoh ini mendemonstrasikan Pencarian Hibrida (topK = 5) pada vektor yang jarang dan mengilustrasikan bagaimana strategi RRFRanker memberi peringkat ulang hasil dari dua pencarian ANN.

• Hasil pencarian ANN pada vektor teks yang jarang (topK=5): Hasil pencarian ANN pada vektor teks yang jarang (topK=5)

  ID	Peringkat (jarang)
  101	1
  203	2
  150	3
  198	4
  175	5

• Hasil pencarian ANN pada vektor teks yang padat (topK=5): Hasil pencarian ANN pada vektor teks yang padat (topK=5)

  ID	Peringkat (padat)
  198	1
  101	2
  110	3
  175	4
  250	5

• Gunakan RRF untuk mengatur ulang peringkat dari dua set hasil pencarian. Asumsikan bahwa parameter perataan k ditetapkan pada 60.

  ID	Skor (Jarang)	Skor (Padat)	Skor Akhir
  101	1	2	1/(60+1)+1/(60+2) = 0.03252247
  198	4	1	1/(60+4)+1/(60+1) = 0.03201844
  175	5	4	1/(60+5)+1/(60+4) = 0.03100962
  203	2	N/A	1/(60+2) = 0.01612903
  150	3	N/A	1/(60+3) = 0.01587302
  110	N/A	3	1/(60+3) = 0.01587302
  250	N/A	5	1/(60+5) = 0.01538462

• Hasil akhir setelah pemeringkatan ulang (topK = 5):: Hasil akhir

  Peringkat	ID	Skor Akhir
  1	101	0.03252247
  2	198	0.03201844
  3	175	0.03100962
  4	203	0.01612903
  5	150	0.01587302
  5	110	0.01587302

Penggunaan Pemeringkat RRF

Saat menggunakan strategi pemeringkatan RRF, Anda perlu mengonfigurasi parameter k. Ini adalah parameter perataan yang secara efektif dapat mengubah bobot relatif pencarian teks lengkap versus pencarian vektor. Nilai default dari parameter ini adalah 60, dan dapat disesuaikan dalam kisaran (0, 16384). Nilainya harus berupa angka floating-point. Nilai yang disarankan adalah antara [10, 100]. Meskipun k=60 adalah pilihan umum, nilai k yang optimal dapat bervariasi tergantung pada aplikasi dan kumpulan data spesifik Anda. Kami merekomendasikan untuk menguji dan menyesuaikan parameter ini berdasarkan kasus penggunaan spesifik Anda untuk mencapai kinerja terbaik.

Membuat Pemeringkat RRF

Setelah koleksi Anda diatur dengan beberapa bidang vektor, buatlah RRF Ranker dengan parameter perataan yang sesuai:

from pymilvus import Function, FunctionType

ranker = Function(
    name="rrf",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "rrf", 
        "k": 100  # Optional
    }
)

import io.milvus.common.clientenum.FunctionType;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

CreateCollectionReq.Function rerank = CreateCollectionReq.Function.builder()
        .name("rrf")
        .functionType(FunctionType.RERANK)
        .param("reranker", "rrf")
        .param("k", "100")
        .build();

import { FunctionType } from "@zilliz/milvus2-sdk-node";

const ranker = {
  name: "weight",
  input_field_names: [],
  function_type: FunctionType.RERANK,
  params: {
    reranker: "weighted",
    weights: [0.1, 0.9],
    norm_score: true,
  },
};

// Go

# Restful

Parameter	Diperlukan?	Deskripsi	Nilai/Contoh
name	Ya	Pengenal unik untuk Fungsi ini	"rrf"
input_field_names	Ya	Daftar bidang vektor yang akan digunakan untuk menerapkan fungsi (harus kosong untuk Pemeringkat RRF)	[]
function_type	Ya	Jenis Fungsi yang akan dipanggil; gunakan RERANK untuk menentukan strategi pemeringkatan	FunctionType.RERANK
params.reranker	Ya	Menentukan metode pemeringkatan ulang yang akan digunakan. Harus diatur ke rrf untuk menggunakan RRF Ranker.	"weighted"
params.k	Tidak	Parameter penghalusan yang mengontrol dampak peringkat dokumen; k yang lebih tinggi mengurangi sensitivitas terhadap peringkat teratas. Rentang: (0, 16384); default: 60. Untuk detailnya, lihat Mekanisme Pemeringkat RRF.	100

Menerapkan pada pencarian hibrida

RRF Ranker dirancang secara khusus untuk operasi pencarian hibrida yang menggabungkan beberapa bidang vektor. Berikut adalah cara menggunakannya dalam pencarian hibrida:

from pymilvus import MilvusClient, AnnSearchRequest

# Connect to Milvus server
milvus_client = MilvusClient(uri="http://localhost:19530")

# Assume you have a collection setup

# Define text vector search request
text_search = AnnSearchRequest(
    data=["modern dining table"],
    anns_field="text_vector",
    param={},
    limit=10
)

# Define image vector search request
image_search = AnnSearchRequest(
    data=[image_embedding],  # Image embedding vector
    anns_field="image_vector",
    param={},
    limit=10
)

# Apply RRF Ranker to product hybrid search
# The smoothing parameter k controls the balance
hybrid_results = milvus_client.hybrid_search(
    collection_name,
    [text_search, image_search],  # Multiple search requests
    ranker=ranker,  # Apply the RRF ranker
    limit=10,
    output_fields=["product_name", "price", "category"]
)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.AnnSearchReq;
import io.milvus.v2.service.vector.request.HybridSearchReq;
import io.milvus.v2.service.vector.response.SearchResp;
import io.milvus.v2.service.vector.request.data.EmbeddedText;
import io.milvus.v2.service.vector.request.data.FloatVec;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .build());
        
List<AnnSearchReq> searchRequests = new ArrayList<>();
searchRequests.add(AnnSearchReq.builder()
        .vectorFieldName("text_vector")
        .vectors(Collections.singletonList(new EmbeddedText("\"modern dining table\"")))
        .limit(10)
        .build());
searchRequests.add(AnnSearchReq.builder()
        .vectorFieldName("image_vector")
        .vectors(Collections.singletonList(new FloatVec(imageEmbedding)))
        .limit(10)
        .build());
        
HybridSearchReq hybridSearchReq = HybridSearchReq.builder()
                .collectionName(COLLECTION_NAME)
                .searchRequests(searchRequests)
                .ranker(ranker)
                .limit(10)
                .outputFields(Arrays.asList("product_name", "price", "category"))
                .build();
SearchResp searchResp = client.hybridSearch(hybridSearchReq);

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

const milvusClient = new MilvusClient({ address: "http://localhost:19530" });

const text_search = {
    data: ["modern dining table"],
    anns_field: "text_vector",
    param: {},
    limit: 10,
};

const image_search = {
  data: [image_embedding],
  anns_field: "image_vector",
  param: {},
  limit: 10,
};

const ranker = {
  name: "weight",
  input_field_names: [],
  function_type: FunctionType.RERANK,
  params: {
    reranker: "weighted",
    weights: [0.1, 0.9],
    norm_score: true,
  },
};

const search = await milvusClient.search({
  collection_name: collection_name,
  data: [text_search, image_search],
  output_fields: ["product_name", "price", "category"],
  limit: 10,
  rerank: ranker,
});

// go

# restful

Untuk informasi lebih lanjut tentang pencarian hibrida, lihat Pencarian Hibrida Multi-Vektor.