Upload 6 files

G2Retrieval_bce.py

@@ -0,0 +1,85 @@
+# 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 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\G2Retrieval\data_sample2k')
+
+
+randEmbed = False
+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=10):
+    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
+
+
+with torch.no_grad():
+    results = []
+    for i in tqdm(range(len(queries)), desc="Converting"):
+        results.extend(getTopK(corpusEmbeds, queriesEmbeds[i], queries['qid'][i]))
+
+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@10: {mean*100:.2f}±{std*100:.2f}')
+
+# 手动释放CUDA缓存内存
+del queriesEmbeds
+del corpusEmbeds
+del model
+torch.cuda.empty_cache()

data_sample2k/corpus.parquet

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

data_sample2k/qrels.parquet

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

data_sample2k/queries.parquet

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

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=2000):
+    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\v-corpus-zh'
+rawcorpus = get_all_files_in_directory(path, '.txt.gz')
+corpus = []
+queries = []
+qrels = []
+
+for sub_path in tqdm(rawcorpus, desc="Reading all data..."):
+    s_sub_path = sub_path.split('\\')
+    会社 = s_sub_path[0]
+    if len(s_sub_path) == 3:
+        系列 = None
+        作品 = s_sub_path[-2]
+        篇章 = s_sub_path[-1]
+    elif len(s_sub_path) == 4:
+        系列 = s_sub_path[1]
+        作品 = s_sub_path[-2]
+        篇章 = s_sub_path[-1]
+    else:
+        print(s_sub_path)
+        raise ValueError('s_sub_path != 3 or 4')
+    print(会社, 系列, 作品, 篇章)
+    tmp = readOne(os.path.join(path, sub_path))
+    阈值 = max(len(tmp) // 40, 4)
+    print(阈值)
+    old_rand = None
+    for i in range(len(tmp)):
+        rand = random.randint(0, 阈值)
+        if rand == 0:
+            queries.append((会社, 系列, 作品, 篇章, i/(len(tmp)-1), tmp[i]))
+        elif rand <= 4 or old_rand == 0:
+            corpus.append((会社, 系列, 作品, 篇章, i/(len(tmp)-1), tmp[i]))
+        else:
+            pass
+        old_rand = rand
+
+for qid, q in tqdm(enumerate(queries), desc="计算 qrels 中..."):
+    for cid, c in enumerate(corpus):
+        if q[0] == c[0]:
+            s = 1
+            if q[1] is not None and q[1] == c[1]:
+                s += 4
+            if q[2] == q[2]:
+                s += 8
+                if q[3] == q[3]:
+                    s += 8
+                    ss = 1 - abs(q[4] - c[4])
+                    s += (79 * ss)
+            qrels.append((qid, cid, s))
+
+corpus_ = [(cid, c[5]) for cid, c in enumerate(corpus)]
+queries_ = [(qid, q[5]) for qid, q in enumerate(queries)]
+
+path = r'D:\datasets\G2Retrieval'
+corpus_pd, queries_pd, qrels_pd = create_dataset(corpus_, queries_, qrels)
+save_all_dataset(path + r'\data', corpus_pd, queries_pd, qrels_pd)
+save_all_dataset(path + r'\data_sample2k', *sample_from_dataset(corpus_pd, queries_pd, qrels_pd))

test_pytrec_eval.py

@@ -0,0 +1,71 @@
+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(_qrels, desc="计算 ndcg 中..."):
+        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))