Calcular la población aproximada de un filtro de floración

12

Dado un filtro de floración de tamaño N-bits y K funciones hash, de las cuales se establecen M-bits (donde M <= N) del filtro.

¿Es posible aproximar el número de elementos insertados en el filtro de floración?

Ejemplo simple

He estado reflexionando sobre el siguiente ejemplo, suponiendo un BF de 100 bits y 5 funciones hash donde se establecen 10 bits ...

El mejor de los casos: suponiendo que las funciones hash son realmente perfectas y mapean un bit de forma única para un número X de valores, luego, dado que se han establecido 10 bits, podemos decir que solo se han insertado 2 elementos en el BF

En el peor de los casos: suponiendo que las funciones hash sean malas y se asignen consistentemente al mismo bit (pero únicas entre sí), entonces podemos decir que se han insertado 10 elementos en el BF

El rango parece ser [2,10], donde los valores aproximados en este rango probablemente estén determinados por la probabilidad de filtro de falsos positivos. Estoy atascado en este punto.

ds.data-structures pr.probability

— Tander Kulip
fuente

44

¿Por qué no mantener un contador del número de elementos insertados? Solo toma unos bits adicionales , si insertó elementos.

O (\log n)

$O(\log n)$

n

$n$

— Joe

@ Joe, si bien es una buena idea, arruina una pregunta realmente interesante.

— dan_waterworth

Solo notando que con los duplicados, el método de Joe tendrá un pequeño error ya que no siempre podemos decir con certeza al agregar un elemento si ya está presente (y, por lo tanto, deberíamos aumentar el recuento o no).

— usul

5

Si. De Wikipedia :

Si ha insertado elementos en un filtro de tamaño usando funciones hash, la probabilidad de que cierto bit sea 0 es $i$ $n$ $k$

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

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

Puede medir esta probabilidad como la proporción de 0 bits en su filtro. Resolver para da $i$

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

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

Lo he usado en la práctica, y siempre que su filtro no exceda su capacidad, el error generalmente es inferior al 0.1% para filtros de hasta millones de bits. A medida que el filtro excede su capacidad, el error, por supuesto, aumenta.

— Jay Hacker
fuente

3

Si supone que para cada función hash para cada objeto, un bit se establece de manera uniforme al azar, y tiene un recuento del número de bits que se han establecido, debería poder vincular la probabilidad de que el número de objetos insertados fuera dentro de un cierto rango, tal vez usando una formulación de bolas y contenedores. Cada bit es un contenedor, y se establece si tiene al menos 1 bola, cada objeto insertado arroja bolas, donde es el número de funciones hash y es el número de bolas lanzadas después de que se hayan insertado objetos. Teniendo en cuenta que contenedores tienen al menos 1 bola en ellos, ¿cuál es la probabilidad de que al menos bolas fueron arrojados? Creo que aquí puedes usar el hecho de que: $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)$ Pero el problema con esa formulación es que no veo una manera directa de calcular o , pero encontrar el valor de que maximice esa probabilidad no debería ser demasiado difícil.

P (t)

$P(t)$

P (b)

$P(b)$

t

$t$

— Joe
fuente

2

Pregunta interesante, veamos algunos casos específicos.

Deje que haya claves, bits , bits en total y elementos insertados. Primero intentaremos encontrar una función que es la probabilidad de que ocurra un estado. $k$ $n_{on}$ $n_{total}$ $m$ $P(k, n_{on}, n_{total}, m)$

Si , entonces debe ser , es decir, es imposible. $km \lt n_{on}$ $P(k, n_{on}, n_{total}, m)$ $0$

Si , entonces estamos buscando la probabilidad de que los hashes de caigan en el mismo cubo, el primero puede marcar dónde deben ir los otros. Por lo tanto, queremos encontrar la probabilidad de que los hashes caigan en un cubo específico. $n_{on} = 1$ $km$ $km - 1$

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

Esos son los casos realmente simples. Si entonces queremos encontrar la probabilidad de que los hashes caigan en cubos distintos y al menos caiga en cada uno. Hay pares de cubos y la probabilidad de que los hashes caigan en un específico es por lo que la probabilidad de que los hashes caigan a cubos es: $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}$

Ya sabemos la probabilidad de que caigan en cubo, así que restemos eso para dar la probabilidad de que caigan exactamente en . $1$ $2$

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

Creo que podemos generalizar esto ahora.

$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)$

No estoy exactamente seguro de cómo hacer que esta fórmula sea más adecuada para el cálculo. Implementado ingenuamente, daría como resultado un tiempo de ejecución de tiempo exponencial, aunque es trivial, a través de la memorización, lograr un tiempo lineal. Es solo un caso de encontrar el más probable . Mi instinto dice que habrá un solo pico, por lo que es posible encontrarlo muy rápidamente, pero ingenuamente, definitivamente puedes encontrar el m más probablemente en . $m$ $O(n^2)$

— dan_waterworth
fuente

Creo que su fórmula se cancela a (ignorando factores constantes). Puede calcular el máximo de esto analíticamente: expanda el primer factor del segundo término y elimine los factores constantes para deshacerse de todo , y luego su fórmula se vuelve muy simple.

(\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, genial, estaba seguro de que algo así sucedería, pero no tuve tiempo de resolverlo.

— dan_waterworth

También puede llegar a esa fórmula directamente de la siguiente manera: . Luego, conecte para .

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

2

Suponga que los hashes están distribuidos uniformemente.

Deja que sea el número de hashes insertados. Como tenemos hashes en bins si tenemos hashes en bins y el siguiente hash va a uno de esos de bins O si tenemos hashes en bins y el siguiente hash va en uno de los otros contenedores, tenemos: $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$

Reescribiendo:

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

También tenemos y cuando y cuando . Esto le proporciona un algoritmo de programación dinámica para calcular P. Calcular el que maximiza le proporciona la estimación de máxima verosimilitud. $P(0,0) = 1$ $P(m,0) = 0$ $m \neq 0$ $P(0,i) = 0$ $i \neq 0$ $O(mi)$ $i$ $P(m,i)$

Si sabemos que hemos introducido hash en este filtro de floración veces y tenemos hashes por elemento, entonces el número de elementos es . $i$ $k$ $i/k$

Para acelerarlo puedes hacer algunas cosas. El factor de puede omitirse ya que no cambia la posición del máximo. Puede compartir las tablas de programación dinámica con múltiples llamadas a para reducir el tiempo de ejecución (asintótico) a . Si está dispuesto a creer que hay un máximo único, puede detener la iteración sobre temprano y obtener el tiempo de ejecución donde es el punto donde adquiere su máximo, o incluso hacer una búsqueda binaria y obtener . $\frac{1}{n}$ $P(m,i)$ $O(nm)$ $i$ $O(jm)$ $j$ $P$ $O(m \log n)$

— Jules
fuente

2

La idea clave es aproximar la expectativa del número de bits cero.

Para cada bit, la posibilidad de ser cero después de t inserciones con funciones K hash es: . $(1-\frac{1}{N})^{Kt} \approx e^{-\frac{Kt}{N}}$

Entonces la expectativa de números de bit cero debería ser:

$N e^{-\frac{Kt}{N}}$ aproximado por la observación $N - M$

Finalmente tenemos $t = - \frac{N}{K} ln(1-\frac{M}{N})$

— Yanghong Zhong
fuente

1

La probabilidad de que un bit particular sea 1 después de n inserciones es: P = 1 - (1 - 1 / m) ^ (kn)

Supongamos que X_i es una variable aleatoria discreta que es 1 si el bit en la posición i es 1 y 0 en caso contrario. Deje X = X_1 + X_2 + .... + X_m. Entonces, E [X] = m * P.

Si el número total de bits establecidos es S, entonces: E [X] = S, lo que implica m * P = S. Esto podría resolverse para n.

— Nikhil
fuente