Décroissance linéaireCompatible with Milvus 2.6.x

La décroissance linéaire crée un déclin en ligne droite qui se termine à un point zéro absolu dans vos résultats de recherche. À l'instar d'un compte à rebours d'un événement à venir dont la pertinence s'estompe progressivement jusqu'à ce que l'événement soit passé, la décroissance linéaire applique une réduction prévisible et régulière de la pertinence au fur et à mesure que les éléments s'éloignent de votre point idéal, jusqu'à ce qu'ils disparaissent complètement. Cette approche est idéale lorsque vous souhaitez un taux de décroissance cohérent avec une limite claire, garantissant que les éléments dépassant une certaine limite sont complètement exclus des résultats.

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

• La désintégration gaussienne suit une courbe en cloche qui se rapproche progressivement de zéro sans jamais l'atteindre

• La décroissance exponentielle maintient une longue queue de pertinence minimale qui s'étend indéfiniment.

La décroissance linéaire crée un point final unique, ce qui la rend particulièrement efficace pour les applications comportant des limites naturelles ou des échéances.

Quand utiliser la décroissance linéaire ?

La décroissance linéaire est particulièrement efficace pour :

Cas d'utilisation	Exemple de cas d'utilisation	Pourquoi la décroissance linéaire fonctionne bien
Listes d'événements	Plateformes de vente de billets de concert	Crée une limite claire pour les événements trop éloignés dans le temps
Offres à durée limitée	Ventes flash, promotions	Permet de s'assurer que les offres expirées ou sur le point d'expirer n'apparaissent pas.
Rayon de livraison	Livraison de nourriture, services de messagerie	Permet d'imposer des limites géographiques strictes
Contenus limités par l'âge	Plateformes de rencontres, services de médias	Établit des seuils d'âge fermes

Choisissez la décroissance linéaire lorsque :

• Votre application a une limite naturelle, une date limite ou un seuil.

• Les éléments dépassant un certain seuil doivent être complètement exclus des résultats.

• Vous avez besoin d'un taux prévisible et cohérent de déclin de la pertinence.

• Les utilisateurs doivent voir une démarcation claire entre les éléments pertinents et ceux qui ne le sont pas.

Principe de décroissance régulière

La décroissance linéaire crée une baisse en ligne droite qui diminue à un taux constant jusqu'à atteindre exactement zéro. Ce modèle apparaît dans de nombreux scénarios quotidiens tels que les comptes à rebours, l'épuisement des stocks et l'approche des échéances, où la pertinence a un point d'expiration clair.

Décroissance linéaire

Le graphique ci-dessus montre comment la décroissance linéaire affecte les listes d'événements sur une plateforme de billetterie :

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

• offset (1 jour) : La "fenêtre des événements immédiats" - tous les événements se déroulant le jour suivant conservent leur score de pertinence maximal (1,0), ce qui garantit que les événements très imminents ne sont pas pénalisés par de légers décalages temporels.

• decay (0.5) : Le score à la distance de l'échelle - ce paramètre contrôle le taux de déclin de la pertinence.

• scale (10 jours) : Le délai à partir duquel la pertinence tombe à la valeur de décroissance - les événements situés à 10 jours de distance voient leur score de pertinence divisé par deux (0,5).

Comme le montre la courbe linéaire, les événements qui se produisent dans plus de 16 jours ont une pertinence nulle et n'apparaissent pas du tout dans les résultats de recherche. Cela crée une limite claire qui garantit que les utilisateurs ne voient que les événements pertinents à venir dans une fenêtre temporelle définie.

Ce comportement reflète le fonctionnement habituel de la planification d'événements : les événements imminents sont les plus pertinents, les événements des semaines à venir ont une importance décroissante et les événements trop éloignés dans le temps (ou déjà passés) ne devraient pas apparaître du tout.

Formule

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

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

Où :

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

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. Déterminez le paramètre $ss$ s à partir de vos valeurs d'échelle et de décroissance.

4. Soustrayez la distance ajustée de $ss$ s et divisez par $ss$ s

5. Veillez à ce que le résultat ne soit jamais inférieur à zéro : $\max (\mathrm{result},0)$\max $(result, 0)$ 0 $)$

Le calcul de $ss$ s transforme vos paramètres d'échelle et de décroissance en un point où le score atteint zéro. Par exemple, avec une décroissance de 0,5 et une échelle de 7, le score atteindra exactement zéro à une distance de 14 (deux fois la valeur de l'échelle).

Utiliser la décroissance linéaire

La décroissance linéaire 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 que votre collection est configurée avec un champ numérique (dans cet exemple, event_date comme secondes à partir de maintenant), créez un classificateur de décroissance linéaire :

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

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