海量數據處理算法—Bloom Filter

時間 2019-12-05

原文原文鏈接

1. Bloom-Filter算法簡介

Bloom-Filter，即布隆過濾器，1970年由Bloom中提出。它能夠用於檢索一個元素是否在一個集合中。ios

Bloom Filter（BF）是一種空間效率很高的隨機數據結構，它利用位數組很簡潔地表示一個集合，並能判斷一個元素是否屬於這個集合。它是一個判斷元素是否存在集合的快速的機率算法。Bloom Filter有可能會出現錯誤判斷，但不會漏掉判斷。也就是Bloom Filter判斷元素再也不集合，那確定不在。若是判斷元素存在集合中，有必定的機率判斷錯誤。所以，Bloom Filter不適合那些「零錯誤」的應用場合。而在能容忍低錯誤率的應用場合下，Bloom Filter比其餘常見的算法（如hash，折半查找）極大節省了空間。算法

它的優勢是空間效率和查詢時間都遠遠超過通常的算法，缺點是有必定的誤識別率和刪除困難。數據庫

Bloom Filter的詳細介紹：Bloom Filter數組

二、 Bloom-Filter的基本思想

Bloom-Filter算法的核心思想就是利用多個不一樣的Hash函數來解決「衝突」。服務器

計算某元素x是否在一個集合中，首先能想到的方法就是將全部的已知元素保存起來構成一個集合R，而後用元素x跟這些R中的元素一一比較來判斷是否存在於集合R中；咱們能夠採用鏈表等數據結構來實現。可是，隨着集合R中元素的增長，其佔用的內存將愈來愈大。試想，若是有幾千萬個不一樣網頁須要下載，所需的內存將足以佔用掉整個進程的內存地址空間。即便用MD5，UUID這些方法將URL轉成固定的短小的字符串，內存佔用也是至關巨大的。網絡

因而，咱們會想到用Hash table的數據結構，運用一個足夠好的Hash函數將一個URL映射到二進制位數組（位圖數組）中的某一位。若是該位已經被置爲1，那麼表示該URL已經存在。數據結構

Hash存在一個衝突（碰撞）的問題，用同一個Hash獲得的兩個URL的值有可能相同。爲了減小衝突，咱們能夠多引入幾個Hash，若是經過其中的一個 Hash值咱們得出某元素不在集合中，那麼該元素確定不在集合中。只有在全部的Hash函數告訴咱們該元素在集合中時，才能肯定該元素存在於集合中。這便是Bloom-Filter的基本思想。ide

原理要點：一是位數組，而是k個獨立hash函數。函數

1）位數組：性能

假設Bloom Filter使用一個m比特的數組來保存信息，初始狀態時，Bloom Filter是一個包含m位的位數組，每一位都置爲0，即BF整個數組的元素都設置爲0。

2）添加元素，k個獨立hash函數

爲了表達S={x₁, x₂,…,x_n}這樣一個n個元素的集合，Bloom Filter使用k個相互獨立的哈希函數（Hash Function），它們分別將集合中的每一個元素映射到{1,…,m}的範圍中。

當咱們往Bloom Filter中增長任意一個元素x時候，咱們使用k個哈希函數獲得k個哈希值，而後將數組中對應的比特位設置爲1。即第i個哈希函數映射的位置hash_i(x)就會被置爲1（1≤i≤k）。

注意，若是一個位置屢次被置爲1，那麼只有第一次會起做用，後面幾回將沒有任何效果。在下圖中，k=3，且有兩個哈希函數選中同一個位置（從左邊數第五位，即第二個「1「處）。

3）判斷元素是否存在集合

在判斷y是否屬於這個集合時，咱們只須要對y使用k個哈希函數獲得k個哈希值，若是全部hash_i(y)的位置都是1（1≤i≤k），即k個位置都被設置爲1了，那麼咱們就認爲y是集合中的元素，不然就認爲y不是集合中的元素。下圖中y₁就不是集合中的元素（由於y1有一處指向了「0」位）。y₂或者屬於這個集合，或者恰好是一個false positive。

顯然這個判斷並不保證查找的結果是100%正確的。

Bloom Filter的缺點：

1）Bloom Filter沒法從Bloom Filter集合中刪除一個元素。由於該元素對應的位會牽動到其餘的元素。因此一個簡單的改進就是 counting Bloom filter，用一個counter數組代替位數組，就能夠支持刪除了。此外，Bloom Filter的hash函數選擇會影響算法的效果。

2）還有一個比較重要的問題，如何根據輸入元素個數n，肯定位數組m的大小及hash函數個數，即hash函數選擇會影響算法的效果。當hash函數個數k=(ln2)*(m/n)時錯誤率最小。在錯誤率不大於E的狀況下，m至少要等於n*lg(1/E) 才能表示任意n個元素的集合。但m還應該更大些，由於還要保證bit數組裏至少一半爲0，則m應該>=nlg(1/E)*lge ，大概就是nlg(1/E)1.44倍(lg表示以2爲底的對數)。

舉個例子咱們假設錯誤率爲0.01，則此時m應大概是n的13倍。這樣k大概是8個。

注意：

這裏m與n的單位不一樣，m是bit爲單位，而n則是以元素個數爲單位(準確的說是不一樣元素的個數)。一般單個元素的長度都是有不少bit的。因此使用bloom filter內存上一般都是節省的。

通常BF能夠與一些key-value的數據庫一塊兒使用，來加快查詢。因爲BF所用的空間很是小，全部BF能夠常駐內存。這樣子的話，對於大部分不存在的元素，咱們只須要訪問內存中的BF就能夠判斷出來了，只有一小部分，咱們須要訪問在硬盤上的key-value數據庫。從而大大地提升了效率。

一個Bloom Filter有如下參數：

m	bit數組的寬度（bit數）
n	加入其中的key的數量
k	使用的hash函數的個數
f	False Positive的比率

Bloom Filter的f知足下列公式：

在給定m和n時，可以使f最小化的k值爲：

此時給出的f爲：

根據以上公式，對於任意給定的f，咱們有：

n = m ln(0.6185) / ln(f) [1]

同時，咱們須要k個hash來達成這個目標：

k = - ln(f) / ln(2) [2]

因爲k必須取整數，咱們在Bloom Filter的程序實現中，還應該使用上面的公式來求得實際的f：

f = (1 – e^-kn/m)^k [3]

以上3個公式是程序實現Bloom Filter的關鍵公式。

三、擴展 CounterBloom Filter

CounterBloom Filter

BloomFilter有個缺點，就是不支持刪除操做，由於它不知道某一個位從屬於哪些向量。那咱們能夠給Bloom Filter加上計數器，添加時增長計數器，刪除時減小計數器。

但這樣的Filter須要考慮附加的計數器大小，假如同個元素屢次插入的話，計數器位數較少的狀況下，就會出現溢出問題。若是對計數器設置上限值的話，會致使Cache Miss，但對某些應用來講，這並非什麼問題，如Web Sharing。

Compressed Bloom Filter

爲了能在服務器之間更快地經過網絡傳輸Bloom Filter，咱們有方法能在已完成Bloom Filter以後，獲得一些實際參數的狀況下進行壓縮。

將元素所有添加入Bloom Filter後，咱們能獲得真實的空間使用率，用這個值代入公式計算出一個比m小的值，從新構造Bloom Filter，對原先的哈希值進行求餘處理，在誤判率不變的狀況下，使得其內存大小更合適。

四、 Bloom-Filter的應用

Bloom-Filter一般用於在大數據量的集合中斷定某元素是否存在。例如郵件服務器中的垃圾郵件過濾器。在搜索引擎領域，Bloom-Filter最經常使用於網絡蜘蛛 (Spider)的URL過濾，網絡蜘蛛一般有一個URL列表，保存着將要下載和已經下載的網頁的URL，網絡蜘蛛下載了一個網頁，從網頁中提取到新的 URL後，須要判斷該URL是否已經存在於列表中。此時，Bloom-Filter算法是最好的選擇。

1.key-value 加快查詢

通常Bloom-Filter能夠與一些key-value的數據庫一塊兒使用，來加快查詢。

通常key-value存儲系統的values存在硬盤，查詢就是件費時的事。將Storage的數據都插入Filter，在Filter中查詢都不存在時，那就不須要去Storage查詢了。當False Position出現時，只是會致使一次多餘的Storage查詢。

因爲Bloom-Filter所用的空間很是小，全部BF能夠常駐內存。這樣子的話，對於大部分不存在的元素，咱們只須要訪問內存中的Bloom-Filter就能夠判斷出來了，只有一小部分，咱們須要訪問在硬盤上的key-value數據庫。從而大大地提升了效率。如圖：

2 .Google的BigTable

Google的BigTable也使用了Bloom Filter，以減小不存在的行或列在磁盤上的查詢，大大提升了數據庫的查詢操做的性能。

3. Proxy-Cache

在Internet Cache Protocol中的Proxy-Cache不少都是使用Bloom Filter存儲URLs，除了高效的查詢外，還能很方便得傳輸交換Cache信息。

4.網絡應用

1）P2P網絡中查找資源操做，能夠對每條網絡通路保存Bloom Filter，當命中時，則選擇該通路訪問。

2）廣播消息時，能夠檢測某個IP是否已發包。

3）檢測廣播消息包的環路，將Bloom Filter保存在包裏，每一個節點將本身添加入Bloom Filter。

4）信息隊列管理，使用Counter Bloom Filter管理信息流量。

5. 垃圾郵件地址過濾

像網易，QQ這樣的公衆電子郵件（email）提供商，老是須要過濾來自發送垃圾郵件的人（spamer）的垃圾郵件。

一個辦法就是記錄下那些發垃圾郵件的 email地址。因爲那些發送者不停地在註冊新的地址，全世界少說也有幾十億個發垃圾郵件的地址，將他們都存起來則須要大量的網絡服務器。

若是用哈希表，每存儲一億個 email地址，就須要 1.6GB的內存（用哈希表實現的具體辦法是將每個 email地址對應成一個八字節的信息指紋，而後將這些信息指紋存入哈希表，因爲哈希表的存儲效率通常只有 50%，所以一個 email地址須要佔用十六個字節。一億個地址大約要 1.6GB，即十六億字節的內存）。所以存貯幾十億個郵件地址可能須要上百 GB的內存。

而Bloom Filter只須要哈希表 1/8到 1/4 的大小就能解決一樣的問題。

BloomFilter決不會漏掉任何一個在黑名單中的可疑地址。而至於誤判問題，常見的補救辦法是在創建一個小的白名單，存儲那些可能別誤判的郵件地址。

五、 Bloom-Filter的具體實現

c語言實現：

stdafx.h：

#pragma once  
#include <stdio.h>    
#include "stdlib.h"  
#include <iostream>  
#include <time.h>  
using namespace std;

#include "stdafx.h"  
  
  
#define ARRAY_SIZE 256 /*we get the 256 chars of each line*/  
#define SIZE 48000000 /* size should be 1/8 of max*/  
#define MAX  384000000/*the max bit space*/  
  
#define SETBIT(ch,n) ch[n/8]|=1<<(7-n%8)  
#define GETBIT(ch,n) (ch[n/8]&1<<(7-n%8))>>(7-n%8)  
  
unsigned int len(char *ch);/* functions to calculate the length of the url*/  
  
unsigned int RSHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int JSHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int PJWHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int ELFHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int BKDRHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int SDBMHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int DJBHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int DEKHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int BPHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int FNVHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int APHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int HFLPHash(char* str,unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int HFHash(char* str,unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int StrHash( char* str,unsigned int len);/* functions to calculate the hash value of the url*/  
unsigned int TianlHash(char* str,unsigned int len);/* functions to calculate the hash value of the url*/  
  
  
int main()  
{  
    int i,num,num2=0; /* the number to record the repeated urls and the total of it*/  
    unsigned int tt=0;  
    int flag;         /*it helps to check weather the url has already existed */  
    char buf[257];    /*it helps to print the start time of the program */  
    time_t tmp = time(NULL);  
  
    char file1[100],file2[100];  
    FILE *fp1,*fp2;/*pointer to the file */  
    char ch[ARRAY_SIZE];    
    char *vector ;/* the bit space*/  
    vector = (char *)calloc(SIZE,sizeof(char));  
  
    printf("Please enter the file with repeated urls:\n");  
    scanf("%s",&file1);     
    if( (fp1 = fopen(file1,"rb")) == NULL) {  /* open the goal file*/  
      printf("Connot open the file %s!\n",file1);  
    }  
  
    printf("Please enter the file you want to save to:\n");  
    scanf("%s",&file2);  
    if( (fp2 = fopen(file2,"w")) == NULL) {  
        printf("Connot open the file %s\n",file2);  
    }  
    strftime(buf,32,"%Y-%m-%d %H:%M:%S",localtime(&tmp));  
    printf("%s\n",buf); /*print the system time*/  
  
    for(i=0;i<SIZE;i++) {  
        vector[i]=0;  /*set 0*/  
    }  
  
    while(!feof(fp1)) { /* the check process*/  
      
        fgets(ch,ARRAY_SIZE,fp1);  
        flag=0;  
        tt++;  
        if( GETBIT(vector, HFLPHash(ch,len(ch))%MAX) ) {      
            flag++;  
        } else {  
            SETBIT(vector,HFLPHash(ch,len(ch))%MAX );  
        }     
  
        if( GETBIT(vector, StrHash(ch,len(ch))%MAX) ) {   
            flag++;  
        } else {  
            SETBIT(vector,StrHash(ch,len(ch))%MAX );  
        }  
          
        if( GETBIT(vector, HFHash(ch,len(ch))%MAX) )   {  
            flag++;  
        } else {  
            SETBIT(vector,HFHash(ch,len(ch))%MAX );  
        }  
  
        if( GETBIT(vector, DEKHash(ch,len(ch))%MAX) ) {  
            flag++;  
        } else {  
            SETBIT(vector,DEKHash(ch,len(ch))%MAX );  
        }   
          
        if( GETBIT(vector, TianlHash(ch,len(ch))%MAX) ) {  
            flag++;  
        } else {  
            SETBIT(vector,TianlHash(ch,len(ch))%MAX );  
        }  
  
        if( GETBIT(vector, SDBMHash(ch,len(ch))%MAX) )  {  
            flag++;  
        } else {  
            SETBIT(vector,SDBMHash(ch,len(ch))%MAX );  
        }  
  
        if(flag<6)  
            num2++;       
        else              
           fputs(ch,fp2);  
      
        /*  printf(" %d",flag); */        
    }  
    /* the result*/  
    printf("\nThere are %d urls!\n",tt);  
    printf("\nThere are %d not repeated urls!\n",num2);  
    printf("There are %d repeated urls!\n",tt-num2);  
    fclose(fp1);  
    fclose(fp2);  
    return 0;  
}  
  
  
/*functions may be used in the main */  
unsigned int len(char *ch)  
{  
    int m=0;  
    while(ch[m]!='\0') {  
        m++;  
    }  
    return m;  
}  
  
unsigned int RSHash(char* str, unsigned int len) {  
   unsigned int b = 378551;  
   unsigned int a = 63689;  
   unsigned int hash = 0;  
   unsigned int i = 0;  
  
   for(i=0; i<len; str++, i++) {  
      hash = hash*a + (*str);  
      a = a*b;  
   }  
   return hash;  
}  
/* End Of RS Hash Function */  
  
  
unsigned int JSHash(char* str, unsigned int len)  
{  
   unsigned int hash = 1315423911;  
   unsigned int i    = 0;  
  
   for(i=0; i<len; str++, i++) {  
      hash ^= ((hash<<5) + (*str) + (hash>>2));  
   }  
   return hash;  
}  
/* End Of JS Hash Function */  
  
  
unsigned int PJWHash(char* str, unsigned int len)  
{  
   const unsigned int BitsInUnsignedInt = (unsigned int)(sizeof(unsigned int) * 8);  
   const unsigned int ThreeQuarters = (unsigned int)((BitsInUnsignedInt  * 3) / 4);  
   const unsigned int OneEighth = (unsigned int)(BitsInUnsignedInt / 8);  
   const unsigned int HighBits = (unsigned int)(0xFFFFFFFF) << (BitsInUnsignedInt - OneEighth);  
   unsigned int hash = 0;  
   unsigned int test = 0;  
   unsigned int i = 0;  
  
   for(i=0;i<len; str++, i++) {  
      hash = (hash<<OneEighth) + (*str);  
      if((test = hash & HighBits)  != 0) {  
         hash = ((hash ^(test >> ThreeQuarters)) & (~HighBits));  
      }  
   }  
  
   return hash;  
}  
/* End Of  P. J. Weinberger Hash Function */  
  
  
unsigned int ELFHash(char* str, unsigned int len)  
{  
   unsigned int hash = 0;  
   unsigned int x    = 0;  
   unsigned int i    = 0;  
  
   for(i = 0; i < len; str++, i++) {  
      hash = (hash << 4) + (*str);  
      if((x = hash & 0xF0000000L) != 0) {  
         hash ^= (x >> 24);  
      }  
      hash &= ~x;  
   }  
   return hash;  
}  
/* End Of ELF Hash Function */  
  
  
unsigned int BKDRHash(char* str, unsigned int len)  
{  
   unsigned int seed = 131; /* 31 131 1313 13131 131313 etc.. */  
   unsigned int hash = 0;  
   unsigned int i    = 0;  
  
   for(i = 0; i < len; str++, i++)  
   {  
      hash = (hash * seed) + (*str);  
   }  
  
   return hash;  
}  
/* End Of BKDR Hash Function */  
  
  
unsigned int SDBMHash(char* str, unsigned int len)  
{  
   unsigned int hash = 0;  
   unsigned int i    = 0;  
  
   for(i = 0; i < len; str++, i++) {  
      hash = (*str) + (hash << 6) + (hash << 16) - hash;  
   }  
  
   return hash;  
}  
/* End Of SDBM Hash Function */  
  
  
unsigned int DJBHash(char* str, unsigned int len)  
{  
   unsigned int hash = 5381;  
   unsigned int i    = 0;  
  
   for(i = 0; i < len; str++, i++) {  
      hash = ((hash << 5) + hash) + (*str);  
   }  
  
   return hash;  
}  
/* End Of DJB Hash Function */  
  
  
unsigned int DEKHash(char* str, unsigned int len)  
{  
   unsigned int hash = len;  
   unsigned int i    = 0;  
  
   for(i = 0; i < len; str++, i++) {  
      hash = ((hash << 5) ^ (hash >> 27)) ^ (*str);  
   }  
   return hash;  
}  
/* End Of DEK Hash Function */  
  
  
unsigned int BPHash(char* str, unsigned int len)  
{  
   unsigned int hash = 0;  
   unsigned int i    = 0;  
   for(i = 0; i < len; str++, i++) {  
      hash = hash << 7 ^ (*str);  
   }  
  
   return hash;  
}  
/* End Of BP Hash Function */  
  
  
unsigned int FNVHash(char* str, unsigned int len)  
{  
   const unsigned int fnv_prime = 0x811C9DC5;  
   unsigned int hash      = 0;  
   unsigned int i         = 0;  
  
   for(i = 0; i < len; str++, i++) {  
      hash *= fnv_prime;  
      hash ^= (*str);  
   }  
  
   return hash;  
}  
/* End Of FNV Hash Function */  
  
  
unsigned int APHash(char* str, unsigned int len)  
{  
   unsigned int hash = 0xAAAAAAAA;  
   unsigned int i    = 0;  
  
   for(i = 0; i < len; str++, i++) {  
      hash ^= ((i & 1) == 0) ? (  (hash <<  7) ^ (*str) * (hash >> 3)) :  
                               (~((hash << 11) + (*str) ^ (hash >> 5)));  
   }  
  
   return hash;  
}  
/* End Of AP Hash Function */  
unsigned int HFLPHash(char *str,unsigned int len)  
{  
   unsigned int n=0;  
   int i;  
   char* b=(char *)&n;  
   for(i=0;i<strlen(str);++i) {  
     b[i%4]^=str[i];  
    }  
    return n%len;  
}  
/* End Of HFLP Hash Function*/  
unsigned int HFHash(char* str,unsigned int len)  
{  
   int result=0;  
   char* ptr=str;  
   int c;  
   int i=0;  
   for (i=1;c=*ptr++;i++)  
   result += c*3*i;  
   if (result<0)  
      result = -result;  
   return result%len;  
}  
/*End Of HKHash Function */  
  
 unsigned int StrHash( char *str,unsigned int len)  
 {  
    register unsigned int   h;  
    register unsigned char *p;  
     for(h=0,p=(unsigned char *)str;*p;p++) {  
         h=31*h+*p;  
     }  
  
      return h;  
  
  }  
 /*End Of StrHash Function*/  
  
unsigned int TianlHash(char *str,unsigned int len)  
{  
   unsigned long urlHashValue=0;  
   int ilength=strlen(str);  
   int i;  
   unsigned char ucChar;  
   if(!ilength)  {  
       return 0;  
   }  
   if(ilength<=256)  {  
      urlHashValue=16777216*(ilength-1);  
  } else {   
      urlHashValue = 42781900080;  
  }  
  if(ilength<=96) {  
      for(i=1;i<=ilength;i++) {  
          ucChar=str[i-1];  
          if(ucChar<='Z'&&ucChar>='A')  {  
              ucChar=ucChar+32;  
          }  
          urlHashValue+=(3*i*ucChar*ucChar+5*i*ucChar+7*i+11*ucChar)%1677216;  
      }  
  } else  {  
      for(i=1;i<=96;i++)  
      {  
          ucChar=str[i+ilength-96-1];  
          if(ucChar<='Z'&&ucChar>='A')  
          {  
              ucChar=ucChar+32;  
          }  
          urlHashValue+=(3*i*ucChar*ucChar+5*i*ucChar+7*i+11*ucChar)%1677216;  
      }  
  }  
  return urlHashValue;  
  
 }  
/*End Of Tianl Hash Function*/

問題實例】給你A,B兩個文件，各存放50億條URL，每條URL佔用64字節，內存限制是4G，讓你找出A,B文件共同的URL。若是是三個乃至n個文件呢？
根據這個問題咱們來計算下內存的佔用，4G=2^32大概是40億*8大概是340億bit，n=50億，若是按出錯率0.01算須要的大概是650億個bit。如今可用的是340億，相差並很少，這樣可能會使出錯率上升些。另外若是這些urlip是一一對應的，就能夠轉換成ip，則大大簡單了。