Bitset
Questo argomento introduce il meccanismo dei bitset che consente di abilitare funzionalità chiave come il filtraggio degli attributi e le operazioni di cancellazione in Milvus.
Panoramica
Un bitset è un insieme di bit. I bit sono elementi con due soli valori possibili, tipicamente 0
e 1
, o valori booleani true
e false
. In Milvus, i bitset sono array di numeri di bit 0
e 1
che possono essere utilizzati per rappresentare determinati dati in modo compatto ed efficiente rispetto a ints, float o caratteri. Un numero di bit è 0
per impostazione predefinita e viene impostato a 1
solo se soddisfa determinati requisiti.
Le operazioni sugli insiemi di bit sono condotte con la logica booleana, in base alla quale un valore in uscita è valido o non valido, indicato rispettivamente con 1
e 0
. Ad esempio, l'operatore logico AND
può essere utilizzato per confrontare due bitset basati su elementi nelle stesse posizioni di indice e produce un nuovo bitset con i risultati. Se due elementi in una posizione sono uguali, nel nuovo bitset verrà scritto 1
in quella posizione; 0
se sono diversi.
L'implementazione
Bitset è un meccanismo semplice ma potente che aiuta Milvus a eseguire il filtraggio degli attributi, la cancellazione dei dati e le interrogazioni con Time Travel.
Filtraggio degli attributi
Poiché i bitet contengono solo due valori possibili, sono perfetti per memorizzare i risultati del filtraggio degli attributi. I dati che soddisfano i requisiti di un determinato filtro di attributo sono contrassegnati da 1
.
Eliminazione dei dati
I bitet sono un modo compatto per memorizzare le informazioni sulla cancellazione di una riga in un segmento. Le entità cancellate sono contrassegnate con 1
nel bitset corrispondente, che non verrà calcolato durante una ricerca o un'interrogazione.
Esempi
Qui presentiamo tre esempi che illustrano l'uso dei bitset in Milvus, con riferimenti a tutte e tre le principali implementazioni di bitset discusse in precedenza. In tutti e tre i casi, c'è un segmento con 8 entità e poi una serie di eventi del linguaggio di manipolazione dei dati (DML) nell'ordine mostrato di seguito.
- Quattro delle entità, i cui
primary_key
s sono rispettivamente [1, 2, 3, 4], vengono inserite quando il timestampts
è uguale a 100. Le altre quattro entità, i cui s sono rispettivamente [1, 2, 3, 4], vengono inserite quando il timestamp è uguale a 100. - Le altre quattro entità, i cui
primary_key
s sono [5, 6, 7, 8], vengono inserite quando il timestampts
è uguale a 200. - Le entità i cui
primary_key
s sono [7, 8] vengono cancellate quando il timestampts
è uguale a 300. - Solo le entità i cui
primary_key
s sono [1, 3, 5, 7] soddisfano le condizioni di filtraggio degli attributi.
Ordine degli eventi DML
Caso uno
In questo caso, un utente imposta time_travel
come 150, il che significa che l'utente esegue una query sui dati che soddisfano ts = 150
. Il processo di generazione del set di bit è illustrato dalla Figura 1.
Durante la fase iniziale di filtraggio, filter_bitset
dovrebbe essere [1, 0, 1, 0, 1, 0, 1, 0]
, dove le entità [1, 3, 5, 7] sono contrassegnate come 1
perché sono risultati validi del filtraggio.
Tuttavia, le entità [4, 5, 6, 7] non sono state inserite nel database vettoriale quando ts
è uguale a 150. Pertanto, queste quattro entità devono essere contrassegnate come . Pertanto, queste quattro entità devono essere contrassegnate come 0, indipendentemente dalla condizione di filtraggio. Ora il risultato del set di bit dovrebbe essere [1, 0, 1, 0, 0, 0, 0, 0]
.
Come discusso in Eliminazione dei dati, le entità contrassegnate con 1
vengono ignorate durante una ricerca o un'interrogazione. Il risultato del bitset deve ora essere capovolto per essere combinato con la bitmap di cancellazione, il che ci dà [0, 1, 0, 1, 1, 1, 1, 1]
.
Per quanto riguarda il bitset di cancellazione del_bitset
, il valore iniziale dovrebbe essere [0, 0, 0, 0, 0, 0, 1, 1]
. Tuttavia, le entità 7 e 8 non vengono cancellate finché ts
non è 300. Pertanto, quando è 150, le entità 7 e 8 vengono cancellate. Pertanto, quando ts
è 150, le entità 7 e 8 sono ancora valide. Di conseguenza, il valore di del_bitset
dopo il Viaggio nel tempo è [0, 0, 0, 0, 0, 0, 0, 0]
.
Ora abbiamo due set di bit dopo il Viaggio nel tempo e il filtraggio degli attributi: filter_bitset
[0, 1, 0, 1, 1, 1, 1, 1]
e del_bitset
[0, 0, 0, 0, 0, 0, 0, 0]
. Combinare questi due insiemi di bit con l'operatore logico binario OR
. Il valore finale di result_bitset è [0, 1, 0, 1, 1, 1, 1, 1]
, il che significa che solo le entità 1 e 3 saranno calcolate nella successiva fase di ricerca o interrogazione.
Figura 1. Ricerca con tempo di percorrenza = 150.
Caso due
In questo caso, l'utente imposta time_travel
a 250. La Figura 2 illustra il processo di generazione del set di bit.
Come nel primo caso, filter_bitset
iniziale è [1, 0, 1, 0, 1, 0, 1, 0]
.
Tutte le entità sono presenti nel database vettoriale quando ts
= 250. Pertanto, rimane lo stesso. Pertanto, filter_bitset
rimane invariato quando si aggiunge il timestamp. Anche in questo caso, dobbiamo invertire il risultato e ottenere [0, 1, 0, 1, 0, 1, 0, 1]
.
Per quanto riguarda il set di bit di cancellazione del_bitset
, il valore iniziale è [0, 0, 0, 0, 0, 0, 1, 1]
. Tuttavia, le entità 7 e 8 non sono state cancellate fino a quando ts
non è 300. Pertanto, quando è 250, il valore rimane invariato. Pertanto, quando ts
è 250, le entità 7 e 8 sono ancora valide. Di conseguenza, del_bitset
dopo il Viaggio nel tempo è [0, 0, 0, 0, 0, 0, 0, 0]
.
Ora abbiamo due bitet dopo il Viaggio nel tempo e il filtraggio degli attributi: filter_bitset
[0, 1, 0, 1, 0, 1, 0, 1]
e del_bitset
[0, 0, 0, 0, 0, 0, 0, 0]
. Combinare questi due insiemi di bit con l'operatore logico binario OR
. L'insieme di bit risultante è [0, 1, 0, 1, 0, 1, 0, 1]
. Ciò significa che solo le entità [1, 3, 5, 7] saranno calcolate nella successiva fase di ricerca o interrogazione.
Figura 2. Ricerca con tempo di percorrenza = 250.
Caso tre
In questo caso, l'utente imposta time_travel
a 350. La Figura 3 illustra il processo di generazione del set di bit.
Come nei casi precedenti, filter_bitset
iniziale è [0, 1, 0, 1, 0, 1, 0, 1]
.
Tutte le entità sono presenti nel database vettoriale quando ts
= 350. Pertanto, il bitset finale, capovolto, è . Pertanto, l'filter_bitset
finale, ribaltato, è [0, 1, 0, 1, 0, 1, 0, 1]
, come nel caso due.
Per quanto riguarda il bitet di cancellazione del_bitset
, poiché le entità 7 e 8 sono già state cancellate quando ts = 350
, quindi il risultato di del_bitset
è [0, 0, 0, 0, 0, 0, 1, 1]
.
Ora abbiamo due bitset dopo il viaggio nel tempo e il filtraggio degli attributi: filter_bitset
[0, 1, 0, 1, 0, 1, 0, 1]
e del_bitset
[0, 0, 0, 0, 0, 0, 1, 1]
. Combiniamo questi due insiemi di bit con l'operatore logico binario OR
. L'ultimo result_bitset
è [0, 1, 0, 1, 0, 1, 1, 1]
. Ciò significa che solo le entità [1, 3, 5] saranno calcolate nella successiva fase di ricerca o interrogazione.
Figura 3. Ricerca con tempo di percorrenza = 350.
Cosa succede dopo
Ora che sapete come funzionano i bitset in Milvus, potreste anche voler:
- Imparare a usare le stringhe per filtrare i risultati della ricerca, oppure consultare la Ricerca ibrida nei nostri documenti.
- Capire come vengono elaborati i dati in Milvus.