Python最小哈希实现海量文档去重的具体方案

J(A,B) = |A ∩ B| / |A ∪ B|

# 示例：文档"我在学习编程"
分词后：["我", "在", "学习", "编程"]
3-shingles：{"我 在 学习", "在 学习 编程"}

import jieba


def generate_word_shingles(text, k=3):
    """
    生成词级别的shingles
    """
    # 分词
    words = list(jieba.cut(text))

    # 生成k个连续词的片段
    shingles = set()
    for i in range(len(words) - k + 1):
        shingle = ' '.join(words[i:i + k])
        shingles.add(shingle)

    return shingles


# 示例
text = "我在学习编程"
shingles = generate_word_shingles(text, k=3)
print("3-shingles:", shingles)
# 输出: {'我 在 学习', '在 学习 编程'}

text1的3-grams集合: {"我在学", "在学习", "学习编", "习编程"}
text2的3-grams集合: {"我现在", "现在学", "在学习", "学习编", "习编程"}

交集 = {"在学习", "学习编", "习编程"} = 3个
并集 = {"我在学", "在学习", "学习编", "习编程", "我现在", "现在学"} = 6个
Jaccard相似度 = 3/6 = 0.5

def generate_char_ngrams(text, n=3):
    """
    生成字符级别的n-grams

    参数：
    text: 输入文本
    n: n-gram的大小

    返回：
    set: n-grams集合
    """
    ngrams = set()
    for i in range(len(text) - n + 1):
        ngram = text[i:i + n]
        ngrams.add(ngram)

    return ngrams


# 示例
text1 = "我在学习编程"
text2 = "我现在学习编程"

ngrams1 = generate_char_ngrams(text1, n=3)
ngrams2 = generate_char_ngrams(text2, n=3)

print("text1的3-grams集合:", ngrams1)
print("text2的3-grams集合:", ngrams2)

# 计算Jaccard相似度
intersection = ngrams1.intersection(ngrams2)
union = ngrams1.union(ngrams2)
jaccard_sim = len(intersection) / len(union)

print("交集:", intersection)
print("并集:", union)
print("Jaccard相似度:", jaccard_sim)

P[min(π(A)) = min(π(B))] = J(A,B)

文档A的shingles: {"我在学", "在学习", "学习编", "习编程"}
文档B的shingles: {"我现在", "现在学", "在学习", "学习编", "习编程"}

哈希函数h₁:
h₁("我在学") = 150
h₁("在学习") = 80    ← 两个文档的最小值！
h₁("学习编") = 200
h₁("习编程") = 180
h₁("我现在") = 250
h₁("现在学") = 300

文档A的min-hash₁ = min(150,80,200,180) = 80
文档B的min-hash₁ = min(250,300,80,200,180) = 80
结果：相等 

哈希函数h₂:
h₂("我在学") = 30    ← 文档A的最小值！
h₂("在学习") = 150
h₂("学习编") = 200
h₂("习编程") = 180
h₂("我现在") = 25    ← 文档B的最小值！
h₂("现在学") = 300

文档A的min-hash₂ = 30
文档B的min-hash₂ = 25
结果：不相等 

哈希函数h₃:
h₃("我在学") = 400
h₃("在学习") = 250
h₃("学习编") = 50    ← 两个文档的最小值！
h₃("习编程") = 150
h₃("我现在") = 300
h₃("现在学") = 350

文档A的min-hash₃ = 50
文档B的min-hash₃ = 50
结果：相等 

import hashlib


def hash_shingle(shingle, hash_func_num):
    """
    对shingle进行哈希
    """
    # 使用不同的哈希函数模拟随机排列
    # 使用不同的盐值来模拟不同的哈希函数
    salt = f"salt_{hash_func_num}"
    data = (shingle + salt).encode('utf-8')

    # 使用MD5哈希并转换为整数
    hash_hex = hashlib.md5(data).hexdigest()
    hash_int = int(hash_hex, 16) % (10 ** 6)  # 取模得到合适大小的整数

    return hash_int


def calculate_minhash(shingles_set, num_hash_funcs=3):
    """
    计算文档的最小哈希签名
    """
    # 初始化最小哈希值为无穷大
    minhash_signature = [float('inf')] * num_hash_funcs

    for shingle in shingles_set:
        for i in range(num_hash_funcs):
            hash_value = hash_shingle(shingle, i)
            if hash_value < minhash_signature[i]:
                minhash_signature[i] = hash_value

    return minhash_signature


# 文档A和B的shingles（使用字符级别的3-grams）
docA_shingles = {"我在学", "在学习", "学习编", "习编程"}
docB_shingles = {"我现在", "现在学", "在学习", "学习编", "习编程"}

# 计算最小哈希签名
minhash_A = calculate_minhash(docA_shingles, num_hash_funcs=300)
minhash_B = calculate_minhash(docB_shingles, num_hash_funcs=300)

print("文档A的300维哈希签名:", minhash_A)
print("文档B的300维哈希签名:", minhash_B)


# 计算签名相似度
def signature_similarity(sigA, sigB):
    """计算两个签名的Jaccard相似度估计值"""
    matches = sum(1 for a, b in zip(sigA, sigB) if a == b)
    return matches / len(sigA)


similarity = signature_similarity(minhash_A, minhash_B)
print("签名相似度估计值:", similarity)

文档A的3维哈希签名: [80, 30, 50]
文档B的3维哈希签名: [80, 25, 50]

def signature_similarity(sigA, sigB):
    """计算两个签名的Jaccard相似度估计值"""
    matches = sum(1 for a, b in zip(sigA, sigB) if a == b)
    return matches / len(sigA)

# 示例
similarity = signature_similarity([80, 30, 50], [80, 25, 50])
# 2/3 ≈ 0.667（接近真实值0.5）

import math


def confidence_interval(n, s=0.5):
    """计算95%置信区间"""
    std = math.sqrt(s * (1 - s) / n)
    margin = 1.96 * std
    return [max(0, s - margin), min(1, s + margin)]


print(confidence_interval(1, s=0.5))
print(confidence_interval(10, s=0.5))
print(confidence_interval(100, s=0.5))
print(confidence_interval(500, s=0.5))
print(confidence_interval(1000, s=0.5))

[0, 1]
[0.19009678930349883, 0.8099032106965012]
[0.402, 0.598]
[0.4561730676410041, 0.5438269323589959]
[0.4690096789303499, 0.5309903210696502]

假设120维原始签名：
[123, 456, 789, 321, 654, 987, ..., 888]

以切成20个片为例（每片6维）：
片 1: [123, 456, 789, ..., ...] 
片 2: [..., ..., ..., ..., ...] 
...
片 20: [..., ..., ..., ..., 888] 

片 1: = hash(tuple(band1))  # 如 0x1a2b3c
片 2: = hash(tuple(band2))  # 如 0x4d5e6f
片 3: = hash(tuple(band3))  # 如 0x7a8b9c  
片 4: = hash(tuple(band4))  # 如 0xd1e2f3

def lsh_probability(s, r=6, b=20):
    """计算LSH匹配概率"""
    prob_one_band = s ** r          # 单个band匹配的概率
    prob_at_least_one = 1 - (1 - prob_one_band) ** b
    return prob_at_least_one

# 示例：相似度0.8的文档
prob = lsh_probability(0.8, 6, 20)  # ≈ 0.9940
# 99.4%的概率会被LSH放到同一个桶中