Decadimento esponenzialeCompatible with Milvus 2.6.x

Il decadimento esponenziale crea un forte calo iniziale seguito da una lunga coda nei risultati di ricerca. Come in un ciclo di breaking news, in cui la rilevanza diminuisce rapidamente all'inizio, ma alcune storie mantengono la loro importanza nel tempo, il decadimento esponenziale applica una forte penalizzazione agli articoli che si trovano appena al di là dell'intervallo ideale, pur mantenendo la possibilità di scoprire articoli lontani. Questo approccio è ideale quando si vuole privilegiare fortemente la prossimità o la ricorrenza, ma non si vogliono eliminare completamente le opzioni più lontane.

A differenza di altre funzioni di decadimento:

• Il decadimento gaussiano crea un declino più graduale e a campana.

• Il decadimento lineare diminuisce a una velocità costante fino a raggiungere esattamente lo zero.

Il decadimento esponenziale "anticipa" in modo univoco la penalizzazione, applicando la maggior parte della riduzione della rilevanza all'inizio, pur mantenendo una lunga coda di rilevanza minima ma non nulla.

Quando usare il decadimento esponenziale

Il decadimento esponenziale è particolarmente efficace per:

Caso d'uso	Esempio	Perché il decadimento esponenziale funziona bene
Feed di notizie	Portali di notizie dell'ultima ora	Riduce rapidamente la rilevanza delle notizie più vecchie, mostrando comunque le storie importanti di qualche giorno fa.
Timeline dei social media	Feed di attività, aggiornamenti di stato	Enfatizza i contenuti freschi, ma permette di far emergere quelli vecchi e virali
Sistemi di notifica	Priorità degli avvisi	Crea urgenza per gli avvisi più recenti, mantenendo la visibilità per quelli più importanti.
Vendite flash	Offerte a tempo limitato	Diminuisce rapidamente la visibilità all'avvicinarsi della scadenza

Scegliere il decadimento esponenziale quando:

• gli utenti si aspettano che gli articoli molto recenti o vicini dominino fortemente i risultati

• Gli articoli più vecchi o più distanti dovrebbero essere ancora scopribili se sono eccezionalmente rilevanti

• Il calo di rilevanza dovrebbe essere frontale (più ripido all'inizio, più graduale in seguito).

Principio del calo netto

Il decadimento esponenziale crea una curva che all'inizio scende rapidamente, poi si appiattisce gradualmente in una lunga coda che si avvicina ma non raggiunge mai lo zero. Questo modello matematico compare spesso in fenomeni naturali come il decadimento radioattivo, il declino della popolazione e la rilevanza delle informazioni nel tempo.

Decadimento Exp

Il grafico qui sopra mostra come il decadimento esponenziale influenzerebbe le classifiche degli articoli di notizie in una piattaforma di notizie digitali:

• origin (ora attuale): Il momento attuale, in cui la rilevanza è massima (1.0).

• offset (3 ore): La "finestra delle ultime notizie": tutte le storie pubblicate nelle ultime 3 ore mantengono il massimo punteggio di rilevanza (1,0), assicurando che le notizie molto recenti non vengano inutilmente penalizzate per piccole differenze temporali.

• decay (0.5): Il punteggio alla distanza di scala: questo parametro controlla quanto drasticamente i punteggi diminuiscono con il tempo.

• scale (24 ore): Il periodo di tempo in cui la rilevanza scende al valore di decadimento: gli articoli di 24 ore esatte hanno un punteggio di rilevanza dimezzato (0,5).

Come si può vedere dalla curva, gli articoli di notizie più vecchi di 24 ore continuano a diminuire la loro rilevanza, ma non raggiungono mai lo zero. Anche le storie di diversi giorni fa mantengono una rilevanza minima, consentendo alle notizie importanti ma più vecchie di apparire ancora nel feed (anche se classificate più in basso).

Questo comportamento imita il funzionamento tipico della rilevanza delle notizie: le storie molto recenti dominano fortemente, ma le storie più vecchie e significative possono ancora emergere se sono eccezionalmente rilevanti per gli interessi dell'utente.

La formula

La formula matematica per calcolare il punteggio di decadimento esponenziale è la seguente:

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

Dove:

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

In parole povere:

1. Calcolo della distanza del valore del campo dall'origine: $\mathrm{\mid fieldvaluedoc-origin\mid |fieldvalue\_\{doc\}}$ $- origin|$ doc $-$ $origin|.$

2. Sottraete l'eventuale offset, ma non scendete mai sotto lo zero: $\max (0,\mathrm{distanza-offset})$\max $(0, distanza - offset)$ $offset)$.

3. Moltiplicare per $λ\lambda$, calcolata in base ai parametri di scala e decadimento.

4. Prendete l'esponente, che dà un valore compreso tra 0 e 1: $\exp (\mathrm{\lambda \cdot value})$\exp $(\lambda \cdot value)$ $value)$.

Il calcolo di $λ\lambda$ converte i parametri di scala e di decadimento nel parametro di velocità della funzione esponenziale. Una $λ\lambda$ più negativa $\lambda$ crea una caduta iniziale più ripida.

Utilizzare il decadimento esponenziale

Il decadimento esponenziale può essere applicato sia alla ricerca vettoriale standard che alle operazioni di ricerca ibrida in Milvus. Di seguito sono riportati i principali frammenti di codice per implementare questa funzione.

Creare un ranker di decadimento

Dopo aver impostato la raccolta con un campo numerico (in questo esempio, publish_time), creare un ranker di decadimento esponenziale:

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

Applicare alla ricerca vettoriale standard

Dopo aver definito il ranker di decadimento, è possibile applicarlo durante le operazioni di ricerca passandolo al parametro 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