|
"""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 = [] |
|
|
