RRF-Rangierer

Reciprocal Rank Fusion (RRF) Ranker ist eine Reranking-Strategie für die Milvus-Hybridsuche, die Ergebnisse aus mehreren Vektorsuchpfaden auf der Grundlage ihrer Rangpositionen und nicht ihrer rohen Ähnlichkeitswerte ausbalanciert. Wie bei einem Sportturnier, bei dem die Rangfolge der Spieler und nicht die individuellen Statistiken berücksichtigt werden, kombiniert RRF Ranker die Suchergebnisse auf der Grundlage der Rangfolge der einzelnen Elemente in den verschiedenen Suchpfaden und erstellt so eine faire und ausgewogene endgültige Rangfolge.

Wann sollte RRF Ranker verwendet werden?

RRF Ranker wurde speziell für hybride Suchszenarien entwickelt, in denen Sie Ergebnisse aus mehreren Vektorsuchpfaden ohne explizite Wichtigkeitsgewichtung abgleichen möchten. Er ist besonders effektiv für:

Anwendungsfall	Beispiel	Warum RRF Ranker gut funktioniert
Multimodale Suche mit gleicher Wichtigkeit	Bild-Text-Suche, bei der beide Modalitäten gleich wichtig sind	Ausgewogene Ergebnisse, ohne dass willkürliche Gewichtungszuweisungen erforderlich sind
Ensemble-Vektor-Suche	Kombiniert Ergebnisse aus verschiedenen Einbettungsmodellen	Führt Rankings demokratisch zusammen, ohne die Punkteverteilung eines bestimmten Modells zu bevorzugen
Sprachübergreifende Suche	Auffinden von Dokumenten in mehreren Sprachen	Gleiche Rangfolge der Ergebnisse unabhängig von sprachspezifischen Einbettungsmerkmalen
Empfehlungen von Experten	Kombiniert Empfehlungen von mehreren Expertensystemen	Erzeugt konsensfähige Rankings, wenn verschiedene Systeme unvergleichbare Bewertungsmethoden verwenden

Wenn Ihre hybride Suchanwendung eine demokratische Abwägung mehrerer Suchpfade erfordert, ohne explizite Gewichtungen zu vergeben, ist RRF Ranker die ideale Wahl.

Mechanismus des RRF Ranker

Der Hauptarbeitsablauf der RRFRanker-Strategie ist wie folgt:

1. Sammeln von Suchrankings: Sammeln der Rangfolgen der Ergebnisse aus jedem Pfad der Vektorsuche (Rang_1, Rang_2).

2. Ranglisten zusammenführen: Konvertieren Sie die Rankings aus jedem Pfad (rank_rrf_1, rank_rrf_2) gemäß einer Formel.

   Die Berechnungsformel beinhaltet N, das die Anzahl der Abrufe darstellt. ranki(d) ist die Rangposition des Dokuments d, die vom i(ten) Abrufer erzeugt wurde. k ist ein Glättungsparameter, der normalerweise auf 60 gesetzt wird.

3. Aggregierte Rankings: Neueinstufung der Suchergebnisse auf der Grundlage der kombinierten Rankings, um die endgültigen Ergebnisse zu erhalten.

Rrf-Rangierer

Beispiel für RRF Ranker

Dieses Beispiel demonstriert eine hybride Suche (topK=5) auf sparse-dense Vektoren und veranschaulicht, wie die RRFRanker-Strategie die Ergebnisse von zwei ANN-Suchen neu ordnet.

• Ergebnisse der ANN-Suche auf spärlichen Textvektoren （topK=5)：

  ID	Rang (spärlich)
  101	1
  203	2
  150	3
  198	4
  175	5

• Ergebnisse der ANN-Suche auf dichten Textvektoren （topK=5)：

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

• Verwenden Sie RRF, um die Rangfolge der beiden Gruppen von Suchergebnissen neu zu ordnen. Nehmen Sie an, dass der Glättungsparameter k auf 60 eingestellt ist.

  ID	Punktzahl (spärlich)	Punktzahl (dicht)	Endgültige Punktzahl
  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	NICHT ZUTREFFEND	1/(60+3) = 0.01587302
  110	NICHT ZUTREFFEND	3	1/(60+3) = 0.01587302
  250	K.A.	5	1/(60+5) = 0.01538462

• Die endgültigen Ergebnisse nach der Neuordnung（topK=5)：

  Rang	ID	Endgültige Punktzahl
  1	101	0.03252247
  2	198	0.03201844
  3	175	0.03100962
  4	203	0.01612903
  5	150	0.01587302
  5	110	0.01587302

Verwendung von RRF Ranker

Wenn Sie die RRF-Ranglistenstrategie verwenden, müssen Sie den Parameter k konfigurieren. Es handelt sich dabei um einen Glättungsparameter, der die relative Gewichtung der Volltextsuche gegenüber der Vektorsuche effektiv verändern kann. Der Standardwert dieses Parameters ist 60, und er kann in einem Bereich von (0, 16384) eingestellt werden. Der Wert sollte eine Fließkommazahl sein. Der empfohlene Wert liegt zwischen [10, 100]. Während k=60 eine gängige Wahl ist, kann der optimale k Wert je nach Ihren spezifischen Anwendungen und Datensätzen variieren. Wir empfehlen, diesen Parameter auf der Grundlage Ihres spezifischen Anwendungsfalls zu testen und anzupassen, um die beste Leistung zu erzielen.

Erstellen eines RRF Rankers

Nachdem Ihre Sammlung mit mehreren Vektorfeldern eingerichtet ist, erstellen Sie einen RRF Ranker mit einem geeigneten Glättungsparameter:

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	Erforderlich?	Beschreibung	Wert/Beispiel
name	Ja	Eindeutiger Bezeichner für diese Funktion	"rrf"
input_field_names	Ja	Liste der Vektorfelder, auf die die Funktion angewendet werden soll (muss für RRF Ranker leer sein)	[]
function_type	Ja	Der Typ der aufzurufenden Funktion; verwenden Sie RERANK, um eine Rangordnungsstrategie anzugeben.	FunctionType.RERANK
params.reranker	Ja	Gibt die zu verwendende Rangfolgemethode an. Muss auf rrf gesetzt werden, um RRF Ranker zu verwenden.	"weighted"
params.k	Nein	Glättungsparameter, der die Auswirkung von Dokumentenrängen steuert; ein höherer k verringert die Empfindlichkeit gegenüber Spitzenrängen. Bereich: (0, 16384); Standardwert: 60. Einzelheiten finden Sie unter Mechanismus des RRF Ranker.	100

Auf hybride Suche anwenden

RRF Ranker wurde speziell für hybride Suchoperationen entwickelt, die mehrere Vektorfelder kombinieren. Hier wird beschrieben, wie man ihn in einer hybriden Suche einsetzt:

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

Weitere Informationen zur hybriden Suche finden Sie unter Hybride Suche mit mehreren Vektoren.