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_keys sono rispettivamente [1, 2, 3, 4], vengono inserite quando il timestamp ts è 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_keys sono [5, 6, 7, 8], sono inserite quando il timestamp ts è uguale a 200.
• Le entità i cui primary_keys sono [7, 8] vengono cancellate quando il timestamp ts è uguale a 300.
• Solo le entità i cui primary_keys 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 bitset è 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.