update

dedup.py

@@ -0,0 +1,285 @@
+''' minhash dedup, nguồn:
+- blog https://huggingface.co/blog/dedup
+- code https://github.com/bigcode-project/bigcode-dataset/blob/main/near_deduplication/minhash_deduplication.py
+
+Giờ ta sẽ đi vào chi tiết từng bước cài đặt thuật toán minhash dedup.
+'''
+
+####################################################################################
+# Đầu tiên là một hàm hash biến dữ liệu có độ dài bất kỳ thành 1 số nguyên (8 bytes)
+
+import struct, hashlib
+def sha1_hash32(data): # data : bytes, return : int
+    return struct.unpack("<I", hashlib.sha1(data).digest()[:4])[0]
+
+# Test code
+# assert sha1_hash32(b'hello') == 499578026
+
+####################################################################################
+# Một hàm tạo ngram từ mảng words đầu vào (easy donkey)
+
+from itertools import tee
+from typing import Any, Dict, Iterable, List, Tuple
+
+def ngrams(sequence: List[str], n: int, min_ngram_size: int) -> Iterable:
+    if len(sequence) < min_ngram_size:
+        return []
+    iterables = tee(sequence, n)
+    for i, sub_iterable in enumerate(iterables):
+        for _ in range(i):
+            next(sub_iterable, None)
+    return zip(*iterables)
+
+import re; NON_ALPHA = re.compile("[^A-Za-z_0-9]+")
+
+# Test code
+# if __name__ == "__main__":
+#     doc = "a b f h k h, m"
+#     x = ngrams(NON_ALPHA.split(doc), 5, 5)
+#     print(f'ngrams("{doc}".split(), 5, 5)')
+#     for i, ngram in enumerate(x): print(f"{i}: {ngram}")
+#     assert i == 2
+#     assert ngram == ('f', 'h', 'k', 'h', 'm')
+
+######################################################################################
+# Hàm quan trọng nhất biến nội dung 1 doc thành các hashvalues để so sánh sự trùng lặp
+# Nó map doc vào khoảng 2000 bytes của hashvalues, xem chi tiết ở ví dụ bên dưới
+
+import numpy as np
+MAX_HASH = np.uint64((1 << 32) - 1)
+MERSENNE_PRIME = np.uint64((1 << 61) - 1)
+
+def doc2hashvalues(
+        content: str,   # The content of the doc to be embedded.
+        num_perm: int,  # The number of permutations.
+        hashranges: List[Tuple[int, int]],  # The ranges of hash values.
+        permutations: np.ndarray,           # The permutations for the minhash.
+        ngram_size: int = 5,
+        min_ngram_size: int = 5,
+):
+    tokens = {" ".join(t) for t in ngrams(NON_ALPHA.split(content), ngram_size, min_ngram_size)}
+    hv = np.array([sha1_hash32(token.encode("utf-8")) for token in tokens], dtype=np.uint64)  # noqa: E501
+
+    a, b = permutations
+    phv = np.bitwise_and(((hv * np.tile(a, (len(hv), 1)).T).T + b) % MERSENNE_PRIME, MAX_HASH)  # noqa: E501
+
+    hashvalues = np.ones(num_perm, dtype=np.uint64) * MAX_HASH
+    hashvalues = np.vstack([phv, hashvalues]).min(axis=0)
+
+    return [ bytes(hashvalues[start:end].byteswap().data) \
+                for start, end in hashranges ]
+
+####################################################################################
+# Hàm trợ giúp để tính toán ra các tham số tối ưu để chạy thuật toán
+
+from scipy.integrate import quad as integrate
+def optimal_param(
+    threshold: float,   # The threshold for similarity.
+    num_perm: int,      # The number of permutations.
+    false_positive_weight: float = 0.5,
+    false_negative_weight: float = 0.5,
+):
+    def false_positive_probability(threshold: float, b: int, r: int):
+        def proba(s): return 1 - (1 - s ** float(r)) ** float(b)
+        a, _ = integrate(proba, 0.0, threshold)
+        return a
+
+    def false_negative_probability(threshold: float, b: int, r: int):
+        def proba(s): return 1 - (1 - (1 - s ** float(r)) ** float(b))
+        a, _ = integrate(proba, threshold, 1.0)
+        return a
+
+    min_error = float("inf")
+ 
+    for b in range(1, num_perm + 1):
+        max_r = int(num_perm / b)
+        for r in range(1, max_r + 1):
+            fp = false_positive_probability(threshold, b, r)
+            fn = false_negative_probability(threshold, b, r)
+            error = fp * false_positive_weight + fn * false_negative_weight
+            if error < min_error:
+                min_error = error
+                opt = {
+                    "number_of_bands": b, 
+                    "number_of_rows" : r,
+                }
+    return opt
+
+####################################################################################
+# Các tham số, xem https://huggingface.co/blog/dedup#minhash-walkthrough 
+# Đây là bộ tham số của thuật toán MinHash + LSH parameters (P, T, K, B, R)
+# Dưới đây sẽ định nghĩa và giải thích ý nghĩa của từng tham số
+
+num_perm = 256      # P: number of permutations / hashes
+threshold = 0.7     # T: Jaccard similarity threshold
+K = 9               # K: n-gram/shingle size
+# K = 13                # K: n-gram/shingle size
+## Điều chỉnh K = 13 cho giống với cách làm của GPT3
+# https://stanford-cs324.github.io/winter2022/lectures/data/#gpt-3-dataset
+
+# LSH breaks the fingerprint array into bands, each band containing the same number of rows
+# https://huggingface.co/blog/dedup#locality-sensitive-hashing
+params = optimal_param(threshold, num_perm)
+B = params["number_of_bands"] # 25
+R = params["number_of_rows"]  # 10
+
+# Dựa vào R, B để tính ra HASH_RANGES (easy donkey)
+HASH_RANGES = [(i * R, (i + 1) * R) for i in range(B)] # [(0, 10), (10, 20), ..., (240, 250)]
+
+# Khởi tạo PERMUTATIONS ngẫu nhiên
+SEED = 42; RNG = np.random.RandomState(SEED)
+X = lambda : ( 
+    RNG.randint(1, MERSENNE_PRIME, dtype=np.uint64), 
+    RNG.randint(0, MERSENNE_PRIME, dtype=np.uint64) 
+)
+PERMUTATIONS = np.array( [ X() for _ in range(num_perm) ], dtype=np.uint64 ).T
+
+# Utils
+from base64 import b85encode, b85decode
+import json
+
+def to_b85hashvalues(hashvalues):
+    return [ str(b85encode(hv), encoding="ascii") for hv in hashvalues ]
+
+def from_b85hashvalues(b85hashvalues):
+    return [ b85decode(x) for x in b85hashvalues ]
+
+# Test code: giờ ta áp các hyper params này vào thuật toán doc2hashvalues
+# if __name__ == "__main__":
+#     hashvalues = doc2hashvalues("a b c d e f", num_perm, HASH_RANGES, PERMUTATIONS, K, K)
+#     size = len(hashvalues[0]); total = len(hashvalues) * size
+#     print(f"Mỗi doc's content được đại diện bởi {B} hashvalues, {size} bytes each, total {total}")
+#     # => Mỗi doc's content được đại diện bởi 25 hashvalues, 80 bytes each, total 2000
+#     b85hashvalues = to_b85hashvalues(hashvalues)
+#     print(json.dumps(b85hashvalues, ensure_ascii=False))
+#     for idx, hv in enumerate(from_b85hashvalues(b85hashvalues)):
+#         assert hv == hashvalues[idx]
+
+####################################################################################
+# Cấu trúc dữ liệu và thuật toán UnionFind để tìm các docs trùng lặp trong 1 cluster
+# https://huggingface.co/blog/dedup#beyond-duplicate-pairs
+'''
+our experiments from The Stack show that treating all of them as duplicates improves 
+the downstream model's performance the best. And now we gradually moved towards this 
+method instead, and it saves time as well. But to apply this to your dataset, we 
+still recommend going over your dataset and looking at your duplicates, 
+and then making a data-driven decision.
+'''
+class UnionFind:
+
+    def __init__(self):
+        self.parent: Dict[int, int] = {}
+
+    def find(self, x):
+        if x not in self.parent:
+            self.parent[x] = x  # => tao là trùm cuối,
+                                # trùm cuối là thằng trỏ tới chính nó (ko có ai cao hơn)
+
+        if  self.parent[x] != x:            # nếu không phải trùm cuối thì
+            self.parent[x] = self.find(self.parent[x])   # => tìm thằng cấp cao hơn
+                                            # đương nhiên sẽ chỉ dừng lại khi gặp trùm cuối
+        return self.parent[x]               # và trả lại giá trị trùm cuối
+
+    def union(self, x, y):
+        px = self.find(x) # px là trùm cuối của x
+        py = self.find(y) # py là trùm cuối của y
+        ret = min(px, py)
+
+        self.parent[px] = ret
+        self.parent[py] = ret 
+        return ret
+        # hợp nhất 2 băng lại với nhau với trùm cuối có giá trị min(px, py)
+        # Note: về lý thuyết có thể chọn bất kỳ px hoặc py là trùm cuối
+        # Việc chọn min của px và py có lẽ liên quan tới hàm minhash ?!?
+        # => cần tìm hiểu thêm !!!
+
+####################################################################################
+# Tóm tắt thuật toán dedup dùng minhash
+'''
+`hashvalues` của 1 doc gồm 20 giá trị hash gộp thành, 
+và mỗi giá trị đó được phân vào một bảng khác nhau theo thứ tự xuất hiện.
+
+doc's hashvalues[ 0] vào HASH_TABLES[ 0]
+doc's hashvalues[ 1] vào HASH_TABLES[ 1]
+...
+doc's hashvalues[19] vào HASH_TABLES[19]
+
+Các hashvalue lẻ được dùng làm key để nhóm các doc idx trong từng bảng lại với nhau
+HASH_TABLES[0][hashvalue] => { idx1, idx2, idx3 ... }
+Các idx trong cùng 1 nhóm (cluster) tức là nội dung bị trùng lặp và sẽ chỉ giữ lại 1 idx thôi
+và đó là min_idx của cluster đó.
+
+sau đó lại tiếp tục dedup ở các bảng khác theo kiểu union (phép hợp), để loại trừ tiếp ...
+'''
+
+if __name__ == "__main__":
+    # load docs
+    import sys, gzip, os, subprocess, lzma
+    docs = []
+    input_file = sys.argv[1]
+    if ".xz" not in input_file:
+        print(f"Input file {input_file} cần có định dạng .xz")
+        sys.exit()
+
+    output_file = input_file.replace(".jsonl.xz", "_dedup.jsonl")
+    if os.path.exists(output_file):
+        print(f"Output file {output_file} đã tồn t��i")
+        sys.exit()
+
+    with lzma.open(input_file, "rt") as fin:
+        for line in fin: docs.append(line)
+
+    from collections import defaultdict
+    HASH_TABLES = [ defaultdict(set) for _ in range(B) ]
+
+    from multiprocessing import Pool
+    def f(doc):
+        # text = doc.split('", "time": "')[0][10:].replace("\\n", " ") # print(text) # OK!
+        text = doc
+        hashvalues = doc2hashvalues(text, num_perm, HASH_RANGES, PERMUTATIONS)
+        return hashvalues
+
+    with Pool(os.cpu_count() - 5) as p:
+        docs2hashvalues = p.map(f, docs)
+
+    for idx, hashvalues in enumerate(docs2hashvalues):
+        for hashvalue, hashtable in zip(hashvalues, HASH_TABLES):
+            hashtable[hashvalue].add(idx) # => 1 hash value trỏ 1 tập nhiều giá trị idx
+
+    uf = UnionFind()
+
+    for table in HASH_TABLES:
+        for cluster in table.values(): # [{idx2, idx3}, {idx1}]
+            if len(cluster) <= 1: continue # có <= 1 phần tử khỏi dedup :)
+            min_idx = min(cluster)
+            for x in cluster: # với mỗi cluster (of doc idx) thì min_idx là trùm cuối
+                uf.union(x, min_idx)
+
+    ## Cuối cùng chỉ giữ lại trùm cuối, các bọn khác là trùng lặp của trùm cuối nên bị loại bỏ.
+    ## và thế là xong việc dedup dùng minhash :D
+    print("\nSau khi dedup giữ lại:")
+    import random
+    count = 0; b85 = 0; check = 5
+    with open(output_file, "wt") as fout:
+        for idx in range(len(docs)):
+            keep_idx = uf.find(idx)
+            if idx == keep_idx:
+                count += 1
+                if count % 10_000 == 0: print(count, b85)
+                line = docs[idx]
+                # if len(line) > 3000:
+                #     b85 += 1
+                #     hvs = to_b85hashvalues(docs2hashvalues[idx])
+                #     hvs = json.dumps(hvs, ensure_ascii=False)
+                #     line = line[:-2] + f', "hashvalues": {hvs}' + "}\n" 
+                #     if check > 0 and random.random() > 0.5: # kiểm tra ngẫu nhiên check lần
+                #         check -= 1
+                #         text = line.split('", "time": "')[0][10:].replace("\\n", " ")
+                #         print(text) # OK!
+                #         ohvs = doc2hashvalues(text, num_perm, HASH_RANGES, PERMUTATIONS)
+                #         data = json.loads(line)
+                #         chvs = data["hashvalues"]
+                #         chvs = from_b85hashvalues(chvs)
+                #         assert ohvs == chvs
+                fout.write(line)
+    print(output_file, count, b85)