聚类之MinHash

最小哈希法

最小哈希原理介绍

1. MinHash是基于Jaccard Index相似度（海量数据不可行）的算法,一种降维的方法A，B 两个集合：A = {s1, s3, s6, s8, s9}  B = {s3, s4, s7, s8, s10}
2. MinHash的基本原理:在A∪B这个大的随机域里，选中的元素落在A∩B这个区域的概率，这个概率就等于Jaccard的相似度

最小哈希：

	S1	S2	S3
A	1	0	0
B	0	1	0
C	0	0	0
D	1	0	1

行的随机排列转换（也称置换运算）

	S1	S2	S3
B	0	1	0
D	1	0	1
A	1	0	0
C	0	0	0

哈希值：排列转换后的行排列次序下第一个列值为1的行的行号，例如h(S1)=D，h(S2)=B

两个集合经随机排列之后得到的两个最小哈希值相等的概率等于这两个集合的Jaccard相似度。

问题：

对于上百万甚至数十亿的行选择一个随机排列转换极其消耗时间，怎么办？

1. 随机选择n个哈希函数h1，h2…
2. 对每列C进行如下操作：

　　　　a)  如果c在第r行为0，则什么也不做；

　　　　b)   否则，如果c在第r行为1，那么对于每个i=1,2，…，n，将SIG（i,c）置为原来的SIG（i，c）和h(r)中的较小值

 

行	S1	S2	S3	S4	x+1 mod 5	3x+1 mod 5
0	1	0	0	1	1	1
1	0	0	1	0	2	4
2	0	1	0	1	3	2
3	1	0	1	1	4	0
4	0	0	1	0	0	3

计算最小哈希签名矩阵：

	S1	S2	S3	S4
h1	1	3	0	1
h2	0	2	0	0

计算Jaccard相似度：

SIM(S1，S4)=1.0；SIM(S1，S3)=1/3；SIM(S1，S2)=0

真实SIM(S1，S4)=2/3；SIM(S1，S3)=1/4；SIM(S1，S2)=0

 

相关论文：

1.《Google News Personalization: Scalable Online Collaborative Filtering》

根据用户的历史点击数据，进行新闻推荐；采用最小哈希聚类的协同过滤算法

2.《The Link-Prediction Problem for Social Networks》

比较社交网络链接预测问题的各种算法

计算好友相似度的流程：

• 找到N个哈希函数，对每个用户好友集合生成一组Minhash（N个）
• 对于一个用户，按Minhash相同个数做排序，给出推荐候选集
• 计算用户跟被备选集的Jaccard Index
• 按Jaccard结果排序，给出TopN进行推荐

哈希函数生成和哈希值计算：

1. 1. 输入向量Vector转换为bytes
      • numHashFunctions--预设生成hash函数的个数（假定为10个）

      • for (int i = 0; i < numHashFunctions; i++) {
              for (Vector.Element ele : featureVector) {
                int value = (int) ele.get();
                bytesToHash[0] = (byte) (value >> 24);
                bytesToHash[1] = (byte) (value >> 16);
                bytesToHash[2] = (byte) (value >> 8);
                bytesToHash[3] = (byte) value;
                int hashIndex = hashFunction[i].hash(bytesToHash); //计算哈希函数值
                //只保留最小哈希值
                if (minHashValues[i] > hashIndex) {
                  minHashValues[i] = hashIndex;
                }
              }
            }

         

   2. 采用Mersenne Twister算法构造伪随机生成器
      • Random random = new MersenneTwisterRNG(new FastRandomSeedGenerator());
        • org.uncommons.maths.random. MersenneTwisterRNG.MersenneTwisterRNG( SeedGenerator seedGenerator)
      • Mersenne Twister（马特赛特旋转演算法），是伪随机数发生器之一，其主要作用是生成伪随机数。
        Mersenne Twister算法的原理：Mersenne Twister算法是利用线性反馈移位寄存器(LFSR)产生随机数的，LFSR的反馈函数是寄存器中某些位的简单异或，这些位也称之为抽头序列。一个n位的LFSR能够在重复之前产生2^n-1位长的伪随机序列。只有具有一定抽头序列的LFSR才能通过所有2^n-1个内部状态，产生2^n - 1位长的伪随机序列，这个输出的序列就称之为m序列。为了使LFSR成为最大周期的LFSR，由抽头序列加上常数1形成的多项式必须是本原多项式。一个n阶本原多项式是不可约多项式，它能整除x^(2*n-1)+1而不能整除x^d+1，其中d能整除2^n-1。例如(32,7,5,3,2,1,0)是指本原多项式x^32+x^7+x^5+x^3+x^2+x+1，把它转化为最大周期LFSR就是在LFSR第32，7，5，2，1位抽头。利用上述两种方法产生周期为m的伪随机序列后，只需要将产生的伪随机序列除以序列的周期，就可以得到(0，1)上均匀分布的伪随机序列了。
        Mersenne Twister有以下优点：随机性好，在计算机上容易实现，占用内存较少(mt19937的C程式码执行仅需624个字的工作区域)，产生随机数的速度快、周期长，可达到2^19937-1，且具有623维均匀分布的性质，对于一般的应用来说，足够大了，序列关联比较小，能通过很多随机性测试。
   3. 四种哈希函数生成器
      • MAX_INT_SMALLER_TWIN_PRIME = 2147482949；为什么选这个值？
        • 它是整型范围内最大孪生素数（相差为2的两个数都是质数的情况）的较小值；哈希用素数取模冲突小
      • seedA、seedB、seedC是采用MersenneTwisterRNG随机生成器生成的0~11均匀分布的随机数
      • 第一种：LinearHash
        

            @Override
            public int hash(byte[] bytes) {
              long hashValue = 31;
              for (long byteVal : bytes) {
                hashValue *= seedA * byteVal;
                hashValue += seedB;
              }
              return Math.abs((int) (hashValue % RandomUtils.MAX_INT_SMALLER_TWIN_PRIME));
            }

      • 第二种:PolynomialHash

         @Override
            public int hash(byte[] bytes) {
              long hashValue = 31;
              for (long byteVal : bytes) {
                hashValue *= seedA * (byteVal >> 4);
                hashValue += seedB * byteVal + seedC;
              }
              return Math.abs((int) (hashValue % RandomUtils.MAX_INT_SMALLER_TWIN_PRIME));
            }

      • 第三种：MurmurHashWrapper

        @Override
            public int hash(byte[] bytes) {
              long hashValue = MurmurHash.hash64A(bytes, seed);
              return Math.abs((int) (hashValue % RandomUtils.MAX_INT_SMALLER_TWIN_PRIME));
            }

      • 第四种:MurmurHash3Wrapper

        @Override
            public int hash(byte[] bytes) {
              long hashValue = MurmurHash3.murmurhash3_x86_32(bytes, 0, bytes.length, seed);
              return Math.abs((int) (hashValue % RandomUtils.MAX_INT_SMALLER_TWIN_PRIME));
            }