| """TODO(xtreme): Add a description here.""" |
|
|
|
|
| import csv |
| import json |
| import os |
| import textwrap |
|
|
| import datasets |
|
|
|
|
| |
| _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} |
| } |
| """ |
|
|
| |
| _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.""" |
|
|
| |
| 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( |
| |
| description=self.config.description + "\n" + _DESCRIPTION, |
| |
| features=datasets.Features( |
| features |
| |
| ), |
| |
| |
| |
| supervised_keys=None, |
| |
| 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, |
| |
| gen_kwargs={"filepath": dl_dir["train"]}, |
| ), |
| datasets.SplitGenerator( |
| name=datasets.Split.VALIDATION, |
| |
| 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, |
| |
| 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, |
| |
| 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, |
| |
| 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, |
| |
| 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.""" |
| |
|
|
| 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"]] |
|
|
| |
| |
| 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"]] |
|
|
| |
| |
| 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: |
| |
| splits = line.split("\t") |
| |
| langs.append(splits[0][:2]) |
| tokens.append(splits[0][3:]) |
| if len(splits) > 1: |
| ner_tags.append(splits[-1].replace("\n", "")) |
| else: |
| |
| 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) |
| 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"): |
| |
| 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 = [] |
|
|
