Boost-RangiererCompatible with Milvus v2.6.2+

Anstatt sich nur auf die semantische Ähnlichkeit zu verlassen, die auf der Grundlage von Vektorabständen berechnet wird, können Sie mit Boost Ranker die Suchergebnisse auf sinnvolle Art und Weise beeinflussen. Sie sind ideal für die schnelle Anpassung von Suchergebnissen mit Hilfe von Metadaten-Filterung.

Wenn eine Suchanfrage eine Boost Ranker-Funktion enthält, verwendet Milvus die optionale Filterbedingung innerhalb der Funktion, um Übereinstimmungen unter den Suchergebniskandidaten zu finden und erhöht die Punktzahlen dieser Übereinstimmungen durch Anwendung der angegebenen Gewichtung, wodurch die Rangfolge der übereinstimmenden Entitäten im Endergebnis verbessert oder verschlechtert wird.

Wann sollte Boost Ranker verwendet werden?

Im Gegensatz zu anderen Rankern, die sich auf Cross-Encoder-Modelle oder Fusionsalgorithmen stützen, fügt ein Boost Ranker optionale metadatengesteuerte Regeln direkt in den Ranking-Prozess ein, wodurch er sich für die folgenden Szenarien besser eignet.

Anwendungsfall	Beispiele	Warum Boost Ranker gut funktioniert
Business-gesteuerte Inhaltspriorisierung	Hervorhebung von Premium-Produkten in E-Commerce-Suchergebnissen Erhöhen der Sichtbarkeit von Inhalten mit hoher Nutzerbindung (z. B. Aufrufe, Likes und Freigaben) Hervorhebung von aktuellen Inhalten in zeitkritischen Suchanwendungen Bevorzugung von Inhalten aus verifizierten oder vertrauenswürdigen Quellen Aufwertung von Ergebnissen, die mit exakten Phrasen oder hochrelevanten Keywords übereinstimmen	Ohne die Notwendigkeit, Indizes neu zu erstellen oder Vektoreinbettungsmodelle zu ändern - Vorgänge, die zeitaufwändig sein können - können Sie bestimmte Elemente in den Suchergebnissen sofort auf- oder abwerten, indem Sie optionale Metadatenfilter in Echtzeit anwenden. Dieser Mechanismus ermöglicht ein flexibles, dynamisches Suchranking, das sich problemlos an sich verändernde Geschäftsanforderungen anpassen lässt.
Strategische Herabstufung von Inhalten	Reduzieren der Bedeutung von Artikeln mit geringem Bestand, ohne sie vollständig zu entfernen Herabstufung von Inhalten mit potenziell anstößigen Begriffen ohne Zensur Herabstufung älterer Dokumentationen, während sie in der technischen Suche zugänglich bleiben Subtiles Verringern der Sichtbarkeit von Konkurrenzprodukten in Marktplatzsuchen Verringerung der Relevanz von Inhalten mit Qualitätsmängeln (z. B. Formatierungsprobleme, geringe Länge usw.)

Sie können auch mehrere Boost Ranker kombinieren, um eine dynamischere und robustere gewichtsbasierte Rankingstrategie zu implementieren.

Mechanismus von Boost Ranker

Das folgende Diagramm veranschaulicht den Hauptarbeitsablauf von Boost Rankern.

Boost Ranker-Mechanismus

Wenn Sie Daten einfügen, verteilt Milvus diese auf Segmente. Während einer Suche gibt jedes Segment eine Reihe von Kandidaten zurück, und Milvus ordnet diese Kandidaten aus allen Segmenten ein, um die endgültigen Ergebnisse zu erhalten. Wenn eine Suchanfrage einen Boost Ranker enthält, wendet Milvus diesen auf die Kandidatenergebnisse aus jedem Segment an, um einen potenziellen Präzisionsverlust zu verhindern und den Recall zu verbessern.

Bevor die Ergebnisse abgeschlossen werden, verarbeitet Milvus diese Kandidaten mit dem Boost Ranker wie folgt:

1. Wendet den optionalen Filterausdruck an, der im Boost Ranker angegeben ist, um die Entitäten zu identifizieren, die mit dem Ausdruck übereinstimmen.

2. Wendet die im Boost Ranker angegebene Gewichtung an, um die Punktzahlen der identifizierten Entitäten zu erhöhen.

Beispiele für Boost Ranker

Das folgende Beispiel veranschaulicht die Verwendung eines Boost Rankers in einer Einzelvektorsuche, bei der die fünf relevantesten Entitäten zurückgegeben werden müssen und den Ergebnissen von Entitäten mit dem abstrakten Dokumenttyp Gewichtungen hinzugefügt werden.

1. Sammeln Sie Suchergebniskandidaten in Segmenten.

   In der folgenden Tabelle wird davon ausgegangen, dass Milvus die Entitäten in zwei Segmente(0001 und 0002) verteilt, wobei jedes Segment fünf Kandidaten zurückgibt.

   ID	DokTyp	Punktzahl	Rang	Segment
   117	abstrakt	0.344	1	0001
   89	abstrakt	0.456	2	0001
   257	Körper	0.578	3	0001
   358	Titel	0.788	4	0001
   168	Körper	0.899	5	0001
   46	Körper	0.189	1	0002
   48	Körper	0265	2	0002
   561	abstrakt	0.366	3	0002
   344	abstrakt	0.444	4	0002
   276	abstrakt	0.845	5	0002

2. Wenden Sie den im Boost Ranker angegebenen Filterausdruck an (doctype='abstract').

   Wie im Feld DocType in der folgenden Tabelle angegeben, markiert Milvus alle Entitäten, deren doctype auf abstract gesetzt ist, für die weitere Verarbeitung.

   ID	DokTyp	Bewertung	Rang	Segment
   117	abstrakt	0.344	1	0001
   89	abstrakt	0.456	2	0001
   257	Körper	0.578	3	0001
   358	Titel	0.788	4	0001
   168	Körper	0.899	5	0001
   46	Körper	0.189	1	0002
   48	Körper	0265	2	0002
   561	abstrakt	0.366	3	0002
   344	abstrakt	0.444	4	0002
   276	abstrakt	0.845	5	0002

3. Wenden Sie die im Boost Ranker angegebene Gewichtung an (weight=0.5).

   Alle im vorangegangenen Schritt identifizierten Entitäten werden mit der im Boost Ranker angegebenen Gewichtung multipliziert, was zu einer Änderung ihres Ranges führt.

   ID	DokTyp	Punktzahl	Gewichtete Punktzahl (= Punktzahl x Gewichtung)	Rang	Segment
   117	abstrakt	0.344	0.172	1	0001
   89	abstrakt	0.456	0.228	2	0001
   257	Körper	0.578	0.578	3	0001
   358	Titel	0.788	0.788	4	0001
   168	Körper	0.899	0.899	5	0001
   561	abstrakt	0.366	0.183	1	0002
   46	Körper	0.189	0.189	2	0002
   344	abstrakt	0.444	0.222	3	0002
   48	Körper	0.265	0.265	4	0002
   276	abstrakt	0.845	0.423	5	0002

   Die Gewichtung muss eine Gleitkommazahl sein, die Sie selbst wählen. In Fällen wie dem obigen Beispiel, in dem eine geringere Punktzahl auf eine höhere Relevanz hinweist, verwenden Sie eine Gewichtung kleiner als 1, ansonsten eine Gewichtung größer als 1.

4. Aggregieren Sie die Kandidaten aus allen Segmenten auf der Grundlage der gewichteten Punktzahlen, um die Ergebnisse zu vervollständigen.

   ID	DokTyp	Punktzahl	Gewichtete Punktzahl	Rang	Segment
   117	abstrakt	0.344	0.172	1	0001
   561	abstrakt	0.366	0.183	2	0002
   46	Körper	0.189	0.189	3	0002
   344	abstrakt	0.444	0.222	4	0002
   89	abstrakt	0.456	0.228	5	0001

Verwendung von Boost Ranker

In diesem Abschnitt sehen Sie Beispiele für die Verwendung von Boost Ranker, um die Ergebnisse einer Einzelvektorsuche zu beeinflussen.

Erstellen eines Boost Rankers

Bevor Sie einen Boost Ranker als Reranker einer Suchanfrage übergeben, sollten Sie den Boost Ranker wie folgt als Reranking-Funktion definieren:

from pymilvus import Function, FunctionType

ranker = Function(
    name="boost",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "boost",
        "filter": "doctype == 'abstract'",
        "random_score": { 
            "seed": 126,
            "field": "id"
        },
        "weight": 0.5
    }
)

import io.milvus.v2.service.vector.request.ranker.BoostRanker;

BoostRanker ranker = BoostRanker.builder()
        .name("boost")
        .filter("doctype == \"abstract\"")
        .weight(5.0f)
        .randomScoreField("id")
        .randomScoreSeed(126)
        .build();

// go

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

const ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    filter: "doctype == 'abstract'",
    random_score: {
      seed: 126,
      field: "id",
    },
    weight: 0.5,
  },
};

# restful

Parameter	Erforderlich?	Beschreibung	Wert/Beispiel
name	Ja	Eindeutiger Bezeichner für diese Funktion	"boost"
input_field_names	Ja	Liste der Vektorfelder, auf die die Funktion angewendet werden soll (muss für Boost Ranker leer sein)	[]
function_type	Ja	Der Typ der aufzurufenden Funktion; verwenden Sie RERANK, um eine Rangordnungsstrategie anzugeben	FunctionType.RERANK
params.reranker	Ja	Gibt den Typ des Rerankers an. Muss auf boost gesetzt werden, um Boost Ranker zu verwenden.	"boost"
params.weight	Ja	Gibt die Gewichtung an, die mit den Punktzahlen aller übereinstimmenden Entitäten in den rohen Suchergebnissen multipliziert wird. Der Wert sollte eine Fließkommazahl sein. Um die Wichtigkeit übereinstimmender Entitäten zu betonen, setzen Sie ihn auf einen Wert, der die Punktzahl erhöht. Um übereinstimmende Entitäten herabzustufen, weisen Sie diesem Parameter einen Wert zu, der ihre Punktzahl senkt.	1
params.filter	Keine	Gibt den Filterausdruck an, der verwendet wird, um Entitäten unter den Suchergebnis-Entitäten abzugleichen. Es kann ein beliebiger gültiger grundlegender Filterausdruck sein, der in Filtering Explained erwähnt wird. Hinweis: Verwenden Sie nur einfache Operatoren wie ==, > oder <. Die Verwendung von erweiterten Operatoren wie text_match oder phrase_match beeinträchtigt die Suchleistung.	"doctype == 'abstract'"
params.random_score	Nein	Gibt die Zufallsfunktion an, die einen Wert zwischen 0 und 1 zufällig erzeugt. Sie hat die folgenden zwei optionalen Argumente: seed (number) Gibt einen Anfangswert an, der zum Starten eines Pseudozufallszahlengenerators (PRNG) verwendet wird. field (string) Gibt den Namen eines Feldes an, dessen Wert als Zufallsfaktor bei der Erzeugung der Zufallszahl verwendet wird. Ein Feld mit eindeutigen Werten ist ausreichend. Es wird empfohlen, sowohl seed als auch field festzulegen, um die Konsistenz zwischen den Generationen zu gewährleisten, indem dieselben Seed- und Feldwerte verwendet werden.	{"seed": 126, "field": "id"}

Suche mit einem einzigen Boost Ranker

Sobald die Boost Ranker-Funktion fertig ist, können Sie sie in einer Suchanfrage referenzieren. Im folgenden Beispiel wird davon ausgegangen, dass Sie bereits eine Sammlung mit den folgenden Feldern erstellt haben: id, vector und doctype.

from pymilvus import MilvusClient

# Connect to the Milvus server
client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

# Assume you have a collection set up

# Conduct a similarity search using the created ranker
client.search(
    collection_name="my_collection",
    data=[[-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911]],
    anns_field="vector",
    params={},
    output_field=["doctype"],
    ranker=ranker
)

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

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build());
        
SearchResp searchReq = client.search(SearchReq.builder()
        .collectionName("my_collection")
        .data(Collections.singletonList(new FloatVec(new float[]{-0.619954f, 0.447943f, -0.174938f, -0.424803f, -0.864845f})))
        .annsField("vector")
        .outputFields(Collections.singletonList("doctype"))
        .functionScore(FunctionScore.builder()
                .addFunction(ranker)
                .build())
        .build());
SearchResp searchResp = client.search(searchReq);

// go

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

// Connect to the Milvus server
const client = new MilvusClient({
  address: 'localhost:19530',
  token: 'root:Milvus'
});

// Assume you have a collection set up

// Conduct a similarity search
const searchResults = await client.search({
  collection_name: 'my_collection',
  data: [-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911],
  anns_field: 'vector',
  output_fields: ['doctype'],
  rerank: ranker,
});

console.log('Search results:', searchResults);

# restful

Suche mit mehreren Boost Rankern

Sie können mehrere Boost Rankers in einer einzigen Suche kombinieren, um die Suchergebnisse zu beeinflussen. Erstellen Sie dazu mehrere Boost Rankers, verweisen Sie auf sie in einer FunctionScore-Instanz und verwenden Sie die FunctionScore-Instanz als Ranker in der Suchanfrage.

Das folgende Beispiel zeigt, wie die Punktzahlen aller identifizierten Entitäten durch Anwendung einer Gewichtung zwischen 0,8 und 1,2 geändert werden können.

from pymilvus import MilvusClient, Function, FunctionType, FunctionScore

# Create a Boost Ranker with a fixed weight
fix_weight_ranker = Function(
    name="boost",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "boost",
        "weight": 0.8
    }
)

# Create a Boost Ranker with a randomly generated weight between 0 and 0.4
random_weight_ranker = Function(
    name="boost",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "boost",
        "random_score": {
            "seed": 126,
        },
        "weight": 0.4
    }
)

# Create a Function Score
ranker = FunctionScore(
    functions=[
        fix_weight_ranker, 
        random_weight_ranker
    ],
    params={
        "boost_mode": "Multiply",
        "function_mode": "Sum"
    }
)

# Conduct a similarity search using the created Function Score
client.search(
    collection_name="my_collection",
    data=[[-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911]],
    anns_field="vector",
    params={},
    output_field=["doctype"],
    ranker=ranker
)

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

CreateCollectionReq.Function fixWeightRanker = CreateCollectionReq.Function.builder()
                 .functionType(FunctionType.RERANK)
                 .name("boost")
                 .param("reranker", "boost")
                 .param("weight", "0.8")
                 .build();
                 
CreateCollectionReq.Function randomWeightRanker = CreateCollectionReq.Function.builder()
                 .functionType(FunctionType.RERANK)
                 .name("boost")
                 .param("reranker", "boost")
                 .param("weight", "0.4")
                 .param("random_score", "{\"seed\": 126}")
                 .build();

Map<String, String> params = new HashMap<>();
params.put("boost_mode","Multiply");
params.put("function_mode","Sum");     
FunctionScore ranker = FunctionScore.builder()
                 .addFunction(fixWeightRanker)
                 .addFunction(randomWeightRanker)
                 .params(params)
                 .build()

SearchResp searchReq = client.search(SearchReq.builder()
                 .collectionName("my_collection")
                 .data(Collections.singletonList(new FloatVec(new float[]{-0.619954f, 0.447943f, -0.174938f, -0.424803f, -0.864845f})))
                 .annsField("vector")
                 .outputFields(Collections.singletonList("doctype"))
                 .addFunction(ranker)
                 .build());
SearchResp searchResp = client.search(searchReq);

// go

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

const fix_weight_ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    weight: 0.8,
  },
};

const random_weight_ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    random_score: {
      seed: 126,
    },
    weight: 0.4,
  },
};

const ranker = {
  functions: [fix_weight_ranker, random_weight_ranker],
  params: {
    boost_mode: "Multiply",
    function_mode: "Sum",
  },
};

await client.search({
  collection_name: "my_collection",
  data: [[-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911]],
  anns_field: "vector",
  params: {},
  output_field: ["doctype"],
  ranker: ranker
});

# restful

Konkret gibt es zwei Boost Ranker: Einer wendet eine feste Gewichtung auf alle gefundenen Entitäten an, während der andere ihnen eine zufällige Gewichtung zuweist. Anschließend referenzieren wir diese beiden Ranker in einer FunctionScore, die auch definiert, wie die Gewichtungen die Punktzahlen der gefundenen Entitäten beeinflussen.

In der folgenden Tabelle sind die Parameter aufgeführt, die zur Erstellung einer FunctionScore-Instanz erforderlich sind.

Parameter	Erforderlich?	Beschreibung	Wert/Beispiel
functions	Ja	Gibt die Namen der Ziel-Rangierer in einer Liste an.	["fix_weight_ranker", "random_weight_ranker"]
params.boost_mode	Nein	Gibt an, wie die angegebenen Gewichtungen die Punktzahlen aller übereinstimmenden Entitäten beeinflussen. Mögliche Werte sind: Multiply Gibt an, dass der gewichtete Wert gleich der ursprünglichen Punktzahl einer übereinstimmenden Entität multipliziert mit der angegebenen Gewichtung ist. Dies ist der Standardwert. Sum Zeigt an, dass der gewichtete Wert gleich der Summe aus der ursprünglichen Punktzahl einer übereinstimmenden Entität und der angegebenen Gewichtung ist.	"Sum"
params.function_mode	Keine	Gibt an, wie die gewichteten Werte aus verschiedenen Boost Rankers verarbeitet werden. Mögliche Werte sind: Multiply Gibt an, dass die endgültige Punktzahl einer übereinstimmenden Entität gleich dem Produkt der gewichteten Werte aus allen Boost Rankern ist. Dies ist der Standardwert. Sum Gibt an, dass die endgültige Punktzahl einer übereinstimmenden Entität gleich der Summe der gewichteten Werte aus allen Boost Rankern ist.	"Sum"