Ricerca di similarità di Milvus in Python

Eseguire la ricerca di similarità vettoriale

Argomento che illustra come utilizzare Milvus per cercare entità.

In Milvus, la ricerca di similarità vettoriale calcola la distanza tra il vettore di query e i vettori nella collezione (utilizzando una misura di similarità specificata) e restituisce i risultati più simili. È possibile eseguire ricerche miste specificando un'espressione booleana per filtrare campi scalari o chiavi primarie.

Nell'esempio seguente viene illustrato come eseguire la ricerca di similarità vettoriale su un dataset contenente 2000 righe di dati, tra cui ID del libro (chiave primaria), conteggio delle parole (campo scalare) e sinossi del libro (campo vettoriale), per simulare la ricerca di libri specifici basandosi sulle loro descrizioni vettoriali. Milvus restituirà i risultati più simili in base al vettore di query e ai parametri di ricerca da te definiti.

Caricamento della Collezione

Tutte le operazioni di ricerca e query all'interno di Milvus vengono eseguite in memoria. Prima di eseguire la ricerca di similarità vettoriale, carica la collezione in memoria.

from pymilvus import Collection
collection = Collection("book")      # Ottieni la collezione esistente.
collection.load()

Preparazione dei Parametri di Ricerca

Prepara i parametri corrispondenti per il tuo scenario di ricerca. Nell'esempio seguente vengono definiti i parametri che la ricerca utilizzerà per calcolare la distanza utilizzando la distanza euclidea e recuperare i vettori dai dieci cluster più vicini costruiti dall'indice IVF_FLAT.

search_params = {
    "metric_type": "L2",
    "offset": 5,
    "ignore_growing": False,
    "params": {"nprobe": 10}
}

Eseguire la Ricerca vettoriale

Utilizzare Milvus per la ricerca vettoriale. Per cercare all'interno di una partizione specifica, specificare un elenco di nomi delle partizioni.

Milvus supporta l'impostazione di un livello di coerenza per le ricerche. L'esempio in questo argomento imposta il livello di coerenza su "Strong". È anche possibile impostare il livello di coerenza su "Bounded", "Session" o "Eventually". Per ulteriori informazioni sui quattro livelli di coerenza in Milvus, vedere Coerenza.

results = collection.search(
    data=[[0.1, 0.2]], 
    anns_field="book_intro", 
    param=search_params,
    limit=10,
    expr=None,
    output_fields=['title'],
    consistency_level="Strong"
)

results[0].ids

results[0].distances

hit = results[0][0]
hit.entity.get('title')

Controllare i valori delle chiavi primarie e le distanze dei vettori più simili.

results[0].ids
results[0].distances

Una volta completata la ricerca, rilasciare la collezione caricata in Milvus per ridurre il consumo di memoria.

collection.release()

Limitazioni

Eseguire la Ricerca Mista

La ricerca mista è essenzialmente una ricerca vettoriale con filtraggio degli attributi. Specificando un'espressione booleana utilizzata per filtrare i campi scalari o i campi chiave primaria, le ricerche possono essere limitate in specifiche condizioni.

L'esempio seguente dimostra come eseguire una ricerca mista basata sulla regolare ricerca vettoriale. Supponiamo di voler cercare determinati libri in base a riassunti vettorializzati, ma si vuole cercare solo all'interno di un determinato intervallo di conteggio delle parole. In tal caso, è possibile specificare un'espressione booleana nei parametri di ricerca per filtrare il campo word_count. Milvus cercherà solo vettori simili all'interno delle entità che corrispondono all'espressione.

Specificando un'espressione booleana, è possibile filtrare i campi scalari delle entità durante la ricerca vettoriale. L'esempio seguente limita il campo di ricerca ai vettori all'interno del valore specificato del conteggio delle parole.

È anche possibile utilizzare campi dinamici nell'espressione di filtro e utilizzare campi di output nella richiesta di ricerca. Ad esempio, fare riferimento al modello dinamico.

search_param = {
  "data": [[0.1, 0.2]],
  "anns_field": "book_intro",
  "param": {"metric_type": "L2", "params": {"nprobe": 10}, "offset": 0},
  "limit": 10,
  "expr": "word_count <= 11000",
}
res = collection.search(**search_param)

Controllare i risultati restituiti.

assert len(res) == 1
hits = res[0]
assert len(hits) == 2
print(f"- Hits totali: {len(hits)}, hits ids: {hits.ids} ")
print(f"- Top1 id hit: {hits[0].id}, distanza: {hits[0].distance}, punteggio: {hits[0].score} ")

Eseguire la Ricerca di Intervallo

La ricerca di intervallo è un metodo di filtraggio dei risultati di ricerca in base alla distanza tra il vettore della query e i valori del campo vettoriale. Diverse metriche di distanza possono essere utilizzate per misurare la distanza.

Nel caso della ricerca di intervallo, Milvus esegue prima la ricerca di similarità vettoriale. Quindi, esegue il filtraggio vettoriale in base alle condizioni di distanza specificate e restituisce i vettori la cui distanza rientra in un intervallo specifico.

L'esempio seguente dimostra come eseguire la ricerca di intervallo basata sulla regolare ricerca vettoriale.

Caricamento della Collezione

Tutte le operazioni di ricerca e interrogazione in Milvus vengono eseguite in memoria. Prima di eseguire la ricerca di similarità vettoriale, la collezione deve essere caricata in memoria.

from pymilvus import Collection
collection = Collection("book")      # Ottenere una collezione esistente
collection.load()

Configurazione degli intervalli di filtraggio vettoriale

Rispetto alla ricerca vettoriale regolare, la ricerca degli intervalli in Milvus è controllata introducendo due nuovi parametri, raggio e range_filter, per ottenere i risultati desiderati entro un intervallo di ricerca specifico.

Il parametro raggio specifica l'angolo minimo a cui i vettori sono considerati simili. Un facoltativo range_filter può essere utilizzato in congiunzione con il raggio per filtrare i valori dei campi vettoriali in base alla similarità al vettore di query entro un intervallo specifico. Entrambi i parametri raggio e range_filter hanno un tipo di dato FLOAT. Impostando questi due parametri si bilancia efficacemente l'accuratezza e l'efficienza della ricerca.

Tipicamente, la similarità è misurata dalla distanza tra il valore del campo vettoriale e il vettore di query. La selezione di diverse metriche di distanza avrà un impatto significativo sulla configurazione di raggio e range_filter.

Ad esempio, nel caso della distanza L2, i risultati della ricerca devono essere filtrati basandosi sui valori dei campi vettoriali con una distanza inferiore a raggio. Ciò è dovuto al fatto che nella distanza L2, distanze più piccole indicano una maggiore similarità. Con questa conoscenza, se si desidera filtrare alcuni dei vettori più simili, è possibile specificare un valore efficace di range_filter che sia inferiore a raggio.

search_params = {
    "tipo_metrica": "L2",
    "parametri": {
        "raggio": 10.0,
        "range_filter" : 5.0
    }
}

Nel caso della distanza IP, lo scenario è differente. Con la distanza IP, una distanza maggiore indica una maggiore similarità. Pertanto, in contrasto con la distanza L2, i valori di raggio e range_filter nella distanza IP sono opposti. In altre parole, quando si utilizza range_filter per filtrare alcuni dei vettori più simili basati sulla distanza IP, il valore efficace di range_filter deve essere maggiore di raggio, e la distanza dei vettori risultanti dovrebbe essere maggiore di raggio ma inferiore o uguale a range_filter.

search_params = {
    "tipo_metrica": "IP",
    "parametri": {
        "raggio": 0.8,
        "range_filter" : 1.0
    }
}

Eseguire la ricerca degli intervalli

Specificando raggio e range_filter in base al tipo di misurazione della distanza, è possibile definire l'intervallo dei vettori risultanti da restituire.

Eseguire la ricerca degli intervalli di similarità nell'intervallo di 5.0 e 10.0 basata sulla distanza L2:

parametri_ricerca = {
  "dati": [[0.1, 0.2]], # Vettore di query
  "campo_anns": "intro_libro", # Campo da cercare
  "param": { "tipo_metrica": "L2", "parametri": { "nprobe": 10, "raggio": 10.0, "range_filter" : 5.0 }, "offset": 0 },
  "limite": 2,
  "campi_output": ["int64", "float"]  # Campi da restituire
}

risultato = raccolta_ricerca.ricerca(**parametri_ricerca)

Eseguire la ricerca degli intervalli di similarità nell'intervallo di 1.0 e 0.8 basata sulla distanza IP:

parametri_ricerca = {
  "dati": [[0.1, 0.2]], # Vettore di query
  "campo_anns": "intro_libro", # Campo da cercare
  "param": {"tipo_metrica": "IP", "parametri": { "nprobe": 10, "raggio": 0.8, "range_filter" : 1.0 }, "offset": 0 },
  "limite": 2,
  "campi_output": ["int64", "float"]  # Campi da restituire
}

risultato = raccolta_ricerca.ricerca(**parametri_ricerca)

Riassunto

In Milvus, la ricerca degli intervalli può restituire risultati vettoriali simili entro l'intervallo di distanza specificato. Questa funzionalità è abilitata specificando raggio e range_filter nei parametri di ricerca. La tabella riassume la configurazione di questi due parametri per i diversi tipi di misurazione della distanza.