Ranker RRF

Reciprocal Rank Fusion (RRF) Ranker è una strategia di reranking per la ricerca ibrida di Milvus che bilancia i risultati di più percorsi di ricerca vettoriali in base alla loro posizione in classifica piuttosto che ai punteggi di somiglianza grezzi. Come un torneo sportivo che considera le classifiche dei giocatori piuttosto che le statistiche individuali, RRF Ranker combina i risultati della ricerca in base alla posizione di ciascun elemento nei diversi percorsi di ricerca, creando una classifica finale equa ed equilibrata.

Quando utilizzare RRF Ranker

RRF Ranker è stato progettato specificamente per scenari di ricerca ibridi in cui si desidera bilanciare i risultati di più percorsi di ricerca vettoriali senza assegnare pesi di importanza espliciti. È particolarmente efficace per:

Caso d'uso	Esempio	Perché RRF Ranker funziona bene
Ricerca multimodale con uguale importanza	Ricerca immagine-testo in cui entrambe le modalità hanno la stessa importanza	Bilancia i risultati senza richiedere assegnazioni di peso arbitrarie
Ricerca vettoriale ensemble	Combina i risultati di diversi modelli di incorporazione	Unisce democraticamente le classifiche senza favorire la distribuzione del punteggio di un particolare modello
Ricerca interlinguistica	Ricerca di documenti in più lingue	Classifica i risultati in modo equo indipendentemente dalle caratteristiche di incorporazione specifiche della lingua
Raccomandazioni di esperti	Combina le raccomandazioni di più sistemi esperti	Crea classifiche di consenso quando sistemi diversi utilizzano metodi di punteggio incomparabili

Se la vostra applicazione di ricerca ibrida richiede un bilanciamento democratico di più percorsi di ricerca senza assegnare pesi espliciti, RRF Ranker è la scelta ideale.

Meccanismo di RRF Ranker

Il flusso di lavoro principale della strategia RRFRanker è il seguente:

1. Raccogliere le classifiche di ricerca: Raccogliere le classifiche dei risultati di ogni percorso di ricerca vettoriale (rank_1, rank_2).

2. Unire le classifiche: Converte le classifiche di ogni percorso (rank_rrf_1, rank_rrf_2) secondo una formula.

   La formula di calcolo prevede N, che rappresenta il numero di recuperi. ranki(d) è la posizione di classifica del documento d generato dall'i(th) retriever. k è un parametro di smussamento tipicamente impostato a 60.

3. Classifica aggregata: Ri-classifica i risultati della ricerca in base alle classifiche combinate per produrre i risultati finali.

Classificatore RRF

Esempio di RRF Ranker

Questo esempio mostra una ricerca ibrida (topK=5) su vettori sparsi e densi e illustra come la strategia RRFRanker classifica i risultati di due ricerche ANN.

• Risultati della ricerca RNA su vettori di testi sparsi (topK=5)：

  ID	Classifica (rada)
  101	1
  203	2
  150	3
  198	4
  175	5

• Risultati della ricerca della RNA su vettori densi di testi （topK=5)：

  ID	Classifica (densa)
  198	1
  101	2
  110	3
  175	4
  250	5

• Utilizzate l'RRF per riordinare le classifiche dei due gruppi di risultati della ricerca. Si supponga che il parametro di lisciatura k sia impostato a 60.

  ID	Punteggio (sparso)	Punteggio (denso)	Punteggio finale
  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/D	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

• I risultati finali dopo la riclassificazione (TopK=5)

  Classifica	ID	Punteggio finale
  1	101	0.03252247
  2	198	0.03201844
  3	175	0.03100962
  4	203	0.01612903
  5	150	0.01587302
  5	110	0.01587302

Utilizzo di RRF Ranker

Quando si utilizza la strategia di reranking RRF, è necessario configurare il parametro k. Si tratta di un parametro di smussamento che può modificare efficacemente i pesi relativi della ricerca full-text rispetto alla ricerca vettoriale. Il valore predefinito di questo parametro è 60 e può essere regolato entro un intervallo di (0, 16384). Il valore deve essere un numero in virgola mobile. Il valore consigliato è compreso tra [10, 100]. Mentre k=60 è una scelta comune, il valore ottimale di k può variare a seconda delle applicazioni e dei set di dati specifici. Si consiglia di testare e regolare questo parametro in base al caso d'uso specifico per ottenere le migliori prestazioni.

Creare un classificatore RRF

Dopo aver impostato la raccolta con più campi vettoriali, creare un RRF Ranker con un parametro di smoothing appropriato:

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

Parametro	Richiesto?	Descrizione	Valore/Esempio
name	Sì	Identificatore univoco per questa funzione	"rrf"
input_field_names	Sì	Elenco di campi vettoriali a cui applicare la funzione (deve essere vuoto per RRF Ranker)	[]
function_type	Sì	Il tipo di Funzione da invocare; utilizzare RERANK per specificare una strategia di reranking	FunctionType.RERANK
params.reranker	Sì	Specifica il metodo di reranking da utilizzare. Deve essere impostato su rrf per utilizzare RRF Ranker.	"weighted"
params.k	No	Parametro di attenuazione che controlla l'impatto dei ranghi dei documenti; un valore più alto di k riduce la sensibilità ai primi posti. Intervallo: (0, 16384); default: 60. Per i dettagli, fare riferimento a Meccanismo di RRF Ranker.	100

Applicazione alla ricerca ibrida

RRF Ranker è stato progettato specificamente per le operazioni di ricerca ibrida che combinano più campi vettoriali. Ecco come utilizzarlo in una ricerca ibrida:

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

Per ulteriori informazioni sulla ricerca ibrida, consultare la sezione Ricerca ibrida multivettoriale.