Upload 9 files

new/H2Retrieval_bce.py

@@ -0,0 +1,90 @@
+# conda install sentence-transformers -c conda-forge
+from sentence_transformers import SentenceTransformer
+import pandas as pd
+from collections import defaultdict
+import torch
+from tqdm import tqdm
+from new.test_pytrec_eval import ndcg_in_all
+
+if torch.cuda.is_available():
+    device = torch.device('cuda')
+else:
+    device = torch.device('cpu')
+
+
+def load_dataset(path):
+    df = pd.read_parquet(path, engine="pyarrow")
+    return df
+
+
+def load_all_dataset(path, convert=False):
+    qrels_pd = load_dataset(path + r'\qrels.parquet')
+    corpus = load_dataset(path + r'\corpus.parquet')
+    queries = load_dataset(path + r'\queries.parquet')
+    if convert:
+        qrels = defaultdict(dict)
+        for i, e in tqdm(qrels_pd.iterrows(), desc="load_all_dataset: Converting"):
+            qrels[e['qid']][e['cid']] = e['score']
+    else:
+        qrels = qrels_pd
+    return corpus, queries, qrels
+
+
+corpus, queries, qrels = load_all_dataset(r'D:\datasets\H2Retrieval\new\data_sample1k')
+
+
+randEmbed = True
+if randEmbed:
+    corpusEmbeds = torch.rand((1, len(corpus)))
+    queriesEmbeds = torch.rand((len(queries), 1))
+else:
+    with torch.no_grad():
+        path = r'D:\models\bce'
+        model = SentenceTransformer(path, device='cuda:0')
+
+        corpusEmbeds = model.encode(corpus['text'].values, normalize_embeddings=True, show_progress_bar=True, batch_size=32)
+        queriesEmbeds = model.encode(queries['text'].values, normalize_embeddings=True, show_progress_bar=True, batch_size=32)
+
+        queriesEmbeds = torch.tensor(queriesEmbeds, device=device)
+        corpusEmbeds = corpusEmbeds.T
+        corpusEmbeds = torch.tensor(corpusEmbeds, device=device)
+
+
+@torch.no_grad()
+def getTopK(corpusEmbeds, qEmbeds, qid, k=200):
+    scores = qEmbeds @ corpusEmbeds
+    top_k_indices = torch.argsort(scores, descending=True)[:k]
+    scores = scores.cpu()
+    top_k_indices = top_k_indices.cpu()
+    retn = []
+    for x in top_k_indices:
+        x = int(x)
+        retn.append((qid, corpus['cid'][x], float(scores[x])))
+    return retn
+
+def print_ndcgs(k):
+    with torch.no_grad():
+        results = []
+        for i in tqdm(range(len(queries)), desc="Converting"):
+            results.extend(getTopK(corpusEmbeds, queriesEmbeds[i], queries['qid'][i], k=k))
+
+    results = pd.DataFrame(results, columns=['qid', 'cid', 'score'])
+    results['score'] = results['score'].astype(float)
+    tmp = ndcg_in_all(qrels, results)
+    ndcgs = torch.tensor([x for x in tmp.values()], device=device)
+
+    mean = torch.mean(ndcgs)
+    std = torch.std(ndcgs)
+
+    print(f'NDCG@{k}: {mean*100:.2f}±{std*100:.2f}')
+
+print_ndcgs(5)
+print_ndcgs(10)
+print_ndcgs(15)
+print_ndcgs(20)
+print_ndcgs(30)
+# # 手动释放CUDA缓存内存
+# del queriesEmbeds
+# del corpusEmbeds
+# del model
+# torch.cuda.empty_cache()

new/data/corpus.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d67866969f5e82dc3b85fe0ed9c43ea96253b9c89463c1cf643e2cdfb6420f88
+size 42572321

new/data/qrels.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35fb7a5c36f5b00cf35ad083900d2a9ccc9ef0eb38ef22b2adc9743a658bf8ad
+size 417621

new/data/queries.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b0c22d59d9d620ae7f6b5d9f12202d8e7dc8965f92e2769ac46cf561e9961deb
+size 2898062

new/data_sample1k/corpus.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:953ac409e644e67ac0776b26deed2b4f180bdeac4cccc05fa91d4eb62e529287
+size 8605887

new/data_sample1k/qrels.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cdda30f96e6b7173affc1071e4e7a12c5cac917d97e44acc8b0451c5e432b99d
+size 78964

new/data_sample1k/queries.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b188665a79683c00ea9a072aa4ef91f0a3939cf971a9a5af41f75bd64c508e8
+size 584130

new/main.py

@@ -0,0 +1,173 @@
+import pandas as pd
+import os
+import gzip
+import random
+import re
+from tqdm import tqdm
+from collections import defaultdict
+
+
+def get_all_files_in_directory(directory, ext=''):
+    all_files = []
+    for root, dirs, files in os.walk(directory):
+        root = root[len(directory):]
+        if root.startswith('\\') or root.startswith('/'):
+            root = root[1:]
+        for file in files:
+            if file.endswith(ext):
+                file_path = os.path.join(root, file)
+                all_files.append(file_path)
+    return all_files
+
+reg_q = re.compile(r'''['"“”‘’「」『』]''')
+reg_e = re.compile(r'''[?!。？！]''')
+def readOne(filePath):
+    with gzip.open(filePath, 'rt', encoding='utf-8') if filePath.endswith('.gz') else open(filePath,
+                                                                                           encoding='utf-8') as f:
+        retn = []
+        cache = ''
+        for line in f:
+            line = reg_q.sub('', line)  # 删除引号
+            if len(cache) + len(line) < 384:
+                cache += line
+                continue
+            if not bool(reg_e.findall(line)):
+                cache += line
+                retn.append(cache.strip())
+                cache = ''
+                continue
+            i = 1
+            s = 0
+            while i <= len(line):
+                if len(cache) + (i - s) < 384:  # 每 384 切一行
+                    i = (384 - len(cache)) + s
+                    if i > len(line):
+                        break
+                    cache += line[s:i]
+                    s = i
+                if line[i-1] in ('?', '!', '。', '？', '！'):
+                    cache += line[s:i]
+                    s = i
+                    retn.append(cache.strip())
+                    cache = ''
+                i += 1
+            if len(line) > s:
+                cache += line[s:]
+
+    cache = cache.strip()
+    if cache:
+        retn.append(cache)
+    return retn
+
+
+def load_dataset(path):
+    df = pd.read_parquet(path, engine="pyarrow")
+    return df
+
+
+def load_all_dataset(path, convert=False):
+    qrels_pd = load_dataset(path + r'\qrels.parquet')
+    corpus = load_dataset(path + r'\corpus.parquet')
+    queries = load_dataset(path + r'\queries.parquet')
+    if convert:
+        qrels = defaultdict(dict)
+        for i, e in tqdm(qrels_pd.iterrows(), desc="load_all_dataset: Converting"):
+            qrels[e['qid']][e['cid']] = e['score']
+    else:
+        qrels = qrels_pd
+    return corpus, queries, qrels
+
+
+def save_dataset(path, df):
+    return df.to_parquet(
+        path,
+        engine="pyarrow",
+        compression="gzip",
+        index=False
+    )
+
+
+def save_all_dataset(path, corpus, queries, qrels):
+    save_dataset(path + r"\corpus.parquet", corpus)
+    save_dataset(path + r"\queries.parquet", queries)
+    save_dataset(path + r"\qrels.parquet", qrels)
+
+
+def create_dataset(corpus, queries, qrels):
+    corpus_pd = pd.DataFrame(corpus, columns=['cid', 'text'])
+    queries_pd = pd.DataFrame(queries, columns=['qid', 'text'])
+    qrels_pd = pd.DataFrame(qrels, columns=['qid', 'cid', 'score'])
+
+    corpus_pd['cid'] = corpus_pd['cid'].astype(str)
+    queries_pd['qid'] = queries_pd['qid'].astype(str)
+    qrels_pd['qid'] = qrels_pd['qid'].astype(str)
+    qrels_pd['cid'] = qrels_pd['cid'].astype(str)
+    qrels_pd['score'] = qrels_pd['score'].astype(int)
+
+    return corpus_pd, queries_pd, qrels_pd
+
+
+def sample_from_dataset(corpus, queries, qrels, k=5000):
+    sample_k = sorted(random.sample(queries['qid'].to_list(), k=k))
+    queries_pd = queries[queries['qid'].isin(sample_k)]
+    qrels_pd = qrels[qrels['qid'].isin(sample_k)]
+    corpus_pd = corpus[corpus['cid'].isin(qrels_pd['cid'])]
+
+    return corpus_pd, queries_pd, qrels_pd
+
+path = r'D:\datasets\h-corpus\h-ss-corpus'
+rawcorpus = get_all_files_in_directory(path, '.txt.gz')
+corpus = []
+queries = []
+qrels = []
+
+for sub_path in tqdm(rawcorpus[103045:], desc="Reading all data..."):
+    tmp = readOne(os.path.join(path, sub_path))
+    if len(tmp) < 5:
+        continue
+    阈值 = max(len(tmp) // 4, 4)  # 大约每个文件抽 4*5 = 20 条语料
+    # print(阈值)
+    old_rand = None
+    for i in range(len(tmp)):
+        rand = random.randint(0, 阈值)
+        if rand == 0 and (old_rand is None or old_rand != 0):
+            queries.append((sub_path, i/(len(tmp)-1), tmp[i]))
+        elif rand <= 4 or old_rand == 0:
+            corpus.append((sub_path, i/(len(tmp)-1), tmp[i]))
+            rand = 1
+        else:
+            pass
+        old_rand = rand
+
+tmp = random.sample(range(len(queries)), k=5000)
+tmp.sort()
+queries = [queries[i] for i in tmp]
+
+sidx = 0
+for qid, q in tqdm(enumerate(queries), desc="计算 qrels 中..."):
+    mt = False
+    for cid in range(sidx, len(corpus)):
+        c = corpus[cid]
+        if q[0] == c[0]:
+            mt = True
+            ss = 1 - abs(q[1] - c[1])
+            qrels.append((qid, cid, 100 * ss))
+        else:
+            if mt:
+                sidx = cid + 1
+                break
+
+corpus_ = [(cid, c[2]) for cid, c in enumerate(corpus)]
+queries_ = [(qid, q[2]) for qid, q in enumerate(queries)]
+
+path = r'D:\datasets\H2Retrieval\new'
+corpus_pd, queries_pd, qrels_pd = create_dataset(corpus_, queries_, qrels)
+tmp = corpus_pd[corpus_pd['cid'].isin(qrels_pd['cid'])]
+corpus_pd = tmp
+save_all_dataset(path + r'\data', corpus_pd, queries_pd, qrels_pd)
+save_all_dataset(path + r'\data_sample1k', *sample_from_dataset(corpus_pd, queries_pd, qrels_pd, k=1000))
+
+
+# save_all_dataset(path + r'\data_sample1k', *sample_from_dataset(*load_all_dataset(r'D:\datasets\H2Retrieval\new\data_sample5k'), k=1000))
+
+tmp = load_all_dataset(r'D:\datasets\H2Retrieval\new\data')

new/test_pytrec_eval.py

@@ -0,0 +1,72 @@
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+
+def dcg(scores):
+    log2_i = np.log2(np.arange(2, len(scores) + 2))
+    return np.sum(scores / log2_i)
+
+
+def idcg(rels, topk):
+    return dcg(np.sort(rels)[::-1][:topk])
+
+
+def odcg(rels, predictions):
+    indices = np.argsort(predictions)[::-1]
+    return dcg(rels[indices])
+
+
+def _ndcg(drels, dpredictions):
+    topk = len(dpredictions)
+    _idcg = idcg(np.array(drels['score']), topk)
+    tmp = drels[drels.index.isin(dpredictions.index)]
+    rels = dpredictions['score'].copy()
+    rels *= 0
+    rels.update(tmp['score'])
+    _odcg = odcg(rels.values, dpredictions['score'].values)
+    return float(_odcg / _idcg)
+
+
+def ndcg(qrels, results):
+    drels = qrels.set_index('cid', inplace=False)
+    dpredictions = results.set_index('cid', inplace=False)
+    # print(drels, dpredictions)
+    return _ndcg(drels, dpredictions)
+
+
+def ndcg_in_all(qrels, results):
+    retn = {}
+    _qrels = {qid: group for qid, group in qrels.groupby('qid')}
+    _results = {qid: group for qid, group in results.groupby('qid')}
+    for qid in tqdm(_results, desc="计算 ndcg 中..."):
+        if qid in _qrels:
+            retn[qid] = ndcg(_qrels[qid], _results[qid])
+    return retn
+
+
+if __name__ == '__main__':
+    qrels = pd.DataFrame(
+        [
+            ['q1', 'd1', 1],
+            ['q1', 'd2', 2],
+            ['q1', 'd3', 3],
+            ['q1', 'd4', 4],
+            ['q2', 'd1', 2],
+            ['q2', 'd2', 1]
+        ],
+        columns=['qid', 'cid', 'score']
+    )
+
+    results = pd.DataFrame(
+        [
+            ['q1', 'd2', 1],
+            ['q1', 'd3', 2],
+            ['q1', 'd4', 3],
+            ['q2', 'd2', 1],
+            ['q2', 'd3', 2],
+            ['q2', 'd5', 2]
+        ],
+        columns=['qid', 'cid', 'score']
+    )
+    print(ndcg_in_all(qrels, results))