Làm thế nào để chiếu đồng nhất một hàm băm vào một số lượng thùng cố định

Xin chào các nhà thống kê,

Tôi có một băm tạo nguồn (ví dụ: tính toán một chuỗi có dấu thời gian và các thông tin khác và băm với md5) và tôi muốn chiếu nó vào một số lượng cố định (ví dụ 100).

mẫu băm: 0fb916f0b174c66fd35ef078d861a367

Điều tôi nghĩ lúc đầu là chỉ sử dụng ký tự đầu tiên của hàm băm để chọn một nhóm, nhưng điều này dẫn đến một phép chiếu không đồng đều cực kỳ (nghĩa là một số chữ cái xuất hiện rất hiếm và rất thường xuyên khác)

Sau đó, tôi đã cố gắng chuyển đổi chuỗi hexa này thành một số nguyên bằng cách sử dụng tổng các giá trị char, sau đó lấy modulo để chọn một nhóm:

import sys

for line in sys.stdin:
    i = 0
    for c in line:
        i += ord(c)
    print i%100

Nó dường như hoạt động trong thực tế, nhưng tôi không biết liệu có bất kỳ ý nghĩa thông thường hoặc kết quả lý thuyết nào có thể giải thích tại sao và mức độ này là đúng không?

[Chỉnh sửa] Sau một số suy nghĩ, tôi đã đi đến kết luận sau: Về lý thuyết, bạn có thể chuyển đổi hàm băm thành số nguyên (rất lớn) bằng cách hiểu nó là một số: i = h [0] + 16 * h [1] + 16 * 16 * h [2] ... + 16 ^ 31 * h [31] (mỗi chữ cái đại diện cho một số thập lục phân). Sau đó, bạn có thể điều chỉnh số lượng lớn này để chiếu nó vào không gian xô. [/Biên tập]

Cảm ơn !

Lưu ý: đưa ra câu trả lời xuất hiện từ các cuộc thảo luận trong các bình luận để dễ đọc hơn cho những người quan tâm

(phiên bản cập nhật)

Giả sử chúng ta có một nguồn tạo ra các sự kiện độc lập mà chúng ta muốn phân phối đồng đều vào các thùng$B$

Các bước chính là:

1. băm mỗi sự kiện đến một số nguyên có kích thướci 2 $e$$i$$2^N$
2. dự án vào asp = $\mathcal{R} \times [0, 1[$$p = \frac{i}{2^N}$
3. tìm xô phù hợp sao chob $b_i$$\frac{b_i}{B} \le p \lt \frac{b_{i+1}}{B}$

Đối với 1. một giải pháp phổ biến là sử dụng MurmurHash để tạo số nguyên 64 hoặc 128 bit.

Cho 3. một giải pháp đơn giản là lặp lại trên và kiểm tra xem có trongp [ b $j = 1..B$$p$$[\frac{b_j}{B}, \frac{b_{j+1}}{B}[$

Trong mã giả (python), quy trình tổng thể có thể là:

def hash_to_bucket(e, B):
    i = murmurhash3.to_long128(str(e))
    p = i / float(2**128)
    for j in range(0, B):
        if j/float(B) <= p and (j+1)/float(B) > p:
            return j+1
    return B

(phiên bản trước, thực sự không tối ưu)

Quan sát đầu tiên là chữ cái thứ n của hàm băm phải được phân phối đồng đều với bảng chữ cái (ở đây dài 16 chữ cái - cảm ơn @leonbloy đã chỉ ra điều đó).

Sau đó, để chiếu nó tới [0,100 [phạm vi, mẹo là lấy 2 chữ cái từ hàm băm (ví dụ: vị trí thứ 1 và thứ 2) và tạo một số nguyên với:

int_value = int(hash[0])+16*int(hash[1])

Giá trị này cuộc sống trong khoảng [0,16+ (16-1) * 16 [, do đó chúng tôi chỉ phải modulo nó đến 100 để tạo ra một cái xô trong khoảng [0, 100 [: Như đã chỉ ra trong các ý kiến, làm do đó tác động đến tính đồng nhất của phân phối vì chữ cái đầu tiên có ảnh hưởng nhiều hơn chữ cái thứ hai.

bucket = int_value % 100

Về lý thuyết, bạn có thể chuyển đổi toàn bộ hàm băm thành số nguyên (rất lớn) bằng cách hiểu nó là một số: i = h [0] + 16 * h [1] + 16 * 16 * h [2] ... + 16 ^ 31 * h [31] (mỗi chữ cái đại diện cho một số thập lục phân). Sau đó, bạn có thể điều chỉnh số lượng lớn này để chiếu nó vào không gian xô. Sau đó, người ta có thể lưu ý rằng việc sử dụng modulo của i có thể được phân tách thành một hoạt động phân phối và phụ gia:

Tôi đã có một vấn đề tương tự và đưa ra một giải pháp khác có thể nhanh hơn và dễ thực hiện hơn trong bất kỳ ngôn ngữ nào.

Suy nghĩ đầu tiên của tôi là gửi các mặt hàng một cách nhanh chóng và thống nhất trong một số lượng thùng cố định, và để có thể mở rộng, tôi nên bắt chước ngẫu nhiên.

Vì vậy, tôi đã mã hóa hàm nhỏ này trả về số float trong [0, 1 [đã cho một chuỗi (hoặc bất kỳ loại dữ liệu nào trong thực tế).

Ở đây trong Python:

import math
def pseudo_random_checksum(s, precision=10000):
    x = sum([ord(c) * math.sin(i + 1) for i,c in enumerate(s)]) * precision
    return x - math.floor(x)

Dĩ nhiên nó không phải là ngẫu nhiên, thực tế nó thậm chí không phải là giả ngẫu nhiên, cùng một dữ liệu sẽ luôn trả về cùng một tổng kiểm tra. Nhưng nó hoạt động như ngẫu nhiên và nó khá nhanh.

Bạn có thể dễ dàng gửi và truy xuất các mục trong N xô bằng cách chỉ định mỗi mục cho số xô math.floor (N * pseudo_random_checksum (mục)).