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.
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 è:
Dove:
Spiegando il tutto in parole semplici:
Calcolare la distanza del valore del campo dall’origine: .
Sottrai l’offset (se presente) ma non scendere mai sotto lo zero: .
Moltiplica per , che viene calcolato in base ai parametri di scala e di decadimento.
Calcolare l’esponente, che fornisce un valore compreso tra 0 e 1: .
Il calcolo converte i parametri di scala e di decadimento nel parametro di velocità della funzione esponenziale. Un valore più negativo 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).
Applicazione alla ricerca vettoriale standard
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"
}'