Update parquet files

.gitattributes

@@ -46,3 +46,5 @@ FewGLUE_32dev/multirc.zip filter=lfs diff=lfs merge=lfs -text
 FewGLUE_32dev/record.zip filter=lfs diff=lfs merge=lfs -text
 FewGLUE_32dev/rte.zip filter=lfs diff=lfs merge=lfs -text
 FewGLUE_32dev/wic.zip filter=lfs diff=lfs merge=lfs -text
+boolq/few_glue-test.parquet filter=lfs diff=lfs merge=lfs -text
+record/few_glue-test.parquet filter=lfs diff=lfs merge=lfs -text

FewGLUE_32dev/copa.zip

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

FewGLUE_32dev/multirc.zip

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

FewGLUE_32dev/record.zip

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

FewGLUE_32dev/rte.zip

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

FewGLUE_32dev/wic.zip

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

FewGLUE_32dev/wsc.zip

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

README.md

@@ -1,13 +0,0 @@
-# FewGLUE_32dev
-
-This repository contains the FewGLUE_32dev dataset, an extension of the [FewGLUE](https://github.com/timoschick/fewglue), which enables NLU few-shot learning tasks to be benchmarked under a new 32-sample-dev setting. It has been proved in [previous work](https://arxiv.org/abs/2012.15723) that using larger development sets confer a significant advantage beyond few-shot. FewGLUE_32dev is built by adding additional few-shot dev sets with 32 examples randomly selected from the original/unused SuperGLUE training sets.
-
-
-### Data Format
-
-The data files follow the exact same format as [SuperGLUE task files](https://super.gluebenchmark.com/tasks).
-
-
-### Structure
-
-For each SuperGLUE task `T`, the directory `FewGLUE_32dev/T` contains the 32-sample-dev file (`dev32.jsonl`), which consists of 32 examples for few-shot validation.

FewGLUE_32dev/boolq.zip → boolq/few_glue-test.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:db6e059e679ee7d9f2d2afe67b99f151012dec3bc6b3ab76e33a971106e58574
-size 859846
+oid sha256:83572ad236930c37170be7a5b5a9331c1e21f206721ab2d368332506e05173df
+size 1313730

few_glue.py

@@ -1,590 +0,0 @@
-# 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 FewGLUE benchmark."""
-
-
-import json
-import os
-
-import datasets
-
-
-_SUPER_GLUE_CITATION = """\
-@article{wang2019superglue,
-  title={SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems},
-  author={Wang, Alex and Pruksachatkun, Yada and Nangia, Nikita and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R},
-  journal={arXiv preprint arXiv:1905.00537},
-  year={2019}
-}
-Note that each SuperGLUE dataset has its own citation. Please see the source to
-get the correct citation for each contained dataset.
-"""
-
-_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 FewGlueConfig(datasets.BuilderConfig):
-    """BuilderConfig for SuperGLUE."""
-
-    def __init__(self, features, data_url, citation, url, label_classes=("False", "True"), **kwargs):
-        """BuilderConfig for SuperGLUE.
-        Args:
-          features: `list[string]`, list of the features that will appear in the
-            feature dict. Should not include "label".
-          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.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(FewGlueConfig, self).__init__(version=datasets.Version("1.0.2"), **kwargs)
-        self.features = features
-        self.label_classes = label_classes
-        self.citation = citation
-        self.data_url = data_url
-        self.url = url
-
-
-class FewGlue(datasets.GeneratorBasedBuilder):
-    """The FewGLUE benchmark."""
-
-    BUILDER_CONFIGS = [
-        FewGlueConfig(
-            name="boolq",
-            description=_BOOLQ_DESCRIPTION,
-            features=["question", "passage"],
-            data_url="https://huggingface.co/datasets/juny116/few_glue/resolve/main/FewGLUE_32dev/boolq.zip",
-            citation=_BOOLQ_CITATION,
-            url="https://github.com/google-research-datasets/boolean-questions",
-        ),
-        FewGlueConfig(
-            name="cb",
-            description=_CB_DESCRIPTION,
-            features=["premise", "hypothesis"],
-            label_classes=["entailment", "contradiction", "neutral"],
-            data_url="https://huggingface.co/datasets/juny116/few_glue/resolve/main/FewGLUE_32dev/cb.zip",
-            citation=_CB_CITATION,
-            url="https://github.com/mcdm/CommitmentBank",
-        ),
-        FewGlueConfig(
-            name="copa",
-            description=_COPA_DESCRIPTION,
-            label_classes=["choice1", "choice2"],
-            # Note that question will only be the X in the statement "What's
-            # the X for this?".
-            features=["premise", "choice1", "choice2", "question"],
-            data_url="https://huggingface.co/datasets/juny116/few_glue/resolve/main/FewGLUE_32dev/copa.zip",
-            citation=_COPA_CITATION,
-            url="http://people.ict.usc.edu/~gordon/copa.html",
-        ),
-        FewGlueConfig(
-            name="multirc",
-            description=_MULTIRC_DESCRIPTION,
-            features=["paragraph", "question", "answer"],
-            data_url="https://huggingface.co/datasets/juny116/few_glue/resolve/main/FewGLUE_32dev/multirc.zip",
-            citation=_MULTIRC_CITATION,
-            url="https://cogcomp.org/multirc/",
-        ),
-        FewGlueConfig(
-            name="record",
-            description=_RECORD_DESCRIPTION,
-            # Note that entities and answers will be a sequences of strings. Query
-            # will contain @placeholder as a substring, which represents the word
-            # to be substituted in.
-            features=["passage", "query", "entities", "answers"],
-            data_url="https://huggingface.co/datasets/juny116/few_glue/resolve/main/FewGLUE_32dev/record.zip",
-            citation=_RECORD_CITATION,
-            url="https://sheng-z.github.io/ReCoRD-explorer/",
-        ),
-        FewGlueConfig(
-            name="rte",
-            description=_RTE_DESCRIPTION,
-            features=["premise", "hypothesis"],
-            label_classes=["entailment", "not_entailment"],
-            data_url="https://huggingface.co/datasets/juny116/few_glue/resolve/main/FewGLUE_32dev/rte.zip",
-            citation=_RTE_CITATION,
-            url="https://aclweb.org/aclwiki/Recognizing_Textual_Entailment",
-        ),
-        FewGlueConfig(
-            name="wic",
-            description=_WIC_DESCRIPTION,
-            # Note that start1, start2, end1, and end2 will be integers stored as
-            # datasets.Value('int32').
-            features=["word", "sentence1", "sentence2", "start1", "start2", "end1", "end2"],
-            data_url="https://huggingface.co/datasets/juny116/few_glue/resolve/main/FewGLUE_32dev/wic.zip",
-            citation=_WIC_CITATION,
-            url="https://pilehvar.github.io/wic/",
-        ),
-        FewGlueConfig(
-            name="wsc",
-            description=_WSC_DESCRIPTION,
-            # Note that span1_index and span2_index will be integers stored as
-            # datasets.Value('int32').
-            features=["text", "span1_index", "span2_index", "span1_text", "span2_text"],
-            data_url="https://huggingface.co/datasets/juny116/few_glue/resolve/main/FewGLUE_32dev/wsc.zip",
-            citation=_WSC_CITATION,
-            url="https://cs.nyu.edu/faculty/davise/papers/WinogradSchemas/WS.html",
-        ),
-        FewGlueConfig(
-            name="wsc.fixed",
-            description=(
-                _WSC_DESCRIPTION + "\n\nThis version fixes issues where the spans are not actually "
-                "substrings of the text."
-            ),
-            # Note that span1_index and span2_index will be integers stored as
-            # datasets.Value('int32').
-            features=["text", "span1_index", "span2_index", "span1_text", "span2_text"],
-            data_url="https://huggingface.co/datasets/juny116/few_glue/resolve/main/FewGLUE_32dev/wsc.zip",
-            citation=_WSC_CITATION,
-            url="https://cs.nyu.edu/faculty/davise/papers/WinogradSchemas/WS.html",
-        ),
-    ]
-
-    def _info(self):
-        features = {feature: datasets.Value("string") for feature in self.config.features}
-        if self.config.name.startswith("wsc"):
-            features["span1_index"] = datasets.Value("int32")
-            features["span2_index"] = datasets.Value("int32")
-        if self.config.name == "wic":
-            features["start1"] = datasets.Value("int32")
-            features["start2"] = datasets.Value("int32")
-            features["end1"] = datasets.Value("int32")
-            features["end2"] = datasets.Value("int32")
-        if self.config.name == "multirc":
-            features["idx"] = dict(
-                {
-                    "paragraph": datasets.Value("int32"),
-                    "question": datasets.Value("int32"),
-                    "answer": datasets.Value("int32"),
-                }
-            )
-        elif self.config.name == "record":
-            features["idx"] = dict(
-                {
-                    "passage": datasets.Value("int32"),
-                    "query": datasets.Value("int32"),
-                }
-            )
-        else:
-            features["idx"] = datasets.Value("int32")
-
-        if self.config.name == "record":
-            # Entities are the set of possible choices for the placeholder.
-            features["entities"] = datasets.features.Sequence(datasets.Value("string"))
-            # Answers are the subset of entities that are correct.
-            features["answers"] = datasets.features.Sequence(datasets.Value("string"))
-        else:
-            features["label"] = datasets.features.ClassLabel(names=self.config.label_classes)
-
-        return datasets.DatasetInfo(
-            description=_GLUE_DESCRIPTION + self.config.description,
-            features=datasets.Features(features),
-            homepage=self.config.url,
-            citation=self.config.citation + "\n" + _SUPER_GLUE_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        dl_dir = dl_manager.download_and_extract(self.config.data_url) or ""
-        task_name = _get_task_name_from_data_url(self.config.data_url)
-        dl_dir = os.path.join(dl_dir, task_name)
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "data_file": os.path.join(dl_dir, "train.jsonl"),
-                    "split": datasets.Split.TRAIN,
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={
-                    "data_file": os.path.join(dl_dir, "dev32.jsonl"),
-                    "split": datasets.Split.VALIDATION,
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={
-                    "data_file": os.path.join(dl_dir, "val.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"]
-                    for qa in row["qas"]:
-                        yield qa["idx"], {
-                            "passage": passage["text"],
-                            "query": qa["query"],
-                            "entities": _get_record_entities(passage),
-                            "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"]
-    entities = set()
-    for entity in passage["entities"]:
-        entities.add(text[entity["start"] : entity["end"] + 1])
-    return sorted(entities)
-
-
-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)
-
-
-def _get_task_name_from_data_url(data_url):
-    return data_url.split("/")[-1].split(".")[0]

FewGLUE_32dev/cb.zip → record/few_glue-test.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:80f371d5328be1647dbb01dbde930304f83bd4580b6ccba3761ae322973e586a
-size 18734
+oid sha256:6e3e15e6a090e3df6b91bc388644af077178ec0a94bd193193b4bcbc827ef1a2
+size 6649377