Calcolo della popolazione approssimativa di un filtro di fioritura

12

Dato un filtro bloom di dimensioni N-bit e funzioni hash K, di cui sono impostati i bit M (dove M <= N) del filtro.

È possibile approssimare il numero di elementi inseriti nel filtro bloom?

Esempio semplice

Ho riflettuto sul seguente esempio, supponendo un BF di 100 bit e 5 funzioni hash in cui sono impostati 10 bit ...

Scenario migliore: supponendo che le funzioni hash siano davvero perfette e mappino in modo univoco un po 'per un numero X di valori, quindi dati 10 bit sono stati impostati possiamo dire che ci sono stati solo 2 elementi inseriti nel BF

Scenario peggiore: supponendo che le funzioni di hash siano cattive e siano coerentemente associate allo stesso bit (ma uniche tra loro), allora possiamo dire che 10 elementi sono stati inseriti nel BF

L'intervallo sembra essere [2,10] dove circa questo intervallo è probabilmente determinato dalla probabilità falsa positiva del filtro - sono bloccato a questo punto.

ds.data-structures pr.probability

— Tander Kulip
fonte

4

Perché non tenere un contatore del numero di elementi inseriti? Ci vogliono solo bit

aggiuntivi , se sono stati inseriti

elementi.

O (\log n)

$O(\log n)$

n

$n$

— Joe

@Joe, sebbene sia una buona idea, rovina una domanda davvero interessante.

— dan_waterworth,

Solo notando che con i duplicati, il metodo di Joe avrà qualche piccolo errore poiché non possiamo sempre dire con certezza quando si aggiunge un elemento se è già presente (e quindi dovremmo aumentare o meno il conteggio).

— usul

5

Sì. Da Wikipedia :

Se hai inserito elementi in un filtro di dimensione usando funzioni hash, la probabilità che un determinato bit sia ancora 0 è $i$ $n$ $k$

z = {(1 - \frac{1}{n})}^{k i}

$z = \left(1 - \frac{1}{n}\right)^{ki}$

È possibile misurare questa probabilità come proporzione di 0 bit nel filtro. Risolvendo per dà $i$

i = \frac{\ln (z)}{k \ln (1 - \frac{1}{n})}

$i = \frac{\ln(z)}{k\ln\left(1 - \frac{1}{n}\right)}$

L'ho usato in pratica e finché il filtro non supera la sua capacità, l'errore è generalmente inferiore allo 0,1% per filtri fino a milioni di bit. Poiché il filtro supera la sua capacità, l'errore ovviamente aumenta.

— Jay Hacker
fonte

3

$k$ $k$ $nk$ $n$ $b$ $t$

P (t balls | b bins) = P (b bins | t balls) \cdot P (t) / P (b)

$P( t \mbox{ balls} | b \mbox{ bins} ) = P(b \mbox{ bins}| t \mbox{ balls}) \cdot P(t)/P(b)$

P (t)

$P(t)$

P (b)

$P(b)$

t

$t$

— Joe
fonte

2

Domanda interessante, diamo un'occhiata ad alcuni casi specifici.

$k$ $n_{on}$ $n_{total}$ $m$ $P(k, n_{on}, n_{total}, m)$

$km \lt n_{on}$ $P(k, n_{on}, n_{total}, m)$ $0$

$n_{on} = 1$ $km$ $km - 1$

$P(k, 1, n_{total}, m) = (1/n_{total})^{(km-1)}$

$n_{on} = 2$ $km$ $2$ $1$ $n_{total}(n_{total} - 1)$ $2$ $(2/n_{total})^{km}$ $2$

$n_{total}(n_{total} - 1)(2/n_{total})^{km}$

$1$ $2$

$P(k, 2, n_{total}, m) = n_{total}(n_{total} - 1)(2/n_{total})^{km} - (1/n_{total})^{(km-1)}$

Penso che possiamo generalizzare questo ora.

$P(k, n_{on}, n_{total}, m) = {n_{total} \choose n_{on}}(n_{on}/n_{total})^{km} - \sum_{i=1}^{i<n_{on}} P(k, i, n_{total}, m)$

Non sono esattamente sicuro di come rendere questa formula più suscettibile al calcolo. Implementato ingenuamente, si tradurrebbe in un tempo di esecuzione del tempo esponenziale, anche se è banale, tramite la memoizzazione, ottenere un tempo lineare. È quindi solo il caso di trovare la più probabile . Il mio istinto dice che ci sarà un singolo picco, quindi potrebbe essere possibile trovarlo molto rapidamente, ma ingenuamente, puoi sicuramente trovare il m probabilmente in . $m$ $O(n^2)$

— dan_waterworth
fonte

Penso che la tua formula si annulli a (ignorando i fattori costanti). Puoi calcolare il massimo di questo analiticamente: espandi il primo fattore del secondo termine e rimuovi i fattori costanti per sbarazzarti di tutto , e quindi la tua formula diventa molto semplice.

(\binom{n_{t o t a l}}{n_{o n}}) n_{o n}^{k m} - (\binom{n_{t o t a l}}{n_{o n} - 1}) (n_{o n} - 1)^{k m}

${n_{total} \choose n_{on}}n_{on}^{km}- {n_{total} \choose n_{on}-1}(n_{on}-1)^{km}$ n choose k

— Jules,

@Jules, fantastico, ero sicuro che sarebbe successo qualcosa del genere, ma non ho avuto il tempo di capirlo.

— dan_waterworth,

Puoi anche arrivare a quella formula direttamente nel modo seguente: . Quindi collegare per .

P (n_{o n} = x) = P (n_{o n} \leq x) - P (n_{o n} < x) = P (n_{o n} \leq x) - P (n_{o n} \leq x - 1)

$P(n_{on} = x) = P(n_{on} \leq x) - P(n_{on} < x) = P(n_{on} \leq x) - P(n_{on} \leq x-1)$

(\binom{n_{t o t a l}}{x}) (x / n_{t o t a l})^{k m}

${n_{total} \choose x} (x/n_{total})^{km}$

P (n_{o n} \leq x)

$P(n_{on} \leq x)$

— Jules il

2

Supponiamo che gli hash siano distribuiti uniformemente.

Permettetemi essere il numero di hash inseriti. Dal momento che abbiamo hash in bidoni se abbiamo hash in bidoni e la prossima hash va in una di quelle di bidoni o se ci sono hash in bidoni e la prossima hash va in uno degli altri bin, abbiamo: $i$ $i$ $m$ $i-1$ $m$ $m$ $n$ $i-1$ $m-1$ $n-(m-1)$

$P(m,i) = P(m,i-1)(m/n) + P(m-1,i-1)(n-(m-1))/n$

riscrittura:

$P(m,i) = \frac{1}{n}(mP(m,i-1) + (n-m+1)P(m-1,i-1))$

Abbiamo anche e quando e quando . Questo ti dà un algoritmo di programmazione dinamica per il calcolo di P. Il calcolo che massimizza ti dà la stima della massima verosimiglianza. $P(0,0) = 1$ $P(m,0) = 0$ $m \neq 0$ $P(0,i) = 0$ $i \neq 0$ $O(mi)$ $i$ $P(m,i)$

Se sappiamo che abbiamo hash in questo filtro fioritura tempi e abbiamo hash per articolo, quindi il numero di elementi è . $i$ $k$ $i/k$

Per accelerare puoi fare alcune cose. Il fattore di può essere lasciato fuori dal momento che non cambia la posizione del massimo. È possibile condividere le tabelle di programmazione dinamica con più chiamate a per ridurre il tempo di esecuzione (asintotico) a . Se sei disposto a credere che ci sia un singolo massimo, puoi interrompere l'iterazione prima di e ottenere il tempo di esecuzione dove è il punto in cui assume il suo massimo, o persino fare una ricerca binaria e ottenere . $\frac{1}{n}$ $P(m,i)$ $O(nm)$ $i$ $O(jm)$ $j$ $P$ $O(m \log n)$

— Jules
fonte

2

L'idea chiave è approssimare l'aspettativa del numero di zero bit.

Per ogni bit, la possibilità di essere zero dopo l'inserimento di t con funzioni hash K è: . $(1-\frac{1}{N})^{Kt} \approx e^{-\frac{Kt}{N}}$

Quindi l'aspettativa di numeri a zero bit dovrebbe essere:

$N e^{-\frac{Kt}{N}}$ approssimato dall'osservazione $N - M$

Alla fine abbiamo ottenuto $t = - \frac{N}{K} ln(1-\frac{M}{N})$

— Yanghong Zhong
fonte

1

La probabilità che un determinato bit sia 1 dopo n inserimenti è: P = 1 - (1 - 1 / m) ^ (kn)

Sia X_i una variabile casuale discreta che è 1 se il bit nella posizione 1 è 1 e 0 altrimenti. Lascia X = X_1 + X_2 + .... + X_m. Quindi, E [X] = m * P.

Se il numero totale di bit impostati è S, allora: E [X] = S che implica m * P = S. Questo potrebbe essere risolto per n.

— Nikhil
fonte