Gaußscher ZerfallCompatible with Milvus 2.6.x

Gaußscher Zerfall, auch bekannt als normaler Zerfall, erzeugt die natürlichste Anpassung Ihrer Suchergebnisse. Ähnlich wie beim menschlichen Sehen, das mit zunehmender Entfernung allmählich verschwimmt, erzeugt der Gaußsche Zerfall eine sanfte, glockenförmige Kurve, die die Relevanz sanft verringert, wenn sich die Elemente von Ihrem Idealpunkt entfernen. Dieser Ansatz ist ideal, wenn Sie einen ausgewogenen Abklingvorgang wünschen, bei dem Artikel, die knapp außerhalb Ihres bevorzugten Bereichs liegen, nicht hart bestraft werden, aber dennoch die Relevanz weiter entfernter Artikel deutlich reduziert wird.

Im Gegensatz zu anderen Zerfallsrankern:

• Exponentieller Verfall fällt anfangs stark ab, was zu einer stärkeren anfänglichen Bestrafung führt.

• Der lineare Verfall nimmt mit einer konstanten Rate ab, bis er den Wert Null erreicht, wodurch eine klare Grenze gesetzt wird.

Gaußscher Zerfall bietet einen ausgewogenen, intuitiven Ansatz, der sich für die Nutzer natürlich anfühlt.

Wann wird Gaußscher Zerfall verwendet?

Gaußscher Zerfall ist besonders effektiv für:

Anwendungsfall	Beispiel	Warum Gaussian gut funktioniert
Standortbezogene Suche	Restaurant-Finder, Ladenlokalisierer	Nachahmung der natürlichen menschlichen Wahrnehmung von Entfernungsrelevanz
Empfehlungen zu Inhalten	Artikelvorschläge basierend auf dem Veröffentlichungsdatum	Allmähliche Abnahme der Relevanz mit zunehmendem Alter der Inhalte
Produktauflistungen	Artikel mit Preisen in der Nähe eines Ziels	Sanfter Rückgang der Relevanz bei Preisabweichungen vom Ziel
Abgleich von Fachwissen	Auffinden von Fachleuten mit relevanter Erfahrung	Ausgewogene Bewertung der Relevanz von Erfahrungen

Wenn Ihre Anwendung ein natürliches Gefühl von abnehmender Relevanz ohne harte Strafen oder strenge Grenzwerte erfordert, ist der Gaußsche Zerfall wahrscheinlich die beste Wahl.

Prinzip der Glockenkurve

Der Gaußsche Zerfall erzeugt eine sanfte, glockenförmige Kurve, die die Relevanz mit zunehmender Entfernung von einem Idealpunkt allmählich verringert. Diese nach dem Mathematiker Carl Friedrich Gauß benannte Verteilung kommt in der Natur und in der Statistik häufig vor, was erklärt, warum sie sich für die menschliche Wahrnehmung so intuitiv anfühlt.

Gaußscher Zerfall

Das obige Diagramm zeigt, wie sich der Gauß'sche Zerfall auf das Ranking von Restaurants in einer mobilen Such-App auswirken würde:

• origin (0 km): Ihr aktueller Standort, wo die Relevanz am höchsten ist (1,0).

• offset (±300 m): Die "perfekte Bewertungszone" um Sie herum - alle Restaurants in einem Umkreis von 300 Metern behalten ihre volle Relevanzbewertung (1,0), um sicherzustellen, dass nahe gelegene Optionen nicht unnötig für winzige Entfernungsunterschiede bestraft werden.

• scale (±2 km): Die Entfernung, bei der die Relevanz auf den Abklingwert sinkt - bei Restaurants, die genau 2 Kilometer entfernt sind, wird die Relevanzbewertung halbiert (0,5).

• decay (0.5): Die Punktzahl bei der Skalendistanz - dieser Parameter steuert im Wesentlichen, wie schnell die Punktzahlen mit der Entfernung abnehmen.

Wie Sie der Kurve entnehmen können, nimmt die Relevanz von Restaurants in mehr als 2 km Entfernung weiter ab, erreicht aber nie ganz den Wert Null. Selbst Restaurants in einer Entfernung von 4 bis 5 Kilometern behalten eine gewisse minimale Relevanz, so dass ausgezeichnete, aber weit entfernte Restaurants immer noch in Ihren Ergebnissen erscheinen (wenn auch in einer niedrigeren Rangfolge).

Dieses Verhalten ahmt nach, wie Menschen natürlicherweise über die Relevanz von Entfernungen denken - nahe gelegene Orte werden bevorzugt, aber wir sind bereit, für außergewöhnliche Optionen weiter zu reisen.

Formel

Die mathematische Formel für die Berechnung eines Gauß'schen Zerfallswertes lautet:

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

Wobei:

$$\sigma^2 = -\frac{scale^2}{2 \cdot \ln(decay)}$$

In einfacher Sprache ausgedrückt:

1. Berechnen Sie, 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. Quadrieren Sie diesen angepassten Abstand: $(angepasster\_Abstand)^2$ 2

4. Dividieren Sie durch $2σ22\sigma^2$ 2, das aus Ihren Skalen- und Abklingparametern berechnet wird.

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

Die Berechnung von $σ2\sigma^{2}$ 2 wandelt Ihre Skalen- und Zerfallsparameter in die quadrierte Standardabweichung der Gaußschen Verteilung um. Dadurch erhält die Funktion ihre charakteristische Glockenform.

Verwendung des Gaußschen Abklingens

Gaußscher Zerfall 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 Sie einen Decay Ranker

Nachdem Ihre Sammlung mit einem numerischen Feld eingerichtet wurde (in diesem Beispiel distance in Metern vom Benutzer), erstellen Sie einen Gauß'schen Abkling-Ranger:

from pymilvus import Function, FunctionType

# Create a Gaussian decay ranker for location-based restaurant search
ranker = Function(
    name="restaurant_distance_decay",     # Function identifier
    input_field_names=["distance"],       # Numeric field for distance in meters
    function_type=FunctionType.RERANK,    # Function type. Must be RERANK
    params={
        "reranker": "decay",              # Specify decay reranker
        "function": "gauss",              # Choose Gaussian decay
        "origin": 0,                      # Your current location (0 meters)
        "offset": 300,                    # 300m no-decay zone
        "decay": 0.5,                     # Half score at scale distance
        "scale": 2000                     # 2 km scale (2000 meters)
    }
)

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

DecayRanker ranker = DecayRanker.builder()
        .name("restaurant_distance_decay")
        .inputFieldNames(Collections.singletonList("distance"))
        .function("gauss")
        .origin(0)
        .offset(300)
        .decay(0.5)
        .scale(2000)
        .build();

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

const ranker = {
  name: "restaurant_distance_decay",
  input_field_names: ["distance"],
  function_type: FunctionType.RERANK,
  params: {
    reranker: "decay",
    function: "gauss",
    origin: 0,
    offset: 300,
    decay: 0.5,
    scale: 2000,
  },
};

// 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 restaurant 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=["name", "cuisine", "distance"],  # 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("italian restaurants")))
        .annsField("vector_field")
        .limit(10)
        .outputFields(Arrays.asList("name", "cuisine", "distance"))
        .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: ["name", "cuisine", "distance"],
  rerank: ranker,
  consistency_level: "Strong",
});

// go

# restful