Comment fonctionnent les filtres de floraison évolutifs?

Je lisais sur les filtres de floraison évolutifs et ne pouvais pas comprendre comment chaque fois qu'un filtre de floraison constitutif se remplit, un nouveau filtre de floraison avec une plus grande taille est ajouté.

Les éléments qui ont contribué aux bits définis dans les filtres créés initialement ne peuvent pas être recherchés pour la présence. Peut-être que je me trompe dans ma compréhension de cela?

Je comprends les filtres de floraison de base. Cependant, je ne peux pas envelopper ma tête autour de filtres de floraison dynamiques.

Permettez-moi d'essayer de donner un coup à ceci pour voir combien je peux l'abattre. :-)

Donc, pour commencer, vous devez être en mesure de créer un filtre de floraison régulier qui permet un nombre fini d'éléments avec une probabilité maximale de faux positif. L'ajout de ces fonctionnalités à votre filtre de base est requis avant de tenter de créer une implémentation évolutive.

Avant d'essayer de contrôler et d'optimiser la probabilité, voyons quelle est la probabilité pour une taille de filtre de floraison donnée.

D'abord, nous divisons le champ binaire par le nombre de fonctions de hachage que nous avons (nombre total de bits / nombre de fonctions de hachage = tranches) pour obtenir k tranches de bits qui représentent chaque fonction de hachage afin que chaque élément soit toujours décrit par k bits.

Si vous augmentez le nombre de tranches ou le nombre de bits par tranche, la probabilité de faux positifs diminue.

Il s'ensuit également qu'à mesure que des éléments sont ajoutés, plus de bits sont mis à 1, donc les faux positifs augmentent. Nous appelons cela le "taux de remplissage" de chaque tranche.

Lorsque le filtre contient une grande quantité de données, nous pouvons supposer que la probabilité de faux positifs pour ce filtre est le rapport de remplissage élevé au nombre de tranches (si nous devions réellement compter les bits au lieu d'utiliser un rapport, cela se simplifie en une permutation avec problème de répétition).

Alors, comment pouvons-nous comprendre comment choisir une probabilité de faux positifs dans un filtre de bloom? Nous pouvons modifier le nombre de tranches (ce qui affectera le taux de remplissage).

Pour déterminer le nombre de tranches que nous devrions avoir, nous commençons par déterminer le taux de remplissage optimal pour une tranche. Étant donné que le taux de remplissage est déterminé par le nombre de bits dans une tranche qui sont 1 par rapport au nombre de bits qui sont 0, nous pouvons déterminer que chaque bit restera non défini avec une probabilité de (100% - (1 / bits dans une tranche) ). Puisque nous allons avoir plusieurs éléments insérés, nous avons une autre permutation avec un problème de réputation et nous étendons les choses au taux de remplissage attendu, qui est (100% - ((100% - (1 / bits dans une tranche)) ^ "éléments insérés")). Eh bien, il s'avère que c'est très similaire à une autre équation. Dans l'article, ils relient le taux de remplissage à une autre équation, de sorte qu'il s'intègre bien dans une série de taylor (1-e ^ (- n / m)). Après un peu de futzing avec cela, il s'avère que le taux de remplissage optimal est toujours d'environ 50%,

Donc, comme la probabilité d'un filtre est le rapport de remplissage élevé au nombre de tranches, nous pouvons remplir 50% et obtenir P = (50%) ^ k ou k = log_2 (1 / P). Nous pouvons ensuite utiliser cette fonction pour calculer le nombre de tranches que nous devons générer pour un filtre donné dans la liste des filtres pour un filtre de bloom évolutif.

    def slices_count(false_positive_probability):
        return math.ceil(math.log(1 / false_positive_probability, 2))

Edit: Après avoir écrit ceci, je suis tombé sur une mention de la "règle des cinquante pour cent" lors de la lecture de l'allocation de mémoire dynamique basée sur le système de copains dans TAoCP Vol 1, pp 442-445 avec un raisonnement beaucoup plus propre que l'ajustement de la courbe à (1 -e ^ (- n / m)). Knuth fait également référence à un article "La règle des cinquante pour cent revisité" avec un peu de contexte sur le concept ( pdf disponible ici ).

Un élément se trouve dans le filtre de bloom évolutif si un filtre renvoie true. Par conséquent, vous pouvez ajouter des filtres sans affecter les requêtes d'adhésion pour les éléments précédents.

Pour vous assurer d'avoir toujours une garantie de faux positifs dans le pire des cas, de nouveaux filtres sont ajoutés avec des taux de faux positifs qui diminuent géométriquement. Par exemple, le premier filtre a un taux de faux positif p, la deuxième rp, la troisième r^2p, etc. La probabilité d'un faux positif sur le filtre bloom évolutive est alors limitée par le syndicat lié: sum_{k>=0} r^k p = p/(1-r).

Je lisais sur les filtres de floraison évolutifs et ne pouvais pas comprendre comment chaque fois qu'un filtre de floraison constitutif se remplit, un nouveau filtre de floraison avec une plus grande taille est ajouté.

La présence des éléments qui ont contribué aux bits définis dans les filtres créés initialement ne peut pas être recherchée. Peut-être que je me trompe dans ma compréhension de cela?

Salut,
L'idée de base est d'ajouter au premier filtre jusqu'à ce que le champ de bits du filtre de premier niveau soit saturé. Être saturé ne signifie pas que chaque bit est utilisé, mais cela signifie que le filtre contient tellement d'entrées que des entrées supplémentaires créeraient trop de faux positifs.

Du point de saturation, tout nouvel élément ne sera pas ajouté au filtre saturé, mais à un sous-filtre frais et plus grand (le filtre de deuxième niveau).

Afin de trouver une valeur, vous devez la rechercher dans le filtre de premier niveau, et si vous ne la trouvez pas, vous la chercherez dans le filtre de second niveau. Si vous pouvez le trouver dans l'un de ces filtres, il est (par chance) "connu" du filtre (des faux positifs peuvent survenir en raison de la nature des filtres Bloom). Si vous ne trouvez la valeur dans aucun des filtres, le filtre est garanti de ne pas l'avoir vu. Ceci, bien sûr, peut être exprimé comme une structure de données récursive.

Vous voudrez peut-être lire mon article de blog qui contient une implémentation du filtre Bloom évolutif en Java et une explication détaillée de son fonctionnement.