BloomFilter原理及实现

BloomFilter原理及实现
题外话：
很久没写博客了，因为前⼀段时间过年在家放假，⼜因为⾃⼰保研了，所以⼀直⽐较闲。

整个假期，基本都在准备毕业设计的相关内容。

我毕业设计的⽅向是关于搜索引擎的，因此，期间阅读了⼤量相关论⽂。

阅读了很多论⽂和技术书籍之后，我有⼏点感触。

⾸先，发现国内很多论⽂或是书籍只是⼤量引述其他⼈的研究结果，⾃⼰的独特的见解⾮常少，⼀篇⽂章，70%的内容都是在以介绍为主，感觉发这样的论⽂是没有什么意义的。

相反，国外尤其是像MIT，斯坦福，google之类的领域专家发表很多极其优秀的论⽂，阅读后给⼈⼀种震撼。

我之前在⽹上搜索技术⽂章或是论⽂的时候经常绕过英⽂的，现在发现国外的确有⾮常多优秀的外⽂⽂章，所以⽆障碍英⽂阅读能⼒是提升⾃⼰专业⽔平的重要因素。

我现在已经逐渐习惯阅读外⽂⽂章和书籍。

期间，我还翻译了⼀篇关于⽹络信息采集和索引的外⽂⽂章，收获很⼤。

不是因为，我从中获得了多少知识，⽽是在翻译的过程中，我了解了作者精⼼的设计思路以及严谨的语⾔表达，也锻炼了我翻译的能⼒以及组织语⾔的能⼒。

废话不多说了，开始正题，写个在爬⾍系统中常⽤的URL去重经典算法Bloom Filter.
正题：
Bloom Filter概念和原理
Bloom Filter概念和原理
焦萌 2007年1⽉27⽇
Bloom Filter是⼀种空间效率很⾼的随机数据结构，它利⽤位数组很简洁地表⽰⼀个集合，并能判断⼀个元素是否属于这个集合。

Bloom Filter的这种⾼效是有⼀定代价的：在判断⼀个元素是否属于某个集合时，有可能会把不属于这个集合的元素误认为属于这个集合（false positive）。

因此，Bloom Filter不适合那些“零错误”的应⽤场合。

⽽在能容忍低错误率的应⽤场合下，Bloom Filter通过极少的错误换取了存储空间的极⼤节省。

集合表⽰和元素查询
下⾯我们具体来看Bloom Filter是如何⽤位数组表⽰集合的。

初始状态时，Bloom Filter是⼀个包含m位的位数组，每⼀位都置为0。

为了表达S={x1, x2,…,x n}这样⼀个n个元素的集合，Bloom Filter使⽤k个相互独⽴的哈希函数（Hash Function），它们分别将集合中的每个元素映射到{1,…,m}的范围中。

对任意⼀个元素x，第i个哈希函数映射的位置h i(x)就会被置为1（1≤i≤k）。

注意，如果⼀个位置多次被置为1，那么只有第⼀次会起作⽤，后⾯⼏次将没有任何效果。

在下图中，k=3，且有两个哈希函数选中同⼀个位置（从左边数第五位）。

在判断y是否属于这个集合时，我们对y应⽤k次哈希函数，如果所有h i(y)的位置都是1（1≤i≤k），那么我们就认为y是集合中的元素，否则就认为y不是集合中的元素。

下图中y1就不是集合中的元素。

y2或者属于这个集合，或者刚好是⼀个false positive。

错误率估计
前⾯我们已经提到了，Bloom Filter在判断⼀个元素是否属于它表⽰的集合时会有⼀定的错误率（false positive rate），下⾯我们就来估计错误率的⼤⼩。

在估计之前为了简化模型，我们假设kn<m且各个哈希函数是完全随机的。

当集合S={x1, x2,…,x n}的所有元素都被k个哈希函数映射到m位的位数组中时，这个位数组中某⼀位还是0的概率是：
其中1/m表⽰任意⼀个哈希函数选中这⼀位的概率（前提是哈希函数是完全随机的），(1-1/m)表⽰哈希⼀次没有选中这⼀位的概率。

要把S完全映射到位数组中，需要
做kn次哈希。

某⼀位还是0意味着kn次哈希都没有选中它，因此这个概率就是（1-1/m）的kn次⽅。

令p = e-kn/m是为了简化运算，这⾥⽤到了计算e时常⽤的近似：
令ρ为位数组中0的⽐例，则ρ的数学期望E(ρ)= p’。

在ρ已知的情况下，要求的错误率（false positive rate）为：
(1-ρ)为位数组中1的⽐例，(1-ρ)k就表⽰k次哈希都刚好选中1的区域，即false positive rate。

上式中第⼆步近似在前⾯已经提到了，现在来看第⼀步近似。

p’只是ρ的数学期望，在实际中ρ的值有可能偏离它的数学期望值。

M. Mitzenmacher已经证明[2]，位数组中0的⽐例⾮常集中地分布在它的数学期望值的附近。

因此，第⼀步的近似得以成⽴。

分别将p和p’代⼊上式中，得：
相⽐p’和f’，使⽤p和f通常在分析中更为⽅便。

最优的哈希函数个数
既然Bloom Filter要靠多个哈希函数将集合映射到位数组中，那么应该选择⼏个哈希函数才能使元素查询时的错误率降到最低呢？这⾥有两个互斥的理由：如果哈希函数的个数多，那么在对⼀个不属于集合的元素进⾏查询时得到0的概率就⼤；但另⼀⽅⾯，如果哈希函数的个数少，那么位数组中的0就多。

为了得到最优的哈希函数个数，我们需要根据上⼀⼩节中的错误率公式进⾏计算。

先⽤p和f进⾏计算。

注意到f = exp(k ln(1 − e−kn/m))，我们令g = k ln(1 − e−kn/m)，只要让g取到最⼩，f⾃然也取到最⼩。

由于p = e-kn/m，我们可以将g写成
根据对称性法则可以很容易看出当p = 1/2，也就是k = ln2· (m/n)时，g取得最⼩值。

在这种情况下，最⼩错误率f等于(1/2)k ≈ (0.6185)m/n。

另外，注意到p是位数组中某⼀位
仍是0的概率，所以p = 1/2对应着位数组中0和1各⼀半。

换句话说，要想保持错误率低，最好让位数组有⼀半还空着。

需要强调的⼀点是，p = 1/2时错误率最⼩这个结果并不依赖于近似值p和f。

同样对于f’ = exp(k ln(1 − (1 − 1/m)kn))，g’ = k ln(1 − (1 − 1/m)kn)，p’ = (1 − 1/m)kn，我们可以将g’写成
同样根据对称性法则可以得到当p’ = 1/2时，g’取得最⼩值。

位数组的⼤⼩
下⾯我们来看看，在不超过⼀定错误率的情况下，Bloom Filter⾄少需要多少位才能表⽰全集中任意n个元素的集合。

假设全集中共有u个元素，允许的最⼤错误率为є，下⾯我们来求位数组的位数m。

假设X为全集中任取n个元素的集合，F(X)是表⽰X的位数组。

那么对于集合X中任意⼀个元素x，在s = F(X)中查询x都能得到肯定的结果，即s能够接受x。

显然，由于Bloom Filter引⼊了错误，s能够接受的不仅仅是X中的元素，它还能够є (u - n)个false positive。

因此，对于⼀个确定的位数组来说，它能够接受总共n + є (u - n)个元素。

在n + є(u - n)个元素中，s真正表⽰的只有其中n个，所以⼀个确定的位数组可以表⽰
个集合。

m位的位数组共有2m个不同的组合，进⽽可以推出，m位的位数组可以表⽰
个集合。

全集中n个元素的集合总共有
个，因此要让m位的位数组能够表⽰所有n个元素的集合，必须有
即：
上式中的近似前提是n和єu相⽐很⼩，这也是实际情况中常常发⽣的。

根据上式，我们得出结论：在错误率不⼤于є的情况下，m⾄少要等于n log2(1/є)才能表⽰任意n个元素的集合。

上⼀⼩节中我们曾算出当k = ln2· (m/n)时错误率f最⼩，这时f = (1/2)k = (1/2)mln2 / n。

现在令f≤є，可以推出
这个结果⽐前⾯我们算得的下界n log2(1/є)⼤了log2 e ≈ 1.44倍。

这说明在哈希函数的个数取到最优时，要让错误率不超过є，m⾄少需要取到最⼩值的1.44倍。

总结
在计算机科学中，我们常常会碰到时间换空间或者空间换时间的情况，即为了达到某⼀个⽅⾯的最优⽽牺牲另⼀个⽅⾯。

Bloom Filter在时间空间这两个因素之外⼜引⼊了另⼀个因素：错误率。

在使⽤Bloom Filter判断⼀个元素是否属于某个集合时，会有⼀定的错误率。

也就是说，有可能把不属于这个集合的元素误认为属于这个集合（False Positive），但不会把属于这个集合的元素误认为不属于这个集合（False Negative）。

在增加了错误率这个因素之后，Bloom Filter通过允许少量的错误来节省⼤量的存储空间。

⾃从Burton Bloom在70年代提出Bloom Filter之后，Bloom Filter就被⼴泛⽤于拼写检查和数据库系统中。

近⼀⼆⼗年，伴随着⽹络的普及和发展，Bloom Filter在⽹络领域获得了新⽣，各种Bloom Filter变种和新的应⽤不断出现。

可以预见，随着⽹络应⽤的不断深⼊，新的变种和应⽤将会继续出现，Bloom Filter必将获得更⼤的发展。

参考资料
[1] A. Broder and M. Mitzenmacher. . Internet Mathematics, 1(4):485–509, 2005.
[2] M. Mitzenmacher. . IEEE/ACM Transactions on Networking 10:5 (2002), 604—612.
[3]
C++代码实现：
bloom类简单的实现了，add和check操作。

有关更强⼤的扩展功能，可以参考Google code⾥⾯的⼀个bloom filter库，它⽀持了有关集合的相关操作。

1/*
2 * bloom.h
3 *
4 * Created on: 2012-2-22
5 * Author: xiaojay
6*/
7
8 #ifndef BLOOM_H_
9#define BLOOM_H_
10 #include <vector>
11 #include "hashFun.h"
12
13class Bloom
14 {
15public :
16 Bloom(int size , std::vector<HashFun*> hashfunclist );
17 ~Bloom();
18void add(const char * text);
19bool check(const char * text);
20
21private :
22const static int CHARBITSIZE = 8;
23int size;
24char * arr;
25 std::vector<HashFun*> hashfunclist;
26 inline void setbit(long pos);
27 inline bool getbit(long pos);
28 };
29
30#endif /* BLOOM_H_ */
31
32 #include"bloom.h"
33 #include<assert.h>
34
35 Bloom::Bloom(int size , std::vector<HashFun*> hashfunclist)
36 {
37 assert(hashfunclist.size()>0);
38this->size = size;
39this->hashfunclist = hashfunclist;
40this->arr = new char [size];
41 }
42
43 Bloom::~Bloom()
44 {
45if(this->arr!=NULL)
46 {
47 delete this->arr;
48 }
49 }
50
51void Bloom::add(const char * text)
52 {
53int nfunc = hashfunclist.size();
54long code = 0;
55for(int i=0;i<nfunc;i++)
56 {
57 code = hashfunclist.at(i)->gethashval(text);
58
59if(code/CHARBITSIZE>size) return;
60else
61 {
62 setbit(code);
63 }
64 }
65 }
66
67bool Bloom::check(const char * text)
68 {
69int nfunc = hashfunclist.size();
70long code = 0;
71for (int i=0;i<nfunc;i++)
72 {
73 code = hashfunclist.at(i)->gethashval(text);
74if(code/CHARBITSIZE>size) return false;
75else
76 {
77 if getbit(code) continue;
else return false;
78 }
79 }
return true;
80 }
81
82 inline void Bloom::setbit(long code)
83 {
84 arr[code/CHARBITSIZE] |= (1<<(code%CHARBITSIZE));
85 }
86
87 inline bool Bloom::getbit(long code)
88 {
89if(!(arr[code/CHARBITSIZE] & (1<<(code%CHARBITSIZE))))
90 {
91return false;
92 }
93return true;
94 }
由于hash函数的数量以及类型都不确定，所以我们创建⼀个抽象类HashFun，⾃定义的hash函数需要继承并实现其HashFun的gethashval ⽅法。

#ifndef HASHFUN_H_
#define HASHFUN_H_
class HashFun
{
public :
virtual long gethashval(const char * key) = 0;
};
#endif /* HASHFUN_H_ */
最后我们写个简单的demo，测试⼀下。

⾸先我们⾃定义两个hash函数HashFunA，HashFunB。

#include "hashFun.h"
class HashFunA : public HashFun
{
public:
virtual long gethashval(const char * key)
{
unsigned int h=0;
while(*key) h^=(h<<5)+(h>>2)+(unsigned char)*key++;
return h%80000;
}
};
#include"hashFun.h"
class HashFunB : public HashFun
{
public:
virtual long gethashval(const char * key)
{
unsigned int h=0;
while(*key) h=(unsigned char)*key++ + (h<<6) + (h<<16) - h;
return h%80000;
}
};
Main函数：
#include<iostream>
#include<stdio.h>
#include"hashFunA.h"
#include"hashFunB.h"
#include"bloom.h"
#include<vector>
using namespace std;
int main()
{
/*
* Create two hash functions
*/
HashFunA *funa = new HashFunA();
HashFunB * funb = new HashFunB();
vector<HashFun*> hashfunclist;
hashfunclist.push_back(funa);
hashfunclist.push_back(funb);
/*
* Create Bloom object with two parameters :
* size of the store array and list of hash functions
*/
Bloom bloom(10000,hashfunclist);
///Add some words to bloom filter
bloom.add("hello");
bloom.add("world");
bloom.add("ipad");
bloom.add("iphone4");
bloom.add("ipod");
bloom.add("apple");
bloom.add("banana");
bloom.add("hello");
/*
* Test
*/
char word[20];
while(true)
{
cout<<"Please input a word : "<<endl;
cin>>word;
if(bloom.check(word))
{
cout<<"Word :"<<word<<" has been set in bloom filter."<<endl;
}
else
{
cout<<"Word :"<<word<<" not exist !" <<endl;
}
}
return0;
}
总结：
Bloom Filter的基本实现很简单，但是其原理和思路是⾮常出⾊的。

这个可以应⽤到URL去重或是某些缓存系统上。

在很多⾯试题⾥⾯，也会出现类似⼤数据量下去重或是筛选的问题，采⽤Bloom Filter算法就可以很轻松的解决了。