Décroissance exponentielleCompatible with Milvus 2.6.x

La décroissance exponentielle crée une chute initiale brutale suivie d'une longue traîne dans vos résultats de recherche. À l'instar d'un cycle de nouvelles de dernière heure où la pertinence diminue rapidement au début mais où certaines histoires conservent leur importance au fil du temps, la décroissance exponentielle applique une pénalité brutale aux éléments situés juste au-delà de votre fourchette idéale, tout en permettant de découvrir des éléments éloignés. Cette approche est idéale lorsque vous souhaitez donner la priorité à la proximité ou à la récence sans pour autant éliminer complètement les options plus éloignées.

Contrairement à d'autres fonctions de désintégration :

• La désintégration gaussienne crée un déclin plus progressif, en forme de cloche

• La décroissance linéaire diminue à un rythme constant jusqu'à atteindre exactement zéro.

La décroissance exponentielle "concentre" de manière unique la pénalité, en appliquant la plus grande partie de la réduction de pertinence au début, tout en maintenant une longue queue de pertinence minimale mais non nulle.

Quand utiliser la décroissance exponentielle ?

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

Cas d'utilisation	Exemple de cas d'utilisation	Pourquoi la décroissance exponentielle fonctionne bien
Flux d'informations	Portails d'actualités	Réduit rapidement la pertinence des anciennes nouvelles tout en affichant les histoires importantes des derniers jours.
Chronologie des médias sociaux	Flux d'activité, mises à jour de statut	Mettent l'accent sur les contenus récents, mais permettent aux contenus viraux plus anciens de remonter à la surface.
Systèmes de notification	Priorité aux alertes	Crée un sentiment d'urgence pour les alertes récentes tout en maintenant la visibilité des alertes importantes
Ventes flash	Offres à durée limitée	Diminue rapidement la visibilité à l'approche de l'échéance

Choisissez la décroissance exponentielle lorsque :

• les utilisateurs s'attendent à ce que les éléments très récents ou proches dominent fortement les résultats

• Les éléments plus anciens ou plus éloignés doivent pouvoir être découverts s'ils sont exceptionnellement pertinents.

• La chute de la pertinence doit être frontale (plus forte au début, plus progressive par la suite).

Principe de la chute brutale

La décroissance exponentielle crée une courbe qui chute rapidement au début, puis s'aplatit progressivement en une longue queue qui s'approche de zéro sans jamais l'atteindre. Ce modèle mathématique apparaît fréquemment dans des phénomènes naturels tels que la décroissance radioactive, le déclin de la population et la pertinence de l'information au fil du temps.

Décroissance exponentielle

Le graphique ci-dessus montre comment la décroissance exponentielle affecterait le classement des articles de presse sur une plateforme d'information numérique :

• origin (heure actuelle) : Le moment présent, où la pertinence est maximale (1.0).

• offset (3 heures) : La "fenêtre des dernières nouvelles" - tous les articles publiés au cours des trois dernières heures conservent un score de pertinence maximal (1,0), ce qui garantit que les nouvelles très récentes ne sont pas inutilement pénalisées pour des différences temporelles mineures.

• decay (0.5) : Le score à la distance de l'échelle - ce paramètre contrôle l'ampleur de la diminution des scores avec le temps.

• scale (24 heures) : Période à partir de laquelle la pertinence tombe à la valeur de décroissance - les articles d'actualité datant d'exactement 24 heures voient leur score de pertinence divisé par deux (0,5).

Comme le montre la courbe, la pertinence des articles datant de plus de 24 heures continue de diminuer sans jamais atteindre zéro. Même les articles datant de plusieurs jours conservent une pertinence minimale, ce qui permet à des informations importantes mais plus anciennes d'apparaître dans votre fil d'actualité (même si elles sont moins bien classées).

Ce comportement reproduit le fonctionnement habituel de la pertinence des actualités : les articles très récents dominent largement, mais des articles plus anciens importants peuvent encore percer s'ils sont exceptionnellement pertinents par rapport aux centres d'intérêt de l'utilisateur.

Formule

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

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

Où :

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

En clair, il s'agit de

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. Multipliez par $λ\lambda$, qui est calculé à partir de vos paramètres d'échelle et de décroissance.

4. Prenez l'exposant, qui vous donne une valeur entre 0 et 1 : $\exp (\mathrm{\lambda \cdot valeur})$\exp $(\lambda \cdot valeur)$ $valeur)$.

Le calcul de $λ\lambda$ convertit vos paramètres d'échelle et de décroissance en paramètre de taux pour la fonction exponentielle. Un $λ\lambda$ plus négatif crée une chute initiale plus abrupte.

Utiliser la décroissance exponentielle

La décroissance exponentielle 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 classificateur de décroissance

Une fois votre collection configurée avec un champ numérique (dans cet exemple, publish_time), créez un classificateur de décroissance exponentielle :

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

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 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