Update files from the datasets library (from 1.0.0)

Release notes: https://github.com/huggingface/datasets/releases/tag/1.0.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

dummy/MLQA.en.ar/1.0.0/dummy_data.zip

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

dummy/MLQA.en.de/1.0.0/dummy_data.zip

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

dummy/MLQA.en.en/1.0.0/dummy_data.zip

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

dummy/MLQA.en.es/1.0.0/dummy_data.zip

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

dummy/MLQA.en.hi/1.0.0/dummy_data.zip

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

dummy/MLQA.en.vi/1.0.0/dummy_data.zip

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

dummy/MLQA.en.zh/1.0.0/dummy_data.zip

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

dummy/XNLI/1.0.0/dummy_data.zip

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

dummy/XQuAD.ar/1.0.0/dummy_data-zip-extracted/dummy_data/xquad.ar.json

@@ -0,0 +1,54 @@
+{
+  "data": [
+    {
+      "paragraphs": [
+        {
+          "context": "Die Verteidigung der Panthers gab nur 308 Punkte ab und belegte den sechsten Platz in der Liga, w\u00e4hrend sie die NFL mit 24 Interceptions in dieser Kategorie anf\u00fchrte und sich mit vier Pro Bowl-Selektionen r\u00fchmen konnte. Pro Bowl Defensive Tackle Kawann Short f\u00fchrte das Team mit 11 Sacks an, erzwang zudem drei Fumbles und erzielte zwei Fumble Recoverys. Mario Addison, ebenfalls Lineman, addierte 6\u00bd Sacks hinzu. Die Panthers-Line pr\u00e4sentierte auch den erfahrenen Defensive End Jared Allen, einen 5-fachen Pro-Bowler, der mit 136 Sacks der aktive Anf\u00fchrer in der NFL-Kategorie Karriere-Sacks war, sowie den Defensive End Kony Ealy, der 5 Sacks in nur 9 Starts erzielte. Nach ihnen wurden zwei der drei Linebacker der Panthers ausgew\u00e4hlt, um im Pro Bowl zu spielen: Thomas Davis und Luke Kuechly. Davis erzielte 5\u00bd Sacks, vier erzwungene Fumbles und vier Interceptions, w\u00e4hrend Kuechly das Team bei den Tackles anf\u00fchrte (118), zwei Fumbles erzwang und vier P\u00e4sse abfing. Carolinas Secondarys bestanden aus dem Pro Bowl-Safety Kurt Coleman, der das Team mit einem Karrierehoch von sieben Interceptions anf\u00fchrte und gleichzeitig 88 Tackles erzielen konnte, und Pro Bowl-Cornerback Josh Norman, der sich w\u00e4hrend der Saison zur Shutdown Corner entwickelte und vier Interceptions erzielte, von denen zwei zu Touchdowns f\u00fcr sein Team wurden.",
+          "qas": [
+            {
+              "answers": [
+                {
+                  "answer_start": 38,
+                  "text": "308"
+                }
+              ],
+              "id": "56beb4343aeaaa14008c925b",
+              "question": "Wie viele Punkte gab die Verteidigung der Panthers ab?"
+            },
+            {
+              "answers": [
+                {
+                  "answer_start": 527,
+                  "text": "136"
+                }
+              ],
+              "id": "56beb4343aeaaa14008c925c",
+              "question": "Wie viele Sacks erzielte Jared Allen in seiner Karriere?"
+            },
+            {
+              "answers": [
+                {
+                  "answer_start": 921,
+                  "text": "118"
+                }
+              ],
+              "id": "56beb4343aeaaa14008c925d",
+              "question": "Wie viele Tackles wurden bei Luke Kuechly registriert?"
+            },
+            {
+              "answers": [
+                {
+                  "answer_start": 179,
+                  "text": "vier"
+                }
+              ],
+              "id": "56beb4343aeaaa14008c925e",
+              "question": "Wie viele B\u00e4lle fing Josh Norman ab?"
+            }
+] 
+}
+]
+}
+]
+}
+

dummy/XQuAD.ar/1.0.0/dummy_data.zip

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

dummy/XQuAD.de/1.0.0/dummy_data.zip

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

dummy/XQuAD.el/1.0.0/dummy_data.zip

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

dummy/XQuAD.en/1.0.0/dummy_data.zip

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

dummy/XQuAD.hi/1.0.0/dummy_data.zip

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

dummy/XQuAD.ru/1.0.0/dummy_data.zip

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

dummy/XQuAD.th/1.0.0/dummy_data.zip

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

dummy/XQuAD.tr/1.0.0/dummy_data.zip

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

dummy/XQuAD.vi/1.0.0/dummy_data.zip

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

dummy/XQuAD.zh/1.0.0/dummy_data.zip

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

dummy/XQuADes/1.0.0/dummy_data.zip

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

dummy/tydiqa/1.0.0/dummy_data.zip

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

xtreme.py

@@ -0,0 +1,913 @@
+"""TODO(xtreme): Add a description here."""
+
+from __future__ import absolute_import, division, print_function
+
+import csv
+import glob
+import json
+import os
+import textwrap
+
+import six
+
+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",
+    "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",
+]
+_PAN_X_FOLDER = "AmazonPhotos.zip"
+_NAMES = ["XNLI", "tydiqa", "SQuAD"]
+for lang in _PAN_X_LANG:
+    _NAMES.append("PAN-X.{}".format(lang))
+for lang1 in _MLQA_LANG:
+    for lang2 in _MLQA_LANG:
+        _NAMES.append("MLQA.{}.{}".format(lang1, lang2))
+for lang in _XQUAD_LANG:
+    _NAMES.append("XQuAD.{}".format(lang))
+for lang in _BUCC_LANG:
+    _NAMES.append("bucc18.{}".format(lang))
+for lang in _PAWSX_LANG:
+    _NAMES.append("PAWS-X.{}".format(lang))
+for lang in _TATOEBA_LANG:
+    _NAMES.append("tatoeba.{}".format(lang))
+for lang in _UD_POS_LANG:
+    _NAMES.append("udpos.{}".format(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": {"word": "", "pos_tag": ""},
+    "SQuAD": {"id": "id", "title": "title", "context": "context", "question": "question", "answers": "answers"},
+    "PAN-X": {"word": "", "ner_tag": "", "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/master/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": "",
+}
+
+_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/master/data/tatoeba/v1/README.md",
+    "udpos": "https://universaldependencies.org/",
+    "SQuAD": "https://rajpurkar.github.io/SQuAD-explorer/",
+    "PAN-X": "",
+}
+
+
+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
+    ]
+
+    @property
+    def manual_download_instructions(self):
+        if self.config.name.startswith("PAN-X"):
+            return """\
+             You need to manually download the AmazonPhotos.zip file on Amazon Cloud Drive
+             (https://www.amazon.com/clouddrive/share/d3KGCRCIYwhKJF0H3eWA26hjg2ZCRhjpEQtDL70FSBN). The folder containing the saved file
+             can be used to load the dataset via `datasets.load_dataset("xtreme", data_dir="<path/to/folder>").
+            """
+        return None
+
+    def _info(self):
+        # TODO(xtreme): Specifies the datasets.DatasetInfo object
+        features = {text_feature: datasets.Value("string") for text_feature in six.iterkeys(self.config.text_features)}
+        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["label"] = datasets.Value("string")
+        if self.config.name == "XNLI":
+            features["gold_label"] = datasets.Value("string")
+
+        if self.config.name.startswith("PAN-X"):
+            features = datasets.Features(
+                {
+                    "words": datasets.Sequence(datasets.Value("string")),
+                    "ner_tags": datasets.Sequence(datasets.Value("string")),
+                    "langs": datasets.Sequence(datasets.Value("string")),
+                }
+            )
+        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."""
+        # TODO(xtreme): Downloads the data and defines the splits
+        # dl_manager is a datasets.download.DownloadManager that can be used to
+        # download and extract URLs
+
+        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": os.path.join(self.config.data_url, train_url),
+                "dev": os.path.join(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"),
+                            "test-context-{}-question-{}.json".format(l1, l2),
+                        )
+                    },
+                ),
+                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"),
+                            "dev-context-{}-question-{}.json".format(l1, l2),
+                        )
+                    },
+                ),
+            ]
+
+        if self.config.name.startswith("XQuAD"):
+            lang = self.config.name.split(".")[1]
+            xquad_downloaded_file = dl_manager.download_and_extract(
+                os.path.join(self.config.data_url, "xquad.{}.json".format(lang))
+            )
+            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"):
+            lang = self.config.name.split(".")[1]
+            paws_x_dir = dl_manager.download_and_extract(self.config.data_url)
+            data_dir = os.path.join(paws_x_dir, "x-final", lang)
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.VALIDATION,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={"filepath": os.path.join(data_dir, "dev_2k.tsv")},
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.Split.TEST,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={"filepath": os.path.join(data_dir, "test_2k.tsv")},
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={
+                        "filepath": os.path.join(data_dir, "translated_train.tsv")
+                        if lang != "en"
+                        else os.path.join(data_dir, "train.tsv")
+                    },
+                ),
+            ]
+        elif self.config.name.startswith("tatoeba"):
+            lang = self.config.name.split(".")[1]
+
+            tatoeba_source_data = dl_manager.download_and_extract(
+                os.path.join(self.config.data_url, "tatoeba.{}-eng.{}".format(lang, lang))
+            )
+            tatoeba_eng_data = dl_manager.download_and_extract(
+                os.path.join(self.config.data_url, "tatoeba.{}-eng.eng".format(lang))
+            )
+            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_dir = dl_manager.download_and_extract(
+                os.path.join(self.config.data_url, "bucc2018-{}-en.training-gold.tar.bz2".format(lang))
+            )
+            bucc18_dl_dev_dir = dl_manager.download_and_extract(
+                os.path.join(self.config.data_url, "bucc2018-{}-en.sample-gold.tar.bz2".format(lang))
+            )
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.VALIDATION,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={"filepath": os.path.join(bucc18_dl_dev_dir, "bucc2018", lang + "-en")},
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.Split.TEST,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={"filepath": os.path.join(bucc18_dl_test_dir, "bucc2018", lang + "-en")},
+                ),
+            ]
+        if self.config.name.startswith("udpos"):
+            udpos_downloaded_files = dl_manager.download_and_extract(self.config.data_url)
+            data_dir = os.path.join(udpos_downloaded_files, "ud-treebanks-v2.5")
+
+            lang = self.config.name.split(".")[1]
+            data_dir = os.path.join(data_dir, "*_" + lang + "*")
+            folders = sorted(glob.glob(data_dir))
+
+            if lang == "Kazakh":
+                return [
+                    datasets.SplitGenerator(
+                        name=datasets.Split.TEST,
+                        # These kwargs will be passed to _generate_examples
+                        gen_kwargs={
+                            "filepath": [
+                                os.path.join(folder, file)
+                                for folder in folders
+                                for file in sorted(os.listdir(folder))
+                                if "test" in file and file.endswith(".conllu")
+                            ]
+                        },
+                    ),
+                    datasets.SplitGenerator(
+                        name=datasets.Split.TRAIN,
+                        # These kwargs will be passed to _generate_examples
+                        gen_kwargs={
+                            "filepath": [
+                                os.path.join(folder, file)
+                                for folder in folders
+                                for file in sorted(os.listdir(folder))
+                                if "train" in file and file.endswith(".conllu")
+                            ]
+                        },
+                    ),
+                ]
+            elif lang == "Tagalog" or lang == "Thai" or lang == "Yoruba":
+                return [
+                    datasets.SplitGenerator(
+                        name=datasets.Split.TEST,
+                        # These kwargs will be passed to _generate_examples
+                        gen_kwargs={
+                            "filepath": [
+                                os.path.join(folder, file)
+                                for folder in folders
+                                for file in sorted(os.listdir(folder))
+                                if "test" in file and file.endswith(".conllu")
+                            ]
+                        },
+                    )
+                ]
+            else:
+                return [
+                    datasets.SplitGenerator(
+                        name=datasets.Split.VALIDATION,
+                        # These kwargs will be passed to _generate_examples
+                        gen_kwargs={
+                            "filepath": [
+                                os.path.join(folder, file)
+                                for folder in folders
+                                for file in sorted(os.listdir(folder))
+                                if "NYUAD" not in folder and "dev" in file and file.endswith(".conllu")
+                            ]
+                            # we exclude Arabic NYUAD which deos not contains any word, only _
+                        },
+                    ),
+                    datasets.SplitGenerator(
+                        name=datasets.Split.TEST,
+                        # These kwargs will be passed to _generate_examples
+                        gen_kwargs={
+                            "filepath": [
+                                os.path.join(folder, file)
+                                for folder in folders
+                                for file in sorted(os.listdir(folder))
+                                if "NYUAD" not in folder and "test" in file and file.endswith(".conllu")
+                            ]
+                        },
+                    ),
+                    datasets.SplitGenerator(
+                        name=datasets.Split.TRAIN,
+                        # These kwargs will be passed to _generate_examples
+                        gen_kwargs={
+                            "filepath": [
+                                os.path.join(folder, file)
+                                for folder in folders
+                                for file in sorted(os.listdir(folder))
+                                if "NYUAD" not in folder and "train" in file and file.endswith(".conllu")
+                            ]
+                        },
+                    ),
+                ]
+
+        if self.config.name == "SQuAD":
+
+            urls_to_download = {
+                "train": os.path.join(self.config.data_url, "train-v1.1.json"),
+                "dev": os.path.join(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"):
+            path_to_manual_folder = os.path.abspath(os.path.expanduser(dl_manager.manual_dir))
+            panx_path = os.path.join(path_to_manual_folder, _PAN_X_FOLDER)
+            if not os.path.exists(panx_path):
+                raise FileNotFoundError(
+                    "{} does not exist. Make sure you insert a manual dir via `datasets.load_dataset('xtreme', data_dir=...)` that includes {}. Manual download instructions: {}".format(
+                        panx_path, _PAN_X_FOLDER, self.manual_download_instructions
+                    )
+                )
+
+            panx_dl_dir = dl_manager.extract(panx_path)
+            lang = self.config.name.split(".")[1]
+            lang_folder = dl_manager.extract(os.path.join(panx_dl_dir, "panx_dataset", lang + ".tar.gz"))
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.VALIDATION,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={
+                        "filepath": os.path.join(lang_folder, "dev")
+                        # we exclude Arabic NYUAD which deos not contains any word, only _
+                    },
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.Split.TEST,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={"filepath": os.path.join(lang_folder, "test")},
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={"filepath": os.path.join(lang_folder, "train")},
+                ),
+            ]
+
+    def _generate_examples(self, filepath):
+        """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"):
+            with open(filepath, encoding="utf-8") as f:
+                data = csv.reader(f, 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]}
+        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"):
+            files = sorted(os.listdir(filepath))
+            target_file = "/"
+            source_file = "/"
+            source_target_file = "/"
+            for file in files:
+                if file.endswith("en"):
+                    target_file = os.path.join(filepath, file)
+                elif file.endswith("gold"):
+                    source_target_file = os.path.join(filepath, file)
+                else:
+                    source_file = os.path.join(filepath, file)
+            with open(target_file, encoding="utf-8") as f:
+                data = csv.reader(f, delimiter="\t")
+                target_sentences = [row for row in data]
+            with open(source_file, encoding="utf-8") as f:
+                data = csv.reader(f, delimiter="\t")
+                source_sentences = [row for row in data]
+            with open(source_target_file, encoding="utf-8") as f:
+                data = csv.reader(f, delimiter="\t")
+                source_target_ids = [row for row in data]
+            for id_, pair in enumerate(source_target_ids):
+                source_id = pair[0]
+                target_id = pair[1]
+                source_sent = ""
+                target_sent = ""
+                for i in range(len(source_sentences)):
+                    if source_sentences[i][0] == source_id:
+                        source_sent = source_sentences[i][1]
+                        source_id = source_sentences[i][0]
+                        break
+                for j in range(len(target_sentences)):
+                    if target_sentences[j][0] == target_id:
+                        target_sent = target_sentences[j][1]
+                        target_id = target_sentences[j][0]
+                        break
+                yield id_, {
+                    "source_sentence": source_sent,
+                    "target_sentence": target_sent,
+                    "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"):
+            for id_file, file in enumerate(filepath):
+                with open(file, encoding="utf-8") as f:
+                    data = csv.reader(f, delimiter="\t", quoting=csv.QUOTE_NONE)
+                    for id_row, row in enumerate(data):
+                        if len(row) >= 10 and row[1] != "_":
+                            yield str(id_file) + "_" + str(id_row), {"word": row[1], "pos_tag": row[3]}
+        if self.config.name.startswith("PAN-X"):
+            guid_index = 1
+            with open(filepath, encoding="utf-8") as f:
+                words = []
+                ner_tags = []
+                langs = []
+                for line in f:
+                    if line.startswith("-DOCSTART-") or line == "" or line == "\n":
+                        if words:
+                            yield guid_index, {"words": words, "ner_tags": ner_tags, "langs": langs}
+                            guid_index += 1
+                            words = []
+                            ner_tags = []
+                            langs = []
+                    else:
+                        # pan-x data is tab separated
+                        splits = line.split("\t")
+                        # strip out en: prefix
+                        langs.append(splits[0][:2])
+                        words.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")