Décroissance gaussienneCompatible with Milvus 2.6.x

La décroissance gaussienne, également connue sous le nom de décroissance normale, crée l'ajustement le plus naturel de vos résultats de recherche. À l'instar de la vision humaine qui s'estompe progressivement avec la distance, la décroissance gaussienne crée une courbe lisse en forme de cloche qui réduit doucement la pertinence au fur et à mesure que les éléments s'éloignent de votre point idéal. Cette approche est idéale lorsque vous souhaitez une décroissance équilibrée qui ne pénalise pas durement les éléments situés juste en dehors de votre plage préférée, mais qui réduit tout de même de manière significative la pertinence des éléments éloignés.

Contrairement à d'autres outils de classement de la décroissance :

• La décroissance exponentielle diminue fortement au début, ce qui crée une pénalité initiale plus forte.

• La décroissance linéaire diminue à un rythme constant jusqu'à atteindre zéro, ce qui crée une limite claire.

La décroissance gaussienne offre une approche plus équilibrée et intuitive qui semble naturelle aux utilisateurs.

Quand utiliser la décroissance gaussienne ?

La décroissance gaussienne est particulièrement efficace dans les cas suivants :

Cas d'utilisation	Exemple de cas d'utilisation	Pourquoi la décroissance gaussienne fonctionne bien
Recherches basées sur la localisation	Recherche de restaurants, de magasins	Imite la perception humaine naturelle de la pertinence de la distance
Recommandations de contenu	Suggestions d'articles basées sur la date de publication	Diminution progressive de la pertinence au fur et à mesure que le contenu vieillit
Listes de produits	Articles dont le prix est proche d'une cible	Diminution progressive de la pertinence lorsque les prix s'écartent de la cible
Correspondance d'expertise	Recherche de professionnels possédant une expérience pertinente	Évaluation équilibrée de la pertinence de l'expérience

Si votre application nécessite un sentiment naturel de déclin de la pertinence sans pénalités sévères ou seuils stricts, la décroissance gaussienne est probablement votre meilleur choix.

Principe de la courbe en cloche

La décroissance gaussienne crée une courbe lisse, en forme de cloche, qui réduit progressivement la pertinence à mesure que l'on s'éloigne d'un point idéal. Nommée d'après le mathématicien Carl Friedrich Gauss, cette distribution apparaît fréquemment dans la nature et les statistiques, ce qui explique pourquoi elle est si intuitive pour la perception humaine.

Décroissance gaussienne

Le graphique ci-dessus montre comment la décroissance gaussienne affecterait le classement des restaurants dans une application de recherche mobile :

• origin (0 km) : Votre emplacement actuel, où la pertinence est maximale (1,0).

• offset (±300 m) : La "zone de score parfait" autour de vous - tous les restaurants situés dans un rayon de 300 mètres conservent des scores de pertinence complets (1,0), ce qui garantit que les options très proches ne sont pas inutilement pénalisées par de minuscules différences de distance.

• scale (±2 km) : La distance à laquelle la pertinence chute à la valeur de décroissance - les restaurants situés à exactement 2 kilomètres voient leur score de pertinence divisé par deux (0,5).

• decay (0.5) : Le score à la distance d'échelle - ce paramètre contrôle essentiellement la vitesse à laquelle les scores diminuent avec la distance.

Comme vous pouvez le voir sur la courbe, la pertinence des restaurants situés à plus de 2 km continue de diminuer sans jamais atteindre zéro. Même les restaurants situés à 4 ou 5 kilomètres conservent une pertinence minimale, ce qui permet à d'excellents restaurants éloignés d'apparaître dans les résultats (bien que moins bien classés).

Ce comportement imite la façon dont les gens pensent naturellement à la pertinence de la distance - les endroits proches sont préférés, mais nous sommes prêts à voyager plus loin pour des options exceptionnelles.

Formule

La formule mathématique permettant de calculer un score de décroissance gaussienne est la suivante :

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

Où :

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

En clair, il s'agit de calculer la distance à laquelle se trouve la valeur du champ :

1. Calculez la distance qui sépare la valeur du champ de l'origine : $- origin|$ doc $-$ $origin|$

2. Soustraire le décalage (le cas échéant) sans jamais descendre en dessous de zéro : $\max (0,\mathrm{distance-décalage})$\max $(0, distance - décalage)$ $décalage)$

3. Élever au carré cette distance ajustée : $(distance_ajustée)^2$ 2

4. Diviser par $2σ22\sigma^2$ 2, qui est calculé à partir de vos paramètres d'échelle et de décroissance.

5. Prendre l'exposant négatif, qui donne une valeur comprise entre 0 et 1 : $\exp (\mathrm{-valeur})$\exp $(-valeur)$

Le calcul de $σ2\sigma^{2}$ 2 convertit vos paramètres d'échelle et de décroissance en écart-type au carré pour la distribution gaussienne. C'est ce qui donne à la fonction sa forme caractéristique de cloche.

Utiliser la décroissance gaussienne

La décroissance gaussienne peut être appliquée aux opérations de recherche vectorielle standard et de recherche hybride dans Milvus. Vous trouverez ci-dessous les principaux extraits de code permettant de mettre en œuvre cette fonctionnalité.

Créer un classeur de décroissance

Une fois votre collection configurée avec un champ numérique (dans cet exemple, distance en mètres de l'utilisateur), créez un classificateur de décroissance gaussienne :

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

Appliquer à la recherche vectorielle standard

Après avoir défini votre classificateur de décroissance, vous pouvez l'appliquer lors des opérations de recherche en le passant au paramètre ranker:

# 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