Ricerca vettoriale di base con StructArray

Utilizza questa pagina per eseguire una ricerca vettoriale sui sottocampi vettoriali all'interno di un campo StructArray. StructArray supporta due modalità di ricerca vettoriale di base: la ricerca EmbeddingList, che valuta un elenco di embedding memorizzato in ciascuna entità, e la ricerca a livello di elemento, che effettua la ricerca su ciascun elemento Struct in modo indipendente.

Questa pagina utilizza la raccolta " tech_articles " descritta nella sezione "Creazione di un campo StructArray". La raccolta presenta un campo StructArray denominato " chunks". Ogni chunk contiene testo, metadati scalari, un sottocampo vettoriale denominato " emb_list_vector " con un indice per la ricerca EmbeddingList e un sottocampo vettoriale denominato " emb " con un indice per la ricerca a livello di elemento.

Prima di iniziare

Assicurarsi che lo schema della raccolta, i dati e gli indici siano già stati preparati.

Requisiti	Dove prepararlo
Creare un campo StructArray, ad esempio chunks.	Creazione di un campo StructArray
Inserire entità il cui campo ` chunks ` contenga oggetti Struct.	Inserire dati nei campi StructArray
Creare un indice ` MAX_SIM* ` su ` chunks[emb_list_vector] ` per la ricerca in `EmbeddingList`.	Indicizzare i campi StructArray
Creare un indice vettoriale-metrico regolare su chunks[emb] per la ricerca a livello di elemento.	Indicizzazione dei campi StructArray

Scegliere una modalità di ricerca

Aspetto	Ricerca EmbeddingList	Ricerca a livello di elemento
Sottocampo di destinazione	chunks[emb_list_vector]	chunks[emb]
Dati di query	Un elenco di embedding contenente uno o più vettori.	Un vettore regolare.
Famiglia di metriche	MAX_SIM*, come ad esempio MAX_SIM_COSINE.	Metriche vettoriali regolari, come COSINE, IP o L2.
Cosa rappresenta un risultato	Un'entità corrispondente il cui sottocampo vettoriale StructArray è simile all'elenco di embedding della query.	Un elemento Struct corrispondente all’interno del campo StructArray.
Granularità dei risultati	A livello di entità.	A livello di elemento Struct.
Offset	Non applicabile.	Identifica la posizione, a partire da zero, dell’elemento Struct corrispondente al momento della restituzione.
Uso tipico	ColBERT, ColPali e altri modelli di recupero a interazione tardiva.	Recupero a livello di chunk, di passaggio, di clip, di patch o di fatto.

Esegui la ricerca EmbeddingList

Utilizzare la ricerca EmbeddingList quando la query stessa contiene più vettori e il sottocampo vettoriale StructArray di destinazione è indicizzato con una metrica MAX_SIM*. Il risultato è una corrispondenza a livello di entità.

from pymilvus import MilvusClient
from pymilvus.client.embedding_list import EmbeddingList

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus",
)

query = EmbeddingList()
query.add([0.12, 0.21, 0.32, 0.44])
query.add([0.18, 0.23, 0.29, 0.36])

results = client.search(
    collection_name="tech_articles",
    data=[query],
    anns_field="chunks[emb_list_vector]",
    limit=3,
    output_fields=[
        "doc_id",
        "title",
        "category",
        "chunks[text]",
        "chunks[section]",
    ],
)

for hits in results:
    for hit in hits:
        print(hit["id"], hit["distance"], hit["entity"])

In questa modalità di ricerca, l’ limit controlla il numero di entità restituite per ciascuna query. L’output può includere sottocampi StructArray, ma il risultato stesso rappresenta l’entità padre corrispondente piuttosto che un singolo elemento Struct specifico.

Eseguire una ricerca a livello di elemento

Utilizzare la ricerca a livello di elemento quando ogni elemento Struct deve partecipare alla ricerca vettoriale in modo indipendente. La query è un vettore regolare e il sottocampo vettoriale di destinazione deve essere indicizzato con una metrica vettoriale regolare.

query_vector = [0.19, 0.24, 0.30, 0.37]

results = client.search(
    collection_name="tech_articles",
    data=[query_vector],
    anns_field="chunks[emb]",
    limit=5,
    output_fields=[
        "doc_id",
        "title",
        "chunks[text]",
        "chunks[section]",
        "chunks[page]",
        "chunks[quality_score]",
    ],
)

for hits in results:
    for hit in hits:
        print(
            "doc_id:", hit["id"],
            "distance:", hit["distance"],
            "offset:", hit.get("offset"),
            "entity:", hit["entity"],
        )

Nella ricerca a livello di elemento, ogni risultato rappresenta un elemento Struct corrispondente. Il valore " offset " è la posizione, a partire da zero, di quell’elemento nel campo StructArray. La stessa entità può comparire più di una volta se più di un elemento Struct corrisponde alla query. Il valore " limit " si applica ai risultati a livello di elemento, non alle entità padre univoche.

Interpretazione dei risultati

Elemento del risultato	Ricerca EmbeddingList	Ricerca a livello di elemento
id	Chiave primaria dell’entità corrispondente.	Chiave primaria dell'entità che contiene l'elemento Struct corrispondente.
distance o punteggio	Punteggio o distanza tra l'elenco di embedding della query e l'elenco di embedding memorizzato.	Punteggio o distanza tra il vettore della query e il vettore dell’elemento Struct trovato.
offset	Non applicabile.	Posizione a partire da zero dell'elemento Struct corrispondente al momento della restituzione.
Chiavi primarie ripetute	Non previsto per una singola query poiché i risultati sono a livello di entità.	Possibile, poiché più elementi Struct nella stessa entità possono corrispondere.
Campi di output StructArray richiesti	Restituiti dall’entità corrispondente.	Restituiti con la forma di corrispondenza a livello di elemento supportata dall’API e dall’SDK di destinazione.

Errori comuni

• Utilizzo di " chunks.emb " anziché della sintassi richiesta per il percorso del sottocampo " chunks[emb]".

• Utilizzo di una query EmbeddingList su un sottocampo vettoriale indicizzato con una metrica vettoriale regolare.

• Utilizzo di una query vettoriale regolare su un sottocampo vettoriale indicizzato con una metrica MAX_SIM*.

• Aspettarsi che la ricerca a livello di elemento limit restituisca altrettante entità padre univoche. Restituisce invece i risultati a livello di elemento.

• Aspettarsi che la ricerca EmbeddingList restituisca un offset specifico dell’elemento. Restituisce invece corrispondenze a livello di entità.

• Riutilizzo di un unico sottocampo vettoriale per entrambe le modalità di ricerca. Utilizzare sottocampi vettoriali separati poiché ogni sottocampo vettoriale accetta un solo indice.

Prossimi passi

1. Per limitare la ricerca a livello di elemento in base a condizioni scalari, consultare Ricerca filtrata con StructArray.

2. Per effettuare ricerche in base a punteggi o limiti di distanza, consultare Ricerca per intervallo con StructArray.

3. Per restituire al massimo un risultato per entità padre dopo una ricerca a livello di elemento, consultare Ricerca raggruppata con StructArray.

4. Per combinare la ricerca StructArray con altre ricerche vettoriali, consultare Ricerca ibrida con StructArray.

5. Per esaminare i tipi di dati, le metriche, i filtri e i limiti specifici della versione supportati, consultare Limiti di StructArray.