Decadimento esponenzialeCompatible with Milvus 2.6.x

Il decadimento esponenziale crea un calo iniziale ripido seguito da una coda lunga nei risultati di ricerca. Proprio come nel ciclo delle notizie dell’ultima ora, in cui la rilevanza diminuisce rapidamente all’inizio ma alcune notizie mantengono la loro importanza nel tempo, il decadimento esponenziale applica una forte penalizzazione agli elementi appena al di fuori dell’intervallo ideale, pur mantenendo individuabili quelli più distanti. Questo approccio è ideale quando si desidera dare la massima priorità alla vicinanza o alla recenza, senza però eliminare completamente le opzioni più distanti.

A differenza di altre funzioni di decadimento:

  • il decadimento gaussiano crea un calo più graduale, a forma di campana

  • Il decadimento lineare diminuisce a un tasso costante fino a raggiungere esattamente lo zero

Il decadimento esponenziale “concentra” in modo unico la penalizzazione, applicando la maggior parte della riduzione di rilevanza nelle prime fasi, pur mantenendo una lunga coda di rilevanza minima ma non nulla.

Quando utilizzare il decadimento esponenziale

Il decadimento esponenziale è particolarmente efficace per:

Caso d’uso

Esempio

Perché il decadimento esponenziale funziona bene

Feed di notizie

Portali di ultime notizie

Riduce rapidamente la rilevanza delle notizie più vecchie, pur continuando a mostrare le notizie importanti dei giorni precedenti

Timeline dei social media

Feed di attività, aggiornamenti di stato

Mette in risalto i contenuti recenti, ma permette ai contenuti più vecchi diventati virali di riemergere

Sistemi di notifica

Priorità degli avvisi

Crea un senso di urgenza per gli avvisi recenti, mantenendo al contempo la visibilità di quelli importanti

Vendite lampo

Offerte a tempo limitato

Riduce rapidamente la visibilità man mano che la scadenza si avvicina

Scegli il decadimento esponenziale quando:

  • Gli utenti si aspettano che gli articoli molto recenti o vicini nel tempo dominino nettamente i risultati

  • Gli articoli più vecchi o più lontani nel tempo dovrebbero comunque essere reperibili se sono particolarmente rilevanti

  • Il calo di rilevanza dovrebbe essere concentrato all’inizio (più ripido all’inizio, più graduale in seguito)

Principio del calo brusco

Il decadimento esponenziale crea una curva che scende rapidamente all’inizio, per poi appiattirsi gradualmente in una coda lunga che si avvicina a zero senza mai raggiungerlo. Questo modello matematico ricorre frequentemente in fenomeni naturali quali il decadimento radioattivo, il declino demografico e l’evoluzione della rilevanza delle informazioni nel tempo.

Tutti i parametri temporali (origin, offset, scale) devono utilizzare la stessa unità dei dati della collezione. Se la tua collezione memorizza i timestamp in un'unità diversa (millisecondi, microsecondi), modifica tutti i parametri di conseguenza.

Exp Decay Decadimento esponenziale

Il grafico sopra mostra come il decadimento esponenziale influenzerebbe il posizionamento degli articoli di cronaca in una piattaforma di notizie digitali:

  • origin (ora attuale): il momento presente, in cui la rilevanza è al massimo (1,0).

  • offset (3 ore): la «finestra delle ultime notizie» — tutti gli articoli pubblicati nelle ultime 3 ore mantengono il punteggio di rilevanza completo (1,0), garantendo che le notizie molto recenti non vengano penalizzate inutilmente a causa di piccole differenze temporali.

  • decay (0,5): il punteggio alla distanza della 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 pubblicati esattamente 24 ore fa vedono il proprio punteggio di rilevanza dimezzato (0,5).

Come si può notare dalla curva, gli articoli pubblicati da più di 24 ore continuano a perdere rilevanza, ma non scendono mai fino a zero. Anche le notizie di diversi giorni fa mantengono una rilevanza minima, consentendo alle notizie importanti ma più datate di apparire comunque nel tuo feed (seppur con un posizionamento inferiore).

Questo comportamento rispecchia il funzionamento tipico della rilevanza delle notizie: le notizie molto recenti dominano nettamente, ma quelle più datate possono comunque emergere se sono eccezionalmente rilevanti per gli interessi dell’utente.

Formula

La formula matematica per calcolare un punteggio di decadimento esponenziale è:

S(doc)=exp⁡(λ⋅max⁡(0,∣fieldvaluedoc−origin∣−offset))S(doc) = \exp\left( \lambda \cdot \max\left(0, \left|fieldvalue_{doc} - origin\right| - offset \right) \right)

Dove:

λ=ln⁡(decay)scale\lambda = \frac{\ln(decay)}{scale}

Spiegando il tutto in parole semplici:

  1. Calcolare la distanza del valore del campo dall’origine: ∣fieldvaluedoc−origin∣|fieldvalue_{doc} - origin| .

  2. Sottrai l’offset (se presente) ma non scendere mai sotto lo zero: max⁡(0,distance−offset)\max(0, distance - offset) .

  3. Moltiplica per λ\lambda, che viene calcolato in base ai parametri di scala e di decadimento.

  4. Calcolare l’esponente, che fornisce un valore compreso tra 0 e 1: exp⁡(λ⋅value)\exp(\lambda \cdot value) .

Il calcolo di λ\lambda converte i parametri di scala e di decadimento nel parametro di velocità della funzione esponenziale. Un valore più negativo di λ\lambda crea un calo iniziale più ripido.

Utilizzo del decadimento esponenziale

Il decadimento esponenziale può essere applicato sia alle operazioni di ricerca vettoriale standard che a quelle ibride in Milvus. Di seguito sono riportati i frammenti di codice chiave per l’implementazione di questa funzionalità.

Prima di utilizzare le funzioni di decadimento, è necessario creare una collezione con campi numerici appropriati (come timestamp, distanze, ecc.) che verranno utilizzati per i calcoli di decadimento. Per esempi completi e funzionanti, inclusi la configurazione della collezione, la definizione dello schema e l’inserimento dei dati, consultare il Tutorial sul Decay Ranker.

Creare un ranker a decadimento

Dopo aver configurato la collezione con un campo numerico (in questo esempio, publish_time), creare un "decay ranker" esponenziale:

Coerenza dell’unità di tempo: quando si utilizza il decadimento basato sul tempo, assicurarsi che i parametri origin, scale e offset utilizzino la stessa unità di tempo dei dati della collezione. Se la collezione memorizza i timestamp in secondi, utilizzare i secondi per tutti i parametri. Se utilizza i millisecondi, utilizzare i millisecondi per tutti i parametri.

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
rerank = 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 java.util.Collections;
import io.milvus.v2.service.vector.request.ranker.DecayRanker;

DecayRanker rerank = DecayRanker.builder()
        .name("news_recency")
        .inputFieldNames(Collections.singletonList("publish_time"))
        .function("exp")
        .origin(System.currentTimeMillis() / 1000)  // 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)
        .build();
import (
    "time"

    "github.com/milvus-io/milvus/client/v3/entity"
)

// Create an exponential decay ranker for news recency
// Note: All time parameters must use the same unit as your collection data
rerank := entity.NewFunction().
    WithName("news_recency").
    WithInputFields("publish_time").
    WithType(entity.FunctionTypeRerank).
    WithParam("reranker", "decay").
    WithParam("function", "exp").
    WithParam("origin", time.Now().Unix()).
    WithParam("offset", 3*60*60).
    WithParam("decay", 0.5).
    WithParam("scale", 24*60*60)
use milvus::v2::prelude::*;

// Create an exponential decay ranker for news recency
// Note: All time parameters must use the same unit as your collection data
let origin = std::time::SystemTime::now()
    .duration_since(std::time::UNIX_EPOCH)
    .unwrap()
    .as_secs();
let rerank = {
    let rerank = DecayRerank::new()
        .name("news_recency")
        .decay_function("exp")
        .origin(origin)
        .offset(3 * 60 * 60)
        .decay(0.5)
        .scale(24 * 60 * 60);
    let value = rerank.get_function().clone().input_fields(["publish_time"]);
    rerank.function(value)
};
#include <ctime>
#include <memory>
#include "milvus/MilvusClientV2.h"

auto rerank = std::make_shared<milvus::DecayRerank>("news_recency");
rerank->AddInputFieldName("publish_time");
rerank->SetFunction("exp");
rerank->SetOrigin(std::time(nullptr));  // Current time (seconds, matching collection data)
rerank->SetScale(24 * 60 * 60);
rerank->SetOffset(3 * 60 * 60);
rerank->SetDecay(0.5);
import { FunctionType } from "@zilliz/milvus2-sdk-node";

const rerank = {
  name: "news_recency",
  input_field_names: ["publish_time"],
  type: FunctionType.RERANK,
  params: {
    reranker: "decay",
    function: "exp",
    origin: Math.floor(Date.now() / 1000), // Current time (seconds)
    offset: 3 * 60 * 60,                   // 3 hour breaking news window (seconds)
    decay: 0.5,                            // Half score at scale distance
    scale: 24 * 60 * 60,                   // 24 hours (seconds)
  },
};
using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Collection;
using Milvus.Client.V2.Requests.Dml;
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Requests.Index;
using Milvus.Client.V2.Types;

// Create an exponential decay ranker for news recency
// Note: All time parameters must use the same unit as your collection data
var rerank = new DecayRerank("news_recency")  // Function identifier
    .WithInputField("publish_time")           // Numeric field to use
    .WithFunction("exp")                      // Choose exponential decay
    .WithOrigin(DateTimeOffset.UtcNow.ToUnixTimeSeconds())  // Current time (seconds, matching collection data)
    .WithOffset(3 * 60 * 60)                  // 3 hour breaking news window (seconds)
    .WithDecay(0.5f)                          // Half score at scale distance
    .WithScale(24 * 60 * 60);                 // 24 hours (in seconds, matching collection data)
# Note: The RESTful API does not expose a standalone "create a decay ranker"
# endpoint. The decay function is passed inline through the functionScore
# field of the search request (see the next section).

Dopo aver definito il proprio "decay ranker", è 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=rerank,                        # Apply the decay ranker
    consistency_level="Strong"
)
import java.util.Arrays;
import java.util.Collections;
import io.milvus.v2.common.ConsistencyLevel;
import io.milvus.v2.service.vector.request.FunctionScore;
import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.request.data.FloatVec;
import io.milvus.v2.service.vector.response.SearchResp;

String COLLECTION_NAME = "collection_name";

SearchReq searchReq = SearchReq.builder()
        .collectionName(COLLECTION_NAME)
        .data(Collections.singletonList(new FloatVec(Arrays.asList(0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f))))  // Replace with your query vector
        .annsField("dense")                    // Vector field to search
        .limit(10)                             // Number of results
        .outputFields(Arrays.asList("title", "publish_time"))  // Fields to return
        .functionScore(FunctionScore.builder()
                .addFunction(rerank)           // Apply the decay ranker
                .build())
        .consistencyLevel(ConsistencyLevel.STRONG)
        .build();
SearchResp searchResp = client.search(searchReq);
import (
    "context"

    "github.com/milvus-io/milvus/client/v3/entity"
    "github.com/milvus-io/milvus/client/v3/milvusclient"
)

// Apply decay ranker to vector search
resultSets, err := cli.Search(ctx, milvusclient.NewSearchOption(
    "collection_name", 10, []entity.Vector{
        entity.FloatVector{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8}, // Replace with your query vector
    }).
    WithANNSField("dense").                    // Vector field to search
    WithOutputFields("title", "publish_time"). // Fields to return
    WithFunctionReranker(rerank).              // Apply the decay ranker
    WithConsistencyLevel(entity.ClStrong))
if err != nil {
    panic(err)
}
use milvus::v2::prelude::*;

// Apply decay ranker to vector search
let response = client.search(
    SearchRequest::builder()
        .collection_name("collection_name")
        .vector_field("dense")                                // Vector field to search
        .vectors(SearchVectors::Float(vec![vec![0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]])) // Replace with your query vector
        .limit(10)                                             // Number of results
        .output_fields(["title", "publish_time"])             // Fields to return
        .rerank(FunctionScore::new().add_function(rerank))    // Apply the decay ranker
        .consistency_level(ConsistencyLevel::Strong)
        .build()?,
).await?;
#include <iostream>
#include <memory>
#include "milvus/MilvusClientV2.h"

auto function_score = std::make_shared<milvus::FunctionScore>();
function_score->AddFunction(rerank);

auto request = milvus::SearchRequest()
                   .WithCollectionName(collection_name)
                   .WithAnnsField("dense")
                   .WithRerank(function_score)
                   .WithLimit(10)
                   .AddOutputField("title")
                   .AddOutputField("publish_time")
                   .AddFloatVector(your_query_vector)
                   .WithConsistencyLevel(milvus::ConsistencyLevel::STRONG);

milvus::SearchResponse response;
auto status = client->Search(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}
import { MilvusClient } from "@zilliz/milvus2-sdk-node";

const milvusClient = new MilvusClient("http://localhost:19530");

const result = await milvusClient.search({
  collection_name: "collection_name",
  data: [[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]], // Replace with your query vector
  anns_field: "dense",
  limit: 10,
  output_fields: ["title", "publish_time"],
  rerank: rerank, // Apply the decay ranker
  consistency_level: "Strong",
});
using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Collection;
using Milvus.Client.V2.Requests.Dml;
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Requests.Index;
using Milvus.Client.V2.Types;

// Apply decay ranker to vector search
var result = await client.SearchAsync(new SearchReq
{
    CollectionName = collectionName,
    VectorFieldName = "dense",                    // Vector field to search
    Vectors = new[] { new ReadOnlyMemory<float>(yourQueryVector) },  // Replace with your query vector
    Limit = 10,                                   // Number of results
    Parameters = new SearchParameters
    {
        OutputFields = { "title", "publish_time" }, // Fields to return
        FunctionScoreReranker = rerank,             // Apply the decay ranker
        ConsistencyLevel = ConsistencyLevel.Strong
    }
});
curl -s http://localhost:19530/v2/vectordb/entities/search \
    -H "Authorization: Bearer root:Milvus" \
    -H "Content-Type: application/json" \
    -d '{
        "collectionName": "collection_name",
        "data": [[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]],
        "annsField": "dense",
        "limit": 10,
        "outputFields": ["title", "publish_time"],
        "functionScore": {
            "functions": [{
                "name": "news_recency",
                "type": "Rerank",
                "inputFieldNames": ["publish_time"],
                "outputFieldNames": [],
                "params": {
                    "reranker": "decay",
                    "function": "exp",
                    "origin": 1790872778,
                    "offset": 10800,
                    "decay": 0.5,
                    "scale": 86400
                }
            }],
            "params": {}
        },
        "consistencyLevel": "Strong"
    }'

Tradotto daDeepL

Prova Milvus gestito gratuitamente

Zilliz Cloud è senza problemi, basato su Milvus e 10 volte più veloce.

Inizia
Feedback

Questa pagina è stata utile?