Esiste un filtro anti-Bloom?

Un filtro Bloom consente di tenere traccia in modo efficiente se durante l'elaborazione sono già stati rilevati vari valori. Quando sono presenti molti elementi di dati, un filtro Bloom può comportare un notevole risparmio di memoria su una tabella hash. La caratteristica principale di un filtro Bloom, che condivide con una tabella hash, è che dice sempre "non nuovo" se un oggetto non è nuovo, ma c'è una probabilità diversa da zero che un oggetto sia contrassegnato come "non nuovo "anche quando è nuovo.

Esiste un "filtro anti-Bloom", che ha il comportamento opposto?

In altre parole: esiste una struttura dati efficiente che dice "nuovo" se un articolo è nuovo, ma che potrebbe anche dire "nuovo" per alcuni articoli che non sono nuovi?

Mantenere tutti gli elementi precedentemente visualizzati (ad esempio, in un elenco collegato ordinato) soddisfa il primo requisito ma può utilizzare molta memoria. Spero anche che non sia necessario, dato il secondo requisito rilassato.

Per coloro che preferiscono un trattamento più formale, scrivi $b(x) = 1$ se il filtro Bloom pensa che $x$ sia nuovo, $b(x) = 0$ altrimenti, e scrivi $n(x) = 1$ se $x$ è davvero nuovo e altrimenti.$n(x) = 0$

Quindi ; ; ; P r [ b ( x ) = 1 | n ( x ) = 1 ] = 1 - α , per alcuni 0 < α < 1 .P r [ b ( x ) = 0 | n ( x ) = 1 ] = α P r [ b ( x ) = 1 | n ( x ) = 0 ] = $Pr[b(x) = 0 | n(x) = 0] = 1$$Pr[b(x) = 0 | n(x) = 1] = \alpha$$Pr[b(x) = 1 | n(x) = 0] = 0$$Pr[b(x) = 1 | n(x) = 1] = 1 - \alpha$$0 < \alpha < 1$

Sto chiedendo: esiste una struttura dati efficiente, implementando una funzione $b'$ con qualche $0 < \beta < 1$ , tale che ; ; ; ?$Pr[b'(x) = 0 | n(x) = 0] = \beta$$Pr[b'(x) = 0 | n(x) = 1] = 0$P r [ b ′ ( x ) = 1 | n ( x ) = 1 ] = $Pr[b'(x) = 1 | n(x) = 0] = 1 - \beta$$Pr[b'(x) = 1 | n(x) = 1] = 1$

Modifica: sembra che questa domanda sia stata posta in precedenza su StackExchange, come /programming/635728 e /cstheory/6596 con una gamma di risposte da "impossibile essere fatto "attraverso" può essere fatto, ad un certo costo "a" è banale da fare, invertendo i valori di $b$ ". Non mi è ancora chiaro quale sia la risposta "giusta". Ciò che è chiaro è che uno schema di memorizzazione nella cache LRU di qualche tipo (come quello suggerito da Ilmari Karonen) funziona piuttosto bene, è facile da implementare e ha comportato una riduzione del 50% del tempo impiegato per eseguire il mio codice.

Seguendo l'idea di hash di Patrick87, ecco una costruzione pratica che soddisfa quasi le tue esigenze: la probabilità di confondere erroneamente un nuovo valore con uno vecchio non è del tutto zero, ma può essere facilmente resa trascurabilmente piccola.

Scegli i parametri e k ; i valori pratici potrebbero essere, diciamo, n = 128 e k = 16 . Sia H una funzione di hash crittografica sicura che produce (almeno) n + k bit di output.$n$$k$$n = 128$$k = 16$$H$$n+k$

Facciamo essere un array di 2 k n -bit bitstrings. Questo array memorizza lo stato del filtro, utilizzando un totale di n 2 k bit. (Non importa in che modo questo array è inizializzato; possiamo semplicemente riempirlo con zeri o con bit casuali.)$a$$2^k$ $n$$n2^k$

• Per aggiungere un nuovo valore al filtro, calcolare $x$ , dove i indica i primi k bit e j indica i seguenti n bit di H ( x ) . Lascia a i = j .$i \,\|\, j = H(x)$$i$$k$$j$$n$$H(x)$$a_{i} = j$

• Per verificare se un valore è stato aggiunto al filtro, calcolare i $x'$ , come sopra, e verificare se a i ′ = j ′ . Se sì, restituisci true; altrimenti restituisce false.$i' \,\|\, j' = H(x')$$a_{i'} = j'$

Rivendicazione 1: La probabilità di un falso positivo (= nuovo valore falsamente dichiarato di essere stato visto) è . Questo può essere reso arbitrariamente piccolo, a un costo modesto nello spazio di archiviazione, aumentando n ; in particolare, per n ≥ 128 , questa probabilità è sostanzialmente trascurabile, essendo, in pratica, molto più piccola della probabilità di un falso positivo a causa di un malfunzionamento dell'hardware.$1/2^{n+k}$$n$$n \ge 128$

In particolare, dopo che valori distinti sono stati controllati e aggiunti al filtro, la probabilità che si sia verificato almeno un falso positivo è ( N 2 - N ) / 2 n + k + 1 . Ad esempio, con n = 128 e k = 16 , il numero di valori distinti necessari per ottenere un falso positivo con una probabilità del 50% è di circa 2 ( n + k ) / 2 = 2 72 .$N$$(N^2-N) / 2^{n+k+1}$$n=128$$k=16$$2^{(n+k)/2} = 2^{72}$

Rivendicazione 2: La probabilità di un falso negativo (= valore aggiunto precedentemente dichiarato erroneamente nuovo) non è maggiore di , dove N è il numero di valori distinti aggiunti al filtro (o, più specificamente, il numero di valori distinti aggiunti dopo che il valore specifico da testare è stato aggiunto più recentemente al filtro).$1-(1-2^{-k})^N \approx 1-\exp(-N/2^k) < N/2^k$$N$

Ps. Per mettere in prospettiva "trascurabilmente piccoli", la crittografia a 128 bit è generalmente considerata indistruttibile con la tecnologia attualmente nota. Ottenere un falso positivo da questo schema con è probabile quanto qualcuno indovini correttamente la tua chiave di crittografia segreta a 128 bit al primo tentativo . (Con n = 128 e k = 16 , in realtà è circa 65.000 volte meno probabile di così.)$n+k=128$$n=128$$k=16$

Ma se questo ti fa ancora sentire irrazionalmente nervoso, puoi sempre passare a ; raddoppierà i tuoi requisiti di archiviazione, ma posso tranquillamente scommettere qualsiasi somma che ti dispiacerebbe nominare che nessuno vedrà mai un falso positivo con n = 256 - supponendo che la funzione hash non sia interrotta, comunque.$n=256$$n=256$

No, non è possibile avere una struttura dati efficiente con queste proprietà, se si desidera avere la garanzia che la struttura dati dirà "nuovo" se è veramente nuova (non dirà mai "non nuovo" se è infatti nuovo; non sono ammessi falsi negativi). Una tale struttura di dati dovrà mantenere tutti i dati per rispondere "non nuovo". Vedi la risposta di pents90 su cstheory per una giustificazione precisa.

Al contrario, i filtri Bloom possono ottenere la garanzia che la struttura dei dati dirà "non nuovo" se non è nuova, in modo efficiente. In particolare, i filtri Bloom possono essere più efficienti della memorizzazione di tutti i dati: ogni singolo elemento potrebbe essere piuttosto lungo, ma la dimensione del filtro Bloom si ridimensiona in base al numero di elementi, non alla loro lunghezza totale. Qualsiasi struttura di dati per il tuo problema dovrà ridimensionarsi in base alla lunghezza totale dei dati, non al numero di elementi di dati.

Che ne dici di una tabella hash? Quando vedi un nuovo elemento, controlla la tabella hash. Se il punto dell'articolo è vuoto, restituisci "nuovo" e aggiungi l'articolo. Altrimenti, controlla per vedere se il posto dell'oggetto è occupato dall'oggetto. In tal caso, restituire "non nuovo". Se il punto è occupato da un altro oggetto, restituisci "nuovo" e sovrascrivi il punto con il nuovo oggetto.

Avrai sicuramente sempre "Nuovo" se non hai mai visto l'hash dell'elemento prima. Avrai sicuramente sempre "Non nuovo" se hai visto l'hash dell'oggetto solo quando hai visto lo stesso oggetto. L'unica volta che otterrai "Nuovo" quando la risposta corretta è "Non nuovo" è se vedi l'articolo A, quindi vedi l'articolo B, quindi vedi di nuovo l'articolo A e entrambi gli hash A e B sulla stessa cosa. È importante sottolineare che non è mai possibile ottenere "Not New" in modo errato.

Nel caso in cui l'universo degli oggetti sia finito, allora sì: basta usare un filtro bloom che registra quali elementi sono fuori dal set, piuttosto che nel set. (Vale a dire, utilizzare un filtro bloom che rappresenta il complemento dell'insieme di interesse.)

Un luogo in cui ciò è utile è consentire una forma limitata di cancellazione. Mantieni due filtri di fioritura. Iniziano vuoti. Quando si inseriscono elementi, li si inserisce nel filtro bloom A. Se in seguito si desidera eliminare un elemento, si inserisce tale elemento nel filtro bloom B. Non è possibile annullare l'eliminazione. Per effettuare una ricerca, devi prima cercare nel filtro Bloom A. Se non trovi alcuna corrispondenza, l'elemento non è mai stato inserito (con probabilità 1). Se trovi una corrispondenza, l'elemento potrebbe (o meno) essere stato inserito. In tal caso, esegui una ricerca nel filtro bloom B. Se non trovi alcuna corrispondenza, l'elemento non viene mai eliminato. Se trovi una corrispondenza nel filtro bloom B, l'elemento è stato probabilmente inserito e quindi eliminato.

Questo in realtà non risponde alla tua domanda, ma, in questo caso limitato, il filtro bloom B sta eseguendo esattamente il comportamento del "filtro anti-bloom" che stai cercando.

I ricercatori del filtro Real Bloom usano modi molto più efficienti di rappresentare la cancellazione, vedi la pagina della pubblicazione di Mike Mitzenmacher .

Voglio solo aggiungere qui, che se sei nella situazione fortunata, che conosci tutti i valori $v_i$che potresti vedere; quindi è possibile utilizzare un filtro bloom conteggio.

Un esempio potrebbe essere rappresentato dagli indirizzi IP e vuoi sapere ogni volta che uno appare che non hai mai visto prima. Ma è ancora un set finito, quindi sai cosa puoi aspettarti.

La soluzione effettiva è semplice:

1. Aggiungi tutti i tuoi articoli al filtro fioritura conteggio.
2. Quando vedi un nuovo oggetto, avrà dei valori $\ge1$ in tutte le slot.
3. Dopo aver visto un nuovo oggetto reale, sottralo dal filtro.

Quindi potresti avere valori di "falsi positivi" che in realtà erano vecchi, ma riconosciuti come nuovi. Tuttavia non otterrai mai "non nuovo" per un nuovo valore, dal momento che il suo valore sarà ancora in tutti gli slot, e nessun altro avrebbe potuto toglierlo.