Classificatore BoostCompatible with Milvus v2.6.2+

Invece di affidarsi esclusivamente alla somiglianza semantica calcolata in base alle distanze vettoriali, i Boost Ranker consentono di influenzare i risultati di ricerca in modo significativo. È ideale per regolare rapidamente i risultati della ricerca utilizzando il filtraggio dei metadati.

Quando una richiesta di ricerca include una funzione Boost Ranker, Milvus utilizza la condizione di filtraggio opzionale all'interno della funzione per trovare le corrispondenze tra i candidati risultati della ricerca e aumenta i punteggi di tali corrispondenze applicando il peso specificato, contribuendo a promuovere o declassare la classifica delle entità abbinate nel risultato finale.

Quando usare Boost Ranker

A differenza di altri classificatori che si basano su modelli cross-encoder o algoritmi di fusione, Boost Ranker inietta direttamente regole opzionali basate sui metadati nel processo di classificazione, il che lo rende più adatto ai seguenti scenari.

Caso d'uso	Esempi	Perché Boost Ranker funziona bene
Priorità dei contenuti in base al business	Evidenziare i prodotti premium nei risultati di ricerca dell'e-commerce Aumentare la visibilità dei contenuti con elevate metriche di coinvolgimento degli utenti (come visualizzazioni, like e condivisioni) Elevare i contenuti recenti nelle applicazioni di ricerca sensibili al fattore tempo Privilegiare i contenuti provenienti da fonti verificate o affidabili Incremento dei risultati che corrispondono a frasi esatte o a parole chiave ad alta rilevanza	Senza dover ricostruire gli indici o modificare i modelli di incorporazione vettoriale - operazioni che possono richiedere molto tempo - è possibile promuovere o declassare istantaneamente elementi specifici nei risultati di ricerca applicando filtri di metadati opzionali in tempo reale. Questo meccanismo consente di ottenere classifiche di ricerca flessibili e dinamiche che si adattano facilmente all'evoluzione dei requisiti aziendali.
Downranking strategico dei contenuti	Riduzione del rilievo degli articoli con un inventario basso senza rimuoverli completamente Riduzione della posizione di contenuti con termini potenzialmente discutibili senza censura. Ridimensionamento della documentazione più vecchia, pur mantenendola accessibile nelle ricerche tecniche. Ridurre sottilmente la visibilità dei prodotti della concorrenza nelle ricerche di mercato. Riduzione della rilevanza dei contenuti con indicazioni di qualità inferiore (come problemi di formattazione, lunghezza ridotta, ecc.)

È inoltre possibile combinare più Boost Ranker per implementare una strategia di ranking basata sul peso più dinamica e robusta.

Meccanismo di Boost Ranker

Il diagramma seguente illustra il flusso di lavoro principale dei Boost Ranker.

Meccanismo di Boost Ranker

Quando si inseriscono i dati, Milvus li distribuisce in segmenti. Durante una ricerca, ogni segmento restituisce un insieme di candidati e Milvus classifica questi candidati da tutti i segmenti per produrre i risultati finali. Quando una richiesta di ricerca include un Boost Ranker, Milvus lo applica ai risultati dei candidati di ogni segmento per evitare una potenziale perdita di precisione e migliorare il richiamo.

Prima di finalizzare i risultati, Milvus elabora questi candidati con il Boost Ranker come segue:

1. Applica l'espressione di filtraggio opzionale specificata nel Boost Ranker per identificare le entità che corrispondono all'espressione.

2. Applica il peso specificato nel Boost Ranker per aumentare i punteggi delle entità identificate.

Esempi di Boost Ranker

L'esempio seguente illustra l'uso di un Boost Ranker in una ricerca a vettore singolo che richiede la restituzione delle cinque entità più rilevanti e l'aggiunta di pesi ai punteggi delle entità con il tipo di documento astratto.

1. Raccogliere i risultati della ricerca in segmenti.

   La tabella seguente ipotizza che Milvus distribuisca le entità in due segmenti(0001 e 0002) e che ogni segmento restituisca cinque candidati.

   ID	Tipo di documento	Punteggio	Classifica	segmento
   117	astratto	0.344	1	0001
   89	astratto	0.456	2	0001
   257	corpo	0.578	3	0001
   358	titolo	0.788	4	0001
   168	corpo	0.899	5	0001
   46	corpo	0.189	1	0002
   48	corpo	0265	2	0002
   561	astratto	0.366	3	0002
   344	astratto	0.444	4	0002
   276	astratto	0.845	5	0002

2. Applicare l'espressione di filtraggio specificata nel Boost Ranker (doctype='abstract').

   Come indicato dal campo DocType nella tabella seguente, Milvus contrassegnerà tutte le entità con doctype impostato su abstract per un'ulteriore elaborazione.

   ID	Tipo di documento	Punteggio	Classifica	segmento
   117	astratto	0.344	1	0001
   89	astratto	0.456	2	0001
   257	corpo	0.578	3	0001
   358	titolo	0.788	4	0001
   168	corpo	0.899	5	0001
   46	corpo	0.189	1	0002
   48	corpo	0265	2	0002
   561	astratto	0.366	3	0002
   344	astratto	0.444	4	0002
   276	astratto	0.845	5	0002

3. Applicare il peso specificato nel Boost Ranker (weight=0.5).

   Tutte le entità identificate nel passaggio precedente saranno moltiplicate per il peso specificato nel Boost Ranker, con conseguente modifica dei loro ranghi.

   ID	Tipo di documento	Punteggio	Punteggio ponderato (= punteggio x peso)	Classifica	segmento
   117	astratto	0.344	0.172	1	0001
   89	astratto	0.456	0.228	2	0001
   257	corpo	0.578	0.578	3	0001
   358	titolo	0.788	0.788	4	0001
   168	corpo	0.899	0.899	5	0001
   561	astratto	0.366	0.183	1	0002
   46	corpo	0.189	0.189	2	0002
   344	astratto	0.444	0.222	3	0002
   48	corpo	0.265	0.265	4	0002
   276	astratto	0.845	0.423	5	0002

   Il peso deve essere un numero a virgola mobile scelto dall'utente. Nei casi come l'esempio precedente, in cui un punteggio minore indica una maggiore rilevanza, utilizzare un peso inferiore a 1. Altrimenti, utilizzare un peso superiore a 1.

4. Aggregare i candidati di tutti i segmenti in base ai punteggi ponderati per finalizzare i risultati.

   ID	Tipo di documento	Punteggio	Punteggio ponderato	Classifica	segmento
   117	astratto	0.344	0.172	1	0001
   561	astratto	0.366	0.183	2	0002
   46	corpo	0.189	0.189	3	0002
   344	astratto	0.444	0.222	4	0002
   89	astratto	0.456	0.228	5	0001

Uso di Boost Ranker

In questa sezione vengono illustrati alcuni esempi di utilizzo di Boost Ranker per influenzare i risultati di una ricerca monovettoriale.

Creare un Boost Ranker

Prima di passare un Boost Ranker come reranker di una richiesta di ricerca, è necessario definire correttamente il Boost Ranker come funzione di reranking, come segue:

from pymilvus import Function, FunctionType

ranker = Function(
    name="boost",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "boost",
        "filter": "doctype == 'abstract'",
        "random_score": { 
            "seed": 126,
            "field": "id"
        },
        "weight": 0.5
    }
)

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

BoostRanker ranker = BoostRanker.builder()
        .name("boost")
        .filter("doctype == \"abstract\"")
        .weight(5.0f)
        .randomScoreField("id")
        .randomScoreSeed(126)
        .build();

// go

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

const ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    filter: "doctype == 'abstract'",
    random_score: {
      seed: 126,
      field: "id",
    },
    weight: 0.5,
  },
};

# restful

Parametro	Richiesto?	Descrizione	Valore/Esempio
name	Sì	Identificatore univoco per questa funzione	"boost"
input_field_names	Sì	Elenco di campi vettoriali a cui applicare la funzione (deve essere vuoto per Boost Ranker)	[]
function_type	Sì	Il tipo di Funzione da invocare; utilizzare RERANK per specificare una strategia di reranking	FunctionType.RERANK
params.reranker	Sì	Specifica il tipo di reranker. Deve essere impostato su boost per utilizzare Boost Ranker.	"boost"
params.weight	Sì	Specifica il peso che sarà moltiplicato per i punteggi delle entità corrispondenti nei risultati grezzi della ricerca. Il valore deve essere un numero a virgola mobile. Per enfatizzare l'importanza delle entità corrispondenti, impostare un valore che aumenti i punteggi. Per declassare le entità corrispondenti, assegnare a questo parametro un valore che ne abbassi il punteggio.	1
params.filter	No	Specifica l'espressione di filtro che verrà usata per abbinare le entità tra i risultati della ricerca. Può essere una qualsiasi espressione di filtro di base valida menzionata in Spiegazioni sui filtri. Nota: utilizzare solo operatori di base, come ==, >, o <. L'uso di operatori avanzati, come text_match o phrase_match, peggiora le prestazioni della ricerca.	"doctype == 'abstract'"
params.random_score	No	Specifica la funzione casuale che genera un valore tra 0 e 1 in modo casuale. Ha i seguenti due argomenti opzionali: seed (numero) Specifica un valore iniziale usato per avviare un generatore di numeri pseudorandom (PRNG). field (stringa) Specifica il nome di un campo il cui valore sarà usato come fattore casuale nella generazione del numero casuale. È sufficiente un campo con valori unici. Si consiglia di impostare sia seed che field per garantire la coerenza tra le generazioni, utilizzando gli stessi valori di seme e campo.	{"seed": 126, "field": "id"}

Ricerca con un singolo Boost Ranker

Una volta che la funzione Boost Ranker è pronta, si può fare riferimento ad essa in una richiesta di ricerca. L'esempio seguente presuppone che sia già stata creata una collezione con i seguenti campi: id, vector e doctype.

from pymilvus import MilvusClient

# Connect to the Milvus server
client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

# Assume you have a collection set up

# Conduct a similarity search using the created ranker
client.search(
    collection_name="my_collection",
    data=[[-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911]],
    anns_field="vector",
    params={},
    output_field=["doctype"],
    ranker=ranker
)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
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;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build());
        
SearchResp searchReq = client.search(SearchReq.builder()
        .collectionName("my_collection")
        .data(Collections.singletonList(new FloatVec(new float[]{-0.619954f, 0.447943f, -0.174938f, -0.424803f, -0.864845f})))
        .annsField("vector")
        .outputFields(Collections.singletonList("doctype"))
        .functionScore(FunctionScore.builder()
                .addFunction(ranker)
                .build())
        .build());
SearchResp searchResp = client.search(searchReq);

// go

import { MilvusClient } from '@zilliz/milvus2-sdk-node';

// Connect to the Milvus server
const client = new MilvusClient({
  address: 'localhost:19530',
  token: 'root:Milvus'
});

// Assume you have a collection set up

// Conduct a similarity search
const searchResults = await client.search({
  collection_name: 'my_collection',
  data: [-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911],
  anns_field: 'vector',
  output_fields: ['doctype'],
  rerank: ranker,
});

console.log('Search results:', searchResults);

# restful

Ricerca con più classificatori Boost

È possibile combinare più Boost Ranker in una singola ricerca per influenzare i risultati. A tale scopo, è necessario creare diversi Boost Ranker, fare riferimento ad essi in un'istanza di FunctionScore e utilizzare l'istanza di FunctionScore come ranker nella richiesta di ricerca.

L'esempio seguente mostra come modificare i punteggi di tutte le entità identificate applicando un peso compreso tra 0,8 e 1,2.

from pymilvus import MilvusClient, Function, FunctionType, FunctionScore

# Create a Boost Ranker with a fixed weight
fix_weight_ranker = Function(
    name="boost",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "boost",
        "weight": 0.8
    }
)

# Create a Boost Ranker with a randomly generated weight between 0 and 0.4
random_weight_ranker = Function(
    name="boost",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "boost",
        "random_score": {
            "seed": 126,
        },
        "weight": 0.4
    }
)

# Create a Function Score
ranker = FunctionScore(
    functions=[
        fix_weight_ranker, 
        random_weight_ranker
    ],
    params={
        "boost_mode": "Multiply",
        "function_mode": "Sum"
    }
)

# Conduct a similarity search using the created Function Score
client.search(
    collection_name="my_collection",
    data=[[-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911]],
    anns_field="vector",
    params={},
    output_field=["doctype"],
    ranker=ranker
)

import io.milvus.common.clientenum.FunctionType;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

CreateCollectionReq.Function fixWeightRanker = CreateCollectionReq.Function.builder()
                 .functionType(FunctionType.RERANK)
                 .name("boost")
                 .param("reranker", "boost")
                 .param("weight", "0.8")
                 .build();
                 
CreateCollectionReq.Function randomWeightRanker = CreateCollectionReq.Function.builder()
                 .functionType(FunctionType.RERANK)
                 .name("boost")
                 .param("reranker", "boost")
                 .param("weight", "0.4")
                 .param("random_score", "{\"seed\": 126}")
                 .build();

Map<String, String> params = new HashMap<>();
params.put("boost_mode","Multiply");
params.put("function_mode","Sum");     
FunctionScore ranker = FunctionScore.builder()
                 .addFunction(fixWeightRanker)
                 .addFunction(randomWeightRanker)
                 .params(params)
                 .build()

SearchResp searchReq = client.search(SearchReq.builder()
                 .collectionName("my_collection")
                 .data(Collections.singletonList(new FloatVec(new float[]{-0.619954f, 0.447943f, -0.174938f, -0.424803f, -0.864845f})))
                 .annsField("vector")
                 .outputFields(Collections.singletonList("doctype"))
                 .addFunction(ranker)
                 .build());
SearchResp searchResp = client.search(searchReq);

// go

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

const fix_weight_ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    weight: 0.8,
  },
};

const random_weight_ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    random_score: {
      seed: 126,
    },
    weight: 0.4,
  },
};

const ranker = {
  functions: [fix_weight_ranker, random_weight_ranker],
  params: {
    boost_mode: "Multiply",
    function_mode: "Sum",
  },
};

await client.search({
  collection_name: "my_collection",
  data: [[-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911]],
  anns_field: "vector",
  params: {},
  output_field: ["doctype"],
  ranker: ranker
});

# restful

Nello specifico, esistono due Boost Ranker: uno applica un peso fisso a tutte le entità trovate, mentre l'altro assegna un peso casuale. Poi, si fa riferimento a questi due classificatori in una FunctionScore, che definisce anche come i pesi influenzano i punteggi delle entità trovate.

La tabella seguente elenca i parametri necessari per creare un'istanza di FunctionScore.

Parametro	Richiesto?	Descrizione	Valore/Esempio
functions	Sì	Specifica i nomi dei classificatori di destinazione in un elenco.	["fix_weight_ranker", "random_weight_ranker"]
params.boost_mode	No	Specifica come i pesi specificati influenzano i punteggi delle entità corrispondenti. I valori possibili sono: Multiply Indica che il valore ponderato è uguale al punteggio originale di un'entità corrispondente moltiplicato per il peso specificato. Questo è il valore predefinito. Sum Indica che il valore ponderato è uguale alla somma del punteggio originale di un'entità corrispondente e del peso specificato.	"Sum"
params.function_mode	No	Specifica come vengono elaborati i valori ponderati dei vari Boost Ranker. I valori possibili sono: Multiply Indica che il punteggio finale di un'entità corrispondente è uguale al prodotto dei valori ponderati di tutti i classificatori Boost. Questo è il valore predefinito. Sum Indica che il punteggio finale di un'entità corrispondente è uguale alla somma dei valori ponderati di tutti i Boost Ranker.	"Sum"