Upload gdds.py

gdds.py

@@ -1,492 +1,8 @@
-import json
-import os
-
-import datasets
-
-
-_SUPER_GLUE_CITATION = """\
-"""
-
-_GLUE_DESCRIPTION = """\
-SuperGLUE (https://super.gluebenchmark.com/) is a new benchmark styled after
-GLUE with a new set of more difficult language understanding tasks, improved
-resources, and a new public leaderboard.
-"""
-
-_BOOLQ_DESCRIPTION = """\
-BoolQ (Boolean Questions, Clark et al., 2019a) is a QA task where each example consists of a short
-passage and a yes/no question about the passage. The questions are provided anonymously and
-unsolicited by users of the Google search engine, and afterwards paired with a paragraph from a
-Wikipedia article containing the answer. Following the original work, we evaluate with accuracy."""
-
-_CB_DESCRIPTION = """\
-The CommitmentBank (De Marneffe et al., 2019) is a corpus of short texts in which at least
-one sentence contains an embedded clause. Each of these embedded clauses is annotated with the
-degree to which we expect that the person who wrote the text is committed to the truth of the clause.
-The resulting task framed as three-class textual entailment on examples that are drawn from the Wall
-Street Journal, fiction from the British National Corpus, and Switchboard. Each example consists
-of a premise containing an embedded clause and the corresponding hypothesis is the extraction of
-that clause. We use a subset of the data that had inter-annotator agreement above 0.85. The data is
-imbalanced (relatively fewer neutral examples), so we evaluate using accuracy and F1, where for
-multi-class F1 we compute the unweighted average of the F1 per class."""
-
-_COPA_DESCRIPTION = """\
-The Choice Of Plausible Alternatives (COPA, Roemmele et al., 2011) dataset is a causal
-reasoning task in which a system is given a premise sentence and two possible alternatives. The
-system must choose the alternative which has the more plausible causal relationship with the premise.
-The method used for the construction of the alternatives ensures that the task requires causal reasoning
-to solve. Examples either deal with alternative possible causes or alternative possible effects of the
-premise sentence, accompanied by a simple question disambiguating between the two instance
-types for the model. All examples are handcrafted and focus on topics from online blogs and a
-photography-related encyclopedia. Following the recommendation of the authors, we evaluate using
-accuracy."""
-
-_RECORD_DESCRIPTION = """\
-(Reading Comprehension with Commonsense Reasoning Dataset, Zhang et al., 2018) is a
-multiple-choice QA task. Each example consists of a news article and a Cloze-style question about
-the article in which one entity is masked out. The system must predict the masked out entity from a
-given list of possible entities in the provided passage, where the same entity may be expressed using
-multiple different surface forms, all of which are considered correct. Articles are drawn from CNN
-and Daily Mail. Following the original work, we evaluate with max (over all mentions) token-level
-F1 and exact match (EM)."""
-
-_RTE_DESCRIPTION = """\
-The Recognizing Textual Entailment (RTE) datasets come from a series of annual competitions
-on textual entailment, the problem of predicting whether a given premise sentence entails a given
-hypothesis sentence (also known as natural language inference, NLI). RTE was previously included
-in GLUE, and we use the same data and format as before: We merge data from RTE1 (Dagan
-et al., 2006), RTE2 (Bar Haim et al., 2006), RTE3 (Giampiccolo et al., 2007), and RTE5 (Bentivogli
-et al., 2009). All datasets are combined and converted to two-class classification: entailment and
-not_entailment. Of all the GLUE tasks, RTE was among those that benefited from transfer learning
-the most, jumping from near random-chance performance (~56%) at the time of GLUE's launch to
-85% accuracy (Liu et al., 2019c) at the time of writing. Given the eight point gap with respect to
-human performance, however, the task is not yet solved by machines, and we expect the remaining
-gap to be difficult to close."""
-
-_MULTIRC_DESCRIPTION = """\
-The Multi-Sentence Reading Comprehension dataset (MultiRC, Khashabi et al., 2018)
-is a true/false question-answering task. Each example consists of a context paragraph, a question
-about that paragraph, and a list of possible answers to that question which must be labeled as true or
-false. Question-answering (QA) is a popular problem with many datasets. We use MultiRC because
-of a number of desirable properties: (i) each question can have multiple possible correct answers,
-so each question-answer pair must be evaluated independent of other pairs, (ii) the questions are
-designed such that answering each question requires drawing facts from multiple context sentences,
-and (iii) the question-answer pair format more closely matches the API of other SuperGLUE tasks
-than span-based extractive QA does. The paragraphs are drawn from seven domains including news,
-fiction, and historical text."""
-
-_WIC_DESCRIPTION = """\
-The Word-in-Context (WiC, Pilehvar and Camacho-Collados, 2019) dataset supports a word
-sense disambiguation task cast as binary classification over sentence pairs. Given two sentences and a
-polysemous (sense-ambiguous) word that appears in both sentences, the task is to determine whether
-the word is used with the same sense in both sentences. Sentences are drawn from WordNet (Miller,
-1995), VerbNet (Schuler, 2005), and Wiktionary. We follow the original work and evaluate using
-accuracy."""
-
-_WSC_DESCRIPTION = """\
-The Winograd Schema Challenge (WSC, Levesque et al., 2012) is a reading comprehension
-task in which a system must read a sentence with a pronoun and select the referent of that pronoun
-from a list of choices. Given the difficulty of this task and the headroom still left, we have included
-WSC in SuperGLUE and recast the dataset into its coreference form. The task is cast as a binary
-classification problem, as opposed to N-multiple choice, in order to isolate the model's ability to
-understand the coreference links within a sentence as opposed to various other strategies that may
-come into play in multiple choice conditions. With that in mind, we create a split with 65% negative
-majority class in the validation set, reflecting the distribution of the hidden test set, and 52% negative
-class in the training set. The training and validation examples are drawn from the original Winograd
-Schema dataset (Levesque et al., 2012), as well as those distributed by the affiliated organization
-Commonsense Reasoning. The test examples are derived from fiction books and have been shared
-with us by the authors of the original dataset. Previously, a version of WSC recast as NLI as included
-in GLUE, known as WNLI. No substantial progress was made on WNLI, with many submissions
-opting to submit only majority class predictions. WNLI was made especially difficult due to an
-adversarial train/dev split: Premise sentences that appeared in the training set sometimes appeared
-in the development set with a different hypothesis and a flipped label. If a system memorized the
-training set without meaningfully generalizing, which was easy due to the small size of the training
-set, it could perform far below chance on the development set. We remove this adversarial design
-in the SuperGLUE version of WSC by ensuring that no sentences are shared between the training,
-validation, and test sets.
-However, the validation and test sets come from different domains, with the validation set consisting
-of ambiguous examples such that changing one non-noun phrase word will change the coreference
-dependencies in the sentence. The test set consists only of more straightforward examples, with a
-high number of noun phrases (and thus more choices for the model), but low to no ambiguity."""
-
-_AXB_DESCRIPTION = """\
-An expert-constructed,
-diagnostic dataset that automatically tests models for a broad range of linguistic, commonsense, and
-world knowledge. Each example in this broad-coverage diagnostic is a sentence pair labeled with
-a three-way entailment relation (entailment, neutral, or contradiction) and tagged with labels that
-indicate the phenomena that characterize the relationship between the two sentences. Submissions
-to the GLUE leaderboard are required to include predictions from the submission's MultiNLI
-classifier on the diagnostic dataset, and analyses of the results were shown alongside the main
-leaderboard. Since this broad-coverage diagnostic task has proved difficult for top models, we retain
-it in SuperGLUE. However, since MultiNLI is not part of SuperGLUE, we collapse contradiction
-and neutral into a single not_entailment label, and request that submissions include predictions
-on the resulting set from the model used for the RTE task.
-"""
-
-_AXG_DESCRIPTION = """\
-Winogender is designed to measure gender
-bias in coreference resolution systems. We use the Diverse Natural Language Inference Collection
-(DNC; Poliak et al., 2018) version that casts Winogender as a textual entailment task. Each example
-consists of a premise sentence with a male or female pronoun and a hypothesis giving a possible
-antecedent of the pronoun. Examples occur in minimal pairs, where the only difference between
-an example and its pair is the gender of the pronoun in the premise. Performance on Winogender
-is measured with both accuracy and the gender parity score: the percentage of minimal pairs for
-which the predictions are the same. We note that a system can trivially obtain a perfect gender parity
-score by guessing the same class for all examples, so a high gender parity score is meaningless unless
-accompanied by high accuracy. As a diagnostic test of gender bias, we view the schemas as having high
-positive predictive value and low negative predictive value; that is, they may demonstrate the presence
-of gender bias in a system, but not prove its absence.
-"""
-
-_BOOLQ_CITATION = """\
-@inproceedings{clark2019boolq,
-  title={BoolQ: Exploring the Surprising Difficulty of Natural Yes/No Questions},
-  author={Clark, Christopher and Lee, Kenton and Chang, Ming-Wei, and Kwiatkowski, Tom and Collins, Michael, and Toutanova, Kristina},
-  booktitle={NAACL},
-  year={2019}
-}"""
-
-_CB_CITATION = """\
-@article{de marneff_simons_tonhauser_2019,
-  title={The CommitmentBank: Investigating projection in naturally occurring discourse},
-  journal={proceedings of Sinn und Bedeutung 23},
-  author={De Marneff, Marie-Catherine and Simons, Mandy and Tonhauser, Judith},
-  year={2019}
-}"""
-
-_COPA_CITATION = """\
-@inproceedings{roemmele2011choice,
-  title={Choice of plausible alternatives: An evaluation of commonsense causal reasoning},
-  author={Roemmele, Melissa and Bejan, Cosmin Adrian and Gordon, Andrew S},
-  booktitle={2011 AAAI Spring Symposium Series},
-  year={2011}
-}"""
-
-_RECORD_CITATION = """\
-@article{zhang2018record,
-  title={Record: Bridging the gap between human and machine commonsense reading comprehension},
-  author={Zhang, Sheng and Liu, Xiaodong and Liu, Jingjing and Gao, Jianfeng and Duh, Kevin and Van Durme, Benjamin},
-  journal={arXiv preprint arXiv:1810.12885},
-  year={2018}
-}"""
-
-_RTE_CITATION = """\
-@inproceedings{dagan2005pascal,
-  title={The PASCAL recognising textual entailment challenge},
-  author={Dagan, Ido and Glickman, Oren and Magnini, Bernardo},
-  booktitle={Machine Learning Challenges Workshop},
-  pages={177--190},
-  year={2005},
-  organization={Springer}
-}
-@inproceedings{bar2006second,
-  title={The second pascal recognising textual entailment challenge},
-  author={Bar-Haim, Roy and Dagan, Ido and Dolan, Bill and Ferro, Lisa and Giampiccolo, Danilo and Magnini, Bernardo and Szpektor, Idan},
-  booktitle={Proceedings of the second PASCAL challenges workshop on recognising textual entailment},
-  volume={6},
-  number={1},
-  pages={6--4},
-  year={2006},
-  organization={Venice}
-}
-@inproceedings{giampiccolo2007third,
-  title={The third pascal recognizing textual entailment challenge},
-  author={Giampiccolo, Danilo and Magnini, Bernardo and Dagan, Ido and Dolan, Bill},
-  booktitle={Proceedings of the ACL-PASCAL workshop on textual entailment and paraphrasing},
-  pages={1--9},
-  year={2007},
-  organization={Association for Computational Linguistics}
-}
-@inproceedings{bentivogli2009fifth,
-  title={The Fifth PASCAL Recognizing Textual Entailment Challenge.},
-  author={Bentivogli, Luisa and Clark, Peter and Dagan, Ido and Giampiccolo, Danilo},
-  booktitle={TAC},
-  year={2009}
-}"""
-
-_MULTIRC_CITATION = """\
-@inproceedings{MultiRC2018,
-    author = {Daniel Khashabi and Snigdha Chaturvedi and Michael Roth and Shyam Upadhyay and Dan Roth},
-    title = {Looking Beyond the Surface:A Challenge Set for Reading Comprehension over Multiple Sentences},
-    booktitle = {Proceedings of North American Chapter of the Association for Computational Linguistics (NAACL)},
-    year = {2018}
-}"""
-
-_WIC_CITATION = """\
-@article{DBLP:journals/corr/abs-1808-09121,
-  author={Mohammad Taher Pilehvar and os{\'{e}} Camacho{-}Collados},
-  title={WiC: 10, 000 Example Pairs for Evaluating Context-Sensitive Representations},
-  journal={CoRR},
-  volume={abs/1808.09121},
-  year={2018},
-  url={http://arxiv.org/abs/1808.09121},
-  archivePrefix={arXiv},
-  eprint={1808.09121},
-  timestamp={Mon, 03 Sep 2018 13:36:40 +0200},
-  biburl={https://dblp.org/rec/bib/journals/corr/abs-1808-09121},
-  bibsource={dblp computer science bibliography, https://dblp.org}
-}"""
-
-_WSC_CITATION = """\
-@inproceedings{levesque2012winograd,
-  title={The winograd schema challenge},
-  author={Levesque, Hector and Davis, Ernest and Morgenstern, Leora},
-  booktitle={Thirteenth International Conference on the Principles of Knowledge Representation and Reasoning},
-  year={2012}
-}"""
-
-_AXG_CITATION = """\
-@inproceedings{rudinger-EtAl:2018:N18,
-  author    = {Rudinger, Rachel  and  Naradowsky, Jason  and  Leonard, Brian  and  {Van Durme}, Benjamin},
-  title     = {Gender Bias in Coreference Resolution},
-  booktitle = {Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies},
-  month     = {June},
-  year      = {2018},
-  address   = {New Orleans, Louisiana},
-  publisher = {Association for Computational Linguistics}
-}
-"""
-
-
-class SuperGlueConfig(datasets.BuilderConfig):
-    """BuilderConfig for SuperGLUE."""
-
-    def __init__(self, **kwargs):
-        """BuilderConfig for SuperGLUE.
-        Args:
-          features: `list[string]`, list of the features that will appear in the
-            feature dict. Should not include "label".
-          data_url: `string`, url to download the zip file from.
-          citation: `string`, citation for the data set.
-          url: `string`, url for information about the data set.
-          label_classes: `list[string]`, the list of classes for the label if the
-            label is present as a string. Non-string labels will be cast to either
-            'False' or 'True'.
-          **kwargs: keyword arguments forwarded to super.
-        """
-        # Version history:
-        # 1.0.3: Fix not including entity position in ReCoRD.
-        # 1.0.2: Fixed non-nondeterminism in ReCoRD.
-        # 1.0.1: Change from the pre-release trial version of SuperGLUE (v1.9) to
-        #        the full release (v2.0).
-        # 1.0.0: S3 (new shuffling, sharding and slicing mechanism).
-        # 0.0.2: Initial version.
-        super(SuperGlueConfig, self).__init__(version=datasets.Version("1.0.3"), **kwargs)
-        self.features = datasets.Features({"text": datasets.Value("string"), "label":datasets.Value("int32")})
-        self.label_classes = [0, 1]
-
-
-class SuperGlue(datasets.GeneratorBasedBuilder):
-    """The SuperGLUE benchmark."""
-
-    BUILDER_CONFIGS = [
-        SuperGlueConfig(
-            name="fake_news",
-            description=_BOOLQ_DESCRIPTION,
-        ),
-        SuperGlueConfig(
-            name="job_scams",
-            description=_CB_DESCRIPTION,
-        ),
-        SuperGlueConfig(
-            name="phishing",
-            description=_COPA_DESCRIPTION,
-        ),
-        SuperGlueConfig(
-            name="political_statements",
-            description=_MULTIRC_DESCRIPTION,
-        ),
-        SuperGlueConfig(
-            name="product_reviews",
-            description=_RECORD_DESCRIPTION,
-        ),
-        SuperGlueConfig(
-            name="sms",
-            description=_RTE_DESCRIPTION,
-        ),
-        SuperGlueConfig(
-            name="twitter_rumours",
-            description=_WIC_DESCRIPTION,
-        ),
-    ]
-
-    def _info(self):
-        features = {feature: datasets.Value("string") for feature in self.config.features}
-        
-        features["label"] = datasets.features.ClassLabel(names=self.config.label_classes)
-
-        return datasets.DatasetInfo(
-            description=_GLUE_DESCRIPTION + self.config.description,
-            features=datasets.Features(features),
-        )
-
-    def _split_generators(self, dl_manager):
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "data_file": os.path.join(self.config.name, "train.jsonl"),
-                    "split": datasets.Split.TRAIN,
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={
-                    "data_file": os.path.join(self.config.name, "validation.jsonl"),
-                    "split": datasets.Split.VALIDATION,
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={
-                    "data_file": os.path.join(self.config.name, "test.jsonl"),
-                    "split": datasets.Split.TEST,
-                },
-            ),
-        ]
-
-    def _generate_examples(self, data_file, split):
-        with open(data_file, encoding="utf-8") as f:
-            for line in f:
-                row = json.loads(line)
-
-                if self.config.name == "multirc":
-                    paragraph = row["passage"]
-                    for question in paragraph["questions"]:
-                        for answer in question["answers"]:
-                            label = answer.get("label")
-                            key = "%s_%s_%s" % (row["idx"], question["idx"], answer["idx"])
-                            yield key, {
-                                "paragraph": paragraph["text"],
-                                "question": question["question"],
-                                "answer": answer["text"],
-                                "label": -1 if label is None else _cast_label(bool(label)),
-                                "idx": {"paragraph": row["idx"], "question": question["idx"], "answer": answer["idx"]},
-                            }
-                elif self.config.name == "record":
-                    passage = row["passage"]
-                    entity_texts, entity_spans = _get_record_entities(passage)
-                    for qa in row["qas"]:
-                        yield qa["idx"], {
-                            "passage": passage["text"],
-                            "query": qa["query"],
-                            "entities": entity_texts,
-                            "entity_spans": entity_spans,
-                            "answers": _get_record_answers(qa),
-                            "idx": {"passage": row["idx"], "query": qa["idx"]},
-                        }
-                else:
-                    if self.config.name.startswith("wsc"):
-                        row.update(row["target"])
-                    example = {feature: row[feature] for feature in self.config.features}
-                    if self.config.name == "wsc.fixed":
-                        example = _fix_wst(example)
-                    example["idx"] = row["idx"]
-
-                    if "label" in row:
-                        if self.config.name == "copa":
-                            example["label"] = "choice2" if row["label"] else "choice1"
-                        else:
-                            example["label"] = _cast_label(row["label"])
-                    else:
-                        assert split == datasets.Split.TEST, row
-                        example["label"] = -1
-                    yield example["idx"], example
-
-
-def _fix_wst(ex):
-    """Fixes most cases where spans are not actually substrings of text."""
-
-    def _fix_span_text(k):
-        """Fixes a single span."""
-        text = ex[k + "_text"]
-        index = ex[k + "_index"]
-
-        if text in ex["text"]:
-            return
-
-        if text in ("Kamenev and Zinoviev", "Kamenev, Zinoviev, and Stalin"):
-            # There is no way to correct these examples since the subjects have
-            # intervening text.
-            return
-
-        if "theyscold" in text:
-            ex["text"].replace("theyscold", "they scold")
-            ex["span2_index"] = 10
-        # Make sure case of the first words match.
-        first_word = ex["text"].split()[index]
-        if first_word[0].islower():
-            text = text[0].lower() + text[1:]
-        else:
-            text = text[0].upper() + text[1:]
-        # Remove punctuation in span.
-        text = text.rstrip(".")
-        # Replace incorrect whitespace character in span.
-        text = text.replace("\n", " ")
-        ex[k + "_text"] = text
-        assert ex[k + "_text"] in ex["text"], ex
-
-    _fix_span_text("span1")
-    _fix_span_text("span2")
-    return ex
-
-
-def _cast_label(label):
-    """Converts the label into the appropriate string version."""
-    if isinstance(label, str):
-        return label
-    elif isinstance(label, bool):
-        return "True" if label else "False"
-    elif isinstance(label, int):
-        assert label in (0, 1)
-        return str(label)
-    else:
-        raise ValueError("Invalid label format.")
-
-
-def _get_record_entities(passage):
-    """Returns the unique set of entities."""
-    text = passage["text"]
-    entity_spans = list()
-    for entity in passage["entities"]:
-        entity_text = text[entity["start"] : entity["end"] + 1]
-        entity_spans.append({"text": entity_text, "start": entity["start"], "end": entity["end"] + 1})
-    entity_spans = sorted(entity_spans, key=lambda e: e["start"])  # sort by start index
-    entity_texts = set(e["text"] for e in entity_spans)  # for backward compatability
-    return entity_texts, entity_spans
-
-
-def _get_record_answers(qa):
-    """Returns the unique set of answers."""
-    if "answers" not in qa:
-        return []
-    answers = set()
-    for answer in qa["answers"]:
-        answers.add(answer["text"])
-    return sorted(answers)
-
-
-# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
-#
-# 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.
-# TODO: Address all TODOs and remove all explanatory comments
-"""TODO: Add a description here."""
-
 
 import csv
 import json
 import os
-
+import sys
 import datasets
 
 
@@ -510,7 +26,7 @@ _LICENSE = ""
 
 
 # TODO: Name of the dataset usually matches the script name with CamelCase instead of snake_case
-class NewDataset(datasets.GeneratorBasedBuilder):
+class GDDS(datasets.GeneratorBasedBuilder):
     """TODO: Short description of my dataset."""
 
     VERSION = datasets.Version("2.1.0")
@@ -568,12 +84,13 @@ class NewDataset(datasets.GeneratorBasedBuilder):
         # dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLS
         # It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
         # By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
+        script_directory = os.path.dirname(os.path.abspath(sys.argv[0]))
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 # These kwargs will be passed to _generate_examples
                 gen_kwargs={
-                    "filepath": os.path.join(self.config.name, "train.jsonl"),
+                    "filepath": os.path.join(script_directory, self.config.name, "train.jsonl"),
                     "split": "train",
                 },
             ),
@@ -581,15 +98,15 @@ class NewDataset(datasets.GeneratorBasedBuilder):
                 name=datasets.Split.VALIDATION,
                 # These kwargs will be passed to _generate_examples
                 gen_kwargs={
-                    "filepath": os.path.join(self.config.name, "validate.jsonl"),
+                    "filepath": os.path.join(script_directory, self.config.name, "validate.jsonl"),
                     "split": "dev",
                 },
             ),
             datasets.SplitGenerator(
                 name=datasets.Split.TEST,
-                # These kwargs will be passed to _generate_examples
+                                # These kwargs will be passed to _generate_examples
                 gen_kwargs={
-                    "filepath": os.path.join(self.config.name, "test.jsonl"),
+                    "filepath": os.path.join(script_directory, self.config.name, "test.jsonl"),
                     "split": "test"
                 },
             ),