Delete loading script

xtreme.py

@@ -1,940 +0,0 @@
-"""TODO(xtreme): Add a description here."""
-
-
-import csv
-import json
-import os
-import textwrap
-
-import datasets
-
-
-# TODO(xtreme): BibTeX citation
-_CITATION = """\
-@article{hu2020xtreme,
-      author    = {Junjie Hu and Sebastian Ruder and Aditya Siddhant and Graham Neubig and Orhan Firat and Melvin Johnson},
-      title     = {XTREME: A Massively Multilingual Multi-task Benchmark for Evaluating Cross-lingual Generalization},
-      journal   = {CoRR},
-      volume    = {abs/2003.11080},
-      year      = {2020},
-      archivePrefix = {arXiv},
-      eprint    = {2003.11080}
-}
-"""
-
-# TODO(xtrem):
-_DESCRIPTION = """\
-The Cross-lingual TRansfer Evaluation of Multilingual Encoders (XTREME) benchmark is a benchmark for the evaluation of
-the cross-lingual generalization ability of pre-trained multilingual models. It covers 40 typologically diverse languages
-(spanning 12 language families) and includes nine tasks that collectively require reasoning about different levels of
-syntax and semantics. The languages in XTREME are selected to maximize language diversity, coverage in existing tasks,
-and availability of training data. Among these are many under-studied languages, such as the Dravidian languages Tamil
-(spoken in southern India, Sri Lanka, and Singapore), Telugu and Malayalam (spoken mainly in southern India), and the
-Niger-Congo languages Swahili and Yoruba, spoken in Africa.
-"""
-_MLQA_LANG = ["ar", "de", "vi", "zh", "en", "es", "hi"]
-_XQUAD_LANG = ["ar", "de", "vi", "zh", "en", "es", "hi", "el", "ru", "th", "tr"]
-_PAWSX_LANG = ["de", "en", "es", "fr", "ja", "ko", "zh"]
-_BUCC_LANG = ["de", "fr", "zh", "ru"]
-_TATOEBA_LANG = [
-    "afr",
-    "ara",
-    "ben",
-    "bul",
-    "deu",
-    "cmn",
-    "ell",
-    "est",
-    "eus",
-    "fin",
-    "fra",
-    "heb",
-    "hin",
-    "hun",
-    "ind",
-    "ita",
-    "jav",
-    "jpn",
-    "kat",
-    "kaz",
-    "kor",
-    "mal",
-    "mar",
-    "nld",
-    "pes",
-    "por",
-    "rus",
-    "spa",
-    "swh",
-    "tam",
-    "tel",
-    "tgl",
-    "tha",
-    "tur",
-    "urd",
-    "vie",
-]
-
-_UD_POS_LANG = [
-    "Afrikaans",
-    "Arabic",
-    "Basque",
-    "Bulgarian",
-    "Dutch",
-    "English",
-    "Estonian",
-    "Finnish",
-    "French",
-    "German",
-    "Greek",
-    "Hebrew",
-    "Hindi",
-    "Hungarian",
-    "Indonesian",
-    "Italian",
-    "Japanese",
-    "Kazakh",
-    "Korean",
-    "Chinese",
-    "Marathi",
-    "Persian",
-    "Portuguese",
-    "Russian",
-    "Spanish",
-    "Tagalog",
-    "Tamil",
-    "Telugu",
-    "Thai",
-    "Turkish",
-    "Urdu",
-    "Vietnamese",
-    "Yoruba",
-]
-_PAN_X_LANG = [
-    "af",
-    "ar",
-    "bg",
-    "bn",
-    "de",
-    "el",
-    "en",
-    "es",
-    "et",
-    "eu",
-    "fa",
-    "fi",
-    "fr",
-    "he",
-    "hi",
-    "hu",
-    "id",
-    "it",
-    "ja",
-    "jv",
-    "ka",
-    "kk",
-    "ko",
-    "ml",
-    "mr",
-    "ms",
-    "my",
-    "nl",
-    "pt",
-    "ru",
-    "sw",
-    "ta",
-    "te",
-    "th",
-    "tl",
-    "tr",
-    "ur",
-    "vi",
-    "yo",
-    "zh",
-]
-
-_NAMES = ["XNLI", "tydiqa", "SQuAD"]
-for lang in _PAN_X_LANG:
-    _NAMES.append(f"PAN-X.{lang}")
-for lang1 in _MLQA_LANG:
-    for lang2 in _MLQA_LANG:
-        _NAMES.append(f"MLQA.{lang1}.{lang2}")
-for lang in _XQUAD_LANG:
-    _NAMES.append(f"XQuAD.{lang}")
-for lang in _BUCC_LANG:
-    _NAMES.append(f"bucc18.{lang}")
-for lang in _PAWSX_LANG:
-    _NAMES.append(f"PAWS-X.{lang}")
-for lang in _TATOEBA_LANG:
-    _NAMES.append(f"tatoeba.{lang}")
-for lang in _UD_POS_LANG:
-    _NAMES.append(f"udpos.{lang}")
-
-_DESCRIPTIONS = {
-    "tydiqa": textwrap.dedent(
-        """Gold passage task (GoldP): Given a passage that is guaranteed to contain the
-             answer, predict the single contiguous span of characters that answers the question. This is more similar to
-             existing reading comprehension datasets (as opposed to the information-seeking task outlined above).
-             This task is constructed with two goals in mind: (1) more directly comparing with prior work and (2) providing
-             a simplified way for researchers to use TyDi QA by providing compatibility with existing code for SQuAD 1.1,
-             XQuAD, and MLQA. Toward these goals, the gold passage task differs from the primary task in several ways:
-             only the gold answer passage is provided rather than the entire Wikipedia article;
-             unanswerable questions have been discarded, similar to MLQA and XQuAD;
-             we evaluate with the SQuAD 1.1 metrics like XQuAD; and
-            Thai and Japanese are removed since the lack of whitespace breaks some tools.
-             """
-    ),
-    "XNLI": textwrap.dedent(
-        """
-          The Cross-lingual Natural Language Inference (XNLI) corpus is a crowd-sourced collection of 5,000 test and
-          2,500 dev pairs for the MultiNLI corpus. The pairs are annotated with textual entailment and translated into
-          14 languages: French, Spanish, German, Greek, Bulgarian, Russian, Turkish, Arabic, Vietnamese, Thai, Chinese,
-          Hindi, Swahili and Urdu. This results in 112.5k annotated pairs. Each premise can be associated with the
-          corresponding hypothesis in the 15 languages, summing up to more than 1.5M combinations. The corpus is made to
-          evaluate how to perform inference in any language (including low-resources ones like Swahili or Urdu) when only
-          English NLI data is available at training time. One solution is cross-lingual sentence encoding, for which XNLI
-          is an evaluation benchmark."""
-    ),
-    "PAWS-X": textwrap.dedent(
-        """
-          This dataset contains 23,659 human translated PAWS evaluation pairs and 296,406 machine translated training
-          pairs in six typologically distinct languages: French, Spanish, German, Chinese, Japanese, and Korean. All
-          translated pairs are sourced from examples in PAWS-Wiki."""
-    ),
-    "XQuAD": textwrap.dedent(
-        """\
-          XQuAD (Cross-lingual Question Answering Dataset) is a benchmark dataset for evaluating cross-lingual question
-          answering performance. The dataset consists of a subset of 240 paragraphs and 1190 question-answer pairs from
-          the development set of SQuAD v1.1 (Rajpurkar et al., 2016) together with their professional translations into
-          ten languages: Spanish, German, Greek, Russian, Turkish, Arabic, Vietnamese, Thai, Chinese, and Hindi. Consequently,
-          the dataset is entirely parallel across 11 languages."""
-    ),
-    "MLQA": textwrap.dedent(
-        """\
-          MLQA (MultiLingual Question Answering) is a benchmark dataset for evaluating cross-lingual question answering performance.
-    MLQA consists of over 5K extractive QA instances (12K in English) in SQuAD format in seven languages - English, Arabic,
-    German, Spanish, Hindi, Vietnamese and Simplified Chinese. MLQA is highly parallel, with QA instances parallel between
-    4 different languages on average."""
-    ),
-    "tatoeba": textwrap.dedent(
-        """\
-          his data is extracted from the Tatoeba corpus, dated Saturday 2018/11/17.
-          For each languages, we have selected 1000 English sentences and their translations, if available. Please check
-          this paper for a description of the languages, their families and scripts as well as baseline results.
-          Please note that the English sentences are not identical for all language pairs. This means that the results are
-          not directly comparable across languages. In particular, the sentences tend to have less variety for several
-          low-resource languages, e.g. "Tom needed water", "Tom needs water", "Tom is getting water", ...
-                    """
-    ),
-    "bucc18": textwrap.dedent(
-        """Building and Using Comparable Corpora
-          """
-    ),
-    "udpos": textwrap.dedent(
-        """\
-    Universal Dependencies (UD) is a framework for consistent annotation of grammar (parts of speech, morphological
-    features, and syntactic dependencies) across different human languages. UD is an open community effort with over 200
-    contributors producing more than 100 treebanks in over 70 languages. If you’re new to UD, you should start by reading
-    the first part of the Short Introduction and then browsing the annotation guidelines.
-    """
-    ),
-    "SQuAD": textwrap.dedent(
-        """\
-    Stanford Question Answering Dataset (SQuAD) is a reading comprehension \
-    dataset, consisting of questions posed by crowdworkers on a set of Wikipedia \
-    articles, where the answer to every question is a segment of text, or span, \
-    from the corresponding reading passage, or the question might be unanswerable."""
-    ),
-    "PAN-X": textwrap.dedent(
-        """\
-    The WikiANN dataset (Pan et al. 2017) is a dataset with NER annotations for PER, ORG and LOC. It has been
-    constructed using the linked entities in Wikipedia pages for 282 different languages including Danish. The dataset
-    can be loaded with the DaNLP package:"""
-    ),
-}
-_CITATIONS = {
-    "tydiqa": textwrap.dedent(
-        (
-            """\
-            @article{tydiqa,
-              title   = {TyDi QA: A Benchmark for Information-Seeking Question Answering in Typologically Diverse Languages},
-              author  = {Jonathan H. Clark and Eunsol Choi and Michael Collins and Dan Garrette and Tom Kwiatkowski and Vitaly Nikolaev and Jennimaria Palomaki}
-              year    = {2020},
-              journal = {Transactions of the Association for Computational Linguistics}
-              }"""
-        )
-    ),
-    "XNLI": textwrap.dedent(
-        """\
-          @InProceedings{conneau2018xnli,
-          author = {Conneau, Alexis
-                         and Rinott, Ruty
-                         and Lample, Guillaume
-                         and Williams, Adina
-                         and Bowman, Samuel R.
-                         and Schwenk, Holger
-                         and Stoyanov, Veselin},
-          title = {XNLI: Evaluating Cross-lingual Sentence Representations},
-          booktitle = {Proceedings of the 2018 Conference on Empirical Methods
-                       in Natural Language Processing},
-          year = {2018},
-          publisher = {Association for Computational Linguistics},
-          location = {Brussels, Belgium},
-        }"""
-    ),
-    "XQuAD": textwrap.dedent(
-        """
-          @article{Artetxe:etal:2019,
-              author    = {Mikel Artetxe and Sebastian Ruder and Dani Yogatama},
-              title     = {On the cross-lingual transferability of monolingual representations},
-              journal   = {CoRR},
-              volume    = {abs/1910.11856},
-              year      = {2019},
-              archivePrefix = {arXiv},
-              eprint    = {1910.11856}
-        }
-        """
-    ),
-    "MLQA": textwrap.dedent(
-        """\
-          @article{lewis2019mlqa,
-          title={MLQA: Evaluating Cross-lingual Extractive Question Answering},
-          author={Lewis, Patrick and Oguz, Barlas and Rinott, Ruty and Riedel, Sebastian and Schwenk, Holger},
-          journal={arXiv preprint arXiv:1910.07475},
-          year={2019}"""
-    ),
-    "PAWS-X": textwrap.dedent(
-        """\
-          @InProceedings{pawsx2019emnlp,
-          title = {{PAWS-X: A Cross-lingual Adversarial Dataset for Paraphrase Identification}},
-          author = {Yang, Yinfei and Zhang, Yuan and Tar, Chris and Baldridge, Jason},
-          booktitle = {Proc. of EMNLP},
-          year = {2019}
-        }"""
-    ),
-    "tatoeba": textwrap.dedent(
-        """\
-                    @article{tatoeba,
-            title={Massively Multilingual Sentence Embeddings for Zero-Shot Cross-Lingual Transfer and Beyond},
-            author={Mikel, Artetxe and Holger, Schwenk,},
-            journal={arXiv:1812.10464v2},
-            year={2018}
-          }"""
-    ),
-    "bucc18": textwrap.dedent(""""""),
-    "udpos": textwrap.dedent(""""""),
-    "SQuAD": textwrap.dedent(
-        """\
-        @article{2016arXiv160605250R,
-           author = {{Rajpurkar}, Pranav and {Zhang}, Jian and {Lopyrev},
-                     Konstantin and {Liang}, Percy},
-            title = "{SQuAD: 100,000+ Questions for Machine Comprehension of Text}",
-          journal = {arXiv e-prints},
-             year = 2016,
-              eid = {arXiv:1606.05250},
-            pages = {arXiv:1606.05250},
-            archivePrefix = {arXiv},
-           eprint = {1606.05250},
-}"""
-    ),
-    "PAN-X": textwrap.dedent(
-        """\
-                    @article{pan-x,
-            title={Massively Multilingual Sentence Embeddings for Zero-Shot Cross-Lingual Transfer and Beyond},
-            author={Xiaoman, Pan and Boliang, Zhang and Jonathan, May and Joel, Nothman and Kevin, Knight and Heng, Ji},
-            volume={Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers}
-            year={2017}
-          }"""
-    ),
-}
-
-_TEXT_FEATURES = {
-    "XNLI": {
-        "language": "language",
-        "sentence1": "sentence1",
-        "sentence2": "sentence2",
-    },
-    "tydiqa": {
-        "id": "id",
-        "title": "title",
-        "context": "context",
-        "question": "question",
-        "answers": "answers",
-    },
-    "XQuAD": {
-        "id": "id",
-        "context": "context",
-        "question": "question",
-        "answers": "answers",
-    },
-    "MLQA": {
-        "id": "id",
-        "title": "title",
-        "context": "context",
-        "question": "question",
-        "answers": "answers",
-    },
-    "tatoeba": {
-        "source_sentence": "",
-        "target_sentence": "",
-        "source_lang": "",
-        "target_lang": "",
-    },
-    "bucc18": {
-        "source_sentence": "",
-        "target_sentence": "",
-        "source_lang": "",
-        "target_lang": "",
-    },
-    "PAWS-X": {"sentence1": "sentence1", "sentence2": "sentence2"},
-    "udpos": {"tokens": "", "pos_tags": ""},
-    "SQuAD": {
-        "id": "id",
-        "title": "title",
-        "context": "context",
-        "question": "question",
-        "answers": "answers",
-    },
-    "PAN-X": {"tokens": "", "ner_tags": "", "lang": ""},
-}
-_DATA_URLS = {
-    "tydiqa": "https://storage.googleapis.com/tydiqa/",
-    "XNLI": "https://dl.fbaipublicfiles.com/XNLI/XNLI-1.0.zip",
-    "XQuAD": "https://github.com/deepmind/xquad/raw/master/",
-    "MLQA": "https://dl.fbaipublicfiles.com/MLQA/MLQA_V1.zip",
-    "PAWS-X": "https://storage.googleapis.com/paws/pawsx/x-final.tar.gz",
-    "bucc18": "https://comparable.limsi.fr/bucc2018/",
-    "tatoeba": "https://github.com/facebookresearch/LASER/raw/main/data/tatoeba/v1/",
-    "udpos": "https://lindat.mff.cuni.cz/repository/xmlui/bitstream/handle/11234/1-3105/ud-treebanks-v2.5.tgz",
-    "SQuAD": "https://rajpurkar.github.io/SQuAD-explorer/dataset/",
-    "PAN-X": "https://s3.amazonaws.com/datasets.huggingface.co/wikiann/1.1.0/panx_dataset.zip",
-}
-
-_URLS = {
-    "tydiqa": "https://github.com/google-research-datasets/tydiqa",
-    "XQuAD": "https://github.com/deepmind/xquad",
-    "XNLI": "https://www.nyu.edu/projects/bowman/xnli/",
-    "MLQA": "https://github.com/facebookresearch/MLQA",
-    "PAWS-X": "https://github.com/google-research-datasets/paws/tree/master/pawsx",
-    "bucc18": "https://comparable.limsi.fr/bucc2018/",
-    "tatoeba": "https://github.com/facebookresearch/LASER/blob/main/data/tatoeba/v1/README.md",
-    "udpos": "https://universaldependencies.org/",
-    "SQuAD": "https://rajpurkar.github.io/SQuAD-explorer/",
-    "PAN-X": "https://github.com/afshinrahimi/mmner",
-}
-
-
-class XtremeConfig(datasets.BuilderConfig):
-    """BuilderConfig for Break"""
-
-    def __init__(self, data_url, citation, url, text_features, **kwargs):
-        """
-        Args:
-            text_features: `dict[string, string]`, map from the name of the feature
-        dict for each text field to the name of the column in the tsv file
-            label_column:
-            label_classes
-            **kwargs: keyword arguments forwarded to super.
-        """
-        super(XtremeConfig, self).__init__(version=datasets.Version("1.0.0", ""), **kwargs)
-        self.text_features = text_features
-        self.data_url = data_url
-        self.citation = citation
-        self.url = url
-
-
-class Xtreme(datasets.GeneratorBasedBuilder):
-    """TODO(xtreme): Short description of my dataset."""
-
-    # TODO(xtreme): Set up version.
-    VERSION = datasets.Version("0.1.0")
-    BUILDER_CONFIGS = [
-        XtremeConfig(
-            name=name,
-            description=_DESCRIPTIONS[name.split(".")[0]],
-            citation=_CITATIONS[name.split(".")[0]],
-            text_features=_TEXT_FEATURES[name.split(".")[0]],
-            data_url=_DATA_URLS[name.split(".")[0]],
-            url=_URLS[name.split(".")[0]],
-        )
-        for name in _NAMES
-    ]
-
-    def _info(self):
-        features = {text_feature: datasets.Value("string") for text_feature in self.config.text_features.keys()}
-        if "answers" in features.keys():
-            features["answers"] = datasets.features.Sequence(
-                {
-                    "answer_start": datasets.Value("int32"),
-                    "text": datasets.Value("string"),
-                }
-            )
-        if self.config.name.startswith("PAWS-X"):
-            features = PawsxParser.features
-        elif self.config.name == "XNLI":
-            features["gold_label"] = datasets.Value("string")
-        elif self.config.name.startswith("udpos"):
-            features = UdposParser.features
-        elif self.config.name.startswith("PAN-X"):
-            features = PanxParser.features
-        return datasets.DatasetInfo(
-            # This is the description that will appear on the datasets page.
-            description=self.config.description + "\n" + _DESCRIPTION,
-            # datasets.features.FeatureConnectors
-            features=datasets.Features(
-                features
-                # These are the features of your dataset like images, labels ...
-            ),
-            # 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="https://github.com/google-research/xtreme" + "\t" + self.config.url,
-            citation=self.config.citation + "\n" + _CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        """Returns SplitGenerators."""
-        if self.config.name == "tydiqa":
-            train_url = "v1.1/tydiqa-goldp-v1.1-train.json"
-            dev_url = "v1.1/tydiqa-goldp-v1.1-dev.json"
-            urls_to_download = {
-                "train": self.config.data_url + train_url,
-                "dev": self.config.data_url + dev_url,
-            }
-            dl_dir = dl_manager.download_and_extract(urls_to_download)
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={"filepath": dl_dir["train"]},
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={"filepath": dl_dir["dev"]},
-                ),
-            ]
-        if self.config.name == "XNLI":
-            dl_dir = dl_manager.download_and_extract(self.config.data_url)
-            data_dir = os.path.join(dl_dir, "XNLI-1.0")
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={"filepath": os.path.join(data_dir, "xnli.test.tsv")},
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    gen_kwargs={"filepath": os.path.join(data_dir, "xnli.dev.tsv")},
-                ),
-            ]
-
-        if self.config.name.startswith("MLQA"):
-            mlqa_downloaded_files = dl_manager.download_and_extract(self.config.data_url)
-            l1 = self.config.name.split(".")[1]
-            l2 = self.config.name.split(".")[2]
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={
-                        "filepath": os.path.join(
-                            os.path.join(mlqa_downloaded_files, "MLQA_V1/test"),
-                            f"test-context-{l1}-question-{l2}.json",
-                        )
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={
-                        "filepath": os.path.join(
-                            os.path.join(mlqa_downloaded_files, "MLQA_V1/dev"),
-                            f"dev-context-{l1}-question-{l2}.json",
-                        )
-                    },
-                ),
-            ]
-
-        if self.config.name.startswith("XQuAD"):
-            lang = self.config.name.split(".")[1]
-            xquad_downloaded_file = dl_manager.download_and_extract(self.config.data_url + f"xquad.{lang}.json")
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={"filepath": xquad_downloaded_file},
-                ),
-            ]
-        if self.config.name.startswith("PAWS-X"):
-            return PawsxParser.split_generators(dl_manager=dl_manager, config=self.config)
-        elif self.config.name.startswith("tatoeba"):
-            lang = self.config.name.split(".")[1]
-
-            tatoeba_source_data = dl_manager.download_and_extract(self.config.data_url + f"tatoeba.{lang}-eng.{lang}")
-            tatoeba_eng_data = dl_manager.download_and_extract(self.config.data_url + f"tatoeba.{lang}-eng.eng")
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    # These kwargs will be passed to _generate_examples
-                    gen_kwargs={"filepath": (tatoeba_source_data, tatoeba_eng_data)},
-                ),
-            ]
-        if self.config.name.startswith("bucc18"):
-            lang = self.config.name.split(".")[1]
-            bucc18_dl_test_archive = dl_manager.download(
-                self.config.data_url + f"bucc2018-{lang}-en.training-gold.tar.bz2"
-            )
-            bucc18_dl_dev_archive = dl_manager.download(
-                self.config.data_url + f"bucc2018-{lang}-en.sample-gold.tar.bz2"
-            )
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    gen_kwargs={"filepath": dl_manager.iter_archive(bucc18_dl_dev_archive)},
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={"filepath": dl_manager.iter_archive(bucc18_dl_test_archive)},
-                ),
-            ]
-        if self.config.name.startswith("udpos"):
-            return UdposParser.split_generators(dl_manager=dl_manager, config=self.config)
-
-        if self.config.name == "SQuAD":
-
-            urls_to_download = {
-                "train": self.config.data_url + "train-v1.1.json",
-                "dev": self.config.data_url + "dev-v1.1.json",
-            }
-            downloaded_files = dl_manager.download_and_extract(urls_to_download)
-
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={"filepath": downloaded_files["train"]},
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    gen_kwargs={"filepath": downloaded_files["dev"]},
-                ),
-            ]
-
-        if self.config.name.startswith("PAN-X"):
-            return PanxParser.split_generators(dl_manager=dl_manager, config=self.config)
-
-    def _generate_examples(self, filepath=None, **kwargs):
-        """Yields examples."""
-        # TODO(xtreme): Yields (key, example) tuples from the dataset
-
-        if self.config.name == "tydiqa" or self.config.name.startswith("MLQA") or self.config.name == "SQuAD":
-            with open(filepath, encoding="utf-8") as f:
-                data = json.load(f)
-                for article in data["data"]:
-                    title = article.get("title", "").strip()
-                    for paragraph in article["paragraphs"]:
-                        context = paragraph["context"].strip()
-                        for qa in paragraph["qas"]:
-                            question = qa["question"].strip()
-                            id_ = qa["id"]
-
-                            answer_starts = [answer["answer_start"] for answer in qa["answers"]]
-                            answers = [answer["text"].strip() for answer in qa["answers"]]
-
-                            # Features currently used are "context", "question", and "answers".
-                            # Others are extracted here for the ease of future expansions.
-                            yield id_, {
-                                "title": title,
-                                "context": context,
-                                "question": question,
-                                "id": id_,
-                                "answers": {
-                                    "answer_start": answer_starts,
-                                    "text": answers,
-                                },
-                            }
-        if self.config.name == "XNLI":
-            with open(filepath, encoding="utf-8") as f:
-                data = csv.DictReader(f, delimiter="\t")
-                for id_, row in enumerate(data):
-                    yield id_, {
-                        "sentence1": row["sentence1"],
-                        "sentence2": row["sentence2"],
-                        "language": row["language"],
-                        "gold_label": row["gold_label"],
-                    }
-        if self.config.name.startswith("PAWS-X"):
-            yield from PawsxParser.generate_examples(config=self.config, filepath=filepath, **kwargs)
-        if self.config.name.startswith("XQuAD"):
-            with open(filepath, encoding="utf-8") as f:
-                xquad = json.load(f)
-                for article in xquad["data"]:
-                    for paragraph in article["paragraphs"]:
-                        context = paragraph["context"].strip()
-                        for qa in paragraph["qas"]:
-                            question = qa["question"].strip()
-                            id_ = qa["id"]
-
-                            answer_starts = [answer["answer_start"] for answer in qa["answers"]]
-                            answers = [answer["text"].strip() for answer in qa["answers"]]
-
-                            # Features currently used are "context", "question", and "answers".
-                            # Others are extracted here for the ease of future expansions.
-                            yield id_, {
-                                "context": context,
-                                "question": question,
-                                "id": id_,
-                                "answers": {
-                                    "answer_start": answer_starts,
-                                    "text": answers,
-                                },
-                            }
-        if self.config.name.startswith("bucc18"):
-            lang = self.config.name.split(".")[1]
-            data_dir = f"bucc2018/{lang}-en"
-            for path, file in filepath:
-                if path.startswith(data_dir):
-                    csv_content = [line.decode("utf-8") for line in file]
-                    if path.endswith("en"):
-                        target_sentences = dict(list(csv.reader(csv_content, delimiter="\t", quotechar=None)))
-                    elif path.endswith("gold"):
-                        source_target_ids = list(csv.reader(csv_content, delimiter="\t", quotechar=None))
-                    else:
-                        source_sentences = dict(list(csv.reader(csv_content, delimiter="\t", quotechar=None)))
-
-            for id_, (source_id, target_id) in enumerate(source_target_ids):
-                yield id_, {
-                    "source_sentence": source_sentences[source_id],
-                    "target_sentence": target_sentences[target_id],
-                    "source_lang": source_id,
-                    "target_lang": target_id,
-                }
-        if self.config.name.startswith("tatoeba"):
-            source_file = filepath[0]
-            target_file = filepath[1]
-            source_sentences = []
-            target_sentences = []
-            with open(source_file, encoding="utf-8") as f1:
-                for row in f1:
-                    source_sentences.append(row)
-            with open(target_file, encoding="utf-8") as f2:
-                for row in f2:
-                    target_sentences.append(row)
-            for i in range(len(source_sentences)):
-                yield i, {
-                    "source_sentence": source_sentences[i],
-                    "target_sentence": target_sentences[i],
-                    "source_lang": source_file.split(".")[-1],
-                    "target_lang": "eng",
-                }
-        if self.config.name.startswith("udpos"):
-            yield from UdposParser.generate_examples(config=self.config, filepath=filepath, **kwargs)
-        if self.config.name.startswith("PAN-X"):
-            yield from PanxParser.generate_examples(filepath=filepath, **kwargs)
-
-
-class PanxParser:
-
-    features = datasets.Features(
-        {
-            "tokens": datasets.Sequence(datasets.Value("string")),
-            "ner_tags": datasets.Sequence(
-                datasets.features.ClassLabel(
-                    names=[
-                        "O",
-                        "B-PER",
-                        "I-PER",
-                        "B-ORG",
-                        "I-ORG",
-                        "B-LOC",
-                        "I-LOC",
-                    ]
-                )
-            ),
-            "langs": datasets.Sequence(datasets.Value("string")),
-        }
-    )
-
-    @staticmethod
-    def split_generators(dl_manager=None, config=None):
-        data_dir = dl_manager.download_and_extract(config.data_url)
-        lang = config.name.split(".")[1]
-        archive = os.path.join(data_dir, lang + ".tar.gz")
-        split_filenames = {
-            datasets.Split.TRAIN: "train",
-            datasets.Split.VALIDATION: "dev",
-            datasets.Split.TEST: "test",
-        }
-        return [
-            datasets.SplitGenerator(
-                name=split,
-                gen_kwargs={
-                    "filepath": dl_manager.iter_archive(archive),
-                    "filename": split_filenames[split],
-                },
-            )
-            for split in split_filenames
-        ]
-
-    @staticmethod
-    def generate_examples(filepath=None, filename=None):
-        idx = 1
-        for path, file in filepath:
-            if path.endswith(filename):
-                tokens = []
-                ner_tags = []
-                langs = []
-                for line in file:
-                    line = line.decode("utf-8")
-                    if line == "" or line == "\n":
-                        if tokens:
-                            yield idx, {
-                                "tokens": tokens,
-                                "ner_tags": ner_tags,
-                                "langs": langs,
-                            }
-                            idx += 1
-                            tokens = []
-                            ner_tags = []
-                            langs = []
-                    else:
-                        # pan-x data is tab separated
-                        splits = line.split("\t")
-                        # strip out en: prefix
-                        langs.append(splits[0][:2])
-                        tokens.append(splits[0][3:])
-                        if len(splits) > 1:
-                            ner_tags.append(splits[-1].replace("\n", ""))
-                        else:
-                            # examples have no label in test set
-                            ner_tags.append("O")
-                if tokens:
-                    yield idx, {
-                        "tokens": tokens,
-                        "ner_tags": ner_tags,
-                        "langs": langs,
-                    }
-
-
-class PawsxParser:
-
-    features = datasets.Features(
-        {
-            "sentence1": datasets.Value("string"),
-            "sentence2": datasets.Value("string"),
-            "label": datasets.Value("string"),
-        }
-    )
-
-    @staticmethod
-    def split_generators(dl_manager=None, config=None):
-        lang = config.name.split(".")[1]
-        archive = dl_manager.download(config.data_url)
-        split_filenames = {
-            datasets.Split.TRAIN: "translated_train.tsv" if lang != "en" else "train.tsv",
-            datasets.Split.VALIDATION: "dev_2k.tsv",
-            datasets.Split.TEST: "test_2k.tsv",
-        }
-        return [
-            datasets.SplitGenerator(
-                name=split,
-                gen_kwargs={"filepath": dl_manager.iter_archive(archive), "filename": split_filenames[split]},
-            )
-            for split in split_filenames
-        ]
-
-    @staticmethod
-    def generate_examples(config=None, filepath=None, filename=None):
-        lang = config.name.split(".")[1]
-        for path, file in filepath:
-            if f"/{lang}/" in path and path.endswith(filename):
-                lines = (line.decode("utf-8") for line in file)
-                data = csv.reader(lines, delimiter="\t")
-                next(data)  # skip header
-                for id_, row in enumerate(data):
-                    if len(row) == 4:
-                        yield id_, {
-                            "sentence1": row[1],
-                            "sentence2": row[2],
-                            "label": row[3],
-                        }
-
-
-class UdposParser:
-
-    features = datasets.Features(
-        {
-            "tokens": datasets.Sequence(datasets.Value("string")),
-            "pos_tags": datasets.Sequence(
-                datasets.features.ClassLabel(
-                    names=[
-                        "ADJ",
-                        "ADP",
-                        "ADV",
-                        "AUX",
-                        "CCONJ",
-                        "DET",
-                        "INTJ",
-                        "NOUN",
-                        "NUM",
-                        "PART",
-                        "PRON",
-                        "PROPN",
-                        "PUNCT",
-                        "SCONJ",
-                        "SYM",
-                        "VERB",
-                        "X",
-                    ]
-                )
-            ),
-        }
-    )
-
-    @staticmethod
-    def split_generators(dl_manager=None, config=None):
-        archive = dl_manager.download(config.data_url)
-        split_names = {datasets.Split.TRAIN: "train", datasets.Split.VALIDATION: "dev", datasets.Split.TEST: "test"}
-        split_generators = {
-            split: datasets.SplitGenerator(
-                name=split,
-                gen_kwargs={
-                    "filepath": dl_manager.iter_archive(archive),
-                    "split": split_names[split],
-                },
-            )
-            for split in split_names
-        }
-        lang = config.name.split(".")[1]
-        if lang in ["Tagalog", "Thai", "Yoruba"]:
-            return [split_generators["test"]]
-        elif lang == "Kazakh":
-            return [split_generators["train"], split_generators["test"]]
-        else:
-            return [split_generators["train"], split_generators["validation"], split_generators["test"]]
-
-    @staticmethod
-    def generate_examples(config=None, filepath=None, split=None):
-        lang = config.name.split(".")[1]
-        idx = 0
-        for path, file in filepath:
-            if f"_{lang}" in path and split in path and path.endswith(".conllu"):
-                # For lang other than [see below], we exclude Arabic-NYUAD which does not contains any words, only _
-                if lang in ["Kazakh", "Tagalog", "Thai", "Yoruba"] or "NYUAD" not in path:
-                    lines = (line.decode("utf-8") for line in file)
-                    data = csv.reader(lines, delimiter="\t", quoting=csv.QUOTE_NONE)
-                    tokens = []
-                    pos_tags = []
-                    for id_row, row in enumerate(data):
-                        if len(row) >= 10 and row[1] != "_" and row[3] != "_":
-                            tokens.append(row[1])
-                            pos_tags.append(row[3])
-                        if len(row) == 0 and len(tokens) > 0:
-                            yield idx, {
-                                "tokens": tokens,
-                                "pos_tags": pos_tags,
-                            }
-                            idx += 1
-                            tokens = []
-                            pos_tags = []