布隆过滤器原理应用场景推导及Go实现

Bloom Filter（布隆过滤器）

布隆过滤器是一种多哈希函数映射的快速查找算法，通常应用在一些需要快速判断某个元素是否属于集合，但并不严格要求100%正确的场合。

Bloom算法类似一个hash set，用来判断某个元素（key）是否在某个集合中。
和一般的hash set不同的是，这个算法无需存储key的值，对于每个key，只需要k个比特位，每个存储一个标志，用来判断key是否在集合中。
布隆过滤器可能会出现误判，但不会漏判。即，如果过滤器判断该元素不在集合中，则元素一定不在集合中，但如果过滤器判断该元素在集合中，有一定的概率判断错误（在合适的参数情况下，误判率可以降低到0.000级别甚至更低）。

因此，Bloom Filter不适合那些“零错误”的应用场合。而在能容忍低错误率的应用场合下，Bloom Filter相比于其他常见的算法极大节省了空间（相较于直接存储，可节省上千倍的空间）。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是存在误识别率和删除困难。

优点:

相比于其它的数据结构，布隆过滤器在空间和时间方面都有巨大的优势。布隆过滤器存储空间和插入/查询时间都是常数。另外, Hash 函数相互之间没有关系，方便由硬件并行实现。布隆过滤器不需要存储元素本身，在某些对保密要求非常严格的场合有优势。
布隆过滤器可以表示全集，其它任何数据结构都不能；
k 和 m 相同，使用同一组 Hash 函数的两个布隆过滤器的交并差运算可以使用位操作进行。

不需要存储key，节省空间

缺点：

但是布隆过滤器的缺点和优点一样明显。误算率（False Positive）是其中之一。随着存入的元素数量增加，误算率随之增加。但是如果元素数量太少，则使用散列表足矣。
另外，一般情况下不能从布隆过滤器中删除元素. 我们很容易想到把位列阵变成整数数组，每插入一个元素相应的计数器加1, 这样删除元素时将计数器减掉就可以了。然而要保证安全的删除元素并非如此简单。首先我们必须保证删除的元素的确在布隆过滤器里面. 这一点单凭这个过滤器是无法保证的。另外计数器回绕也会造成问题。

算法判断key在集合中时，有一定的概率key其实不在集合中
无法删除

典型的应用场景：

某些存储系统的设计中，会存在空查询缺陷：当查询一个不存在的key时，需要访问慢设备，导致效率低下。
比如一个前端页面的缓存系统，可能这样设计：先查询某个页面在本地是否存在，如果存在就直接返回，如果不存在，就从后端获取。但是当频繁从缓存系统查询一个页面时，缓存系统将会频繁请求后端，把压力导入后端。

这是只要增加一个bloom算法的服务，后端插入一个key时，在这个服务中设置一次
需要查询后端时，先判断key在后端是否存在，这样就能避免后端的压力。

网页黑名单
垃圾邮件过滤
电话黑名单
url去重
Redis缓存穿透
比特币钱包查询
内容推荐等

算法步骤：

首先需要k个hash函数，每个函数可以把key散列成为1个整数
初始化时，需要一个长度为n比特的数组，每个比特位初始化为0
某个key加入集合时，用k个hash函数计算出k个散列值，并把数组中对应的比特位置为1
判断某个key是否在集合时，用k个hash函数计算出k个散列值，并查询数组中对应的比特位，如果所有的比特位都是1，认为在集合中。

首先需要用到 bitset? 和计算hash 的2个库。

import(
	"github.com/willf/bitset"	//bitset
	"github.com/spaolacci/murmur3" //hash计算
	"math"
)

哈希函数 - Murmur hash3

murmur hash是一种非加密型哈希函数，适用于一般的哈希检索操作。对于规律性较强的key，murmurhash的随机分布特征表现更良好。相比于md5，murmur hash在万次测试中，性能高4-5倍。
在这里插入图片描述

下面定义布隆过滤器的基础结构。

type BloomFilter struct {
	m uint			//布隆过滤器key的个数
	k uint			//hash函数的个数
	b *bitset.BitSet //所有value
}
//比大小
func max(x,y uint)uint{
	if x > y {
		return x
	}
	return y
}

新建一个布隆过滤器,mSet 就是一个存储 10101101 的数组而要判断一个键,存在与否就是找到散列在这个mSet上的值是否都设置为了1,但现实中的数据分布肯恩个会非常不均匀导致有些位的重复率特别高这样会影响,查询寻得准确率导致一些没有的键也能被查到，所以需要用到散列函数,将数字或者文本散列在一个列表各个bit上,同时由于文本不能存储在bitset中,所以hash函数还能帮助文本进行去重。
在这里插入图片描述

func NewBloomFilter(m uint,k uint) *BloomFilter{
	return &BloomFilter{
		m: max(1,m), //最小1个
		k: max(1,k),//同理
		b: bitset.New(m),//bitmap
	}
}

根据数据量新建布隆过滤器,每多加一个数容量就会添加64.

func From(data []uint,k uint)*BloomFilter{
	m := uint(len(data)*64)
	return &BloomFilter{
		m: m,
		k: k,
		b: bitset.From(data),
	}
}

在这里插入图片描述
如上图存放一个字符串先将字符串hash 成 k = 3 个 hash整数存在了 HashSet中。这所以用多个Hash 确认一个Key主要是可以减少误判(不存在的Key 判断为了存在)的概率。

给定数据返回四个 hash的整数

func bashHashes(data []byte) [4]uint64{
	X := []byte{1}
	haser := murmur3.New128() //128的hash 2^128
	haser.Write(data)	//2个整数 1578830625359084202 6865968778589710305
	v1,v2 := haser.Sum128()
	haser.Write(X)
	v3,v4 := haser.Sum128() // 2个整数 
	return [4]uint64{v1,v2,v3,v4}	//返回四个整数
}

下面就是输入上面生成的四个随机hash整数,然后通过运算可以生成K个整数,用于散列在bitset上。

func (f *BloomFilter) location(h [4]uint64,i uint) uint{
	//对计算处的位置 求余 找到 布隆过滤器中的位置
	return uint(location(h,i) % uint64(f.m))
}
//
func location(h [4]uint64,i uint) uint64{
	ii := uint64(i)
	//hash 这个公式 是将 4 个 uint64 和 i 进行计算  传入不同的i 可以算出不同的Hash i是 0 ~ k 个 。
	return h[ii %2] + ii*h[2+(((ii+(ii % 2))%4)/2)]
}

重复出现的概率

布隆过滤器出现误判的几率和他的大小是有关的,假设布隆过滤器有 m个元素,n个元素,每个元素散列 k个信息指纹的哈希函数。每一个 bit位被置为 1的概率p(a)是一样的: $P(a) = \frac{1}{m}$ ,所以每一位上不为0的概率为 $1 - p(a) = 1 - \frac{1}{m}$ 那么对于散列在HashSet上确定一个key的 K个散列值,不为0的概率为 $(1 - \frac{1}{m})^k$ ,假设第二个键插入到hashSet中,不重复的概率为 $(1 - \frac{1}{m})^k · (1 - \frac{1}{m})^k = (1 - \frac{1}{m})^{2k}$ 同理可得,
如果有N个不同的键通过K个散列Hash插入到大小为M的hashSet中某个位不重复的概率为: $(1 - \frac{1}{m})^{kn}$ ,
再取反,在插入了N的Key后某一位不重复的概率为: $1-(1- \frac{1}{m})^{kn}$ ,
假设来了一个新的Key 要让他误判成Key已经存在,相当于要让k位hash散列Bit都在已有的表中出现,而某一位重复出现的概率就是上面的公式,那么K位重复的概率就是： $(1-(1- \frac{1}{m})^{kn})^{k} ≈ (1 - e^{\frac{kn}{m}})^k$ ,

推理过程为,当n比较大时,

引入一个我们很熟悉的公式: $(1 - \frac{1}{m})^{-m} ≈ e$ 大学都应该有学过。

所以可以变形为:

$(1 - e ^{\frac{-kn}{m}})^k$ 。

接下来假设错误率 $p(e) = (1 - e ^{\frac{-kn}{m}})^k$

对公示两边取自然对数:

$lnp = kln(1 - e ^{\frac{-kn}{m}})$

然后再进行求导：

$= \frac{\partial{kln}(1 - e ^{\frac{-kn}{m}})}{\partial{k}}$ = $ln(1 - e^{\frac{-kn}{m}}) + k\frac{\frac{n}{m}e^{\frac{-kn}{m}}}{1 - e^{\frac{-kn}{m}}}$
$\frac{\partial{lnp}}{\partial{k}} = ln(1 - x) - \frac{x}{1-x}$
设 $x = e ^{\frac{-kn}{m}}$ $则 $k = \frac{-m}{n}lnx$
得 : $\frac{\partial{lnp}}{\partial{k}} = ln(1 -x) - \frac{x} {1-x} * lnx$

对 $\frac{\partial{lnp}}{\partial{k}}$ 取极限0, $x = \frac{1}{2}$ 最后解得 k 为: $\frac{m}{n}ln2$

当hash函数个数 k = ln2 * m / n 时错误率最小。

以下是不同m/n 情况下不同多个k 出现误判的几率:
在这里插入图片描述
布隆过滤器论文

对于给定错误率 p,如何选择最优的位数的数组大小呢?
$m = -\frac{nlnp}{(ln2)^2}$
用来计算最合适的k个hash $k=\frac{m}{n}ln2$

假设有 10 亿数据错误率 0.01% 那要多少空间呢?

让我们来算一算下面是python代码:

import math
n = 1000000000
p = 0.0001
m = -(n *math.log(p,math.e)/(math.log(2,math.e ) ** 2))
k = m/n * math.log(2,math.e ) 
m = m / 8 / 1024 /1024 / 1024

在这里插入图片描述
计算结果为 M为 2 .2 个G 左右 K 为 13 。这种情况下 10亿个数据也就会误判1万个左右而且只用了 2个G 还是可以接受的。

下面用Go实现这两个公式,用来估计假阳性(不存在但查出来是存在)的概率和用k个Hash 来存储一个key k的取值最合适的值。

func EStamatewithParameters(n uint,p float64) (m uint,k uint){
	m = uint(math.Ceil( -1 * float64(n) * math.Log(p)) / math.Pow(math.Log(2),2))
	k = uint(math.Ceil(math.Log(2) * float64(m)/float64(n)))
	return m,k
}

//得到 多少蛇值多少个hash
func (f *BloomFilter)K()uint{
	return f.k //hash
}

//包含的key大小
func (f *BloomFilter)Cap()uint{
	return f.m//布隆过滤器存放的数据量
}

func (f *BloomFilter)Add(data []byte)*BloomFilter{
	h := bashHashes(data)//计算哈希
	for i:= uint(0);i<f.k;i++{
		f.b.Set(f.location(h,i)) //设置数据
	}
	return f
}


//新建一个布隆过滤器,预估数据规模
func NewwithEstimates(n uint,p float64) *BloomFilter{
	m,k := EStamatewithParameters(n,p)
	return NewBloomFilter(m,k)
}

下面的代码通过循环K次,通过f.location这个Hash计算函数计算出 f.k 个位置,设置到 bitset中。

func (f *BloomFilter)Add(data []byte)*BloomFilter{
	//生成hash
	h := bashHashes(data)
	//循环k 次生成hash
	for i:= uint(0);i<f.k;i++{
		//把hash函数映射到对应的位置
		f.b.Set(f.location(h,i))
	}
	return f
}

合并就是把 2 个 bitSet 合在一起,其实也就是执行或操作。
在这里插入图片描述

func (f *BloomFilter) Merge(g *BloomFilter)error{
	if f.m != g.m{
		return fmt.Errorf("大小不一样!")
	}
	if f.k != g.k{
		return fmt.Errorf("Key不一样!")
	}
	f.b.InPlaceUnion(g.b) //归并 bitset
	return nil
}

完整版:

type BloomFilter struct {
	m uint //容量
	k uint //hash函数个数
	b *bitset.BitSet
}

func max(x,y uint)uint{
	if x > y {
		return x
	}
	return y
}
//新建一个布隆 过滤器
func NewBloomFilter(m uint,k uint) *BloomFilter{
	return &BloomFilter{
		m: max(1,m),
		k: max(1,k),
		b: bitset.New(m),
	}
}
//根据数据量新建布隆过滤器
func From(data []uint64,k uint)*BloomFilter{
	m := uint(len(data)*64)
	return &BloomFilter{
		m: m,
		k: k,
		b: bitset.From(data),
	}
}
//对字符串进行hash
func bashHashes(data []byte) [4]uint64{
	X := []byte{1}
	haser := murmur3.New128() //128的hash 2^128
	haser.Write(data)
	v1,v2 := haser.Sum128()
	haser.Write(X)
	v3,v4 := haser.Sum128()
	return [4]uint64{v1,v2,v3,v4}
}

func location(h [4]uint64,i uint) uint64{
	ii := uint64(i)
	return h[ii %2] + ii*h[2+(((ii+(ii % 2))%4)/2)]
}

func (f *BloomFilter) location(h [4]uint64,i uint) uint{
	return uint(location(h,i) % uint64(f.m))
}

func EStamatewithParameters(n uint,p float64) (m uint,k uint){
	m = uint(math.Ceil( -1 * float64(n) * math.Log(p)) / math.Pow(math.Log(2),2))
	k = uint(math.Ceil(math.Log(2) * float64(m)/float64(n)))
	return m,k
}


//新建一个布隆过滤器,预估数据规模
func NewwithEstimates(n uint,p float64) *BloomFilter{
	m,k := EStamatewithParameters(n,p)
	return NewBloomFilter(m,k)
}

func (f *BloomFilter)K()uint{
	return f.k //hash
}

func (f *BloomFilter)Cap()uint{
	return f.m//数量
}

func (f *BloomFilter)Add(data []byte)*BloomFilter{
	h := bashHashes(data)
	for i:= uint(0);i<f.k;i++{
		f.b.Set(f.location(h,i))
	}
	return f
}

func (f *BloomFilter) Merge(g *BloomFilter)error{
	if f.m != g.m{
		return fmt.Errorf("大小不一样!")
	}
	if f.k != g.k{
		return fmt.Errorf("Key不一样!")
	}
	f.b.InPlaceUnion(g.b) //归并 bitset
	return nil
}
//拷贝新建一个布隆过滤器
func (f *BloomFilter)Copy() *BloomFilter{
	fc := NewBloomFilter(f.m,f.k)
	fc.Merge(f)
	return fc
}

func (f *BloomFilter)AddString(data string)*BloomFilter{
	return f.Add([]byte(data))
}

func (f *BloomFilter)Test(data []byte) bool{
	h := bashHashes(data)
	for i:= uint(0);i < f.k;i++{
		if !f.b.Test(f.location(h,i)){
			return false
		}
	}
	return true
}
func (f *BloomFilter)TestString(data []byte) bool{
	return f.Test([]byte(data))
}
//测试整数 是否存在
func (f *BloomFilter)TestLocations(locs []uint64) bool{
	for i := 0;i<len(locs);i++{
		if !f.b.Test(uint(locs[i] % uint64(f.m))){
			return false
		}
	}
	return true
}


//测试是否存在,存在就更新
func (f *BloomFilter)TestAndAdd(data []byte) bool{
	isin := true
	h := bashHashes(data)
	for i := uint(0);i<f.k;i++{
		if !f.b.Test(f.location(h,i)){
			isin = false
		}
		f.b.Set(1)
	}
	return isin
}

//布隆过滤器的
type BloomFilterJson struct{
	M uint  `json:"m"`
	K uint  `json:"k"`
	B *bitset.BitSet  `json:"b"`
}
//字节转对象
func (f *BloomFilter)MarshaJson() ([]byte,error){
	return json.Marshal(BloomFilterJson{f.m,f.k,f.b})
}
//字节转对象
func (f *BloomFilter)UnMarshaJson(data []byte) (error){
	var j BloomFilterJson
	err := json.Unmarshal(data,&j)
	if err != nil{
		return err
	}
	f.m = j.M
	f.k = j.K
	f.b = j.B
	return nil
}
func (f *BloomFilter)Writeto(stream io.Writer)(int64,error){
	err := binary.Write(stream,binary.BigEndian,uint64(f.m))
	if err != nil{
		return 0,err
	}
	err = binary.Write(stream,binary.BigEndian,uint64(f.k))
	if err != nil{
		return 0,err
	}
	bumbytes ,err := f.b.WriteTo(stream)
	return bumbytes + int64(2 * binary.Size(uint64(0))),err
}
func (f *BloomFilter)Readfrom(stream io.Reader)(int64,error){
	var m,k uint64
	err := binary.Read(stream,binary.BigEndian,&m)
	if err != nil{
		return 0,err
	}
	err = binary.Read(stream,binary.BigEndian,&k)
	if err != nil{
		return 0,err
	}
	b := &bitset.BitSet{}
	f.m = uint(m)
	f.k = uint(k)
	f.b = b
	numbyte,err := b.ReadFrom(stream)
	return numbyte + int64(2 *binary.Size(uint64(0))),err
}

func (f *BloomFilter) GoDecode(data []byte) (error){
	buf := bytes.NewBuffer(data)
	_,err := f.Readfrom(buf)
	return err
}
func (f *BloomFilter) GoEncode() ([]byte,error){
	var buf bytes.Buffer
	_,err := f.Writeto(&buf)
	if err != nil{
		return nil,err
	}
	return buf.Bytes(),nil
}
func locations(data []byte,k uint) []uint64{
	locs := make([]uint64,k)
	h := bashHashes(data)
	for i:= uint(0);i<k;i++{
		locs[i] = location(h,i)
	}
	return locs
}


//判断布隆过滤器是否相等
func (f *BloomFilter) Equal (g *BloomFilter) bool{
	return f.m == g.m && f.k == g.k && f.b.Equal(g.b)
}


//测试是否存在,存在就更新
func (f *BloomFilter)TestAndAddString(data []byte) bool{
	return f.TestAndAdd([]byte(data))
}
//清空布隆过滤器
func (f *BloomFilter)Clear() *BloomFilter{
	f.b.ClearAll()
	return  f
}
//测试正确率
func (f*BloomFilter)EstimateFalsePositiveRate(n uint,rounds uint32)(fpRate float64){
	f.Clear()
	n1:=make([]byte,4)//开辟字节数组
	for i:=uint32(0);i<uint32(n);i++{ 
		binary.BigEndian.PutUint32(n1,i)
		f.Add(n1)//循环n次生成字节加入 布隆过滤器
	}
	fp:=0
	for i:=uint32(0);i<rounds;i++{ //这里生成 数据测试 是不是在布隆过滤器里
		binary.BigEndian.PutUint32(n1,i+uint32(n)+1)
		if f.Test(n1) {
			fp++
		}

	}
	fpRate=float64(fp)/float64(rounds)//正确率
	f.Clear()
	return


}

测试代码:

f:=NewwithEstimates(100000000,0.001) //计算 1亿个数据 错误率为 0.001的情况下 m 和 k的值 并创建布隆过滤器
n1:=[]byte("123123")
n2:=[]byte("sdfsdf")
n3:=[]byte("dsfsdf")
n4:=[]byte("caomaoboy7777")
n5:=[]byte("helloworld")
f.Add(n1)
f.Add(n2)
f.Add(n3)
//这里测试序列化
data,_ := f.MarshaJson()
var g BloomFilter
err := g.UnMarshaJson(data)
if err != nil{
	fmt.Println("error!")
}
fmt.Println(f.Test(n1))
fmt.Println(f.Test(n3))
fmt.Println(f.Test(n4))
fmt.Println(f.Test(n5))
fmt.Println(f.Test(n3))
f.Clear()
fmt.Println(f.EstimateFalsePositiveRate(100000000)) //测试 插入100000000  如果正确的话 会输出 0.001左右的值

---------

在这里插入图片描述
和设置的正确率是一样的说明代码没什么问题。

参考:
吴军 – 《数学之美》
详解布隆过滤器（Bloomfilter）+scrapy分布式持久化去重 ----https://www.jianshu.com/p/e4773b69319d
详解布隆过滤器的原理、使用场景和注意事项 ----- https://www.jianshu.com/p/2104d11ee0a2
[算法系列之十]大数据量处理利器：布隆过滤器 -------https://yq.aliyun.com/articles/3607
Google算法工程师尹成带你深度学习数据结构与算法导论-----https://edu.51cto.com/course/20394.html?source=so

草帽boy7

发布了85 篇原创文章 · 获赞 5 · 访问量 4688

私信关注