Decadimento lineareCompatible with Milvus 2.6.x

Il decadimento lineare crea una linea retta di declino che termina con un punto zero assoluto nei risultati di ricerca. Come un conto alla rovescia per un evento imminente, in cui la rilevanza diminuisce gradualmente fino a quando l'evento non è passato, il decadimento lineare applica una riduzione prevedibile e costante della rilevanza man mano che gli elementi si allontanano dal punto ideale, fino a scomparire completamente. Questo approccio è ideale quando si desidera un tasso di decadimento coerente con un limite chiaro, che garantisca che gli elementi oltre un certo limite siano completamente esclusi dai risultati.

A differenza di altre funzioni di decadimento:

• Il decadimento gaussiano segue una curva a campana che si avvicina gradualmente ma non raggiunge mai lo zero.

• Il decadimento esponenziale mantiene una lunga coda di rilevanza minima che si estende all'infinito.

Il decadimento lineare crea in modo univoco un punto finale definitivo, rendendolo particolarmente efficace per le applicazioni con limiti o scadenze naturali.

Quando utilizzare il decadimento lineare

Il decadimento lineare è particolarmente efficace per:

Caso d'uso	Esempio	Perché il decadimento lineare funziona bene
Annunci di eventi	Piattaforme di biglietti per concerti	Crea un limite chiaro per gli eventi troppo lontani nel futuro
Offerte a tempo limitato	Vendite flash, promozioni	Assicura che le offerte scadute o di prossima scadenza non vengano visualizzate.
Raggio di consegna	Consegna di cibo, servizi di corriere	Impone confini geografici rigidi
Contenuti con limiti di età	Piattaforme di incontri, servizi multimediali	Stabilisce soglie di età rigide

Scegliete il decadimento lineare quando:

• L'applicazione ha un limite, una scadenza o una soglia naturale.

• Gli elementi che superano un certo punto dovrebbero essere completamente esclusi dai risultati

• Avete bisogno di un tasso prevedibile e coerente di declino della rilevanza

• Gli utenti devono vedere una chiara demarcazione tra elementi rilevanti e irrilevanti.

Principio del declino costante

Il decadimento lineare crea un calo lineare che diminuisce a un tasso costante fino a raggiungere esattamente lo zero. Questo schema appare in molti scenari quotidiani, come i timer per il conto alla rovescia, l'esaurimento delle scorte e l'avvicinarsi di una scadenza in cui la rilevanza ha un chiaro punto di scadenza.

Decadimento lineare

Il grafico qui sopra mostra come il decadimento lineare influenzerebbe gli annunci di eventi su una piattaforma di biglietteria:

• origin (data attuale): Il momento attuale, dove la rilevanza è massima (1.0).

• offset (1 giorno): La "finestra degli eventi immediati": tutti gli eventi che si verificano entro il giorno successivo mantengono il massimo punteggio di rilevanza (1,0), assicurando che gli eventi molto imminenti non vengano penalizzati per lievi differenze temporali.

• decay (0.5): Il punteggio alla distanza della scala: questo parametro controlla il tasso di declino della rilevanza.

• scale (10 giorni): Il periodo di tempo in cui la rilevanza scende al valore di decadimento: gli eventi a 10 giorni di distanza hanno il punteggio di rilevanza dimezzato (0,5).

Come si può vedere dalla curva rettilinea, gli eventi che si verificano a circa 16 giorni di distanza hanno una rilevanza esattamente pari a zero e non appaiono affatto nei risultati di ricerca. In questo modo si crea un chiaro confine che assicura che gli utenti vedano solo gli eventi imminenti rilevanti all'interno di una finestra temporale definita.

Questo comportamento rispecchia il funzionamento tipico della pianificazione degli eventi: gli eventi imminenti sono i più rilevanti, quelli delle prossime settimane hanno un'importanza decrescente e quelli troppo lontani nel tempo (o già passati) non dovrebbero comparire affatto.

La formula

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

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

Dove:

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

In parole povere:

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

2. Sottrarre l'offset (se presente) ma non scendere mai sotto lo zero: $\max (0,\mathrm{distanza-offset})$\max $(0, distanza - offset)$ $offset)$

3. Determinare il parametro $ss$ s dai valori di scala e decadimento.

4. Sottrarre la distanza regolata da $ss$ s e dividere per $ss$ s.

5. Assicurarsi che il risultato non scenda mai sotto lo zero: $\max (\mathrm{risultato},0)$\max $(risultato, 0)$ 0 $)$

Il calcolo di $ss$ s trasforma i parametri di scala e decadimento nel punto in cui il punteggio raggiunge lo zero. Ad esempio, con decadimento=0,5 e scala=7, il punteggio raggiungerà esattamente lo zero a distanza=14 (il doppio del valore della scala).

Utilizzare il decadimento lineare

Il decadimento lineare 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, event_date come secondi da ora), creare un ranker di decadimento lineare:

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

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