# -*- 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 add argument in parser to specify them. seen_transformations_ids = [1, 2, 3, 11, 13, 23, 31, 32, 33, 34, 37] unseen_transformations_ids = [12, 22, 32, 35, 36] train = [] val = [] seen_transformations_test = [] unseen_transformations_test = [] for transf_id in seen_transformations_ids: curr_len = len(pairs_by_transformation[transf_id]) train_limit = int(curr_len * training_ratio) val_limit = train_limit + int(curr_len * (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 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) 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.8). 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)