Question

我试图在python中理解/实现基于minHash的jaccard相似性。主要目标是在MapReduce中使用它。但是我不清楚散列函数的选择和签名长度如何影响计算jaccard相似度的错误率。从维基百科，我发现通常签名（K）的长度和与计算的jaccard相似性相关的误差（e）是k = 0（1 / e ^ 2）。我尝试在python中实现minHash：

import random
import sys

#ERROR_THRESHOLD = 0.05
#SIG_LENGTH = int(1/(ERROR_THRESHOLD**2))
_memomask = {}

def hash_values(n, x):
    """Compute n different hash values"""
    values = []
    for i in range(n):
        mask = _memomask.get(i)
        if mask is None:
            random.seed(i)
            mask = _memomask[i] = random.getrandbits(32)
        values.append((hash(str(x)) % mask))
    return values


def compare_signatures(x, y):
    """Compare MinHash Signatures"""
    size = len(x)

    if size != len(y): raise Exception("Different signature length")
    if size == 0: raise Exception("signature length is zero")

    counter = 0
    for i in range(size): counter += int(x[i] == y[i])
    return counter/float(size)

items = [['A',3], ['A',6], ['A',9], ['B',2], ['B',4], ['B',6], ['B',8]]

for SIG_LENGTH in [1, 10, 100, 400, 1000]:
    #Step 1: Compute Hash Signature for each token
    data = []
    for item in items:
        values = hash_values(SIG_LENGTH, item[1])
        key = item[0]    
        data.append((key, values))

    #Step 2: Group by Key and compute MinHash for each index
    signatures = {}
    for item in data:
        key = item[0]
        values = item[1]
        if key not in signatures: signatures[key] = [-1.0]*SIG_LENGTH
        cur_signature = signatures[key]   

        signatures[key] = [(values[i] if cur_signature[i] == -1.0 else min(values[i], cur_signature[i])) for i in range(SIG_LENGTH)]

    #Step 3: Compute Probability of minHash signature to be same
    keys = signatures.keys()
    key_length = len(keys)
    print "Jaccard Similarity based on signature of length {0}".format(SIG_LENGTH)
    for i in range(key_length):
        x_key = keys[i]
        x_sig = signatures[x_key]
        for j in range(i+1,key_length):
            y_key = keys[j]
            y_sig = signatures[y_key]
            print "J({0},{1}) = {2}".format(x_key, y_key, compare_signatures(x_sig, y_sig))

在我的测试中，我发现随着签名长度的增加，准确度会提高，但之后会逐渐降低（或保持稳定）。我想知道是因为哈希函数的选择。如果是，有人可以建议使用好的哈希函数。

我发现了一些相关的帖子，但仍然不清楚： How many hash functions are required in a minhash algorithm

Answer 1

md5和sha工作得很好：

import random
import hashlib
import sys

k = int(sys.argv[1])
salts = [random.getrandbits(32) for i in range(k)]

def h(value, salt):
    m = hashlib.md5() #or hashlib.sha1()
    m.update(str(value))
    m.update(str(salt))
    return m.digest()

def get_signatures(A):
    return [min([h(x, salt) for x in A]) for salt in salts]

def compare_signatures(A, B):
    """Compare MinHash Signatures"""
    sigA = get_signatures(A)
    sigB = get_signatures(B)
    return sum(map(lambda x: int(sigA[x] == sigB[x]), range(k)))/float(k)

A = [3,6,9]
B = [2,4,6,8]

print compare_signatures(A, B)

和一些测试：

$ for((i=10;i<2000;i*=10)); do python minhash.py $i; done
0.2
0.14
0.163

Answer 2

生成大量散列函数的一种方法是使用不同的种子。与createHashFunctions here中一样。

Answer 3

你问过1）minhash算法的最佳哈希数是多少; 2）你是否使用了正确的哈希函数。

1）你提到：k = O（1 / e ^ 2）。如果e指的是错误，这是正确的。您也可以将此表达为预期错误（epsilon）在订单上（1 / k ** 0.5）。请记住，这是此算法收敛的平均预期误差，不一定是特定比较的预期误差。

2）您可以使用任何随机散列函数，只要每个散列以不同的方式加盐。 64位哈希值可能是我推荐的最小值。我避免使用MD5或SHA，因为你不需要这些开销。请务必按操作系统的大小获取散列模数，例如。 Python中的sys.maxsize（）。如果你不这样做，那么你将遇到算法行为不正确的实例。

（1）散列函数，（2）签名长度和（3）jaccard相似度之间的关系？

3 个答案: