Decay Ranker ÜberblickCompatible with Milvus 2.6.x

Bei der herkömmlichen Vektorsuche werden die Ergebnisse ausschließlich nach der Vektorähnlichkeit eingestuft, d. h. danach, wie gut die Vektoren im mathematischen Raum übereinstimmen. In realen Anwendungen hängt die tatsächliche Relevanz von Inhalten jedoch oft von mehr als nur semantischer Ähnlichkeit ab.

Betrachten Sie diese alltäglichen Szenarien:

• Eine Nachrichtensuche, bei der der Artikel von gestern höher bewertet werden sollte als ein ähnlicher Artikel von vor drei Jahren

• Ein Restaurantfinder, der Lokale in 5 Minuten Entfernung gegenüber solchen bevorzugt, die eine 30-minütige Fahrt erfordern

• Eine E-Commerce-Plattform, die trendige Produkte anpreist, auch wenn sie der Suchanfrage weniger ähnlich sind

Alle diese Szenarien haben eine gemeinsame Anforderung: Abwägung der Vektorähnlichkeit mit anderen numerischen Faktoren wie Zeit, Entfernung oder Popularität.

Die Decay Ranker in Milvus gehen auf dieses Bedürfnis ein, indem sie Suchrankings basierend auf numerischen Feldwerten anpassen. Sie ermöglichen es Ihnen, die Vektorähnlichkeit mit "Frische", "Nähe" oder anderen numerischen Eigenschaften Ihrer Daten auszugleichen und so intuitivere und kontextbezogene Sucherlebnisse zu schaffen.

Hinweise zur Verwendung

• Das Decay-Ranking kann nicht mit Gruppierungssuchen verwendet werden.

• Das für das Verfallsranking verwendete Feld muss numerisch sein (INT8, INT16, INT32, INT64, FLOAT oder DOUBLE).

• Jeder Decay Ranker kann nur ein numerisches Feld verwenden.

• Konsistenz der Zeiteinheit: Wenn Sie ein zeitbasiertes Zerfallsranking verwenden, müssen die Einheiten für die Parameter origin, scale und offset mit den in Ihren Sammlungsdaten verwendeten Einheiten übereinstimmen:

  • Wenn Ihre Sammlung Zeitstempel in Sekunden speichert, verwenden Sie Sekunden für alle Parameter

  • Wenn Ihre Sammlung Zeitstempel in Millisekunden speichert, verwenden Sie Millisekunden für alle Parameter

  • Wenn Ihre Sammlung Zeitstempel in Mikrosekunden speichert, verwenden Sie für alle Parameter Mikrosekunden.

Wie funktioniert das?

Das Decay-Ranking erweitert die traditionelle Vektorsuche, indem es numerische Faktoren wie Zeit oder geografische Entfernung in den Ranking-Prozess einbezieht. Der gesamte Prozess verläuft in den folgenden Phasen:

Stufe 1: Berechnung der normalisierten Ähnlichkeitswerte

Zunächst berechnet und normalisiert Milvus die Ähnlichkeitswerte der Vektoren, um einen einheitlichen Vergleich zu gewährleisten:

• Für L2 und JACCARD Distanzmetriken (wobei niedrigere Werte eine höhere Ähnlichkeit anzeigen):

  normalized_score = 1.0 - (2 × arctan(score))/π
  

  Hier werden die Abstände in Ähnlichkeitswerte zwischen 0 und 1 umgewandelt, wobei ein höherer Wert besser ist.

• Für IP-, COSINE- und BM25-Metriken (wo höhere Punktzahlen bereits bessere Übereinstimmungen anzeigen): Die Werte werden direkt ohne Normalisierung verwendet.

Stufe 2: Berechnung der Decay-Scores

Als Nächstes berechnet Milvus einen Decay-Score auf der Grundlage des numerischen Feldwerts (wie Zeitstempel oder Entfernung) unter Verwendung des von Ihnen gewählten Decay Rankers:

• Jeder Decay Ranker wandelt rohe numerische Werte in normalisierte Relevanzwerte zwischen 0-1 um.

• Der Decay-Score gibt an, wie relevant ein Element ist, basierend auf seiner "Entfernung" vom idealen Punkt.

Die spezifische Berechnungsformel variiert je nach Typ des Decay Rankers. Einzelheiten zur Berechnung eines Zerfallswertes finden Sie auf den entsprechenden Seiten für Gauß'schen Zerfall, Exponentialzerfall und linearen Zerfall.

Stufe 3: Berechnen der endgültigen Punktzahlen

Abschließend kombiniert Milvus die normalisierte Ähnlichkeitsbewertung und die Abklingbewertung, um die endgültige Ranglistenbewertung zu erstellen:

final_score = normalized_similarity_score × decay_score

Im Falle einer hybriden Suche (Kombination mehrerer Vektorfelder) nimmt Milvus die maximale normalisierte Ähnlichkeitsbewertung unter den Suchanfragen:

final_score = max([normalized_score₁, normalized_score₂, ..., normalized_scoreₙ]) × decay_score

Wenn beispielsweise eine Forschungsarbeit bei einer hybriden Suche 0,82 bei der Vektorähnlichkeit und 0,91 beim BM25-basierten Text-Retrieval erzielt, verwendet Milvus 0,91 als Basisähnlichkeitswert, bevor der Decay-Faktor angewendet wird.

Decay-Ranking in Aktion

Schauen wir uns das Decay-Ranking in einem praktischen Szenario an - bei der Suche nach "AI-Forschungsarbeiten" mit zeitbasiertem Decay:

Papier	Vektorielle Ähnlichkeit	Normalisierter Ähnlichkeitswert	Datum der Veröffentlichung	Abklingende Punktzahl	Endgültige Punktzahl	Endgültiger Rang
Papier A	Hoch	0.85 (COSINE)	vor 2 Wochen	0.80	0.68	2
Papier B	Sehr hoch	0.92 (COSINE)	vor 6 Monaten	0.45	0.41	3
Papier C	Mittel	0.75 (COSINE)	vor 1 Tag	0.98	0.74	1
Papier D	Mittel-Hoch	0.76 (COSINE)	vor 3 Wochen	0.70	0.53	4

Ohne decay reranking würde Papier B auf der Grundlage der reinen Vektorähnlichkeit (0,92) den höchsten Rang einnehmen. Bei Anwendung des Decay-Rerankings jedoch:

• Arbeit C springt trotz mittlerer Ähnlichkeit auf Platz 1, weil sie sehr aktuell ist (gestern veröffentlicht)

• Arbeit B fällt trotz ausgezeichneter Ähnlichkeit auf Platz 3, weil sie relativ alt ist.

• Arbeit D verwendet die L2-Distanz (niedriger ist besser), daher wird ihre Punktzahl von 1,2 auf 0,76 normalisiert, bevor der Decay angewendet wird.

Wählen Sie den richtigen Decay Ranker

Milvus bietet verschiedene Decay Ranker an - gauss, exp, linear, die jeweils für spezielle Anwendungsfälle entwickelt wurden:

Abkling-Rangierer	Merkmale	Ideale Anwendungsfälle	Beispiel-Szenario
Gaußförmig (gauss)	Natürlich wirkender allmählicher Rückgang, der sich mäßig ausdehnt	Allgemeine Suchen, die ausgewogene Ergebnisse erfordern Anwendungen, bei denen die Benutzer ein intuitives Gefühl für die Entfernung haben Wenn eine moderate Entfernung die Ergebnisse nicht stark beeinträchtigen sollte	Bei der Suche nach einem Restaurant bleiben qualitativ hochwertige Lokale in 3 km Entfernung auffindbar, obwohl sie in der Rangliste niedriger eingestuft werden als nahe gelegene Optionen
Exponential (exp)	Nimmt anfangs schnell ab, behält aber einen langen Schwanz bei	Newsfeeds, bei denen die Aktualität entscheidend ist Soziale Medien, wo frische Inhalte dominieren sollten Wenn die Nähe stark bevorzugt wird, aber außergewöhnlich weit entfernte Artikel sichtbar bleiben sollten	In einer Nachrichten-App rangieren die Geschichten von gestern viel höher als wochenalte Inhalte, aber hochrelevante ältere Artikel können immer noch erscheinen
Linear (linear)	Konsistenter, vorhersehbarer Rückgang mit einer klaren Abgrenzung	Anwendungen mit natürlichen Grenzen Dienste mit Entfernungsgrenzen Inhalte mit Verfallsdaten oder klaren Schwellenwerten	In einer Ereignissuche werden Ereignisse, die über ein zweiwöchiges Zukunftsfenster hinausgehen, einfach nicht angezeigt.

Detaillierte Informationen darüber, wie jeder Decay Ranker die Punktzahlen und spezifischen Abnahmemuster berechnet, finden Sie in der entsprechenden Dokumentation:

• Gaußscher Zerfall

• Exponentialer Zerfall

• Linearer Verfall

Beispiel für die Implementierung

Decay Rankers können sowohl auf die Standard-Vektorsuche als auch auf hybride Suchoperationen in Milvus angewendet werden. Im Folgenden finden Sie die wichtigsten Codeschnipsel für die Implementierung dieser Funktion.

Erstellen Sie einen Decay Ranker

Um das Decay-Ranking zu implementieren, definieren Sie zunächst ein Function Objekt mit der entsprechenden Konfiguration:

from pymilvus import Function, FunctionType

# Create a decay function for timestamp-based decay
# Note: All time parameters must use the same unit as your collection data
decay_ranker = Function(
    name="time_decay",                  # Function identifier
    input_field_names=["timestamp"],    # Numeric field to use for decay
    function_type=FunctionType.RERANK,  # Must be set to RERANK for decay rankers
    params={
        "reranker": "decay",            # Specify decay reranker. Must be "decay"
        "function": "gauss",            # Choose decay function type: "gauss", "exp", or "linear"
        "origin": int(datetime.datetime(2025, 1, 15).timestamp()),    # Reference point (seconds)
        "scale": 7 * 24 * 60 * 60,      # 7 days in seconds (must match collection data unit)
        "offset": 24 * 60 * 60,         # 1 day no-decay zone (must match collection data unit)
        "decay": 0.5                    # Half score at scale distance
    }
)

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

import java.time.ZoneId;
import java.time.ZonedDateTime;

ZonedDateTime zdt = ZonedDateTime.of(2025, 1, 25, 0, 0, 0, 0, ZoneId.systemDefault());

DecayRanker ranker = DecayRanker.builder()
        .name("time_decay")
        .inputFieldNames(Collections.singletonList("timestamp"))
        .function("gauss")
        .origin(zdt.toInstant().toEpochMilli())
        .scale(7 * 24 * 60 * 60)
        .offset(24 * 60 * 60)
        .decay(0.5)
        .build();

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

const decayRanker = {
  name: "time_decay",
  input_field_names: ["timestamp"],
  function_type: FunctionType.RERANK,
  params: {
    reranker: "decay",
    function: "gauss",
    origin: new Date(2025, 1, 15).getTime(),
    scale: 7 * 24 * 60 * 60,
    offset: 24 * 60 * 60,
    decay: 0.5,
  },
};

// go

# restful

Parameter	Erforderlich?	Beschreibung	Wert/Beispiel
name	Ja	Bezeichner für Ihre Funktion, die bei der Ausführung von Suchen verwendet wird. Wählen Sie einen beschreibenden Namen, der für Ihren Anwendungsfall relevant ist.	"time_decay"
input_field_names	Ja	Numerisches Feld für die Berechnung der Abklingrate. Legt fest, welches Datenattribut für die Berechnung des Verfalls verwendet wird (z. B. Zeitstempel für zeitbasierten Verfall, Koordinaten für ortsbezogenen Verfall). Muss ein Feld in Ihrer Sammlung sein, das relevante numerische Werte enthält. Unterstützt INT8/16/32/64, FLOAT, DOUBLE.	["timestamp"]
function_type	Ja	Gibt den Typ der zu erstellenden Funktion an. Muss für alle Zerfallsrangierer auf RERANK gesetzt werden.	FunctionType.RERANK
params.reranker	Ja	Legt die zu verwendende Ranglistenmethode fest. Muss auf "decay" gesetzt werden, um die Funktion des Zerfallsrankings zu aktivieren.	"decay"
params.function	Ja	Legt fest, welcher mathematische Decay Ranker angewendet werden soll. Bestimmt die Kurvenform des Relevanzabfalls. Eine Anleitung zur Auswahl der geeigneten Funktion finden Sie im Abschnitt Wählen Sie den richtigen Decay Ranker.	"gauss", "exp", oder "linear"
params.origin	Ja	Referenzpunkt, von dem aus die Zerfallsbewertung berechnet wird. Artikel mit diesem Wert erhalten maximale Relevanzwerte. Bei zeitbasiertem Verfall muss die Zeiteinheit mit Ihren Erfassungsdaten übereinstimmen.	Für Zeitstempel: aktuelle Zeit (z. B. int(time.time())) Für Geolocation: die aktuellen Koordinaten des Nutzers
params.scale	Ja	Entfernung oder Zeit, zu der die Relevanz auf den Wert decay fällt. Steuert, wie schnell die Relevanz abnimmt. Bei einem zeitbasierten Verfall muss die Zeiteinheit mit Ihren Erfassungsdaten übereinstimmen. Größere Werte sorgen für einen allmählichen Rückgang der Relevanz, kleinere Werte für einen steileren Rückgang.	Für Zeit: Zeitraum in Sekunden (z. B. 7 * 24 * 60 * 60 für 7 Tage) Für die Entfernung: Meter (z. B. 5000 für 5 km)
params.offset	Kein	Erzeugt eine "Nicht-Verfall-Zone" um die origin, in der Elemente ihre volle Punktzahl beibehalten (Verfallswert = 1,0). Bei zeitbasiertem Verfall muss die Zeiteinheit mit Ihren Erfassungsdaten übereinstimmen. Elemente innerhalb dieses Bereichs von origin behalten ihre maximale Relevanz.	Für Zeit: Zeitraum in Sekunden (z. B. 24 * 60 * 60 für 1 Tag) Für die Entfernung: Meter (z. B. 500 für 500 m)
params.decay	Keine	Punktwert bei der Entfernung scale, steuert die Steilheit der Kurve. Niedrigere Werte ergeben steilere Kurven, höhere Werte ergeben langsamere Kurven. Muss zwischen 0 und 1 liegen.	0.5 (Voreinstellung)

Auf Standard-Vektorsuche anwenden

Nachdem Sie Ihren Decay Ranker definiert haben, können Sie ihn bei Suchvorgängen anwenden, indem Sie ihn an den Parameter ranker übergeben:

# Use the decay function in standard vector search
results = milvus_client.search(
    collection_name,
    data=[your_query_vector], # Replace with your query vector
    anns_field="vector_field",
    limit=10,
    output_fields=["document", "timestamp"],  # Include the decay field in outputs to see values
    ranker=decay_ranker,                      # Apply the decay ranker here
    consistency_level="Strong"
)

import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.response.SearchResp;
import io.milvus.v2.service.vector.request.data.EmbeddedText;

SearchReq searchReq = SearchReq.builder()
        .collectionName(COLLECTION_NAME)
        .data(Collections.singletonList(new EmbeddedText("search query")))
        .annsField("vector_field")
        .limit(10)
        .outputFields(Arrays.asList("document", "timestamp"))
        .functionScore(FunctionScore.builder()
                .addFunction(ranker)
                .build())
        .build();
SearchResp searchResp = client.search(searchReq);

const result = await milvusClient.search({
  collection_name: "collection_name",
  data: [your_query_vector], // Replace with your query vector
  anns_field: "dense",
  limit: 10,
  output_fields: ["document", "timestamp"],
  rerank: ranker,
  consistency_level: "Strong",
});

// go

# restful