import json import os import tarfile import zipfile import gzip import requests from glob import glob import gdown from random import seed, shuffle validation_ratio = 0.2 k = 10 # the 3rd level negative-distance ranking m = 5 # the 3rd level negative-distance ranking top_n = 10 # threshold of positive pairs in the 1st and 2nd relation seed(42) def wget(url, cache_dir: str = './cache', gdrive_filename: str = None): """ wget and uncompress data_iterator """ os.makedirs(cache_dir, exist_ok=True) if url.startswith('https://drive.google.com'): assert gdrive_filename is not None, 'please provide fileaname for gdrive download' gdown.download(url, f'{cache_dir}/{gdrive_filename}', quiet=False) filename = gdrive_filename else: filename = os.path.basename(url) with open(f'{cache_dir}/{filename}', "wb") as f: r = requests.get(url) f.write(r.content) path = f'{cache_dir}/{filename}' if path.endswith('.tar.gz') or path.endswith('.tgz') or path.endswith('.tar'): if path.endswith('.tar'): tar = tarfile.open(path) else: tar = tarfile.open(path, "r:gz") tar.extractall(cache_dir) tar.close() os.remove(path) elif path.endswith('.zip'): with zipfile.ZipFile(path, 'r') as zip_ref: zip_ref.extractall(cache_dir) os.remove(path) elif path.endswith('.gz'): with gzip.open(path, 'rb') as f: with open(path.replace('.gz', ''), 'wb') as f_write: f_write.write(f.read()) os.remove(path) def get_training_data(): """ Get RelBERT training data Returns ------- pairs: dictionary of list (positive pairs, negative pairs) {'1b': [[0.6, ('office', 'desk'), ..], [[-0.1, ('aaa', 'bbb'), ...]] """ cache_dir = 'cache' os.makedirs(cache_dir, exist_ok=True) remove_relation = None path_answer = f'{cache_dir}/Phase2Answers' path_scale = f'{cache_dir}/Phase2AnswersScaled' url = 'https://drive.google.com/u/0/uc?id=0BzcZKTSeYL8VYWtHVmxUR3FyUmc&export=download' filename = 'SemEval-2012-Platinum-Ratings.tar.gz' if not (os.path.exists(path_scale) and os.path.exists(path_answer)): wget(url, gdrive_filename=filename, cache_dir=cache_dir) files_answer = [os.path.basename(i) for i in glob(f'{path_answer}/*.txt')] files_scale = [os.path.basename(i) for i in glob(f'{path_scale}/*.txt')] assert files_answer == files_scale, f'files are not matched: {files_scale} vs {files_answer}' positives = {} negatives = {} positives_limit = {} all_relation_type = {} # score_range = [90.0, 88.7] # the absolute value of max/min prototypicality rating for i in files_scale: relation_id = i.split('-')[-1].replace('.txt', '') if remove_relation and int(relation_id[:-1]) in remove_relation: continue with open(f'{path_answer}/{i}', 'r') as f: lines_answer = [_l.replace('"', '').split('\t') for _l in f.read().split('\n') if not _l.startswith('#') and len(_l)] relation_type = list(set(list(zip(*lines_answer))[-1])) assert len(relation_type) == 1, relation_type relation_type = relation_type[0] with open(f'{path_scale}/{i}', 'r') as f: # list of tuple [score, ("a", "b")] scales = [[float(_l[:5]), _l[6:].replace('"', '')] for _l in f.read().split('\n') if not _l.startswith('#') and len(_l)] scales = sorted(scales, key=lambda _x: _x[0]) # positive pairs are in the reverse order of prototypicality score positive_pairs = [[s, tuple(p.split(':'))] for s, p in filter(lambda _x: _x[0] > 0, scales)] positive_pairs = sorted(positive_pairs, key=lambda x: x[0], reverse=True) positives[relation_id] = list(list(zip(*positive_pairs))[1]) positives_limit[relation_id] = list(list(zip(*positive_pairs[:min(top_n, len(positive_pairs))]))[1]) negatives[relation_id] = [tuple(p.split(':')) for s, p in filter(lambda _x: _x[0] < 0, scales)] all_relation_type[relation_id] = relation_type parent = list(set([i[:-1] for i in all_relation_type.keys()])) # 1st level relation contrast (among parent relations) relation_pairs_1st = [] relation_pairs_1st_validation = [] for p in parent: child_positive = list(filter(lambda x: x.startswith(p), list(all_relation_type.keys()))) child_negative = list(filter(lambda x: not x.startswith(p), list(all_relation_type.keys()))) positive_pairs = [] negative_pairs = [] for c in child_positive: positive_pairs += positives_limit[c] for c in child_negative: negative_pairs += positives_limit[c] shuffle(positive_pairs) positive_pairs_val = positive_pairs[:int(len(positive_pairs) * validation_ratio)] positive_pairs_tra = positive_pairs[int(len(positive_pairs) * validation_ratio):] shuffle(negative_pairs) negative_pairs_val = negative_pairs[:int(len(negative_pairs) * validation_ratio)] negative_pairs_tra = negative_pairs[int(len(negative_pairs) * validation_ratio):] relation_pairs_1st += [{ "positives": positive_pairs_tra, "negatives": negative_pairs_tra, "relation_type": p, "level": "parent" }] relation_pairs_1st_validation += [{ "positives": positive_pairs_val, "negatives": negative_pairs_val, "relation_type": p, "level": "parent" }] # 2nd level relation contrast (among child relations) & 3rd level relation contrast (within child relations) relation_pairs_2nd = [] relation_pairs_2nd_validation = [] for p in all_relation_type.keys(): positive_pairs = positives_limit[p] negative_pairs = [] for n in all_relation_type.keys(): if p == n: continue negative_pairs += positives[n] shuffle(positive_pairs) positive_pairs_val = positive_pairs[:int(len(positive_pairs) * validation_ratio)] positive_pairs_tra = positive_pairs[int(len(positive_pairs) * validation_ratio):] shuffle(negative_pairs) negative_pairs_val = negative_pairs[:int(len(negative_pairs) * validation_ratio)] negative_pairs_tra = negative_pairs[int(len(negative_pairs) * validation_ratio):] relation_pairs_2nd += [{ "positives": positive_pairs_tra, "negatives": negative_pairs_tra, "relation_type": p, "level": "child" }] relation_pairs_2nd_validation += [{ "positives": positive_pairs_val, "negatives": negative_pairs_val, "relation_type": p, "level": "child" }] relation_pairs_3rd = [] for p in all_relation_type.keys(): positive_pairs = positives[p] negative_pairs = positives[p] + negatives[p] for n, anchor in enumerate(positive_pairs): if n > m: continue for _n, posi in enumerate(positive_pairs): if n < _n and len(negative_pairs) > _n + k: relation_pairs_3rd += [{ # "positives": [(anchor, posi)], # "negatives": [(anchor, neg) for neg in negative_pairs[_n+k:]], "positives": [anchor, posi], "negatives": negative_pairs[_n + k:], "relation_type": p, "level": "child_prototypical" }] print(len(relation_pairs_3rd)) shuffle(relation_pairs_3rd) relation_pairs_3rd_validation = relation_pairs_3rd[:int(len(relation_pairs_3rd)*validation_ratio)] relation_pairs_3rd = relation_pairs_3rd[int(len(relation_pairs_3rd) * validation_ratio):] train = relation_pairs_1st + relation_pairs_2nd + relation_pairs_3rd validation = relation_pairs_1st_validation + relation_pairs_2nd_validation + relation_pairs_3rd_validation return train, validation if __name__ == '__main__': data_train, data_validation = get_training_data() print(f"- training data : {len(data_train)}") print(f"- validation data : {len(data_validation)}") with open('dataset/train.jsonl', 'w') as f_writer: f_writer.write('\n'.join([json.dumps(i) for i in data_train])) with open('dataset/valid.jsonl', 'w') as f_writer: f_writer.write('\n'.join([json.dumps(i) for i in data_validation]))