Upload xglue_mirror.py

xglue_mirror.py

@@ -0,0 +1,585 @@
+# coding=utf-8
+# Copyright 2020 The TensorFlow Datasets Authors and the HuggingFace Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Lint as: python3
+"""The General Language Understanding Evaluation (GLUE) benchmark."""
+
+
+import json
+import textwrap
+
+import datasets
+
+
+_XGLUE_CITATION = """\
+@article{Liang2020XGLUEAN,
+  title={XGLUE: A New Benchmark Dataset for Cross-lingual Pre-training, Understanding and Generation},
+  author={Yaobo Liang and Nan Duan and Yeyun Gong and Ning Wu and Fenfei Guo and Weizhen Qi
+  and Ming Gong and Linjun Shou and Daxin Jiang and Guihong Cao and Xiaodong Fan and Ruofei
+  Zhang and Rahul Agrawal and Edward Cui and Sining Wei and Taroon Bharti and Ying Qiao
+  and Jiun-Hung Chen and Winnie Wu and Shuguang Liu and Fan Yang and Daniel Campos
+  and Rangan Majumder and Ming Zhou},
+  journal={arXiv},
+  year={2020},
+  volume={abs/2004.01401}
+}
+"""
+
+_XGLUE_DESCRIPTION = """\
+XGLUE is a new benchmark dataset to evaluate the performance of cross-lingual pre-trained
+models with respect to cross-lingual natural language understanding and generation.
+The benchmark is composed of the following 11 tasks:
+- NER
+- POS Tagging (POS)
+- News Classification (NC)
+- MLQA
+- XNLI
+- PAWS-X
+- Query-Ad Matching (QADSM)
+- Web Page Ranking (WPR)
+- QA Matching (QAM)
+- Question Generation (QG)
+- News Title Generation (NTG)
+
+For more information, please take a look at https://microsoft.github.io/XGLUE/.
+"""
+
+_XGLUE_ALL_DATA = "https://1drv.ms/u/s!Amt8n9AJEyxchJtmUXkNFaTXLCbVOQ?e=2jYlMZ"
+
+_LANGUAGES = {
+    "ner": ["en", "de", "es", "nl"],
+    "pos": ["en", "de", "es", "nl", "bg", "el", "fr", "pl", "tr", "vi", "zh", "ur", "hi", "it", "ar", "ru", "th"],
+    "mlqa": ["en", "de", "ar", "es", "hi", "vi", "zh"],
+    "nc": ["en", "de", "es", "fr", "ru"],
+    "xnli": ["en", "ar", "bg", "de", "el", "es", "fr", "hi", "ru", "sw", "th", "tr", "ur", "vi", "zh"],
+    "paws-x": ["en", "de", "es", "fr"],
+    "qadsm": ["en", "de", "fr"],
+    "wpr": ["en", "de", "es", "fr", "it", "pt", "zh"],
+    "qam": ["en", "de", "fr"],
+    "qg": ["en", "de", "es", "fr", "it", "pt"],
+    "ntg": ["en", "de", "es", "fr", "ru"],
+}
+
+_PATHS = {
+    "mlqa": {
+        "train": "squad1.1/train-v1.1.json",
+        "dev": "MLQA_V1/dev/dev-context-{0}-question-{0}.json",
+        "test": "MLQA_V1/test/test-context-{0}-question-{0}.json",
+    },
+    "xnli": {"train": "multinli.train.en.tsv", "dev": "{}.dev", "test": "{}.test"},
+    "paws-x": {
+        "train": "en/train.tsv",
+        "dev": "{}/dev_2k.tsv",
+        "test": "{}/test_2k.tsv",
+    },
+}
+for name in ["ner", "pos"]:
+    _PATHS[name] = {"train": "en.train", "dev": "{}.dev", "test": "{}.test"}
+for name in ["nc", "qadsm", "wpr", "qam"]:
+    _PATHS[name] = {
+        "train": "xglue." + name + ".en.train",
+        "dev": "xglue." + name + ".{}.dev",
+        "test": "xglue." + name + ".{}.test",
+    }
+for name in ["qg", "ntg"]:
+    _PATHS[name] = {"train": "xglue." + name + ".en", "dev": "xglue." + name + ".{}", "test": "xglue." + name + ".{}"}
+
+
+class XGlueConfig(datasets.BuilderConfig):
+    """BuilderConfig for XGLUE."""
+
+    def __init__(
+        self,
+        data_dir,
+        citation,
+        url,
+        **kwargs,
+    ):
+        """BuilderConfig for XGLUE.
+
+        Args:
+          data_dir: `string`, the path to the folder containing the files in the
+            downloaded .tar
+          citation: `string`, citation for the data set
+          url: `string`, url for information about the data set
+          **kwargs: keyword arguments forwarded to super.
+        """
+        super(XGlueConfig, self).__init__(version=datasets.Version("1.0.0", ""), **kwargs)
+        self.data_dir = data_dir
+        self.citation = citation
+        self.url = url
+
+
+class XGlue(datasets.GeneratorBasedBuilder):
+    """The Cross-lingual Pre-training, Understanding and Generation (XGlue) Benchmark."""
+
+    BUILDER_CONFIGS = [
+        XGlueConfig(
+            name="ner",
+            description=textwrap.dedent(
+                """\
+            The shared task of CoNLL-2003 concerns language-independent named entity recognition.
+            We will concentrate on four types of named entities:
+            persons, locations, organizations and names of miscellaneous entities
+            that do not belong to the previous three groups.
+            """
+            ),
+            data_dir="NER",
+            citation=textwrap.dedent(
+                """\
+            @article{Sang2003IntroductionTT,
+              title={Introduction to the CoNLL-2003 Shared Task: Language-Independent Named Entity Recognition},
+              author={Erik F. Tjong Kim Sang and Fien De Meulder},
+              journal={ArXiv},
+              year={2003},
+              volume={cs.CL/0306050}
+            },
+            @article{Sang2002IntroductionTT,
+              title={Introduction to the CoNLL-2002 Shared Task: Language-Independent Named Entity Recognition},
+              author={Erik F. Tjong Kim Sang},
+              journal={ArXiv},
+              year={2002},
+              volume={cs.CL/0209010}
+            }"""
+            ),
+            url="https://www.clips.uantwerpen.be/conll2003/ner/",
+        ),
+        XGlueConfig(
+            name="pos",
+            description=textwrap.dedent(
+                """\
+            Universal Dependencies (UD) is a project that is developing cross-linguistically consistent treebank
+            annotation for many languages, with the goal of facilitating multilingual parser development, cross-lingual
+            learning, and parsing research from a language typology perspective. The annotation scheme is based on an
+            evolution of (universal) Stanford dependencies (de Marneffe et al., 2006, 2008, 2014), Google universal
+            part-of-speech tags (Petrov et al., 2012), and the Interset interlingua for morphosyntactic tagsets
+            (Zeman, 2008). The general philosophy is to provide a universal inventory of categories and guidelines
+            to facilitate consistent annotation of similar constructions across languages, while
+            allowing language-specific extensions when necessary.
+            """
+            ),
+            data_dir="POS",
+            citation=textwrap.dedent(
+                """\
+            @misc{11234/1-3105,
+              title={Universal Dependencies 2.5},
+              author={Zeman, Daniel and Nivre, Joakim and Abrams, Mitchell and Aepli, et al.},
+              url={http://hdl.handle.net/11234/1-3105},
+              note={{LINDAT}/{CLARIAH}-{CZ} digital library at the Institute of Formal and Applied Linguistics ({{\'U}FAL}), Faculty of Mathematics and Physics, Charles University},
+              copyright={Licence Universal Dependencies v2.5},
+              year={2019}
+            }"""
+            ),
+            url="https://universaldependencies.org/",
+        ),
+        XGlueConfig(
+            name="mlqa",
+            description=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.
+            """
+            ),
+            data_dir="MLQA",
+            citation=textwrap.dedent(
+                """\
+            @article{Lewis2019MLQAEC,
+              title={MLQA: Evaluating Cross-lingual Extractive Question Answering},
+              author={Patrick Lewis and Barlas Oguz and Ruty Rinott and Sebastian Riedel and Holger Schwenk},
+              journal={ArXiv},
+              year={2019},
+              volume={abs/1910.07475}
+            }"""
+            ),
+            url="https://github.com/facebookresearch/MLQA",
+        ),
+        XGlueConfig(
+            name="nc",
+            description=textwrap.dedent(
+                """\
+            This task aims to predict the category given a news article. It covers
+            5 languages, including English, Spanish, French,
+            German and Russian. Each labeled instance is a
+            3-tuple: <news title, news body, category>. The
+            category number is 10. We crawl this dataset from
+            a commercial news website. Accuracy (ACC) of
+            the multi-class classification is used as the metric.
+            """
+            ),
+            data_dir="NC",
+            citation="",
+            url="",
+        ),
+        XGlueConfig(
+            name="xnli",
+            description=textwrap.dedent(
+                """\
+            XNLI is a subset of a few thousand examples from MNLI which has been translated
+            into a 14 different languages (some low-ish resource). As with MNLI, the goal is
+            to predict textual entailment (does sentence A imply/contradict/neither sentence
+            B) and is a classification task (given two sentences, predict one of three
+            labels).
+            """
+            ),
+            data_dir="XNLI",
+            citation=textwrap.dedent(
+                """\
+            @inproceedings{Conneau2018XNLIEC,
+              title={XNLI: Evaluating Cross-lingual Sentence Representations},
+              author={Alexis Conneau and Guillaume Lample and Ruty Rinott and Adina Williams and Samuel R. Bowman and Holger Schwenk and Veselin Stoyanov},
+              booktitle={EMNLP},
+              year={2018}
+            }"""
+            ),
+            url="https://github.com/facebookresearch/XNLI",
+        ),
+        XGlueConfig(
+            name="paws-x",
+            description=textwrap.dedent(
+                """\
+            PAWS-X contains 23,659 human translated PAWS (Paraphrase Adversaries from Word Scrambling) 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.
+            """
+            ),
+            data_dir="PAWSX",
+            citation=textwrap.dedent(
+                """\
+            @article{Yang2019PAWSXAC,
+              title={PAWS-X: A Cross-lingual Adversarial Dataset for Paraphrase Identification},
+              author={Yinfei Yang and Yuan Zhang and Chris Tar and Jason Baldridge},
+              journal={ArXiv},
+              year={2019},
+              volume={abs/1908.11828}
+            }"""
+            ),
+            url="https://github.com/google-research-datasets/paws/tree/master/pawsx",
+        ),
+        XGlueConfig(
+            name="qadsm",
+            description=textwrap.dedent(
+                """\
+            Query-Ad Matching (QADSM) task aims
+            to predict whether an advertisement (ad) is relevant to an input query. It covers 3 languages, including English, French and German. Each labeled instance is a 4-tuple: <query, ad title, ad description, label>. The label indicates whether the
+            ad is relevant to the query (Good), or not (Bad).
+            This dataset was constructed based on a commercial search engine. Accuracy (ACC) of the binary classification should be used as the metric.
+            """
+            ),
+            data_dir="QADSM",
+            citation="",
+            url="",
+        ),
+        XGlueConfig(
+            name="wpr",
+            description=textwrap.dedent(
+                """\
+                Tthe Web Page Ranking (WPR) task aims to
+                predict whether a web page is relevant to an input query. It covers 7 languages, including English, German, French, Spanish, Italian, Portuguese and Chinese. Each labeled instance is a
+                4-tuple: <query, web page title, web page snippet, label>. The relevance label contains 5 ratings: Perfect (4), Excellent (3), Good (2), Fair (1)
+                and Bad (0). The dataset is constructed based on a
+                commercial search engine. Normalize Discounted
+                Cumulative Gain (nDCG) should be used as the metric.
+            """
+            ),
+            data_dir="WPR",
+            citation="",
+            url="",
+        ),
+        XGlueConfig(
+            name="qam",
+            description=textwrap.dedent(
+                """\
+                The QA Matching (QAM) task aims to predict whether a <question, passage> pair is a QA pair.
+                It covers 3 languages, including English, French
+                and German. Each labeled instance is a 3-tuple:
+                <question, passage, label>. The label indicates
+                whether the passage is the answer of the question
+                (1), or not (0). This dataset is constructed  based on
+                a commercial search engine. Accuracy (ACC) of
+                the binary classification should be used as the metric.
+            """
+            ),
+            data_dir="QAM",
+            citation="",
+            url="",
+        ),
+        XGlueConfig(
+            name="qg",
+            description=textwrap.dedent(
+                """\
+                The Question Generation (QG) task aims to
+generate a question for a given passage. <passage, question> pairs were collected from a commercial search engine. It covers 6 languages, including English, French, German, Spanish, Italian and
+Portuguese. BLEU-4 score should be used as the metric.
+            """
+            ),
+            data_dir="QG",
+            citation="",
+            url="",
+        ),
+        XGlueConfig(
+            name="ntg",
+            description=textwrap.dedent(
+                """\
+                News Title Generation (NTG) task aims
+                to generate a proper title for a given news body.
+                We collect <news body, news title> pairs from a
+                commercial news website. It covers 5 languages,
+                including German, English, French, Spanish and
+                Russian. BLEU-4 score should be used as the metric.
+            """
+            ),
+            data_dir="NTG",
+            citation="",
+            url="",
+        ),
+    ]
+
+    def _info(self):
+        if self.config.name == "ner":
+            features = {
+                "words": datasets.Sequence(datasets.Value("string")),
+                "ner": datasets.Sequence(
+                    datasets.features.ClassLabel(
+                        names=[
+                            "O",
+                            "B-PER",
+                            "I-PER",
+                            "B-ORG",
+                            "I-ORG",
+                            "B-LOC",
+                            "I-LOC",
+                            "B-MISC",
+                            "I-MISC",
+                        ]
+                    )
+                ),
+            }
+        elif self.config.name == "pos":
+            features = {
+                "words": datasets.Sequence(datasets.Value("string")),
+                "pos": datasets.Sequence(
+                    datasets.features.ClassLabel(
+                        names=[
+                            "ADJ",
+                            "ADP",
+                            "ADV",
+                            "AUX",
+                            "CCONJ",
+                            "DET",
+                            "INTJ",
+                            "NOUN",
+                            "NUM",
+                            "PART",
+                            "PRON",
+                            "PROPN",
+                            "PUNCT",
+                            "SCONJ",
+                            "SYM",
+                            "VERB",
+                            "X",
+                        ]
+                    )
+                ),
+            }
+        elif self.config.name == "mlqa":
+            features = {
+                "context": datasets.Value("string"),
+                "question": datasets.Value("string"),
+                "answers": datasets.features.Sequence(
+                    {"answer_start": datasets.Value("int32"), "text": datasets.Value("string")}
+                ),
+                # These are the features of your dataset like images, labels ...
+            }
+        elif self.config.name == "nc":
+            features = {
+                "news_title": datasets.Value("string"),
+                "news_body": datasets.Value("string"),
+                "news_category": datasets.ClassLabel(
+                    names=[
+                        "foodanddrink",
+                        "sports",
+                        "travel",
+                        "finance",
+                        "lifestyle",
+                        "news",
+                        "entertainment",
+                        "health",
+                        "video",
+                        "autos",
+                    ]
+                ),
+            }
+        elif self.config.name == "xnli":
+            features = {
+                "premise": datasets.Value("string"),
+                "hypothesis": datasets.Value("string"),
+                "label": datasets.features.ClassLabel(names=["entailment", "neutral", "contradiction"]),
+            }
+        elif self.config.name == "paws-x":
+            features = {
+                "sentence1": datasets.Value("string"),
+                "sentence2": datasets.Value("string"),
+                "label": datasets.features.ClassLabel(names=["different", "same"]),
+            }
+        elif self.config.name == "qadsm":
+            features = {
+                "query": datasets.Value("string"),
+                "ad_title": datasets.Value("string"),
+                "ad_description": datasets.Value("string"),
+                "relevance_label": datasets.features.ClassLabel(names=["Bad", "Good"]),
+            }
+        elif self.config.name == "wpr":
+            features = {
+                "query": datasets.Value("string"),
+                "web_page_title": datasets.Value("string"),
+                "web_page_snippet": datasets.Value("string"),
+                "relavance_label": datasets.features.ClassLabel(names=["Bad", "Fair", "Good", "Excellent", "Perfect"]),
+            }
+        elif self.config.name == "qam":
+            features = {
+                "question": datasets.Value("string"),
+                "answer": datasets.Value("string"),
+                "label": datasets.features.ClassLabel(names=["False", "True"]),
+            }
+        elif self.config.name == "qg":
+            features = {
+                "answer_passage": datasets.Value("string"),
+                "question": datasets.Value("string"),
+            }
+        elif self.config.name == "ntg":
+            features = {
+                "news_body": datasets.Value("string"),
+                "news_title": datasets.Value("string"),
+            }
+
+        return datasets.DatasetInfo(
+            description=_XGLUE_DESCRIPTION,
+            features=datasets.Features(features),
+            homepage=self.config.url,
+            citation=self.config.citation + "\n" + _XGLUE_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        archive = dl_manager.download(_XGLUE_ALL_DATA)
+        data_folder = f"xglue_full_dataset/{self.config.data_dir}"
+        name = self.config.name
+
+        languages = _LANGUAGES[name]
+        return (
+            [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs={
+                        "archive": dl_manager.iter_archive(archive),
+                        "data_path": f"{data_folder}/{_PATHS[name]['train']}",
+                        "split": "train",
+                    },
+                ),
+            ]
+            + [
+                datasets.SplitGenerator(
+                    name=datasets.Split(f"validation.{lang}"),
+                    gen_kwargs={
+                        "archive": dl_manager.iter_archive(archive),
+                        "data_path": f"{data_folder}/{_PATHS[name]['dev'].format(lang)}",
+                        "split": "dev",
+                    },
+                )
+                for lang in languages
+            ]
+            + [
+                datasets.SplitGenerator(
+                    name=datasets.Split(f"test.{lang}"),
+                    gen_kwargs={
+                        "archive": dl_manager.iter_archive(archive),
+                        "data_path": f"{data_folder}/{_PATHS[name]['test'].format(lang)}",
+                        "split": "test",
+                    },
+                )
+                for lang in languages
+            ]
+        )
+
+    def _generate_examples(self, archive, data_path, split=None):
+        keys = list(self._info().features.keys())
+        src_f = tgt_f = None
+        for path, file in archive:
+            if self.config.name == "mlqa":
+                if path == data_path:
+                    data = json.load(file)
+                    for examples in data["data"]:
+                        for example in examples["paragraphs"]:
+                            context = example["context"]
+                            for qa in example["qas"]:
+                                question = qa["question"]
+                                id_ = qa["id"]
+                                answers = qa["answers"]
+                                answers_start = [answer["answer_start"] for answer in answers]
+                                answers_text = [answer["text"] for answer in answers]
+                                yield id_, {
+                                    "context": context,
+                                    "question": question,
+                                    "answers": {"answer_start": answers_start, "text": answers_text},
+                                }
+            elif self.config.name in ["ner", "pos"]:
+                if path == data_path:
+                    words = []
+                    result = []
+                    idx = -1
+                    for line in file:
+                        line = line.decode("utf-8")
+                        if line.strip() == "":
+                            if len(words) > 0:
+                                out_dict = {keys[0]: words, keys[1]: result}
+                                words = []
+                                result = []
+                                idx += 1
+                                yield idx, out_dict
+                        else:
+                            splits = line.strip().split(" ")
+                            words.append(splits[0])
+                            result.append(splits[1])
+            elif self.config.name in ["ntg", "qg"]:
+                if path == data_path + ".src." + split:
+                    src_f = [line.decode("utf-8") for line in file]
+                elif path == data_path + ".tgt." + split:
+                    tgt_f = [line.decode("utf-8") for line in file]
+                if src_f and tgt_f:
+                    for idx, (src_line, tgt_line) in enumerate(zip(src_f, tgt_f)):
+                        yield idx, {keys[0]: src_line.strip(), keys[1]: tgt_line.strip()}
+            else:
+                _process_dict = {
+                    "paws-x": {"0": "different", "1": "same"},
+                    "xnli": {"contradictory": "contradiction"},
+                    "qam": {"0": "False", "1": "True"},
+                    "wpr": {"0": "Bad", "1": "Fair", "2": "Good", "3": "Excellent", "4": "Perfect"},
+                }
+
+                def _process(value):
+                    if self.config.name in _process_dict and value in _process_dict[self.config.name]:
+                        return _process_dict[self.config.name][value]
+                    return value
+
+                if path == data_path:
+                    for idx, line in enumerate(file):
+                        line = line.decode("utf-8")
+                        if data_path.split(".")[-1] == "tsv" and idx == 0:
+                            continue
+                        items = line.strip().split("\t")
+                        yield idx, {
+                            key: _process(value)
+                            for key, value in zip(keys, items[1:] if self.config.name == "paws-x" else items)
+                        }
+