RRF Ranker

Reciprocal Rank Fusion (RRF) Ranker est une stratégie de reclassement pour la recherche hybride Milvus qui équilibre les résultats de plusieurs chemins de recherche vectorielle en fonction de leurs positions de classement plutôt que de leurs scores de similarité bruts. À l'instar d'un tournoi sportif qui prend en compte les classements des joueurs plutôt que les statistiques individuelles, RRF Ranker combine les résultats de recherche en fonction du classement de chaque élément dans les différents chemins de recherche, créant ainsi un classement final juste et équilibré.

Quand utiliser RRF Ranker ?

RRF Ranker est spécialement conçu pour les scénarios de recherche hybride dans lesquels vous souhaitez équilibrer les résultats de plusieurs chemins de recherche vectoriels sans attribuer de poids d'importance explicites. Il est particulièrement efficace pour :

Cas d'utilisation	Exemple de cas d'utilisation	Pourquoi RRF Ranker fonctionne bien
Recherche multimodale avec la même importance	Recherche image-texte où les deux modalités ont la même importance	Équilibre les résultats sans nécessiter d'affectations de poids arbitraires
Recherche vectorielle d'ensemble	Combinaison des résultats de différents modèles d'intégration	Fusion démocratique des classements sans favoriser la distribution des scores d'un modèle particulier
Recherche multilingue	Recherche de documents dans plusieurs langues	Classement équitable des résultats indépendamment des caractéristiques d'intégration propres à chaque langue
Recommandations d'experts	Combinaison de recommandations provenant de plusieurs systèmes experts	Crée des classements consensuels lorsque différents systèmes utilisent des méthodes de notation incomparables.

Si votre application de recherche hybride nécessite d'équilibrer démocratiquement plusieurs chemins de recherche sans attribuer de poids explicites, RRF Ranker est votre choix idéal.

Mécanisme de RRF Ranker

Le flux de travail principal de la stratégie RRFRanker est le suivant :

1. Collecte des classements de recherche: Collecte des classements des résultats de chaque chemin de recherche vectorielle (rang_1, rang_2).

2. Fusionner les classements: Convertir les classements de chaque chemin (rang_rrf_1, rang_rrf_2) selon une formule.

   La formule de calcul implique N, qui représente le nombre d'extractions. ranki(d) est la position de classement du document d généré par le i(ème ) extracteur. k est un paramètre de lissage généralement fixé à 60.

3. Classement agrégé: Reclasser les résultats de la recherche sur la base des classements combinés pour produire les résultats finaux.

Classeur RRF

Exemple de classement RRF

Cet exemple illustre une recherche hybride (topK=5) sur des vecteurs peu denses et montre comment la stratégie RRFRanker reclasse les résultats de deux recherches ANN.

• Résultats de la recherche ANN sur des vecteurs de textes peu denses （topK=5)：

  ID	Rang (clair)
  101	1
  203	2
  150	3
  198	4
  175	5

• Résultats de la recherche ANN sur des vecteurs denses de textes （topK=5)：

  ID	Rang (dense)
  198	1
  101	2
  110	3
  175	4
  250	5

• Utilisez la méthode RRF pour réorganiser les classements des deux ensembles de résultats de recherche. Supposez que le paramètre de lissage k est fixé à 60.

  ID	Score (clairsemé)	Score (dense)	Score final
  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

• Les résultats finaux après reranking（topK=5)：

  Rang	ID	Score final
  1	101	0.03252247
  2	198	0.03201844
  3	175	0.03100962
  4	203	0.01612903
  5	150	0.01587302
  5	110	0.01587302

Utilisation du classificateur RRF

Lorsque vous utilisez la stratégie de reclassement RRF, vous devez configurer le paramètre k. Il s'agit d'un paramètre de lissage qui peut modifier efficacement les poids relatifs de la recherche en texte intégral par rapport à la recherche vectorielle. La valeur par défaut de ce paramètre est 60, et il peut être ajusté dans une plage de (0, 16384). La valeur doit être un nombre à virgule flottante. La valeur recommandée est comprise entre [10 et 100]. Bien que k=60 soit un choix courant, la valeur optimale de k peut varier en fonction de vos applications et ensembles de données spécifiques. Nous vous recommandons de tester et d'ajuster ce paramètre en fonction de votre cas d'utilisation spécifique afin d'obtenir les meilleures performances.

Créer un classificateur RRF

Une fois que votre collection est configurée avec plusieurs champs de vecteurs, créez un Ranker RRF avec un paramètre de lissage approprié :

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

Paramètres	Nécessaire ?	Description	Valeur/Exemple
name	Oui	Identifiant unique pour cette fonction	"rrf"
input_field_names	Oui	Liste des champs vectoriels auxquels appliquer la fonction (doit être vide pour RRF Ranker)	[]
function_type	Oui	Type de fonction à invoquer ; utiliser RERANK pour spécifier une stratégie de reclassement	FunctionType.RERANK
params.reranker	Oui	Spécifie la méthode de reclassement à utiliser. La valeur rrf est requise pour utiliser RRF Ranker.	"weighted"
params.k	Non	Paramètre de lissage qui contrôle l'impact du classement des documents ; une valeur plus élevée ( k ) réduit la sensibilité aux premiers rangs. Plage : (0, 16384) ; valeur par défaut : 60. Pour plus de détails, voir Mécanisme de RRF Ranker.	100

Application à la recherche hybride

RRF Ranker est conçu spécifiquement pour les opérations de recherche hybride qui combinent plusieurs champs de vecteurs. Voici comment l'utiliser dans une recherche hybride :

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

Pour plus d'informations sur la recherche hybride, reportez-vous à la section Recherche hybride multi-vecteurs.