Lineares AbklingenCompatible with Milvus 2.6.x

Der lineare Verfall erzeugt einen geradlinigen Rückgang, der an einem absoluten Nullpunkt in Ihren Suchergebnissen endet. Ähnlich wie bei einem Countdown für ein bevorstehendes Ereignis, bei dem die Relevanz allmählich abnimmt, bis das Ereignis vorüber ist, führt der lineare Verfall zu einer vorhersehbaren, stetigen Verringerung der Relevanz, wenn sich die Elemente von Ihrem Idealpunkt entfernen, bis sie ganz verschwinden. Dieser Ansatz ist ideal, wenn Sie eine konsistente Abklingrate mit einem klaren Grenzwert wünschen, der sicherstellt, dass Artikel jenseits einer bestimmten Grenze vollständig aus den Ergebnissen ausgeschlossen werden.

Im Gegensatz zu anderen Zerfallsfunktionen:

• Der Gaußsche Zerfall folgt einer Glockenkurve, die sich allmählich dem Nullpunkt nähert, ihn aber nie erreicht.

• Exponentieller Zerfall behält einen langen Schwanz minimaler Relevanz bei, der sich unendlich verlängert

Der lineare Zerfall schafft einen eindeutigen Endpunkt, was ihn besonders effektiv für Anwendungen mit natürlichen Grenzen oder Fristen macht.

Wann sollte man lineares Abklingen verwenden?

Lineares Abklingen ist besonders effektiv für:

Anwendungsfall	Beispiel	Warum Linear gut funktioniert
Veranstaltungsverzeichnisse	Konzertkarten-Plattformen	Schafft eine klare Grenze für Veranstaltungen, die zu weit in der Zukunft liegen
Befristete Angebote	Blitzverkäufe, Werbeaktionen	Stellt sicher, dass abgelaufene oder bald ablaufende Angebote nicht angezeigt werden
Lieferradius	Lebensmittellieferung, Kurierdienste	Erzwingt harte geografische Grenzen
Altersbeschränkte Inhalte	Dating-Plattformen, Mediendienste	Legt feste Altersschwellen fest

Wählen Sie lineares Abklingen, wenn:

• Ihre Anwendung eine natürliche Grenze, Frist oder Schwelle hat

• Elemente, die einen bestimmten Punkt überschreiten, vollständig aus den Ergebnissen ausgeschlossen werden sollen

• Sie benötigen eine vorhersehbare, konsistente Rate der Relevanzabnahme

• Die Benutzer sollten eine klare Abgrenzung zwischen relevanten und irrelevanten Elementen sehen

Prinzip des stetigen Rückgangs

Die lineare Abnahme erzeugt einen geradlinigen Abfall, der mit einer konstanten Rate abnimmt, bis er genau Null erreicht. Dieses Muster kommt in vielen alltäglichen Szenarien vor, wie z. B. bei Countdown-Timern, bei der Erschöpfung von Lagerbeständen und bei der Annäherung an Fristen, bei denen die Relevanz einen eindeutigen Verfallszeitpunkt hat.

Lineares Abklingen

Das obige Diagramm zeigt, wie sich der lineare Verfall auf Veranstaltungsangebote auf einer Ticketing-Plattform auswirken würde:

• origin (aktuelles Datum): Der gegenwärtige Moment, in dem die Relevanz am größten ist (1,0).

• offset (1 Tag): Das "unmittelbare Veranstaltungsfenster" - alle Veranstaltungen, die innerhalb des nächsten Tages stattfinden, behalten die volle Relevanzbewertung (1,0), wodurch sichergestellt wird, dass sehr bald stattfindende Veranstaltungen nicht wegen geringer Zeitunterschiede benachteiligt werden.

• decay (0.5): Die Punktzahl in der Skalendistanz - dieser Parameter steuert die Geschwindigkeit der Abnahme der Relevanz.

• scale (10 Tage): Der Zeitraum, in dem die Relevanz auf den Abklingwert fällt - bei Ereignissen, die 10 Tage entfernt sind, wird die Relevanzbewertung halbiert (0,5).

Wie Sie der geradlinigen Kurve entnehmen können, haben Ereignisse, die mehr als 16 Tage entfernt sind, genau null Relevanz und werden in den Suchergebnissen überhaupt nicht angezeigt. Damit wird eine klare Grenze gezogen, die sicherstellt, dass die Nutzer nur relevante Veranstaltungen innerhalb eines bestimmten Zeitfensters sehen.

Dieses Verhalten spiegelt wider, wie die Veranstaltungsplanung in der Regel funktioniert: Unmittelbar bevorstehende Veranstaltungen sind am relevantesten, Veranstaltungen in den kommenden Wochen haben eine abnehmende Bedeutung, und Veranstaltungen, die zu weit in der Zukunft liegen (oder bereits vergangen sind), sollten überhaupt nicht angezeigt werden.

Formel

Die mathematische Formel für die Berechnung eines linearen Zerfallswertes lautet:

$$S(doc) = \max\left( \frac{s - \max(0, |fieldvalue_{doc} - origin| - offset)}{s}, 0 \right)$$

Wo:

$$s = \frac{scale}{(1.0 - decay)}$$

In einfacher Sprache ausgedrückt:

1. Berechne, wie weit der Feldwert vom Ursprung entfernt ist: $- Ursprung$ doc $-$ $Ursprung|$

2. Subtrahieren Sie den Offset (falls vorhanden), aber gehen Sie nie unter Null: $\max (0,\mathrm{distance-offset})$\max $(0, distance - offset)$ $offset)$

3. Bestimmen Sie den Parameter $ss$ s aus Ihren Skalen- und Abklingwerten.

4. Ziehen Sie die angepasste Entfernung von $ss$ s ab und dividieren Sie durch $ss$ s

5. Stellen Sie sicher, dass das Ergebnis nie unter Null geht: $\max (\mathrm{result},0)$\max $(result, 0)$ 0 $)$

Die Berechnung von $ss$ s wandelt Ihre Skalierungs- und Abklingparameter in den Punkt um, an dem die Punktzahl Null erreicht. Bei decay=0,5 und scale=7 zum Beispiel erreicht die Punktzahl genau Null bei distance=14 (doppelter Skalenwert).

Lineares Abklingen verwenden

Lineares Decay kann 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 eines Decay Rankers

Nachdem Ihre Sammlung mit einem numerischen Feld eingerichtet wurde (in diesem Beispiel event_date als Sekunden ab jetzt), erstellen Sie eine lineare Zerfallsrangliste:

from pymilvus import Function, FunctionType
import time

# Calculate current time
current_time = int(time.time())

# Create a linear decay ranker for event listings
# Note: All time parameters must use the same unit as your collection data
ranker = Function(
    name="event_relevance",               # Function identifier
    input_field_names=["event_date"],     # Numeric field to use
    function_type=FunctionType.RERANK,    # Function type. Must be RERANK
    params={
        "reranker": "decay",              # Specify decay reranker
        "function": "linear",             # Choose linear decay
        "origin": current_time,           # Current time (seconds, matching collection data)
        "offset": 12 * 60 * 60,           # 12 hour immediate events window (seconds)
        "decay": 0.5,                     # Half score at scale distance
        "scale": 7 * 24 * 60 * 60         # 7 days (in seconds, matching collection data)
    }
)

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

DecayRanker ranker = DecayRanker.builder()
        .name("event_relevance")
        .inputFieldNames(Collections.singletonList("event_date"))
        .function("linear")
        .origin(System.currentTimeMillis())
        .offset(12 * 60 * 60)
        .decay(0.5)
        .scale(7 * 24 * 60 * 60)
        .build();

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

const ranker = {
  name: "event_relevance",
  input_field_names: ["event_date"],
  type: FunctionType.RERANK,
  params: {
    reranker: "decay",
    function: "linear",
    origin: new Date(2025, 1, 15).getTime(),
    offset: 12 * 60 * 60,
    decay: 0.5,
    scale: 7 * 24 * 60 * 60,
  },
};

// go

# restful

Auf die 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:

# Apply decay ranker to vector search
result = milvus_client.search(
    collection_name,
    data=[your_query_vector],              # Replace with your query vector
    anns_field="dense",                   # Vector field to search
    limit=10,                             # Number of results
    output_fields=["title", "venue", "event_date"], # Fields to return
    ranker=ranker,                        # Apply the decay ranker
    consistency_level="Strong"
)

import io.milvus.v2.common.ConsistencyLevel;
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;

SearchReq searchReq = SearchReq.builder()
        .collectionName(COLLECTION_NAME)
        .data(Collections.singletonList(new FloatVec(embedding)))
        .annsField("dense")
        .limit(10)
        .outputFields(Arrays.asList("title", "venue", "event_date"))
        .functionScore(FunctionScore.builder()
                .addFunction(ranker)
                .build())
        .consistencyLevel(ConsistencyLevel.STRONG)
        .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: ["title", "venue", "event_date"],
  rerank: ranker,
  consistency_level: "Strong",
});

// go

# restful