हैश फ़िथन में परिवार जनरेटर

Question

मैं एक हैश फ़ंक्शन पारिवारिक जनरेटर ढूंढ रहा हूं जो पैरामीटर के सेट दिए गए हैश फ़ंक्शन का एक परिवार उत्पन्न कर सकता है। मुझे अब तक ऐसा कोई जनरेटर नहीं मिला है। क्या hashlib पैकेज के साथ ऐसा करने का कोई तरीका है?

h1 = hash_function(1) 
h2 = hash_function(2) 
... 

और h1 और h2 अलग हैश फंक्शन होगा:

उदाहरण के लिए मैं कुछ ऐसा करना चाहते हैं।

आप में से जो लोग इसके बारे में जानते हैं, मैं एक बहुत बड़े डेटासेट पर एक मिनी-हैशिंग एल्गोरिदम लागू करने की कोशिश कर रहा हूं।

असल में, मेरे पास किसी दिए गए दस्तावेज़ के लिए सुविधाओं का एक बहुत बड़ा सेट (100 मिलियन से 1 बिलियन) है, और मुझे सुविधाओं के इस सेट के लिए 1000 से 10000 विभिन्न यादृच्छिक क्रमपरिवर्तन बनाने की आवश्यकता है।

मैं यादृच्छिक क्रमपरिवर्तन स्पष्ट रूप से निर्माण करने के लिए इतना तकनीक मैं में उपयोग करना चाहते हैं नहीं करना चाहती है:

1. एक हैश समारोह h पैदा करते हैं और मानते हैं कि दो सूचकांक r और s
2. r के लिए क्रमशः s पर क्रमशः h(r) < h(s) पर दिखाई देता है और यह 100 से 1000 विभिन्न हैश फ़ंक्शंस के लिए करता है।

क्या कोई ज्ञात पुस्तकालय हैं जिन्हें मैं याद कर सकता हूं? या हैश के परिवारों को पाइथन के साथ उत्पन्न करने का कोई मानक तरीका जिसे आप जानते हो?

Answer 1

मैं बस की तरह कुछ करना चाहते हैं (यदि आप धागे की सुरक्षा की जरूरत नहीं है - मुश्किल नहीं बदलने के लिए अगर आप धागा सुरक्षा की जरूरत है - और एक 32-बिट अजगर संस्करण कल्पना करते हुए):

import random 

_memomask = {} 

def hash_function(n): 
    mask = _memomask.get(n) 
    if mask is None: 
    random.seed(n) 
    mask = _memomask[n] = random.getrandbits(32) 
    def myhash(x): 
    return hash(x)^mask 
    return myhash 

Answer 2

आपको सार्वभौमिक हैशिंग का उपयोग करने पर विचार करना चाहिए। मेरा उत्तर और कोड यहां पाया जा सकता है: https://stackoverflow.com/a/25104050/207661

Answer 3

जैसा ऊपर बताया गया है, आप मिन्हैश के लिए सार्वभौमिक हैशिंग का उपयोग कर सकते हैं। उदाहरण के लिए:

import random 



def minhash(): 
    d1 = set(random.randint(0, 2000) for _ in range(1000)) 
    d2 = set(random.randint(0, 2000) for _ in range(1000)) 
    jacc_sim = len(d1.intersection(d2))/len(d1.union(d2)) 
    print("jaccard similarity: {}".format(jacc_sim)) 

    N_HASHES = 200 
    hash_funcs = [] 
    for i in range(N_HASHES): 
     hash_funcs.append(universal_hashing()) 

    m1 = [min([h(e) for e in d1]) for h in hash_funcs] 
    m2 = [min([h(e) for e in d2]) for h in hash_funcs] 
    minhash_sim = sum(int(m1[i] == m2[i]) for i in range(N_HASHES))/N_HASHES 
    print("min-hash similarity: {}".format(minhash_sim)) 



def universal_hashing(): 
    def rand_prime(): 
     while True: 
      p = random.randrange(2 ** 32, 2 ** 34, 2) 
      if all(p % n != 0 for n in range(3, int((p ** 0.5) + 1), 2)): 
       return p 
    m = 2 ** 32 - 1 
    p = rand_prime() 
    a = random.randint(0, p) 
    if a % 2 == 0: 
     a += 1 
    b = random.randint(0, p) 
    def h(x): 
     return ((a * x + b) % p) % m 
    return h 

Reference