feat

VieGLUE.py

@@ -0,0 +1,581 @@
+# 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 CC-News dataset is based on Common Crawl News Dataset by Sebastian Nagel"""
+
+import json
+import os
+from fnmatch import fnmatch
+import io
+import textwrap
+
+import datasets
+
+
+logger = datasets.logging.get_logger(__name__)
+
+######################
+#### DESCRIPTIONS ####
+######################
+_DESCRIPTION = """\
+"""
+
+###################
+#### CITATIONS ####
+###################
+_CITATION = """\
+"""
+
+
+#######################
+#### DOWNLOAD URLs ####
+#######################
+_DOWNLOAD_URL = {
+    "ax": {
+        "test": [os.path.join("data", "ax", "test.tar.gz")],
+    },
+    "cola": {
+        "train": [os.path.join("data", "cola", "train.tar.gz")],
+        "test": [os.path.join("data", "cola", "test.tar.gz")],
+        "validation": [os.path.join("data", "cola", "validation.tar.gz")],
+    },
+    "mnli": {
+        "train": [os.path.join("data", "mnli", "train.tar.gz")],
+        "test_matched": [os.path.join("data", "mnli", "test.tar.gz")],
+        "validation_matched": [
+            os.path.join("data", "mnli", "validation_matched.tar.gz")
+        ],
+        "test_mismatched": [os.path.join("data", "mnli", "test_mismatched.tar.gz")],
+        "validation_mismatched": [
+            os.path.join("data", "mnli", "validation_mismatched.tar.gz")
+        ],
+    },
+    "mrpc": {
+        "train": [os.path.join("data", "mrpc", "train.tar.gz")],
+        "test": [os.path.join("data", "mrpc", "test.tar.gz")],
+        "validation": [os.path.join("data", "mrpc", "validation.tar.gz")],
+    },
+    "qnli": {
+        "train": [os.path.join("data", "qnli", "train.tar.gz")],
+        "test": [os.path.join("data", "qnli", "test.tar.gz")],
+        "validation": [os.path.join("data", "qnli", "validation.tar.gz")],
+    },
+    "qqp": {
+        "train": [os.path.join("data", "qqp", "train.tar.gz")],
+        "test": [os.path.join("data", "qqp", "test.tar.gz")],
+        "validation": [os.path.join("data", "qqp", "validation.tar.gz")],
+    },
+    "rte": {
+        "train": [os.path.join("data", "rte", "train.tar.gz")],
+        "test": [os.path.join("data", "rte", "test.tar.gz")],
+        "validation": [os.path.join("data", "rte", "validation.tar.gz")],
+    },
+    "sst2": {
+        "train": [os.path.join("data", "sst2", "train.tar.gz")],
+        "test": [os.path.join("data", "sst2", "test.tar.gz")],
+        "validation": [os.path.join("data", "sst2", "validation.tar.gz")],
+    },
+    "stsb": {
+        "train": [os.path.join("data", "stsb", "train.tar.gz")],
+        "test": [os.path.join("data", "stsb", "test.tar.gz")],
+        "validation": [os.path.join("data", "stsb", "validation.tar.gz")],
+    },
+    "wnli": {
+        "train": [os.path.join("data", "wnli", "train.tar.gz")],
+        "test": [os.path.join("data", "wnli", "test.tar.gz")],
+        "validation": [os.path.join("data", "wnli", "validation.tar.gz")],
+    },
+}
+# VieGLUEConfig(
+#             name="cola",
+#             description=textwrap.dedent(
+#                 """\
+#             The Corpus of Linguistic Acceptability consists of English
+#             acceptability judgments drawn from books and journal articles on
+#             linguistic theory. Each example is a sequence of words annotated
+#             with whether it is a grammatical English sentence."""
+#             ),
+#             text_features={"sentence": "sentence"},
+#             label_classes=["unacceptable", "acceptable"],
+#             label_column="is_acceptable",
+#             data_url="https://dl.fbaipublicfiles.com/glue/data/CoLA.zip",
+#             data_dir="CoLA",
+#             citation=textwrap.dedent(
+#                 """\
+#             @article{warstadt2018neural,
+#                 title={Neural Network Acceptability Judgments},
+#                 author={Warstadt, Alex and Singh, Amanpreet and Bowman, Samuel R},
+#                 journal={arXiv preprint arXiv:1805.12471},
+#                 year={2018}
+#             }"""
+#             ),
+#             url="https://nyu-mll.github.io/CoLA/",
+#         ),
+#         VieGLUEConfig(
+#             name="mnli",
+#             description=textwrap.dedent(
+#                 """\
+#             The Multi-Genre Natural Language Inference Corpus is a crowdsourced
+#             collection of sentence pairs with textual entailment annotations. Given a premise sentence
+#             and a hypothesis sentence, the task is to predict whether the premise entails the hypothesis
+#             (entailment), contradicts the hypothesis (contradiction), or neither (neutral). The premise sentences are
+#             gathered from ten different sources, including transcribed speech, fiction, and government reports.
+#             We use the standard test set, for which we obtained private labels from the authors, and evaluate
+#             on both the matched (in-domain) and mismatched (cross-domain) section. We also use and recommend
+#             the SNLI corpus as 550k examples of auxiliary training data."""
+#             ),
+#             text_features={
+#                 "premise": "sentence1",
+#                 "hypothesis": "sentence2",
+#             },
+#             label_classes=["entailment", "neutral", "contradiction"],
+#             label_column="gold_label",
+#             data_url="https://dl.fbaipublicfiles.com/glue/data/MNLI.zip",
+#             data_dir="MNLI",
+#             citation=textwrap.dedent(
+#                 """\
+#         @InProceedings{N18-1101,
+#         author = "Williams, Adina
+#                 and Nangia, Nikita
+#                 and Bowman, Samuel",
+#         title = "A Broad-Coverage Challenge Corpus for
+#                 Sentence Understanding through Inference",
+#         booktitle = "Proceedings of the 2018 Conference of
+#                     the North American Chapter of the
+#                     Association for Computational Linguistics:
+#                     Human Language Technologies, Volume 1 (Long
+#                     Papers)",
+#         year = "2018",
+#         publisher = "Association for Computational Linguistics",
+#         pages = "1112--1122",
+#         location = "New Orleans, Louisiana",
+#         url = "http://aclweb.org/anthology/N18-1101"
+#         }
+#         @article{bowman2015large,
+#             title={A large annotated corpus for learning natural language inference},
+#             author={Bowman, Samuel R and Angeli, Gabor and Potts, Christopher and Manning, Christopher D},
+#             journal={arXiv preprint arXiv:1508.05326},
+#             year={2015}
+#         }"""
+#             ),
+#             url="http://www.nyu.edu/projects/bowman/multinli/",
+#         ),
+SUBSET_KWARGS = {
+    "ax": {
+        "name": "ax",
+        "text_features": ["premise", "hypothesis"],
+        "label_classes": ["entailment", "neutral", "contradiction"],
+        "label_column": "",
+        "citation": "",
+        "description": textwrap.dedent(
+            """\
+A manually-curated evaluation dataset for fine-grained analysis of
+system performance on a broad range of linguistic phenomena. This
+dataset evaluates sentence understanding through Natural Language
+Inference (NLI) problems. Use a model trained on MulitNLI to produce
+predictions for this dataset."""
+        ),
+    },
+    "cola": {
+        "name": "cola",
+        "text_features": ["sentence"],
+        "label_classes": ["unacceptable", "acceptable"],
+        "label_column": "is_acceptable",
+        "citation": textwrap.dedent(
+            """\
+            @article{warstadt2018neural,
+                title={Neural Network Acceptability Judgments},
+                author={Warstadt, Alex and Singh, Amanpreet and Bowman, Samuel R},
+                journal={arXiv preprint arXiv:1805.12471},
+                year={2018}
+            }"""
+        ),
+        "description": textwrap.dedent(
+            """\
+            The Corpus of Linguistic Acceptability consists of English
+            acceptability judgments drawn from books and journal articles on
+            linguistic theory. Each example is a sequence of words annotated
+            with whether it is a grammatical English sentence."""
+        ),
+    },
+    "mnli": {
+        "name": "mnli",
+        "text_features": ["premise", "hypothesis"],
+        "label_classes": ["entailment", "neutral", "contradiction"],
+        "label_column": "gold_label",
+        "citation": textwrap.dedent(
+            """\
+            @InProceedings{N18-1101,
+            author = "Williams, Adina
+                    and Nangia, Nikita
+                    and Bowman, Samuel",
+            title = "A Broad-Coverage Challenge Corpus for
+                    Sentence Understanding through Inference",
+            booktitle = "Proceedings of the 2018 Conference of
+                        the North American Chapter of the
+                        Association for Computational Linguistics:
+                        Human Language Technologies, Volume 1 (Long
+                        Papers)",
+            year = "2018",
+            publisher = "Association for Computational Linguistics",
+            pages = "1112--1122",
+            location = "New Orleans, Louisiana",
+            url = "http://aclweb.org/anthology/N18-1101"
+            }
+            @article{bowman2015large,
+                title={A large annotated corpus for learning natural language inference},
+                author={Bowman, Samuel R and Angeli, Gabor and Potts, Christopher and Manning, Christopher D},
+                journal={arXiv preprint arXiv:1508.05326},
+                year={2015}
+            }"""
+        ),
+        "description": textwrap.dedent(
+            """\
+            The Multi-Genre Natural Language Inference Corpus is a crowdsourced
+            collection of sentence pairs with textual entailment annotations. Given a premise sentence
+            and a hypothesis sentence, the task is to predict whether the premise entails the hypothesis
+            (entailment), contradicts the hypothesis (contradiction), or neither (neutral). The premise sentences are
+            gathered from ten different sources, including transcribed speech, fiction, and government reports.
+            We use the standard test set, for which we obtained private labels from the authors, and evaluate
+            on both the matched (in-domain) and mismatched (cross-domain) section. We also use and recommend
+            the SNLI corpus as 550k examples of auxiliary training data."""
+        ),
+    },
+    "mrpc": {
+        "name": "mrpc",
+        "text_features": ["sentence1", "sentence2"],
+        "label_classes": ["not_equivalent", "equivalent"],
+        "label_column": "Quality",
+        "citation": textwrap.dedent(
+            """\
+            @inproceedings{dolan2005automatically,
+                title={Automatically constructing a corpus of sentential paraphrases},
+                author={Dolan, William B and Brockett, Chris},
+                booktitle={Proceedings of the Third International Workshop on Paraphrasing (IWP2005)},
+                year={2005}
+            }"""
+        ),
+        "description": textwrap.dedent(
+            """\
+            The Microsoft Research Paraphrase Corpus (Dolan & Brockett, 2005) is a corpus of
+            sentence pairs automatically extracted from online news sources, with human annotations
+            for whether the sentences in the pair are semantically equivalent."""
+        ),  # pylint: disable=line-too-long
+    },
+    "qnli": {
+        "name": "qnli",
+        "text_features": ["question", "sentence"],
+        "label_classes": ["entailment", "not_entailment"],
+        "label_column": "label",
+        "citation": textwrap.dedent(
+            """\
+            @article{rajpurkar2016squad,
+                title={Squad: 100,000+ questions for machine comprehension of text},
+                author={Rajpurkar, Pranav and Zhang, Jian and Lopyrev, Konstantin and Liang, Percy},
+                journal={arXiv preprint arXiv:1606.05250},
+                year={2016}
+            }"""
+        ),
+        "description": textwrap.dedent(
+            """\
+            The Stanford Question Answering Dataset is a question-answering
+            dataset consisting of question-paragraph pairs, where one of the sentences in the paragraph (drawn
+            from Wikipedia) contains the answer to the corresponding question (written by an annotator). We
+            convert the task into sentence pair classification by forming a pair between each question and each
+            sentence in the corresponding context, and filtering out pairs with low lexical overlap between the
+            question and the context sentence. The task is to determine whether the context sentence contains
+            the answer to the question. This modified version of the original task removes the requirement that
+            the model select the exact answer, but also removes the simplifying assumptions that the answer
+            is always present in the input and that lexical overlap is a reliable cue."""
+        ),  # pylint: disable=line-too-long
+    },
+    "qqp": {
+        "name": "qqp",
+        "text_features": ["question1", "question2"],
+        "label_classes": ["not_duplicate", "duplicate"],
+        "label_column": "is_duplicate",
+        "citation": textwrap.dedent(
+            """\
+            @online{WinNT,
+                author = {Iyer, Shankar and Dandekar, Nikhil and Csernai, Kornel},
+                title = {First Quora Dataset Release: Question Pairs},
+                year = {2017},
+                url = {https://data.quora.com/First-Quora-Dataset-Release-Question-Pairs},
+                urldate = {2019-04-03}
+            }"""
+        ),
+        "description": textwrap.dedent(
+            """\
+            The Quora Question Pairs2 dataset is a collection of question pairs from the
+            community question-answering website Quora. The task is to determine whether a
+            pair of questions are semantically equivalent."""
+        ),
+    },
+    "rte": {
+        "name": "rte",
+        "text_features": ["sentence1", "sentence2"],
+        "label_classes": ["entailment", "not_entailment"],
+        "label_column": "label",
+        "citation": textwrap.dedent(
+            """\
+            @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}
+            }"""
+        ),
+        "description": textwrap.dedent(
+            """\
+            The Recognizing Textual Entailment (RTE) datasets come from a series of annual textual
+            entailment challenges. We combine the data from RTE1 (Dagan et al., 2006), RTE2 (Bar Haim
+            et al., 2006), RTE3 (Giampiccolo et al., 2007), and RTE5 (Bentivogli et al., 2009).4 Examples are
+            constructed based on news and Wikipedia text. We convert all datasets to a two-class split, where
+            for three-class datasets we collapse neutral and contradiction into not entailment, for consistency."""
+        ),  # pylint: disable=line-too-long
+    },
+    "sst2": {
+        "name": "sst2",
+        "text_features": ["sentence"],
+        "label_classes": ["negative", "positive"],
+        "label_column": "label",
+        "citation": textwrap.dedent(
+            """\
+            @inproceedings{socher2013recursive,
+                title={Recursive deep models for semantic compositionality over a sentiment treebank},
+                author={Socher, Richard and Perelygin, Alex and Wu, Jean and Chuang, Jason and Manning, Christopher D and Ng, Andrew and Potts, Christopher},
+                booktitle={Proceedings of the 2013 conference on empirical methods in natural language processing},
+                pages={1631--1642},
+                year={2013}
+            }"""
+        ),
+        "description": textwrap.dedent(
+            """\
+            The Stanford Sentiment Treebank consists of sentences from movie reviews and
+            human annotations of their sentiment. The task is to predict the sentiment of a
+            given sentence. We use the two-way (positive/negative) class split, and use only
+            sentence-level labels."""
+        ),
+    },
+    "stsb": {
+        "name": "stsb",
+        "text_features": ["sentence1", "sentence2"],
+        "label_classes": None,
+        "label_column": "score",
+        "citation": textwrap.dedent(
+            """\
+            @inproceedings{cer2017semeval,
+                title={Semeval-2017 task 1: Semantic textual similarity-multilingual and cross-lingual focused evaluation},
+                author={Cer, Daniel and Diab, Mona and Agirre, Eneko and Lopez-Gazpio, Inigo and Specia, Lucia},
+                booktitle={Proceedings of the 11th International Workshop on Semantic Evaluation (SemEval-2017)},
+                pages={1--14},
+                year={2017}
+            }"""
+        ),
+        "description": textwrap.dedent(
+            """\
+            The Semantic Textual Similarity Benchmark (Cer et al., 2017) is a collection of
+            sentence pairs drawn from news headlines, video and image captions, and natural language
+            inference data. Each pair is human-annotated with a similarity score from 1 to 5. We
+            convert this to a binary classification task by labeling examples with a similarity score
+            >= 4.5 as entailment and < 4.5 as not entailment."""
+        ),
+        "process_label": lambda x: float(x),
+    },
+    "wnli": {
+        "name": "wnli",
+        "text_features": ["sentence1", "sentence2"],
+        "label_classes": ["not_entailment", "entailment"],
+        "label_column": "label",
+        "citation": textwrap.dedent(
+            """\
+            @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}
+            }"""
+        ),
+        "description": textwrap.dedent(
+            """\
+            The Winograd Schema Challenge (Levesque et al., 2011) 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. The examples are manually constructed to foil simple statistical methods: Each
+            one is contingent on contextual information provided by a single word or phrase in the sentence.
+            To convert the problem into sentence pair classification, we construct sentence pairs by replacing
+            the ambiguous pronoun with each possible referent. The task is to predict if the sentence with the
+            pronoun substituted is entailed by the original sentence. We use a small evaluation set consisting of
+            new examples derived from fiction books that was shared privately by the authors of the original
+            corpus. While the included training set is balanced between two classes, the test set is imbalanced
+            between them (65% not entailment). Also, due to a data quirk, the development set is adversarial:
+            hypotheses are sometimes shared between training and development examples, so if a model memorizes the
+            training examples, they will predict the wrong label on corresponding development set
+            example. As with QNLI, each example is evaluated separately, so there is not a systematic correspondence
+            between a model's score on this task and its score on the unconverted original task. We
+            call converted dataset WNLI (Winograd NLI)."""
+        ),
+    },
+}
+
+
+_VERSION = datasets.Version("1.0.0", "")
+
+
+class VieGLUEConfig(datasets.BuilderConfig):
+    """BuilderConfig for GLUE."""
+
+    def __init__(
+        self,
+        text_features,
+        label_column="",
+        data_url="",
+        data_dir="",
+        citation="",
+        url="",
+        label_classes=None,
+        process_label=lambda x: x,
+        **kwargs,
+    ):
+        """BuilderConfig for VieGLUE.
+        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: `string`, name of the column in the tsv file corresponding
+                to the label
+            data_url: `string`, url to download the zip file from
+            data_dir: `string`, the path to the folder containing the tsv files in the
+                downloaded zip
+            citation: `string`, citation for the data set
+            url: `string`, url for information about the data set
+            label_classes: `list[string]`, the list of classes if the label is
+                categorical. If not provided, then the label will be of type
+                `datasets.Value('float32')`.
+            process_label: `Function[string, any]`, function  taking in the raw value
+                of the label and processing it to the form required by the label feature
+            **kwargs: keyword arguments forwarded to super.
+        """
+        super(VieGLUEConfig, self).__init__(
+            version=datasets.Version("1.0.0", ""), **kwargs
+        )
+        self.text_features = text_features
+        self.label_column = label_column
+        self.label_classes = label_classes
+        self.data_url = data_url
+        self.data_dir = data_dir
+        self.citation = citation
+        self.url = url
+        self.process_label = process_label
+
+
+class VNExpress(datasets.GeneratorBasedBuilder):
+    """"""
+
+    VERSION = _VERSION
+    DEFAULT_CONFIG_NAME = "mnli"
+
+    BUILDER_CONFIGS = [VieGLUEConfig(**config) for config in SUBSET_KWARGS.values()]
+
+    def _info(self):
+        features = {f: datasets.Value("string") for f in self.config.text_features}
+        if self.config.label_classes:
+            features["label"] = datasets.features.ClassLabel(
+                names=self.config.label_classes
+            )
+        else:
+            features["label"] = datasets.Value("float32")
+        features["idx"] = datasets.Value("int32")
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(features),
+            homepage=self.config.url,
+            citation=self.config.citation + "\n" + _CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        _SPLIT_MAPPING = {
+            "train": datasets.Split.TRAIN,
+            "training": datasets.Split.TRAIN,
+            "test": datasets.Split.TEST,
+            "testing": datasets.Split.TEST,
+            "val": datasets.Split.VALIDATION,
+            "validation": datasets.Split.VALIDATION,
+            "valid": datasets.Split.VALIDATION,
+            "dev": datasets.Split.VALIDATION,
+        }
+
+        name = self.config.name
+        download_url = _DOWNLOAD_URL[name]
+        filepath = dl_manager.download_and_extract(download_url)
+
+        return_datasets = []
+        for split in download_url:
+            return_datasets.append(
+                datasets.SplitGenerator(
+                    name=_SPLIT_MAPPING[split],
+                    gen_kwargs={
+                        "files": filepath[split],
+                        "urls": download_url[split],
+                        "stage": split,
+                        "config": self.config,
+                    },
+                )
+            )
+
+        return return_datasets
+
+    def _generate_examples(self, files, urls, stage):
+        # id_ = 0
+
+        if not isinstance(files, list):
+            files = [files]
+        for path, url in zip(files, urls):
+            print(f"Loading file from {url}...")
+            for file in os.listdir(path):
+                if file.startswith("._"):
+                    continue
+                file_path = os.path.join(path, file)
+                if not os.path.isfile(file_path):
+                    continue
+                with open(file_path) as f:
+                    all_samples = json.load(f)
+                    for sample in all_samples:
+                        yield sample

data/ax/test.tar.gz

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

data/cola/test.tar.gz

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

data/cola/train.tar.gz

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

data/cola/validation.tar.gz

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

data/mnli/test_matched.tar.gz

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

data/mnli/test_mismatched.tar.gz

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

data/mnli/train.tar.gz

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

data/mnli/validation_matched.tar.gz

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

data/mnli/validation_mismatched.tar.gz

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

data/mrpc/test.tar.gz

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

data/mrpc/train.tar.gz

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

data/mrpc/validation.tar.gz

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

data/qnli/test.tar.gz

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

data/qnli/train.tar.gz

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

data/qnli/validation.tar.gz

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

data/qqp/test.tar.gz

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

data/qqp/train.tar.gz

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

data/qqp/validation.tar.gz

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

data/rte/test.tar.gz

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

data/rte/train.tar.gz

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

data/rte/validation.tar.gz

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

data/sst2/test.tar.gz

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

data/sst2/train.tar.gz

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

data/sst2/validation.tar.gz

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

data/stsb/test.tar.gz

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

data/stsb/train.tar.gz

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

data/stsb/validation.tar.gz

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

data/wnli/test.tar.gz

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

data/wnli/train.tar.gz

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

data/wnli/validation.tar.gz

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