Gewichteter Ranker

Der Weighted Ranker kombiniert und priorisiert auf intelligente Weise Ergebnisse aus mehreren Suchpfaden, indem er ihnen eine unterschiedliche Gewichtung zuweist. Ähnlich wie ein geschickter Koch mehrere Zutaten zu einem perfekten Gericht kombiniert, gleicht Weighted Ranker verschiedene Suchergebnisse aus, um die relevantesten kombinierten Ergebnisse zu liefern. Dieser Ansatz ist ideal für die Suche in mehreren Vektorfeldern oder Modalitäten, bei denen bestimmte Felder einen größeren Beitrag zum endgültigen Ranking leisten sollten als andere.

Wann wird der Weighted Ranker verwendet?

Der Weighted Ranker wurde speziell für hybride Suchszenarien entwickelt, bei denen Sie Ergebnisse aus mehreren Vektorsuchpfaden kombinieren müssen. Er ist besonders effektiv für:

Anwendungsfall	Beispiel	Warum Weighted Ranker gut funktioniert
E-Commerce-Suche	Produktsuche, die Bildähnlichkeit und Textbeschreibung kombiniert	Ermöglicht Einzelhändlern, bei Modeartikeln die visuelle Ähnlichkeit zu priorisieren, während bei technischen Produkten die Textbeschreibungen im Vordergrund stehen
Suche nach Medieninhalten	Videosuche mit visuellen Merkmalen und Audiotranskripten	Gewichtet die Wichtigkeit von visuellen Inhalten gegenüber gesprochenen Dialogen je nach Suchabsicht
Abrufen von Dokumenten	Unternehmensweite Dokumentensuche mit mehreren Einbettungen für verschiedene Abschnitte	Höhere Gewichtung von Titel- und Zusammenfassungseinbettungen bei gleichzeitiger Berücksichtigung von Volltexteinbettungen

Wenn Ihre hybride Suchanwendung die Kombination mehrerer Suchpfade bei gleichzeitiger Kontrolle ihrer relativen Bedeutung erfordert, ist Weighted Ranker die ideale Wahl.

Mechanismus des Weighted Ranker

Der Hauptarbeitsablauf der WeightedRanker-Strategie ist wie folgt:

1. Sammeln von Suchergebnissen: Sammeln der Ergebnisse und Scores von jedem Pfad der Vektorsuche (score_1, score_2).

2. Normalisierung der Ergebnisse: Jede Suche kann unterschiedliche Ähnlichkeitsmetriken verwenden, was zu unterschiedlichen Punkteverteilungen führt. Beispielsweise kann die Verwendung des Inneren Produkts (IP) als Ähnlichkeitstyp zu Ergebnissen im Bereich [-∞,+∞] führen, während die Verwendung des Euklidischen Abstands (L2) zu Ergebnissen im Bereich [0,+∞] führt. Da die Wertebereiche der verschiedenen Suchvorgänge unterschiedlich sind und nicht direkt miteinander verglichen werden können, müssen die Werte der einzelnen Suchpfade normalisiert werden. In der Regel wird die Funktion arctan angewendet, um die Punktzahlen in einen Bereich zwischen [0, 1] umzuwandeln (score_1_normalisiert, score_2_normalisiert). Werte, die näher bei 1 liegen, zeigen eine höhere Ähnlichkeit an.

3. Gewichte zuweisen: Auf der Grundlage der Bedeutung, die den verschiedenen Vektorfeldern zugewiesen wird, werden den normalisierten Scores (score_1_normalisiert, score_2_normalisiert) Gewichte(wi) zugewiesen. Die Gewichte der einzelnen Pfade sollten zwischen [0,1] liegen. Die resultierenden gewichteten Scores sind score_1_weighted und score_2_weighted.

4. Scores zusammenführen: Die gewichteten Punktzahlen (score_1_weighted, score_2_weighted) werden vom höchsten zum niedrigsten Wert geordnet, um einen endgültigen Satz von Punktzahlen (score_final) zu erhalten.

Gewichteter Ranker

Beispiel für Weighted Ranker

Dieses Beispiel zeigt eine multimodale Hybrid-Suche (topK=5) mit Bildern und Text und veranschaulicht, wie die WeightedRanker-Strategie die Ergebnisse von zwei ANN-Suchen neu ordnet.

• Ergebnisse der ANN-Suche nach Bildern （topK=5)：

  ID	Punktzahl (Bild)
  101	0.92
  203	0.88
  150	0.85
  198	0.83
  175	0.8

• Ergebnisse der ANN-Suche nach Texten （topK=5)：

  ID	Punktzahl (Text)
  198	0.91
  101	0.87
  110	0.85
  175	0.82
  250	0.78

• Verwenden Sie WeightedRanker, um den Bild- und Textsuchergebnissen Gewichte zuzuweisen. Angenommen, die Gewichtung für die ANN-Bildersuche ist 0,6 und die Gewichtung für die Textsuche ist 0,4.

  ID	Punktzahl (Bild)	Punktzahl (Text)	Gewichtetes Ergebnis
  101	0.92	0.87	0.6×0.92+0.4×0.87=0.90
  203	0.88	N/A	0.6×0.88+0.4×0=0.528
  150	0.85	NICHT ZUTREFFEND	0.6×0.85+0.4×0=0.51
  198	0.83	0.91	0.6×0.83+0.4×0.91=0.86
  175	0.80	0.82	0.6×0.80+0.4×0.82=0.81
  110	Nicht im Bild	0.85	0.6×0+0.4×0.85=0.34
  250	Nicht im Bild	0.78	0.6×0+0.4×0.78=0.312

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

  Rang	ID	Endgültige Punktzahl
  1	101	0.90
  2	198	0.86
  3	175	0.81
  4	203	0.528
  5	150	0.51

Verwendung des Weighted Rankers

Bei der Verwendung der WeightedRanker-Strategie ist es erforderlich, Gewichtungswerte einzugeben. Die Anzahl der einzugebenden Gewichtungswerte sollte der Anzahl der grundlegenden ANN-Suchanfragen in der Hybrid Search entsprechen. Die eingegebenen Gewichtungswerte sollten im Bereich von [0,1] liegen, wobei Werte näher an 1 eine größere Bedeutung anzeigen.

Einen gewichteten Ranker erstellen

Angenommen, es gibt zwei grundlegende ANN-Suchanfragen in einer hybriden Suche: Textsuche und Bildsuche. Wenn die Textsuche als wichtiger angesehen wird, sollte ihr ein höheres Gewicht zugewiesen werden.

from pymilvus import Function, FunctionType

rerank = Function(
    name="weight",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "weighted", 
        "weights": [0.1, 0.9],
        "norm_score": True  # Optional
    }
)

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

CreateCollectionReq.Function rerank = CreateCollectionReq.Function.builder()
                .name("weight")
                .functionType(FunctionType.RERANK)
                .param("reranker", "weighted")
                .param("weights", "[0.1, 0.9]")
                .param("norm_score", "true")
                .build();

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

const rerank = {
    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	"weight"
input_field_names	Ja	Liste der Vektorfelder, auf die die Funktion angewendet werden soll (muss bei Weighted 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 weighted gesetzt werden, um Weighted Ranker zu verwenden.	"weighted"
params.weights	Ja	Array von Gewichten, die jedem Suchpfad entsprechen; Werte ∈ [0,1]. Für Details siehe Mechanismus des Weighted Ranker.	[0.1, 0.9]
params.norm_score	Nein	Ob die Rohwerte vor der Gewichtung normalisiert werden sollen (mit arctan). Für Details siehe Mechanismus des Weighted Rankers.	True

Auf hybride Suche anwenden

Weighted Ranker ist speziell für hybride Suchoperationen konzipiert, die mehrere Vektorfelder kombinieren. Bei der Durchführung einer hybriden Suche müssen Sie die Gewichte für jeden Suchpfad angeben:

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 Weighted Ranker to product hybrid search
# Text search has 0.8 weight, image search has 0.3 weight
hybrid_results = milvus_client.hybrid_search(
    collection_name,
    [text_search, image_search],  # Multiple search requests
    ranker=rerank,  # Apply the weighted 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 rerank = {
  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,
  limit: 10,
  data: [text_search, image_search],
  rerank: rerank,
  output_fields = ["product_name", "price", "category"],
});

// go

# restful

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