adding raw xml + json splits + scripts

.gitattributes

@@ -25,3 +25,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zstandard filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text

simpitiki.py

@@ -0,0 +1,278 @@
+# coding=utf-8
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""TODO: Add a description here."""
+
+
+import csv
+import json
+import os
+import datasets
+from lxml import etree
+
+# TODO: Add BibTeX citation
+# Find for instance the citation on arxiv or on the dataset repo/website
+_CITATION = """\
+@article{tonelli2016simpitiki,
+  title={SIMPITIKI: a Simplification corpus for Italian},
+  author={Tonelli, Sara and Aprosio, Alessio Palmero and Saltori, Francesca},
+  journal={Proceedings of CLiC-it},
+  year={2016}
+}
+"""
+
+# TODO: Add description of the dataset here
+# You can copy an official description
+_DESCRIPTION = """\
+SIMPITIKI is a Simplification corpus for Italian and it consists of two sets of simplified pairs: the first one is harvested from the Italian Wikipedia in a semi-automatic way; the second one is manually annotated sentence-by-sentence from documents in the administrative domain.
+"""
+
+_HOMEPAGE = "https://github.com/dhfbk/simpitiki"
+
+_LICENSE = "CC-BY 4.0"
+
+_URLs = {
+        "v1":{
+            "random": {
+                "train":"./v1/random_split/train.json",
+                "val":"./v1/random_split/val.json",
+                "test":"./v1/random_split/test.json"
+                },
+            "transformations": {
+                "train": "./v1/transformations_split/train.json",
+                "val": "./v1/transformations_split/val.json",
+                "seen_transformations_test": "./v1/transformations_split/seen_transformations_test.json",
+                "unseen_transformations_test":"./v1/transformations_split/unseen_transformations_test.json"
+                },
+            "source_dataset": {
+                "itwiki_train":"./v1/source_dataset_split/itwiki_train.json",
+                "itwiki_val": "./v1/source_dataset_split/itwiki_val.json", 
+                "itwiki_test":"./v1/source_dataset_split/itwiki_test.json",
+                "tn_test":"./v1/source_dataset_split/tn_test.json"
+                }
+
+
+            },
+        "v2":{
+            "random": {
+                "train":"./v2/random_split/train.json",
+                "val":"./v2/random_split/val.json",
+                "test":"./v2/random_split/test.json"
+                },
+            "transformations": {
+                "train": "./v2/transformations_split/train.json",
+                "val": "./v2/transformations_split/val.json",
+                "seen_transformations_test": "./v2/transformations_split/seen_transformations_test.json",
+                "unseen_transformations_test":"./v2/transformations_split/unseen_transformations_test.json"
+                },
+            "source_dataset": {
+                "itwiki_train":"./v2/source_dataset_split/itwiki_train.json",
+                "itwiki_val": "./v2/source_dataset_split/itwiki_val.json",
+                "itwiki_test":"./v2/source_dataset_split/itwiki_test.json",
+                "tn_test":"./v2/source_dataset_split/tn_test.json"
+                }
+
+
+            }
+
+    }
+
+
+class SIMPITIKI(datasets.GeneratorBasedBuilder):
+    """TODO: Short description of my dataset."""
+
+    VERSION_1 = datasets.Version("1.0.0")
+    VERSION_2 = datasets.Version("2.0.0")
+
+    # This is an example of a dataset with multiple configurations.
+    # If you don't want/need to define several sub-sets in your dataset,
+    # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.
+
+    # If you need to make complex sub-parts in the datasets with configurable options
+    # You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
+    # BUILDER_CONFIG_CLASS = MyBuilderConfig
+
+    # You will be able to load one or the other configurations in the following list with
+    # data = datasets.load_dataset('my_dataset', 'first_domain')
+    # data = datasets.load_dataset('my_dataset', 'second_domain')
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(name="v1", version=VERSION_1, description="First version"),
+        datasets.BuilderConfig(name="v2", version=VERSION_2, description="Second version with better sentence boundaries."),
+    ]
+
+    DEFAULT_CONFIG_NAME = "v2"  # It's not mandatory to have a default configuration. Just use one if it make sense.
+
+    def _info(self):
+        #  This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
+        features = datasets.Features(
+            {
+                "text": datasets.Value("string"),
+                "simplified_text": datasets.Value("string"),
+                "transformation_type":datasets.Value("string"),
+                "source_dataset":datasets.Value("string")
+                # These are the features of your dataset like images, labels ...
+            }
+        )
+        return datasets.DatasetInfo(
+            # This is the description that will appear on the datasets page.
+            description=_DESCRIPTION,
+            # This defines the different columns of the dataset and their types
+            features=features,  # Here we define them above because they are different between the two configurations
+            # If there's a common (input, target) tuple from the features,
+            # specify them here. They'll be used if as_supervised=True in
+            # builder.as_dataset.
+            supervised_keys=None,
+            # Homepage of the dataset for documentation
+            homepage=_HOMEPAGE,
+            # License for the dataset if available
+            license=_LICENSE,
+            # Citation for the dataset
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        """Returns SplitGenerators."""
+        # This method is tasked with downloading/extracting the data and defining the splits depending on the configuration
+        # If several configurations are possible (listed in BUILDER_CONFIGS), the configuration selected by the user is in self.config.name
+
+        # dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLs
+        # It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
+        # By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
+   
+        my_urls = _URLs[self.config.name]
+        downloaded_files = dl_manager.download_and_extract(my_urls)
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "filepath": downloaded_files['random']['train'],
+                    "split": "train",
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "filepath": downloaded_files['random']['val'],
+                    "split": "val"
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "filepath": downloaded_files['random']['test'],
+                    "split": "test",
+                },
+            ),
+
+            datasets.SplitGenerator(
+                name='challenge_seen_transformations_train',
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "filepath": downloaded_files['transformations']['train'],
+                    "split": "challenge_seen_transformations_train",
+                },
+            ),
+
+            
+            datasets.SplitGenerator(
+                name='challenge_seen_transformations_val',
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "filepath": downloaded_files['transformations']['val'],
+                    "split": "challenge_seen_transformations_val",
+                },
+            ),
+
+            datasets.SplitGenerator(
+                name='challenge_seen_transformations_test',
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "filepath": downloaded_files['source_dataset']['seen_transformations_test'],
+                    "split": "challenge_seen_transformations_test",
+                },
+            ),
+
+            datasets.SplitGenerator(
+                name='challenge_unseen_transformations_test',
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "filepath": downloaded_files['source_dataset']['unseen_transformations_test'],
+                    "split": "challenge_unseen_transformations_test",
+                },
+            ),
+
+            datasets.SplitGenerator(
+                name='challenge_itwiki_train',
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "filepath": downloaded_files['source_dataset']['itwiki_train'],
+                    "split": "challenge_itwiki_train",
+                },
+            ),
+
+            datasets.SplitGenerator(
+                name='challenge_itwiki_val',
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "filepath": downloaded_files['source_dataset']['itwiki_val'],
+                    "split": "challenge_itwiki_val",
+                },
+            ),
+
+            datasets.SplitGenerator(
+                name='challenge_itwiki_test',
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "filepath": downloaded_files['source_dataset']['itwiki_test'],
+                    "split": "challenge_itwiki_test",
+                },
+            ),
+            
+            datasets.SplitGenerator(
+                name='challenge_tn_test',
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "filepath": downloaded_files['source_dataset']['tn_test'],
+                    "split": "challenge_tn_test",
+                },
+            ),
+        ]
+
+    def _generate_examples(
+        self, filepath, split  # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
+    ):
+        """ Yields examples as (key, example) tuples. """
+        # This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
+        # The `key` is here for legacy reason (tfds) and is not important in itself.
+
+        with open(filepath, encoding="utf-8") as f:
+            data = json.load(f)
+            for id_, row in enumerate(data):
+                yield id_, {
+                        "text": data["text"],
+                        "simplified_text": data["simplified_text"],
+                        "transformation_type":data["transformation_type"],
+                        "source_dataset": data["source_dataset"],
+                        "gem_id": f"gem-SIMPITIKI-{split}-{id_}",
+                        }
+
+
+if __name__ == '__main__':
+    dataset = SIMPITIKI()
+    
+
+

train_val_test_split.py

@@ -0,0 +1,343 @@
+# -*- 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 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, 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<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)
+
+    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_json(train, f'{args.out_dir}/{version}/random_split/train.json')
+        save_json(val, f'{args.out_dir}/{version}/random_split/val.json')
+        save_json(test, f'{args.out_dir}/{version}/random_split/test.json')
+
+    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_json(seen_transformations_train, f'{args.out_dir}/{version}/transformations_split/train.json')
+        save_json(seen_transformations_val, f'{args.out_dir}/{version}/transformations_split/val.json')
+        save_json(seen_transformations_test, f'{args.out_dir}/{version}/transformations_split/seen_transformations_test.json')
+        save_json(unseen_transformations_test, f'{args.out_dir}/{version}/transformations_split/unseen_transformations_test.json')
+
+    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_json(itwiki_train, f'{args.out_dir}/{version}/source_dataset_split/itwiki_train.json')
+        save_json(itwiki_val, f'{args.out_dir}/{version}/source_dataset_split/itwiki_val.json')
+        save_json(itwiki_test, f'{args.out_dir}/{version}/source_dataset_split/itwiki_test.json')
+        save_json(tn_test, f'{args.out_dir}/{version}/source_dataset_split/tn_test.json')
+        
+
+
+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)

v1/random_split/test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5dac082e3d051d78b25937282edc951ead893ec2a41e87430da684cb7d524990
+size 299984

v1/random_split/train.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cc8b506b54eb812364998689e181575d52df09fc23b67f5054875e3bf288478
+size 1430831

v1/random_split/val.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25256b0fc7d889fa6b25bac2a865e470929919c196cd3be8575b42b1402fdcf8
+size 245148

v1/source_dataset_split/itwiki_test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:69f4035eb57152e71f2f8b667d4ef88e0e2bb7a956829823bfc5a6f51ac900f4
+size 279736

v1/source_dataset_split/itwiki_train.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a34e6a2092856be8dde443891faf53cac526866e77814d65a148b192288d23ce
+size 1096254

v1/source_dataset_split/itwiki_val.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61a87de9dcee3a0c0838722b6c2e4df972f200369947ea3b1db6ce0b640bb4eb
+size 244635

v1/source_dataset_split/tn_test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a001c79926f5594e71d28003ce907f4916ffb0e1e489fb388465d717ab51c92
+size 355338

v1/transformations_split/seen_transformations_test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:047cdb0092a33bb9b6e09632e4e065f184ee9d1f0be28e6430f8a8af1e1024aa
+size 509377

v1/transformations_split/train.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afddddba2efb73de0b8575cc4b2481e5c50a43e1870a4a54515d636685482393
+size 902444

v1/transformations_split/unseen_transformations_test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f832e8d7d939245a8a3e6dc6531fe24b9d44f7064d7f7e4e8f260c1b352b8ed
+size 497149

v1/transformations_split/val.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9655310c9ec3aa5ff52ef8cc3df0bd0c420c932d1af21ebeb1b075e70cba60b0
+size 446973

v2/random_split/test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e65e3eb598fbb694ceef759bdefc1c6e3957b9af1520b1e964203177ddbd859
+size 142960

v2/random_split/train.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3282e371402269ffc06ee0e5e761ee9365c281f1cc8c855f726129643a7d4141
+size 663238

v2/random_split/val.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a83774f26390e04688c5b1f99b35321d621adfd78d3f2ae65a55896367e3e2b7
+size 129446

v2/source_dataset_split/itwiki_test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91bc8e5fb2dace099eb75780e8630125f2fedfbe397f507313eb5fdb4ca29942
+size 87192

v2/source_dataset_split/itwiki_train.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32d3f71c35b9b81c434eb52b66449a2e616fd38eeb9ceedc0e950a4af767328e
+size 405402

v2/source_dataset_split/itwiki_val.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21a06b3ba2aa1e9cf8602e1d39f44a43e908b8fb9692181bfd5db180e65db8e7
+size 87712

v2/source_dataset_split/tn_test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a001c79926f5594e71d28003ce907f4916ffb0e1e489fb388465d717ab51c92
+size 355338

v2/transformations_split/seen_transformations_test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72476c69784cb698d3d2bff5d86e790ae1fe7f8ca576d28fa22653cbb839129c
+size 168164

v2/transformations_split/train.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ffa6e04415c4bca8f457eb61b2fc817a6f74b161c962693b651bb53df11da6f
+size 547046

v2/transformations_split/unseen_transformations_test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7da8a84d6a2ab6e1fee954932014adefedd97be471ec1f792a95fe3488debbb
+size 270500

v2/transformations_split/val.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92edca1d8e3d12cee4bc69a47823315dad1fd2c6d924b6635dc38daa8f8f3762
+size 179045