Datasets:
GEM
/
SIMPITIKI

Languages: Italian
Multilinguality: unknown
Size Categories: unknown
Language Creators: unknown
Annotations Creators: crowd-sourced
Source Datasets: original
License: cc-by-4.0
SIMPITIKI / train_val_test_split.py
Sebastien Montella
fix challenge transformation error
dd3cf43
# -*- coding: utf-8 -*-
import os
import sys
import json
import random
import argparse
import xml.etree.ElementTree as ET
def load_xml_file(path):
""" Load an xml file.
Args:
path (:obj:`float`): Path where the XML file is stored.
Returns:
tree (:obj:`ElementTree`): Parsed tree structure of the XML file.
"""
tree = ET.parse(path)
return tree
def save_json(data, path):
""" Save data as json file.
Args:
data (:obj:`list`): Data to store as json.
path (:obj:`str`): Path where data will be stored.
Returns:
None
"""
json.dump(data, open(path, 'w+', encoding='utf-8'))
def save_jsonl(data, path):
""" Save data as a json file where each line is a dictionary
Args:
data (:obj:`list`): Data to store as json.
path (:obj:`str`): Path where data will be stored.
Returns:
None
"""
with open(path, 'w+', encoding='utf-8') as f:
for sample_dict in data:
f.write(json.dumps(sample_dict))
f.write('\n')
def get_types(xml):
""" Extract the different transformation types.
Args:
xml (:obj:`ElementTree`): XML as tree.
Returns:
transformations_types (:obj:`dict`): Mapping of transformations ids to their type
Example:
>>assert transformations_types[34] == 'Transformation - Noun to Verb' # True
"""
transformations_types = {}
root = xml.getroot()
types = root[0]
for curr_type in types:
transformations_types[int(curr_type.attrib['id'])] = curr_type.text
return transformations_types
def create_pair(text, simplified_text, transformation_id, transformation_type, source_dataset):
""" Instanciate pair given parameters.
Args:
text (:obj:`str`): Raw text.
simplified_text (:obj:`str`): Simplified text.
transformation_id (:obj:`int`): Transformation ID
transformation_type (:obj:`str`): Transformation Category
source_dataset (:obj:`str`): Source dataset from which the pair comes from.
Returns:
pair (:obj:`dict`): Complex-Simplified Text pair with corresponding information.
"""
pair = {}
pair['transformation_id'] = transformation_id
pair['transformation_type'] = transformation_type
pair['source_dataset'] = source_dataset
pair['text'] = text
pair['simplified_text'] = simplified_text
return pair
def fill_pairs_by_transformation(pairs_by_transformation, pair):
""" This function adds a pair to the pairs_by_transformation dict. (into corresponding field).
Args:
pairs_by_transformation (:obj:`dict`): Dictionnary where pairs are organized by their
transformation types.
pair (:obj:`dict`): Complex-Simplified Text pair with corresponding information.
Returns:
None
"""
transformation_id = pair['transformation_id']
if transformation_id not in pairs_by_transformation.keys():
pairs_by_transformation[transformation_id] = [pair]
else:
pairs_by_transformation[transformation_id].append(pair)
def fill_pairs_by_source_dataset(pairs_by_source_dataset, pair):
""" This function adds a pair to the pairs_by_source_dataset dict. to corresponding field.
Args:
pairs_by_source_dataset (:obj:`dict`): Dictionnary where pairs are organized by their
source dataset.
pair (:obj:`dict`): Complex-Simplified Text pair with corresponding information.
Returns:
None
"""
source_dataset = pair['source_dataset']
if source_dataset not in pairs_by_source_dataset.keys():
pairs_by_source_dataset[source_dataset] = [pair]
else:
pairs_by_source_dataset[source_dataset].append(pair)
def get_pairs(xml, types):
""" This function returns Complex-Simplified pairs from XML.
Args:
xml (:obj:`ElementTree`): XML simplifications pairs as tree structure.
types (:obj:`dict`): Mapping of transformations ID to their transformations category.
Returns:
pairs (:obj:`list`): List of pairs (:obj:`dict`) without any ordering.
pairs_by_transformation (:obj:`dict`): Pairs clustered by their transformation type.
pairs_by_source_dataset (:obj:`dict`): Pairs clustered by their source dataset.
"""
root = xml.getroot()
simplifications = root[1]
pairs = []
pairs_by_transformation = {}
pairs_by_source_dataset = {}
for simplification in simplifications:
transformation_id = int(simplification.attrib['type'])
source = simplification.attrib['origin']
raw_text = simplification[0].text
simplified_text = simplification[1].text
curr_pair = create_pair(raw_text, simplified_text, transformation_id, types[transformation_id], source)
pairs.append(curr_pair)
fill_pairs_by_transformation(pairs_by_transformation, curr_pair)
fill_pairs_by_source_dataset(pairs_by_source_dataset, curr_pair)
return pairs, pairs_by_transformation, pairs_by_source_dataset
def random_split(pairs, training_ratio):
""" This function randomly splits pairs as train/val/test subsets.
Args:
pairs (:obj:`list`): List of pairs (:obj:`dict`) without any ordering.
training_ratio (:obj:`float`): Ratio of training data (0<training_ratio<1).
Returns:
train (:obj:`list`): Training set
validation (:obj:`list`): Validation set
test (:obj:`list`): Testing set
"""
random.shuffle(pairs)
size = len(pairs)
train_limit = int(size * training_ratio)
val_limit = train_limit + int(size*(1-training_ratio)/2)
train = pairs[:train_limit]
val = pairs[train_limit:val_limit]
test = pairs[val_limit:]
return train, val, test
def challenge_seen_unseen_transformation_split(pairs_by_transformation, training_ratio):
""" This function splits pairs s.t. evaluation can be done on seen and unseen
transformations for more challenging robustness/generalization evaluation.
Args:
pairs_by_transformation (:obj:`dict`): Pairs organized by their transformation ID.
training_ratio (:obj:`float`): Ratio of training data (0<training_ratio<1).
Returns:
train (:obj:`list`): Training set
validation (:obj:`list`): Validation set
seen_transformations_test (:obj:`list`): Seen Transformations testing set
unseen_transformations_test (:obj:`list`): Unseen transformations testing set
"""
# TODO transformations are hard-coded for now --> add argument in parser to specify them.
seen_transformations_ids = [1, 2, 3, 11, 13, 21, 23, 31, 33, 34, 37]
unseen_transformations_ids = [12, 22, 32, 35, 36]
train = []
val = []
seen_transformations_test = []
unseen_transformations_test = []
total_samples= 0
for transf_id in unseen_transformations_ids:
total_samples += len(pairs_by_transformation[transf_id])
for transf_id in seen_transformations_ids:
curr_len = len(pairs_by_transformation[transf_id])
train_limit = int(curr_len * training_ratio)
val_limit = int(curr_len * (training_ratio + (1-training_ratio)/2.0))
train += pairs_by_transformation[transf_id][:train_limit]
val += pairs_by_transformation[transf_id][train_limit:val_limit]
seen_transformations_test += pairs_by_transformation[transf_id][val_limit:]
for transf_id in unseen_transformations_ids:
unseen_transformations_test += pairs_by_transformation[transf_id]
return train, val, seen_transformations_test, unseen_transformations_test
def challenge_seen_unseen_source_dataset_split(pairs_by_source_dataset, training_ratio):
""" This function splits pairs s.t. evaluation can be done on seen and unseen
source dataset for more challenging robustness/generalization evaluation.
Args:
pairs_by_source_dataset (:obj:`dict`): Pairs organized by their source dataset.
training_ratio (:obj:`float`): Ratio of training data (0<training_ratio<1).
Returns:
train (:obj:`list`): Training set
validation (:obj:`list`): Validation set
seen_source_test (:obj:`list`): Seen source dataset testing set
unseen_source_test (:obj:`list`): Unseen source dataset testing set
"""
# TODO source dataset for training hard-coded --> add argument in parser.
seen_source = ['itwiki'] # semi-supervised
unseen_source = ['tn'] # manually annotated
train = []
val = []
seen_source_test = []
unseen_source_test = []
for source in seen_source:
random.shuffle(pairs_by_source_dataset[source])
curr_len = len(pairs_by_source_dataset[source])
train_limit = int(curr_len * training_ratio)
val_limit = train_limit + int(curr_len * (1-training_ratio)/2.0)
train += pairs_by_source_dataset[source][:train_limit]
val += pairs_by_source_dataset[source][train_limit:val_limit]
seen_source_test += pairs_by_source_dataset[source][val_limit:]
for source in unseen_source:
unseen_source_test += pairs_by_source_dataset[source]
return train, val, seen_source_test, unseen_source_test
def split(args):
"""This function splits the XML file to produce specified subsets according to args.
Args:
args (:obj:`argparse.Namespace`): Parsed arguments.
Returns:
None
"""
xml = load_xml_file(args.data_path)
version = args.data_path[-6:-4]
transformations_types = get_types(xml)
pairs, pairs_by_transformation, pairs_by_source_dataset = get_pairs(xml, transformations_types)
total_samples = 0
for transf_id in pairs_by_transformation.keys():
total_samples += len(pairs_by_transformation[transf_id])
if args.split_criteria == 'random':
train, val, test = random_split(pairs, args.training_ratio)
os.makedirs(f'{args.out_dir}/{version}/random_split/', exist_ok=True)
save_jsonl(train, f'{args.out_dir}/{version}/random_split/train.jsonl')
save_jsonl(val, f'{args.out_dir}/{version}/random_split/val.jsonl')
save_jsonl(test, f'{args.out_dir}/{version}/random_split/test.jsonl')
elif args.split_criteria == 'transformations':
seen_transformations_train, seen_transformations_val, seen_transformations_test, unseen_transformations_test = challenge_seen_unseen_transformation_split(pairs_by_transformation, args.training_ratio)
os.makedirs(f'{args.out_dir}/{version}/transformations_split/', exist_ok=True)
save_jsonl(seen_transformations_train, f'{args.out_dir}/{version}/transformations_split/train.jsonl')
save_jsonl(seen_transformations_val, f'{args.out_dir}/{version}/transformations_split/val.jsonl')
save_jsonl(seen_transformations_test, f'{args.out_dir}/{version}/transformations_split/seen_transformations_test.jsonl')
save_jsonl(unseen_transformations_test, f'{args.out_dir}/{version}/transformations_split/unseen_transformations_test.jsonl')
elif args.split_criteria == 'source_dataset':
itwiki_train, itwiki_val, itwiki_test, tn_test = challenge_seen_unseen_source_dataset_split(pairs_by_source_dataset, args.training_ratio)
os.makedirs(f'{args.out_dir}/{version}/source_dataset_split/', exist_ok=True)
save_jsonl(itwiki_train, f'{args.out_dir}/{version}/source_dataset_split/itwiki_train.jsonl')
save_jsonl(itwiki_val, f'{args.out_dir}/{version}/source_dataset_split/itwiki_val.jsonl')
save_jsonl(itwiki_test, f'{args.out_dir}/{version}/source_dataset_split/itwiki_test.jsonl')
save_jsonl(tn_test, f'{args.out_dir}/{version}/source_dataset_split/tn_test.jsonl')
if __name__ == '__main__':
parser = argparse.ArgumentParser(description="Creating Train/Val/Test files")
parser.add_argument('--data_path', type=str, required=True, help='path to (single) data file')
parser.add_argument('--out_dir', type=str, required=True, help='output dir to store files')
parser.add_argument('--training_ratio', type=float, required=True, help='training ratio (e.g. 0.7). Remaining will be divided for val and test EQUALLY.')
parser.add_argument('--split_criteria', type=str, required=True, choices=['random', 'transformations', 'source_dataset'], help='split criteria')
args = parser.parse_args()
split(args)
sys.exit(0)