|
import json |
|
import os |
|
import tarfile |
|
import zipfile |
|
import gzip |
|
import requests |
|
from random import shuffle, seed |
|
|
|
from glob import glob |
|
from itertools import chain |
|
import gdown |
|
|
|
validation_ratio = 0.2 |
|
top_n = 10 |
|
|
|
|
|
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 = {} |
|
all_relation_type = {} |
|
positives_score = {} |
|
seed(42) |
|
|
|
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: |
|
|
|
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 = [[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) |
|
|
|
positive_pairs = positive_pairs[:min(top_n, len(positive_pairs))] |
|
shuffle(positive_pairs) |
|
positives_score[relation_id] = positive_pairs |
|
positives[relation_id] = list(list(zip(*positive_pairs))[1]) |
|
|
|
negative_pairs = [tuple(p.split(':')) for s, p in filter(lambda _x: _x[0] < 0, scales)] |
|
shuffle(negative_pairs) |
|
negatives[relation_id] = negative_pairs |
|
|
|
all_relation_type[relation_id] = relation_type |
|
|
|
|
|
for k in positives.keys(): |
|
negatives[k] += list(chain(*[_v for _k, _v in positives.items() if _k != k])) |
|
|
|
|
|
|
|
positives_valid = {k: v[:int(len(v) * validation_ratio)] for k, v in positives.items()} |
|
positives_train = {k: v[int(len(v) * validation_ratio):] for k, v in positives.items()} |
|
|
|
negatives_valid = {k: v[:int(len(v) * validation_ratio)] for k, v in negatives.items()} |
|
negatives_train = {k: v[int(len(v) * validation_ratio):] for k, v in negatives.items()} |
|
|
|
positives_score_valid = {k: v[:int(len(v) * validation_ratio)] for k, v in positives_score.items()} |
|
positives_score_train = {k: v[int(len(v) * validation_ratio):] for k, v in positives_score.items()} |
|
|
|
outputs = [] |
|
for positives, negatives, positives_score in zip( |
|
[positives_train, positives_valid], |
|
[negatives_train, negatives_valid], |
|
[positives_score_train, positives_score_valid]): |
|
pairs = {k: [positives[k], negatives[k]] for k in positives.keys()} |
|
parent = list(set([i[:-1] for i in all_relation_type.keys()])) |
|
relation_structure = {p: [i for i in all_relation_type.keys() if p == i[:-1]] for p in parent} |
|
for k, v in relation_structure.items(): |
|
positive = list(chain(*[positives_score[_v] for _v in v])) |
|
positive = list(list(zip(*sorted(positive, key=lambda x: x[0], reverse=True)))[1]) |
|
negative = [] |
|
for _k, _v in relation_structure.items(): |
|
if _k != k: |
|
negative += list(chain(*[positives[__v] for __v in _v])) |
|
pairs[k] = [positive, negative] |
|
outputs.append([{'relation_type': k, 'positives': pos, 'negatives': neg} for k, (pos, neg) in pairs.items()]) |
|
return outputs |
|
|
|
|
|
if __name__ == '__main__': |
|
data_train, data_valid = get_training_data() |
|
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_valid])) |
|
|
