Datasets:
Tasks:
Text2Text Generation
Sub-tasks:
text-simplification
Languages:
Italian
Multilinguality:
unknown
Size Categories:
unknown
Language Creators:
unknown
Annotations Creators:
crowd-sourced
Source Datasets:
original
License:
cc-by-4.0
| # -*- 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) | |