Decadimento gaussianoCompatible with Milvus 2.6.x

Il decadimento gaussiano, noto anche come decadimento normale, crea la regolazione più naturale dei risultati di ricerca. Come la vista umana che si offusca gradualmente con la distanza, il decadimento gaussiano crea una curva liscia e a campana che riduce delicatamente la rilevanza man mano che gli elementi si allontanano dal punto ideale. Questo approccio è ideale quando si desidera un decadimento bilanciato che non penalizzi duramente gli elementi appena al di fuori dell'intervallo preferito, ma che riduca comunque in modo significativo la rilevanza degli elementi lontani.

A differenza di altri classificatori di decadimento:

• Il decadimento esponenziale diminuisce bruscamente all'inizio, creando una penalizzazione iniziale più forte.

• Il decadimento lineare diminuisce a un tasso costante fino a raggiungere lo zero, creando un limite netto.

Il decadimento gaussiano offre un approccio più equilibrato, intuitivo e naturale per gli utenti.

Quando usare il decadimento gaussiano

Il decadimento gaussiano è particolarmente efficace per:

Caso d'uso	Esempio	Perché la gaussiana funziona bene
Ricerche basate sulla posizione	Ricerca di ristoranti, localizzazione di negozi	Imita la naturale percezione umana della rilevanza della distanza
Raccomandazioni sui contenuti	Suggerimenti di articoli basati sulla data di pubblicazione	Diminuzione graduale della rilevanza con l'invecchiamento dei contenuti
Annunci di prodotti	Articoli con prezzi vicini a un obiettivo	Diminuzione graduale della rilevanza quando i prezzi si discostano dal target
Corrispondenza delle competenze	Trovare professionisti con esperienza rilevante	Valutazione equilibrata della rilevanza dell'esperienza

Se la vostra applicazione richiede una sensazione naturale di rilevanza decrescente, senza penalizzazioni severe o limiti rigidi, il decadimento gaussiano è probabilmente la scelta migliore.

Principio della curva a campana

Il decadimento gaussiano crea una curva liscia, a forma di campana, che riduce gradualmente la rilevanza all'aumentare della distanza da un punto ideale. Questa distribuzione, che prende il nome dal matematico Carl Friedrich Gauss, compare spesso in natura e in statistica, il che spiega perché sia così intuitiva per la percezione umana.

Decadimento gaussiano

Il grafico qui sopra mostra come il decadimento gaussiano influenzerebbe le classifiche dei ristoranti in un'applicazione di ricerca mobile:

• origin (0 km): La vostra posizione attuale, dove la rilevanza è massima (1,0).

• offset (±300 m): La "zona di punteggio perfetto" intorno a voi: tutti i ristoranti nel raggio di 300 metri mantengono il punteggio di rilevanza massimo (1,0), assicurando che le opzioni molto vicine non vengano inutilmente penalizzate per le piccole differenze di distanza.

• scale (±2 km): La distanza alla quale la rilevanza scende al valore di decadimento: i ristoranti che distano esattamente 2 chilometri hanno il punteggio di rilevanza dimezzato (0,5).

• decay (0.5): Il punteggio alla distanza di scala: questo parametro controlla essenzialmente la velocità con cui i punteggi diminuiscono con la distanza.

Come si può vedere dalla curva, i ristoranti oltre i 2 km continuano a diminuire la loro rilevanza, ma non raggiungono mai lo zero. Anche i ristoranti a 4-5 chilometri di distanza mantengono un minimo di rilevanza, consentendo a ristoranti eccellenti ma distanti di apparire comunque nei risultati (anche se classificati più in basso).

Questo comportamento imita il modo in cui le persone pensano naturalmente alla rilevanza della distanza: i posti vicini sono preferiti, ma siamo disposti a viaggiare più lontano per avere opzioni eccezionali.

La formula

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

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

Dove:

$$\sigma^2 = -\frac{scale^2}{2 \cdot \ln(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) senza mai scendere sotto lo zero: $\max (0,\mathrm{distanza-offset})$\max $(0, distanza - offset)$ $offset)$

3. Elevare al quadrato la distanza corretta: $(distanza_regolata)^2$ 2

4. Dividere per $2σ22\sigma^2$ 2, calcolato in base ai parametri di scala e decadimento.

5. Prendere l'esponente negativo, che dà un valore compreso tra 0 e 1: $\exp (\mathrm{-valore})$\exp $(-valore)$

Il calcolo $σ2\sigma^{2}$ 2 converte i parametri di scala e di decadimento nella deviazione standard al quadrato della distribuzione gaussiana. Ciò conferisce alla funzione la caratteristica forma a campana.

Utilizzare il decadimento gaussiano

Il decadimento gaussiano 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, distance in metri dall'utente), creare un ranker di decadimento gaussiano:

from pymilvus import Function, FunctionType

# Create a Gaussian decay ranker for location-based restaurant search
ranker = Function(
    name="restaurant_distance_decay",     # Function identifier
    input_field_names=["distance"],       # Numeric field for distance in meters
    function_type=FunctionType.RERANK,    # Function type. Must be RERANK
    params={
        "reranker": "decay",              # Specify decay reranker
        "function": "gauss",              # Choose Gaussian decay
        "origin": 0,                      # Your current location (0 meters)
        "offset": 300,                    # 300m no-decay zone
        "decay": 0.5,                     # Half score at scale distance
        "scale": 2000                     # 2 km scale (2000 meters)
    }
)

import io.milvus.v2.service.vector.request.ranker.DecayRanker;

DecayRanker ranker = DecayRanker.builder()
        .name("restaurant_distance_decay")
        .inputFieldNames(Collections.singletonList("distance"))
        .function("gauss")
        .origin(0)
        .offset(300)
        .decay(0.5)
        .scale(2000)
        .build();

import { FunctionType } from "@zilliz/milvus2-sdk-node";

const ranker = {
  name: "restaurant_distance_decay",
  input_field_names: ["distance"],
  function_type: FunctionType.RERANK,
  params: {
    reranker: "decay",
    function: "gauss",
    origin: 0,
    offset: 300,
    decay: 0.5,
    scale: 2000,
  },
};

// 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 restaurant 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=["name", "cuisine", "distance"],  # 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("italian restaurants")))
        .annsField("vector_field")
        .limit(10)
        .outputFields(Arrays.asList("name", "cuisine", "distance"))
        .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: ["name", "cuisine", "distance"],
  rerank: ranker,
  consistency_level: "Strong",
});

// go

# restful