Exponentialer ZerfallCompatible with Milvus 2.6.x

Der exponentielle Verfall erzeugt einen steilen anfänglichen Abfall, gefolgt von einem langen Schwanz in Ihren Suchergebnissen. Ähnlich wie bei einem Nachrichtenzyklus, bei dem die Relevanz zunächst rapide abnimmt, einige Meldungen aber im Laufe der Zeit ihre Bedeutung behalten, werden durch den exponentiellen Verfall Artikel, die knapp jenseits Ihres idealen Bereichs liegen, stark benachteiligt, während weiter entfernte Artikel weiterhin auffindbar bleiben. Dieser Ansatz ist ideal, wenn Sie der Nähe oder Aktualität einen hohen Stellenwert einräumen, aber weiter entfernte Optionen nicht vollständig ausschließen möchten.

Im Gegensatz zu anderen Abklingfunktionen:

• Gaußscher Zerfall erzeugt einen allmählichen, glockenförmigen Rückgang

• Lineares Abklingen nimmt mit einer konstanten Rate ab, bis es genau Null erreicht

Exponentielles Abklingen sorgt dafür, dass der größte Teil der Relevanzreduzierung früh einsetzt, während ein langer Schwanz minimaler, aber von Null verschiedener Relevanz erhalten bleibt.

Wann wird exponentieller Zerfall verwendet?

Exponentieller Zerfall ist besonders effektiv für:

Anwendungsfall	Beispiel	Warum Exponential gut funktioniert
Nachrichten-Feeds	Portale mit aktuellen Nachrichten	Reduziert schnell die Relevanz älterer Nachrichten und zeigt dennoch wichtige Meldungen von vor einigen Tagen an
Timelines in sozialen Medien	Aktivitäts-Feeds, Status-Updates	Hebt frische Inhalte hervor, lässt aber virale ältere Inhalte auftauchen
Benachrichtigungssysteme	Priorisierung von Warnungen	Erhöht die Dringlichkeit aktueller Meldungen, während die Sichtbarkeit wichtiger Meldungen erhalten bleibt
Blitzverkäufe	Zeitlich begrenzte Angebote	Schnelles Abnehmen der Sichtbarkeit, wenn die Frist näher rückt

Wählen Sie exponentiellen Verfall, wenn:

• die Nutzer erwarten, dass sehr aktuelle oder nahe gelegene Artikel die Ergebnisse stark dominieren

• Ältere oder weiter entfernte Artikel sollten noch auffindbar sein, wenn sie außergewöhnlich relevant sind.

• Der Relevanzabfall sollte nach vorne gerichtet sein (zu Beginn steiler, später allmählicher).

Prinzip des steilen Abfalls

Der exponentielle Zerfall erzeugt eine Kurve, die zunächst schnell abfällt und dann allmählich zu einem langen Schwanz abflacht, der sich dem Wert Null nähert, ihn aber nie erreicht. Dieses mathematische Muster tritt häufig bei natürlichen Phänomenen wie dem radioaktiven Zerfall, dem Bevölkerungsrückgang und der Bedeutung von Informationen im Laufe der Zeit auf.

Exp-Abklingung

Das obige Diagramm zeigt, wie sich der exponentielle Verfall auf das Ranking von Nachrichtenartikeln auf einer digitalen Nachrichtenplattform auswirken würde:

• origin (aktueller Zeitpunkt): Der gegenwärtige Moment, in dem die Relevanz am höchsten ist (1,0).

• offset (3 Stunden): Das "Eilmeldung-Fenster" - alle innerhalb der letzten drei Stunden veröffentlichten Artikel behalten ihre volle Relevanz (1,0), wodurch sichergestellt wird, dass sehr aktuelle Nachrichten nicht unnötigerweise wegen geringer Zeitunterschiede benachteiligt werden.

• decay (0.5): Die Punktzahl in der Skalendistanz - dieser Parameter steuert, wie stark die Punktzahl mit der Zeit abnimmt.

• scale (24 Stunden): Der Zeitraum, in dem die Relevanz auf den Abklingwert fällt - bei Nachrichten, die genau 24 Stunden alt sind, wird die Relevanzbewertung halbiert (0,5).

Wie Sie der Kurve entnehmen können, sinkt die Relevanz von Nachrichten, die älter als 24 Stunden sind, weiter, erreicht aber nie ganz den Wert Null. Selbst Artikel, die mehrere Tage alt sind, behalten eine minimale Relevanz, so dass wichtige, aber ältere Nachrichten immer noch in Ihrem Feed erscheinen (wenn auch in einem niedrigeren Ranking).

Dieses Verhalten ahmt nach, wie die Relevanz von Nachrichten in der Regel funktioniert - sehr aktuelle Nachrichten dominieren stark, aber wichtige ältere Nachrichten können immer noch durchbrechen, wenn sie für die Interessen des Nutzers außergewöhnlich relevant sind.

Formel

Die mathematische Formel für die Berechnung eines exponentiellen Verfallswertes lautet:

$$S(doc) = \exp\left( \lambda \cdot \max\left(0, \left|fieldvalue_{doc} - origin\right| - offset \right) \right)$$

Wobei:

$$\lambda = \frac{\ln(decay)}{scale}$$

In einfacher Sprache ausgedrückt:

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

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

3. Multiplizieren Sie mit $λ\lambda$, das aus Ihren Skalen- und Abklingparametern berechnet wird.

4. Nehmen Sie den Exponenten, der Ihnen einen Wert zwischen 0 und 1 liefert: $\exp (\mathrm{\lambda \cdot Wert})$\exp $(\lambda \cdot Wert)$ $Wert)$.

Die Berechnung von $λ\lambda$ wandelt Ihre Skalen- und Zerfallsparameter in den Ratenparameter für die Exponentialfunktion um. Ein negativerer $λ\lambda$ erzeugt einen steileren Anfangsabfall.

Exponentielles Abklingen verwenden

Exponentielles Abklingen 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 (in diesem Beispiel publish_time) eingerichtet wurde, erstellen Sie einen exponentiellen Zerfalls-Ranger:

from pymilvus import Function, FunctionType
import datetime

# Create an exponential decay ranker for news recency
# Note: All time parameters must use the same unit as your collection data
ranker = Function(
    name="news_recency",                  # Function identifier
    input_field_names=["publish_time"],   # Numeric field to use
    function_type=FunctionType.RERANK,    # Function type. Must be RERANK
    params={
        "reranker": "decay",              # Specify decay reranker
        "function": "exp",                # Choose exponential decay
        "origin": int(datetime.datetime.now().timestamp()),  # Current time (seconds, matching collection data)
        "offset": 3 * 60 * 60,            # 3 hour breaking news window (seconds)
        "decay": 0.5,                     # Half score at scale distance
        "scale": 24 * 60 * 60             # 24 hours (in seconds, matching collection data)
    }
)

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

DecayRanker ranker = DecayRanker.builder()
        .name("news_recency")
        .inputFieldNames(Collections.singletonList("publish_time"))
        .function("exp")
        .origin(System.currentTimeMillis())
        .offset(3 * 60 * 60)
        .decay(0.5)
        .scale(24 * 60 * 60)
        .build();

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

const ranker = {
  name: "news_recency",
  input_field_names: ["publish_time"],
  type: FunctionType.RERANK,
  params: {
    reranker: "decay",
    function: "exp",
    origin: new Date(2025, 1, 15).getTime(),
    offset: 3 * 60 * 60,
    decay: 0.5,
    scale: 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", "publish_time"], # 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.EmbeddedText;

SearchReq searchReq = SearchReq.builder()
        .collectionName(COLLECTION_NAME)
        .data(Collections.singletonList(new EmbeddedText("market analysis")))
        .annsField("vector_field")
        .limit(10)
        .outputFields(Arrays.asList("title", "publish_time"))
        .functionScore(FunctionScore.builder()
                .addFunction(ranker)
                .build())
        .consistencyLevel(ConsistencyLevel.STRONG)
        .build();
SearchResp searchResp = client.search(searchReq);

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

const milvusClient = new MilvusClient("http://localhost:19530");

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", "publish_time"],
  rerank: ranker,
  consistency_level: "Strong",
});

// go

# restful