Update files from the datasets library (from 1.2.0)

Release notes: https://github.com/huggingface/datasets/releases/tag/1.2.0

.gitattributes

@@ -0,0 +1,27 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.xz 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

README.md

@@ -0,0 +1,214 @@
+---
+annotations_creators:
+- found
+language_creators:
+- crowdsourced
+languages:
+  de:
+  - de
+  en:
+  - en
+licenses:
+- cc-by-sa-4-0
+multilinguality:
+- monolingual
+size_categories:
+- 1K<n<10K
+source_datasets:
+- extended|other-web-nlg
+task_categories:
+- conditional-text-generation
+task_ids:
+- other-stuctured-to-text
+---
+
+# Dataset Card for WebNLG
+
+## Table of Contents
+
+- [Dataset Description](#dataset-description)
+    - [Dataset Summary](#dataset-summary)
+    - [Supported Tasks](#supported-tasks-and-leaderboards)
+    - [Languages](#languages)
+- [Dataset Structure](#dataset-structure)
+    - [Data Instances](#data-instances)
+    - [Data Fields](#data-instances)
+    - [Data Splits](#data-instances)
+- [Dataset Creation](#dataset-creation)
+    - [Curation Rationale](#curation-rationale)
+    - [Source Data](#source-data)
+    - [Annotations](#annotations)
+    - [Personal and Sensitive Information](#personal-and-sensitive-information)
+- [Considerations for Using the Data](#considerations-for-using-the-data)
+    - [Social Impact of Dataset](#social-impact-of-dataset)
+    - [Discussion of Biases](#discussion-of-biases)
+    - [Other Known Limitations](#other-known-limitations)
+- [Additional Information](#additional-information)
+    - [Dataset Curators](#dataset-curators)
+    - [Licensing Information](#licensing-information)
+    - [Citation Information](#citation-information)
+
+## Dataset Description
+
+- **Homepage:** [WebNLG challenge website](https://webnlg-challenge.loria.fr/)
+- **Repository:** [Enriched WebNLG Github repository](https://github.com/ThiagoCF05/webnlg)
+- **Paper:** [Enriching the WebNLG corpus](https://www.aclweb.org/anthology/W18-6521/)
+
+### Dataset Summary
+
+The WebNLG challenge consists in mapping data to text. The training data consists of Data/Text pairs where the data is a
+set of triples extracted from DBpedia and the text is a verbalisation of these triples. For instance, given the 3
+DBpedia triples shown in (a), the aim is to generate a text such as (b). It is a valuable resource and benchmark for the Natural Language Generation (NLG) community. However, as other NLG benchmarks, it only consists of a collection of parallel raw representations and their corresponding textual realizations. This work aimed to provide intermediate representations of the data for the development and evaluation of popular tasks in the NLG pipeline architecture, such as Discourse Ordering, Lexicalization, Aggregation and Referring Expression Generation.
+
+### Supported Tasks and Leaderboards
+
+The dataset supports a `other-structured-to-text` task which requires a model takes a set of RDF (Resource Description
+Format) triples from a database (DBpedia) of the form (subject, property, object) as input and write out a natural
+language sentence expressing the information contained in the triples.
+
+### Languages
+
+The dataset is presented in two versions: English (config `en`) and German (config `de`)
+
+## Dataset Structure
+
+### Data Instances
+
+A typical example contains the original RDF triples in the set, a modified version which presented to crowd workers, and
+a set of possible verbalizations for this set of triples:
+
+```
+{ 'category': 'Politician',
+ 'eid': 'Id10',
+ 'lex': {'comment': ['good', 'good', 'good'],
+         'lid': ['Id1', 'Id2', 'Id3'],
+         'text': ['World War II had Chiang Kai-shek as a commander and United States Army soldier Abner W. Sibal.',
+                  'Abner W. Sibal served in the United States Army during the Second World War and during that war Chiang Kai-shek was one of the commanders.',
+                  'Abner W. Sibal, served in the United States Army and fought in World War II, one of the commanders of which, was Chiang Kai-shek.']},
+ 'modified_triple_sets': {'mtriple_set': [['Abner_W._Sibal | battle | World_War_II',
+                                           'World_War_II | commander | Chiang_Kai-shek',
+                                           'Abner_W._Sibal | militaryBranch | United_States_Army']]},
+ 'original_triple_sets': {'otriple_set': [['Abner_W._Sibal | battles | World_War_II', 'World_War_II | commander | Chiang_Kai-shek', 'Abner_W._Sibal | branch | United_States_Army'],
+                                          ['Abner_W._Sibal | militaryBranch | United_States_Army',
+                                           'Abner_W._Sibal | battles | World_War_II',
+                                           'World_War_II | commander | Chiang_Kai-shek']]},
+ 'shape': '(X (X) (X (X)))',
+ 'shape_type': 'mixed',
+ 'size': 3}
+```
+
+### Data Fields
+
+The following fields can be found in the instances:
+
+- `category`: the category of the DBpedia entites present in the RDF triples.
+- `eid`: an example ID, only unique per split per category.
+- `size`: number of RDF triples in the set.
+- `shape`: (for v3 only) Each set of RDF-triples is a tree, which is characterised by its shape and shape type. `shape`
+  is a string representation of the tree with nested parentheses where X is a node (
+  see [Newick tree format](https://en.wikipedia.org/wiki/Newick_format))
+- `shape_type`: (for v3 only) is a type of the tree shape, which can be: `chain` (the object of one triple is the
+  subject of the other); `sibling` (triples with a shared subject); `mixed` (both chain and sibling types present).
+- `2017_test_category`: (for `webnlg_challenge_2017`) tells whether the set of RDF triples was present in the training
+  set or not.
+- `lex`: the lexicalizations, with:
+    - `text`: the text to be predicted.
+    - `lid`: a lexicalizayion ID, unique per example.
+    - `comment`: the lexicalizations were rated by crowd workers are either `good` or `bad`
+
+### Data Splits
+
+The `en` version has `train`, `test` and `dev` splits; the `de` version, only `train` and `dev`.
+
+## Dataset Creation
+
+### Curation Rationale
+
+Natural  Language  Generation  (NLG)  is  the  process  of  automatically  converting  non-linguistic data  into  a  linguistic  output  format  (Reiter  andDale,   2000;   Gatt   and   Krahmer,   2018). Recently,   the  field  has  seen  an  increase  in  the number  of  available  focused  data  resources  as E2E (Novikova et al., 2017), ROTOWIRE(Wise-man  et  al.,  2017)  and  WebNLG  (Gardent  et  al.,2017a,b) corpora. Although theses recent releases are highly valuable resources for the NLG community in general,nall  of  them  were  designed  to  work  with  end-to-end NLG models.   Hence,  they consist of a collection  of  parallel  raw  representations  and  their corresponding  textual  realizations.   No  intermediate representations are available so researchersncan straight-forwardly use them to develop or evaluate  popular tasks  in NLG  pipelines (Reiter  and Dale, 2000), such as Discourse Ordering, Lexicalization,  Aggregation,  Referring Expression Generation, among others.  Moreover, these new corpora, like many other resources in Computational Linguistics  more  in  general,  are  only  available in  English,  limiting  the  development  of  NLG-applications  to  other  languages.
+
+
+### Source Data
+
+#### Initial Data Collection and Normalization
+
+[More Information Needed]
+
+#### Who are the source language producers?
+
+[More Information Needed]
+
+### Annotations
+
+#### Annotation process
+
+[More Information Needed]
+
+#### Who are the annotators?
+
+[More Information Needed]
+
+### Personal and Sensitive Information
+
+[More Information Needed]
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+[More Information Needed]
+
+### Discussion of Biases
+
+[More Information Needed]
+
+### Other Known Limitations
+
+[More Information Needed]
+
+## Additional Information
+
+### Dataset Curators
+
+[More Information Needed]
+
+### Licensing Information
+
+The dataset uses the `cc-by-nc-sa-4.0` license. The source DBpedia project uses the `cc-by-sa-3.0` and `gfdl-1.1`
+licenses.
+
+### Citation Information
+
+- If you use the Enriched WebNLG corpus, cite:
+
+```
+@InProceedings{ferreiraetal2018,
+  author = 	"Castro Ferreira, Thiago
+		and Moussallem, Diego
+		and Wubben, Sander
+		and Krahmer, Emiel",
+  title = 	"Enriching the WebNLG corpus",
+  booktitle = 	"Proceedings of the 11th International Conference on Natural Language Generation",
+  year = 	"2018",
+  series = {INLG'18},
+  publisher = 	"Association for Computational Linguistics",
+  address = 	"Tilburg, The Netherlands",
+}
+
+@inproceedings{web_nlg,
+  author    = {Claire Gardent and
+               Anastasia Shimorina and
+               Shashi Narayan and
+               Laura Perez{-}Beltrachini},
+  editor    = {Regina Barzilay and
+               Min{-}Yen Kan},
+  title     = {Creating Training Corpora for {NLG} Micro-Planners},
+  booktitle = {Proceedings of the 55th Annual Meeting of the Association for Computational
+               Linguistics, {ACL} 2017, Vancouver, Canada, July 30 - August 4, Volume
+               1: Long Papers},
+  pages     = {179--188},
+  publisher = {Association for Computational Linguistics},
+  year      = {2017},
+  url       = {https://doi.org/10.18653/v1/P17-1017},
+  doi       = {10.18653/v1/P17-1017}
+}
+```

dataset_infos.json

@@ -0,0 +1 @@
+{"en": {"description": "WebNLG is a valuable resource and benchmark for the Natural Language Generation (NLG) community. However, as other NLG benchmarks, it only consists of a collection of parallel raw representations and their corresponding textual realizations. This work aimed to provide intermediate representations of the data for the development and evaluation of popular tasks in the NLG pipeline architecture (Reiter and Dale, 2000), such as Discourse Ordering, Lexicalization, Aggregation and Referring Expression Generation.\n", "citation": "@InProceedings{ferreiraetal2018,\n  author = \t\"Castro Ferreira, Thiago and Moussallem, Diego and Wubben, Sander and Krahmer, Emiel\",\n  title = \t\"Enriching the WebNLG corpus\",\n  booktitle = \t\"Proceedings of the 11th International Conference on Natural Language Generation\",\n  year = \t\"2018\",\n  series = {INLG'18},\n  publisher = \t\"Association for Computational Linguistics\",\n  address = \t\"Tilburg, The Netherlands\",\n}\n", "homepage": "https://github.com/ThiagoCF05/webnlg", "license": "CC Attribution-Noncommercial-Share Alike 4.0 International", "features": {"category": {"dtype": "string", "id": null, "_type": "Value"}, "size": {"dtype": "int32", "id": null, "_type": "Value"}, "eid": {"dtype": "string", "id": null, "_type": "Value"}, "original_triple_sets": {"feature": {"otriple_set": {"feature": {"dtype": "string", "id": null, "_type": "Value"}, "length": -1, "id": null, "_type": "Sequence"}}, "length": -1, "id": null, "_type": "Sequence"}, "modified_triple_sets": {"feature": {"mtriple_set": {"feature": {"dtype": "string", "id": null, "_type": "Value"}, "length": -1, "id": null, "_type": "Sequence"}}, "length": -1, "id": null, "_type": "Sequence"}, "shape": {"dtype": "string", "id": null, "_type": "Value"}, "shape_type": {"dtype": "string", "id": null, "_type": "Value"}, "lex": {"feature": {"comment": {"dtype": "string", "id": null, "_type": "Value"}, "lid": {"dtype": "string", "id": null, "_type": "Value"}, "text": {"dtype": "string", "id": null, "_type": "Value"}, "template": {"dtype": "string", "id": null, "_type": "Value"}, "sorted_triple_sets": {"feature": {"dtype": "string", "id": null, "_type": "Value"}, "length": -1, "id": null, "_type": "Sequence"}, "lexicalization": {"dtype": "string", "id": null, "_type": "Value"}}, "length": -1, "id": null, "_type": "Sequence"}}, "post_processed": null, "supervised_keys": null, "builder_name": "enriched_web_nlg", "config_name": "en", "version": {"version_str": "0.0.0", "description": null, "major": 0, "minor": 0, "patch": 0}, "splits": {"train": {"name": "train", "num_bytes": 14665155, "num_examples": 6940, "dataset_name": "enriched_web_nlg"}, "dev": {"name": "dev", "num_bytes": 1843787, "num_examples": 872, "dataset_name": "enriched_web_nlg"}, "test": {"name": "test", "num_bytes": 3931381, "num_examples": 1862, "dataset_name": "enriched_web_nlg"}}, "download_checksums": {"https://github.com/ThiagoCF05/webnlg/archive/12ca34880b225ebd1eb9db07c64e8dd76f7e5784.zip": {"num_bytes": 44284508, "checksum": "624f8c4bc1ef9f59851d92dec1456607ad2b2dc9242e107a4cb62dad774f68cb"}}, "download_size": 44284508, "post_processing_size": null, "dataset_size": 20440323, "size_in_bytes": 64724831}, "de": {"description": "WebNLG is a valuable resource and benchmark for the Natural Language Generation (NLG) community. However, as other NLG benchmarks, it only consists of a collection of parallel raw representations and their corresponding textual realizations. This work aimed to provide intermediate representations of the data for the development and evaluation of popular tasks in the NLG pipeline architecture (Reiter and Dale, 2000), such as Discourse Ordering, Lexicalization, Aggregation and Referring Expression Generation.\n", "citation": "@InProceedings{ferreiraetal2018,\n  author = \t\"Castro Ferreira, Thiago and Moussallem, Diego and Wubben, Sander and Krahmer, Emiel\",\n  title = \t\"Enriching the WebNLG corpus\",\n  booktitle = \t\"Proceedings of the 11th International Conference on Natural Language Generation\",\n  year = \t\"2018\",\n  series = {INLG'18},\n  publisher = \t\"Association for Computational Linguistics\",\n  address = \t\"Tilburg, The Netherlands\",\n}\n", "homepage": "https://github.com/ThiagoCF05/webnlg", "license": "CC Attribution-Noncommercial-Share Alike 4.0 International", "features": {"category": {"dtype": "string", "id": null, "_type": "Value"}, "size": {"dtype": "int32", "id": null, "_type": "Value"}, "eid": {"dtype": "string", "id": null, "_type": "Value"}, "original_triple_sets": {"feature": {"otriple_set": {"feature": {"dtype": "string", "id": null, "_type": "Value"}, "length": -1, "id": null, "_type": "Sequence"}}, "length": -1, "id": null, "_type": "Sequence"}, "modified_triple_sets": {"feature": {"mtriple_set": {"feature": {"dtype": "string", "id": null, "_type": "Value"}, "length": -1, "id": null, "_type": "Sequence"}}, "length": -1, "id": null, "_type": "Sequence"}, "shape": {"dtype": "string", "id": null, "_type": "Value"}, "shape_type": {"dtype": "string", "id": null, "_type": "Value"}, "lex": {"feature": {"comment": {"dtype": "string", "id": null, "_type": "Value"}, "lid": {"dtype": "string", "id": null, "_type": "Value"}, "text": {"dtype": "string", "id": null, "_type": "Value"}, "template": {"dtype": "string", "id": null, "_type": "Value"}, "sorted_triple_sets": {"feature": {"dtype": "string", "id": null, "_type": "Value"}, "length": -1, "id": null, "_type": "Sequence"}}, "length": -1, "id": null, "_type": "Sequence"}}, "post_processed": null, "supervised_keys": null, "builder_name": "enriched_web_nlg", "config_name": "de", "version": "0.0.0", "splits": {"train": {"name": "train", "num_bytes": 9748193, "num_examples": 6940, "dataset_name": "enriched_web_nlg"}, "dev": {"name": "dev", "num_bytes": 1238609, "num_examples": 872, "dataset_name": "enriched_web_nlg"}}, "download_checksums": {"https://github.com/ThiagoCF05/webnlg/archive/12ca34880b225ebd1eb9db07c64e8dd76f7e5784.zip": {"num_bytes": 44284508, "checksum": "624f8c4bc1ef9f59851d92dec1456607ad2b2dc9242e107a4cb62dad774f68cb"}}, "download_size": 44284508, "post_processing_size": null, "dataset_size": 10986802, "size_in_bytes": 55271310}}

dummy/de/0.0.0/dummy_data.zip

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

dummy/en/0.0.0/dummy_data.zip

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

enriched_web_nlg.py

@@ -0,0 +1,237 @@
+# 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.
+"""The Enriched WebNLG corpus"""
+
+from __future__ import absolute_import, division, print_function
+
+import itertools
+import os
+import xml.etree.cElementTree as ET
+from collections import defaultdict
+from glob import glob
+from os.path import join as pjoin
+
+import datasets
+
+
+_CITATION = """\
+@InProceedings{ferreiraetal2018,
+  author = 	"Castro Ferreira, Thiago and Moussallem, Diego and Wubben, Sander and Krahmer, Emiel",
+  title = 	"Enriching the WebNLG corpus",
+  booktitle = 	"Proceedings of the 11th International Conference on Natural Language Generation",
+  year = 	"2018",
+  series = {INLG'18},
+  publisher = 	"Association for Computational Linguistics",
+  address = 	"Tilburg, The Netherlands",
+}
+"""
+
+_DESCRIPTION = """\
+WebNLG is a valuable resource and benchmark for the Natural Language Generation (NLG) community. However, as other NLG benchmarks, it only consists of a collection of parallel raw representations and their corresponding textual realizations. This work aimed to provide intermediate representations of the data for the development and evaluation of popular tasks in the NLG pipeline architecture (Reiter and Dale, 2000), such as Discourse Ordering, Lexicalization, Aggregation and Referring Expression Generation.
+"""
+
+_HOMEPAGE = "https://github.com/ThiagoCF05/webnlg"
+
+_LICENSE = "CC Attribution-Noncommercial-Share Alike 4.0 International"
+
+_SHA = "12ca34880b225ebd1eb9db07c64e8dd76f7e5784"
+
+_URL = f"https://github.com/ThiagoCF05/webnlg/archive/{_SHA}.zip"
+
+_FILE_PATHS = {
+    "en": {
+        "train": [f"webnlg-{_SHA}/data/v1.5/en/train/{i}triples/" for i in range(1, 8)],
+        "dev": [f"webnlg-{_SHA}/data/v1.5/en/dev/{i}triples/" for i in range(1, 8)],
+        "test": [f"webnlg-{_SHA}/data/v1.5/en/test/{i}triples/" for i in range(1, 8)],
+    },
+    "de": {
+        "train": [f"webnlg-{_SHA}/data/v1.5/de/train/{i}triples/" for i in range(1, 8)],
+        "dev": [f"webnlg-{_SHA}/data/v1.5/de/dev/{i}triples/" for i in range(1, 8)],
+    },
+}
+
+
+def et_to_dict(tree):
+    """Takes the xml tree within a dataset file and returns a dictionary with entry data"""
+    dct = {tree.tag: {} if tree.attrib else None}
+    children = list(tree)
+    if children:
+        dd = defaultdict(list)
+        for dc in map(et_to_dict, children):
+            for k, v in dc.items():
+                dd[k].append(v)
+        dct = {tree.tag: dd}
+    if tree.attrib:
+        dct[tree.tag].update((k, v) for k, v in tree.attrib.items())
+    if tree.text:
+        text = tree.text.strip()
+        if children or tree.attrib:
+            if text:
+                dct[tree.tag]["text"] = text
+        else:
+            dct[tree.tag] = text
+    return dct
+
+
+def parse_entry(entry, config_name):
+    """Takes the dictionary corresponding to an entry and returns a dictionary with:
+    - Proper feature naming
+    - Default values
+    - Proper typing"""
+    res = {}
+    otriple_set_list = entry["originaltripleset"]
+    res["original_triple_sets"] = [{"otriple_set": otriple_set["otriple"]} for otriple_set in otriple_set_list]
+    mtriple_set_list = entry["modifiedtripleset"]
+    res["modified_triple_sets"] = [{"mtriple_set": mtriple_set["mtriple"]} for mtriple_set in mtriple_set_list]
+    res["category"] = entry["category"]
+    res["eid"] = entry["eid"]
+    res["size"] = int(entry["size"])
+    lex = entry["lex"]
+    # Some entries are misformed, with None instead of the sorted triplet information.
+    entry_triples = [
+        ex["sortedtripleset"][0] if ex["sortedtripleset"][0] is not None else {"sentence": []} for ex in lex
+    ]
+    # the xml structure is inconsistent; sorted triplets are often separated in several dictionaries, so we sum them.
+    sorted_triples = [
+        list(itertools.chain.from_iterable(item.get("striple", []) for item in entry["sentence"]))
+        for entry in entry_triples
+    ]
+    res["lex"] = {
+        "comment": [ex.get("comment", "") for ex in lex],
+        "lid": [ex.get("lid", "") for ex in lex],
+        # all of the sequence are within their own 1-element sublist, thus the [0]
+        "text": [ex.get("text", [""])[0] for ex in lex],
+        "template": [ex.get("template", [""])[0] for ex in lex],
+        "sorted_triple_sets": sorted_triples,
+    }
+    # only present in the en version
+    if config_name == "en":
+        res["lex"]["lexicalization"] = [ex.get("lexicalization", [""])[0] for ex in lex]
+    res["shape"] = entry.get("shape", "")
+    res["shape_type"] = entry.get("shape_type", "")
+    return res
+
+
+def xml_file_to_examples(filename, config_name):
+    tree = ET.parse(filename).getroot()
+    examples = et_to_dict(tree)["benchmark"]["entries"][0]["entry"]
+    return [parse_entry(entry, config_name) for entry in examples]
+
+
+class EnrichedWebNlg(datasets.GeneratorBasedBuilder):
+    """The WebNLG corpus"""
+
+    VERSION = datasets.Version("1.5.0")
+
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(name="en", description="Enriched English version of the WebNLG data"),
+        datasets.BuilderConfig(name="de", description="Enriched German version of the WebNLG data"),
+    ]
+
+    def _info(self):
+        if self.config.name == "en":
+            features = datasets.Features(
+                {
+                    "category": datasets.Value("string"),
+                    "size": datasets.Value("int32"),
+                    "eid": datasets.Value("string"),
+                    "original_triple_sets": datasets.Sequence(
+                        {"otriple_set": datasets.Sequence(datasets.Value("string"))}
+                    ),
+                    "modified_triple_sets": datasets.Sequence(
+                        {"mtriple_set": datasets.Sequence(datasets.Value("string"))}
+                    ),
+                    "shape": datasets.Value("string"),
+                    "shape_type": datasets.Value("string"),
+                    "lex": datasets.Sequence(
+                        {
+                            "comment": datasets.Value("string"),
+                            "lid": datasets.Value("string"),
+                            "text": datasets.Value("string"),
+                            "template": datasets.Value("string"),
+                            "sorted_triple_sets": datasets.Sequence(datasets.Value("string")),
+                            # only present in the en version
+                            "lexicalization": datasets.Value("string"),
+                        }
+                    ),
+                }
+            )
+        else:
+            features = datasets.Features(
+                {
+                    "category": datasets.Value("string"),
+                    "size": datasets.Value("int32"),
+                    "eid": datasets.Value("string"),
+                    "original_triple_sets": datasets.Sequence(
+                        {"otriple_set": datasets.Sequence(datasets.Value("string"))}
+                    ),
+                    "modified_triple_sets": datasets.Sequence(
+                        {"mtriple_set": datasets.Sequence(datasets.Value("string"))}
+                    ),
+                    "shape": datasets.Value("string"),
+                    "shape_type": datasets.Value("string"),
+                    "lex": datasets.Sequence(
+                        {
+                            "comment": datasets.Value("string"),
+                            "lid": datasets.Value("string"),
+                            "text": datasets.Value("string"),
+                            "template": datasets.Value("string"),
+                            "sorted_triple_sets": datasets.Sequence(datasets.Value("string")),
+                        }
+                    ),
+                }
+            )
+        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,
+            citation=_CITATION,
+            license=_LICENSE,
+        )
+
+    def _split_generators(self, dl_manager):
+        """Returns SplitGenerators."""
+        data_dir = dl_manager.download_and_extract(_URL)
+        # Downloading the repo adds the current commit sha to the directory, so we can't specify the directory
+        # name in advance.
+        split_files = {
+            split: [os.path.join(data_dir, dir_suf) for dir_suf in dir_suffix_list]
+            for split, dir_suffix_list in _FILE_PATHS[self.config.name].items()
+        }
+        return [
+            datasets.SplitGenerator(
+                name=split,
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={"filedirs": filedirs},
+            )
+            for split, filedirs in split_files.items()
+        ]
+
+    def _generate_examples(self, filedirs):
+        """ Yields examples. """
+
+        id_ = 0
+        for xml_location in filedirs:
+            for xml_file in sorted(glob(pjoin(xml_location, "*.xml"))):
+                for exple_dict in xml_file_to_examples(xml_file, self.config.name):
+                    id_ += 1
+                    yield id_, exple_dict